📄 m24b_drv.c
字号:
((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;
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 */
switch (logFnc)
{
case 0: /* can't happen */
case 1: /* "OR" */
locColr = pnColrB ^ *lclSrcPtr--;
locColr = locColr | *lclDstPtr;
*lclDstPtr-- = locColr;
locColr = pnColrG ^ *lclSrcPtr--;
locColr = locColr | *lclDstPtr;
*lclDstPtr-- = locColr;
locColr = pnColrR ^ *lclSrcPtr--;
locColr = locColr | *lclDstPtr;
*lclDstPtr-- = locColr;
break;
case 2: /* "XOR" */
locColr = pnColrB ^ *lclSrcPtr--;
locColr = locColr ^ *lclDstPtr;
*lclDstPtr-- = locColr;
locColr = pnColrG ^ *lclSrcPtr--;
locColr = locColr ^ *lclDstPtr;
*lclDstPtr-- = locColr;
locColr = pnColrR ^ *lclSrcPtr--;
locColr = locColr ^ *lclDstPtr;
*lclDstPtr-- = locColr;
break;
case 3: /* "AND" */
locColr = pnColrB ^ *lclSrcPtr--;
locColr = locColr & *lclDstPtr;
*lclDstPtr-- = locColr;
locColr = pnColrG ^ *lclSrcPtr--;
locColr = locColr & *lclDstPtr;
*lclDstPtr-- = locColr;
locColr = pnColrR ^ *lclSrcPtr--;
locColr = locColr & *lclDstPtr;
*lclDstPtr-- = locColr;
break;
}
}
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 */
switch (logFnc)
{
case 0: /* can't happen */
case 1: /* "OR" */
locColr = pnColrR ^ *lclSrcPtr++;
locColr = locColr | *lclDstPtr;
*lclDstPtr++ = locColr;
locColr = pnColrG ^ *lclSrcPtr++;
locColr = locColr | *lclDstPtr;
*lclDstPtr++ = locColr;
locColr = pnColrB ^ *lclSrcPtr++;
locColr = locColr | *lclDstPtr;
*lclDstPtr++ = locColr;
break;
case 2: /* "XOR" */
locColr = pnColrR ^ *lclSrcPtr++;
locColr = locColr ^ *lclDstPtr;
*lclDstPtr++ = locColr;
locColr = pnColrG ^ *lclSrcPtr++;
locColr = locColr ^ *lclDstPtr;
*lclDstPtr++ = locColr;
locColr = pnColrB ^ *lclSrcPtr++;
locColr = locColr ^ *lclDstPtr;
*lclDstPtr++ = locColr;
break;
case 3: /* "AND" */
locColr = pnColrR ^ *lclSrcPtr++;
locColr = locColr & *lclDstPtr;
*lclDstPtr++ = locColr;
locColr = pnColrG ^ *lclSrcPtr++;
locColr = locColr & *lclDstPtr;
*lclDstPtr++ = locColr;
locColr = pnColrB ^ *lclSrcPtr++;
locColr = locColr & *lclDstPtr;
*lclDstPtr++ = locColr;
break;
}
}
lclDstPtr += dstNextRow; /* advance to next row */
lclSrcPtr += srcNextRow;
}
}
return;
}
/* Function mwWRIMA24 is a special case optimization for WriteImage,
24-bit per pixel, interleaved or linear. Also passes through 1->24Bit
WriteImage to mwWRIMMA24. */
void mwWRIMA24(blitRcd *blitRec)
{
void mwWRIMMA24(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 DrawRectEntryImg24(blitRcd *blitRec);
void nuResume(grafMap *dstBmap);
void RepDestM24B(void);
void OXADestM24B(void);
void SetDestM24B(void);
void NotDestSolidM24B(void);
void InvertDestM24B(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? */
{
mwWRIMMA24(blitRec);/* Let the 1->24 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 */
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, &cRect, blitMayOverlap, isLine))
goto WI_RTN;
dRect = *rListPtr;
/* See if the destination is too wide */
if((dRect.Xmax - dRect.Xmin) > srcImag->imWidth)
dRect.Xmax = dRect.Xmin + srcImag->imWidth;
/* sXmax not adjusted because not used */
/* See if the destination is too high */
if((dRect.Ymax - dRect.Ymin) > srcImag->imHeight)
dRect.Ymax = dRect.Ymin + srcImag->imHeight;
/* sYmax not adjusted because not used */
/* do we need to worry about clipping */
if(clipToRectFlag != 0)
{
if (dRect.Xmin < cRect.Xmin)
{ /* Reset src & dst Xmin clip limit */
sRect.Xmin -= (dRect.Xmin - cRect.Xmin);
dRect.Xmin = cRect.Xmin;
}
if (dRect.Ymin < cRect.Ymin)
{ /* Reset src & dst Ymin clip limit */
sRect.Ymin -= (dRect.Ymin - cRect.Ymin);
dRect.Ymin = cRect.Ymin;
}
if (dRect.Xmax > cRect.Xmax)
{ /* Reset src & dst Xmax clip limit */
dRect.Xmax = cRect.Xmax;
/* sXmax not altered because not used */
}
if (dRect.Ymax > cRect.Ymax)
{ /* Reset src & dst Ymax clip limit */
dRect.Ymax = cRect.Ymax;
/* sYmax not altered because not used */
}
if ((dRect.Xmin >= dRect.Xmax) || (dRect.Ymin >= dRect.Ymax))
return;
/* do we need to worry about region clipping? */
if (clipToRegionFlag != 0)
{ /* yes, go do it */
FillDrawer = &DrawRectEntryImg24;
Blit_Clip_Region(blitRec, &dRect, &sRect);
goto WI_RTN;
}
}
DrawRectEntryImg24(blitRec);
WI_RTN:
nuResume(dstBmap);
return;
}
/* Draw the image */
void DrawRectEntryImg24(blitRcd *blitRec)
{
lineCntM1 = dRect.Ymax - dRect.Ymin - 1;
dstBgnByte = 3 * dRect.Xmin;
byteCntM1 = dRect.Xmax - dRect.Xmin - 1;
dstNextRow = dstBmap->pixBytes - (3 * byteCntM1) - 3;
srcNextRow = srcPixBytes - (3 * byteCntM1) - 3;
srcBgnByte = 3 * sRect.Xmin;
srcPtr = (byte *) (srcImag->imData + (sRect.Ymin * srcPixBytes))
+ srcBgnByte;
dstPtr = (byte *) (*(dstBmap->mapTable[0] + dRect.Ymin))
+ dstBgnByte;
optPtr(); /* blit the rectangle */
return;
}
/* Function mwWRIMMA24 is a special case optimization for 1->24Bit
WriteImage. */
void mwWRIMMA24(blitRcd *blitRec)
{
void DrawRectEntryImg1B24(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 RepDest1M24B(void);
void OXADest1M24B(void);
void SetDestM24B(void);
void NotDestSolid1M24B(void);
void InvertDestM24B(void);
void QuickEnd(void);
void SetTrans1M24B(void);
void InvertTrans1M24B(void);
rect *rListPtr; /* list pointer */
int blitMayOverlap = 0; /* Set false for region clipping*/
int isLine = 0; /* Set false */
srcImag = (image *) blitRec->blitSmap;
if((srcImag->imWidth <= 0) || (srcImag->imHeight <= 0))
return;
sRect.Ymin = 0;
sRect.Xmin = 0;
srcPixBytes = srcImag->imBytes;
rListPtr = (rect *) blitRec->blitList;
dstBmap = blitRec->blitDmap;
dstClass = blitRec->blitRop & 0x1f;
M_PAUSE(dstBmap);
bkColr24 = blitRec->blitBack; /* background color */
pnColr24 = blitRec->blitFore; /* foreground color */
switch (dstClass)
{ /* look up the optimization routine */
/* Memory non-transparent */
case 0: /* zREPz : src */
case 4: /* zNREPz : (NOT src) */
optPtr = &RepDest1M24B;
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 = &OXADest1M24B;
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 = &NotDestSolid1M24B;
break;
case 10: /* zNOPz : dst <NOP> */
optPtr = &QuickEnd;
break;
case 14: /* zINVERTz: (NOT dst) */
optPtr = &InvertDestM24B;
break;
/* Memory transparent */
case 16: /* xREPx : !0src */
case 17: /* xORx : !0src OR dst */
case 25: /* xORNx : !0src OR (NOT dst) */
case 28: /* xSETx : 1's */
optPtr = &SetTrans1M24B;
break;
case 18: /* xXORx : !0src XOR dst */
case 27: /* xANDNx : !0src AND (NOT dst) */
case 30: /* xINVERTx: (NOT dst) */
optPtr = &InvertTrans1M24B;
break;
case 19: /* xNANDx : (NOT !0src) AND dst */
case 20: /* xNREPx : (NOT !0src) */
case 21: /* xNORx : (NOT !0src) OR dst */
case 22: /* xNXORx : (NOT !0src) XOR dst */
case 23: /* xANDx : !0src AND dst */
case 24: /* xCLEARx : 0's */
case 26: /* xNOPx : dst <NOP> */
case 29: /* xNORNx : (NOT !0src) OR (NOT dst) */
case 31: /* xNANDNx : (NOT !0src) AND (NOT dst) */
optPtr = &QuickEnd;
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 = ~pnColr24; /* 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 */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -