m8b_drv.c

nucleus 文件系统,内核和彩色图形系统,在小系统上非常好用

	int pxBitVal;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclSrcPtr = srcPtr;
	lclLineCnt = lineCntM1;
	logFnc = (dstClass & 3);	/* only two lower bits needed */

/* BobB 5/6/98 - changed the following line
	pxBit = 128 >> (sRect.Xmin & 7); */
	pxBitVal = 128 >> (sRect.Xmin & 7);

	while (lclLineCnt-- >= 0)
	{	/* for each row */
		lclByteCnt = byteCntM1;
/* BobB 5/6/98 - added the following line: */
		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 = bkColr;
				}
				else
				{	/* "OR","XOR" with 0,1 */
					*lclDstPtr = pnColr;
				}
			}
			else
			{	/* source is 1 */
				if (logFnc == 1)
				{	/* "OR" with 1,X */
					*lclDstPtr = pnColr;
				}
				else
				{
					if (logFnc == 3)
					{	/* "AND" */
						if (*lclDstPtr)
						{	/* "AND", with 1,1 */
							*lclDstPtr = pnColr;
						}
						else
						{	/* "AND", with 1,0 */
							*lclDstPtr = bkColr;
						}
					}
					else
					{	/* "XOR" */
						if (*lclDstPtr)
						{	/* "XOR", with 1,1 */
							*lclDstPtr = bkColr;
						}
						else
						{	/* "XOR", with 1,0 */
							*lclDstPtr = pnColr;
						}
					}
				}
			}

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

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

	return;
}


/* Function mwPBAAA is a special case optimization for memory
to memory, rectangular clipping with no color translation. */
void mwPBAAA(blitRcd *blitRec)
{
	int Check_YX_Band_Blit(rect *bandRect, rect *blitRectPtr,
		rect *clipR, int *rectCnt);
	void DrawRectEntryBlitMM(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 RepDestM8B(void);
	void OXADestM8B(void);
	void SetSrcLCD(void);
	void NotDestSolidM8B(void);
	void InvertSrcLCD(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 */

	bkColr = (char) blitRec->blitBack;	/* background color */
	pnColr = (char) 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 = &RepDestM8B;
		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 = &OXADestM8B;
		break;
	case 8:		/* zCLEARz :           0's			 */
	case 12:	/* zSETz   :           1's			 */
		optPtr = &SetSrcLCD;
		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 = &NotDestSolidM8B;
		break;
	case 10:	/* zNOPz   :           dst <NOP>	 */
		optPtr = &QuickEnd;
		break;
	case 14:	/* zINVERTz:        (NOT dst)		 */
		optPtr = &InvertSrcLCD;
		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 */
		pnColr = (char)-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 */
		pnColr = 0;
		break;
	case 8:	/* zCLEARz */
		pnColr = 0;	/* sets all source bits to 0 */
		break;
	case 12:	/* zSETz */
	case 14:	/* zINVERTz */
		pnColr = (char)-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 = &DrawRectEntryBlitMM;
				if (Blit_Clip_Region(blitRec, &dRect, &sRect)
					== 0) break;
				continue;
			}
		}
		
		DrawRectEntryBlitMM(blitRec);	/* blit the rectangle */
	}

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


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

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

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

	return;
}


/* Function NotDestSolidM8B handles memory "not dst" by inverting the
destination first. */
void NotDestSolidM8B(void)
{
	void InvertSrcLCD(void);
	void OXADestM8B(void);

	InvertSrcLCD();

	OXADestM8B();	/* fill this rectangle */

	return;
}


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

	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))
			+ dRect.Xmax;
		lclSrcPtr = (byte *) (*(dstBmap->mapTable[0] + sRect.Ymax))
			+ sRect.Xmax;
		lclLineCnt = lineCntM1;

		while (lclLineCnt-- >= 0)
		{	/* for each row */
			lclByteCnt = byteCntM1;
			while (lclByteCnt-- >= 0)
			{	/* for each byte in the row */
				*lclDstPtr-- = pnColr ^ *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++ = pnColr ^ *lclSrcPtr++;
			}

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

	return;
}


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

	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))
			+ dRect.Xmax;
		lclSrcPtr = (byte *) (*(dstBmap->mapTable[0] + sRect.Ymax))
			+ sRect.Xmax;
/* BobB 11/10/99 - removed extra line
		lclLineCnt = lineCntM1;*/
		lclLineCnt = lineCntM1;
		logFnc = (dstClass & 3);	/* only two lower bits needed */

		while (lclLineCnt-- >= 0)
		{	/* for each row */
			lclByteCnt = byteCntM1;
			while (lclByteCnt-- >= 0)
			{	/* for each byte in the row */
				locColr = pnColr ^ *lclSrcPtr--;
				switch (logFnc)
				{
				case 0:	/* can't happen */
				case 1:	/* "OR" */
					locColr = locColr | *lclDstPtr;
					*lclDstPtr = locColr;
					break;
				case 2:	/* "XOR" */
					locColr = locColr ^ *lclDstPtr;
					*lclDstPtr = locColr;
					break;
				case 3:	/* "AND" */
					locColr = locColr & *lclDstPtr;
					*lclDstPtr = locColr;
					break;
				}

				lclDstPtr--;
			}

			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;
		logFnc = (dstClass & 3);	/* only two lower bits needed */

		while (lclLineCnt-- >= 0)
		{	/* for each row */
			lclByteCnt = byteCntM1;
			while (lclByteCnt-- >= 0)
			{	/* for each byte in the row */
				locColr = pnColr ^ *lclSrcPtr++;
				switch (logFnc)
				{
				case 0:	/* can't happen */
				case 1:	/* "OR" */
					locColr = locColr | *lclDstPtr;
					*lclDstPtr = locColr;
					break;
				case 2:	/* "XOR" */
					locColr = locColr ^ *lclDstPtr;
					*lclDstPtr = locColr;
					break;
				case 3:	/* "AND" */
					locColr = locColr & *lclDstPtr;
					*lclDstPtr = locColr;
					break;
				}

				lclDstPtr++;
			}

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

	return;
}


/* Function mwWRIMA is a special case optimization for WriteImage,
8 bit per pixel, interleaved or linear. Also passes through 1->8Bit
WriteImage to mwWRIMMA. */
void mwWRIMA(blitRcd *blitRec)
{
	void mwWRIMMA(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 DrawRectEntryImg(blitRcd *blitRec);
	void nuResume(grafMap *dstBmap);
	void RepDestM8B(void);
	void OXADestM8B(void);
	void SetSrcLCD(void);
	void NotDestSolidM8B(void);
	void InvertSrcLCD(void);
	void QuickEnd(void);

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

	srcImag = (image *) blitRec->blitSmap; 
	srcBmap = 0;

	if(srcImag->imBits == 1) /*is this a monochrome image?  */
	{
		mwWRIMMA(blitRec);/* Let the 1->8 bit handler handle  */
		return;
	}

	if((srcImag->imWidth <= 0) || (srcImag->imHeight <= 0))
		return;

	sRect.Ymin = 0;
	sRect.Xmin = srcImag->imAlign;
	srcPixBytes = srcImag->imBytes;
	rListPtr =  (rect *) blitRec->blitList;

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

	M_PAUSE(dstBmap);

	switch (dstClass)
	{	/* look up the optimization routine */
	  			    /* Memory non-transparent */
	case 0:		/* zREPz   :           src			 */