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.
661 lines
19 KiB
661 lines
19 KiB
// File: Blt.cpp
|
|
// Author: Michael Marr (mikemarr)
|
|
//
|
|
// History:
|
|
// -@- 09/23/97 (mikemarr) copied to DXCConv from d2d\mmimage
|
|
// -@- 10/28/97 (mikemarr) added colorfill routines
|
|
//
|
|
// Notes:
|
|
// Asserts can not be used because the code may be executing on
|
|
// pixels in the front buffer. If there is an assertion failure,
|
|
// GDI might lock up.
|
|
|
|
#include "stdafx.h"
|
|
#include "PalMap.h"
|
|
#include "Blt.h"
|
|
|
|
ColorFillFn g_rgColorFillFn[5] = {
|
|
NULL, ColorFill8, ColorFill16, ColorFill24, ColorFill32
|
|
};
|
|
|
|
HasPixelFn g_rgHasPixelFn[5] = {
|
|
NULL, HasPixel8, HasPixel16, HasPixel24, HasPixel32
|
|
};
|
|
|
|
|
|
// Function: ColorFill
|
|
// These functions are designed for small color fills...
|
|
HRESULT
|
|
ColorFill8(BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, DWORD dwColor)
|
|
{
|
|
BYTE iColor = (BYTE) dwColor;
|
|
DWORD i, j;
|
|
for (i = 0; i < nHeight; i++) {
|
|
for (j = 0; j < nWidth; j++)
|
|
pDstPixels[j] = iColor;
|
|
pDstPixels += nDstPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
ColorFill16(BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, DWORD dwColor)
|
|
{
|
|
WORD wColor = (WORD) dwColor;
|
|
DWORD i, j;
|
|
for (i = 0; i < nHeight; i++) {
|
|
WORD *pwDstPixels = (WORD *) pDstPixels;
|
|
for (j = 0; j < nWidth; j++)
|
|
*pwDstPixels++ = wColor;
|
|
pDstPixels += nDstPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
ColorFill24(BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, DWORD dwColor)
|
|
{
|
|
BYTE c0 = (BYTE) dwColor;
|
|
BYTE c1 = (BYTE) (dwColor >> 8);
|
|
BYTE c2 = (BYTE) (dwColor >> 16);
|
|
DWORD i, j;
|
|
for (i = 0; i < nHeight; i++) {
|
|
BYTE *pDstNext = pDstPixels + nDstPitch;
|
|
for (j = 0; j < nWidth; j++) {
|
|
pDstPixels[0] = c0;
|
|
pDstPixels[1] = c1;
|
|
pDstPixels[2] = c2;
|
|
pDstPixels += 3;
|
|
}
|
|
pDstPixels = pDstNext;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
ColorFill32(BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, DWORD dwColor)
|
|
{
|
|
DWORD i, j;
|
|
for (i = 0; i < nHeight; i++) {
|
|
DWORD *pdwDstPixels = (DWORD *) pDstPixels;
|
|
for (j = 0; j < nWidth; j++)
|
|
*pdwDstPixels++ = dwColor;
|
|
pDstPixels += nDstPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
HasPixel8(const BYTE *pSrcPixels, DWORD nSrcPitch, DWORD dwPixel,
|
|
DWORD nSrcWidth, DWORD nHeight, BOOL *pb)
|
|
{
|
|
BYTE iPixel = (BYTE) dwPixel;
|
|
if (nSrcPitch == nSrcWidth) {
|
|
// do a flat search thru contiguous memory
|
|
*pb = (memchr(pSrcPixels, iPixel, nSrcPitch * nHeight) != NULL);
|
|
} else {
|
|
// do search line by line
|
|
for (; nHeight; nHeight--) {
|
|
if (memchr(pSrcPixels, iPixel, nSrcWidth) != NULL) {
|
|
*pb = TRUE;
|
|
return S_OK;
|
|
}
|
|
pSrcPixels += nSrcPitch;
|
|
}
|
|
*pb = FALSE;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
HasPixel16(const BYTE *pSrcPixels, DWORD nSrcPitch, DWORD dwPixel,
|
|
DWORD nSrcWidth, DWORD nHeight, BOOL *pb)
|
|
{
|
|
WORD wPixel = (WORD) dwPixel;
|
|
for (; nHeight; nHeight--) {
|
|
const WORD *pPixels = (const WORD *) pSrcPixels;
|
|
const WORD *pLimit = pPixels + nSrcWidth;
|
|
while (pPixels != pLimit) {
|
|
if (*pPixels++ == wPixel) {
|
|
*pb = TRUE;
|
|
return S_OK;
|
|
}
|
|
}
|
|
pSrcPixels += nSrcPitch;
|
|
}
|
|
*pb = FALSE;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
HasPixel24(const BYTE *pSrcPixels, DWORD nSrcPitch, DWORD dwPixel,
|
|
DWORD nSrcWidth, DWORD nHeight, BOOL *pb)
|
|
{
|
|
// REVIEW: only works on little endian machines
|
|
BYTE c0 = (BYTE) dwPixel;
|
|
BYTE c1 = (BYTE) (dwPixel >> 8);
|
|
BYTE c2 = (BYTE) (dwPixel >> 16);
|
|
DWORD nWidth = nSrcWidth * 3;
|
|
for (; nHeight; nHeight--) {
|
|
const BYTE *pPixels = pSrcPixels;
|
|
const BYTE *pLimit = pPixels + nWidth;
|
|
while (pPixels != pLimit) {
|
|
if ((pPixels[0] == c0) && (pPixels[1] == c1) && (pPixels[2] == c2)) {
|
|
*pb = TRUE;
|
|
return S_OK;
|
|
}
|
|
pPixels += 3;
|
|
}
|
|
pSrcPixels += nSrcPitch;
|
|
}
|
|
*pb = FALSE;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
HasPixel32(const BYTE *pSrcPixels, DWORD nSrcPitch, DWORD dwPixel,
|
|
DWORD nSrcWidth, DWORD nHeight, BOOL *pb)
|
|
{
|
|
for (; nHeight; nHeight--) {
|
|
const DWORD *pPixels = (const DWORD *) pSrcPixels;
|
|
const DWORD *pLimit = pPixels + nSrcWidth;
|
|
while (pPixels != pLimit) {
|
|
if (*pPixels++ == dwPixel) {
|
|
*pb = TRUE;
|
|
return S_OK;
|
|
}
|
|
}
|
|
pSrcPixels += nSrcPitch;
|
|
}
|
|
*pb = FALSE;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch, DWORD nSrcWidth, DWORD nHeight)
|
|
{
|
|
if (nSrcWidth == nDstPitch) {
|
|
// do a flat copy
|
|
memcpy(pDstPixels, pSrcPixels, nSrcPitch * nHeight);
|
|
} else {
|
|
LPBYTE pPixelLimit = pDstPixels + nDstPitch * nHeight;
|
|
// copy each row
|
|
for (; pDstPixels != pPixelLimit; ) {
|
|
memcpy(pDstPixels, pSrcPixels, nSrcWidth);
|
|
pDstPixels += nDstPitch;
|
|
pSrcPixels += nSrcPitch;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast8CK(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nSrcWidth, DWORD nHeight, DWORD dwTrans)
|
|
{
|
|
if ((nSrcWidth == 0) || (nHeight == 0))
|
|
return S_OK;
|
|
|
|
DWORD nRemainder = (nSrcWidth & 0x7);
|
|
DWORD nAligned = (nSrcWidth & ~0x7);
|
|
const BYTE *pSrcLineStart = pSrcPixels;
|
|
const BYTE *pPixelLimit = pSrcPixels + (nHeight * nSrcPitch);
|
|
DWORD nSrcAlignedPitch = nSrcPitch + nAligned;
|
|
DWORD nDstAlignedPitch = nDstPitch + nAligned;
|
|
pSrcPixels += nAligned;
|
|
pDstPixels += nAligned;
|
|
BYTE iTrans = BYTE(dwTrans), uch;
|
|
|
|
do {
|
|
switch (nRemainder) {
|
|
do {
|
|
case 0: pDstPixels -= 8; pSrcPixels -= 8;
|
|
if ((uch = pSrcPixels[7]) != iTrans) pDstPixels[7] = uch;
|
|
case 7: if ((uch = pSrcPixels[6]) != iTrans) pDstPixels[6] = uch;
|
|
case 6: if ((uch = pSrcPixels[5]) != iTrans) pDstPixels[5] = uch;
|
|
case 5: if ((uch = pSrcPixels[4]) != iTrans) pDstPixels[4] = uch;
|
|
case 4: if ((uch = pSrcPixels[3]) != iTrans) pDstPixels[3] = uch;
|
|
case 3: if ((uch = pSrcPixels[2]) != iTrans) pDstPixels[2] = uch;
|
|
case 2: if ((uch = pSrcPixels[1]) != iTrans) pDstPixels[1] = uch;
|
|
case 1: if ((uch = pSrcPixels[0]) != iTrans) pDstPixels[0] = uch;
|
|
} while (pSrcPixels != pSrcLineStart);
|
|
}
|
|
pSrcLineStart += nSrcPitch;
|
|
pSrcPixels += nSrcAlignedPitch;
|
|
pDstPixels += nDstAlignedPitch;
|
|
} while (pSrcLineStart != pPixelLimit);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFastMirrorY(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch, DWORD nSrcWidth, DWORD nHeight)
|
|
{
|
|
LPBYTE pPixelLimit = pDstPixels + nDstPitch * nHeight;
|
|
// set the src pixels to point to the last line of the bitmap
|
|
pSrcPixels += nSrcPitch * (nHeight - 1);
|
|
|
|
// copy each row
|
|
for (; pDstPixels != pPixelLimit; ) {
|
|
memcpy(pDstPixels, pSrcPixels, nSrcWidth);
|
|
pDstPixels += nDstPitch;
|
|
pSrcPixels -= nSrcPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFastRGBToRGB(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight,
|
|
const CPixelInfo &pixiSrc, const CPixelInfo &pixiDst)
|
|
{
|
|
if (pixiSrc.nBPP == 24) {
|
|
if (pixiDst.nBPP == 16)
|
|
return BltFast24To16(pSrcPixels, nSrcPitch, pDstPixels, nDstPitch,
|
|
nWidth, nHeight, pixiSrc, pixiDst);
|
|
if (pixiDst.nBPP == 32)
|
|
return BltFast24To32(pSrcPixels, nSrcPitch, pDstPixels, nDstPitch,
|
|
nWidth, nHeight, pixiSrc, pixiDst);
|
|
} else if (pixiSrc.nBPP == 32) {
|
|
if (pixiDst.nBPP == 32)
|
|
return BltFast32To32(pSrcPixels, nSrcPitch, pDstPixels, nDstPitch,
|
|
nWidth, nHeight, pixiSrc, pixiDst);
|
|
}
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast32To32(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight,
|
|
const CPixelInfo &pixiSrc, const CPixelInfo &pixiDst)
|
|
{
|
|
if (nSrcPitch == 0)
|
|
nSrcPitch = nWidth * 4;
|
|
if (nDstPitch == 0)
|
|
nDstPitch = nWidth * 4;
|
|
DWORD nDeltaSrcPitch = nSrcPitch - (nWidth * 4);
|
|
const BYTE *pPixelLimit = pSrcPixels + nSrcPitch * nHeight;
|
|
DWORD iRed = pixiSrc.iRed, iBlue = pixiSrc.iBlue;
|
|
// copy each row
|
|
for (; pSrcPixels != pPixelLimit; ) {
|
|
LPDWORD pdwDstPixel = (LPDWORD) pDstPixels;
|
|
for (DWORD i = nWidth; i != 0; i--) {
|
|
*pdwDstPixel++ = pixiDst.Pack(pSrcPixels[iRed], pSrcPixels[1], pSrcPixels[iBlue], pSrcPixels[3]);
|
|
pSrcPixels += 4;
|
|
}
|
|
pDstPixels += nDstPitch;
|
|
pSrcPixels += nDeltaSrcPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast24To16(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight,
|
|
const CPixelInfo &pixiSrc, const CPixelInfo &pixiDst)
|
|
{
|
|
if (nSrcPitch == 0)
|
|
nSrcPitch = nWidth * 3;
|
|
if (nDstPitch == 0)
|
|
nDstPitch = nWidth * 2;
|
|
DWORD nDeltaSrcPitch = nSrcPitch - (nWidth * 3);
|
|
const BYTE *pPixelLimit = pSrcPixels + nSrcPitch * nHeight;
|
|
DWORD iRed = pixiSrc.iRed, iBlue = pixiSrc.iBlue;
|
|
// copy each row
|
|
for (; pSrcPixels != pPixelLimit; ) {
|
|
LPWORD pwDstPixel = (LPWORD) pDstPixels;
|
|
for (DWORD i = nWidth; i != 0; i--) {
|
|
*pwDstPixel++ = pixiDst.Pack16(pSrcPixels[iRed], pSrcPixels[1], pSrcPixels[iBlue]);
|
|
pSrcPixels += 3;
|
|
}
|
|
pDstPixels += nDstPitch;
|
|
pSrcPixels += nDeltaSrcPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast24To32(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight,
|
|
const CPixelInfo &pixiSrc, const CPixelInfo &pixiDst)
|
|
{
|
|
if (nSrcPitch == 0)
|
|
nSrcPitch = nWidth * 3;
|
|
if (nDstPitch == 0)
|
|
nDstPitch = nWidth * 4;
|
|
DWORD nDeltaSrcPitch = nSrcPitch - (nWidth * 3);
|
|
DWORD iRed = pixiSrc.iRed, iBlue = pixiSrc.iBlue;
|
|
// copy each row
|
|
const BYTE *pPixelLimit = pSrcPixels + nSrcPitch * nHeight;
|
|
for (; pSrcPixels != pPixelLimit; ) {
|
|
LPDWORD pdwDstPixel = (LPDWORD) pDstPixels;
|
|
for (DWORD i = nWidth; i != 0; i--) {
|
|
*pdwDstPixel++ = pixiDst.Pack(pSrcPixels[iRed], pSrcPixels[1], pSrcPixels[iBlue]);
|
|
pSrcPixels += 3;
|
|
}
|
|
pDstPixels += nDstPitch;
|
|
pSrcPixels += nDeltaSrcPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
BltFast8To4(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, DWORD nOffset)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast8To2(const BYTE *pSrcPixels, DWORD nSrcPitch,
|
|
BYTE *pDstPixels, DWORD nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, DWORD nOffset)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast8To1(const BYTE *pSrcPixels, long nSrcPitch,
|
|
BYTE *pDstPixels, long nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, DWORD nOffset)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BltFast8To8T(const BYTE *pSrcPixel, long nSrcPitch, BYTE *pDstPixel, long nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, const BYTE *pIndexMap)
|
|
{
|
|
if ((nWidth == 0) || (nHeight == 0))
|
|
return S_OK;
|
|
|
|
DWORD nRemainder = (nWidth & 0x7);
|
|
DWORD nAligned = (nWidth & ~0x7);
|
|
const BYTE *pSrcLineStart = pSrcPixel;
|
|
const BYTE *pPixelLimit = pSrcPixel + (nHeight * nSrcPitch);
|
|
DWORD nSrcAlignedPitch = nSrcPitch + nAligned;
|
|
DWORD nDstAlignedPitch = nDstPitch + nAligned;
|
|
pSrcPixel += nAligned;
|
|
pDstPixel += nAligned;
|
|
|
|
do {
|
|
switch (nRemainder) {
|
|
do {
|
|
case 0: pDstPixel -= 8; pSrcPixel -= 8;
|
|
pDstPixel[7] = pIndexMap[pSrcPixel[7]];
|
|
case 7: pDstPixel[6] = pIndexMap[pSrcPixel[6]];
|
|
case 6: pDstPixel[5] = pIndexMap[pSrcPixel[5]];
|
|
case 5: pDstPixel[4] = pIndexMap[pSrcPixel[4]];
|
|
case 4: pDstPixel[3] = pIndexMap[pSrcPixel[3]];
|
|
case 3: pDstPixel[2] = pIndexMap[pSrcPixel[2]];
|
|
case 2: pDstPixel[1] = pIndexMap[pSrcPixel[1]];
|
|
case 1: pDstPixel[0] = pIndexMap[pSrcPixel[0]];
|
|
} while (pSrcPixel != pSrcLineStart);
|
|
}
|
|
pSrcLineStart += nSrcPitch;
|
|
pSrcPixel += nSrcAlignedPitch;
|
|
pDstPixel += nDstAlignedPitch;
|
|
} while (pSrcLineStart != pPixelLimit);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
BltFast8To16T(const BYTE *pSrcPixel, long nSrcPitch, BYTE *pDstPixel, long nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, const BYTE *pIndexMap)
|
|
{
|
|
#ifdef _DEBUG
|
|
if ((long(pDstPixel) & 0x1) || (nDstPitch & 0x1) || (nWidth == 0) || (nHeight == 0))
|
|
return E_INVALIDARG;
|
|
#endif
|
|
DWORD nRemainder = (nWidth & 0x7);
|
|
DWORD nAligned = (nWidth & ~0x7);
|
|
const BYTE *pSrcLineStart = pSrcPixel;
|
|
const BYTE *pPixelLimit = pSrcPixel + (nHeight * nSrcPitch);
|
|
DWORD nSrcAlignedPitch = nSrcPitch + nAligned;
|
|
DWORD nDstAlignedPitch = (nDstPitch >> 1) + nAligned;
|
|
pSrcPixel += nAligned;
|
|
WORD *pDstPixel16 = ((WORD *) pDstPixel) + nAligned;
|
|
MapEntry16 *pIndexMap16 = (MapEntry16 *) pIndexMap;
|
|
|
|
do {
|
|
switch (nRemainder) {
|
|
do {
|
|
case 0: pDstPixel16 -= 8; pSrcPixel -= 8;
|
|
pDstPixel16[7] = pIndexMap16[pSrcPixel[7]];
|
|
case 7: pDstPixel16[6] = pIndexMap16[pSrcPixel[6]];
|
|
case 6: pDstPixel16[5] = pIndexMap16[pSrcPixel[5]];
|
|
case 5: pDstPixel16[4] = pIndexMap16[pSrcPixel[4]];
|
|
case 4: pDstPixel16[3] = pIndexMap16[pSrcPixel[3]];
|
|
case 3: pDstPixel16[2] = pIndexMap16[pSrcPixel[2]];
|
|
case 2: pDstPixel16[1] = pIndexMap16[pSrcPixel[1]];
|
|
case 1: pDstPixel16[0] = pIndexMap16[pSrcPixel[0]];
|
|
} while (pSrcPixel != pSrcLineStart);
|
|
}
|
|
pSrcLineStart += nSrcPitch;
|
|
pSrcPixel += nSrcAlignedPitch;
|
|
pDstPixel16 += nDstAlignedPitch;
|
|
} while (pSrcLineStart != pPixelLimit);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
BltFast8To24T(const BYTE *pSrcPixels, long nSrcPitch, BYTE *pDstPixels, long nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, const BYTE *pIndexMap)
|
|
{
|
|
MapEntry24 *pIndexMap24 = (MapEntry24 *) pIndexMap;
|
|
BYTE *pDstPixelsLimit = pDstPixels + nDstPitch * nHeight;
|
|
int nDstWidth = nWidth * 3;
|
|
|
|
for (; pDstPixels != pDstPixelsLimit; ) {
|
|
const BYTE *pSrcPixel = pSrcPixels;
|
|
BYTE *pDstPixel = pDstPixels;
|
|
BYTE *pDstPixelLimit = pDstPixel + nDstWidth;
|
|
for (; pDstPixel != pDstPixelLimit; ) {
|
|
MapEntry24 mePixel = pIndexMap24[*pSrcPixel++];
|
|
*pDstPixel++ = (BYTE) (mePixel);
|
|
*pDstPixel++ = (BYTE) (mePixel >> 8);
|
|
*pDstPixel++ = (BYTE) (mePixel >> 16);
|
|
}
|
|
pDstPixels += nDstPitch;
|
|
pSrcPixels += nSrcPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
BltFast8To32T(const BYTE *pSrcPixels, long nSrcPitch, BYTE *pDstPixels, long nDstPitch,
|
|
DWORD nWidth, DWORD nHeight, const BYTE *pIndexMap)
|
|
{
|
|
#ifdef _DEBUG
|
|
if ((long(pDstPixels) & 0x3) != 0)
|
|
return E_INVALIDARG;
|
|
#endif
|
|
|
|
MapEntry32 *pIndexMap32 = (MapEntry32 *) pIndexMap;
|
|
int nDstPitch32 = nDstPitch >> 2;
|
|
DWORD *pDstPixels32 = (DWORD *) pDstPixels;
|
|
DWORD *pDstPixelsLimit = pDstPixels32 + nDstPitch32 * nHeight;
|
|
|
|
for (; pDstPixels32 != pDstPixelsLimit; ) {
|
|
const BYTE *pSrcPixel = pSrcPixels;
|
|
DWORD *pDstPixel = pDstPixels32;
|
|
DWORD *pDstPixelLimit = pDstPixel + nWidth;
|
|
for (; pDstPixel != pDstPixelLimit; ) {
|
|
*pDstPixel++ = pIndexMap32[*pSrcPixel++];
|
|
}
|
|
pDstPixels32 += nDstPitch32;
|
|
pSrcPixels += nSrcPitch;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// RLE
|
|
//
|
|
|
|
HRESULT
|
|
BltFastRLE8(DWORD nXPos, DWORD nYPos, const BYTE *pSrcPixels, long nSrcPitch,
|
|
BYTE *pDstPixels, long nDstPitch, const LPRECT prSrcRect)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
BltFastRLE8To8T(DWORD nXPos, DWORD nYPos, const BYTE *pSrcPixels, long nSrcPitch,
|
|
BYTE *pDstPixels, long nDstPitch, const LPRECT prSrcRect,
|
|
const BYTE *pIndexMap)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
BltFastRLE8To16T(DWORD nXPos, DWORD nYPos, const BYTE *pSrcPixels, long nSrcPitch,
|
|
BYTE *pDstPixels, long nDstPitch, const LPRECT prSrcRect,
|
|
const BYTE *pIndexMap)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
BltFastRLE8To24T(DWORD nXPos, DWORD nYPos, const BYTE *pSrcPixels, long nSrcPitch,
|
|
BYTE *pDstPixels, long nDstPitch, const LPRECT prSrcRect,
|
|
const BYTE *pIndexMap)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
BltFastRLE8To32T(DWORD nXPos, DWORD nYPos, const BYTE *pSrcPixels, long nSrcPitch,
|
|
BYTE *pDstPixels, long nDstPitch, const LPRECT prSrcRect,
|
|
const BYTE *pIndexMap)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/*
|
|
// Function: Write4BitRow
|
|
// This function packs a buffer of unsigned char's representing
|
|
// 4 bit numbers into a packed unsigned char buffer. It is assumed
|
|
// that the bytes in the src have the uppermost 4 bits zeroed out.
|
|
void *
|
|
Write4BitRow(void *pDst, const void *pSrc, unsigned int cCount)
|
|
{
|
|
// use an inverse Duff machine
|
|
int nRemainder = cCount & 0x07;
|
|
int nAligned = cCount - nRemainder;
|
|
const unsigned char *puchSrc = (const unsigned char *) pSrc + nAligned;
|
|
unsigned char *puchDst = (unsigned char *) pDst + (nAligned >> 1);
|
|
unsigned char uchCompositionBuf = 0;
|
|
|
|
switch (nRemainder) {
|
|
do {
|
|
puchDst -= 4; puchSrc -= 8;
|
|
uchCompositionBuf = puchSrc[7];
|
|
case 7: puchDst[3] = (puchSrc[6] << 4) | uchCompositionBuf;
|
|
case 6: uchCompositionBuf = puchSrc[5];
|
|
case 5: puchDst[2] = (puchSrc[4] << 4) | uchCompositionBuf;
|
|
case 4: uchCompositionBuf = puchSrc[3];
|
|
case 3: puchDst[1] = (puchSrc[2] << 4) | uchCompositionBuf;
|
|
case 2: uchCompositionBuf = puchSrc[1];
|
|
case 1: puchDst[0] = (puchSrc[0] << 4) | uchCompositionBuf;
|
|
case 0: ;
|
|
} while (puchDst != (unsigned char *) pDst);
|
|
}
|
|
|
|
return pDst;
|
|
}
|
|
|
|
// Function: Write2BitRow
|
|
// This function packs a buffer of unsigned char's representing
|
|
// 2 bit numbers into a packed unsigned char buffer. It is assumed
|
|
// that the bytes in the src have the uppermost 6 bits zeroed out.
|
|
void *
|
|
Write2BitRow(void *pDst, const void *pSrc, unsigned int cCount)
|
|
{
|
|
// use an inverse Duff machine
|
|
int nRemainder = cCount & 0x07;
|
|
int nAligned = cCount - nRemainder;
|
|
const unsigned char *puchSrc = (const unsigned char *) pSrc + nAligned;
|
|
unsigned char *puchDst = (unsigned char *) pDst + (nAligned >> 2);
|
|
unsigned char uchCompositionBuf = 0;
|
|
|
|
switch (nRemainder) {
|
|
do {
|
|
puchDst -= 2; puchSrc -= 8;
|
|
uchCompositionBuf = puchSrc[7];
|
|
case 7: uchCompositionBuf |= (puchSrc[6] << 2);
|
|
case 6: uchCompositionBuf |= (puchSrc[5] << 4);
|
|
case 5: puchDst[1] = (puchSrc[4] << 6) | uchCompositionBuf;
|
|
case 4: uchCompositionBuf = puchSrc[3];
|
|
case 3: uchCompositionBuf |= (puchSrc[2] << 2);
|
|
case 2: uchCompositionBuf |= (puchSrc[1] << 4);
|
|
case 1: puchDst[0] = (puchSrc[0] << 6) | uchCompositionBuf;
|
|
case 0: ;
|
|
} while (puchDst != (unsigned char *) pDst);
|
|
}
|
|
|
|
return pDst;
|
|
}
|
|
|
|
// Function: Write1BitRow
|
|
// This function packs a buffer of unsigned char's representing
|
|
// 1 bit numbers into a packed unsigned char buffer. It is assumed
|
|
// that the bytes in the src have the uppermost 7 bits zeroed out.
|
|
void *
|
|
Write1BitRow(void *pDst, const void *pSrc, unsigned int cCount)
|
|
{
|
|
// use an inverse Duff machine
|
|
int nRemainder = cCount & 0x07;
|
|
int nAligned = cCount - nRemainder;
|
|
const unsigned char *puchSrc = (const unsigned char *) pSrc + nAligned;
|
|
unsigned char *puchDst = (unsigned char *) pDst + (nAligned >> 3);
|
|
unsigned char uchCompositionBuf = 0;
|
|
|
|
switch (nRemainder) {
|
|
do {
|
|
puchDst -= 1; puchSrc -= 8;
|
|
uchCompositionBuf = puchSrc[7];
|
|
case 7: uchCompositionBuf |= (puchSrc[6] << 1);
|
|
case 6: uchCompositionBuf |= (puchSrc[5] << 2);
|
|
case 5: uchCompositionBuf |= (puchSrc[4] << 3);
|
|
case 4: uchCompositionBuf |= (puchSrc[3] << 4);
|
|
case 3: uchCompositionBuf |= (puchSrc[2] << 5);
|
|
case 2: uchCompositionBuf |= (puchSrc[1] << 6);
|
|
case 1: puchDst[0] = (puchSrc[0] << 7) | uchCompositionBuf;
|
|
case 0: ;
|
|
} while (puchDst != (unsigned char *) pDst);
|
|
}
|
|
|
|
return pDst;
|
|
}
|
|
*/
|