m24b_drv.c

与Nucleus Plus配套的图形库

	lclSrcPtr = srcPtr;
	lclLineCnt = lineCntM1;
	pxBitVal = 128 >> (sRect.Xmin & 7);

	while (lclLineCnt-- >= 0)
	{	/* for each row */
		lclByteCnt = byteCntM1;
		pxBit = pxBitVal;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			if (*lclSrcPtr & pxBit)
			{	/* source is 1 */
				pixlVal = *lclDstPtr;
				*lclDstPtr++ = ~pixlVal;
				pixlVal = *lclDstPtr;
				*lclDstPtr++ = ~pixlVal;
				pixlVal = *lclDstPtr;
				*lclDstPtr++ = ~pixlVal;
			}
			else
			{
				lclDstPtr += 3;
			}

			pxBit = pxBit >> 1;
			if (pxBit == 0)
			{
				pxBit = 128;
				lclSrcPtr++;
			}
		}

		lclDstPtr += dstNextRow;	/* advance to next row */
		lclSrcPtr += srcNextRow;
	}

	return;
}


/* Function OXADest1M24B sets the destination pixel data based on
the logical function "OR", "XOR" or "AND". */
void OXADest1M24B(void)
{
	byte *lclDstPtr, pnColrR, pnColrG, pnColrB;
	byte *lclSrcPtr, bkColrR, bkColrG, bkColrB;
	int lclLineCnt, lclByteCnt;
	int logFnc;
	int pxBit;
	int pxBitVal;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclSrcPtr = srcPtr;
	pnColrR = (byte) (pnColr24 >> 16);	/* set up local colors */
	pnColrG = (pnColr24 >> 8) & 0xff;
	pnColrB = pnColr24  & 0xff;
	bkColrR = (byte) (bkColr24 >> 16);
	bkColrG = (bkColr24 >> 8) & 0xff;
	bkColrB = bkColr24  & 0xff;
	lclLineCnt = lineCntM1;
	logFnc = (dstClass & 3);	/* only two lower bits needed */
	pxBitVal = 128 >> (sRect.Xmin & 7);

	while (lclLineCnt-- >= 0)
	{	/* for each row */
		lclByteCnt = byteCntM1;
		pxBit = pxBitVal;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			if (!(*lclSrcPtr & pxBit))
			{	/* source is 0 */
				if ((logFnc == 3) || (*lclDstPtr == 0))
				{	/* "AND" or 0,0 */
				*lclDstPtr++ = bkColrR;
				*lclDstPtr++ = bkColrG;
				*lclDstPtr++ = bkColrB;
				}
				else
				{	/* "OR","XOR" with 0,1 */
				*lclDstPtr++ = pnColrR;
				*lclDstPtr++ = pnColrG;
				*lclDstPtr++ = pnColrB;
				}
			}
			else
			{	/* source is 1 */
				if (logFnc == 1)
				{	/* "OR" with 1,X */
					*lclDstPtr++ = pnColrR;
					*lclDstPtr++ = pnColrG;
					*lclDstPtr++ = pnColrB;
				}
				else
				{
					if (logFnc == 3)
					{	/* "AND" */
						if (*lclDstPtr)
						{	/* "AND", with 1,1 */
							*lclDstPtr++ = pnColrR;
							*lclDstPtr++ = pnColrG;
							*lclDstPtr++ = pnColrB;
						}
						else
						{	/* "AND", with 1,0 */
							*lclDstPtr++ = bkColrR;
							*lclDstPtr++ = bkColrG;
							*lclDstPtr++ = bkColrB;
						}
					}
					else
					{	/* "XOR" */
						if (*lclDstPtr)
						{	/* "XOR", with 1,1 */
							*lclDstPtr++ = bkColrR;
							*lclDstPtr++ = bkColrG;
							*lclDstPtr++ = bkColrB;
						}
						else
						{	/* "XOR", with 1,0 */
							*lclDstPtr++ = pnColrR;
							*lclDstPtr++ = pnColrG;
							*lclDstPtr++ = pnColrB;
						}
					}
				}
			}

			pxBit = pxBit >> 1;
			if (pxBit == 0)
			{
				pxBit = 128;
				lclSrcPtr++;
			}
		}

		lclDstPtr += dstNextRow;	/* advance to next row */
		lclSrcPtr += srcNextRow;
	}

	return;
}


