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.
822 lines
19 KiB
822 lines
19 KiB
#include "stdafx.h"
|
|
#include "pngfilt.h"
|
|
#include "resource.h"
|
|
#include "cpngfilt.h"
|
|
#include "scanline.h"
|
|
|
|
void DuplicateScanLineARGB32( void* pScanLine, ULONG nDeltaX, ULONG nFullPixels,
|
|
ULONG nFullPixelWidth, ULONG nPartialPixelWidth )
|
|
{
|
|
BYTE* pbSrcPixel;
|
|
BYTE* pbDestPixel;
|
|
ULONG iSrcPixel;
|
|
ULONG iDestPixel;
|
|
BYTE bAlpha;
|
|
BYTE bRed;
|
|
BYTE bGreen;
|
|
BYTE bBlue;
|
|
|
|
pbSrcPixel = LPBYTE( pScanLine );
|
|
|
|
for( iSrcPixel = 0; iSrcPixel < nFullPixels; iSrcPixel++ )
|
|
{
|
|
bAlpha = pbSrcPixel[4];
|
|
bRed = pbSrcPixel[2];
|
|
bGreen = pbSrcPixel[1];
|
|
bBlue = pbSrcPixel[0];
|
|
pbDestPixel = pbSrcPixel+4;
|
|
|
|
for( iDestPixel = 1; iDestPixel < nFullPixelWidth; iDestPixel++ )
|
|
{
|
|
pbDestPixel[0] = bBlue;
|
|
pbDestPixel[1] = bGreen;
|
|
pbDestPixel[2] = bRed;
|
|
pbDestPixel[3] = bAlpha;
|
|
|
|
pbDestPixel += 4;
|
|
}
|
|
|
|
pbSrcPixel += 4*nDeltaX;
|
|
}
|
|
|
|
if( nPartialPixelWidth > 0 )
|
|
{
|
|
bAlpha = pbSrcPixel[3];
|
|
bRed = pbSrcPixel[2];
|
|
bGreen = pbSrcPixel[1];
|
|
bBlue = pbSrcPixel[0];
|
|
pbDestPixel = pbSrcPixel+4;
|
|
|
|
for( iDestPixel = 1; iDestPixel < nPartialPixelWidth; iDestPixel++ )
|
|
{
|
|
pbDestPixel[0] = bBlue;
|
|
pbDestPixel[1] = bGreen;
|
|
pbDestPixel[2] = bRed;
|
|
pbDestPixel[3] = bAlpha;
|
|
|
|
pbDestPixel += 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DuplicateScanLineBGR24( void* pScanLine, ULONG nDeltaX, ULONG nFullPixels,
|
|
ULONG nFullPixelWidth, ULONG nPartialPixelWidth )
|
|
{
|
|
BYTE* pbSrcPixel;
|
|
BYTE* pbDestPixel;
|
|
ULONG iSrcPixel;
|
|
ULONG iDestPixel;
|
|
BYTE bRed;
|
|
BYTE bGreen;
|
|
BYTE bBlue;
|
|
|
|
pbSrcPixel = LPBYTE( pScanLine );
|
|
|
|
for( iSrcPixel = 0; iSrcPixel < nFullPixels; iSrcPixel++ )
|
|
{
|
|
bRed = pbSrcPixel[2];
|
|
bGreen = pbSrcPixel[1];
|
|
bBlue = pbSrcPixel[0];
|
|
pbDestPixel = pbSrcPixel+3;
|
|
|
|
for( iDestPixel = 1; iDestPixel < nFullPixelWidth; iDestPixel++ )
|
|
{
|
|
pbDestPixel[0] = bBlue;
|
|
pbDestPixel[1] = bGreen;
|
|
pbDestPixel[2] = bRed;
|
|
|
|
pbDestPixel += 3;
|
|
}
|
|
|
|
pbSrcPixel += 3*nDeltaX;
|
|
}
|
|
|
|
if( nPartialPixelWidth > 0 )
|
|
{
|
|
bRed = pbSrcPixel[2];
|
|
bGreen = pbSrcPixel[1];
|
|
bBlue = pbSrcPixel[0];
|
|
pbDestPixel = pbSrcPixel+3;
|
|
|
|
for( iDestPixel = 1; iDestPixel < nPartialPixelWidth; iDestPixel++ )
|
|
{
|
|
pbDestPixel[0] = bBlue;
|
|
pbDestPixel[1] = bGreen;
|
|
pbDestPixel[2] = bRed;
|
|
|
|
pbDestPixel += 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DuplicateScanLineIndex8( void* pScanLine, ULONG nDeltaX,
|
|
ULONG nFullPixels, ULONG nFullPixelWidth, ULONG nPartialPixelWidth )
|
|
{
|
|
BYTE* pbSrcPixel;
|
|
BYTE* pbDestPixel;
|
|
ULONG iSrcPixel;
|
|
ULONG iDestPixel;
|
|
BYTE bIndex;
|
|
|
|
pbSrcPixel = LPBYTE( pScanLine );
|
|
|
|
for( iSrcPixel = 0; iSrcPixel < nFullPixels; iSrcPixel++ )
|
|
{
|
|
bIndex = pbSrcPixel[0];
|
|
pbDestPixel = pbSrcPixel+1;
|
|
|
|
for( iDestPixel = 1; iDestPixel < nFullPixelWidth; iDestPixel++ )
|
|
{
|
|
pbDestPixel[0] = bIndex;
|
|
|
|
pbDestPixel++;
|
|
}
|
|
|
|
pbSrcPixel += nDeltaX;
|
|
}
|
|
|
|
if( nPartialPixelWidth > 0 )
|
|
{
|
|
bIndex = pbSrcPixel[0];
|
|
pbDestPixel = pbSrcPixel+1;
|
|
|
|
for( iDestPixel = 1; iDestPixel < nPartialPixelWidth; iDestPixel++ )
|
|
{
|
|
pbDestPixel[0] = bIndex;
|
|
|
|
pbDestPixel++;
|
|
}
|
|
}
|
|
}
|
|
|
|
const float RECIP65535 = 1.0f/65535.0f;
|
|
const float RECIP255 = 1.0f/255.0f;
|
|
|
|
void CopyScanLineRGBA64ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
float fAlpha;
|
|
float fInverseAlpha;
|
|
float fSrcRed;
|
|
float fSrcGreen;
|
|
float fSrcBlue;
|
|
float fDestRed;
|
|
float fDestGreen;
|
|
float fDestBlue;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
fAlpha = ((pbSrc[6]<<8)+pbSrc[7])*RECIP65535;
|
|
fInverseAlpha = 1.0f-fAlpha;
|
|
|
|
fSrcRed = ((pbSrc[0]<<8)+pbSrc[1])*RECIP65535;
|
|
fSrcGreen = ((pbSrc[2]<<8)+pbSrc[3])*RECIP65535;
|
|
fSrcBlue = ((pbSrc[4]<<8)+pbSrc[5])*RECIP65535;
|
|
|
|
fDestRed = (fAlpha*fSrcRed)+(fInverseAlpha*pfrgbBackground->fRed);
|
|
fDestGreen = (fAlpha*fSrcGreen)+(fInverseAlpha*pfrgbBackground->fGreen);
|
|
fDestBlue = (fAlpha*fSrcBlue)+(fInverseAlpha*pfrgbBackground->fBlue);
|
|
|
|
pbDest[0] = pXlate[BYTE(fDestBlue*255.0f)];
|
|
pbDest[1] = pXlate[BYTE(fDestGreen*255.0f)];
|
|
pbDest[2] = pXlate[BYTE(fDestRed*255.0f)];
|
|
|
|
pbSrc += 8;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineRGBA32ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
float fAlpha;
|
|
float fInverseAlpha;
|
|
float fSrcRed;
|
|
float fSrcGreen;
|
|
float fSrcBlue;
|
|
float fDestRed;
|
|
float fDestGreen;
|
|
float fDestBlue;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
fAlpha = pbSrc[3]*RECIP255;
|
|
fInverseAlpha = 1.0f-fAlpha;
|
|
|
|
fSrcRed = pbSrc[0]*RECIP255;
|
|
fSrcGreen = pbSrc[1]*RECIP255;
|
|
fSrcBlue = pbSrc[2]*RECIP255;
|
|
|
|
fDestRed = (fAlpha*fSrcRed)+(fInverseAlpha*pfrgbBackground->fRed);
|
|
fDestGreen = (fAlpha*fSrcGreen)+(fInverseAlpha*pfrgbBackground->fGreen);
|
|
fDestBlue = (fAlpha*fSrcBlue)+(fInverseAlpha*pfrgbBackground->fBlue);
|
|
|
|
pbDest[0] = pXlate[BYTE(fDestBlue*255.0f)];
|
|
pbDest[1] = pXlate[BYTE(fDestGreen*255.0f)];
|
|
pbDest[2] = pXlate[BYTE(fDestRed*255.0f)];
|
|
|
|
pbSrc += 4;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineGrayA32ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
float fAlpha;
|
|
float fInverseAlpha;
|
|
float fSrc;
|
|
float fDest;
|
|
BYTE bDest;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
fAlpha = ((pbSrc[2]<<8)+pbSrc[3])*RECIP65535;
|
|
fInverseAlpha = 1.0f-fAlpha;
|
|
|
|
fSrc = ((pbSrc[0]<<8)+pbSrc[1])*RECIP65535;
|
|
|
|
fDest = (fAlpha*fSrc)+(fInverseAlpha*pfrgbBackground->fRed);
|
|
bDest = pXlate[BYTE(fDest*255.0f)];
|
|
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
pbSrc += 4;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineGrayA16ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
float fAlpha;
|
|
float fInverseAlpha;
|
|
float fSrc;
|
|
float fDest;
|
|
BYTE bDest;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
fAlpha = pbSrc[1]*RECIP255;
|
|
fInverseAlpha = 1.0f-fAlpha;
|
|
|
|
fSrc = pbSrc[0]*RECIP255;
|
|
|
|
fDest = (fAlpha*fSrc)+(fInverseAlpha*pfrgbBackground->fRed);
|
|
bDest = pXlate[BYTE(fDest*255.0f)];
|
|
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
pbSrc += 2;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineRGBA64ToBGRA32( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[4]];
|
|
pbDest[1] = pXlate[pbSrc[2]];
|
|
pbDest[2] = pXlate[pbSrc[0]];
|
|
pbDest[3] = pbSrc[6]; // alpha not gamma corrected
|
|
|
|
pbSrc += 8;
|
|
pbDest += 4*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineRGB48ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[4]];
|
|
pbDest[1] = pXlate[pbSrc[2]];
|
|
pbDest[2] = pXlate[pbSrc[0]];
|
|
|
|
pbSrc += 6;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineRGBA32ToBGRA32( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[2]];
|
|
pbDest[1] = pXlate[pbSrc[1]];
|
|
pbDest[2] = pXlate[pbSrc[0]];
|
|
pbDest[3] = pbSrc[3]; // alpha not gamma corrected
|
|
|
|
pbSrc += 4;
|
|
pbDest += 4*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineRGB24ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[2]];
|
|
pbDest[1] = pXlate[pbSrc[1]];
|
|
pbDest[2] = pXlate[pbSrc[0]];
|
|
|
|
pbSrc += 3;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineGrayA32ToBGRA32( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[0]];
|
|
pbDest[1] = pbDest[0];
|
|
pbDest[2] = pbDest[0];
|
|
pbDest[3] = pbSrc[2]; // alpha not gamma corrected
|
|
|
|
pbSrc += 4;
|
|
pbDest += 4*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineGray16ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[0]];
|
|
pbDest[1] = pbDest[0];
|
|
pbDest[2] = pbDest[0];
|
|
|
|
pbSrc += 2;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineGrayA16ToBGRA32( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[0]];
|
|
pbDest[1] = pbDest[0];
|
|
pbDest[2] = pbDest[0];
|
|
pbDest[3] = pbSrc[1];
|
|
|
|
pbSrc += 2;
|
|
pbDest += 4*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineGray8ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[0]];
|
|
pbDest[1] = pbDest[0];
|
|
pbDest[2] = pbDest[0];
|
|
|
|
pbSrc++;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineGray8ToGray8( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[0]];
|
|
|
|
pbSrc++;
|
|
pbDest += nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
static inline BYTE Expand4To8( ULONG nIntensity )
|
|
{
|
|
return( BYTE( nIntensity+(nIntensity<<4) ) );
|
|
}
|
|
|
|
void CopyScanLineGray4ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPair;
|
|
ULONG nPairs;
|
|
BYTE bSrc;
|
|
BYTE bDest;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
nPairs = nPixels/2;
|
|
for( iPair = 0; iPair < nPairs; iPair++ )
|
|
{
|
|
bSrc = pbSrc[0];
|
|
bDest = pXlate[BYTE((bSrc & 0xf0) + ((bSrc & 0xf0) >> 4))];
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
pbDest += 3*nDeltaXDest;
|
|
|
|
bDest = pXlate[BYTE((bSrc & 0x0f) + ((bSrc & 0x0f) << 4))];
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
pbDest += 3*nDeltaXDest;
|
|
pbSrc++;
|
|
}
|
|
|
|
if( (nPixels%2) > 0 )
|
|
{
|
|
bSrc = pbSrc[0];
|
|
bDest = pXlate[BYTE((bSrc & 0xf0) + ((bSrc & 0xf0) >> 4))];
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
}
|
|
}
|
|
|
|
static BYTE g_abExpand2To8[4] = { 0, 85, 170, 255 };
|
|
|
|
static inline BYTE Expand2To8( ULONG nIntensity )
|
|
{
|
|
return( g_abExpand2To8[nIntensity] );
|
|
}
|
|
|
|
void CopyScanLineGray2ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iQuad;
|
|
ULONG nQuads;
|
|
ULONG iPixel;
|
|
ULONG nShift;
|
|
ULONG nExtraPixels;
|
|
BYTE bSrc;
|
|
BYTE bDest;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
nQuads = nPixels/4;
|
|
for( iQuad = 0; iQuad < nQuads; iQuad++ )
|
|
{
|
|
bSrc = pbSrc[0];
|
|
nShift = 6;
|
|
for( iPixel = 0; iPixel < 4; iPixel++ )
|
|
{
|
|
bDest = pXlate[Expand2To8((bSrc >> nShift) & 0x03)];
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
nShift -= 2;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
|
|
pbSrc++;
|
|
}
|
|
|
|
nExtraPixels = nPixels%4;
|
|
if( nExtraPixels > 0 )
|
|
{
|
|
nShift = 6;
|
|
bSrc = pbSrc[0];
|
|
for( iPixel = 0; iPixel < nExtraPixels; iPixel++ )
|
|
{
|
|
bDest = pXlate[Expand2To8((bSrc >> nShift) & 0x03)];
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
nShift -= 2;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
}
|
|
|
|
static BYTE g_abExpand1To8[2] = { 0, 255 };
|
|
|
|
static inline BYTE Expand1To8( ULONG nIntensity )
|
|
{
|
|
return( g_abExpand1To8[nIntensity] );
|
|
}
|
|
|
|
void CopyScanLineGray1ToBGR24( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iOctet;
|
|
ULONG nOctets;
|
|
ULONG nShift;
|
|
ULONG nExtraPixels;
|
|
ULONG iPixel;
|
|
BYTE bSrc;
|
|
BYTE bDest;
|
|
|
|
(void)pfrgbBackground;
|
|
(void)pXlate;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
nOctets = nPixels/8;
|
|
for( iOctet = 0; iOctet < nOctets; iOctet++ )
|
|
{
|
|
bSrc = pbSrc[0];
|
|
nShift = 7;
|
|
for( iPixel = 0; iPixel < 8; iPixel++ )
|
|
{
|
|
bDest = Expand1To8( (bSrc>>nShift)&0x01 );
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
nShift--;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
|
|
pbSrc++;
|
|
}
|
|
|
|
nExtraPixels = nPixels%8;
|
|
if( nExtraPixels > 0 )
|
|
{
|
|
nShift = 7;
|
|
bSrc = pbSrc[0];
|
|
for( iPixel = 0; iPixel < nExtraPixels; iPixel++ )
|
|
{
|
|
bDest = Expand1To8( (bSrc>>nShift)&0x01 );
|
|
pbDest[0] = bDest;
|
|
pbDest[1] = bDest;
|
|
pbDest[2] = bDest;
|
|
|
|
nShift--;
|
|
pbDest += 3*nDeltaXDest;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CopyScanLineIndex8ToIndex8( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPixel;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
|
|
for( iPixel = 0; iPixel < nPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[pbSrc[0]];
|
|
|
|
pbSrc++;
|
|
pbDest += nDeltaXDest;
|
|
}
|
|
}
|
|
|
|
void CopyScanLineIndex4ToIndex8( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iPair;
|
|
ULONG nPairs;
|
|
BYTE bSrc;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
nPairs = nPixels/2;
|
|
for( iPair = 0; iPair < nPairs; iPair++ )
|
|
{
|
|
bSrc = pbSrc[0];
|
|
pbDest[0] = pXlate[BYTE((bSrc >> 4) & 0x0f)];
|
|
pbDest[nDeltaXDest] = pXlate[BYTE(bSrc & 0x0f)];
|
|
|
|
pbSrc++;
|
|
pbDest += 2*nDeltaXDest;
|
|
}
|
|
|
|
if( (nPixels%2) > 0 )
|
|
{
|
|
pbDest[0] = pXlate[BYTE((pbSrc[0] >> 4) & 0x0f)];
|
|
}
|
|
}
|
|
|
|
void CopyScanLineIndex2ToIndex8( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate )
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iQuad;
|
|
ULONG nQuads;
|
|
ULONG nShift;
|
|
ULONG nExtraPixels;
|
|
ULONG iPixel;
|
|
BYTE bSrc;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
nQuads = nPixels/4;
|
|
for( iQuad = 0; iQuad < nQuads; iQuad++ )
|
|
{
|
|
bSrc = pbSrc[0];
|
|
pbDest[0] = pXlate[BYTE((bSrc>>6) & 0x03)];
|
|
pbDest[nDeltaXDest] = pXlate[BYTE((bSrc >> 4) & 0x03)];
|
|
pbDest[2*nDeltaXDest] = pXlate[BYTE((bSrc >> 2) & 0x03)];
|
|
pbDest[3*nDeltaXDest] = pXlate[BYTE(bSrc & 0x03)];
|
|
|
|
pbSrc++;
|
|
pbDest += 4*nDeltaXDest;
|
|
}
|
|
|
|
nExtraPixels = nPixels%4;
|
|
if( nExtraPixels > 0 )
|
|
{
|
|
nShift = 6;
|
|
bSrc = pbSrc[0];
|
|
for( iPixel = 0; iPixel < nExtraPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[BYTE((bSrc >> nShift) & 0x03)];
|
|
nShift -= 2;
|
|
pbDest += nDeltaXDest;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CopyScanLineIndex1ToIndex8( void* pDest, const void* pSrc, ULONG nPixels,
|
|
ULONG nDeltaXDest, const FLOATRGB* pfrgbBackground, BYTE *pXlate)
|
|
{
|
|
const BYTE* pbSrc;
|
|
BYTE* pbDest;
|
|
ULONG iOctet;
|
|
ULONG nOctets;
|
|
ULONG nShift;
|
|
ULONG nExtraPixels;
|
|
ULONG iPixel;
|
|
BYTE bSrc;
|
|
|
|
(void)pfrgbBackground;
|
|
|
|
pbSrc = (const BYTE*)pSrc;
|
|
pbDest = LPBYTE( pDest );
|
|
nOctets = nPixels/8;
|
|
for( iOctet = 0; iOctet < nOctets; iOctet++ )
|
|
{
|
|
bSrc = pbSrc[0];
|
|
nShift = 7;
|
|
for( iPixel = 0; iPixel < 8; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[BYTE((bSrc>>nShift) &0x01)];
|
|
nShift--;
|
|
pbDest += nDeltaXDest;
|
|
}
|
|
|
|
pbSrc++;
|
|
}
|
|
|
|
nExtraPixels = nPixels%8;
|
|
if( nExtraPixels > 0 )
|
|
{
|
|
nShift = 7;
|
|
bSrc = pbSrc[0];
|
|
for( iPixel = 0; iPixel < nExtraPixels; iPixel++ )
|
|
{
|
|
pbDest[0] = pXlate[BYTE((bSrc>>nShift) &0x01)];
|
|
nShift--;
|
|
pbDest += nDeltaXDest;
|
|
}
|
|
}
|
|
}
|
|
|