lcd_drv.c

与Nucleus Plus配套的图形库

	byte *lclDstPtr, *lclSrcPtr;
	int lclLineCnt, lclByteCnt;

/* BobB 5/18/98 - added for first pixel addressing */
	byte * dstPtrSave;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclSrcPtr = srcPtr;
	lclLineCnt = lineCntM1;

	while (lclLineCnt-- >= 0)
	{	/* for each row */

/* BobB 5/18/98 - added for first pixel addressing */
		dstPtrSave = lclDstPtr;

		lclByteCnt = byteCntM1;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			*lclDstPtr = pnColr ^ *lclSrcPtr++;

			if (((long) lclDstPtr) & 1)
			{	/* advance 3 bytes */
				lclDstPtr += 3;
			}
			else
			{	/* advance only 1 byte */
				lclDstPtr++;
			}
		}

/* BobB 5/18/98 - corrected for first pixel addressing
		lclDstPtr += dstNextRow;*/	/* advance to next row */
		lclDstPtr = dstPtrSave + dstNextRow;
		lclSrcPtr += srcNextRow;
	}

	return;
}


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

/* BobB 5/18/98 - added for first pixel addressing */
	byte * dstPtrSave;

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

	while (lclLineCnt-- >= 0)
	{	/* for each row */

/* BobB 5/18/98 - added for first pixel addressing */
		dstPtrSave = lclDstPtr;

		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;
			}

			if (((long) lclDstPtr) & 1)
			{	/* advance 3 bytes */
				lclDstPtr += 3;
			}
			else
			{	/* advance only 1 byte */
				lclDstPtr++;
			}
		}

/* BobB 5/18/98 - corrected for first pixel addressing
		lclDstPtr += dstNextRow;*/	/* advance to next row */
		lclDstPtr = dstPtrSave + dstNextRow;
		lclSrcPtr += srcNextRow;
	}

	return;
}


/* Function QuickEnd is just a NOP */
void QuickEnd(void)
{
	return;
}


/* Function mwPBSMLCD is a special case optimization for LCD
to memory, rectangular clipping with color translation. */
void mwPBSMLCD(blitRcd *blitRec)
{
	int Check_YX_Band_Blit(rect *bandRect, rect *blitRectPtr,
		rect *clipR, int *rectCnt);
	void DrawRectEntryBlitLM(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 RepSrcLCD(void);
	void OXASrcLCD(void);
	void SetSrcLCD(void);
	void NotSrcSolidLCD(void);
	void InvertSrcLCD(void);
	void QuickEnd(void);

	rect clipR;	/* Clip rect */
	rect *rListPtr;	/* list pointer */
	int blitMayOverlap = 0;	/* Set false 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 = &RepSrcLCD;
		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 = &OXASrcLCD;
		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 = &NotSrcSolidLCD;
		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 = &DrawRectEntryBlitLM;
				if (Blit_Clip_Region(blitRec, &dRect, &sRect)
					== 0) break;
				continue;
			}
		}
		
		DrawRectEntryBlitLM(blitRec);	/* blit the rectangle */
	}

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


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

	lineCntM1 = dRect.Ymax - dRect.Ymin - 1;
	srcBgnByte = ((sRect.Xmin & 0xfffe) << 1) + (sRect.Xmin & 1);
	dstBgnByte = dRect.Xmin;
	byteCntM1 = dRect.Xmax - dRect.Xmin - 1;

/* BobB 5/15/98 - corrected for first pixel addressing
	srcNextRow = srcPixBytes - byteCntM1 - byteCntM1 - 2;*/
	srcNextRow = srcPixBytes;

	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 NotSrcSolidLCD handles LCD "not dst" by inverting the
destination first. */
void NotSrcSolidLCD(void)
{
	void InvertSrcLCD(void);
	void OXASrcLCD(void);

	InvertSrcLCD();

	OXASrcLCD();	/* fill this rectangle */

	return;
}


/* Function InvertSrcLCD inverts the destination pixel data. */
void InvertSrcLCD(void)
{
	byte *lclDstPtr;
	int lclLineCnt, lclByteCnt;

/* BobB 5/18/98 - added for first pixel addressing */
	byte * dstPtrSave;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclLineCnt = lineCntM1;

	while (lclLineCnt-- >= 0)
	{	/* for each row */

/* BobB 5/18/98 - added for first pixel addressing */
		dstPtrSave = lclDstPtr;

		lclByteCnt = byteCntM1;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			*lclDstPtr = ~(*lclDstPtr);
			lclDstPtr++;
		}

/* BobB 5/18/98 - corrected for first pixel addressing
		lclDstPtr += dstNextRow;*/	/* advance to next row */
		lclDstPtr = dstPtrSave + dstNextRow;
	}

	return;
}


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

/* BobB 5/18/98 - added for first pixel addressing */
	byte * dstPtrSave;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclLineCnt = lineCntM1;

	while (lclLineCnt-- >= 0)
	{	/* for each row */

/* BobB 5/18/98 - added for first pixel addressing */
		dstPtrSave = lclDstPtr;

		lclByteCnt = byteCntM1;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			*lclDstPtr++ = pnColr;
		}

/* BobB 5/18/98 - corrected for first pixel addressing
		lclDstPtr += dstNextRow;*/	/* advance to next row */
		lclDstPtr = dstPtrSave + dstNextRow;
	}

	return;
}


/* Function RepSrcLCD sets the destination pixel data to pnColr
if the source is 1 else bkColr. */
void RepSrcLCD(void)
{
	byte *lclDstPtr, *lclSrcPtr;
	int lclLineCnt, lclByteCnt;
/* BobB 5/18/98 - added the temp variable for first pixel addressing */
	byte *srcPtrSave;

	lclDstPtr = dstPtr;	/* set up local pointers */
	lclSrcPtr = srcPtr;
	lclLineCnt = lineCntM1;

	while (lclLineCnt-- >= 0)
	{	/* for each row */

/* BobB 5/18/98 - added for first pixel addressing */
		srcPtrSave = lclSrcPtr;

		lclByteCnt = byteCntM1;
		while (lclByteCnt-- >= 0)
		{	/* for each byte in the row */
			*lclDstPtr = pnColr ^ *lclSrcPtr;

			if (((long) lclSrcPtr) & 1)
			{	/* advance 3 bytes */
				lclSrcPtr += 3;
			}
			else
			{	/* advance only 1 byte */
				lclSrcPtr++;
			}

			lclDstPtr++;	/* advance dest pointer */
		}

/* BobB 5/18/98 - corrected for first pixel addressing
		lclSrcPtr += srcNextRow;*/
		lclSrcPtr = srcPtrSave + srcNextRow;

		lclDstPtr += dstNextRow;
	}

	return;
}


/* Function OXASrcLCD sets the destination pixel data based on
the logical funtion "OR", "XOR" or "AND". */
void OXASrcLCD(void)
{
	byte *lclDstPtr, *lclSrcPtr;
	int lclLineCnt, lclByteCnt;
	int logFnc, locColr;
/* BobB 5/18/98 - added the temp variable for first pixel addressing */
	byte *srcPtrSave;

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

	while (lclLineCnt-- >= 0)
	{	/* for each row */

/* BobB 5/18/98 - added for first pixel addressing */
		srcPtrSave = lclSrcPtr;

		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;