/* Function mwPBAAA24 is a special case optimization for memory
to memory, rectangular clipping with no color translation. */
void mwPBAAA24(blitRcd *blitRec)
{
	int Check_YX_Band_Blit(rect *bandRect, rect *blitRectPtr,
		rect *clipR, int *rectCnt);
	void DrawRectEntryBlitMM24(blitRcd *blitRec);
	int Set_Up_Clip(blitRcd *clipBlit, rect *clipR, int blitMayOverlap,
				int isLine);
	int Blit_Clip_Region(blitRcd *fcRec, rect *fillRect, rect *sRect);
	void nuResume(grafMap *srcBmap);
	void RepDestM24B(void);
	void OXADestM24B(void);
	void SetDestM24B(void);
	void NotDestSolidM24B(void);
	void InvertDestM24B(void);
	void QuickEnd(void);

	rect clipR;	/* Clip rect */
	rect *rListPtr;	/* list pointer */
	int blitMayOverlap = 1;	/* Set true for region clipping*/
	int isLine = 0;	/* Set false */

	rectCnt =  blitRec->blitCnt;
	rListPtr =  (rect *) blitRec->blitList;
	srcBmap =  blitRec->blitSmap;
	srcPixBytes = srcBmap->pixBytes;

	M_PAUSE(srcBmap);	/* pause the source */

	bkColr24 = blitRec->blitBack;	/* background color */
	pnColr24 = blitRec->blitFore;	/* foreground color */

	dstBmap =  blitRec->blitDmap;
	dstClass = blitRec->blitRop & 0x0f;

	M_PAUSE(dstBmap);

	switch (dstClass)
	{	/* look up the optimization routine */
	  			    /* LCD non-transparent */
	case 0:		/* zREPz   :           src			 */
	case 4:		/* zNREPz  :        (NOT src)		 */
		optPtr = &RepDestM24B;
		break;
	case 1:		/* zORz    :       src OR  dst		 */
	case 2:		/* zXORz   :       src XOR dst		 */
	case 3:		/* zNANDz  :    (NOT src) AND dst	 */
	case 5:		/* zNORz   :    (NOT src) OR  dst	 */
	case 6:		/* zNXORz  :    (NOT src) XOR dst	 */
	case 7:		/* zANDz   :       src AND dst		 */
		optPtr = &OXADestM24B;
		break;
	case 8:		/* zCLEARz :           0's			 */
	case 12:	/* zSETz   :           1's			 */
		optPtr = &SetDestM24B;
		break;
	case 9:		/* zORNz   :     src OR  (NOT dst)	 */
	case 11:	/* zANDNz  :     src AND (NOT dst)	 */
	case 13:	/* zNORNz  : (NOT src) OR  (NOT dst) */
	case 15:	/* zNANDNz : (NOT src) AND (NOT dst) */
		optPtr = &NotDestSolidM24B;
		break;
	case 10:	/* zNOPz   :           dst <NOP>	 */
		optPtr = &QuickEnd;
		break;
	case 14:	/* zINVERTz:        (NOT dst)		 */
		optPtr = &InvertDestM24B;
		break;
	}

	/* modify the pen color as necessary */
	switch (dstClass)
	{
	case 3:	/* zNANDz */
	case 4:	/* zNREPz */
	case 5:	/* zNORz */
	case 6:	/* zNXORz */
	case 13:	/* zNORNz */
	case 15:	/* zNANDNz */
		pnColr24 = -1;	/* this has the effect of notting the
					pen color for all operations during this call */
	case 0:	/* zREPz */
	case 1:	/* zORz */
	case 2:	/* zXORz */
	case 7:	/* zANDz */
	case 9:	/* zORNz */
	case 10:	/* zNOPz */
	case 11:	/* zANDNz */
		pnColr24 = 0;
		break;
	case 8:	/* zCLEARz */
		pnColr24 = 0;	/* sets all source bits to 0 */
		break;
	case 12:	/* zSETz */
	case 14:	/* zINVERTz */
		pnColr24 = -1;	/* sets all source bits to 1 */
	}

	/* set up clipping */
	if (Set_Up_Clip(blitRec, &clipR, blitMayOverlap, isLine))
		goto PB_RTN;

	while (--rectCnt >= 0 )
	{
		sRect = *rListPtr++;
		dRect = *rListPtr++;
		if (clipToRectFlag != 0)	/* do we need to worry about clipping */
		{	/* yes, do trivial reject */
			if (dRect.Xmin < clipR.Xmin)
			{	/* Reset src & dst Xmin clip limit */
				sRect.Xmin -= (dRect.Xmin - clipR.Xmin);
				dRect.Xmin  = clipR.Xmin;
			}
			if (dRect.Ymin < clipR.Ymin)
			{	/* Reset src & dst Ymin clip limit */
				sRect.Ymin -= (dRect.Ymin - clipR.Ymin);
				dRect.Ymin  = clipR.Ymin;
			}
			if (dRect.Xmax > clipR.Xmax)
			{	/* Reset src & dst Xmax clip limit */
				sRect.Xmax -= (dRect.Xmax - clipR.Xmax);
				dRect.Xmax  = clipR.Xmax;
			}
			if (dRect.Ymax > clipR.Ymax)
			{	/* Reset src & dst Ymax clip limit */
				sRect.Ymax -= (dRect.Ymax - clipR.Ymax);
				dRect.Ymax  = clipR.Ymax;
			}
			
			if (dRect.Ymin >= dRect.Ymax)
			{	/* Check to see whether the rectangle was trivially
				clipped because it was fully below the clip rect,
				in which case we can discard the rest of a YX banded
				blitList, or because it was fully above the clip
				rect, in which case we can whiz ahead through a YX
				banded blitList until we run out of rects or find a
				rect that isn't fully above the clip rect. */
				if (Check_YX_Band_Blit(&dRect, rListPtr, &clipR,
					   &rectCnt)) break;
				continue;
			}
			
			if (dRect.Xmin >= dRect.Xmax) continue;

			/* do we need to worry about region clipping? */
			if (clipToRegionFlag != 0)
			{	/* yes */
				FillDrawer = &DrawRectEntryBlitMM24;
				if (Blit_Clip_Region(blitRec, &dRect, &sRect)
					== 0) break;
				continue;
			}
		}
		
		DrawRectEntryBlitMM24(blitRec);	/* blit the rectangle */
	}

PB_RTN:
	nuResume(srcBmap);
	nuResume(dstBmap);
	return;
}


