📄 m2b4_drv.c
字号:
{ /* for each byte in the row */
if (*srcPtr & pxBit)
{ /* source is 1 */
*dstPtr = (*dstPtr ^ dstPxBit);
}
dstPxBit = (dstPxBit >> shfCnt);
if (dstPxBit == 0)
{ /* advance to next byte */
dstPtr++;
if (shfCnt == 2)
{
dstPxBit = 0xc0;
}
else
{
dstPxBit = 0xf0;
}
}
pxBit = pxBit >> 1;
if (pxBit == 0)
{
pxBit = 128;
srcPtr++;
}
}
dRect.Ymin++; /* advance to next row */
srcPtr += srcNextRow;
}
return;
}
/* Function OXADest1M2_4B sets the destination pixel data based on
the logical function "OR", "XOR" or "AND". */
void OXADest1M2_4B(void)
{
int lclLineCnt, lclByteCnt;
int pxBit;
int pxBitVal;
int pxShift;
byte dstPxBit;
int logFnc;
pxShift = (dRect.Xmin & firstOffset) * shfCnt;
lclLineCnt = lineCntM1;
logFnc = (dstClass & 3); /* only two lower bits needed */
pxBitVal = 128 >> (sRect.Xmin & 7);
while (lclLineCnt-- >= 0)
{ /* for each row */
dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymin))
+ dstBgnByte;
lclByteCnt = byteCntM1;
pxBit = pxBitVal;
dstPxBit = (byte) (shiftMask >> pxShift);
while (lclByteCnt-- >= 0)
{ /* for each byte in the row */
if (*srcPtr & pxBit)
{ /* source is 1 */
switch (logFnc)
{
case 0: /* handled elsewhere */
case 1: /* "OR" */
*dstPtr = *dstPtr | (dstPxBit & pnColr);
break;
case 2: /* "XOR" */
*dstPtr = *dstPtr ^ (dstPxBit & pnColr);
break;
case 3: /* "AND" */
*dstPtr = *dstPtr & (~dstPxBit | (dstPxBit & pnColr));
}
}
else
{ /* source is 0 */
switch (logFnc)
{
case 0: /* handled elsewhere */
case 1: /* "OR" */
*dstPtr = *dstPtr | (dstPxBit & bkColr);
break;
case 2: /* "XOR" */
*dstPtr = *dstPtr ^ (dstPxBit & bkColr);
break;
case 3: /* "AND" */
*dstPtr = *dstPtr & (~dstPxBit | (dstPxBit & bkColr));
}
}
dstPxBit = (dstPxBit >> shfCnt);
if (dstPxBit == 0)
{ /* advance to next byte */
dstPtr++;
if (shfCnt == 2)
{
dstPxBit = 0xc0;
}
else
{
dstPxBit = 0xf0;
}
}
pxBit = pxBit >> 1;
if (pxBit == 0)
{
pxBit = 128;
srcPtr++;
}
}
dRect.Ymin++; /* advance to next row */
srcPtr += srcNextRow;
}
return;
}
/* Function mwPBSS2_4B is a special case optimization for memory
to memory, rectangular clipping with no color translation. */
void mwPBSS2_4B(blitRcd *blitRec)
{
int Check_YX_Band_Blit(rect *bandRect, rect *blitRectPtr,
rect *clipR, int *rectCnt);
void DrawRectEntryBlitM2_4M(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 RepDestM2_4B(void);
void OXADestM2_4B(void);
void SetDestM2_4B(void);
void NotDestSolidM2_4B(void);
void InvertDestM2_4B(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);
dstWidth = dstBmap->pixBytes;
shfCnt = dstBmap->pixBits; /* determine number of bits per pixel */
if (shfCnt == 2)
{ /* 2 bpp */
flipMask = 2;
shiftMask = 0xc0;
firstOffset = 0x03;
}
else
{ /* 4 bpp */
flipMask = 1;
shiftMask = 0xf0;
firstOffset = 0x01;
}
switch (dstClass)
{ /* look up the optimization routine */
/* LCD non-transparent */
case 0: /* zREPz : src */
case 4: /* zNREPz : (NOT src) */
optPtr = &RepDestM2_4B;
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 = &OXADestM2_4B;
break;
case 8: /* zCLEARz : 0's */
case 12: /* zSETz : 1's */
optPtr = &SetDestM2_4B;
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 = &NotDestSolidM2_4B;
break;
case 10: /* zNOPz : dst <NOP> */
optPtr = &QuickEnd;
break;
case 14: /* zINVERTz: (NOT dst) */
optPtr = &InvertDestM2_4B;
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 = &DrawRectEntryBlitM2_4M;
if (Blit_Clip_Region(blitRec, &dRect, &sRect)
== 0) break;
continue;
}
}
DrawRectEntryBlitM2_4M(blitRec); /* blit the rectangle */
}
PB_RTN:
nuResume(srcBmap);
nuResume(dstBmap);
return;
}
/* Function DrawRectEntryBlitM2_4M blits the rectangle to the memory */
void DrawRectEntryBlitM2_4M(blitRcd *blitRec)
{
lineCntM1 = dRect.Ymax - dRect.Ymin - 1;
srcBgnByte = (sRect.Xmin >> flipMask);
dstBgnByte = (dRect.Xmin >> flipMask);
byteCntM1 = dRect.Xmax - dRect.Xmin - 1;
optPtr(); /* blit the rectangle */
return;
}
/* Function NotDestSolidM2_4B handles memory "not dst" by inverting the
destination first. */
void NotDestSolidM2_4B(void)
{
void InvertDestM2_4B(void);
void OXADestM2_4B(void);
InvertDestM2_4B();
OXADestM2_4B(); /* fill this rectangle */
return;
}
/* Function RepDestM2_4B sets the destination pixel data with the
source data. */
void RepDestM2_4B(void)
{
int lclByteCnt, lclShift;
int dstPxShift, srcPxShift, srcShf;
byte dstPxBit, srcPxBit, srcColr;
if ((dstBmap == srcBmap) && ((sRect.Ymin < dRect.Ymin) ||
((sRect.Ymin == dRect.Ymin) && (sRect.Xmin < dRect.Xmin))))
{ /* blit bottom to top, right to left */
dstPxShift = (dRect.Xmax & firstOffset) * shfCnt;
srcPxShift = (sRect.Xmax & firstOffset) * shfCnt;
srcShf = srcPxShift - dstPxShift;
/* BobB 1/15/99 - corrected image shifting */
if (srcShf < 0) srcShf = -srcShf;
lclShift = (flipMask << 1);
while (lineCntM1-- >= 0)
{ /* for each row */
dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymax))
+ (dRect.Xmax >> flipMask);
srcPtr = (byte *) (*(srcBmap->mapTable[0] + sRect.Ymax))
+ (sRect.Xmax >> flipMask);
lclByteCnt = byteCntM1;
dstPxBit = (byte) (shiftMask >> dstPxShift);
srcPxBit = (byte) (shiftMask >> srcPxShift);
while (lclByteCnt-- >= 0)
{ /* for each byte in the row */
srcColr = (*srcPtr ^ pnColr) & srcPxBit;
/* BobB 1/15/99 - corrected image shifting
if (srcShf < 0) srcColr = (srcColr >> -srcShf);
if (srcShf > 0) srcColr = (srcColr << srcShf); */
if (dstPxBit < srcPxBit) srcColr = (srcColr >> srcShf);
if (dstPxBit > srcPxBit) srcColr = (srcColr << srcShf);
*dstPtr = (*dstPtr & ~dstPxBit) | srcColr;
dstPxBit = (dstPxBit << shfCnt);
if (dstPxBit == 0)
{ /* advance to next byte */
dstPtr--;
/* now check for high speed middle blit */
if (srcShf == 0)
{ /* yes */
while (lclByteCnt >= lclShift)
{ /* for each byte in the row */
srcPtr--;
*dstPtr = pnColr ^ *srcPtr;
dstPtr--;
lclByteCnt -= lclShift;
}
}
/* do rest of data */
if (shfCnt == 2)
{
dstPxBit = 0x03;
}
else
{
dstPxBit = 0x0f;
}
}
srcPxBit = (srcPxBit << shfCnt);
if (srcPxBit == 0)
{ /* advance to next byte */
srcPtr--;
if (shfCnt == 2)
{
srcPxBit = 0x03;
}
else
{
srcPxBit = 0x0f;
}
}
}
dRect.Ymax--; /* advance to next row */
sRect.Ymax--;
}
}
else
{ /* blit top to bottom, left to right */
dstPxShift = (dRect.Xmin & firstOffset) * shfCnt;
srcPxShift = (sRect.Xmin & firstOffset) * shfCnt;
srcShf = srcPxShift - dstPxShift;
/* BobB 1/15/99 - corrected image shifting */
if (srcShf < 0) srcShf = -srcShf;
lclShift = (flipMask << 1);
while (lineCntM1-- >= 0)
{ /* for each row */
dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymin))
+ dstBgnByte;
srcPtr = (byte *) (*(srcBmap->mapTable[0] + sRect.Ymin))
+ srcBgnByte;
lclByteCnt = byteCntM1;
dstPxBit = (byte) (shiftMask >> dstPxShift);
srcPxBit = (byte) (shiftMask >> srcPxShift);
while (lclByteCnt-- >= 0)
{ /* for each byte in the row */
srcColr = (*srcPtr ^ pnColr) & srcPxBit;
/* BobB 1/15/99 - corrected image shifting
if (srcShf < 0) srcColr = (srcColr >> -srcShf);
if (srcShf > 0) srcColr = (srcColr << srcShf); */
if (dstPxBit < srcPxBit) srcColr = (srcColr >> srcShf);
if (dstPxBit > srcPxBit) srcColr = (srcColr << srcShf);
*dstPtr = (*dstPtr & ~dstPxBit) | srcColr;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -