vesadci.c

超级解霸源代码。纯c语言写的。适合有一定编程基础的开发人员用来学习提高

		return;
		}
}
extern	RECT	SrcRect;
extern	RECT	VideoRc;
extern	DCIOFFSCREEN	DCISurfaceScreen;	//Offscreen or primary
extern	int	Caputuring;
DCIRVAL	CALLBACK _loadds SetDestination(LPVOID lpSurface,LPRECT lprDst,LPRECT lprSrc)
{
	if(Caputuring) return 0;
	VCDHigh=lprSrc->bottom-lprSrc->top;
	if(VCDHigh<0) VCDHigh=240;
	if(VCDHigh==240) DeleteLine=5;//240
	else DeleteLine=3;	//288
	SrcRect.top=lprSrc->top;
	SrcRect.left=lprSrc->left;
	SrcRect.bottom=lprSrc->bottom;
	SrcRect.right=lprSrc->right;
	//////// Set Destination /////////
//	DCISurfaceScreen.dciInfo.dwHeight=lprSrc->bottom-lprSrc->top;
	if(DCISurfaceScreenPtr!=NULL)
		{//The Pointer not be NULL
		DCISurfaceScreenPtr->dciInfo.dwHeight=lprSrc->bottom-lprSrc->top;
		if(DCIType==2)	(*DCISurfaceScreenPtr->SetDestination)(DCISurfaceScreenPtr,lprDst,lprSrc);
		}
	return 0;
}
extern	RGNDATA	RgnData;
static	void	Align4(void)
{
}
DCIRVAL	CALLBACK _loadds SetClipList(LPVOID lpSurface,LPRGNDATA lpClipList)
{
	if(Caputuring) 	return 0;
	if(DCISurfaceScreenPtr!=NULL)
		{//The Pointer not be NULL
		if(DCIType==2)	(*DCISurfaceScreenPtr->SetCliplist)(DCISurfaceScreenPtr,lpClipList);
		}
	return 0;
}
#pragma	warn .par

