/*
  www.freedo.org
The first and only working 3DO multiplayer emulator.

The FreeDO licensed under modified GNU LGPL, with following notes:

*   The owners and original authors of the FreeDO have full right to develop closed source derivative work.
*   Any non-commercial uses of the FreeDO sources or any knowledge obtained by studying or reverse engineering
	of the sources, or any other material published by FreeDO have to be accompanied with full credits.
*   Any commercial uses of FreeDO sources or any knowledge obtained by studying or reverse engineering of the sources,
	or any other material published by FreeDO is strictly forbidden without owners approval.

The above notes are taking precedence over GNU LGPL in conflicting situations.

Project authors:

Alexander Troosh
Maxim Grishin
Allen Wright
John Sammons
Felix Lazarev
*/


#include "stdafx.h"
#include "freedoconfig.h"
#include "Madam.h"
#include "Clio.h"
#include "vdlp.h"
#include "arm.h"
#include <math.h>
#include <memory.h>

#include "bitop.h"
BitReaderBig bitoper;

#include "freedocore.h"

extern _ext_Interface  io_interface;



/* === CCB control word flags === */
#define CCB_SKIP        0x80000000
#define CCB_LAST        0x40000000
#define CCB_NPABS       0x20000000
#define CCB_SPABS       0x10000000
#define CCB_PPABS       0x08000000
#define CCB_LDSIZE      0x04000000
#define CCB_LDPRS       0x02000000
#define CCB_LDPPMP      0x01000000
#define CCB_LDPLUT      0x00800000
#define CCB_CCBPRE      0x00400000
#define CCB_YOXY        0x00200000
#define CCB_ACSC        0x00100000
#define CCB_ALSC        0x00080000
#define CCB_ACW         0x00040000
#define CCB_ACCW        0x00020000
#define CCB_TWD         0x00010000
#define CCB_LCE         0x00008000
#define CCB_ACE         0x00004000
#define CCB_reserved13  0x00002000
#define CCB_MARIA       0x00001000
#define CCB_PXOR        0x00000800
#define CCB_USEAV       0x00000400
#define CCB_PACKED      0x00000200
#define CCB_POVER_MASK  0x00000180
#define CCB_PLUTPOS     0x00000040
#define CCB_BGND        0x00000020
#define CCB_NOBLK       0x00000010
#define CCB_PLUTA_MASK  0x0000000F

#define CCB_POVER_SHIFT  7
#define CCB_PLUTA_SHIFT  0

#define PMODE_PDC   ((0x00000000)<<CCB_POVER_SHIFT) /* Normal */
#define PMODE_ZERO  ((0x00000002)<<CCB_POVER_SHIFT)
#define PMODE_ONE   ((0x00000003)<<CCB_POVER_SHIFT)

//  === CCBCTL0 flags ===   
#define B15POS_MASK   0xC0000000
#define B0POS_MASK    0x30000000
#define SWAPHV        0x08000000
#define ASCALL        0x04000000
#define _CCBCTL0_u25  0x02000000
#define CFBDSUB       0x01000000
#define CFBDLSB_MASK  0x00C00000
#define PDCLSB_MASK   0x00300000

#define B15POS_SHIFT  30
#define B0POS_SHIFT   28
#define CFBD_SHIFT    22
#define PDCLSB_SHIFT  20

//  B15POS_MASK definitions   
#define B15POS_0    0x00000000
#define B15POS_1    0x40000000
#define B15POS_PDC  0xC0000000

//  B0POS_MASK definitions   
#define B0POS_0     0x00000000
#define B0POS_1     0x10000000
#define B0POS_PPMP  0x20000000
#define B0POS_PDC   0x30000000

/*
//  CFBDLSB_MASK definitions   
#define CFBDLSB_0      0x00000000
#define CFBDLSB_CFBD0  0x00400000
#define CFBDLSB_CFBD4  0x00800000
#define CFBDLSB_CFBD5  0x00C00000

//  PDCLSB_MASK definitions   
#define PDCLSB_0     0x00000000
#define PDCLSB_PDC0  0x00100000
#define PDCLSB_PDC4  0x00200000
#define PDCLSB_PDC5  0x00300000
*/

/* === Cel first preamble word flags === */
#define PRE0_LITERAL    0x80000000
#define PRE0_BGND       0x40000000
#define PREO_reservedA  0x30000000
#define PRE0_SKIPX_MASK 0x0F000000
#define PREO_reservedB  0x00FF0000
#define PRE0_VCNT_MASK  0x0000FFC0
#define PREO_reservedC  0x00000020
#define PRE0_LINEAR     0x00000010
#define PRE0_REP8       0x00000008
#define PRE0_BPP_MASK   0x00000007

#define PRE0_SKIPX_SHIFT 24
#define PRE0_VCNT_SHIFT  6
#define PRE0_BPP_SHIFT   0

/* PRE0_BPP_MASK definitions */
#define PRE0_BPP_1   0x00000001
#define PRE0_BPP_2   0x00000002
#define PRE0_BPP_4   0x00000003
#define PRE0_BPP_6   0x00000004
#define PRE0_BPP_8   0x00000005
#define PRE0_BPP_16  0x00000006

/* Subtract this value from the actual vertical source line count */
#define PRE0_VCNT_PREFETCH    1


/* === Cel second preamble word flags === */
#define PRE1_WOFFSET8_MASK   0xFF000000
#define PRE1_WOFFSET10_MASK  0x03FF0000
#define PRE1_NOSWAP          0x00004000
#define PRE1_TLLSB_MASK      0x00003000
#define PRE1_LRFORM          0x00000800
#define PRE1_TLHPCNT_MASK    0x000007FF

#define PRE1_WOFFSET8_SHIFT   24
#define PRE1_WOFFSET10_SHIFT  16
#define PRE1_TLLSB_SHIFT      12
#define PRE1_TLHPCNT_SHIFT    0

#define PRE1_TLLSB_0     0x00000000
#define PRE1_TLLSB_PDC0  0x00001000 /* Normal */
#define PRE1_TLLSB_PDC4  0x00002000
#define PRE1_TLLSB_PDC5  0x00003000

/* Subtract this value from the actual word offset */
#define PRE1_WOFFSET_PREFETCH 2
/* Subtract this value from the actual pixel count */
#define PRE1_TLHPCNT_PREFETCH 1

#define PPMP_0_SHIFT 0
#define PPMP_1_SHIFT 16

#define PPMPC_1S_MASK  0x00008000
#define PPMPC_MS_MASK  0x00006000
#define PPMPC_MF_MASK  0x00001C00
#define PPMPC_SF_MASK  0x00000300
#define PPMPC_2S_MASK  0x000000C0
#define PPMPC_AV_MASK  0x0000003E
#define PPMPC_2D_MASK  0x00000001

#define PPMPC_MS_SHIFT  13
#define PPMPC_MF_SHIFT  10
#define PPMPC_SF_SHIFT  8
#define PPMPC_2S_SHIFT  6
#define PPMPC_AV_SHIFT  1

/* PPMPC_1S_MASK definitions */
#define PPMPC_1S_PDC   0x00000000
#define PPMPC_1S_CFBD  0x00008000

/* PPMPC_MS_MASK definitions */
#define PPMPC_MS_CCB         0x00000000
#define PPMPC_MS_PIN         0x00002000
#define PPMPC_MS_PDC_MFONLY  0x00004000
#define PPMPC_MS_PDC         0x00004000

/* PPMPC_MF_MASK definitions */
#define PPMPC_MF_1  0x00000000
#define PPMPC_MF_2  0x00000400
#define PPMPC_MF_3  0x00000800
#define PPMPC_MF_4  0x00000C00
#define PPMPC_MF_5  0x00001000
#define PPMPC_MF_6  0x00001400
#define PPMPC_MF_7  0x00001800
#define PPMPC_MF_8  0x00001C00

/* PPMPC_SF_MASK definitions */
#define PPMPC_SF_2   0x00000100
#define PPMPC_SF_4   0x00000200
#define PPMPC_SF_8   0x00000300
#define PPMPC_SF_16  0x00000000

/* PPMPC_2S_MASK definitions */
#define PPMPC_2S_0     0x00000000
#define PPMPC_2S_CCB   0x00000040
#define PPMPC_2S_CFBD  0x00000080
#define PPMPC_2S_PDC   0x000000C0

/* PPMPC_2D_MASK definitions */
#define PPMPC_2D_1  0x00000000
#define PPMPC_2D_2  0x00000001


#pragma pack(push,1)

struct cp1btag{
	unsigned short	c:1;
	unsigned short	pad:15;
};
struct cp2btag{
	unsigned short	c:2;
	unsigned short	pad:14;
};
typedef struct cp4btag{
	unsigned short	c:4;
	unsigned short	pad:12;
} cp4b;
struct cp6btag{
	unsigned short  c:5;
	unsigned short  pw:1;
	unsigned short	pad:10;
};
struct cp8btag{
	unsigned short	c:5;
	unsigned short	mpw:1;
	unsigned short	m:2;
	unsigned short	pad:8;
};
struct cp16btag{
	unsigned short	c:5;
	unsigned short	mb:3;
	unsigned short	mg:3;
	unsigned short	mr:3;
	unsigned short	pad:1;
	unsigned short	pw:1;
};
struct up8btag{
	unsigned short	b:2;
	unsigned short	g:3;
	unsigned short	r:3;
	unsigned short	pad:8;
};
struct up16btag{
	unsigned short	bw:1;
	unsigned short	b:4;
	unsigned short	g:5;
	unsigned short	r:5;
	unsigned short	p:1;
};
struct res16btag{
	unsigned short	b:5;
	unsigned short	g:5;
	unsigned short	r:5;
	unsigned short	p:1;
};
union pdeco{
	unsigned int	raw;
	cp1btag	c1b;
	cp2btag	c2b;
	cp4btag	c4b;
	cp6btag	c6b;
	cp8btag	c8b;
	cp16btag	c16b;
	up8btag	u8b;
	up16btag	u16b;
	res16btag	r16b;
};

struct avtag
{
	unsigned char NEG:1;
	unsigned char XTEND:1;
	unsigned char nCLIP:1;
	unsigned char dv3:2;
	unsigned char pad:3;
};
union AVS{
	avtag avsignal;
	unsigned int raw;
};
struct pixctag
{
	unsigned char	dv2:1;
	unsigned char	av:5;  // why int don't work???
	unsigned char	s2:2;
	unsigned char	dv1:2;
	unsigned char	mxf:3;
	unsigned char	ms:2;
	unsigned char	s1:1;
};

union	PXC
{
	pixctag	meaning;
	unsigned int raw;
};

#pragma pack(pop)


//*******************************************
#pragma pack(push,1)
struct MADAMDatum
{
 unsigned int mregs[2048+64];
 unsigned short PLUT[32];
 unsigned char PBUSQueue[20];
 int RMOD;
 int WMOD;
 unsigned int _madam_FSM;
};
#pragma pack(pop)
static MADAMDatum madam;

unsigned int Get_madam_FSM(){return madam._madam_FSM;};
void Set_madam_FSM(unsigned int val){madam._madam_FSM=val;};

unsigned int _madam_SaveSize()
{
		return sizeof(MADAMDatum);
}
void _madam_Save(void *buff)
{
		memcpy(buff,&madam,sizeof(MADAMDatum));
}
void _madam_Load(void *buff)
{
		memcpy(&madam,buff,sizeof(MADAMDatum));
}

#define mregs madam.mregs
#define PLUT madam.PLUT
#define PBUSQueue madam.PBUSQueue
#define RMOD madam.RMOD
#define WMOD madam.WMOD
#define _madam_FSM madam._madam_FSM
//*******************************************



 unsigned int PXOR1, PXOR2;


#define PDV(x) ((((x)-1)&3)+1)