/* Function DrawRectEntryBlitMM24 blits the rectangle to the memory */
void DrawRectEntryBlitMM24(blitRcd *blitRec)
{

	lineCntM1 = dRect.Ymax - dRect.Ymin - 1;
	srcBgnByte = 3 * sRect.Xmin;
	dstBgnByte = 3 * dRect.Xmin;
	byteCntM1 = dRect.Xmax - dRect.Xmin - 1;
	srcNextRow = srcPixBytes - (3 * byteCntM1) - 3;
	dstNextRow = dstBmap->pixBytes - (3 * byteCntM1) - 3;

	dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymin))
				+ dstBgnByte;
	srcPtr = (byte *) (*(srcBmap->mapTable[0] + sRect.Ymin))
				+ srcBgnByte;
	optPtr();	/* blit the rectangle */

	return;
}


/* Function NotDestSolidM24B handles memory "not dst" by inverting the
destination first. */
void NotDestSolidM24B(void)
{
	void InvertDestM24B(void);
	void OXADestM24B(void);

	InvertDestM24B();

	OXADestM24B();	/* fill this rectangle */

	return;
}


/* Function RepDestM24B sets the destination pixel data with the
source data. */
void RepDestM24B(void)
{
	byte *lclDstPtr, pnColrR, pnColrG, pnColrB;
	byte *lclSrcPtr;
	int lclLineCnt, lclByteCnt;

	pnColrR = (byte) (pnColr24 >> 16);	/* set up local colors */
	pnColrG = (pnColr24 >> 8) & 0xff;
	pnColrB = pnColr24  & 0xff;
	if ((dstBmap == srcBmap) && ((sRect.Ymin < dRect.Ymin) ||
		((sRect.Ymin == dRect.Ymin) && (sRect.Xmin < dRect.Xmin))))
	{	/* blit bottom to top, right to left */
		lclDstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymax))
			+ (3 * dRect.Xmax) + 2;
		lclSrcPtr = (byte *) (*(dstBmap->mapTable[0] + sRect.Ymax))
			+ (3 * sRect.Xmax) + 2;
		lclLineCnt = lineCntM1;

		while (lclLineCnt-- >= 0)
		{	/* for each row */
			lclByteCnt = byteCntM1;
			while (lclByteCnt-- >= 0)
			{	/* for each byte in the row */
				*lclDstPtr-- = pnColrB ^ *lclSrcPtr--;
				*lclDstPtr-- = pnColrG ^ *lclSrcPtr--;
				*lclDstPtr-- = pnColrR ^ *lclSrcPtr--;
			}

			lclDstPtr -= dstNextRow;	/* advance to next row */
			lclSrcPtr -= srcNextRow;
		}
	}
	else
	{	/* blit top to bottom, left to right */
		lclDstPtr = dstPtr;	/* set up local pointers */
		lclSrcPtr = srcPtr;
		lclLineCnt = lineCntM1;

		while (lclLineCnt-- >= 0)
		{	/* for each row */
			lclByteCnt = byteCntM1;
			while (lclByteCnt-- >= 0)
			{	/* for each byte in the row */
				*lclDstPtr++ = pnColrR ^ *lclSrcPtr++;
				*lclDstPtr++ = pnColrG ^ *lclSrcPtr++;
				*lclDstPtr++ = pnColrB ^ *lclSrcPtr++;
			}

			lclDstPtr += dstNextRow;	/* advance to next row */
			lclSrcPtr += srcNextRow;
		}
	}

	return;
}


/* Function OXADestM24B sets the destination pixel data based on
the logical function "OR", "XOR" or "AND". */
void OXADestM24B(void)
{
	byte *lclDstPtr, pnColrR, pnColrG, pnColrB;
	byte *lclSrcPtr;
	int lclLineCnt, lclByteCnt;
	int logFnc, locColr;

	pnColrR = (byte) (pnColr24 >> 16);	/* set up local colors */
	pnColrG = (pnColr24 >> 8) & 0xff;
	pnColrB = pnColr24  & 0xff;
	if ((dstBmap == srcBmap) && ((sRect.Ymin < dRect.Ymin) ||