mqaafont.blt

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

//#pragma optimize("", off)

#ifdef	AAFONT_ON
#if 0
SCODE MQGC::AAFontBlt8( GPEBltParms *pBltParms )
{
	RETURN_AAFONT8;
}
#endif

#if defined( CHECK_8BPP ) || defined( CHECK_16BPP )
SCODE MQGC::AAFontBlt( GPEBltParms *pBltParms )
{
	DEBUGMSG(GPE_ZONE_MQEMUL1,(TEXT("AAFontBlt\r\n")));
	
	ROTATE_PARAMS(pBltParms);

	geINIT( pBltParms->pDst );

	PULONG		pulSrc;
	ULONG		dstxy, width, height, ulBitSpace, ulOffset;
	ULONG		ulDWords, ulExtras, width2, left2;
	long		lSrcStride, i;

	width = pBltParms->prclDst->right - pBltParms->prclDst->left;
	width2 = width << 2;

	dstxy = ((pBltParms->prclDst->top << 16) | pBltParms->prclDst->left)
			+ ((MQGCSurf *)(pBltParms->pDst))->m_ulTopLeft;
	height = pBltParms->prclDst->bottom - pBltParms->prclDst->top;

	//m_pSrc already points to pBltParms->pMask
	lSrcStride = pBltParms->pMask->Stride();
	i = (long)(pBltParms->pMask->Buffer())
						+ (pBltParms->prclMask->top * lSrcStride);

	//Compute src start in bits first, then dword-align src start.
	//This will get us the total bit offset aligned to dword.
	left2 = pBltParms->prclMask->left << 2;
	ulOffset = ((i & 0x03UL) << 3) + left2;
	pulSrc = (PULONG)(((i & ~0x03UL) + (ulOffset >> 3)) & ~0x03UL);
	ulOffset &= 0x01FUL;		//SrcBits already adjusted to closest
								//  dword aligned.  Adjust offset to 32bit too.

//DebugBreak();
#ifdef BUG_AAFONT16
	if ( (16 == m_ulBPP) && !(width & 0x0FUL) )
	{
		//Guarantee to be only 16bpp.  Use lined mode.
		PULONG		pulSrcBits;
	#ifdef CHECK_SRCFIFO
		ULONG		ulSegmentCnt, ulSegmentLeft, ulSegmentLeftTotal;
	#endif
		ULONG		i;

		lSrcStride = lSrcStride >> 2;
		ulDWords = (ulOffset + width2 + 31) & ~0x1FUL;	//32 bit aligned
		ulExtras = (ulDWords + 127) & ~0x7FUL;			//128bit aligned
		ulOffset = (ulExtras >> 3)						//src stride in bytes
				 		+ ((ulOffset & 0x03FUL) << 25);	//  aligned
		ulDWords = ulDWords >> 5;
		ulExtras = (ulExtras >> 5) - ulDWords;
	#ifdef CHECK_SRCFIFO
		ulSegmentCnt = ulDWords >> 5;					//32 dwords depth
		ulSegmentLeft = ulDWords & 0x1FUL;
		ulSegmentLeftTotal = ulSegmentLeft + ulExtras;
	#endif

		geWAITCMDFIFO( 5 );
		geREG(WIDTH_HEIGHT,			((height << 16) | width));
		geREG(DEST_XY,				dstxy);
		geREG(FG_COLOR,				pBltParms->solidColor);
		geREG(SRC_STRIDE_OFFSET,	ulOffset);
		SET_GE_DEST_STRIDE(m_ulDestStride);
		geREG(DRAW_CMD,				(DO_AAFONT | SRC_IS_MEMORY | MONO_SRC |
									 SRC_NE_DEST_STRIDE | TRANS_MONO | 0x22UL));

		while( height-- )
		{
			pulSrcBits = pulSrc;
	#ifdef CHECK_SRCFIFO
			for( i = 0; i < ulSegmentCnt; i++ )
				geSRCFIFO16(pulSrcBits);
			geWAITSRCFIFO( ulSegmentLeftTotal );
			for( i = 0; i < ulSegmentLeft; i++ )
				geREG(SRC_IMAGE_DATA, *pulSrcBits++);
	#else	//CHECK_SRCFIFO
			for( i = 0; i < ulDWords; i++ )
				geREG(SRC_IMAGE_DATA, *pulSrcBits++);
	#endif	//CHECK_SRCFIFO
			for( i = 0; i < ulExtras; i++ )
				geREG(SRC_IMAGE_DATA, 0UL);
			pulSrc += lSrcStride;		//lSrcStride in dword increments
		}
	}
	else
#endif	//BUG_AAFONT16
	{
		ULONG		ulSpace;
	#ifdef CHECK_SRCFIFO
		ULONG		ulExtras2;
	#endif	//CHECK_SRCFIFO

		//Compute bit space.
		//For AAF0 Rop4, src stride always > 0
		lSrcStride = lSrcStride << 3;
		ulSpace = lSrcStride - width2;
		if ( ulSpace <  64 )
			ulBitSpace = ulSpace;
		else
		{
			ulBitSpace = (ULONG)((-(long)(left2+width2)) & 0x1FUL)
								+ ((lSrcStride + left2) & 0x1FUL);
			if ( ulBitSpace < 32 )
				ulBitSpace += 32;
		}

		geWAITCMDFIFO( 5 );
		geREG(WIDTH_HEIGHT,			((height << 16) | width));
		geREG(DEST_XY,				dstxy);
		geREG(FG_COLOR,				pBltParms->solidColor);
		geREG(SRC_STRIDE_OFFSET,	(ulOffset | (ulBitSpace << 25)));
		SET_GE_DEST_STRIDE(m_ulDestStride);
		geREG(DRAW_CMD,				(DO_AAFONT | SRC_IS_MEMORY | MONO_SRC
									| TRANS_MONO | PACKED_MODE | 0x22UL));

		if ( ulSpace < 64 )
		{
			//Really Packed
			//Src data packed.  Calculate total and extra dwords first.
		#if 0							//Don't use multiply operator
			ulBitSpace += width2;
			ulDWords = width2 + ulOffset;
			while( --height )
				ulDWords += ulBitSpace;
			ulDWords = (ulDWords + 31L) >> 5;
		#else
			ulDWords = (((width2 + ulBitSpace) * (height - 1)) + width2
						+ ulOffset + 31L) >> 5;
		#endif
		#ifdef CHECK_SRCFIFO
			ulExtras = ulDWords & 0x1FUL;
			ulExtras2 = ((ULONG)(-(long)ulExtras)) & 0x03;
			ulDWords = ulDWords >> 5;		//number of 32 dwords;

			while( ulDWords-- )
			{
				i = 32;
				geWAITSRCFIFO( 32 );
				while( i-- )
					geSID( (*pulSrc++) );
			}
			if ( ulExtras )
			{
				geWAITSRCFIFO( ulExtras );
				while ( ulExtras-- )
					geSID( (*pulSrc++) );
				while ( ulExtras2-- )
					geSID( 0UL );
			}
		#else	//CHECK_SRCFIFO
			ulExtras = -(long)ulDWords & 0x3UL;
			while( ulDWords-- )
				geSID( (*pulSrc++) );
			while( ulExtras-- )
				geSID( 0UL );
		#endif	//CHECK_SRCFIFO

			//PUMP_REALLY_PACKED_SRCFIFO(pulSrc, ulDWords, lExtras)
		}
		else
		{
			ulExtras = 0;
			ulBitSpace += width2;					//Added width
			while( height-- )
			{
				ulSpace = (ULONG)pulSrc;			//Use ulSpace as temp var

				if ( height > 0 )
					ulDWords = (ulOffset + ulBitSpace) >> 5;
				else
					ulDWords = (ulOffset + width2 + 31) >> 5;
				ulExtras += ulDWords;
		#ifdef CHECK_SRCFIFO
				ulExtras2 = ulDWords & 0x1fL;
				ulDWords = ulDWords >> 5;				//number of 32 dwords
				while( ulDWords-- )
				{
					i = 32;
					geWAITSRCFIFO( 32 );
					while( i-- )
						geSID( (*pulSrc++) );
				}
				if ( ulExtras2 )
				{
					geWAITSRCFIFO( ulExtras2 );
					while( ulExtras2-- )
						geSID( (*pulSrc++) );
				}
		#else	//CHECK_SRCFIFO
				while( ulDWords-- )
					geSID( (*pulSrc++) );
		#endif	//CHECK_SRCFIFO

				//For AAF0 Rop4, SrcStride always > 0
				i = lSrcStride + (long)ulOffset;	//Advance bit offset
				pulSrc = (PULONG)((long)ulSpace + ((i & ~0x1F) >> 3));
													//lSpace has prev pulSrc
				ulOffset = (ULONG)(i & 0x1FL);		//only keep 32bit offset
			}

			//No need to wait for srcfifo here since any previous call to
			//wait-for-srcfifo actually waits for 128bit aligned number of slots
			ulExtras = (ULONG)(-(long)ulExtras) & 0x03UL;
			while( ulExtras-- )
				geSID( 0UL );						//Padded to total of 128bit
													//aligned
			//PUMP_PACKED_SRCFIFO(pulSrc, ulDWords, lExtras, ulDWordsTotal,
			//		lSrcStride, height)
		}
	}	//Packed Mode
	geTERMINATE();
	
	ROTATE_PARAMS_BACK(pBltParms);

#if 0	//def DEBUG	//HSUTEST
	{
		ULONG	loop, status;
		loop = 200UL;
		while( loop-- )
		{
			status = cpuREAD( DRAW_STATUS );
			if ( !(status & GE_BUSY) )
				break;
		}
		if ( status & GE_BUSY )
			DebugBreak();
	}
#endif

	RETURN_AAFONT;
}
#endif	//CHECK_s
#endif	//AAFONT_ON

//#pragma optimize("", on)