#define MIN(x,y) (x)+(((signed int)((y)-(x))>>31&((y)-(x))))
#define MAX(x,y) (y)-(((signed int)((y)-(x))>>31&((y)-(x))))

#define TESTCLIP(cx,cy) ( ((int)cx>=0)&&((int)cx<=((CLIPXVAL)<<16))&&((int)cy>=0)&&((int)cy<=((CLIPYVAL)<<16)))

#define FLT(a) ((float)(int)(a)/65536.0)
#define  XY2OFF(a,b,c)   (  (((int)b>>1)*c/*bitmap width*/)   + (((int)(b)&1)<<1) +    (a)    )


#define PBMASK 0x80000000
#define KUP    0x08000000
#define KDN    0x10000000
#define KRI    0x04000000
#define KLE    0x02000000
#define KA     0x01000000
#define KB     0x00800000
#define KC     0x00400000
#define KP     0x00200000
#define KX     0x00100000
#define KRS    0x00080000
#define KLS    0x00040000
#define FIXP16_SHIFT     16
#define FIXP16_MAG       65536
#define FIXP16_DP_MASK   0x0000ffff
#define FIXP16_WP_MASK   0xffff0000
#define FIXP16_ROUND_UP  0x0000ffff //0x8000



// TYPES ///////////////////////////////////////////////////////////////////


// CLASSES /////////////////////////////////////////////////////////////////
unsigned int __fastcall mread(unsigned int addr);
void __fastcall mwrite(unsigned int addr, unsigned int val);
int TestInitVisual(int packed);
int Init_Line_Map();
void Init_Scale_Map();
void Init_Arbitrary_Map();
int __fastcall TexelDraw_Line(unsigned short CURPIX, unsigned short LAMV, int xcur, int ycur, int cnt);
int __fastcall TexelDraw_Scale(unsigned short CURPIX, unsigned short LAMV, int xcur, int ycur, int deltax, int deltay);
int __fastcall TexelDraw_Arbitrary(unsigned short CURPIX, unsigned short LAMV, int xA, int yA, int xB, int yB, int xC, int yC, int xD, int yD);
void __fastcall DrawPackedCel_New();
void __fastcall DrawLiteralCel_New();
void __fastcall DrawLRCel_New();
void HandleDMA8();
void DMAPBus();


unsigned int MAPPING;

// general 3D vertex class

#define INT1220(a)	 ((signed int)(a)>>20)
#define INT1220up(a) ((signed int)((a)+(1<<19))>>20)





static struct
{
	unsigned int plutaCCBbits;
	unsigned int pixelBitsMask;
	bool tmask;
} pdec;

static struct
{
	unsigned int pmode;
	unsigned int pmodeORmask;
	unsigned int pmodeANDmask;
	bool Transparent;
} pproj;

 unsigned int pbus=0;
 unsigned char * Mem;
 unsigned int retuval;
 unsigned int BITADDR;
 //static unsigned int * BITPTR;
 //static unsigned int * BITEND;
 unsigned int BITBUFLEN;
 unsigned int BITBUF;
 unsigned int CCBFLAGS,/*PLUTDATA*/PIXC,PRE0,PRE1,TARGETPROJ,SRCDATA,debug;
 int SPRWI,SPRHI;
	unsigned int PLUTF,PDATF,NCCBF;
 int CELCYCLES,__smallcicles;
 bool ADD;
 //static SDL_Event cpuevent;
 int BITCALC;


 unsigned short bitbuf; //bit buffer
 unsigned char  subbitbuf;// bit sub buffer
 int    bitcount; // bit counter
 long   compsize; // size of commpressed!!! in bytes!!! actually pixcount*bpp/8!!!
 unsigned int gFINISH;
 unsigned short RRR;
 int USECEL;

 unsigned int	const BPP[8]={1,1,2,4,6,8,16,1};

 unsigned char PSCALAR[8][4][32];

 unsigned short MAPu8b[256+64], MAPc8bAMV[256+64], MAPc16bAMV[8*8*8+64];


 int currentrow;
 unsigned int bpp;
 int pixcount;
 unsigned int type;
 unsigned int offsetl;
 unsigned int offset;
 //static unsigned int begining;
 unsigned int eor;
  int calcx;
  int nrows;

 unsigned int pix;

 unsigned short ttt;

 unsigned int OFF;

 unsigned int pSource;

//AString str;

//CelEngine STATBits
#define STATBITS	mregs[0x28]

#define SPRON		0x10
#define SPRPAU		0x20

//CelEngine Registers
#define SPRSTRT		0x100
#define SPRSTOP		0x104
#define SPRCNTU		0x108
#define SPRPAUS		0x10c

#define CCBCTL0		mregs[0x110]
#define REGCTL0		mregs[0x130]
#define REGCTL1		mregs[0x134]
#define REGCTL2		mregs[0x138]
#define REGCTL3		mregs[0x13c]

#define CLIPXVAL	((int)mregs[0x134]&0x3ff)
#define CLIPYVAL	((int)(mregs[0x134]>>16)&0x3ff)

#define PIXSOURCE	(mregs[0x138])
#define FBTARGET	(mregs[0x13c])

#define CURRENTCCB	mregs[0x5a0]
//next ccb == 0 stop the engine
#define NEXTCCB		mregs[0x5a4]
#define PLUTDATA	mregs[0x5a8]
#define PDATA		mregs[0x5ac]
#define ENGAFETCH	mregs[0x5b0]
#define ENGALEN		mregs[0x5b4]
#define	ENGBFETCH	mregs[0x5b8]
#define ENGBLEN		mregs[0x5bc]
#define PAL_EXP		(&mregs[0x5d0])
#define CHAR_BIT  (8)



int FLOAT1612(int a)
{
	return a<<4;
}

//////////////////////////////////////////////////////////////////////
// Quick divide helper
//////////////////////////////////////////////////////////////////////

const int QUICK_DIVIDE_CACHE_SIZE = 512;
static int QUICK_DIVIDE_UBOUND = 0;
static int QUICK_DIVIDE_LBOUND = 0;

static short quickDivide_lookups[QUICK_DIVIDE_CACHE_SIZE][QUICK_DIVIDE_CACHE_SIZE];

void quickDivide_init()
{
	QUICK_DIVIDE_UBOUND	= (QUICK_DIVIDE_CACHE_SIZE / 2) - 1;
	QUICK_DIVIDE_LBOUND	= -(QUICK_DIVIDE_CACHE_SIZE / 2);
	for (int a = QUICK_DIVIDE_LBOUND; a <= QUICK_DIVIDE_UBOUND; a++)
	{
		for (int b = QUICK_DIVIDE_LBOUND; b <= QUICK_DIVIDE_UBOUND; b++)
		{
			if (b == 0)
				quickDivide_lookups[a - QUICK_DIVIDE_LBOUND][b - QUICK_DIVIDE_LBOUND] = 0;
			else
				quickDivide_lookups[a - QUICK_DIVIDE_LBOUND][b - QUICK_DIVIDE_LBOUND] = a / b;
		}
	}
}