DCIPRIMARY	Primary;
DCIOFFSCREEN	OffScreen;
DCISURFACEINFO	SurFace;
int	DCISupport(LPDCIENUMINPUT lpInput,DWORD far *lpvOutData)
{
	if(lpInput->dcicmd.dwVersion!=0x100) return -4;
	if(lpInput->dcicmd.dwCommand==4)//DCI ENUM
		{
		void PASCAL far (*CallBackDCI)(LPVOID lpContext,LPDCISURFACEINFO lpSurface);
		CallBackDCI=(void PASCAL far (*)())lpInput->EnumCallback;
		SurFace.dwSize=sizeof(SurFace);
		/////////// YV12 /////////
		SurFace.dwDCICaps=0x3401;
		SurFace.dwCompression=0x32315659;	//'YV12'
		SurFace.dwMask[0]=0;
		SurFace.dwMask[1]=0;
		SurFace.dwMask[2]=0;
		SurFace.dwWidth=ScrWidth;		// Window Width
		SurFace.dwHeight=ScrHigh;		// High
		SurFace.lStride=LineWidth;		// Line Width
		SurFace.dwBitCount=12;			// Color Deep.
		(*CallBackDCI)(&SurFace,lpInput->lpContext);
		/////////// RGB //////////////
		SurFace.dwDCICaps=0x3041;
		if(PixelBits==16)//64K Color
			{
			SurFace.dwCompression=3;
			SurFace.dwMask[0]=0xF800;
			SurFace.dwMask[1]=0x7E0;
			SurFace.dwMask[2]=0x1F;
			}
		else	{//Not RGB 16 bits.
			SurFace.dwCompression=0;
			SurFace.dwMask[0]=0;
			SurFace.dwMask[1]=0;
			SurFace.dwMask[2]=0;
			}
		SurFace.dwWidth=ScrWidth;		// Window Width
		SurFace.dwHeight=ScrHigh;		// High
		SurFace.lStride=LineWidth;		// Line Width
		SurFace.dwBitCount=PixelBits;		// Color Deep.
		(*CallBackDCI)(&SurFace,lpInput->lpContext);
		return 0;
		}
	if(lpInput->dcicmd.dwCommand==1)//DCI Create Primary
		{
		if(lpvOutData==NULL) return -4;
		*lpvOutData=(DWORD)(LPSTR)&Primary;
		Primary.dwSize	=sizeof(Primary);
		Primary.dwDCICaps=0x50;
		if(PixelBits==16)//64K Color
			{
			Primary.dwCompression=3;
			Primary.dwMask[0]=0xF800;
			Primary.dwMask[1]=0x7E0;
			Primary.dwMask[2]=0x1F;
			}
		else	{//Not RGB 16 bits.
			Primary.dwCompression=0;
			Primary.dwMask[0]=0;
			Primary.dwMask[1]=0;
			Primary.dwMask[2]=0;
			}
		Primary.dwWidth		=ScrWidth;	//Width
		Primary.dwHeight	=ScrHigh;	//High
		Primary.lStride		=LineWidth;	//Line byte width
		Primary.dwBitCount	=PixelBits;	//Color deep 16 Bits
		Primary.dwOffSurface	=0;
		Primary.dwSelSurface	=Linear;	//Linear Buffer;
		Primary.dwReserved1	=0;
		Primary.dwReserved2	=0;
		Primary.dwReserved3	=0;
		Primary.BeginAccess	=BeginAccess;
		Primary.EndAccess	=EndAccess;
		Primary.DestroySurface	=DestroySurface;
		return 0;
		}
	if(lpInput->dcicmd.dwCommand==2)//DCI Create OffSurface
		{
		LPDCICREATEINPUT lpCreateOffscreen;
		if(lpvOutData==NULL) return -4;
		OffScrSel=GlobalAlloc(GMEM_MOVEABLE,sizeof(VIDEODATA));
		if(OffScrSel==NULL) return -4;
		lpCreateOffscreen=(LPDCICREATEINPUT)lpvOutData;
		*lpvOutData=(DWORD)(LPSTR)&OffScreen;
		OffScreen.dciInfo.dwSize=sizeof(OffScreen);
		OffScreen.dciInfo.dwDCICaps=0x50;
		OffScreen.dciInfo.dwCompression=0;
		OffScreen.dciInfo.dwMask[0]=0;
		OffScreen.dciInfo.dwMask[1]=0;
		OffScreen.dciInfo.dwMask[2]=0;
		OffScreen.dciInfo.dwWidth	=lpCreateOffscreen->dwWidth;	//Width
		OffScreen.dciInfo.dwHeight	=lpCreateOffscreen->dwHeight;	//High
		OffScreen.dciInfo.lStride	=lpCreateOffscreen->dwWidth;	//Line byte width
		OffScreen.dciInfo.dwBitCount	=12;	//Color deep 16 Bits
		OffScreen.dciInfo.dwOffSurface	=0;
		OffScreen.dciInfo.dwSelSurface	=OffScrSel;//Offscreen Buffer;
		OffScreen.dciInfo.dwReserved1	=0;
		OffScreen.dciInfo.dwReserved2	=0;
		OffScreen.dciInfo.dwReserved3	=0;
		OffScreen.dciInfo.BeginAccess	=0;//BeginAccess;
		OffScreen.dciInfo.EndAccess	=0;//EndAccess;
		OffScreen.dciInfo.DestroySurface=DestroySurface;
		if(DCIType==2)	OffScreen.Draw	=DrawYUVDCI;// DCI YUV->RGB
		else 	OffScreen.Draw	=DrawYVURGB;	//My YUV->RGB
		OffScreen.SetCliplist	=SetClipList;
		OffScreen.SetDestination=SetDestination;
		return 0;
		}
	return -4;
}
void huge TurnOffEscape(void);
void huge TurnOnEscape(void);
int  _huge _pascal MyEscape(HDC hdc,int nEscape,int cbInput,
			LPCSTR	lpszInData,void FAR * lpvOutData)
{
	int	Ret;
	if(nEscape==QUERYESCSUPPORT && cbInput==2)
		{	//Support DCI
		if(*(int far *)lpszInData==0x0C03)
			return	1;
		}
	if(nEscape==0x0C03)
		{
		return 	DCISupport((LPDCIENUMINPUT)lpszInData,(DWORD far *)lpvOutData);
		}
	TurnOnEscape();
	Ret=Escape(hdc,nEscape,cbInput,lpszInData,lpvOutData);
	TurnOffEscape();
	return Ret;
}
#pragma warn .par
unsigned char   Code[10];
void huge TurnOffEscape(void)
{
	unsigned char far       *CallAdr;
	unsigned char far       *PtrAdr;
	unsigned long           Here;
	int     Sel;

	if(*(unsigned long *)Code==0L)
		{
		CallAdr=(unsigned char far *)Escape;// Read Old ernter Point
		PtrAdr=Code;
		*PtrAdr++=*CallAdr++;
		*((unsigned long far *)PtrAdr)=*(unsigned long far *)CallAdr;
		}

	PtrAdr=(unsigned char far *)Escape;
	Sel=FP_SEG(PtrAdr);
	PrestoChangoSelector(Sel,Sel);
	Here=(unsigned long)MyEscape;
	*PtrAdr++=0xEA;
	*((unsigned long far *)PtrAdr)=Here;
	PrestoChangoSelector(Sel,Sel);
}

