archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/windows/core/ntgdi/halftone/ht/htgetbmp.c

2746 lines
54 KiB
Raw Permalink Blame History

/*++
Copyright (c) 1990-1991 Microsoft Corporation
Module Name:
htgetbmp.c
Abstract:
This module provided a set of functions which read the 1/4/8/16/24/32
bits per pel bitmap and composed it
Author:
08-Jan-1999 Fri 18:14:42 updated -by- Daniel Chou (danielc)
Re-write
23-Apr-1992 Thu 21:14:55 updated -by- Daniel Chou (danielc)
1. Delete InFuncInfo.StretchSize, and using Prim1/Prim2 to determined
when we will stop the source stretch,
2. Change 'ColorInfoIncrement' from 'CHAR' to 'SHORT', this will make
sure the default MIPS's 'unsigned char' will not affect our
signed operation.
28-Mar-1992 Sat 20:54:58 updated -by- Daniel Chou (danielc)
Update it for VGA intensity (16 colors mode), this make all the
codes update to 4 primaries internal.
05-Apr-1991 Fri 15:55:08 created -by- Daniel Chou (danielc)
[Environment:]
Printer Driver.
[Notes:]
Revision History:
--*/
#define DBGP_VARNAME dbgpHTGetBmp
#include "htp.h"
#include "htmapclr.h"
#include "htpat.h"
#include "htalias.h"
#include "htrender.h"
#include "htstret.h"
#include "htgetbmp.h"
#define DBGP_INPUT 0x00000001
#define DBGP_GETFIXUP 0x00000002
#define DBGP_CHK_FUDI 0x00000004
#define DBGP_FUDI 0x00000008
#define DBGP_EXP_MASK 0x00000010
DEF_DBGPVAR(BIT_IF(DBGP_INPUT, 0) |
BIT_IF(DBGP_GETFIXUP, 0) |
BIT_IF(DBGP_CHK_FUDI, 0) |
BIT_IF(DBGP_FUDI, 0) |
BIT_IF(DBGP_EXP_MASK, 0))
#if DBG
INT cCXMask = 0;
#define DBG_CXMASK 0
#else
#define DBG_CXMASK 0
#endif
#define GET_AV(p) (BYTE)(p)->f
#define OR_AV(AV1, AV2) (BYTE)(((UINT)(AV1) + (UINT)(AV2) + 1) >> 1)
extern DWORD dwABPreMul[256];
#define GET_PREMUL_SRC(x, m) \
(BYTE)((((DWORD)(x) * (DWORD)(m)) + 0x800000) >> 24)
VOID
HTENTRY
BltAV_CX(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
LPBYTE pSrcAV;
LPBYTE pSrcAVEnd;
INT SrcAVInc;
PBGRF pbgrfAB;
pSrcAV = pAAHdr->pSrcAVBeg;
pSrcAVEnd = pAAHdr->pSrcAVEnd;
SrcAVInc = (INT)pAAHdr->SrcAVInc;
pbgrfAB = pAAHdr->pbgrfAB;
if (pAAHdr->Flags & AAHF_OR_AV) {
do {
*pSrcAV = OR_AV(*pSrcAV, GET_AV(pbgrfAB));
++pbgrfAB;
} while (((LPBYTE)pSrcAV += SrcAVInc) != (LPBYTE)pSrcAVEnd);
} else {
do {
*pSrcAV = GET_AV(pbgrfAB);
++pbgrfAB;
} while (((LPBYTE)pSrcAV += SrcAVInc) != (LPBYTE)pSrcAVEnd);
}
}
VOID
HTENTRY
BltAV_CY(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
pAAHdr->GetAVCXFunc(pAAHdr);
(LPBYTE)pAAHdr->pbgrfAB += pAAHdr->cyABNext;
}
VOID
HTENTRY
TileAV_CY(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
11-Jul-1997 Fri 14:26:26 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
LPBYTE pSrcAV;
LPBYTE pSrcAVEnd;
INT SrcAVInc;
PBGRF pbgrfAB;
PBGRF pbgrfABBeg;
PBGRF pbgrfABEnd;
pSrcAV = pAAHdr->pSrcAVBeg;
pSrcAVEnd = pAAHdr->pSrcAVEnd;
SrcAVInc = (INT)pAAHdr->SrcAVInc;
pbgrfAB =
pbgrfABBeg = pAAHdr->pbgrfAB;
pbgrfABEnd = pbgrfAB + pAAHdr->SrcSurfInfo.cx;
pbgrfAB += pAAHdr->pAAInfoCX->iSrcBeg;
do {
*pSrcAV = GET_AV(pbgrfAB);
if (++pbgrfAB >= pbgrfABEnd) {
pbgrfAB = pbgrfABBeg;
}
} while (((LPBYTE)pSrcAV += SrcAVInc) != (LPBYTE)pSrcAVEnd);
if (--pAAHdr->cybgrfAB <= 0) {
pAAHdr->pbgrfAB = (PBGRF)pAAHdr->SrcSurfInfo.pbOrg;
pAAHdr->cybgrfAB = pAAHdr->SrcSurfInfo.cyOrg;
}
}
VOID
HTENTRY
ExpandAV_CX(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:54:25 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
PREPDATA pRep;
PREPDATA pRepEnd;
LPBYTE pSrcAV;
LPBYTE pSrcAVEnd;
PBGRF pbgrfAB;
INT SrcAVInc;
BOOL OrAV;
DWORD cRep;
BYTE AV;
pSrcAV = pAAHdr->pSrcAVBeg;
pSrcAVEnd = pAAHdr->pSrcAVEnd;
SrcAVInc = (INT)pAAHdr->SrcAVInc;
pbgrfAB = pAAHdr->pbgrfAB;
pAAInfo = pAAHdr->pAAInfoCX;
pRep = pAAInfo->AB.pRep;
pRepEnd = pAAInfo->AB.pRepEnd;
cRep = 1;
//
// The AB set to 0xff so if the source AB is not available at begining
// then it will be no AB
//
AV = 0xFF;
OrAV = (BOOL)(pAAHdr->Flags & AAHF_OR_AV);
do {
if (--cRep == 0) {
ASSERT(pRep < pRepEnd);
cRep = (DWORD)pRep++->c;
AV = GET_AV(pbgrfAB);
if (OrAV) {
AV = OR_AV(AV, *pSrcAV);
}
++pbgrfAB;
}
*pSrcAV = (BYTE)AV;
} while (((LPBYTE)pSrcAV += SrcAVInc) != (LPBYTE)pSrcAVEnd);
}
VOID
HTENTRY
ExpandAV_CY(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
pAAInfo = pAAHdr->pAAInfoCY;
if (--pAAInfo->AB.cRep == 0) {
ASSERT(pAAInfo->AB.pRep < pAAInfo->AB.pRepEnd);
pAAInfo->AB.cRep = (DWORD)pAAInfo->AB.pRep++->c;
BltAV_CY(pAAHdr);
}
}
VOID
HTENTRY
ShrinkAV_CX(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
PREPDATA pRep;
PREPDATA pRepEnd;
LPBYTE pSrcAV;
LPBYTE pSrcAVEnd;
PBGRF pbgrfAB;
INT SrcAVInc;
DWORD cRep;
BOOL OrAV;
BYTE AV;
pSrcAV = pAAHdr->pSrcAVBeg;
pSrcAVEnd = pAAHdr->pSrcAVEnd;
SrcAVInc = (INT)pAAHdr->SrcAVInc;
pbgrfAB = pAAHdr->pbgrfAB;
pAAInfo = pAAHdr->pAAInfoCX;
pRep = pAAInfo->AB.pRep;
pRepEnd = pAAInfo->AB.pRepEnd;
OrAV = (BOOL)(pAAHdr->Flags & AAHF_OR_AV);
do {
AV = 0xFF;
ASSERT(pRep < pRepEnd);
if (pRep < pRepEnd) {
AV = GET_AV(pbgrfAB);
if (OrAV) {
AV = OR_AV(*pSrcAV, AV);
}
++pbgrfAB;
cRep = (DWORD)pRep++->c;
while (--cRep) {
AV = OR_AV(AV, GET_AV(pbgrfAB));
++pbgrfAB;
}
}
*pSrcAV = AV;
} while (((LPBYTE)pSrcAV += SrcAVInc) != (LPBYTE)pSrcAVEnd);
}
VOID
HTENTRY
ShrinkAV_CY(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfoCY;
DWORD AAHFlags;
DWORD cRep;
//
// We will get the scan first then subsequence scans will be or in
//
pAAInfoCY = pAAHdr->pAAInfoCY;
AAHFlags = pAAHdr->Flags;
pAAHdr->Flags &= ~AAHF_OR_AV;
ASSERT(pAAInfoCY->AB.pRep < pAAInfoCY->AB.pRepEnd);
cRep = (DWORD)pAAInfoCY->AB.pRep++->c;
while (cRep--) {
pAAHdr->GetAVCXFunc(pAAHdr);
pAAHdr->Flags = AAHFlags;
(LPBYTE)pAAHdr->pbgrfAB += pAAHdr->cyABNext;
}
}
VOID
HTENTRY
BltMask_CX(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
PBGRF pDst;
PBGRF pDstEnd;
LPBYTE pb;
INT DstInc;
DW2W4B dw4b;
BYTE Mask;
pAAInfo = pAAHdr->pAAInfoCX;
pDst = pAAHdr->pAABufBeg;
pDstEnd = pAAHdr->pAABufEnd;
DstInc = pAAHdr->AABufInc;
pb = pAAHdr->pMaskSrc;
dw4b.dw = 0x01;
dw4b.b[2] = *pb++;
dw4b.dw <<= pAAHdr->MaskBitOff;
do {
if (dw4b.b[1]) {
dw4b.dw = 0x01;
dw4b.b[2] = *pb++;
}
pDst->f = (BYTE)((dw4b.b[2] & 0x80) ? PBGRF_MASK_FLAG : 0);
dw4b.dw <<= 1;
} while (((LPBYTE)pDst += DstInc) != (LPBYTE)pDstEnd);
}
VOID
HTENTRY
BltMask_CY(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
GET_MASK_SCAN(pAAHdr);
pAAHdr->AAMaskCXFunc(pAAHdr);
}
VOID
HTENTRY
ExpandMask_CX(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:54:25 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
PREPDATA pRep;
PREPDATA pRepEnd;
PBGRF pDst;
PBGRF pDstEnd;
LPBYTE pb;
DWORD cRep;
INT DstInc;
DW2W4B dw4b;
BYTE Mask;
pAAInfo = pAAHdr->pAAInfoCX;
pRep = pAAInfo->Mask.pRep;
pRepEnd = pAAInfo->Mask.pRepEnd;
pDst = pAAHdr->pAABufBeg;
pDstEnd = pAAHdr->pAABufEnd;
DstInc = pAAHdr->AABufInc;
pb = pAAHdr->pMaskSrc;
dw4b.dw = 0x01;
dw4b.b[2] = *pb++;
dw4b.dw <<= pAAHdr->MaskBitOff;
//
// The Mask set to 0xff so if the source mask is not available at begining
// then it will be no mask
//
Mask = PBGRF_MASK_FLAG;
cRep = 1;
do {
if (--cRep == 0) {
ASSERT(pRep < pRepEnd);
cRep = (DWORD)pRep++->c;
//
// Load new byte data if we already used up current byte
//
if (dw4b.b[1]) {
dw4b.dw = 0x01;
dw4b.b[2] = *pb++;
}
Mask = (BYTE)((dw4b.b[2] & 0x80) ? PBGRF_MASK_FLAG : 0);
dw4b.dw <<= 1;
}
pDst->f = Mask;
} while (((LPBYTE)pDst += DstInc) != (LPBYTE)pDstEnd);
SETDBGVAR(cCXMask, -1);
}
VOID
HTENTRY
ExpandMask_CY(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
pAAInfo = pAAHdr->pAAInfoCY;
if (--pAAInfo->Mask.cRep == 0) {
ASSERT(pAAInfo->Mask.pRep < pAAInfo->Mask.pRepEnd);
pAAInfo->Mask.cRep = (DWORD)pAAInfo->Mask.pRep++->c;
DBGP_IF(DBGP_EXP_MASK,
DBGP("LOAD: cy=%4ld, cMaskRem=%4ld, cMaskIn=%4ld, cMaskOut=%4ld"
ARGDW(pAAHdr->cyMaskIn) ARGDW(pAAInfo->Mask.cRep)
ARGDW(pAAInfo->Mask.cIn) ARGDW(pAAInfo->Mask.cOut)));
BltMask_CY(pAAHdr);
} else {
DBGP_IF(DBGP_EXP_MASK,
DBGP(" cy=%4ld, cMaskRem=%4ld, cMaskIn=%4ld, cMaskOut=%4ld"
ARGDW(pAAHdr->cyMaskIn) ARGDW(pAAInfo->Mask.cRep)
ARGDW(pAAInfo->Mask.cIn) ARGDW(pAAInfo->Mask.cOut)));
}
}
VOID
HTENTRY
ShrinkMask_CX(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
PREPDATA pRep;
PREPDATA pRepEnd;
PBGRF pDst;
PBGRF pDstEnd;
LPBYTE pb;
DWORD cRep;
DW2W4B dw4b;
INT DstInc;
BYTE Mask;
pAAInfo = pAAHdr->pAAInfoCX;
pRep = pAAInfo->Mask.pRep;
pRepEnd = pAAInfo->Mask.pRepEnd;
pDst = pAAHdr->pAABufBeg;
pDstEnd = pAAHdr->pAABufEnd;
DstInc = pAAHdr->AABufInc;
pb = pAAHdr->pMaskSrc;
dw4b.dw = 0x01;
dw4b.b[2] = *pb++;
dw4b.dw <<= pAAHdr->MaskBitOff;
//
// --iMaskSize, because we want it to go negative when we reach 0, and
// use bit 24-31 for mask
//
do {
ASSERT(pRep < pRepEnd);
cRep = (DWORD)pRep++->c;
Mask = 0;
while (cRep--) {
//
// Load new byte data if we already used up current byte
//
if (dw4b.b[1]) {
dw4b.dw = 0x01;
dw4b.b[2] = *pb++;
}
//
// Or in the bit 0x80, we will mask it later
//
Mask |= dw4b.b[2];
dw4b.dw <<= 1;
}
pDst->f = (BYTE)((Mask & 0x80) ? PBGRF_MASK_FLAG : 0);
} while (((LPBYTE)pDst += DstInc) != (LPBYTE)pDstEnd);
}
VOID
HTENTRY
ShrinkMask_CY(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
09-Dec-1998 Wed 15:32:38 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PAAINFO pAAInfo;
DWORD cRep;
//
// We will get the scan first then subsequence scans will be or in
//
GET_MASK_SCAN(pAAHdr);
pAAInfo = pAAHdr->pAAInfoCY;
ASSERT(pAAInfo->Mask.pRep < pAAInfo->Mask.pRepEnd);
cRep = (DWORD)pAAInfo->Mask.pRep++->c;
while (--cRep) {
OR_MASK_SCAN(pAAHdr);
}
pAAHdr->AAMaskCXFunc(pAAHdr);
}
PBGR8
HTENTRY
Input1BPPToAA24(
PAASURFINFO pAASI,
PBGR8 pInBuf
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
15-Apr-1998 Wed 16:25:04 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
LPBYTE pIn;
PBGR8 pRet;
UINT cIn;
UINT Idx;
UINT i;
W2B Bit;
UINT InData;
pIn = pAASI->pb;
cIn = (UINT)pAASI->cx;
pRet = pInBuf;
if (pAASI->Flags & AASIF_GRAY) {
LPBYTE pbIB = (LPBYTE)pInBuf;
BYTE Gray[2];
Gray[0] = pAASI->pClrTable[0].a;
Gray[1] = pAASI->pClrTable[1].a;
if (Idx = pAASI->BitOffset) {
Bit.w = (WORD)*pIn++ << Idx;
if ((Idx = 8 - Idx) > cIn) {
Idx = cIn;
}
cIn -= Idx;
while (Idx--) {
Bit.w <<= 1;
*pbIB++ = Gray[i = (Bit.b[1] & 0x01)];
}
}
Idx = cIn >> 3;
while (Idx--) {
InData = (UINT)*pIn++;
*(pbIB + 0) = Gray[(InData >> 7) & 0x01];
*(pbIB + 1) = Gray[(InData >> 6) & 0x01];
*(pbIB + 2) = Gray[(InData >> 5) & 0x01];
*(pbIB + 3) = Gray[(InData >> 4) & 0x01];
*(pbIB + 4) = Gray[(InData >> 3) & 0x01];
*(pbIB + 5) = Gray[(InData >> 2) & 0x01];
*(pbIB + 6) = Gray[(InData >> 1) & 0x01];
*(pbIB + 7) = Gray[(InData ) & 0x01];
pbIB += 8;
}
if (cIn &= 0x07) {
Bit.w = (WORD)*pIn;
while (cIn--) {
Bit.w <<= 1;
*pbIB++ = Gray[i = (Bit.b[1] & 0x01)];
}
}
} else {
BGR8 rgb[2];
rgb[0] = *(PBGR8)pAASI->pClrTable;
rgb[1] = *(PBGR8)(pAASI->pClrTable + 1);
if (Idx = pAASI->BitOffset) {
Bit.w = (WORD)*pIn++ << Idx;
if ((Idx = 8 - Idx) > cIn) {
Idx = cIn;
}
cIn -= Idx;
while (Idx--) {
Bit.w <<= 1;
*pInBuf++ = rgb[i = (Bit.b[1] & 0x01)];
}
}
Idx = cIn >> 3;
while (Idx--) {
InData = (UINT)*pIn++;
*(pInBuf + 0) = rgb[(InData >> 7) & 0x01];
*(pInBuf + 1) = rgb[(InData >> 6) & 0x01];
*(pInBuf + 2) = rgb[(InData >> 5) & 0x01];
*(pInBuf + 3) = rgb[(InData >> 4) & 0x01];
*(pInBuf + 4) = rgb[(InData >> 3) & 0x01];
*(pInBuf + 5) = rgb[(InData >> 2) & 0x01];
*(pInBuf + 6) = rgb[(InData >> 1) & 0x01];
*(pInBuf + 7) = rgb[(InData ) & 0x01];
pInBuf += 8;
}
if (cIn &= 0x07) {
Bit.w = (WORD)*pIn;
while (cIn--) {
Bit.w <<= 1;
*pInBuf++ = rgb[i = (Bit.b[1] & 0x01)];
}
}
}
DBGP_IF(DBGP_INPUT,
DBGP("cyIn=%5ld, pIn=%p-%p, cbIn=%5ld, Buf=%p-%p"
ARGDW(pAASI->cy) ARGPTR(pAASI->pb)
ARGPTR(pIn) ARGDW(pAASI->cbCX)
ARGPTR(pRet) ARGPTR((LPBYTE)pRet + pAASI->cbCX)));
SET_NEXT_PIN(pAASI);
return(pRet);
}
PBGR8
HTENTRY
Input4BPPToAA24(
PAASURFINFO pAASI,
PBGR8 pInBuf
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
15-Apr-1998 Wed 16:25:04 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
LPBYTE pIn;
PBGR8 pRet;
PRGB4B pColorTable;
UINT InData;
UINT InData2;
UINT cIn;
UINT Idx;
pIn = pAASI->pb;
cIn = (UINT)pAASI->cx;
pRet = pInBuf;
pColorTable = pAASI->pClrTable;
if (pAASI->Flags & AASIF_GRAY) {
LPBYTE pbIB = (LPBYTE)pInBuf;
if (pAASI->BitOffset) {
--cIn;
InData = (UINT)(*pIn++ & 0x0F);
*pbIB++ = pColorTable[InData].a;
}
Idx = cIn >> 1;
while (Idx--) {
InData = (UINT)*pIn++;
*(pbIB + 0) = pColorTable[InData >> 4].a;
*(pbIB + 1) = pColorTable[InData & 0x0F].a;
pbIB += 2;
}
if (cIn & 0x01) {
InData = (UINT)(*pIn >> 4);
*pbIB++ = pColorTable[InData].a;
}
} else {
if (pAASI->BitOffset) {
--cIn;
InData = (UINT)(*pIn++ & 0x0F);
*pInBuf++ = *(PBGR8)(pColorTable + InData);
}
Idx = cIn >> 1;
while (Idx--) {
InData = (UINT)*pIn++;
*(pInBuf + 0) = *(PBGR8)(pColorTable + (InData >> 4));
*(pInBuf + 1) = *(PBGR8)(pColorTable + (InData & 0x0F));
pInBuf += 2;
}
if (cIn & 0x01) {
InData = (UINT)(*pIn >> 4);
*pInBuf++ = *(PBGR8)(pColorTable + InData);
}
}
DBGP_IF(DBGP_INPUT,
DBGP("cyIn=%5ld, pIn=%p-%p, cbIn=%5ld, Buf=%p-%p"
ARGDW(pAASI->cy) ARGPTR(pAASI->pb)
ARGPTR(pIn) ARGDW(pAASI->cbCX)
ARGPTR(pRet) ARGPTR((LPBYTE)pRet + pAASI->cbCX)));
SET_NEXT_PIN(pAASI);
return(pRet);
}
PBGR8
HTENTRY
Input8BPPToAA24(
PAASURFINFO pAASI,
PBGR8 pInBuf
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
15-Apr-1998 Wed 16:25:04 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
#define pbIB ((LPBYTE)pInBuf)
LPBYTE pIn;
LPBYTE pInBufEnd;
PBGR8 pRet;
PRGB4B pColorTable;
pIn = pAASI->pb;
pRet = pInBuf;
pColorTable = pAASI->pClrTable;
pInBufEnd = (LPBYTE)pInBuf + pAASI->cbCX;
if (pAASI->Flags & AASIF_GRAY) {
ASSERT(pAASI->cbCX == pAASI->cx);
do {
*pbIB = pColorTable[*pIn++].a;
} while (++pbIB < pInBufEnd);
} else {
ASSERT(pAASI->cbCX == (LONG)(pAASI->cx * sizeof(BGR8)));
do {
*pInBuf = *(PBGR8)(pColorTable + *pIn++);
} while (++pInBuf < (PBGR8)pInBufEnd);
}
DBGP_IF(DBGP_INPUT,
DBGP("cyIn=%5ld, pIn=%p-%p, cbIn=%5ld, Buf=%p-%p"
ARGDW(pAASI->cy) ARGPTR(pAASI->pb)
ARGPTR(pIn) ARGDW(pAASI->cbCX)
ARGPTR(pRet) ARGPTR((LPBYTE)pRet + pAASI->cbCX)));
SET_NEXT_PIN(pAASI);
return(pRet);
#undef pbIB
}
PBGR8
HTENTRY
InputPreMul32BPPToAA24(
PAASURFINFO pAASI,
PBGR8 pInBuf
)
/*++
Routine Description:
This function will read input from a 32-bit (red, green, blue, alpha
8 bits for each channel) type of source and reverse mapped the input
alpha channel pre-multiply RGB byte data to its orginal value.
This function only used if alpha blending is requested and its is a per
pixel alpha blending with 32-bit source
Arguments:
Return Value:
pointer to the pInBuf
Author:
16-Aug-2000 Wed 11:07:15 updated -by- Daniel Chou (danielc)
Revision History:
--*/
{
#define pbIB ((LPBYTE)pInBuf)
#define mR (AABFData.MaskRGB[0])
#define mG (AABFData.MaskRGB[1])
#define mB (AABFData.MaskRGB[2])
LPBYTE pbIn;
PBGR8 pRet;
LPBYTE pInBufEnd;
AABFDATA AABFData;
DWORD Mul;
BYTE bgr[3];
pbIn = (LPBYTE)pAASI->pb;
pRet = pInBuf;
AABFData = pAASI->AABFData;
pInBufEnd = pbIB + pAASI->cbCX;
ASSERT(AABFData.Flags & AABF_MASK_IS_ORDER);
ASSERT(dwABPreMul[0] == 0);
//
// If the pbIn[0], pbIn[1], pbIn[2] is greater than is alpha value in
// pbIn[3] then it will be some wrong xlate, but at here we trust that
// caller doing the right math for its RGB values
//
if (pAASI->Flags & AASIF_GRAY) {
PLONG pIdxBGR;
BGR8 bgr8;
pIdxBGR = pAASI->pIdxBGR;
ASSERT((LONG)pAASI->cbCX == (LONG)pAASI->cx);
ASSERT(pIdxBGR);
//
// When we need to translate from a 32-bits RGB source to gray, the
// pIdxBGR mapping table must already re-arranged to have
//
// pIdxBGR[ 0 - 255] for 1st byte source RGB order
// pIdxBGR[256 - 511] for 2nd byte source RGB order
// pIdxBGR[512 - 768] for 3rd byte source RGB order
//
do {
Mul = (DWORD)dwABPreMul[pbIn[3]];
*pbIB = IDXBGR_2_GRAY_BYTE(pIdxBGR,
GET_PREMUL_SRC(pbIn[0], Mul),
GET_PREMUL_SRC(pbIn[1], Mul),
GET_PREMUL_SRC(pbIn[2], Mul));
pbIn += 4;
} while (++pbIB < pInBufEnd);
} else {
ASSERT(pAASI->cbCX == (LONG)(pAASI->cx * sizeof(BGR8)));
if (AABFData.Flags & AABF_SRC_IS_BGR_ALPHA) {
do {
Mul = (DWORD)dwABPreMul[pbIn[3]];
pInBuf->b = GET_PREMUL_SRC(pbIn[0], Mul);
pInBuf->g = GET_PREMUL_SRC(pbIn[1], Mul);
pInBuf->r = GET_PREMUL_SRC(pbIn[2], Mul);
pbIn += 4;
} while (++pInBuf < (PBGR8)pInBufEnd);
} else if (AABFData.Flags & AABF_SRC_IS_RGB_ALPHA) {
do {
Mul = (DWORD)dwABPreMul[pbIn[3]];
pInBuf->r = GET_PREMUL_SRC(pbIn[0], Mul);
pInBuf->g = GET_PREMUL_SRC(pbIn[1], Mul);
pInBuf->b = GET_PREMUL_SRC(pbIn[2], Mul);
pbIn += 4;
} while (++pInBuf < (PBGR8)pInBufEnd);
} else {
do {
Mul = (DWORD)dwABPreMul[pbIn[3]];
bgr[0] = pbIn[mB];
bgr[1] = pbIn[mG];
bgr[2] = pbIn[mR];
pInBuf->b = GET_PREMUL_SRC(bgr[0], Mul);
pInBuf->g = GET_PREMUL_SRC(bgr[1], Mul);
pInBuf->r = GET_PREMUL_SRC(bgr[2], Mul);
pbIn += 4;
} while (++pInBuf < (PBGR8)pInBufEnd);
}
}
SET_NEXT_PIN(pAASI);
return(pRet);
#undef mR
#undef mG
#undef mB
#undef pbIB
}
PBGR8
HTENTRY
InputAABFDATAToAA24(
PAASURFINFO pAASI,
PBGR8 pInBuf
)
/*++
Routine Description:
This function read input from a 16/24/32 bits per pixel source, these
source can be bit mask type of source (16/32 bits)
Arguments:
Return Value:
Author:
12-Mar-1999 Fri 12:53:16 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
#define pbIB ((LPBYTE)pInBuf)
#define pwIn ((LPWORD)pbIn)
#define pdwIn ((LPDWORD)pbIn)
#define mR (AABFData.MaskRGB[0])
#define mG (AABFData.MaskRGB[1])
#define mB (AABFData.MaskRGB[2])
#define lR (AABFData.LShiftRGB[0])
#define lG (AABFData.LShiftRGB[1])
#define lB (AABFData.LShiftRGB[2])
#define rR (AABFData.RShiftRGB[0])
#define rG (AABFData.RShiftRGB[1])
#define rB (AABFData.RShiftRGB[2])
#define GET_AABFDATA_BGR8(pbgr8, dwIn) \
{ \
(pbgr8)->r = (BYTE)(((dwIn >> rR) << lR) & mR); \
(pbgr8)->g = (BYTE)(((dwIn >> rG) << lG) & mG); \
(pbgr8)->b = (BYTE)(((dwIn >> rB) << lB) & mB); \
}
LPBYTE pbIn;
PBGR8 pRet;
LPBYTE pInBufEnd;
AABFDATA AABFData;
DWORD dwIn;
UINT cbSrcInc;
pbIn = (LPBYTE)pAASI->pb;
pRet = pInBuf;
AABFData = pAASI->AABFData;
cbSrcInc = (UINT)AABFData.cbSrcInc;
pInBufEnd = (LPBYTE)pInBuf + pAASI->cbCX;
if (pAASI->Flags & AASIF_GRAY) {
PLONG pIdxBGR;
BGR8 bgr8;
ASSERT((LONG)pAASI->cbCX == (LONG)pAASI->cx);
pIdxBGR = pAASI->pIdxBGR;
pInBufEnd = pbIB + pAASI->cx;
if (AABFData.Flags & AABF_MASK_IS_ORDER) {
//
// When we have AASIF_GRAY, the pIdxBGR must already re-arranged
// to have
//
// pIdxBGR[ 0 - 255] for 1st byte source RGB order
// pIdxBGR[256 - 511] for 2nd byte source RGB order
// pIdxBGR[512 - 768] for 3rd byte source RGB order
//
do {
*pbIB = IDXBGR_2_GRAY_BYTE(pIdxBGR, pbIn[0], pbIn[1], pbIn[2]);
pbIn += cbSrcInc;
} while (++pbIB < pInBufEnd);
} else if (cbSrcInc == 4) {
do {
dwIn = (DWORD)*pdwIn++;
GET_AABFDATA_BGR8(&bgr8, dwIn);
*pbIB = IDXBGR_2_GRAY_BYTE(pIdxBGR, bgr8.b, bgr8.g, bgr8.r);
} while (++pbIB < pInBufEnd);
} else {
ASSERT(cbSrcInc == 2);
do {
dwIn = (DWORD)*pwIn++;
GET_AABFDATA_BGR8(&bgr8, dwIn);
*pbIB = IDXBGR_2_GRAY_BYTE(pIdxBGR, bgr8.b, bgr8.g, bgr8.r);
} while (++pbIB < pInBufEnd);
}
} else {
ASSERT(pAASI->cbCX == (LONG)(pAASI->cx * sizeof(BGR8)));
if (AABFData.Flags & AABF_MASK_IS_ORDER) {
if (AABFData.Flags & AABF_SRC_IS_BGR8) {
CopyMemory(pInBuf, pbIn, pAASI->cbCX);
} else {
do {
pInBuf->r = pbIn[mR];
pInBuf->g = pbIn[mG];
pInBuf->b = pbIn[mB];
pbIn += cbSrcInc;
} while (++pInBuf < (PBGR8)pInBufEnd);
}
} else if (cbSrcInc == 4) {
do {
dwIn = (DWORD)*pdwIn++;
GET_AABFDATA_BGR8(pInBuf, dwIn);
} while (++pInBuf < (PBGR8)pInBufEnd);
} else {
ASSERT(cbSrcInc == 2);
do {
dwIn = (DWORD)*pwIn++;
GET_AABFDATA_BGR8(pInBuf, dwIn);
} while (++pInBuf < (PBGR8)pInBufEnd);
}
}
SET_NEXT_PIN(pAASI);
return(pRet);
#undef mR
#undef mG
#undef mB
#undef lR
#undef lG
#undef lB
#undef rR
#undef rG
#undef rB
#undef pwIn
#undef pdwIn
#undef pbIB
}
#if DBG
LPSTR
GetAAInputFuncName(
AAINPUTFUNC AAInputFunc
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
06-Jan-1999 Wed 19:11:27 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
if (AAInputFunc == (AAINPUTFUNC)Input1BPPToAA24) {
return("Input1BPPToAA24");
} else if (AAInputFunc == (AAINPUTFUNC)Input4BPPToAA24) {
return("Input4BPPToAA24");
} else if (AAInputFunc == (AAINPUTFUNC)Input8BPPToAA24) {
return("Input8BPPToAA24");
} else if (AAInputFunc == (AAINPUTFUNC)InputPreMul32BPPToAA24) {
return("InputPreMul32BPPToAA24");
} else if (AAInputFunc == (AAINPUTFUNC)InputAABFDATAToAA24) {
return("InputAABFDATAToAA24");
} else {
return("ERROR: Unknown Function");
}
}
#endif
PBGR8
HTENTRY
FixupGrayScan(
PAAHEADER pAAHdr,
PBGR8 pInBuf
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
13-Apr-1999 Tue 11:48:14 created -by- Daniel Chou (danielc)
Revision History:
06-May-1999 Thu 13:07:49 updated -by- Daniel Chou (danielc)
The pInBuf can be NULL now
--*/
{
FIXUPDIBINFO FUDI;
LPBYTE pS0;
LPBYTE pS1;
LPBYTE pS2;
LPBYTE pS3;
LPBYTE pD1;
LPBYTE pD2;
UINT cIn;
UINT cbIn;
BYTE Mask;
cbIn =
cIn = (UINT)pAAHdr->SrcSurfInfo.cx;
FUDI = pAAHdr->FUDI;
if (pAAHdr->Flags & AAHF_GET_LAST_SCAN) {
pS0 = (LPBYTE)FUDI.prgbD[4];
pAAHdr->Flags &= ~AAHF_GET_LAST_SCAN;
DBGP_IF(DBGP_GETFIXUP,
DBGP("*** GetFixupScan: Re-Copy cyIn=%ld LAST SCANLINE ***"
ARGDW(FUDI.cyIn)));
++FUDI.cyIn;
} else if (FUDI.cyIn <= 1) {
pS0 = (LPBYTE)FUDI.prgbD[5];
DBGP_IF(DBGP_GETFIXUP,
DBGP("*** GetFixupScan: cyIn=%ld, FINAL SCANLINE, cChecker=%ld, cCorner=%ld, Tot=%ld"
ARGDW(FUDI.cyIn)
ARGDW(pAAHdr->FUDI.cChecker)
ARGDW(pAAHdr->FUDI.cCorner)
ARGDW(pAAHdr->FUDI.cCorner + pAAHdr->FUDI.cChecker)));
} else {
DWORD g0;
DWORD g1;
LONG c0;
LONG c1;
LONG c2;
LONG c3;
LONG c0L;
LONG c0T;
LONG c1R;
LONG c1T;
LONG c2L;
LONG c2B;
LONG c3R;
LONG c3B;
//
// Scroll up the scan lines
//
pD2 = (LPBYTE)FUDI.prgbD[0];
CopyMemory(&FUDI.prgbD[0], &FUDI.prgbD[1], sizeof(FUDI.prgbD[0]) * 5);
FUDI.prgbD[5] = (PBGR8)pD2;
pS0 = (LPBYTE)FUDI.prgbD[0];
pS1 = (LPBYTE)FUDI.prgbD[1];
pS2 = (LPBYTE)FUDI.prgbD[2];
pS3 = (LPBYTE)FUDI.prgbD[3];
pD1 = (LPBYTE)FUDI.prgbD[4];
CopyMemory(pD2, pS2, FUDI.cbbgr);
//
// Save the next source scan line
//
if (pAAHdr->SrcSurfInfo.cy > 0) {
pAAHdr->SrcSurfInfo.InputFunc(&(pAAHdr->SrcSurfInfo),
(PBGR8)(pS3 + 1));
*(pS3 + 0) = *(pS3 + 2);
*(pS3 + cIn + 1) = *(pS3 + cIn - 1);
} else {
//
// No more scan lines, so copy the prev -2
//
CopyMemory(pS3, pS1, FUDI.cbbgr);
}
c0 = (LONG)*(pS1 + 0);
c2 = (LONG)*(pS2 + 0);
c1 = (LONG)*(pS1 + 1);
c3 = (LONG)*(pS2 + 1);
c1R = (LONG)*(pS1 + 2);
c3R = (LONG)*(pS2 + 2);
g1 = c1;
while (--cIn) {
c0L = c0;
c2L = c2;
c0 = c1;
c2 = c3;
c1 = c1R;
c3 = c3R;
c1R = (LONG)*(pS1 + 3);
c3R = (LONG)*(pS2 + 3);
g0 = g1;
g1 = c1;
if ((c0 != c1) && (!((c0 ^ c3) | (c1 ^ c2)))) {
c0T = (LONG)*(pS0 + 1);
c1T = (LONG)*(pS0 + 2);
c2B = (LONG)*(pS3 + 1);
c3B = (LONG)*(pS3 + 2);
if ((!((c0L ^ c1) | (c2L ^ c3) | (c1R ^ c0) | (c3R ^ c2))) ||
(!((c0T ^ c2) | (c1T ^ c3) | (c2B ^ c0) | (c3B ^ c1)))) {
*(pD1 + 1) =
*(pD1 + 2) =
*(pD2 + 1) =
*(pD2 + 2) = (BYTE)(((LONG)*(pS1 + 1) +
(LONG)*(pS1 + 2) + 1) >> 1);
SETDBGVAR(FUDI.cChecker, FUDI.cChecker + 1);
} else {
if (g0 >= g1) {
SET_CORNER_GRAY(pD1 + 1, c1, c1R, c2, c2B);
SET_CORNER_GRAY(pD2 + 2, c1, c1T, c2, c2L);
} else {
SET_CORNER_GRAY(pD1 + 2, c0, c0L, c3, c3B);
SET_CORNER_GRAY(pD2 + 1, c0, c0T, c3, c3R);
}
SETDBGVAR(FUDI.cCorner, FUDI.cCorner + 1);
}
}
++pS0;
++pS1;
++pS2;
++pS3;
++pD1;
++pD2;
}
pS0 = (LPBYTE)FUDI.prgbD[4];
DBGP_IF(DBGP_GETFIXUP,
DBGP("*** GetFixupScan: cyIn=%ld" ARGDW(FUDI.cyIn - 1)));
}
if (pInBuf) {
CopyMemory(pInBuf, pS0 + 1, cbIn);
}
--FUDI.cyIn;
pAAHdr->FUDI = FUDI;
return(pInBuf);
}
PBGR8
HTENTRY
FixupColorScan(
PAAHEADER pAAHdr,
PBGR8 pInBuf
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
13-Apr-1999 Tue 11:48:20 created -by- Daniel Chou (danielc)
Revision History:
06-May-1999 Thu 13:07:49 updated -by- Daniel Chou (danielc)
The pInBuf can be NULL now
--*/
{
FIXUPDIBINFO FUDI;
PBGR8 pS0;
PBGR8 pS1;
PBGR8 pS2;
PBGR8 pS3;
PBGR8 pD1;
PBGR8 pD2;
UINT cIn;
UINT cbIn;
BYTE Mask;
cIn = (UINT)pAAHdr->SrcSurfInfo.cx;
cbIn = (UINT)pAAHdr->SrcSurfInfo.cbCX;
FUDI = pAAHdr->FUDI;
if (pAAHdr->Flags & AAHF_GET_LAST_SCAN) {
pS0 = FUDI.prgbD[4];
pAAHdr->Flags &= ~AAHF_GET_LAST_SCAN;
DBGP_IF(DBGP_GETFIXUP,
DBGP("*** GetFixupScan: Re-Copy cyIn=%ld LAST SCANLINE ***"
ARGDW(FUDI.cyIn)));
++FUDI.cyIn;
} else if (FUDI.cyIn <= 1) {
pS0 = FUDI.prgbD[5];
DBGP_IF(DBGP_GETFIXUP,
DBGP("*** GetFixupScan: cyIn=%ld, FINAL SCANLINE, cChecker=%ld, cCorner=%ld, Tot=%ld"
ARGDW(FUDI.cyIn)
ARGDW(pAAHdr->FUDI.cChecker)
ARGDW(pAAHdr->FUDI.cCorner)
ARGDW(pAAHdr->FUDI.cCorner + pAAHdr->FUDI.cChecker)));
} else {
DWORD g0;
DWORD g1;
LONG c0;
LONG c1;
LONG c2;
LONG c3;
LONG c0L;
LONG c0T;
LONG c1R;
LONG c1T;
LONG c2L;
LONG c2B;
LONG c3R;
LONG c3B;
//
// Scroll up the scan lines
//
pD2 = FUDI.prgbD[0];
CopyMemory(&FUDI.prgbD[0], &FUDI.prgbD[1], sizeof(FUDI.prgbD[0]) * 5);
FUDI.prgbD[5] = pD2;
pS0 = FUDI.prgbD[0];
pS1 = FUDI.prgbD[1];
pS2 = FUDI.prgbD[2];
pS3 = FUDI.prgbD[3];
pD1 = FUDI.prgbD[4];
CopyMemory(pD2, pS2, FUDI.cbbgr);
//
// Save the next source scan line
//
if (pAAHdr->SrcSurfInfo.cy > 0) {
pAAHdr->SrcSurfInfo.InputFunc(&(pAAHdr->SrcSurfInfo), pS3 + 1);
*(pS3 + 0) = *(pS3 + 2);
*(pS3 + cIn + 1) = *(pS3 + cIn - 1);
} else {
//
// No more scan lines, so copy the prev -2
//
CopyMemory(pS3, pS1, FUDI.cbbgr);
}
c0 = GET_LBGR(pS1 + 0);
c2 = GET_LBGR(pS2 + 0);
c1 = GET_LBGR(pS1 + 1);
c3 = GET_LBGR(pS2 + 1);
c1R = GET_LBGR(pS1 + 2);
c3R = GET_LBGR(pS2 + 2);
g1 = GET_GRAY_RGB(pS1 + 1);
while (--cIn) {
c0L = c0;
c2L = c2;
c0 = c1;
c2 = c3;
c1 = c1R;
c3 = c3R;
c1R = GET_LBGR(pS1 + 3);
c3R = GET_LBGR(pS2 + 3);
g0 = g1;
g1 = GET_GRAY_RGB(pS1 + 2);
if ((c0 != c1) && (!((c0 ^ c3) | (c1 ^ c2)))) {
c0T = GET_LBGR(pS0 + 1);
c1T = GET_LBGR(pS0 + 2);
c2B = GET_LBGR(pS3 + 1);
c3B = GET_LBGR(pS3 + 2);
if ((!((c0L ^ c1) | (c2L ^ c3) | (c1R ^ c0) | (c3R ^ c2))) ||
(!((c0T ^ c2) | (c1T ^ c3) | (c2B ^ c0) | (c3B ^ c1)))) {
(pD1 + 1)->r =
(pD1 + 2)->r =
(pD2 + 1)->r =
(pD2 + 2)->r = (BYTE)(((LONG)(pS1 + 1)->r +
(LONG)(pS1 + 2)->r + 1) >> 1);
(pD1 + 1)->g =
(pD1 + 2)->g =
(pD2 + 1)->g =
(pD2 + 2)->g = (BYTE)(((LONG)(pS1 + 1)->g +
(LONG)(pS1 + 2)->g + 1) >> 1);
(pD1 + 1)->b =
(pD1 + 2)->b =
(pD2 + 1)->b =
(pD2 + 2)->b = (BYTE)(((LONG)(pS1 + 1)->b +
(LONG)(pS1 + 2)->b + 1) >> 1);
SETDBGVAR(FUDI.cChecker, FUDI.cChecker + 1);
} else {
if (g0 >= g1) {
SET_CORNER_BGR(pD1 + 1, c1, c1R, c2, c2B);
SET_CORNER_BGR(pD2 + 2, c1, c1T, c2, c2L);
} else {
SET_CORNER_BGR(pD1 + 2, c0, c0L, c3, c3B);
SET_CORNER_BGR(pD2 + 1, c0, c0T, c3, c3R);
}
SETDBGVAR(FUDI.cCorner, FUDI.cCorner + 1);
}
}
++pS0;
++pS1;
++pS2;
++pS3;
++pD1;
++pD2;
}
pS0 = FUDI.prgbD[4];
DBGP_IF(DBGP_GETFIXUP,
DBGP("*** GetFixupScan: cyIn=%ld" ARGDW(FUDI.cyIn - 1)));
}
if (pInBuf) {
CopyMemory(pInBuf, pS0 + 1, cbIn);
}
--FUDI.cyIn;
pAAHdr->FUDI = FUDI;
return(pInBuf);
}
PBGR8
HTENTRY
GetFixupScan(
PAAHEADER pAAHdr,
PBGR8 pInBuf
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
17-Oct-1998 Sat 15:25:57 created -by- Daniel Chou (danielc)
Revision History:
06-May-1999 Thu 13:07:49 updated -by- Daniel Chou (danielc)
The pInBuf can be NULL now
--*/
{
DWORD AAHFlags;
DBG_TIMER_BEG(TIMER_INPUT);
if (!((AAHFlags = pAAHdr->Flags) & AAHF_DO_FIXUPDIB)) {
if (AAHFlags & AAHF_GET_LAST_SCAN) {
if (++pAAHdr->SrcSurfInfo.cy > pAAHdr->SrcSurfInfo.cyOrg) {
DBGP("Error: GET_LAST_SCAN on first scan line %ld (%ld)"
ARGDW(pAAHdr->SrcSurfInfo.cy)
ARGDW(pAAHdr->SrcSurfInfo.cyOrg));
pAAHdr->SrcSurfInfo.cy = pAAHdr->SrcSurfInfo.cyOrg;
}
pAAHdr->SrcSurfInfo.pb = pAAHdr->SrcSurfInfo.pbOrg +
((pAAHdr->SrcSurfInfo.cyOrg -
pAAHdr->SrcSurfInfo.cy) *
pAAHdr->SrcSurfInfo.cyNext);
pAAHdr->SrcSurfInfo.Flags |= AASIF_INC_PB;
pAAHdr->Flags &= ~AAHF_GET_LAST_SCAN;
}
if (pInBuf) {
pAAHdr->SrcSurfInfo.InputFunc(&(pAAHdr->SrcSurfInfo), pInBuf);
} else {
SET_NEXT_PIN((&(pAAHdr->SrcSurfInfo)));
}
} else if (pAAHdr->SrcSurfInfo.Flags & AASIF_GRAY) {
FixupGrayScan(pAAHdr, pInBuf);
} else {
FixupColorScan(pAAHdr, pInBuf);
}
if ((pAAHdr->Flags & AAHF_DO_SRC_CLR_MAPPING) && (pInBuf)) {
MappingBGR(pInBuf,
pAAHdr->SrcSurfInfo.cx,
(PBGR8)pAAHdr->pBGRMapTable,
(LPBYTE)pAAHdr->AAPI.pbPat555);
if ((pAAHdr->AAPI.pbPat555 += pAAHdr->AAPI.cyNext555) ==
pAAHdr->AAPI.pbWrap555) {
pAAHdr->AAPI.pbPat555 = pAAHdr->AAPI.pbBeg555;
}
}
DBG_TIMER_END(TIMER_INPUT);
return(pInBuf);
}
BOOL
HTENTRY
CheckBMPNeedFixup(
PDEVICECOLORINFO pDCI,
PAAHEADER pAAHdr,
PHTSURFACEINFO pSrcSI,
PAABBP pAABBP
)
/*++
Routine Description:
This function check the bitmap to see if we need to do a fixup, if yes
then it allocated memory accordingly
Arguments:
Return Value:
Author:
07-Dec-1998 Mon 18:25:45 created -by- Daniel Chou (danielc)
Revision History:
15-Aug-2000 Tue 19:05:25 updated -by- Daniel Chou (danielc)
At pre-read checking, we HAVE TO turn off the the gray conversion
and Alpha Blending pre-multiply conversion.
--*/
{
LPBYTE pbAlloc = NULL;
LPBYTE pInEnd;
LPDWORD pdwBegPal;
LPDWORD pdwEndPal;
LPDWORD pdw;
AASURFINFO SrcSurfInfo;
RECTL rclSrc;
UINT SrcFmt;
LONG cIn;
LONG cbIn;
LONG cPalChk;
LONG cPalTot;
LONG cyIn;
LONG cySkip;
LONG cy;
DW2W4B dw4b;
DWORD AAHFlags;
BOOL NewPal;
DEFDBGVAR(LONG, iY)
SrcFmt = (UINT)pSrcSI->SurfaceFormat;
if (!((AAHFlags = pAABBP->AAHFlags) & AAHF_DO_FIXUPDIB)) {
DBGP_IF(DBGP_FUDI | DBGP_CHK_FUDI,
DBGP("CheckBMPNeedFixup(%ld)=No" ARGDW(SrcFmt)));
return(FALSE);
}
switch (SrcFmt) {
case BMF_1BPP:
case BMF_4BPP:
case BMF_4BPP_VGA16:
pAABBP->AAHFlags |= (AAHF_DO_FIXUPDIB | AAHF_BBPF_AA_OFF);
DBGP_IF(DBGP_FUDI | DBGP_CHK_FUDI,
DBGP("CheckBMPNeedFixup(%ld)=1BPP/4BPPNo, Check DIB and AA=OFF" ARGDW(SrcFmt)));
return(TRUE);
break;
case BMF_8BPP:
case BMF_8BPP_VGA256:
case BMF_16BPP:
case BMF_16BPP_555:
case BMF_16BPP_565:
case BMF_24BPP:
case BMF_32BPP:
rclSrc.left =
rclSrc.top = 0;
rclSrc.right = pSrcSI->Width;
rclSrc.bottom = pSrcSI->Height;
if (!IntersectRECTL(&rclSrc, &pAABBP->rclSrc)) {
return(FALSE);
}
//
// 15-Aug-2000 Tue 19:05:25 updated -by- Daniel Chou (danielc)
// At pre-read checking, we HAVE TO turn off the the gray conversion
// and Alpha Blending pre-multiply conversion.
//
SrcSurfInfo = pAAHdr->SrcSurfInfo;
SrcSurfInfo.Flags &= ~(AASIF_GRAY | AASIF_AB_PREMUL_SRC);
SrcSurfInfo.cyNext =
cIn = GET_PHTSI_CXSIZE(pSrcSI);
cyIn =
SrcSurfInfo.cy = rclSrc.bottom - rclSrc.top;
SrcSurfInfo.pb = pSrcSI->pPlane +
(rclSrc.top * cIn) +
ComputeByteOffset(SrcFmt,
rclSrc.left,
&(SrcSurfInfo.BitOffset));
SrcSurfInfo.cx =
cIn = rclSrc.right - rclSrc.left;
SrcSurfInfo.cbCX = cIn * sizeof(BGR8);
cySkip = 1;
ALIGN_MEM(cbIn, (cIn + 2) * sizeof(BGR8));
if ((cPalTot = cyIn * cIn) <= MIN_FIXUP_SIZE) {
DBGP_IF(DBGP_FUDI,
DBGP("cyIn=%ld x cIn==%ld = %ld (<= MIN_FIXUP_SIZE=%ld, Turn off AA"
ARGDW(cyIn) ARGDW(cIn) ARGDW(cPalTot)
ARGDW(MIN_FIXUP_SIZE)));
AAHFlags |= AAHF_BBPF_AA_OFF;
break;
} else if (cPalTot <= MIN_PAL_SIZE) {
DBGP_IF(DBGP_FUDI,
DBGP("cPalTot=%ld <= MIN_PAL_SIZE=%ld, cPalChk: %ld -> %ld"
ARGDW(cPalTot) ARGDW(MIN_PAL_SIZE)
ARGDW(cPalTot) ARGDW(GET_PAL_CHK_COUNT(cPalTot))));
cPalChk = GET_PAL_CHK_COUNT(cPalTot);
} else {
SrcSurfInfo.cy = (cyIn + STD_PAL_CY_SKIP - 1) / STD_PAL_CY_SKIP;
SrcSurfInfo.cyNext *= (cySkip = STD_PAL_CY_SKIP);
cPalChk = MAX_FIXUPDIB_PAL;
DBGP_IF(DBGP_FUDI,
DBGP("REGULAR BITMAP, cySkip=%ld, cy=%ld -> %ld, cPalChk=%ld (MAX_FIXUPDIB_PAL)"
ARGDW(cySkip) ARGDW(cyIn) ARGDW(SrcSurfInfo.cy)
ARGDW(cPalChk) ARGDW(MAX_FIXUPDIB_PAL)));
}
if (!(pbAlloc = (LPBYTE)HTAllocMem((LPVOID)pDCI,
HTMEM_FIXUPDIB,
LPTR,
cbIn + ((cPalChk + 1) *
sizeof(DWORD))))) {
DBGP("Error: Cannot Allocate FixupDIB memory=%ld bytes, Turn of FIXUP"
ARGDW(cbIn + ((cPalChk + 1) * sizeof(DWORD))));
pAABBP->AAHFlags = (AAHFlags & ~AAHF_DO_FIXUPDIB);
return(FALSE);
}
pdwEndPal =
pdwBegPal = (LPDWORD)(pbAlloc + cbIn);
pInEnd = (LPBYTE)pbAlloc + (cIn * sizeof(BGR8));
cPalTot = 0;
SETDBGVAR(iY, 0);
DBGP_IF(DBGP_FUDI,
DBGP("SrcInputFunc=%p, cySkip=%ld, pIn=%p, Fmt=%ld (%ld x %ld), cPalChk=%ld"
ARGPTR(SrcSurfInfo.InputFunc) ARGDW(cySkip)
ARGPTR(SrcSurfInfo.pb) ARGDW(SrcFmt)
ARGDW(cIn) ARGDW(cyIn) ARGDW(cPalChk)));
cbIn = (cyIn * cIn);
dw4b.dw = 0;
do {
PBGR8 pbgr;
//
// Try to read some lines and determine if this is a non primary
// color bitmap, we only fixed up the bitmap if any of RGB is
// 0x00, 0x40, 0x80, 0xc0, 0xFF
//
NewPal = FALSE;
pbgr = SrcSurfInfo.InputFunc(&SrcSurfInfo, (PBGR8)pbAlloc);
do {
//
// The first entry is the sentinal, so it always stop there
//
dw4b.b[0] = pbgr->g;
if ((dw4b.b[1] = pbgr->r) ==
(dw4b.b[2] = pbgr->b)) {
//
// This is a gray scale data, make it collapse by 4,
// the 0, 1, 2, 3 = 0, 4, 5, 6, 7 = 4,...., 252, 253,
// 254, 255 = 252
//
dw4b.dw &= 0xFCFCFCFC;
}
*pdwBegPal = dw4b.dw;
pdw = pdwEndPal;
while (*pdw != dw4b.dw) {
--pdw;
}
if (pdw == pdwBegPal) {
//
// We have new palette entry
//
if (++cPalTot > cPalChk) {
break;
}
*(++pdwEndPal) = dw4b.dw;
NewPal = TRUE;
}
} while (++pbgr < (PBGR8)pInEnd);
DBGP_IF(DBGP_FUDI,
DBGP("IsBmpNeedFixup(%4ld/%4ld) [%4ld/%4ld]: cPalTot=%4ld, cPalChk=%4ld"
ARGDW(iY) ARGDW(SrcSurfInfo.cy)
ARGDW((iY * cySkip) + 1)
ARGDW(cyIn) ARGDW(cPalTot) ARGDW(cPalChk)));
SETDBGVAR(iY, iY + 1);
if ((cPalChk != MAX_FIXUPDIB_PAL) && (!NewPal)) {
DBGP_IF(DBGP_FUDI,
DBGP("Same Scanline Pal (%4ld / %4ld), cPalChk=%ld (%ld)"
ARGDW(iY) ARGDW(SrcSurfInfo.cy)
ARGDW(cPalChk) ARGDW(MAX_FIXUPDIB_PAL)));
//
// Scan line is same, so reduced the cPalChk for SMALL BMP
//
if ((cbIn -= cIn) <= MIN_FIXUP_SIZE) {
DBGP_IF(DBGP_FUDI | DBGP_CHK_FUDI,
DBGP("cx*cy=%ld <= MIN_FIXUP_SIZE=%ld, Turn off AA"
ARGDW(cbIn) ARGDW(MIN_FIXUP_SIZE)));
AAHFlags |= AAHF_BBPF_AA_OFF;
break;
}
cPalChk = GET_PAL_CHK_COUNT2(cbIn);
}
} while ((cPalTot <= cPalChk) && (SrcSurfInfo.cy));
DBGP_IF(DBGP_CHK_FUDI,
DBGP("IsBmpNeedFixup(): cPalChk=%ld, cy=%ld, cPalTot=%ld"
ARGDW(cPalChk) ARGDW((iY * cySkip) + 1)
ARGDW(cPalTot)));
if (cPalTot < MAX_FIXUPDIB_PAL) {
DBGP_IF(DBGP_FUDI | DBGP_CHK_FUDI,
DBGP("cPalTot=%ld < MAX_FIXUPDIB_PAL (%ld) Turn off AA"
ARGDW(cPalTot) ARGDW(MAX_FIXUPDIB_PAL)));
AAHFlags |= AAHF_BBPF_AA_OFF;
}
if (cPalChk == MAX_FIXUPDIB_PAL) {
//
// We are checking regular size bitmap, turn OFF FIXUPDIB if
// cPalTot > cPalChk
//
if (cPalTot > cPalChk) {
AAHFlags &= ~AAHF_DO_FIXUPDIB;
}
DBGP_IF(DBGP_FUDI | DBGP_CHK_FUDI,
DBGP("Checking REGULAR BITMAP: cPalTot=%ld, cPalChk=%ld, DO_FIXUP=%hs"
ARGDW(cPalTot) ARGDW(cPalChk)
ARGPTR((AAHFlags & AAHF_DO_FIXUPDIB) ? "Yes" : "No")));
} else {
//
// We are checking bitmap size <= MIN_PAL_SIZE (smaller size)
// the FIXUPDIB will be turn ON if (cPalTot <= MAX_FIXUPDIB_PAL) ||
// (cPalTot > cPalChk)
//
if ((cPalTot > MAX_FIXUPDIB_PAL) ||
(cPalTot <= cPalChk)) {
AAHFlags &= ~AAHF_DO_FIXUPDIB;
}
DBGP_IF(DBGP_FUDI | DBGP_CHK_FUDI,
DBGP("Checking SMALL BITMAP: Min=%ld, cPalTot=%ld, cPalChk=%ld, DO_FIXUP=%hs"
ARGDW(MAX_FIXUPDIB_PAL) ARGDW(cPalTot) ARGDW(cPalChk)
ARGPTR((AAHFlags & AAHF_DO_FIXUPDIB) ? "Yes" : "No")));
}
}
if (pbAlloc) {
HTFreeMem(pbAlloc);
}
pAABBP->AAHFlags = AAHFlags;
DBGP_IF(DBGP_FUDI | DBGP_CHK_FUDI,
DBGP("CheckBMPNeedFixup(%ld): DoFixup=%hs, AA=%hs"
ARGDW(SrcFmt)
ARGPTR((AAHFlags & AAHF_DO_FIXUPDIB) ? "Yes" : "No")
ARGPTR((AAHFlags & AAHF_BBPF_AA_OFF) ? "Off" : "On")));
return((BOOL)(AAHFlags & AAHF_DO_FIXUPDIB));
}
VOID
HTENTRY
InitializeFUDI(
PAAHEADER pAAHdr
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
16-Dec-1998 Wed 17:30:34 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PBGR8 pbgr;
LPBYTE pb;
UINT cIn;
UINT i;
pAAHdr->FUDI.cyIn = (pAAHdr->Flags & AAHF_TILE_SRC) ?
pAAHdr->DstSurfInfo.cy :
pAAHdr->SrcSurfInfo.cy;
cIn = pAAHdr->SrcSurfInfo.cx;
if (pAAHdr->SrcSurfInfo.Flags & AASIF_GRAY) {
for (i = 2; i <= 3; i++) {
pb = (LPBYTE)pAAHdr->FUDI.prgbD[i];
pAAHdr->SrcSurfInfo.InputFunc(&(pAAHdr->SrcSurfInfo),
(PBGR8)(pb + 1));
*(pb + 0) = *(pb + 2);
*(pb + cIn + 1) = *(pb + cIn - 1);
}
} else {
for (i = 2; i <= 3; i++) {
pbgr = pAAHdr->FUDI.prgbD[i];
pAAHdr->SrcSurfInfo.InputFunc(&(pAAHdr->SrcSurfInfo), pbgr + 1);
*(pbgr + 0) = *(pbgr + 2);
*(pbgr + cIn + 1) = *(pbgr + cIn - 1);
}
}
//
// Save this one in case we need to copy first scan line
//
CopyMemory(pAAHdr->FUDI.prgbD[5],
pAAHdr->FUDI.prgbD[2],
pAAHdr->FUDI.cbbgr);
CopyMemory(pAAHdr->FUDI.prgbD[1],
pAAHdr->FUDI.prgbD[3],
pAAHdr->FUDI.cbbgr);
}