int __inline quickDivide(int a, int b)
{
	if (a >= QUICK_DIVIDE_LBOUND 
		&& a <= QUICK_DIVIDE_UBOUND 
		&& b >= QUICK_DIVIDE_LBOUND 
		&& b <= QUICK_DIVIDE_UBOUND)
	{
		return quickDivide_lookups[a - QUICK_DIVIDE_LBOUND][b - QUICK_DIVIDE_LBOUND];
	}
	else
		return a / b;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//void MapCoord(poly *pol);
//void RenderPoly();



unsigned int __fastcall _madam_Peek(unsigned int addr)
{

//	if((addr>=0x400)&&(addr<=0x53f))
//		printf("#Madam Peek [%X]=%X\n",addr,mregs[addr]);


	if((addr>=0x400)&&(addr<=0x53f))
		{
		   //we need to return actual fifo status!!!!
		return _clio_FIFOStruct(addr);
		}


	if(addr==0x28) // STATUS OF CEL
		{
			switch(_madam_FSM)
			{
				case FSM_IDLE:return 0x0;
				case FSM_SUSPENDED:return 0x30;
				case FSM_INPROCESS:return 0x10;
			}
		}
	if(addr>=0x580 && addr<0x5A0)
	{
		//sprintf(str,"CLUT - MADAM Read madam[0x%X]\n",addr);
		//CDebug::DPrint(str);
	}
	return mregs[addr];
}


void __fastcall _madam_Poke(unsigned int addr, unsigned int val)
{
 if(addr>0x2ff && addr<0x400)
 {
	  //  io_interface(EXT_DEBUG_PRINT,(void*)str.print("MADAM Write madam[0x%X] = 0x%8.8X\n",addr,val).CStr());
 }
 /*
 if(addr==0x13c)
 {
		sprintf(str,"Switch screen SWI 0x%8X addr 0x%8X\n",last_SWI,val);
		CDebug::DPrint(str);
 }*/

	if((addr>=0x400)&&(addr<=0x53f))
	{

		_clio_SetFIFO(addr,val);

		return;

	}
	else
		switch(addr)
	{
	case 0x4:
		val=0x29;
		mregs[addr]=val;
		break;

	case 0x8:
		mregs[addr]=val;
		HandleDMA8();
		break;
	case 0x580:
		_vdl_ProcessVDL(val);
		return;
	case 0x584:
	case 0x588:
	case 0x58C:
	case 0x590:
	case 0x594:
	case 0x598:
	case 0x59C:
		//_3do_DPrint(str.print("CLUT - MADAM Write madam[0x%X] = 0x%8.8X\n",addr,val));
		mregs[addr]=val;
		return;

	case 0x0:
	//	io_interface(EXT_KPRINT,(void*)val);
		return;
	case SPRSTRT:
		if(_madam_FSM==FSM_IDLE)
			_madam_FSM=FSM_INPROCESS;
		return;

	case SPRSTOP:
		_madam_FSM=FSM_IDLE;
		NEXTCCB=0;
		return;

	case SPRCNTU:
		if(_madam_FSM==FSM_SUSPENDED)
			_madam_FSM=FSM_INPROCESS;
		return;

	case SPRPAUS:
		if(_madam_FSM==FSM_INPROCESS)
			_madam_FSM=FSM_SUSPENDED;
		return;

//Matrix engine macros
#define M00  ((double)(signed int)mregs[0x600])
#define M01  ((double)(signed int)mregs[0x604])
#define M02  ((double)(signed int)mregs[0x608])
#define M03  ((double)(signed int)mregs[0x60C])
#define M10  ((double)(signed int)mregs[0x610])
#define M11  ((double)(signed int)mregs[0x614])
#define M12  ((double)(signed int)mregs[0x618])
#define M13  ((double)(signed int)mregs[0x61C])
#define M20  ((double)(signed int)mregs[0x620])
#define M21  ((double)(signed int)mregs[0x624])
#define M22  ((double)(signed int)mregs[0x628])
#define M23  ((double)(signed int)mregs[0x62C])
#define M30  ((double)(signed int)mregs[0x630])
#define M31  ((double)(signed int)mregs[0x634])
#define M32  ((double)(signed int)mregs[0x638])
#define M33  ((double)(signed int)mregs[0x63C])

#define  V0  ((double)(signed int)mregs[0x640])
#define  V1  ((double)(signed int)mregs[0x644])
#define  V2  ((double)(signed int)mregs[0x648])
#define  V3  ((double)(signed int)mregs[0x64C])

#define Rez0 mregs[0x660]
#define Rez1 mregs[0x664]
#define Rez2 mregs[0x668]
#define Rez3 mregs[0x66C]

//#define Nfrac16 ((__int64)mregs[0x680]<<32|(unsigned int)mregs[0x684])
#define Nfrac16 (((__int64)mregs[0x680]<<32)|(unsigned int)mregs[0x684])

// Matix engine


	case 0x7fc:

		mregs[0x7fc]=0; // Ours matrix engine already ready

		static double Rez0T,Rez1T,Rez2T,Rez3T;
			   // io_interface(EXT_DEBUG_PRINT,(void*)str.print("MADAM Write madam[0x%X] = 0x%8.8X\n",addr,val).CStr());

		switch(val) // Cmd
		{
			case 0: //printf("#Matrix = NOP\n");
				Rez0=Rez0T;
				Rez1=Rez1T;
				Rez2=Rez2T;
				Rez3=Rez3T;
				return;   // NOP


			case 1: //multiply a 4x4 matrix of 16.16 values by a vector of 16.16 values

				Rez0=Rez0T;
				Rez1=Rez1T;
				Rez2=Rez2T;
				Rez3=Rez3T;


				Rez0T=(int)((M00*V0+M01*V1+M02*V2+M03*V3)/65536.0);
				Rez1T=(int)((M10*V0+M11*V1+M12*V2+M13*V3)/65536.0);
				Rez2T=(int)((M20*V0+M21*V1+M22*V2+M23*V3)/65536.0);
				Rez3T=(int)((M30*V0+M31*V1+M32*V2+M33*V3)/65536.0);

				return;
			case 2: //multiply a 3x3 matrix of 16.16 values by a vector of 16.16 values
				Rez0=Rez0T;
				Rez1=Rez1T;
				Rez2=Rez2T;
				Rez3=Rez3T;

				Rez0T=(int)((M00*V0+M01*V1+M02*V2)/65536.0);
				Rez1T=(int)((M10*V0+M11*V1+M12*V2)/65536.0);
				Rez2T=(int)((M20*V0+M21*V1+M22*V2)/65536.0);
				//printf("#Matrix CMD2, R0=0x%8.8X, R1=0x%8.8X, R2=0x%8.8X\n",Rez0,Rez1,Rez2);
				return;

			case 3: // Multiply a 3x3 matrix of 16.16 values by multiple vectors, then multiply x and y by n/z
				{   // Return the result vectors {x*n/z, y*n/z, z}


					Rez0=Rez0T;
					Rez1=Rez1T;
					Rez2=Rez2T;
					Rez3=Rez3T;

					double M;

					Rez2T=(signed int)((M20*V0+M21*V1+M22*V2)/65536.0); // z
					if(Rez2T!=0)
						M=Nfrac16/(double)Rez2T;          // n/z
					else
						{
							M=Nfrac16;
						//	io_interface(EXT_DEBUG_PRINT,(void*)"!!!Division by zero!!!\n");
						}

					Rez0T=(signed int)((M00*V0+M01*V1+M02*V2)/65536.0);
					Rez1T=(signed int)((M10*V0+M11*V1+M12*V2)/65536.0);


					Rez0T=(double)((Rez0T*M)/65536.0/65536.0); // x * n/z
					Rez1T=(double)((Rez1T*M)/65536.0/65536.0); // y * n/z

				}
				return;
				default:
					//io_interface(EXT_DEBUG_PRINT,(void*)str.print("??? Unknown cmd MADAM[0x7FC]==0x%x\n", val).CStr());
					return;
		}
		break;
	case 0x130:
		mregs[addr]=val;	//modulo variables :)
		RMOD=((val&1)<<7)+((val&12)<<8)+((val&0x70)<<4);
		val>>=8;
		WMOD=((val&1)<<7)+((val&12)<<8)+((val&0x70)<<4);
		break;
	default:
		mregs[addr]=val;
		break;
	}


}
unsigned int OFFSET;
unsigned int temp1;
unsigned int Flag;

double HDDX,HDDY,HDX,HDY,VDX,VDY,XPOS,YPOS,HDX_2,HDY_2;

int HDDX1616,HDDY1616,HDX1616,HDY1616,VDX1616,VDY1616,XPOS1616,YPOS1616,HDX1616_2,HDY1616_2;
unsigned int CEL_ORIGIN_VH_VALUE;
char	TEXEL_FUN_NUMBER;
int TEXTURE_WI_START,TEXTURE_HI_START,TEXEL_INCX,TEXEL_INCY;
int TEXTURE_WI_LIM, TEXTURE_HI_LIM;


void LoadPLUT(unsigned int pnt,int n)
{
 int i;
	for(i=0;i<n;i++)
	{
			PLUT[i]=_mem_read16((((pnt>>1)+i)^1)<<1);
	}
}

int CCBCOUNTER;
int _madam_HandleCEL()
{


	__smallcicles=CELCYCLES=0;
	if(NEXTCCB!=0)CCBCOUNTER=0;
		STATBITS|=SPRON;
	Flag=0;


	while((NEXTCCB!=0)&&(!Flag))
	//if(_madam_FSM==FSM_INPROCESS)
	{
		CCBCOUNTER++;
		if((NEXTCCB==0)||(Flag))
			{
				_madam_FSM=FSM_IDLE;
				return CELCYCLES;
			}
//1st step -- parce CCB and load it into registers
		CURRENTCCB=NEXTCCB&0xfffffc;
		if((CURRENTCCB>>20)>2)
		{
				_madam_FSM=FSM_IDLE;
				return CELCYCLES;
		}
		OFFSET=CURRENTCCB;


		CCBFLAGS=mread(CURRENTCCB);

		CURRENTCCB+=4;


		if(CCBFLAGS&CCB_PXOR)
		{
			PXOR1=0;
			PXOR2=0x1f1f1f1f;
		}
		else
		{
			PXOR1=0xFFffFFff;
			PXOR2=0;
		}
		Flag=0;
		PLUTF=PDATF=NCCBF=0;

		NEXTCCB=mread(CURRENTCCB)&(~3);


		if(!(CCBFLAGS&CCB_NPABS))
		{
				NEXTCCB+=CURRENTCCB+4;
				NEXTCCB&=0xffffff;
		}
		if((NEXTCCB==0))
			NCCBF=1;
		if((NEXTCCB>>20)>2)
			NCCBF=1;

		CURRENTCCB+=4;


		PDATA=mread(CURRENTCCB)&(~3);
		//if((PDATA==0))
		//	PDATF=1;
		if(!(CCBFLAGS&CCB_SPABS))
		{
			PDATA+=CURRENTCCB+4;
			PDATA&=0xffffff;
		}
		if((PDATA>>20)>2)
			PDATF=1;
		CURRENTCCB+=4;

		if((CCBFLAGS&CCB_LDPLUT))
		{
			   PLUTDATA=mread(CURRENTCCB)&(~3);
			   //if((PLUTDATA==0))
			   //    PLUTF=1;
			   if(!(CCBFLAGS&CCB_PPABS))
			   {
				   PLUTDATA+=CURRENTCCB+4;
				   PLUTDATA&=0xffffff;
			   }
			   if((PLUTDATA>>20)>2)
				   PLUTF=1;
		}
		CURRENTCCB+=4;


		if(NCCBF)
			CCBFLAGS|=CCB_LAST;


		if(CCBFLAGS&CCB_LAST)
			Flag=1;


		if(CCBFLAGS&CCB_YOXY)
		{
			XPOS1616=mread(CURRENTCCB);
						XPOS=XPOS1616/65536.0;
			CURRENTCCB+=4;
			YPOS1616=mread(CURRENTCCB);
						YPOS=YPOS1616/65536.0;
			CURRENTCCB+=4;
		}
		else
			CURRENTCCB+=8;

		// Get the VH value for this cel. This is done in case the
		// cel later decides to use the position as the source of
		// its VH values in the projector.
		CEL_ORIGIN_VH_VALUE = (XPOS1616 & 0x1) | ((YPOS1616 & 0x1) << 15);

		//if((CCBFLAGS&CCB_SKIP)&& debug)
		//	printf("###Cel skipped!!! PDATF=%d PLUTF=%d NCCBF=%d\n",PDATF,PLUTF,NCCBF);


			if(CCBFLAGS&CCB_LAST)
				NEXTCCB=0;
			if(CCBFLAGS&CCB_LDSIZE)
			{
				HDX1616=((int)mread(CURRENTCCB))>>4;
								HDX=HDX1616/65536.0;
				CURRENTCCB+=4;
				HDY1616=((int)mread(CURRENTCCB))>>4;
								HDY=HDY1616/65536.0;
				CURRENTCCB+=4;
				VDX1616=mread(CURRENTCCB);
								VDX=VDX1616/65536.0;
				CURRENTCCB+=4;
				VDY1616=mread(CURRENTCCB);
								VDY=VDY1616/65536.0;
				CURRENTCCB+=4;
			}
			if(CCBFLAGS&CCB_LDPRS)
			{
				HDDX1616=((int)mread(CURRENTCCB))>>4;
								HDDX=HDDX1616/65536.0;
				CURRENTCCB+=4;
				HDDY1616=((int)mread(CURRENTCCB))>>4;
								HDDY=HDDY1616/65536.0;
				CURRENTCCB+=4;
			}
			if(CCBFLAGS&CCB_LDPPMP)
			{
				PIXC=mread(CURRENTCCB);
				CURRENTCCB+=4;
			}
			if(CCBFLAGS&CCB_CCBPRE)
			{
				PRE0=mread(CURRENTCCB);
				CURRENTCCB+=4;
				if(!(CCBFLAGS&CCB_PACKED))
				{
					PRE1=mread(CURRENTCCB);
					CURRENTCCB+=4;
				}
			}
			else if(!PDATF)
			{
				PRE0=mread(PDATA);
				PDATA+=4;
				if(!(CCBFLAGS&CCB_PACKED))
				{
					PRE1=mread(PDATA);
					PDATA+=4;
				}
			}

			{// PDEC data compute
				//pdec.mode=PRE0&PRE0_BPP_MASK;
				switch(PRE0&PRE0_BPP_MASK)
					{
						case 0:
						case 7:
							continue;
						case 1:
							pdec.plutaCCBbits=(CCBFLAGS&0xf)*4;
							pdec.pixelBitsMask=1; // 1 bit
							break;
						case 2:
							pdec.plutaCCBbits=(CCBFLAGS&0xe)*4;
							pdec.pixelBitsMask=3; // 2 bit
							break;
						default://case 3:
							pdec.plutaCCBbits=(CCBFLAGS&0x8)*4;
							pdec.pixelBitsMask=15; // 4 bit
							break;
				}
				pdec.tmask=!(CCBFLAGS&CCB_BGND);
				
				pproj.pmode = (CCBFLAGS&CCB_POVER_MASK);
				pproj.pmodeORmask= (pproj.pmode==PMODE_ONE )? 0x8000:0x0000;
				pproj.pmodeANDmask=(pproj.pmode!=PMODE_ZERO)? 0xFFFF:0x7FFF;
			}

			if((CCBFLAGS&CCB_LDPLUT) && !PLUTF) //load PLUT
			{
			   switch(PRE0&PRE0_BPP_MASK)
			   {
			   case 1:
				   LoadPLUT(PLUTDATA,2);
				   break;
			   case 2:
				   LoadPLUT(PLUTDATA,4);
				   break;
			   case 3:
				   LoadPLUT(PLUTDATA,16);
				   break;
			   default:
				   LoadPLUT(PLUTDATA,32);
			   };
			}

//ok -- CCB decoded -- let's print out our current status
//step#2 -- getting CEL data
			//*
		if(!(CCBFLAGS&CCB_SKIP) && !PDATF)
		{
			if(CCBFLAGS&CCB_PACKED)
			{
				DrawPackedCel_New();
			}
			else
			{

				if((PRE1&PRE1_LRFORM)&&(BPP[PRE0&PRE0_BPP_MASK]==16))
					DrawLRCel_New();
				else
					DrawLiteralCel_New();

			}

		}//if(!(CCBFLAGS& CCB_SKIP))
	}//while

	//STATBITS&=~SPRON;
		if((NEXTCCB==0)||(Flag))
			{
				_madam_FSM=FSM_IDLE;
			}

		return CELCYCLES;
}//HandleCEL



void HandleDMA8()
{
	if(mregs[0x8]&0x8000)// pbus transfer
	{
		DMAPBus();
		mregs[0x8]&=~0x8000; // dma done

		_clio_GenerateFiq(0,1);
	}
}


void DMAPBus()
{
	unsigned int i=0;

	if((int)mregs[0x574]<0)
		return;

	mregs[0x574]-=4;
	mregs[0x570]+=4;
	mregs[0x578]+=4;

	while((int)mregs[0x574]>0)
	{
			if(i<5) WriteIO(mregs[0x570],((unsigned int*)PBUSQueue)[i]);
			else WriteIO(mregs[0x570],0xffffffff);
			mregs[0x574]-=4;
			mregs[0x570]+=4;
			mregs[0x578]+=4;
			i++;
	}

	mregs[0x574]=0xfffffffc;
}

void _madam_KeyPressed(unsigned char* data, unsigned int num)
{
	if(num>16)num=16;
	if(num)memcpy(PBUSQueue,data,num);
	memset(&PBUSQueue[num],-1,20-num);
}


void _madam_Init(unsigned char *memory)
{
	int i,j,n;
	ADD=0;
	debug=0;
	USECEL=1;
	CELCYCLES=0;
	Mem=memory;

	quickDivide_init();

	MAPPING=1;

	_madam_FSM=FSM_IDLE;

	for(i=0;i<2048;i++)
		mregs[i]=0;

	mregs[004]=0x29;		// DRAM dux init
	mregs[574]=0xfffffffc;

#if 1
	mregs[000]=0x01020000; // for Green matrix engine autodetect
		//mregs[000]=0x02022000; // for Green matrix engine autodetect
#else
	mregs[000]=0x01020001; // for ARM soft emu of matrix engine
#endif



	for(i=0;i<32;i++)
		for(j=0;j<8;j++)
			for(n=0;n<4;n++)
			{
				PSCALAR[j][n][i]=((i*(j+1))>>PDV(n));
			}

	for(i=0;i<256;i++)
	{
		pdeco	pix1,pix2;
		unsigned short pres, resamv;

			pix1.raw=i;
			pix2.r16b.b=(pix1.u8b.b<<3)+(pix1.u8b.b<<1)+(pix1.u8b.b>>1);
			pix2.r16b.g=(pix1.u8b.g<<2)+(pix1.u8b.g>>1);
			pix2.r16b.r=(pix1.u8b.r<<2)+(pix1.u8b.r>>1);
			pres=pix2.raw;
			pres&=0x7fff; //pmode=0;
			MAPu8b[i]=pres;

			resamv=(pix1.c8b.m<<1)+pix1.c8b.mpw;
			resamv=(resamv<<6)+(resamv<<3)+resamv;
			MAPc8bAMV[i]=resamv;
	}
	for(i=0;i<(8*8*8);i++)
	{
		pdeco pix1;

			pix1.raw=i<<5;
			MAPc16bAMV[i]=(pix1.c16b.mr<<6)+(pix1.c16b.mg<<3)+pix1.c16b.mb;
	}



}

extern void _3do_InternalFrame(int cicles);
void exteraclocker()
{
		if((CELCYCLES-__smallcicles)>>7)
		{
				__smallcicles=CELCYCLES;
				//_3do_InternalFrame(64);
		}
}

unsigned int __fastcall mread(unsigned int addr)
{
	unsigned int val;
#ifdef SAFEMEMACCESS
//	addr&=0x3FFFFF;
#endif
	val=_mem_read32(addr);
	CELCYCLES+=1;
		//exteraclocker();
	return val;
}

void __fastcall mwrite(unsigned int addr, unsigned int val)
{
#ifdef SAFEMEMACCESS
	addr&=0x3FFFFF;
#endif
	_mem_write32(addr,val);
	CELCYCLES+=2;
		//exteraclocker();

}

void __fastcall mwriteh(unsigned int addr, unsigned short val)
{
#ifdef SAFEMEMACCESS
	addr&=0x3fffff;
#endif
	CELCYCLES+=2;
	_mem_write16((addr^2),val);
		//exteraclocker();
}

unsigned short __fastcall mreadh(unsigned int addr)
{
#ifdef SAFEMEMACCESS
//	addr&=0x3FFFFF;
#endif
	CELCYCLES+=1;
		//exteraclocker();
	return _mem_read16((addr^2));
}

unsigned int __fastcall readPLUTDATA(unsigned int offset)
{
	CELCYCLES+=4;
	if(PLUTDATA==0)
		return 0;
	return *(unsigned short*)(PLUTDATA+(offset^2));
	//return ((unsigned short*)PAL_EXP)[((offset^2)>>1)];
}

unsigned int __fastcall PDEC(unsigned int pixel, unsigned short * amv)
{
	pdeco	pix1,pix2;
	unsigned short resamv,pres;

	pix1.raw=pixel;

	switch(PRE0&PRE0_BPP_MASK)
	{
		default:
		//case 1: // 1 bit
		//case 2: // 2 bits
		//case 3: // 4 bits


			pres=PLUT[(pdec.plutaCCBbits+((pix1.raw&pdec.pixelBitsMask)*2))>>1];

			resamv=0x49;
			break;

		case 4:   // 6 bits

			pres=PLUT[pix1.c6b.c];
			pres=(pres&0x7FFF)+(pix1.c6b.pw<<15); //pmode=pix1.c6b.pw; ???

			resamv=0x49;
			break;

		case 5:   // 8 bits

			if(PRE0&PRE0_LINEAR)
			{
				// (Uncoded 8 bit CEL)

				pres=MAPu8b[pix1.raw&0xFF];

				resamv=0x49;
			}
			else
			{
				// (Coded 8 bit CEL)

				pres=PLUT[pix1.c8b.c];

				resamv=MAPc8bAMV[pix1.raw&0xFF];
			}
			break;

		case 6:  // 16 bits
		case 7:
			//*amv=0;
			//pres=0;
			//Transparent=0;
			if((PRE0&PRE0_LINEAR))
			{
				// (Uncoded 16 bit CEL)

				pres=pix1.raw;
				//pres&=0x7ffe;

				//pres=0x11;
				// pres=(pres&0x7fff)+(pix1.u16b.p<<15);//pmode=pix1.u16b.p; ???
				resamv=0x49;

			}
			else
			{
				// (Uncoded 16 bit CEL)

				pres=PLUT[pix1.c16b.c];
				pres=(pres&0x7fff)|(pixel&0x8000);
				resamv=MAPc16bAMV[(pix1.raw>>5)&0x1FF];
				//nop: pres=(pres&0x7fff)+(pix1.c16b.pw<<15);//pmode=pix1.c16b.pw; ???
			}

			break;
	}

	*amv=resamv;

	// (Conceptual end of DECODER)

	//////////////////////
	// TODO: Do PROJECTOR functions now?
	// They'll be done before using the PROCESSOR.



	//if(!(PRE1&PRE1_NOSWAP) && (CCBCTL0&(1<<27)))
	//			pres=(pres&0x7ffe)|((pres&0x8000)>>15)|((pres&1)<<15);

	//if(!(CCBCTL0&0x80000000))pres=(pres&0x7fff)|((CCBCTL0>>15)&0x8000);

	//pres=(pres|pdec.pmodeORmask)&pdec.pmodeANDmask;


	pproj.Transparent=( ((pres&0x7fff)==0x0) & pdec.tmask );

	return pres;
}

unsigned int __fastcall PPROJ_OUTPUT(unsigned int pdec_output, unsigned int pproc_output, unsigned int pframe_input)
{
	unsigned int VHOutput;
	
	///////////////////////////
	// CCB_PLUTPOS flag
	// Determine projector's originating source of VH values.
	if (CCBFLAGS & CCB_PLUTPOS)
	{
		// Use pixel decoder output.
		VHOutput = (pdec_output & 0x8001);
	}
	else
	{
		// Use VH values determined from the CEL's origin.
		VHOutput = CEL_ORIGIN_VH_VALUE;
	}

	//////////////////////////
	// SWAPHV flag
	// Swap the H and V values now if requested.
	if (CCBCTL0 & SWAPHV)
	{
		// TODO: I have read that PRE1 is only set for unpacked CELs.
		//       So... should this be ignored if using packed CELs? I don't know.
		if (!(PRE1&PRE1_NOSWAP))
		{
			VHOutput=(VHOutput>>15)|((VHOutput&1)<<15);
		}
	}

	//////////////////////////
	// CFBDSUB flag
	// Substitute the VH values from the frame buffer if requested.
	if (CCBCTL0 & CFBDSUB)
	{
		// TODO: This should be re-enabled sometime. However, it currently 
		//       causes the wing commander 3 movies to screw up again! There
		//       must be some missing mbehavior elsewhere.
		//VHOutput = (pframe_input & 0x8001);
	}


	//////////////////////////
	// B15POS_MASK settings
	// Substitute the V value explicitly if requested.
	int b15mode = (CCBCTL0 & B15POS_MASK);
	if (b15mode == B15POS_PDC)
	{
		// Don't touch it.
	}
	else if (b15mode == B15POS_0)
	{
		VHOutput = (VHOutput & ~0x8000);
	}
	else if (b15mode == B15POS_1)
	{
		VHOutput |= 0x8000;
	}

	//////////////////////////
	// B15POS_MASK settings
	// Substitute the H value explicitly if requested.
	int b0mode = (CCBCTL0 & B0POS_MASK);
	if (b0mode == B0POS_PDC)
	{
		// Don't touch it.
	}
	else if (b0mode == B0POS_PPMP)
	{
		// Use LSB from pixel processor output.
		VHOutput = (VHOutput & ~0x1) | (pproc_output & 0x1);
	}
	else if (b0mode == B0POS_0)
	{
		VHOutput = (VHOutput & ~0x1);
	}
	else if (b0mode == B0POS_1)
	{
		VHOutput |= 0x01;
	}

	return (pproc_output & 0x7FFE) | VHOutput;
}

unsigned int __fastcall PPROC(unsigned int pixel, unsigned int fpix, unsigned int amv)
{
	AVS AV;
	PXC pixc;

	pdeco	input1,out,pix1;

	// Set PMODE according to the values set up in the CCBFLAGS word.
	// (This merely uses masks here because it's faster).
	// This is a duty of the PROJECTOR, but we'll do it here because its easier.
	pixel = (pixel|pproj.pmodeORmask)&pproj.pmodeANDmask;

	pixc.raw=PIXC&0xffff;
	if((pixel&0x8000))
	{
		pixc.raw=PIXC>>16;
	}

	//pres,fpix

	//now let's select the sources
	//1. av
	//2. input1
	//3. input2
	//pixc.raw=0;

	if(CCBFLAGS&CCB_USEAV)
	{
		AV.raw=pixc.meaning.av;
	}
	else
	{
		AV.avsignal.dv3=0;
		AV.avsignal.nCLIP=0;
		AV.avsignal.XTEND=0;
		AV.avsignal.NEG=0;
	}

	if(!pixc.meaning.s1)
		input1.raw=pixel;
	else
		input1.raw=fpix;


#pragma pack(push,1)
	union
	{
		unsigned int raw;
		struct
		{
			char R;
			char B;
			char G;
			char a;
		};
	} color1, color2, AOP, BOP;
#pragma pack(pop)

	switch(pixc.meaning.s2)
	{
	case 0:
		color2.raw=0;
		break;
	case 1:
		color2.R=color2.G=color2.B=(pixc.meaning.av>>AV.avsignal.dv3);
				break;
	case 2:
		pix1.raw=fpix;
		color2.R=(pix1.r16b.r)>>AV.avsignal.dv3;
		color2.G=(pix1.r16b.g)>>AV.avsignal.dv3;
		color2.B=(pix1.r16b.b)>>AV.avsignal.dv3;
		break;
	case 3:
		pix1.raw=pixel;
		color2.R=(pix1.r16b.r)>>AV.avsignal.dv3;
		color2.G=(pix1.r16b.g)>>AV.avsignal.dv3;
		color2.B=(pix1.r16b.b)>>AV.avsignal.dv3;
		break;
	}


	switch(pixc.meaning.ms)
	{
	case 0:
		color1.R=PSCALAR[pixc.meaning.mxf][pixc.meaning.dv1][input1.r16b.r];
		color1.G=PSCALAR[pixc.meaning.mxf][pixc.meaning.dv1][input1.r16b.g];
		color1.B=PSCALAR[pixc.meaning.mxf][pixc.meaning.dv1][input1.r16b.b];
		break;
	case 1:
		color1.R=PSCALAR[(amv>>6)&7][pixc.meaning.dv1][input1.r16b.r];
		color1.G=PSCALAR[(amv>>3)&7][pixc.meaning.dv1][input1.r16b.g];
		color1.B=PSCALAR[amv&7][pixc.meaning.dv1][input1.r16b.b];
		break;
	case 2:
		pix1.raw=pixel;
		color1.R=PSCALAR[pix1.r16b.r>>2][pix1.r16b.r&3][input1.r16b.r];
		color1.G=PSCALAR[pix1.r16b.g>>2][pix1.r16b.g&3][input1.r16b.g];
		color1.B=PSCALAR[pix1.r16b.b>>2][pix1.r16b.b&3][input1.r16b.b];
		break;
	case 3:
		color1.R=PSCALAR[4][pixc.meaning.dv1][input1.r16b.r];
		color1.G=PSCALAR[4][pixc.meaning.dv1][input1.r16b.g];
		color1.B=PSCALAR[4][pixc.meaning.dv1][input1.r16b.b];
		break;
	}
	
	/*
	// Use this to render magenta for testing.
	if (false)
	{
		pdeco fakeColor;
		fakeColor.r16b.r = 0x1b;
		fakeColor.r16b.g = 0x00;
		fakeColor.r16b.b = 0x1b;
		fakeColor.r16b.p = 1;
		
		return fakeColor.raw;
	}
	*/

	//ok -- we got the sources -- now RGB processing
	//AOP/BOP calculation
	AOP.raw=color1.raw&PXOR1;
	color1.raw&=PXOR2;


	if(AV.avsignal.NEG)
		BOP.raw=color2.raw^0x00ffffff;
	else
	{
		BOP.raw=color2.raw^color1.raw;
	}

	if(AV.avsignal.XTEND)
	{
		BOP.R=(BOP.R<<3)>>3;
		BOP.B=(BOP.B<<3)>>3;
		BOP.G=(BOP.G<<3)>>3;
	}

	color2.R=(AOP.R+BOP.R+AV.avsignal.NEG)>>pixc.meaning.dv2;
	color2.G=(AOP.G+BOP.G+AV.avsignal.NEG)>>pixc.meaning.dv2;
	color2.B=(AOP.B+BOP.B+AV.avsignal.NEG)>>pixc.meaning.dv2;


//fprintf(flog,"%d %d %02x\t%02d %02d %02d\n", pixc.meaning.s2, pixc.meaning.ms, AV.raw, color2.R, color2.G, color2.B);

	if(!AV.avsignal.nCLIP)
	{
		if(color2.R<0)  color2.R=0;
		else if(color2.R>31) color2.R=31;

		if(color2.G<0)  color2.G=0;
		else if(color2.G>31) color2.G=31;

		if(color2.B<0)  color2.B=0;
		else if(color2.B>31) color2.B=31;

	}



	out.raw=0;
	out.r16b.r=color2.R;
	out.r16b.g=color2.G;
	out.r16b.b=color2.B;

	// TODO: Is this something the PROJECTOR should do?
	if(!(CCBFLAGS&CCB_NOBLK) && out.raw==0) out.raw=1<<10;

	//if(!(PRE1&PRE1_NOSWAP) && (CCBCTL0&(1<<27)))
				//out.raw=(out.raw&0x7ffe)|((out.raw&0x8000)>>15)|((out.raw&1)<<15);

	//if(!(CCBCTL0&0x80000000))out.raw=(out.raw&0x7fff)|((CCBCTL0>>15)&0x8000);

	return out.raw;
}



unsigned int * _madam_GetRegs()
{
	return mregs;
}



void __fastcall DrawPackedCel_New()
{
	sf=100000;
	unsigned int pixel;
	unsigned int framePixel;
	unsigned int start;
	unsigned short CURPIX,LAMV;
	int i,j;

	int lastaddr;
	int xcur,ycur,xvert,yvert,xdown,ydown,hdx,hdy, scipw, wcnt;
	int accx, accy, scipstr;

	start = PDATA;

	nrows=(PRE0&PRE0_VCNT_MASK)>>PRE0_VCNT_SHIFT;

	bpp=BPP[PRE0&PRE0_BPP_MASK];
	offsetl=2;	if(bpp < 8) offsetl=1;

	pixcount=0;

	compsize=30;

	SPRHI=nrows+1;
	calcx=0;

	if(TestInitVisual(1))return;
	xvert=XPOS1616;
	yvert=YPOS1616;

	if(TEXEL_FUN_NUMBER==0)
	{
		//return;
		for(currentrow=0;currentrow<(TEXTURE_HI_LIM);currentrow++)
		{

			//Initbitoper.Read(start,300);
			bitoper.AttachBuffer(start);
			offset=bitoper.Read(offsetl<<3);
			//bitoper.Read(offsetl<<3);

			//BITCALC=((offset+2)<<2)<<5;
			lastaddr=start+((offset+2)<<2);
		//	calcx=0;
			eor=0;


			xcur=xvert;
			ycur=yvert;
			xvert+=VDX1616;
			yvert+=VDY1616;
			//if((ycur>>16)>CLIPXVAL)ycur=CLIPXVAL<<16;
			//if(ycur<0)ycur=0;

			if(TEXTURE_HI_START){TEXTURE_HI_START--;start=lastaddr;continue;}
			scipw=TEXTURE_WI_START;
			wcnt=scipw;
			while(!eor)//while not end of row
			{

				type=bitoper.Read(2);//bitoper.Read(2);
							if( (int)(bitoper.GetBytePose()+start) >= (lastaddr))type=0;

				//pixcount=bitoper.Read(6)+1;
				pixcount=bitoper.Read(6)+1;

				if(scipw)
				{
					if(type==0) break;
					if(scipw>=(int)(pixcount))
					{
						scipw-=(pixcount);
						if(HDX1616)xcur+=HDX1616*(pixcount);
						if(HDY1616)ycur+=HDY1616*(pixcount);
						if(type==1)bitoper.Skip(bpp*pixcount);//bitoper.Skip(bpp*(pixcount));
						else if(type==3)bitoper.Skip(bpp);//bitoper.Skip(bpp);
						continue;
					}
					else
					{
						if(HDX1616)xcur+=HDX1616*(scipw);
						if(HDY1616)ycur+=HDY1616*(scipw);
						pixcount-=scipw;
						if(type==1)bitoper.Skip(bpp*scipw);//bitoper.Skip(bpp*scipw);
						scipw=0;
					}
				}
				//if(wcnt>=TEXTURE_WI_LIM)break;
				wcnt+=(pixcount);
				if(wcnt>TEXTURE_WI_LIM)
				{
					pixcount-=(wcnt-TEXTURE_WI_LIM);
					//if(pixcount>>31)break;
				}
				switch(type)
				{
					case 0: //end of row
						eor=1;
						break;
					case 1: //PACK_LITERAL
						for(pix=0;pix<pixcount;pix++)
						{
							CURPIX=PDEC(bitoper.Read(bpp),&LAMV);
							if(!pproj.Transparent)
							{
									//TexelDraw_Line(CURPIX, LAMV, xcur, ycur, 1);
									framePixel = mreadh((PIXSOURCE+XY2OFF((xcur>>16)<<2,ycur>>16,RMOD)));
									pixel = PPROC(CURPIX,framePixel,LAMV);
									pixel = PPROJ_OUTPUT(CURPIX, pixel, framePixel);
									mwriteh((FBTARGET+XY2OFF((xcur>>16)<<2,ycur>>16,WMOD)),pixel);

							}
							xcur+=HDX1616;
							ycur+=HDY1616;

						}

						break;
					case 2: //PACK_TRANSPARENT
						//	calcx+=(pixcount+1);
						if(HDX1616)xcur+=HDX1616*(pixcount);
						if(HDY1616)ycur+=HDY1616*(pixcount);

						break;
					case 3: //PACK_REPEAT
						CURPIX=PDEC(bitoper.Read(bpp),&LAMV);
						if(CURPIX>32300&&CURPIX<33500&&(CURPIX>32760||CURPIX<32750)){
						if(speedfixes>=0&&sdf==0&&speedfixes<=200001&&unknownflag11==0)speedfixes=200000;}
						if(unknownflag11>0&&sdf==0&&CURPIX<30000&&CURPIX>29000) speedfixes=-200000;
						if(!pproj.Transparent)
						{

								TexelDraw_Line(CURPIX, LAMV, xcur, ycur, (pixcount));

						}
						if(HDX1616)xcur+=HDX1616*(pixcount);
						if(HDY1616)ycur+=HDY1616*(pixcount);

					break;
				}//type
				if(wcnt>=TEXTURE_WI_LIM)break;
			}//eor

			start=lastaddr;

		}
	}
	else if(TEXEL_FUN_NUMBER==1)
	{
		unknownflag11=100000;

		int drawHeight;
		drawHeight = VDY1616;
		if (CCBFLAGS&CCB_MARIA && drawHeight > (1 << 16))
			drawHeight = (1 << 16);

		for(currentrow=0;currentrow<SPRHI;currentrow++)
		{

			bitoper.AttachBuffer(start);
			offset=bitoper.Read(offsetl<<3);

			BITCALC=((offset+2)<<2)<<5;
			lastaddr=start+((offset+2)<<2);

			eor=0;

			xcur=xvert;
			ycur=yvert;
			xvert+=VDX1616;
			yvert+=VDY1616;

			while(!eor)//while not end of row
			{

				type=bitoper.Read(2);
							if( (bitoper.GetBytePose()+start) >= (lastaddr))type=0;

				int __pix=bitoper.Read(6)+1;
				switch(type)
				{
					case 0: //end of row
						eor=1;
						break;
					case 1: //PACK_LITERAL
						while(__pix)
						{
							__pix--;
							CURPIX=PDEC(bitoper.Read(bpp),&LAMV);

							if(!pproj.Transparent)
							{
								if (drawHeight != VDY1616 && YPOS < 0)
								{
									int sfdjlk = 0;
								}

								if(TexelDraw_Scale(CURPIX, LAMV, xcur>>16, ycur>>16, (xcur+(HDX1616+VDX1616))>>16, (ycur+(HDY1616+drawHeight))>>16))
									break;
							}
							xcur+=HDX1616;
							ycur+=HDY1616;

						}

						break;
					case 2: //PACK_TRANSPARENT
						//	calcx+=(pixcount+1);
						xcur+=HDX1616*(__pix);
						ycur+=HDY1616*(__pix);
											__pix=0;

						break;
					case 3: //PACK_REPEAT
						CURPIX=PDEC(bitoper.Read(bpp),&LAMV);
						if(!pproj.Transparent)
						{

								if(TexelDraw_Scale(CURPIX, LAMV, xcur>>16, ycur>>16, (xcur+(HDX1616*(__pix))+VDX1616)>>16, (ycur+(HDY1616*(__pix))+drawHeight)>>16))break;

						}
						xcur+=HDX1616*(__pix);
						ycur+=HDY1616*(__pix);
											__pix=0;
					break;
				}//type
				if(__pix)break;
			}//eor


			start=lastaddr;


		}

	}
	else
	{    
	  if(speedfixes>=0&&speedfixes<=100001) speedfixes=100000;
			for(currentrow=0;currentrow<SPRHI;currentrow++)
		{

			bitoper.AttachBuffer(start);
			offset=bitoper.Read(offsetl<<3);

			BITCALC=((offset+2)<<2)<<5;
			lastaddr=start+((offset+2)<<2);

			eor=0;

			xcur=xvert;
			ycur=yvert;
			hdx=HDX1616;
			hdy=HDY1616;

			xvert+=VDX1616;
			yvert+=VDY1616;
			HDX1616+=HDDX1616;
			HDY1616+=HDDY1616;


					xdown=xvert;
			ydown=yvert;

			while(!eor)//while not end of row
			{

				type=bitoper.Read(2);
							if( (bitoper.GetBytePose()+start) >= (lastaddr))type=0;

				int __pix=bitoper.Read(6)+1;

				switch(type)
				{
					case 0: //end of row
						eor=1;
						break;
					case 1: //PACK_LITERAL

						while(__pix)
						{
							CURPIX=PDEC(bitoper.Read(bpp),&LAMV);
							__pix--;
							//   if(speedfixes>=0&&speedfixes<=100001) speedfixes=300000;
							if(!pproj.Transparent)
							{
								if(TexelDraw_Arbitrary(CURPIX, LAMV, xcur, ycur, xcur+hdx, ycur+hdy, xdown+HDX1616, ydown+HDY1616, xdown, ydown))
									break;
							}
							xcur+=hdx;
							ycur+=hdy;
							xdown+=HDX1616;
							ydown+=HDY1616;
						}
											//pixcount=0;
						break;
					case 2: //PACK_TRANSPARENT
						if(speedfixes>=0&&sdf>0/*&&speedfixes<=100001*/)    speedfixes=300000;
						//	calcx+=(pixcount+1);
						xcur+=hdx*(__pix);
						ycur+=hdy*(__pix);
						xdown+=HDX1616*(__pix);
						ydown+=HDY1616*(__pix);
											__pix=0;

						break;
					case 3: //PACK_REPEAT
						CURPIX=PDEC(bitoper.Read(bpp),&LAMV);
						if(speedfixes>=0&&speedfixes<200001&&((CURPIX>10000&&CURPIX<11000)&&sdf==0/*||(CURPIX>10500&&CURPIX<10650)*/))speedfixes=200000;//(CURPIX>10450&&CURPIX<10470)
						if(!pproj.Transparent)
						{
								while(__pix)
								{
									__pix--;
									if(TexelDraw_Arbitrary(CURPIX, LAMV, xcur, ycur, xcur+hdx, ycur+hdy, xdown+HDX1616, ydown+HDY1616, xdown, ydown))
										break;
									xcur+=hdx;
									ycur+=hdy;
									xdown+=HDX1616;
									ydown+=HDY1616;
								}
						}
						else
						{
								xcur+=hdx*__pix;
								ycur+=hdy*__pix;
								xdown+=HDX1616*__pix;
								ydown+=HDY1616*__pix;
								__pix=0;
						}
						//pixcount=0;

					break;
				};//type
				if(__pix) break;
			}//eor

			start=lastaddr;

		}
	}
	SPRWI++;

	if (fixmode&FIX_BIT_GRAPHICS_STEP_Y)
	{
		YPOS1616=ycur;
		YPOS=YPOS1616/65536.0;
	}
	else
	{
		XPOS1616=xcur;
		XPOS=XPOS1616/65536.0;
	}
}

void __fastcall DrawLiteralCel_New()
{
	sf=100000;
	unsigned int pixel;
	unsigned int framePixel;
	int i,j,xcur,ycur,xvert,yvert,xdown,ydown,hdx,hdy,pix_repit,scipstr;
	unsigned short CURPIX,LAMV;
	int get1,get2;
	// RMOD=RMODULO[REGCTL0];
	// WMOD=WMODULO[REGCTL0];


	bpp=BPP[PRE0&PRE0_BPP_MASK];
	offsetl=2;	if(bpp < 8)	offsetl=1;
	pixcount=0;
	offset=(offsetl==1)?((PRE1&PRE1_WOFFSET8_MASK)>>PRE1_WOFFSET8_SHIFT):((PRE1&PRE1_WOFFSET10_MASK)>>PRE1_WOFFSET10_SHIFT);


	SPRWI=1+(PRE1&PRE1_TLHPCNT_MASK);
	SPRHI=((PRE0&PRE0_VCNT_MASK)>>PRE0_VCNT_SHIFT)+1;

	if(TestInitVisual(0))return;
	xvert=XPOS1616;
	yvert=YPOS1616;



	if(TEXEL_FUN_NUMBER==0)
	{
		//  if(speedfixes>=0&&speedfixes<=100001)   speedfixes=300000;
		sdf=100000;
		//øðèôòû NFS
		SPRWI-=((PRE0>>24)&0xf);
		xvert+=TEXTURE_HI_START*VDX1616;
		yvert+=TEXTURE_HI_START*VDY1616;
		PDATA+=((offset+2)<<2)*TEXTURE_HI_START;
		if(SPRWI>TEXTURE_WI_LIM)SPRWI=TEXTURE_WI_LIM;
		for(i=TEXTURE_HI_START;i<TEXTURE_HI_LIM;i++)
		{

			bitoper.AttachBuffer(PDATA);
			BITCALC=((offset+2)<<2)<<5;
			xcur=xvert+TEXTURE_WI_START*HDX1616;
			ycur=yvert+TEXTURE_WI_START*HDY1616;
					bitoper.Skip(bpp*(((PRE0>>24)&0xf)));
			if(TEXTURE_WI_START)bitoper.Skip(bpp*(TEXTURE_WI_START));

			xvert+=VDX1616;
			yvert+=VDY1616;


			for(j=TEXTURE_WI_START;j<SPRWI;j++)
			{
				CURPIX=PDEC(bitoper.Read(bpp),&LAMV);

				if(!pproj.Transparent)
				{
					//TexelDraw_Line(CURPIX, LAMV, xcur, ycur, 1);
					framePixel = mreadh((PIXSOURCE+XY2OFF((xcur>>16)<<2,ycur>>16,RMOD)));
					pixel = PPROC(CURPIX,framePixel,LAMV);
					pixel = PPROJ_OUTPUT(CURPIX, pixel, framePixel);
					mwriteh((FBTARGET+XY2OFF((xcur>>16)<<2,ycur>>16,WMOD)),pixel);

				}
				xcur+=HDX1616;
				ycur+=HDY1616;

			}
			PDATA+=(offset+2)<<2;

		}
	}
	else if(TEXEL_FUN_NUMBER==1)
	{
		SPRWI-=((PRE0>>24)&0xf);

		int drawHeight;
		drawHeight = VDY1616;
		if (CCBFLAGS&CCB_MARIA && drawHeight > (1 << 16))
			drawHeight = (1 << 16);

		for(i=0;i<SPRHI;i++)
		{

			bitoper.AttachBuffer(PDATA);
			BITCALC=((offset+2)<<2)<<5;
			xcur=xvert;
			ycur=yvert;
			xvert+=VDX1616;
			yvert+=VDY1616;
					bitoper.Skip(bpp*(((PRE0>>24)&0xf)));


			for(j=0;j<SPRWI;j++)
			{

				CURPIX=PDEC(bitoper.Read(bpp),&LAMV);


				if(!pproj.Transparent)
				{
						if(TexelDraw_Scale(CURPIX, LAMV, xcur>>16, ycur>>16, (xcur+HDX1616+VDX1616)>>16, (ycur+HDY1616+drawHeight)>>16))break;

				}
				xcur+=HDX1616;
				ycur+=HDY1616;

			}
			PDATA+=(offset+2)<<2;

		}
	}
	else
	{

		SPRWI-=((PRE0>>24)&0xf);
		for(i=0;i<SPRHI;i++)
		{
			bitoper.AttachBuffer(PDATA);
			BITCALC=((offset+2)<<2)<<5;

			xcur=xvert;
			ycur=yvert;
			hdx=HDX1616;
			hdy=HDY1616;

			xvert+=VDX1616;
			yvert+=VDY1616;
			HDX1616+=HDDX1616;
			HDY1616+=HDDY1616;

					bitoper.Skip(bpp*(((PRE0>>24)&0xf)));


			xdown=xvert;
			ydown=yvert;

			for(j=0;j<SPRWI;j++)
			{

				CURPIX=PDEC(bitoper.Read(bpp),&LAMV);

				if(!pproj.Transparent)
				{
						if(TexelDraw_Arbitrary(CURPIX, LAMV, xcur, ycur, xcur+hdx, ycur+hdy, xdown+HDX1616, ydown+HDY1616, xdown, ydown))
							break;
						if(speedfixes<1||(speedfixes>=0&&speedfixes<200001)){
							if (CURPIX>30000&&CURPIX<40000)speedfixes=0;
							else speedfixes=-100000;}
				}
				xcur+=hdx;
				ycur+=hdy;
				xdown+=HDX1616;
				ydown+=HDY1616;
			}
			PDATA+=(((offset+2)<<2)/*scipstr*/);


		}
	}

	if (fixmode&FIX_BIT_GRAPHICS_STEP_Y)
	{
		YPOS1616=ycur;
		YPOS=YPOS1616/65536.0;
	}
	else
	{
		XPOS1616=xcur;
		XPOS=XPOS1616/65536.0;
	}
}

void __fastcall DrawLRCel_New()
{
	sf=100000;
	unsigned int pixel;
	unsigned int framePixel;
	int i,j,xcur,ycur,xvert,yvert,xdown,ydown,hdx,hdy;
	unsigned short CURPIX,LAMV;


	bpp=BPP[PRE0&PRE0_BPP_MASK];
	offsetl=2;	if(bpp < 8)	offsetl=1;
	pixcount=0;
	offset=(offsetl==1)?((PRE1&PRE1_WOFFSET8_MASK)>>PRE1_WOFFSET8_SHIFT):((PRE1&PRE1_WOFFSET10_MASK)>>PRE1_WOFFSET10_SHIFT);
	offset+=2;

	SPRWI=1+(PRE1&PRE1_TLHPCNT_MASK);
	SPRHI=(((PRE0&PRE0_VCNT_MASK)>>PRE0_VCNT_SHIFT)<<1)+2;   //doom fix

	if(TestInitVisual(0))return;
	xvert=XPOS1616;
	yvert=YPOS1616;

	if(TEXEL_FUN_NUMBER==0)
	{
		xvert+=TEXTURE_HI_START*VDX1616;
		yvert+=TEXTURE_HI_START*VDY1616;
		//if(SPRHI>TEXTURE_HI_LIM)SPRHI=TEXTURE_HI_LIM;
		if(SPRWI>TEXTURE_WI_LIM)SPRWI=TEXTURE_WI_LIM;
		for(i=TEXTURE_HI_START;i<TEXTURE_HI_LIM;i++)
		{
			xcur=xvert+TEXTURE_WI_START*HDX1616;
			ycur=yvert+TEXTURE_WI_START*HDY1616;
			xvert+=VDX1616;
			yvert+=VDY1616;


			for(j=TEXTURE_WI_START;j<SPRWI;j++)
			{
				CURPIX=PDEC(mreadh((PDATA+XY2OFF(j<<2,i,offset<<2))),&LAMV);

				if(!pproj.Transparent)
				{
					//TexelDraw_Line(CURPIX, LAMV, xcur, ycur, 1);
					framePixel = mreadh((PIXSOURCE+XY2OFF((xcur>>16)<<2,ycur>>16,RMOD)));
					pixel = PPROC(CURPIX,framePixel,LAMV);
					pixel = PPROJ_OUTPUT(CURPIX, pixel, framePixel);
					mwriteh((FBTARGET+XY2OFF((xcur>>16)<<2,ycur>>16,WMOD)),pixel);
				}

				xcur+=HDX1616;
				ycur+=HDY1616;
			}

		}
	}
	else if(TEXEL_FUN_NUMBER==1)
	{
		int drawHeight;
		drawHeight = VDY1616;
		if (CCBFLAGS&CCB_MARIA && drawHeight > (1 << 16))
			drawHeight = (1 << 16);

		for(i=0;i<SPRHI;i++)
		{
			xcur=xvert;
			ycur=yvert;
			xvert+=VDX1616;
			yvert+=VDY1616;


			for(j=0;j<SPRWI;j++)
			{

				CURPIX=PDEC(mreadh((PDATA+XY2OFF(j<<2,i,offset<<2))),&LAMV);

				if(!pproj.Transparent)
				{

						if(TexelDraw_Scale(CURPIX, LAMV, xcur>>16, ycur>>16, (xcur+HDX1616+VDX1616)>>16, (ycur+HDY1616+drawHeight)>>16))break;

				}
				xcur+=HDX1616;
				ycur+=HDY1616;


			}

		}
	}
	else
	{
		//return;

		for(i=0;i<SPRHI;i++)
		{


			xcur=xvert;
			ycur=yvert;
			xvert+=VDX1616;
			yvert+=VDY1616;
			xdown=xvert;
			ydown=yvert;
			hdx=HDX1616;
			hdy=HDY1616;
			HDX1616+=HDDX1616;
			HDY1616+=HDDY1616;


			for(j=0;j<SPRWI;j++)
			{
				CURPIX=PDEC(mreadh((PDATA+XY2OFF(j<<2,i,offset<<2))),&LAMV);

				if(!pproj.Transparent)
				{
					if(TexelDraw_Arbitrary(CURPIX, LAMV, xcur, ycur, xcur+hdx, ycur+hdy, xdown+HDX1616, ydown+HDY1616, xdown, ydown))
						break;
				}

				xcur+=hdx;
				ycur+=hdy;
				xdown+=HDX1616;
				ydown+=HDY1616;


			}


		}
	}

	if (fixmode&FIX_BIT_GRAPHICS_STEP_Y)
	{
		YPOS1616=ycur;
		YPOS=YPOS1616/65536.0;
	}
	else
	{
		XPOS1616=xcur;
		XPOS=XPOS1616/65536.0;
	}
}



unsigned int _madam_GetCELCycles()
{
	unsigned int val=CELCYCLES; // 1 word = 2 CELCYCLES, 1 hword= 1 CELCYCLE, 8 CELCYCLE=1 CPU SCYCLE
	CELCYCLES=0;
	return val;
}


void _madam_Reset()
{
int i;
for(i=0;i<2048;i++)
	mregs[i]=0;
}


void _madam_SetMapping(unsigned int flag)
{
	MAPPING=flag;
}



#define ROAN_SHIFT 16
#define ROAN_TYPE int

#include <math.h>

unsigned int TexelCCWTest(double hdx, double hdy, double vdx, double vdy)
{
	if(((hdx+vdx)*(hdy-vdy)+vdx*vdy-hdx*hdy)<0.0)return CCB_ACCW;
	return CCB_ACW;
}
bool QuardCCWTest(int wdt)
{
	unsigned int tmp;
	if(((CCBFLAGS&CCB_ACCW)) && ((CCBFLAGS&CCB_ACW)))return false;

	tmp=TexelCCWTest(HDX,HDY,VDX,VDY);
	if(tmp!=TexelCCWTest(HDX,HDY,VDX+(HDDX)*(float)wdt,VDY+(HDDY)*(float)wdt))return false;
	if(tmp!=TexelCCWTest(HDX+(HDDX)*SPRHI,HDY+(HDDY)*SPRHI,VDX,VDY))return false;
	if(tmp!=TexelCCWTest(HDX+(HDDX)*SPRHI,HDY+(HDDY)*SPRHI,VDX+(HDDX)*(float)SPRHI*(float)wdt,VDY+(HDDY)*(float)SPRHI*(float)wdt))return false;
	if(tmp==(CCBFLAGS&(CCB_ACCW|CCB_ACW)))
		return true;
	return false;
}

__inline int __abs(int val)
{
	if(val>0)return val;
	return -val;
}
int TestInitVisual(int packed)
{
	int xpoints[4],ypoints[4];

	if((!(CCBFLAGS&CCB_ACCW)) && (!(CCBFLAGS&CCB_ACW)))return -1;


	if(!packed)
	{
		xpoints[0]=XPOS1616>>16;
		xpoints[1]=(XPOS1616+HDX1616*SPRWI)>>16;
		xpoints[2]=(XPOS1616+VDX1616*SPRHI)>>16;
		xpoints[3]=(XPOS1616+VDX1616*SPRHI+
			(HDX1616+HDDX1616*SPRHI)*SPRWI)>>16;
		if(xpoints[0]<0 && xpoints[1]<0 && xpoints[2]<0 && xpoints[3]<0) return -1;
		if(xpoints[0]>CLIPXVAL && xpoints[1]>CLIPXVAL && xpoints[2]>CLIPXVAL && xpoints[3]>CLIPXVAL) return -1;


		ypoints[0]=YPOS1616>>16;
		ypoints[1]=(YPOS1616+HDY1616*SPRWI)>>16;
		ypoints[2]=(YPOS1616+VDY1616*SPRHI)>>16;
		ypoints[3]=(YPOS1616+VDY1616*SPRHI+
			(HDY1616+HDDY1616*SPRHI)*SPRWI)>>16;
		if(ypoints[0]<0 && ypoints[1]<0 && ypoints[2]<0 && ypoints[3]<0) return -1;
		if(ypoints[0]>CLIPYVAL && ypoints[1]>CLIPYVAL && ypoints[2]>CLIPYVAL && ypoints[3]>CLIPYVAL) return -1;
	}
	else
	{
		xpoints[0]=XPOS1616>>16;
		xpoints[1]=(XPOS1616+VDX1616*SPRHI)>>16;
		if( xpoints[0]<0 && xpoints[1]<0 && HDX1616<=0 && HDDX1616<=0 ) return -1;
		if(xpoints[0]>CLIPXVAL && xpoints[1]>CLIPXVAL && HDX1616>=0 && HDDX1616>=0 ) return -1;

		ypoints[0]=YPOS1616>>16;
		ypoints[1]=(YPOS1616+VDY1616*SPRHI)>>16;
		if(ypoints[0]<0 && ypoints[1]<0 && HDY1616<=0 && HDDY1616<=0 ) return -1;
		if(ypoints[0]>CLIPYVAL && ypoints[1]>CLIPYVAL && HDY1616>=0 && HDDY1616>=0 ) return -1;
	}

	//*
	if(HDDX1616==0 && HDDY1616==0)
	{
		if(HDX1616==0 && VDY1616==0)
		{
			if((HDY1616<0 && VDX1616>0)||(HDY1616>0 && VDX1616<0))
			{
				if((CCBFLAGS&CCB_ACW))
				{
					if(__abs(HDY1616)==0x10000 && __abs(VDX1616)==0x10000 && !((YPOS1616|XPOS1616)&0xffff))
					{
						return Init_Line_Map();
						//return 0;
					}
					else
					{
						Init_Scale_Map();
						return 0;
					}
				}
			}
			else
			{
				if((CCBFLAGS&CCB_ACCW))
				{
					if(__abs(HDY1616)==0x10000 && __abs(VDX1616)==0x10000 && !((YPOS1616|XPOS1616)&0xffff))
					{
						return Init_Line_Map();
						//return 0;
					}
					else
					{
						Init_Scale_Map();
						return 0;
					}
				}

			}
			return -1;


		}
		else if(HDY1616==0 && VDX1616==0)
		{

			if((HDX1616<0 && VDY1616>0)||(HDX1616>0 && VDY1616<0))
			{
				if((CCBFLAGS&CCB_ACCW))
				{
					if(__abs(HDX1616)==0x10000 &&	__abs(VDY1616)==0x10000 && !((YPOS1616|XPOS1616)&0xffff))
					{
						return Init_Line_Map();
						//return 0;
					}
					else
					{
						Init_Scale_Map();
						return 0;
					}
				}
			}
			else
			{
				if((CCBFLAGS&CCB_ACW))
				{
					if(__abs(HDX1616)==0x10000 &&	__abs(VDY1616)==0x10000 && !((YPOS1616|XPOS1616)&0xffff))
					{
						return Init_Line_Map();
						//return 0;
					}
					else
					{
						Init_Scale_Map();
						return 0;
					}
				}
			}
			return -1;


		}
	} //*/

	if(QuardCCWTest((!packed)?SPRWI:2048))return -1;
	Init_Arbitrary_Map();


	return 0;

}

int Init_Line_Map()
{
	TEXEL_FUN_NUMBER=0;
	TEXTURE_WI_START=0;
	TEXTURE_HI_START=0;
	TEXTURE_HI_LIM=SPRHI;
	if(HDX1616<0)
		XPOS1616-=0x8000;
	else if(VDX1616<0)
		XPOS1616-=0x8000;

	if(HDY1616<0)
		YPOS1616-=0x8000;
	else if(VDY1616<0)
		YPOS1616-=0x8000;

	if(VDX1616<0)
	{
		if(((XPOS1616)-((SPRHI-1)<<16)>>16)<0)
			TEXTURE_HI_LIM=(XPOS1616>>16)+1;
		if(TEXTURE_HI_LIM>SPRHI)TEXTURE_HI_LIM=SPRHI;
	}
	else if(VDX1616>0)
	{
		if(((XPOS1616+(SPRHI<<16))>>16)>CLIPXVAL)
			TEXTURE_HI_LIM=CLIPXVAL-(XPOS1616>>16)+1;
	}
	if(VDY1616<0)
	{
		if(((YPOS1616)-((SPRHI-1)<<16)>>16)<0)
			TEXTURE_HI_LIM=(YPOS1616>>16)+1;
		if(TEXTURE_HI_LIM>SPRHI)TEXTURE_HI_LIM=SPRHI;
	}
	else if(VDY1616>0)
	{
		if(((YPOS1616+(SPRHI<<16))>>16)>CLIPYVAL)
			TEXTURE_HI_LIM=CLIPYVAL-(YPOS1616>>16)+1;
	}

	if(HDX1616<0)
		TEXTURE_WI_LIM=(XPOS1616>>16)+1;
	else if(HDX1616>0)
		TEXTURE_WI_LIM=CLIPXVAL-(XPOS1616>>16)+1;

	if(HDY1616<0)
		TEXTURE_WI_LIM=(YPOS1616>>16)+1;
	else if(HDY1616>0)
		TEXTURE_WI_LIM=CLIPYVAL-(YPOS1616>>16)+1;


	if(XPOS1616<0)
	{
		if(HDX1616<0)return -1;
		else if(HDX1616>0)
			TEXTURE_WI_START=-(XPOS1616>>16);

		if(VDX1616<0)return -1;
		else if(VDX1616>0)
			TEXTURE_HI_START=-(XPOS1616>>16);
	}
	else if((XPOS1616>>16)>CLIPXVAL)
	{
		if(HDX1616>0)return -1;
		else if(HDX1616<0)
			TEXTURE_WI_START=(XPOS1616>>16)-CLIPXVAL;

		if(VDX1616>0)return -1;
		else if(VDX1616<0)
			TEXTURE_HI_START=(XPOS1616>>16)-CLIPXVAL;

	}
	if(YPOS1616<0)
	{
		if(HDY1616<0)return -1;
		else if(HDY1616>0)
			TEXTURE_WI_START=-(YPOS1616>>16);

		if(VDY1616<0)return -1;
		else if(VDY1616>0)
			TEXTURE_HI_START=-(YPOS1616>>16);
	}
	else if((YPOS1616>>16)>CLIPYVAL)
	{
		if(HDY1616>0)return -1;
		else if(HDY1616<0)
			TEXTURE_WI_START=(YPOS1616>>16)-CLIPYVAL;

		if(VDY1616>0)return -1;
		else if(VDY1616<0)
			TEXTURE_HI_START=(YPOS1616>>16)-CLIPYVAL;
	}
	//if(TEXTURE_WI_START<((PRE0>>24)&0xf))
	//        TEXTURE_WI_START=((PRE0>>24)&0xf);
	//TEXTURE_WI_START+=(PRE0>>24)&0xf;
	//if(TEXTURE_WI_START<0)TEXTURE_WI_START=0;
	//if(TEXTURE_HI_START<0)TEXTURE_HI_START=0;
	//if(TEXTURE_HI_LIM>SPRHI)TEXTURE_HI_LIM=SPRHI;
	if(TEXTURE_WI_LIM<=0)return -1;
	return 0;
}

void Init_Scale_Map()
{
 int deltax,deltay;
	TEXEL_FUN_NUMBER=1;
	if(HDX1616<0)
		XPOS1616-=0x8000;
	else if(VDX1616<0)
		XPOS1616-=0x8000;

	if(HDY1616<0)
		YPOS1616-=0x8000;
	else if(VDY1616<0)
		YPOS1616-=0x8000;

	deltax=HDX1616+VDX1616;
	deltay=HDY1616+VDY1616;
	if(deltax<0)TEXEL_INCX=-1;
	else TEXEL_INCX=1;
	if(deltay<0)TEXEL_INCY=-1;
	else TEXEL_INCY=1;

	TEXEL_INCX<<=2;

	TEXTURE_WI_START=0;
	TEXTURE_HI_START=0;
}

void Init_Arbitrary_Map()
{
	TEXEL_FUN_NUMBER=2;
	TEXTURE_WI_START=0;
	TEXTURE_HI_START=0;
}

int __fastcall TexelDraw_Line(unsigned short CURPIX, unsigned short LAMV, int xcur, int ycur, int cnt)
{
	int i=0,j,incx,incy;
	unsigned int pixel;
	unsigned int curr=0xffffffff, next;

	xcur>>=16;
	ycur>>=16;

	for(i=0;i<cnt;i++,xcur+=(HDX1616>>16),ycur+=(HDY1616>>16))
	{
		next=mreadh((PIXSOURCE+XY2OFF((xcur)<<2,ycur,RMOD)));
		if(next!=curr)
		{
			curr=next;
			pixel=PPROC(CURPIX,next,LAMV);
		}
		//pixel=PPROC(CURPIX,mreadh((PIXSOURCE+XY2OFF((xcur>>16)<<2,ycur>>16,RMOD))),LAMV);
		pixel = PPROJ_OUTPUT(CURPIX, pixel, next);
		mwriteh((FBTARGET+XY2OFF((xcur)<<2,ycur,WMOD)),pixel);
	}
 return 0;
}


__inline uint16 readPIX(uint32 src, int i, int j)
{
	src+=XY2OFF((((j)>>(RESSCALE))<<2),(i>>RESSCALE),WMOD);
	if(RESSCALE)
		return *((uint16*)&Mem[(src^2)+(((i&1)<<1)+((j)&1))*1024*1024]);
	return *((uint16*)&Mem[src^2]);
}

__inline void writePIX(uint32 src, int i, int j, uint16 pix)
{
	src+=XY2OFF((((j)>>(RESSCALE))<<2),(i>>RESSCALE),WMOD);
	if(RESSCALE)
		*((uint16*)&Mem[(src^2)+(((i&1)<<1)+((j)&1))*1024*1024])=pix;
	else
		*((uint16*)&Mem[src^2])=pix;
}


int __fastcall TexelDraw_Scale(unsigned short CURPIX, unsigned short LAMV, int xcur, int ycur, int deltax, int deltay)
{
	int i,j;
	unsigned int pixel;
	unsigned int framePixel;
	unsigned int curr=-1, next;

	if((HDX1616<0) && (deltax)<0 && xcur<0)
	{
		return -1;
	}
	else if((HDY1616<0) && (deltay)<0 && ycur<0 )
	{
		return -1;
	}
	else if((HDX1616>0) && (deltax)>(CLIPXVAL) && (xcur)>(CLIPXVAL))
	{
		return -1;
	}
	else if((HDY1616>0) && ((deltay))>(CLIPYVAL) && (ycur)>(CLIPYVAL))
	{
		return -1;
	}
	else
	{
		if((((int)xcur))==(((int)deltax)))return 0;

		for(i=((int)ycur);i!=(((int)deltay));i+=TEXEL_INCY)
			for(j=(((int)xcur))<<2;j!=((((int)deltax))<<2);j+=TEXEL_INCX)
				if((TESTCLIP((j<<14),(i<<16))))
				{
					framePixel = mreadh((PIXSOURCE+XY2OFF(j,i,RMOD)));
					pixel=PPROC(CURPIX,framePixel,LAMV);
					pixel=PPROJ_OUTPUT(CURPIX, pixel, framePixel);
					//next=mreadh((PIXSOURCE+XY2OFF(j,i,RMOD)));
					//if(next!=curr){curr=next;pixel=PPROC(CURPIX,next,LAMV);}
					mwriteh((FBTARGET+XY2OFF(j,i,WMOD)),pixel);

				}
	}
	return 0;
}


__inline int TexelCCWTestSmp(int hdx, int hdy, int vdx, int vdy)
{
	if(((hdx+vdx)*(hdy-vdy)+vdx*vdy-hdx*hdy)<0)return CCB_ACCW;
	return CCB_ACW;
}

int __fastcall TexelDraw_Arbitrary(unsigned short CURPIX, unsigned short LAMV, int xA, int yA, int xB, int yB, int xC, int yC, int xD, int yD)
{
	int miny, maxy, i, itmp, xpoints[4], j, maxyt, maxxt, maxx, minx;
	int updowns[4],cnt_cross, jtmp;
	unsigned int pixel;
	unsigned int curr=-1, next;

	xA>>=(16-RESSCALE);
	xB>>=(16-RESSCALE);
	xC>>=(16-RESSCALE);
	xD>>=(16-RESSCALE);
	yA>>=(16-RESSCALE);
	yB>>=(16-RESSCALE);
	yC>>=(16-RESSCALE);
	yD>>=(16-RESSCALE);

	if((xA)==(xB) && (xB)==(xC) && (xC)==(xD)) return 0;

	maxxt=((CLIPXVAL+1)<<RESSCALE);
	maxyt=((CLIPYVAL+1)<<RESSCALE);

	if(HDX1616<0 && HDDX1616<0)
	{
		if((xA<0) && (xB<0) && (xC<0) && (xD<0))
			return -1;
	}
	if(HDX1616>0 && HDDX1616>0)
	{
		if(((xA)>=maxxt) && ((xB)>=maxxt) && ((xC)>=maxxt) && ((xD)>=maxxt))
			return -1;
	}
	if(HDY1616<0 && HDDY1616<0)
	{
		if((yA<0) && (yB<0) && (yC<0) && (yD<0))
			return -1;
	}
	if(HDY1616>0 && HDDY1616>0)
	{
		if(((yA)>=maxyt) && ((yB)>=maxyt) && ((yC)>=maxyt) && ((yD)>=maxyt))
			return -1;
	}
	
	miny=maxy=yA;
	if(miny>yB)miny=yB;
	if(miny>yC)miny=yC;
	if(miny>yD)miny=yD;
	if(maxy<yB)maxy=yB;
	if(maxy<yC)maxy=yC;
	if(maxy<yD)maxy=yD;

	i=(miny);
	if(i<0)i=0;
	if(maxy<maxyt)maxyt=maxy;


	for(;i<maxyt;i++)
	{

		cnt_cross=0;
		if(i<(yB) && i>=(yA))
		{
			xpoints[cnt_cross]=(int)((quickDivide(((xB-xA)*(i-yA)),(yB-yA))+xA));
			updowns[cnt_cross++]=1;
		}
		else if(i>=(yB) && i<(yA))
		{
			xpoints[cnt_cross]=(int)((quickDivide(((xA-xB)*(i-yB)),(yA-yB))+xB));
			updowns[cnt_cross++]=0;
		}

		if(i<(yC) && i>=(yB))
		{
			xpoints[cnt_cross]=(int)((quickDivide(((xC-xB)*(i-yB)),(yC-yB))+xB));
			updowns[cnt_cross++]=1;
		}
		else if(i>=(yC) && i<(yB))
		{
			xpoints[cnt_cross]=(int)((quickDivide(((xB-xC)*(i-yC)),(yB-yC))+xC));
			updowns[cnt_cross++]=0;
		}

		if(i<(yD) && i>=(yC))
		{
			xpoints[cnt_cross]=(int)((quickDivide(((xD-xC)*(i-yC)),(yD-yC))+xC));
			updowns[cnt_cross++]=1;
		}
		else if(i>=(yD) && i<(yC))
		{
			xpoints[cnt_cross]=(int)((quickDivide(((xC-xD)*(i-yD)),(yC-yD))+xD));
			updowns[cnt_cross++]=0;
		}

		if(cnt_cross&1)
		{
			if(i<(yA) && i>=(yD))
			{
				xpoints[cnt_cross]=(int)((quickDivide(((xA-xD)*(i-yD)),(yA-yD))+xD));
				updowns[cnt_cross]=1;
			}
			else if(i>=(yA) && i<(yD))
			{
				xpoints[cnt_cross]=(int)((quickDivide(((xD-xA)*(i-yA)),(yD-yA))+xA));
				updowns[cnt_cross]=0;
			}
		}

		if(cnt_cross!=0)
		{

			if(xpoints[0]>xpoints[1])
			{
				xpoints[1]+=xpoints[0];
				xpoints[0]=xpoints[1]-xpoints[0];
				xpoints[1]=xpoints[1]-xpoints[0];

				jtmp=updowns[0];
				updowns[0]=updowns[1];
				updowns[1]=jtmp;
			}
			if(cnt_cross>2)
			{
				if( ((CCBFLAGS&CCB_ACW)&&updowns[2]==0) ||
					((CCBFLAGS&CCB_ACCW)&&updowns[2]==1))
				{
					j=xpoints[2];
					if(j<0)j=0;
					maxx=xpoints[3];
					if(maxx>maxxt)maxx=maxxt;
					for(;j<maxx;j++)
					{
						next=readPIX(PIXSOURCE, i, j);
						if(next!=curr){curr=next;
							pixel=PPROC(CURPIX,next,LAMV);
							pixel = PPROJ_OUTPUT(CURPIX, pixel, next);
						}
					writePIX(FBTARGET, i, j, pixel);
					}
				}
	
			}

			if( ((CCBFLAGS&CCB_ACW)&&updowns[0]==0) ||
					((CCBFLAGS&CCB_ACCW)&&updowns[0]==1))
			{
				j=xpoints[0];
				if(j<0)j=0;
				maxx=xpoints[1];
				if(maxx>maxxt)maxx=maxxt;

				for(;j<maxx;j++)
				{
					next=readPIX(PIXSOURCE, i, j);
					if(next!=curr){curr=next;
						pixel=PPROC(CURPIX,next,LAMV);
						pixel=PPROJ_OUTPUT(CURPIX, pixel, next);
						}
					writePIX(FBTARGET, i, j, pixel);
				}
			}

		}

	}

	return 0;
}