void huge TurnOnEscape(void)
{
	unsigned char far       *PtrAdr;
	unsigned char far       *CallAdr;
	int     Sel;

	if(*(unsigned long *)Code==0L)
		{
		return;
		}
	PtrAdr=(unsigned char far *)Escape;// Restore Old enter point
	CallAdr=Code;
	Sel=FP_SEG(PtrAdr);
	PrestoChangoSelector(Sel,Sel);
	*PtrAdr++=*CallAdr++;
	*((unsigned long far *)PtrAdr)=*(unsigned long far *)CallAdr;
	PrestoChangoSelector(Sel,Sel);
}
/////////////////////////////////////////
void far (*TrapIO)(void);
void far *GetAPIEntry(int VxD_ID)
{       //if Not support return NULL
	void far *APIPtr;

	_ES=_DI=0;
	_BX=VxD_ID;
	_AX=0x1684;
	geninterrupt(0x2F);
	APIPtr=MK_FP(_ES,_DI);
	return  APIPtr;
}
DWORD	GetBasePage(DWORD Base,DWORD Limit)
{
	_EDX=Limit;
	_EBX=Base;
	_AX=0x00;
	(*TrapIO)();
	return	(DWORD)MK_FP(_DX,_AX);
}
void	VxDSet128KBuffer(void)
{
	_AX=0x01;
	(*TrapIO)();
}
void	VxDSet64KBuffer(void)
{
	_AX=0x01;
	(*TrapIO)();
}
/////////////////////////////////////////
DWORD	VideoBase;
DWORD	VideoPhysBase;
void	SetVideoBufferBase(DWORD Base)
{
	VideoPhysBase=Base;
	VideoBase=GetBasePage(VideoPhysBase,0x20000L);
	SetSelectorBase(Linear,VideoBase);//Base A0000-BFFFF or linear addressing
}
HGLOBAL	VideoShadow;
WORD	A000Buffer;
extern	int	VideoCardType;
extern	int	LinearFlags;
int 	SetDCI(int ScrW,int ScrH,int LineW,int ColorBits)
{
	if(DCIType==2)	return 1;	//YUV->RGB support
	A000Buffer=FP_OFF(__A000H);		//Screen Buffer as A000 Segment.
	if(VESAColor!=8)
		if(VESAColor==64 || VESAColor==32)
		{//S3 86 Banking or 640x240 banking
		ScrWidth=ScrW;
		ScrHigh=ScrH;
		LineWidth=LineW;	//Line Byte Width.
		PixelBits=ColorBits;
//		VideoShadow=GlobalAlloc(GMEM_MOVEABLE,153600L);//320*240*2
//		if(VideoShadow==NULL)	return 0;//false
		Linear=A000Buffer;//VideoShadow;
		return 1;
		}
	TrapIO=GetAPIEntry(0x0543);	// TrapIO_ID = 0x678
	if((long)TrapIO==0)
		{
		MessageBox(NULL,"No Base Support Vxd","Error",MB_OK);
		return 0;
		}
	Linear=A000Buffer;
	Linear=AllocSelector(Linear);	//Allocate a Selector.
	SetSelectorLimit(Linear,0x1FFFF);//12K;
	SetVideoBufferBase(0xA0000);	//Set Video buffer base.
	LinearFlags=1;	//Can write to 128K
	//////////////////////
	ScrWidth=ScrW;
	ScrHigh=ScrH;
	LineWidth=LineW;	//Line Byte Width.
	PixelBits=ColorBits;
	//////////////////////
	return 1;
}

void	ReleaseDCI(void)
{
	WORD	ScrSel;
	if(DCIType==2)	return;	//YUV->RGB support
	if(VESAColor==64 || VESAColor==32)
		{//free video shadow buffer
//		GlobalFree(VideoShadow);
		return;
		}
	ScrSel=FP_OFF(__A000H);
	SetSelectorLimit(Linear,GetSelectorLimit(ScrSel));
	SetSelectorBase(Linear,GetSelectorBase(ScrSel));
	FreeSelector(Linear);//Free it.
}