OS_Develop/WindowsXP
OS_Develop/WindowsXP
1
0
Fork 0
Code Pull Requests Activity
350cc3dbe1
WindowsXP/Source/XPSP1/NT/enduser/netmeeting/as/cpi32/bcd.cpp

2727 lines
103 KiB
C++
Raw Normal View History

Initial commit
2024-08-03 16:30:48 +02:00
#include "precomp.h"
//
// BCD.CPP
// Bitmap Compression-Decompression
//
// Copyright(c) Microsoft 1997-
//
#define MLZ_FILE_ZONE ZONE_ORDER
//
// Introduction
//
// These functions take a bitmap and encode it according to the codes
// defined in bcd.h. Although there are some complexities in the
// encoding (particularly with the "sliding palette" encoding for
// compressing 8 bit down to 4 bit) the encodings should be self
// explanatory. bcd describes some nuances of the encoding scheme.
//
// The important thing to note is that, when used in conjunction with a
// dictionary based compression scheme the objective of this function is
// not to minimize the output but to "prime" it such that the GDC can
// perform faster and more effectively on the data.
//
// Specifically we must NOT encode short runs in the data, even though we
// know that they reduce the output from this stage, as they will
// invariably reduce the efficiency of the GDC compression by a greater
// factor! The break even point seems to be about a 5/6 byte run. To
// illustrate this, consider the following run
// xxxxyyyyyxxxyyyxxxxxyyyyyyxxxyyyxxxxyyy We would encode this as
// 4x5y3x3y5x5y3x3y4x3y The compression factor is only *2 and yet the
// output data is now much more random - the tokenized look of the input
// has been lost.
//
// Encodings that are not context independent are particularly bad. A FG
// run in one position may become a SET+FG run in another position, thus
// "randomizing" the data.
//
// Bottom line is that all of the apparently arbitrary numbers below have
// been carefully tuned to prep the data for input to GDC. Screwing them
// down does increase the compression of this stage in some cases by as
// much as 20%, but loses about 20% post GDC. Frustrating! Be warned.
//
//
//
// BCD_ShareStarting()
// Creates resources needed for bitmap compression/decompression
//
BOOL ASShare::BCD_ShareStarting(void)
{
BOOL rc = FALSE;
DebugEntry(ASShare::BCD_ShareStarting);
// Allocate BCD scratch buffers
m_abNormal = new BYTE[BCD_NORMALSIZE];
if (!m_abNormal)
{
ERROR_OUT(("BCD_ShareStarting: failed to alloc m_abNormal"));
DC_QUIT;
}
m_abXor = new BYTE[BCD_XORSIZE];
if (!m_abXor)
{
ERROR_OUT(("BCD_ShareStarting: failed to alloc m_abXor"));
DC_QUIT;
}
m_amatch = new MATCH[BCD_MATCHCOUNT];
if (!m_amatch)
{
ERROR_OUT(("BCD_ShareStarting: failed to alloc m_amatch"));
DC_QUIT;
}
rc = TRUE;
DC_EXIT_POINT:
DebugExitBOOL(ASShare::BCD_ShareStarting, rc);
return(rc);
}
//
// BCD_ShareEnded()
//
void ASShare::BCD_ShareEnded(void)
{
DebugEntry(ASShare::BCD_ShareEnded);
//
// Free the BCD scratch buffers
//
if (m_amatch)
{
delete[] m_amatch;
m_amatch = NULL;
}
if (m_abXor)
{
delete[] m_abXor;
m_abXor = NULL;
}
if (m_abNormal)
{
delete[] m_abNormal;
m_abNormal = NULL;
}
DebugExitVOID(ASShare::BCD_ShareEnded);
}
//
// BC_CompressBitmap(..)
//
BOOL ASShare::BC_CompressBitmap
(
LPBYTE pSrcBitmap,
LPBYTE pDstBuffer,
LPUINT pDstBufferSize,
UINT bitmapWidth,
UINT bitmapHeight,
UINT cBpp,
LPBOOL pLossy
)
{
BOOL fCompressedData = FALSE;
UINT cbScanWidth;
PCD_HEADER pCompDataHeader;
LPBYTE pCompData;
UINT cbUncompressedDataSize;
UINT cbFreeDstBytes;
UINT cbCompFirstRowSize;
UINT cbCompMainBodySize;
DebugEntry(ASShare::BC_CompressBitmap);
//
// We support 4 and 8 bpp only
//
if ((cBpp != 4) && (cBpp != 8))
{
TRACE_OUT(("BC_CompressBitmap: No compression at %d bpp", cBpp));
DC_QUIT;
}
//
// If we don't have scratch buffers, can't do it either
// But for now, we just won't enter into a share if we can't allocate
// themm.
//
ASSERT(m_abNormal);
ASSERT(m_abXor);
ASSERT(m_amatch);
cbScanWidth = BYTES_IN_SCANLINE(bitmapWidth, cBpp);
//
// Take a local copy of the destination buffer size.
//
cbFreeDstBytes = *pDstBufferSize;
//
// Calculate the size of the uncompressed src data.
//
cbUncompressedDataSize = cbScanWidth * bitmapHeight;
//
// Check that the size of the uncompressed data is less than our max.
//
ASSERT(cbUncompressedDataSize < TSHR_MAX_SEND_PKT);
//
// We write a compressed data header at the start of the dst buffer.
// Reserve space for it now, and fill in the size of the uncompressed
// data.
//
if (sizeof(CD_HEADER) >= cbFreeDstBytes)
{
WARNING_OUT(("BC_CompressBitmap: Dest buffer too small: %d", cbFreeDstBytes));
DC_QUIT;
}
pCompDataHeader = (PCD_HEADER)pDstBuffer;
pCompDataHeader->cbUncompressedSize = (TSHR_UINT16)cbUncompressedDataSize;
pCompData = ((LPBYTE)pCompDataHeader) + sizeof(CD_HEADER);
cbFreeDstBytes -= sizeof(CD_HEADER);
//
// Compress the bitmap data.
// We just pass the complete image into the compression function.
// The header size in the packet is set to 0 and the whole thing
// flows as the main body
//
cbCompFirstRowSize = 0; // lonchanc: a must for V2
cbCompMainBodySize = CompressV2Int(pSrcBitmap, pCompData,
bitmapWidth*bitmapHeight, cBpp, cbScanWidth, cbFreeDstBytes,
pLossy, m_abNormal, m_abXor, m_amatch);
if (cbCompMainBodySize == 0)
{
WARNING_OUT(("BC_CompressBitmap: Compression failed"));
DC_QUIT;
}
//
// Fill in the compressed data header.
//
pCompDataHeader->cbCompFirstRowSize = (TSHR_UINT16)cbCompFirstRowSize;
pCompDataHeader->cbCompMainBodySize = (TSHR_UINT16)cbCompMainBodySize;
pCompDataHeader->cbScanWidth = (TSHR_UINT16)cbScanWidth;
ASSERT(IsV2CompressedDataHeader(pCompDataHeader));
//
// Write back the new (compressed) packet size.
//
*pDstBufferSize = sizeof(CD_HEADER) + cbCompFirstRowSize + cbCompMainBodySize;
TRACE_OUT(("Bitmap Compressed %u bytes to %u",
cbUncompressedDataSize, *pDstBufferSize));
fCompressedData = TRUE;
DC_EXIT_POINT:
DebugExitBOOL(ASShare::BC_CompressBitmap, fCompressedData);
return(fCompressedData);
}
//
// BD_DecompressBitmap(..)
//
BOOL ASShare::BD_DecompressBitmap
(
LPBYTE pCompressedData,
LPBYTE pDstBitmap,
UINT cbSrcData,
UINT bitmapWidth,
UINT bitmapHeight,
UINT cBpp
)
{
BOOL fDecompressedData = FALSE;
PCD_HEADER pCompDataHeader;
LPBYTE pCompDataFirstRow;
LPBYTE pCompDataMainBody;
UINT decompSize;
DebugEntry(ASShare::BD_DecompressBitmap);
//
// We currently support 4 and 8 bpp bitmaps only
//
if ((cBpp != 4) && (cBpp != 8))
{
ERROR_OUT(("BD_DecompressBitmap: Unsupported bpp %d", cBpp));
DC_QUIT;
}
//
// Work out the location in the source data of each component.
//
pCompDataHeader = (PCD_HEADER)pCompressedData;
pCompDataFirstRow = (LPBYTE)pCompDataHeader + sizeof(CD_HEADER);
pCompDataMainBody = pCompDataFirstRow +
pCompDataHeader->cbCompFirstRowSize;
ASSERT(IsV2CompressedDataHeader(pCompDataHeader));
TRACE_OUT(( "FirstRowSize(%u) MainBodySize(%u) ScanWidth(%u)",
pCompDataHeader->cbCompFirstRowSize,
pCompDataHeader->cbCompMainBodySize,
pCompDataHeader->cbScanWidth ));
//
// Check that the supplied data size matches our expectations.
//
if (cbSrcData != sizeof(CD_HEADER) +
pCompDataHeader->cbCompFirstRowSize +
pCompDataHeader->cbCompMainBodySize )
{
ERROR_OUT(("BD_DecompressBitmap: Supplied packet size %u does not match bitmap header",
cbSrcData));
DC_QUIT;
}
//
// As with compression, the V2 decompression function just takes
// the whole image for decompression.
// THE ABSENCE OF A FIRST LINE COUNT DOES, IN FACT, INDICATE TO US
// THAT THIS IS A V2 COMPRESSED BITMAP.
//
if (pCompDataHeader->cbCompFirstRowSize != 0)
{
ERROR_OUT(("BD_DecompressBitmap: Bogus header data"));
}
else
{
ASSERT(m_abXor);
decompSize = DecompressV2Int(pCompDataFirstRow, pDstBitmap,
pCompDataHeader->cbCompMainBodySize, cBpp,
pCompDataHeader->cbScanWidth, m_abXor);
TRACE_OUT(("Bitmap Exploded %u bytes from %u", decompSize, cbSrcData));
fDecompressedData = TRUE;
}
DC_EXIT_POINT:
DebugExitBOOL(ASShare::BD_DecompressBitmap, fDecompressedData);
return(fDecompressedData);
}
//
//
// Create a second copy of the source, which consists of all lines XORed,
// if there is a rowDelta specified
//
// Scan both the non-xored and the xored buffers for matches
//
// A best matches are built up in an array which contains an index to the
// match type, together with the match type. Non repetetive sequences are
// stored in this array as color image strings.
//
//
//
// The following constant controls the threshold at which we decide that
// a lossy compress is a pointless overhead. For low bandwidth connections
// DC-Share will always initially request a lossy compress to get some
// data out quickly. If we find that the percentage of COLOR_IMAGE data
// is below this threshold then we turn off lossy compression for this
// bitmap, redo the analysis, perform non-lossy compression and return
// an indication to the caller that the compression was non-lossy.
//
#define LOSSY_THRESHOLD 75
//
// The following functions have been carefully coded to ensure that the
// 16 bit compiler can minimize its switching of segment registers.
// However, this will not impair its performance on 32 bit systems.
//
//
// Utility macros for encoding orders
//
//
// Encode a combined order and set fg color
//
#define ENCODE_SET_ORDER_MEGA(buffer, \
order_code, \
length, \
mega_order_code, \
DEF_LENGTH_ORDER, \
DEF_LENGTH_LONG_ORDER) \
if (length <= DEF_LENGTH_ORDER) \
{ \
*buffer++ = (BYTE)((BYTE)order_code | (BYTE)length); \
} \
else \
{ \
if (length <= DEF_LENGTH_LONG_ORDER) \
{ \
*buffer++ = (BYTE)order_code; \
*buffer++ = (BYTE)(length-DEF_LENGTH_ORDER-1); \
} \
else \
{ \
*buffer++ = (BYTE)mega_order_code; \
INSERT_TSHR_UINT16_UA( buffer, (TSHR_UINT16)length); \
buffer += 2; \
} \
} \
*buffer++ = fgChar;
//
// Encode a combined order and set fg color for a special FGBG image
//
#define ENCODE_SET_ORDER_MEGA_FGBG(buffer, \
order_code, \
length, \
mega_order_code, \
DEF_LENGTH_ORDER, \
DEF_LENGTH_LONG_ORDER) \
if (((length & 0x0007) == 0) && \
(length <= DEF_LENGTH_ORDER)) \
{ \
*buffer++ = (BYTE)((BYTE)order_code | (BYTE)(length/8));\
} \
else \
{ \
if (length <= DEF_LENGTH_LONG_ORDER) \
{ \
*buffer++ = (BYTE)order_code; \
*buffer++ = (BYTE)(length-1); \
} \
else \
{ \
*buffer++ = (BYTE)mega_order_code; \
INSERT_TSHR_UINT16_UA( buffer, (TSHR_UINT16)length); \
buffer += 2; \
} \
} \
*buffer++ = fgChar;
//
// Encode an order for a standard run
//
#define ENCODE_ORDER_MEGA(buffer, \
order_code, \
length, \
mega_order_code, \
DEF_LENGTH_ORDER, \
DEF_LENGTH_LONG_ORDER) \
if (length <= DEF_LENGTH_ORDER) \
{ \
*buffer++ = (BYTE)((BYTE)order_code | (BYTE)length); \
} \
else \
{ \
if (length <= DEF_LENGTH_LONG_ORDER) \
{ \
*buffer++ = (BYTE)order_code; \
*buffer++ = (BYTE)(length-DEF_LENGTH_ORDER-1); \
} \
else \
{ \
*buffer++ = (BYTE)mega_order_code; \
INSERT_TSHR_UINT16_UA( buffer, (TSHR_UINT16)length); \
buffer += 2; \
} \
}
//
// Encode a special FGBG image
//
#define ENCODE_ORDER_MEGA_FGBG(buffer, \
order_code, \
length, \
mega_order_code, \
DEF_LENGTH_ORDER, \
DEF_LENGTH_LONG_ORDER) \
if (((length & 0x0007) == 0) && \
(length <= DEF_LENGTH_ORDER)) \
{ \
*buffer++ = (BYTE)((BYTE)order_code | (BYTE)(length/8));\
} \
else \
{ \
if (length <= DEF_LENGTH_LONG_ORDER) \
{ \
*buffer++ = (BYTE)order_code; \
*buffer++ = (BYTE)(length-1); \
} \
else \
{ \
*buffer++ = (BYTE)mega_order_code; \
INSERT_TSHR_UINT16_UA( buffer, (TSHR_UINT16)length); \
buffer += 2; \
} \
}
//
// Macros to extract the length from order codes
//
#define EXTRACT_LENGTH(buffer, length) \
length = *buffer++ & MAX_LENGTH_ORDER; \
if (length == 0) \
{ \
length = *buffer++ + MAX_LENGTH_ORDER + 1; \
}
#define EXTRACT_LENGTH_LITE(buffer, length) \
length = *buffer++ & MAX_LENGTH_ORDER_LITE; \
if (length == 0) \
{ \
length = *buffer++ + MAX_LENGTH_ORDER_LITE + 1; \
}
#define EXTRACT_LENGTH_FGBG(buffer, length) \
length = *buffer++ & MAX_LENGTH_ORDER; \
if (length == 0) \
{ \
length = *buffer++ + 1; \
} \
else \
{ \
length = length << 3; \
}
#define EXTRACT_LENGTH_FGBG_LITE(buffer, length) \
length = *buffer++ & MAX_LENGTH_ORDER_LITE; \
if (length == 0) \
{ \
length = *buffer++ + 1; \
} \
else \
{ \
length = length << 3; \
}
//
// RunSingle
//
// Determine the length of the current run
//
// RunSingle may only be called if the buffer has at least four
// consecutive identical bytes from the start position
//
// For 16 bit processing there are two versions of this macro. For 32
// bit the nulling of NEAR/FAR will make them the same.
//
#define RUNSINGLE_XOR(buffer, length, result) \
{ \
BYTE NEAR *buf = buffer+4; \
BYTE NEAR *endbuf = buffer+length-4; \
while ((buf < endbuf) && \
(EXTRACT_TSHR_UINT32_UA(buf) == EXTRACT_TSHR_UINT32_UA(buf-4))) \
{ \
buf += 4; \
} \
endbuf += 4; \
while(buf < endbuf && (*buf == *(buf-1))) \
{ \
buf++; \
} \
result = (DWORD)(buf - (buffer)); \
}
#define RUNSINGLE_NRM(buffer, length, result) \
{ \
BYTE FAR *buf = buffer+4; \
BYTE FAR *endbuf = buffer+length-4; \
while ((buf < endbuf) && \
(EXTRACT_TSHR_UINT32_UA(buf) == EXTRACT_TSHR_UINT32_UA(buf-4))) \
{ \
buf += 4; \
} \
endbuf += 4; \
while(buf < endbuf && (*buf == *(buf-1))) \
{ \
buf++; \
} \
result = (DWORD)(buf - (buffer)); \
}
//
// RunDouble
//
// Determine the length of the current run of paired bytes
//
#define RunDouble(buffer, length, result) \
{ \
int len = ((int)length); \
BYTE FAR *buf = buffer; \
BYTE testchar1 = *buf; \
BYTE testchar2 = *(buf+1); \
result = 0; \
while(len > 1) \
{ \
if (*buf++ != testchar1) \
{ \
break; \
} \
if (*buf++ != testchar2) \
{ \
break; \
} \
result += 2; \
len -= 2; \
} \
}
//
// RUNFGBG
//
// Determine the length of the run of bytes that consist
// only of black or a single FG color
// We exit the loop when
// - the next character is not a fg or bg color
// - we hit a run of 24 of the FG or BG color
// 24 may seem excessive, but note the following sample compression:
// 12 16 20 24 28
// Pre GDC 3845 3756 3712 3794 3822
// Post GDC 2401 2313 2286 2189 2209
//
//
#define RUNFGBG(buffer, length, result, work) \
{ \
BYTE NEAR *buf = buffer; \
BYTE NEAR *endbuf = buffer + length; \
result = 0; \
work = *buf; \
while (TRUE) \
{ \
buf++; \
result++; \
if (buf >= endbuf) \
{ \
break; \
} \
\
if ((*buf != work) && (*buf != 0)) \
{ \
break; \
} \
\
if ((result & 0x0007) == 0) \
{ \
if ((*buf == *(buf+1)) && \
(EXTRACT_TSHR_UINT16_UA(buf) == \
EXTRACT_TSHR_UINT16_UA(buf+ 2)) && \
(EXTRACT_TSHR_UINT32_UA(buf) == \
EXTRACT_TSHR_UINT32_UA(buf+ 4)) && \
(EXTRACT_TSHR_UINT32_UA(buf) == \
EXTRACT_TSHR_UINT32_UA(buf+ 8)) && \
(EXTRACT_TSHR_UINT32_UA(buf) == \
EXTRACT_TSHR_UINT32_UA(buf+12)) && \
(EXTRACT_TSHR_UINT32_UA(buf) == \
EXTRACT_TSHR_UINT32_UA(buf+16)) && \
(EXTRACT_TSHR_UINT32_UA(buf) == \
EXTRACT_TSHR_UINT32_UA(buf+20)) ) \
{ \
break; \
} \
} \
} \
}
//
// Determine whether a run is better than any previous run
// For efficiency we take any run of 32 pels or more without looking
// further.
//
#define CHECK_BEST_RUN(run_type, run_length, bestrun_length, bestrun_type) \
if (run_length > bestrun_length) \
{ \
bestrun_length = run_length; \
bestrun_type = run_type; \
if (bestrun_length >= 32) \
{ \
break; \
} \
}
//
// SETFGCHAR
//
// Set up a new value in fgChar and recalculate the shift
//
#define CHECK_WORK(workchar)
#define SETFGCHAR(newchar, curchar, curshift) \
curchar = newchar; \
{ \
BYTE workchar = curchar; \
curshift = 0; \
CHECK_WORK(workchar); \
while ((workchar & 0x01) == 0) \
{ \
curshift++; \
workchar = (BYTE)(workchar>>1); \
} \
}
//
// Macro to store an FGBG image
//
#define STORE_FGBG(xorbyte, fgbgChar, fgChar, bits) \
{ \
UINT numbits = bits; \
if (fgbgChar & 0x01) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
if (--numbits > 0) \
{ \
if (fgbgChar & 0x02) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
if (--numbits > 0) \
{ \
if (fgbgChar & 0x04) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
if (--numbits > 0) \
{ \
if (fgbgChar & 0x08) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
if (--numbits > 0) \
{ \
if (fgbgChar & 0x10) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
if (--numbits > 0) \
{ \
if (fgbgChar & 0x20) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
if (--numbits > 0) \
{ \
if (fgbgChar & 0x40) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
if (--numbits > 0) \
{ \
if (fgbgChar & 0x80) \
{ \
*destbuf++ = (BYTE)(xorbyte ^ fgChar); \
} \
else \
{ \
*destbuf++ = xorbyte; \
} \
} \
} \
} \
} \
} \
} \
} \
}
//
// ENCODEFGBG
//
// Encode 8 bytes of FG and black into a one byte bitmap representation
//
// The FgChar will always be non-zero, and therefore must have at least one
// bit set.
//
// We arrange that all bytes have this bit in their lowest position
//
// The zero pels will still have a 0 in the lowest bit.
//
// Getting the result is a 4 stage process
//
// 1) Get the wanted bits into bit 0 of each byte
//
// <***************work1*****************>
// 31 0
// 0000 000d 0000 000c 0000 000b 0000 000a
// ^ ^ ^ ^
// <***************work2*****************>
// 31 0
// 0000 000h 0000 000g 0000 000f 0000 000e
// ^ ^ ^ ^
//
// a..h = bits that we want to output
//
// We just need to collect the indicated bits and squash them into a single
// byte.
//
// 2) Compress down to 32 bits
//
// <***************work1*****************>
// 31 0
// 000h 000d 000g 000c 000f 000b 000e 000a
// ^ ^ ^ ^ ^ ^ ^ ^
//
// 3) Compress down to 16 bits
//
// <******work*******>
// 15 0
// 0h0f 0d0b 0g0e 0c0a
// ^ ^ ^ ^
//
// 4) Compress down to 8 bits
//
// hgfedcba
//
#define ENCODEFGBG(result) \
{ \
UINT work1; \
UINT work2; \
UINT work; \
\
work1 = (((UINT)(xorbuf[srcOffset]) ) | \
((UINT)(xorbuf[srcOffset+1]) << 8) | \
((UINT)(xorbuf[srcOffset+2]) << 16) | \
((UINT)(xorbuf[srcOffset+3]) << 24)); \
work2 = (((UINT)(xorbuf[srcOffset+4]) ) | \
((UINT)(xorbuf[srcOffset+5]) << 8) | \
((UINT)(xorbuf[srcOffset+6]) << 16) | \
((UINT)(xorbuf[srcOffset+7]) << 24)); \
\
work1 = (work1 >> fgShift) & 0x01010101; \
work2 = (work2 >> fgShift) & 0x01010101; \
\
work1 = (work2 << 4) | work1; \
\
work = work1 | (work1 >> 14); \
\
result = ((BYTE)(((BYTE)(work>>7)) | ((BYTE)work))); \
}
//
// Unpack4bpp
//
// Convert a 4bpp bitmap into an 8bpp one
//
void Unpack4bpp(LPBYTE destbuf,
LPBYTE srcbuf,
UINT srclen)
{
do
{
*destbuf++ = (BYTE)((*srcbuf) >> 4);
*destbuf++ = (BYTE)((*srcbuf) & 0x0F);
srcbuf++;
} while (--srclen > 0);
}
//
// Pack4bpp
//
// Convert an 8bpp bitmap back to 4bpp
//
void Pack4bpp(LPBYTE destbuf,
LPBYTE srcbuf,
UINT srclen)
{
BYTE work1, work2;
DebugEntry(Pack4bpp);
while (srclen > 1)
{
work1 = (BYTE)(*srcbuf++ << 4);
work2 = (BYTE)(*srcbuf++ & 0x0F);
*destbuf++ = (BYTE)(work1 | work2);
srclen -= 2;
}
if (srclen > 0)
{
*destbuf++ = (BYTE)(*srcbuf++ << 4);
}
DebugExitVOID(Pack4bpp);
}
//
// XORBuffer
//
// Create an XOR image of the input bitmap
//
// Note: This function assumes that rowDelta is always a multiple of 4, and
// that destbuf and srcbuf start on a 4 byte boundary. It does not deal
// with unaligned accesses if this is not true.
//
void XORBuffer(BYTE NEAR *destbuf,
BYTE FAR *srcbuf,
UINT srclen,
int rowDelta)
{
UINT NEAR *dwdest = (UINT NEAR *)destbuf;
DebugEntry(XORBuffer);
ASSERT((rowDelta % 4 == 0));
ASSERT((((UINT_PTR)destbuf) % 4 == 0));
ASSERT((((UINT_PTR)srcbuf) % 4 == 0));
while (srclen > 8)
{
*dwdest++ = *((LPUINT)srcbuf) ^ *((LPUINT)(srcbuf+rowDelta));
srclen -= 4;
srcbuf += 4;
*dwdest++ = *((LPUINT)srcbuf) ^ *((LPUINT)(srcbuf+rowDelta));
srclen -= 4;
srcbuf += 4;
}
if (srclen)
{
destbuf = (BYTE NEAR *)dwdest;
while(srclen)
{
*destbuf++ = (BYTE)(*srcbuf++ ^ *(srcbuf+rowDelta));
srclen--;
}
}
DebugExitVOID(XORBuffer);
}
//
// CompressV2Int
//
// Internal compresssion function
//
// The work buffer addresses are moved onto the stack, thus eliminating any
// need to use DS to address the default data segment. This allows the
// compiler to perform more general optimizations.
//
UINT CompressV2Int(LPBYTE pSrc,
LPBYTE pDst,
UINT numPels,
UINT bpp,
UINT rowDelta,
UINT dstBufferSize,
LPBOOL pLossy,
LPBYTE nrmbuf,
LPBYTE xorbuf,
MATCH FAR *match)
{
int i;
UINT srcOffset;
UINT matchindex;
UINT bestRunLength;
UINT nextRunLength;
UINT runLength;
UINT bestFGRunLength;
UINT checkFGBGLength;
UINT scanCount;
BOOL firstLine;
UINT saveNumPels;
BOOL saveLossy;
BOOL lossy;
BYTE bestRunType = 0;
LPBYTE destbuf = pDst;
BYTE fgChar = 0xFF;
BYTE fgCharWork = 0xFF;
BYTE fgShift = 0;
BOOL lossyStarted = FALSE;
BOOL inColorRun = FALSE;
UINT compressedLength = 0;
DebugEntry(CompressV2Int);
//
// Validate the line length
//
if ((numPels < rowDelta) ||
(rowDelta & 0x0003) ||
(numPels & 0x0003))
{
WARNING_OUT(( "Lines must be a multiple of 4 pels"));
DC_QUIT;
}
//
// First create the character and XOR buffers
//
if (bpp == 4)
{
Unpack4bpp(nrmbuf, pSrc, numPels/2);
}
else
{
nrmbuf = pSrc;
}
//
// Set up the first portion of the XORBUF to contain the source buffer
//
memcpy(xorbuf, nrmbuf, rowDelta);
//
// Calculate the rest of the XOR buffer
//
XORBuffer( xorbuf+rowDelta,
nrmbuf+rowDelta,
numPels-rowDelta,
-(int)rowDelta);
//
// Loop processing the input
// We perform the loop twice, the first time for the non-xor portion
// of the buffer and the second for the XOR portion
// Note that we start the run at a match index of 2 to avoid having
// to special case the startup condition in some of the match
// merging code
// The first time through is always a non-lossy pass. If we find
// enough incompressible data then we redo the compression in lossy
// mode. To achieve this we set saveLossy = FALSE here and reset it
// following the first scan.
//
saveLossy = FALSE;
RESTART_COMPRESSION_IN_LOSSY_MODE:
srcOffset = 0;
firstLine = TRUE;
match[0].type = 0;
match[1].type = 0;
matchindex = 2;
saveNumPels = numPels;
//
// Until we enter XOR mode we do not allow lossy compression on a
// non-XOR request so set up to process just the first line.
// Also, if the user is requesting a lossy compression then we
// perform an initial full non-lossy pass to see if the request is
// worthwhile.
//
lossy = FALSE;
numPels = rowDelta;
for (scanCount = 0; scanCount < 2; scanCount++)
{
while (srcOffset < numPels)
{
//
// Give up if we are nearing the end of the match array
//
if (matchindex >= BCD_MATCHCOUNT)
{
DC_QUIT;
}
//
// Start a while loop to allow a more structured break when we
// hit the first run type we want to encode (We can't afford
// the overheads of a function call to provide the scope here.)
//
while (TRUE)
{
bestRunLength = 0;
bestFGRunLength = 0;
//
// If we are hitting the end of the buffer then just take
// color characters now - take them one at a time so that
// lossy encoding still works. We will only hit this
// condition if we break out of a run just before the end
// of the buffer, so this should not be too common a
// situation, which is good given that we are encoding the
// final 6 bytes uncompressed.
//
if (srcOffset+6 >= numPels)
{
bestRunType = IMAGE_COLOR;
bestRunLength = 1;
break;
}
//
// First do the scans on the XOR buffer. Look for a
// character run or a BG run. Note that if there is no row
// delta then xorbuf actually points to the normal buffer.
// We must do the test independent of how long the run
// might be because even for a 1 pel BG run our later logic
// requires that we detect it seperately. This code is
// absolute main path so fastpath as much as possible. In
// particular detect short bg runs early and allow
// RunSingle to presuppose at least 4 matching bytes
//
if (xorbuf[srcOffset] == 0x00)
{
if (((srcOffset+1) >= numPels) ||
(xorbuf[srcOffset+1] != 0x00))
{
bestRunType = RUN_BG;
bestRunLength = 1;
if (!inColorRun)
{
break;
}
}
else
{
if (((srcOffset+2) >= numPels) ||
(xorbuf[srcOffset+2] != 0x00))
{
bestRunType = RUN_BG;
bestRunLength = 2;
if (!inColorRun)
{
break;
}
}
else
{
if (((srcOffset+3) >= numPels) ||
(xorbuf[srcOffset+3] != 0x00))
{
bestRunType = RUN_BG;
bestRunLength = 3;
if (!inColorRun)
{
break;
}
}
else
{
RUNSINGLE_XOR(xorbuf+srcOffset,
numPels-srcOffset,
bestFGRunLength);
CHECK_BEST_RUN(RUN_BG,
bestFGRunLength,
bestRunLength,
bestRunType);
if (!inColorRun)
{
break;
}
}
}
}
}
else
{
//
// No point in starting if FG run less than 4 bytes so
// check the first dword as quickly as possible Note
// that we don't need to check for an end-buffer
// condition here because our XOR buffer always has
// some free space at the end and the RUNSINGLE_XOR
// will break at the correct place
//
if ( (xorbuf[srcOffset] == xorbuf[srcOffset+1]) &&
(xorbuf[srcOffset] == xorbuf[srcOffset+2]) &&
(xorbuf[srcOffset] == xorbuf[srcOffset+3]) )
{
RUNSINGLE_XOR(xorbuf+srcOffset,
numPels-srcOffset,
bestFGRunLength);
//
// Don't permit a short FG run to prevent a FGBG
// image from starting up. Only take if >= 5
//
if (bestFGRunLength > 5)
{
CHECK_BEST_RUN(RUN_FG,
bestFGRunLength,
bestRunLength,
bestRunType);
}
}
}
//
// Look for sequences in the non XOR buffer In this case we
// insist upon a run of at least 6 pels
//
if ( (nrmbuf[srcOffset] == nrmbuf[srcOffset + 2]) &&
(nrmbuf[srcOffset] == nrmbuf[srcOffset + 4]) &&
(nrmbuf[srcOffset + 1] == nrmbuf[srcOffset + 3]) &&
(nrmbuf[srcOffset + 1] == nrmbuf[srcOffset + 5]) )
{
//
// Now do the scan on the normal buffer for a character
// run Don't bother if first line because we will have
// found it already in the XOR buffer, since we just
// copy nrmbuf to xorbuf for the first line
//
if (*(nrmbuf+srcOffset) == *(nrmbuf+srcOffset+1))
{
if (!firstLine)
{
RUNSINGLE_NRM(nrmbuf+srcOffset,
numPels-srcOffset,
nextRunLength);
if (nextRunLength > 5)
{
CHECK_BEST_RUN(RUN_COLOR,
nextRunLength,
bestRunLength,
bestRunType);
}
}
}
else
{
//
// Look for a dither on the nrm buffer Dithers are
// not very efficient for short runs so only take
// if 8 or longer
//
RunDouble(nrmbuf+srcOffset,
numPels-srcOffset,
nextRunLength);
if (nextRunLength > 9)
{
CHECK_BEST_RUN(RUN_DITHER,
nextRunLength,
bestRunLength,
bestRunType);
}
}
}
//
// If nothing so far then look for a FGBG run (The 6 is
// carefully tuned!)
//
if (bestRunLength < 6)
{
//
// But first look for a single fg bit breaking up a BG
// run. If so then encode a BG run. Careful of the
// enforced BG run break across the first line
// non-XOR/XOR boundary.
//
if ((EXTRACT_TSHR_UINT32_UA(xorbuf+srcOffset+1) == 0) &&
(*(xorbuf+srcOffset) == fgChar) &&
(match[matchindex-1].type == RUN_BG) &&
(srcOffset != (TSHR_UINT16)rowDelta))
{
RUNSINGLE_XOR(xorbuf+srcOffset+1,
numPels-srcOffset-1,
nextRunLength);
nextRunLength++;
CHECK_BEST_RUN(RUN_BG_PEL,
nextRunLength,
bestRunLength,
bestRunType);
}
else
{
//
// If we have not found a run then look for a FG/BG
// image. The disruptive effect of a short FGBG
// run on GDC is such that it is worth preventing
// one unless we are certain of the benefits.
// However, if the alternative is a color run then
// allow a lower value.
//
RUNFGBG( xorbuf+srcOffset,
numPels-srcOffset,
nextRunLength,
fgCharWork );
checkFGBGLength = 48;
if (fgCharWork == fgChar)
{
checkFGBGLength -= 16;
}
if ((nextRunLength & 0x0007) == 0)
{
checkFGBGLength -= 8;
}
if (nextRunLength >= checkFGBGLength)
{
CHECK_BEST_RUN(IMAGE_FGBG,
nextRunLength,
bestRunLength,
bestRunType);
}
}
}
//
// If nothing useful so far then allow a short run, if any
// Don't do this if we are accumulating a color run because
// it will really mess up GDC compression if we allow lots
// of little runs. Also require that it is a regular short
// run, rather than one that disturbs the fgChar
//
if (!inColorRun)
{
if (bestRunLength < 6)
{
if ((bestFGRunLength > 4) &&
(xorbuf[srcOffset] == fgChar))
{
if (match[matchindex-1].type == RUN_FG)
{
match[matchindex-1].length += (WORD)bestFGRunLength;
srcOffset += bestFGRunLength;
continue;
}
else
{
bestRunLength = bestFGRunLength;
bestRunType = RUN_FG;
}
}
else
{
//
// If we decided to take a run earlier then
// allow it now. (May be a short BG run, for
// example) If nothing so far then take color
// image)
//
if (bestRunLength == 0)
{
bestRunType = IMAGE_COLOR;
bestRunLength = 1;
}
}
}
}
else
{
//
// May seem restrictive, but it is important for our
// lossy compression that a color run is rather
// "sticky", in particular not broken by random FGBG
// runs which do appear from time to time.
//
if (lossy)
{
if ((bestRunLength < 8) ||
((bestRunType == IMAGE_FGBG) &&
(bestRunLength < 16)))
{
bestRunType = IMAGE_COLOR;
bestRunLength = 1;
}
}
else
{
if ((bestRunLength < 6) ||
((bestRunType != RUN_BG) && (bestRunLength < 8)))
{
bestRunType = IMAGE_COLOR;
bestRunLength = 1;
}
}
}
break;
}
//
// When we get here we have found the best run. Now check for
// various amalamation conditions with the previous run type.
// Note that we may already have done amalgamation of short
// runs, but we had to do multiple samples for the longer runs
// so we repeat the checks here
//
//
// If we are encoding a color run then
// - process it for lossy compression
// - combine it with an existing run if possible
//
if (bestRunType == IMAGE_COLOR)
{
//
// Flag that we are within a color run
//
inColorRun = TRUE;
//
// If we are doing a lossy compression then process
// even/odd lines differently
//
if (lossy)
{
//
// For even lines duplicate every other character,
// discarding the original value
//
if (((srcOffset/rowDelta)%2) == 0)
{
if ((match[matchindex-1].type == IMAGE_COLOR) &&
(match[matchindex-1].length%2 == 1))
{
nrmbuf[srcOffset] = nrmbuf[srcOffset-1];
//
// If we are not on the final line of the
// bitmap then propagate the update down to the
// next XORed line
//
if (numPels-srcOffset > rowDelta)
{
xorbuf[srcOffset+rowDelta] =
(BYTE)(nrmbuf[srcOffset+rowDelta] ^
nrmbuf[srcOffset]);
}
}
}
else
{
//
// For odd lines we will just encode nulls which
// will replicate the previous line. However, if
// the last run was a BG run then we will
// inadvertently insert a pel, so if we hit this
// situation then leave a single color char
//
bestRunType = IMAGE_LOSSY_ODD;
//
// No need to adjust the buffers for this, except
// to update the next XOR line to reflect the fact
// that the decoder will be operating on a
// replicated line. Therefore we replace the
// character in the next line of the XOR buffer
// with the value it would have if the current line
// was identical with the previous line
//
if (numPels-srcOffset > (TSHR_UINT16)rowDelta)
{
xorbuf[srcOffset+rowDelta] =
(BYTE)(nrmbuf[srcOffset+rowDelta] ^
nrmbuf[srcOffset-rowDelta]);
}
}
}
//
// Merge the color run immediately, if possible
//
if (match[matchindex-1].type == bestRunType)
{
match[matchindex-1].length += (WORD)bestRunLength;
srcOffset += bestRunLength;
continue;
}
}
else
{
//
// We are no longer encoding a COLOR_IMAGE of any kind
//
inColorRun = FALSE;
//
// Keep track of the fg Color The macro that searches for
// FGBG runs leaves the character in fgCharWork.
//
if (bestRunType == RUN_FG)
{
fgChar = xorbuf[srcOffset];
}
else
{
if (bestRunType == IMAGE_FGBG)
{
fgChar = fgCharWork;
}
}
}
//
// If we can amalgamate the entry then do so without creating a
// new array entry. We must amalgamate a lossy ODD with a
// RUN_BG because otherwise the lossy would trigger a pel
// insertion. Our search for FGBG runs is dependent upon that
// type of run being amalgamated because we break every 64
// characters so that our mode switch detection works OK.
//
// Take care not to merge across the non-xor/xor boundary
//
if (srcOffset == (TSHR_UINT16)rowDelta)
{
//
// Just bump the source offset
//
srcOffset += bestRunLength;
}
else
{
//
// Bump srcOffset and try a merge
//
srcOffset += bestRunLength;
//
// The simpler merges are where the types are identical
//
if (bestRunType == match[matchindex-1].type)
{
//
// COLOR IMAGES and BG images are trivial
//
if ((bestRunType == IMAGE_LOSSY_ODD) ||
(bestRunType == RUN_BG))
{
match[matchindex-1].length += (WORD)bestRunLength;
continue;
}
//
// FG runs and FGBG images merge if fgChars match
//
if (((bestRunType == RUN_FG) ||
(bestRunType == IMAGE_FGBG)) &&
(fgChar == match[matchindex-1].fgChar))
{
match[matchindex-1].length += (WORD)bestRunLength;
TRACE_OUT(( "Merged %u with preceding, giving %u",
match[matchindex-1].type,
match[matchindex-1].length));
continue;
}
}
//
// BG RUNs merge with LOSSY odd lines It is important that
// we do this merging because otherwise we will get
// inadvertent pel insertion due to the broken BG runs.
//
if (((bestRunType == RUN_BG) ||
(bestRunType == IMAGE_LOSSY_ODD)) &&
((match[matchindex-1].type == RUN_BG) ||
(match[matchindex-1].type == IMAGE_LOSSY_ODD) ||
(match[matchindex-1].type == RUN_BG_PEL)))
{
match[matchindex-1].length += (WORD)bestRunLength;
continue;
}
//
// If it is a normal FGBG run which follows a short BG run
// then it is better to merge them.
//
if ((bestRunType == IMAGE_FGBG) &&
(match[matchindex-1].type == RUN_BG) &&
(match[matchindex-1].length < 8))
{
match[matchindex-1].type = IMAGE_FGBG;
match[matchindex-1].length += (WORD)bestRunLength;
match[matchindex-1].fgChar = fgChar;
TRACE_OUT(( "Merged FGBG with preceding BG run -> %u",
match[matchindex-1].length));
continue;
}
//
// If it is a BG run following a FGBG run then merge in the
// pels to make the FGBG a multiple of 8 bits. The if the
// remaining BG run is < 16 merge it in also otherwise just
// write the shortened BG run
//
if (((bestRunType == RUN_BG) ||
(bestRunType == RUN_BG_PEL)) &&
(match[matchindex-1].type == IMAGE_FGBG) &&
(match[matchindex-1].length & 0x0007))
{
UINT mergelen = 8 -
(match[matchindex-1].length & 0x0007);
if (mergelen > bestRunLength)
{
mergelen = bestRunLength;
}
match[matchindex-1].length += (WORD)mergelen;
bestRunLength -= mergelen;
TRACE_OUT(( "Added %u pels to FGBG giving %u leaving %u",
mergelen, match[matchindex-1].length,bestRunLength));
if (bestRunLength < 9)
{
match[matchindex-1].length += (WORD)bestRunLength;
TRACE_OUT(( "Merged BG with preceding FGBG gives %u",
match[matchindex-1].length));
continue;
}
}
//
// Finally, if it is a color run spanning any kind of
// single pel entity then merge that last two entries.
//
if ((bestRunType == IMAGE_COLOR) &&
(match[matchindex-2].type == IMAGE_COLOR) &&
(match[matchindex-1].length == 1))
{
match[matchindex-2].length += bestRunLength + 1;
matchindex--;
TRACE_OUT(( "Merged color with preceding color gives %u",
match[matchindex-1].length));
continue;
}
}
//
// Handle runs that will not amalgamate by adding a new array
// entry
//
match[matchindex].type = bestRunType;
match[matchindex].length = (WORD)bestRunLength;
match[matchindex].fgChar = fgChar;
TRACE_OUT(( "Best run of type %u (index %u) has length %u",
match[matchindex-1].type,
matchindex-1,
match[matchindex-1].length));
TRACE_OUT(( "Trying run of type %u (index %u) length %u",
match[matchindex].type,
matchindex,
match[matchindex].length));
matchindex++;
}
//
// If we have just done our scan of the first line then now do the
// rest of the buffer. Reset our saved pel count.
//
numPels = saveNumPels;
lossy = saveLossy;
firstLine = FALSE;
}
//
// END OF INITIAL TWO PASS SCAN OF THE INPUT
//
//
// We have parsed the buffer so now we can go ahead and encode it.
// First we should check to see whether we want to redo the encoding
// in lossy mode. We only do this if requested and worthwhile.
//
if (!saveLossy && (pLossy != NULL) && *pLossy)
{
UINT lossyCharCount = 0;
UINT divisor;
for (i = 2; i < (int)matchindex; i++)
{
if ((match[i].type == IMAGE_COLOR) ||
(match[i].type == IMAGE_LOSSY_ODD))
{
lossyCharCount += match[i].length;
}
}
divisor = max(numPels/100, 1);
if (lossyCharCount/divisor > LOSSY_THRESHOLD)
{
saveLossy = TRUE;
goto RESTART_COMPRESSION_IN_LOSSY_MODE;
}
else
{
*pLossy = FALSE;
}
}
//
// Now do the encoding
//
srcOffset = 0;
firstLine = TRUE;
lossy = FALSE;
fgChar = 0xFF;
for (i = 2; i < (int)matchindex; i++)
{
//
// First check for our approaching the end of the destination
// buffer and get out if this is the case. We allow for the
// largest general run order (a mega-mega set run = 4 bytes).
// Orders which may be larger are checked within the case arm
//
if ((UINT)(destbuf - pDst + 4) > dstBufferSize)
{
//
// We are about to blow it so just get out
//
DC_QUIT;
}
//
// While we are encoding the first line keep checking for the end
// of line to switch encoding states
//
if (firstLine)
{
if (srcOffset >= rowDelta)
{
firstLine = FALSE;
lossy = saveLossy;
}
}
switch (match[i].type)
{
//
// BG_RUN, FG_RUN, COLOR, PACKED COLOR and FGBG are normal
// precision codes
//
case RUN_BG:
case RUN_BG_PEL:
ENCODE_ORDER_MEGA(destbuf,
CODE_BG_RUN,
match[i].length,
CODE_MEGA_MEGA_BG_RUN,
MAX_LENGTH_ORDER,
MAX_LENGTH_LONG_ORDER);
TRACE_OUT(( "BG RUN %u",match[i].length));
srcOffset += match[i].length;
break;
case IMAGE_LOSSY_ODD:
//
// For a lossy odd line we encode a background run
// Note that we do not need to encode a start lossy
// because the decode does not need to distinguish this
// from a regular bg run
//
ENCODE_ORDER_MEGA(destbuf,
CODE_BG_RUN,
match[i].length,
CODE_MEGA_MEGA_BG_RUN,
MAX_LENGTH_ORDER,
MAX_LENGTH_LONG_ORDER);
TRACE_OUT(( "BG RUN %u",match[i].length));
srcOffset += match[i].length;
break;
case RUN_FG:
//
// If the fg char is not yet set then encode a set+run code
//
if (fgChar != match[i].fgChar)
{
SETFGCHAR(match[i].fgChar, fgChar, fgShift);
//
// Encode the order
//
ENCODE_SET_ORDER_MEGA(destbuf,
CODE_SET_FG_FG_RUN,
match[i].length,
CODE_MEGA_MEGA_SET_FG_RUN,
MAX_LENGTH_ORDER_LITE,
MAX_LENGTH_LONG_ORDER_LITE);
TRACE_OUT(( "SET_FG_FG_RUN %u",match[i].length));
srcOffset += match[i].length;
}
else
{
ENCODE_ORDER_MEGA(destbuf,
CODE_FG_RUN,
match[i].length,
CODE_MEGA_MEGA_FG_RUN,
MAX_LENGTH_ORDER,
MAX_LENGTH_LONG_ORDER);
TRACE_OUT(( "FG_RUN %u",match[i].length));
srcOffset += match[i].length;
}
break;
case IMAGE_FGBG:
//
// IMAGE_FGBG
//
runLength = match[i].length;
//
// First check for our approaching the end of the
// destination buffer and get out if this is the case.
//
if ((destbuf-pDst+(runLength+7)/8+4) > dstBufferSize)
{
//
// We are about to blow it so just get out
//
DC_QUIT;
}
//
// We need to convert FGBG runs into the pixel form
//
if (fgChar != match[i].fgChar)
{
SETFGCHAR(match[i].fgChar, fgChar, fgShift);
ENCODE_SET_ORDER_MEGA_FGBG(destbuf,
CODE_SET_FG_FG_BG,
runLength,
CODE_MEGA_MEGA_SET_FGBG,
MAX_LENGTH_FGBG_ORDER_LITE,
MAX_LENGTH_LONG_FGBG_ORDER);
TRACE_OUT(( "SET_FG_FG_BG %u",match[i].length));
while (runLength >= 8)
{
ENCODEFGBG(*destbuf);
destbuf++;
srcOffset += 8;
runLength -= 8;
}
if (runLength)
{
ENCODEFGBG(*destbuf);
//
// Keep the final partial byte clean to help GDC
// packing
//
*destbuf &= ((0x01 << runLength) - 1);
destbuf++;
srcOffset += runLength;
}
}
else
{
if (runLength == 8)
{
BYTE fgbgChar;
//
// See if it is one of the high probability bytes
//
ENCODEFGBG(fgbgChar);
//
// Check for single byte encoding of FGBG images
//
switch (fgbgChar)
{
case SPECIAL_FGBG_CODE_1:
*destbuf++ = CODE_SPECIAL_FGBG_1;
break;
case SPECIAL_FGBG_CODE_2:
*destbuf++ = CODE_SPECIAL_FGBG_2;
break;
default:
ENCODE_ORDER_MEGA_FGBG(destbuf,
CODE_FG_BG_IMAGE,
runLength,
CODE_MEGA_MEGA_FGBG,
MAX_LENGTH_FGBG_ORDER,
MAX_LENGTH_LONG_FGBG_ORDER);
*destbuf++ = fgbgChar;
break;
}
srcOffset += 8;
}
else
{
//
// Encode as standard FGBG
//
ENCODE_ORDER_MEGA_FGBG(destbuf,
CODE_FG_BG_IMAGE,
runLength,
CODE_MEGA_MEGA_FGBG,
MAX_LENGTH_FGBG_ORDER,
MAX_LENGTH_LONG_FGBG_ORDER);
TRACE_OUT(( "FG_BG %u",match[i].length));
while (runLength >= 8)
{
ENCODEFGBG(*destbuf);
destbuf++;
srcOffset += 8;
runLength -= 8;
}
if (runLength)
{
ENCODEFGBG(*destbuf);
*destbuf &= ((0x01 << runLength) - 1);
destbuf++;
srcOffset += runLength;
}
}
}
break;
case RUN_COLOR:
//
// COLOR RUN
//
ENCODE_ORDER_MEGA(destbuf,
CODE_COLOR_RUN,
match[i].length,
CODE_MEGA_MEGA_COLOR_RUN,
MAX_LENGTH_ORDER,
MAX_LENGTH_LONG_ORDER);
TRACE_OUT(( "COLOR_RUN %u",match[i].length));
*destbuf++ = nrmbuf[srcOffset];
srcOffset += match[i].length;
break;
case RUN_DITHER:
//
// DITHERED RUN
//
{
UINT ditherlen = match[i].length/2;
ENCODE_ORDER_MEGA(destbuf,
CODE_DITHERED_RUN,
ditherlen,
CODE_MEGA_MEGA_DITHER,
MAX_LENGTH_ORDER_LITE,
MAX_LENGTH_LONG_ORDER_LITE);
TRACE_OUT(( "DITHERED_RUN %u",match[i].length));
//
// First check for our approaching the end of the
// destination buffer and get out if this is the case.
//
if ((UINT)(destbuf - pDst + 2) > dstBufferSize)
{
//
// We are about to blow it so just get out
//
DC_QUIT;
}
*destbuf++ = nrmbuf[srcOffset];
*destbuf++ = nrmbuf[srcOffset+1];
srcOffset += match[i].length;
}
break;
case IMAGE_COLOR:
//
// IMAGE_COLOR
//
//
// A length of 1 can possibly be encoded as a single
// "BLACK"
//
if (match[i].length == 1)
{
if (nrmbuf[srcOffset] == 0x00)
{
*destbuf++ = CODE_BLACK;
srcOffset++;
break;
}
if (nrmbuf[srcOffset] == 0xFF)
{
*destbuf++ = CODE_WHITE;
srcOffset++;
break;
}
}
//
// If lossy compression is requested then indicate it
// immediately we get a color image to encode here
//
if (lossy & !lossyStarted)
{
lossyStarted = TRUE;
*destbuf++ = CODE_START_LOSSY;
}
//
// For 4bpp data pack color runs into nibbles
//
if (bpp == 4)
{
//
// Store the data in packed format
//
ENCODE_ORDER_MEGA(destbuf,
CODE_PACKED_COLOR_IMAGE,
match[i].length,
CODE_MEGA_MEGA_PACKED_CLR,
MAX_LENGTH_ORDER,
MAX_LENGTH_LONG_ORDER);
TRACE_OUT(( "PACKED COLOR %u",match[i].length));
//
// If we are not doing lossy compress then just copy
// the data over, packing two to a byte
//
if (!lossy)
{
//
// First check for our approaching the end of the
// destination buffer and get out if this is the
// case.
//
if ((destbuf - pDst + (UINT)(match[i].length + 1) / 2) >
dstBufferSize)
{
//
// We are about to blow it so just get out
//
DC_QUIT;
}
Pack4bpp(destbuf, nrmbuf+srcOffset, match[i].length);
destbuf += (match[i].length+1)/2;
srcOffset += match[i].length;
}
else
{
//
// First check for our approaching the end of the
// destination buffer and get out if this is the
// case.
//
if ((destbuf - pDst + (UINT)(match[i].length + 3) / 4) >
dstBufferSize)
{
//
// We are about to blow it so just get out
//
DC_QUIT;
}
//
// For a lossy compress we need to discard every
// even byte
//
while (match[i].length > 2)
{
*destbuf++ =
(BYTE)((*(nrmbuf+srcOffset)<<4) |
(*(nrmbuf+srcOffset+2) & 0x0F));
if (match[i].length > 3)
{
srcOffset += 4;
match[i].length -= 4;
}
else
{
srcOffset += 3;
match[i].length -= 3;
}
}
if (match[i].length > 0)
{
*destbuf++ = (BYTE)(*(nrmbuf+srcOffset)<<4);
srcOffset += match[i].length;
}
}
}
else
{
//
// For 8bpp we don't bother trying to detect packed
// data. Doing so disturbs GDC.
//
if (!lossy)
{
//
// Store the data in non-compressed form
//
ENCODE_ORDER_MEGA(destbuf,
CODE_COLOR_IMAGE,
match[i].length,
CODE_MEGA_MEGA_CLR_IMG,
MAX_LENGTH_ORDER,
MAX_LENGTH_LONG_ORDER);
TRACE_OUT(( "COLOR_IMAGE %u",match[i].length));
//
// First check for our approaching the end of the
// destination buffer and get out if this is the
// case.
//
if ((destbuf - pDst + (UINT)match[i].length) > dstBufferSize)
{
//
// We are about to blow it so just get out
//
DC_QUIT;
}
//
// Now just copy the data over
//
memcpy(destbuf, nrmbuf+srcOffset, match[i].length);
destbuf += match[i].length;
srcOffset += match[i].length;
}
else
{
//
// Lossy compression - store the data with
// discarding
//
ENCODE_ORDER_MEGA(destbuf,
CODE_COLOR_IMAGE,
match[i].length,
CODE_MEGA_MEGA_CLR_IMG,
MAX_LENGTH_ORDER,
MAX_LENGTH_LONG_ORDER);
TRACE_OUT(( "COLOR_IMAGE %u",match[i].length));
//
// First check for our approaching the end of the
// destination buffer and get out if this is the
// case.
//
if ((destbuf - pDst + (UINT)(match[i].length + 1) / 2) >
dstBufferSize)
{
//
// We are about to blow it so just get out
//
DC_QUIT;
}
//
// For a lossy compress we need to discard every
// even byte
//
while (match[i].length > 1)
{
*destbuf++ = *(nrmbuf+srcOffset);
srcOffset += 2;
match[i].length -= 2;
}
if (match[i].length == 1)
{
*destbuf++ = *(nrmbuf+srcOffset);
srcOffset++;
}
}
}
break;
default:
ERROR_OUT(( "Invalid run type %u",match[i].type));
}
}
//
// return the size of the compressed buffer
//
compressedLength = (UINT)(destbuf-pDst);
DC_EXIT_POINT:
DebugExitDWORD(CompressV2Int, compressedLength);
return(compressedLength);
}
//
// DecompressV2Int
//
UINT DecompressV2Int(LPBYTE pSrc,
LPBYTE pDst,
UINT bytes,
UINT bpp,
UINT rowDelta,
LPBYTE nrmbuf)
{
UINT codeLength;
BYTE codeByte;
BYTE codeByte2;
BYTE decode;
BYTE decodeLite;
BYTE decodeMega;
BYTE fgChar = 0xFF;
BYTE NEAR *destbuf = nrmbuf;
LPBYTE endSrc = pSrc + bytes;
BOOL backgroundNeedsPel = FALSE;
BOOL lossyStarted = FALSE;
UINT resultSize = 0;
BOOL firstLine = TRUE;
DebugEntry(DecompressV2Int);
//
// Loop processing the input
//
while(pSrc < endSrc)
{
//
// While we are processing the first line we should keep a look out
// for the end of the line
//
if (firstLine)
{
if ((UINT)(destbuf - nrmbuf) >= rowDelta)
{
firstLine = FALSE;
backgroundNeedsPel = FALSE;
}
}
//
// Trace out the source data for debugging
//
TRACE_OUT(( "Next code is %2.2x%2.2x%2.2x%2.2x",
*pSrc,
*(pSrc+1),
*(pSrc+2),
*(pSrc+3)));
//
// Get the decode
//
decode = (BYTE)(*pSrc & CODE_MASK);
decodeLite = (BYTE)(*pSrc & CODE_MASK_LITE);
decodeMega = (BYTE)(*pSrc);
//
// BG RUN
//
if ((decode == CODE_BG_RUN) ||
(decodeMega == CODE_MEGA_MEGA_BG_RUN))
{
if (decode == CODE_BG_RUN)
{
EXTRACT_LENGTH(pSrc, codeLength);
}
else
{
codeLength = EXTRACT_TSHR_UINT16_UA(pSrc+1);
pSrc += 3;
}
TRACE_OUT(( "Background run %u",codeLength));
if (!firstLine)
{
if (backgroundNeedsPel)
{
*destbuf++ = (BYTE)(*(destbuf - rowDelta) ^ fgChar);
codeLength--;
}
while (codeLength-- > 0)
{
*destbuf++ = *(destbuf - rowDelta);
}
}
else
{
if (backgroundNeedsPel)
{
*destbuf++ = fgChar;
codeLength--;
}
while (codeLength-- > 0)
{
*destbuf++ = 0x00;
}
}
//
// A follow on BG run will need a pel inserted
//
backgroundNeedsPel = TRUE;
continue;
}
//
// For any of the other runtypes a follow on BG run does not need
// a FG pel inserted
//
backgroundNeedsPel = FALSE;
//
// FGBG IMAGE
//
if ((decode == CODE_FG_BG_IMAGE) ||
(decodeLite == CODE_SET_FG_FG_BG) ||
(decodeMega == CODE_MEGA_MEGA_FGBG) ||
(decodeMega == CODE_MEGA_MEGA_SET_FGBG))
{
if ((decodeMega == CODE_MEGA_MEGA_FGBG) ||
(decodeMega == CODE_MEGA_MEGA_SET_FGBG))
{
codeLength = EXTRACT_TSHR_UINT16_UA(pSrc+1);
pSrc += 3;
}
else
{
if (decode == CODE_FG_BG_IMAGE)
{
EXTRACT_LENGTH_FGBG(pSrc, codeLength);
}
else
{
EXTRACT_LENGTH_FGBG_LITE(pSrc, codeLength);
}
}
if ((decodeLite == CODE_SET_FG_FG_BG) ||
(decodeMega == CODE_MEGA_MEGA_SET_FGBG))
{
fgChar = *pSrc++;
TRACE_OUT(( "Set FGBG image %u",codeLength));
}
else
{
TRACE_OUT(( "FGBG image %u",codeLength));
}
while (codeLength > 8)
{
codeByte = *pSrc++;
if (firstLine)
{
STORE_FGBG(0x00, codeByte, fgChar, 8);
}
else
{
STORE_FGBG(*(destbuf - rowDelta), codeByte, fgChar, 8);
}
codeLength -= 8;
}
if (codeLength > 0)
{
codeByte = *pSrc++;
if (firstLine)
{
STORE_FGBG(0x00, codeByte, fgChar, codeLength);
}
else
{
STORE_FGBG(*(destbuf - rowDelta),
codeByte,
fgChar,
codeLength);
}
}
continue;
}
//
// FG RUN
//
if ((decode == CODE_FG_RUN) ||
(decodeLite == CODE_SET_FG_FG_RUN) ||
(decodeMega == CODE_MEGA_MEGA_FG_RUN) ||
(decodeMega == CODE_MEGA_MEGA_SET_FG_RUN))
{
if ((decodeMega == CODE_MEGA_MEGA_FG_RUN) ||
(decodeMega == CODE_MEGA_MEGA_SET_FG_RUN))
{
codeLength = EXTRACT_TSHR_UINT16_UA(pSrc+1);
pSrc += 3;
}
else
{
if (decode == CODE_FG_RUN)
{
EXTRACT_LENGTH(pSrc, codeLength);
}
else
{
EXTRACT_LENGTH_LITE(pSrc, codeLength);
}
}
//
// Push the old fgChar down to the ALT position
//
if ((decodeLite == CODE_SET_FG_FG_RUN) ||
(decodeMega == CODE_MEGA_MEGA_SET_FG_RUN))
{
TRACE_OUT(( "Set FG run %u",codeLength));
fgChar = *pSrc++;
}
else
{
TRACE_OUT(( "FG run %u",codeLength));
}
while (codeLength-- > 0)
{
if (!firstLine)
{
*destbuf++ = (BYTE)(*(destbuf - rowDelta) ^ fgChar);
}
else
{
*destbuf++ = fgChar;
}
}
continue;
}
//
// DITHERED RUN
//
if ((decodeLite == CODE_DITHERED_RUN) ||
(decodeMega == CODE_MEGA_MEGA_DITHER))
{
if (decodeMega == CODE_MEGA_MEGA_DITHER)
{
codeLength = EXTRACT_TSHR_UINT16_UA(pSrc+1);
pSrc += 3;
}
else
{
EXTRACT_LENGTH_LITE(pSrc, codeLength);
}
TRACE_OUT(( "Dithered run %u",codeLength));
codeByte = *pSrc++;
codeByte2 = *pSrc++;
while (codeLength-- > 0)
{
*destbuf++ = codeByte;
*destbuf++ = codeByte2;
}
continue;
}
//
// COLOR IMAGE
//
if ((decode == CODE_COLOR_IMAGE) ||
(decodeMega == CODE_MEGA_MEGA_CLR_IMG))
{
if (decodeMega == CODE_MEGA_MEGA_CLR_IMG)
{
codeLength = EXTRACT_TSHR_UINT16_UA(pSrc+1);
pSrc += 3;
}
else
{
EXTRACT_LENGTH(pSrc, codeLength);
}
TRACE_OUT(( "Color image %u",codeLength));
//
// If not doing lossy compression then just copy the bytes
//
if (!lossyStarted)
{
while (codeLength-- > 0)
{
//
// Update the target with the character
//
*destbuf++ = *pSrc++;
}
}
else
{
//
// For lossy compression we must duplicate all the bytes,
// bar the final odd byte
//
while (codeLength > 3)
{
//
// Dither the bytes unless they are black in which
// case a non-dither is preferable
//
*destbuf++ = *pSrc;
if (*pSrc == 0)
{
*destbuf++ = *(pSrc);
*destbuf++ = *(pSrc+1);
*destbuf++ = *(pSrc+1);
pSrc += 2;
}
else
{
*destbuf++ = *(pSrc+1);
*destbuf++ = *pSrc++;
*destbuf++ = *pSrc++;
}
codeLength -= 4;
}
if (codeLength == 3)
{
*destbuf++ = *pSrc;
*destbuf++ = *(pSrc+1);
*destbuf++ = *pSrc;
pSrc += 2;
}
else
{
if (codeLength == 2)
{
*destbuf++ = *pSrc;
*destbuf++ = *pSrc++;
}
else
{
if (codeLength == 1)
{
*destbuf++ = *pSrc++;
}
}
}
}
continue;
}
//
// PACKED COLOR IMAGE
//
if ((decode == CODE_PACKED_COLOR_IMAGE) ||
(decodeMega == CODE_MEGA_MEGA_PACKED_CLR))
{
if (decodeMega == CODE_MEGA_MEGA_PACKED_CLR)
{
codeLength = EXTRACT_TSHR_UINT16_UA(pSrc+1);
pSrc += 3;
}
else
{
EXTRACT_LENGTH(pSrc, codeLength);
}
TRACE_OUT(( "Packed color %u",codeLength));
//
// If not doing lossy compression then we just unpack the 4bpp
// data two pels per byte
//
if (!lossyStarted)
{
if (bpp == 4)
{
UINT worklen = (codeLength)/2;
BYTE workchar;
while (worklen--)
{
workchar = *pSrc++;
*destbuf++ = (BYTE)(workchar>>4);
*destbuf++ = (BYTE)(workchar & 0x0F);
}
if (codeLength & 0x0001)
{
*destbuf++ = (BYTE)(*pSrc++>>4);
}
}
else
{
ERROR_OUT(( "Don't support packed color for 8bpp"));
}
}
else
{
//
// For lossy compression we must duplicate all the bytes,
// bar the final odd byte, again unpacking as we go
//
while (codeLength > 3)
{
*destbuf++ = (BYTE)((*pSrc) >> 4);
*destbuf++ = (BYTE)((*pSrc) >> 4);
*destbuf++ = (BYTE)((*pSrc) & 0x0F);
*destbuf++ = (BYTE)((*pSrc) & 0x0F);
pSrc++;
codeLength -= 4;
}
if (codeLength > 0)
{
if (codeLength-- > 0)
{
*destbuf++ = (BYTE)((*pSrc) >> 4);
}
if (codeLength-- > 0)
{
*destbuf++ = (BYTE)((*pSrc) >> 4);
}
if (codeLength-- > 0)
{
*destbuf++ = (BYTE)((*pSrc) & 0x0F);
}
if (codeLength-- > 0)
{
*destbuf++ = (BYTE)((*pSrc) & 0x0F);
}
pSrc++;
}
}
continue;
}
//
// COLOR RUN
//
if ((decode == CODE_COLOR_RUN) ||
(decodeMega == CODE_MEGA_MEGA_COLOR_RUN))
{
if (decodeMega == CODE_MEGA_MEGA_COLOR_RUN)
{
codeLength = EXTRACT_TSHR_UINT16_UA(pSrc+1);
pSrc += 3;
}
else
{
EXTRACT_LENGTH(pSrc, codeLength);
}
TRACE_OUT(( "Color run %u",codeLength));
codeByte = *pSrc++;
while (codeLength-- > 0)
{
*destbuf++ = codeByte;
}
continue;
}
//
// If we get here then the code must be a special one
//
TRACE_OUT(( "Special code %x",decodeMega));
switch (decodeMega)
{
case CODE_BLACK:
*destbuf++ = 0x00;
break;
case CODE_WHITE:
*destbuf++ = 0xFF;
break;
//
// Ignore the unreachable code warnings that follow
// Simply because we use the STORE_FGBG macro with a constant
// value
//
case CODE_SPECIAL_FGBG_1:
if (firstLine)
{
STORE_FGBG(0x00, SPECIAL_FGBG_CODE_1, fgChar, 8);
}
else
{
STORE_FGBG(*(destbuf - rowDelta),
SPECIAL_FGBG_CODE_1,
fgChar,
8);
}
break;
case CODE_SPECIAL_FGBG_2:
if (firstLine)
{
STORE_FGBG(0x00,
SPECIAL_FGBG_CODE_2,
fgChar,
8);
}
else
{
STORE_FGBG(*(destbuf - rowDelta),
SPECIAL_FGBG_CODE_2,
fgChar,
8);
}
break;
case CODE_START_LOSSY:
lossyStarted = TRUE;
break;
default:
ERROR_OUT(( "Invalid compression data %x",decodeMega));
break;
}
pSrc++;
}
//
// Our final task is to copy the decoded image into the target buffer
// compacting if we are generating a 4bpp image
//
resultSize = (UINT)(destbuf-nrmbuf);
if (bpp == 4)
{
//
// Zero the final byte to eliminate single byte packing problems
//
*destbuf = 0x00;
Pack4bpp(pDst, nrmbuf, resultSize);
}
else
{
memcpy(pDst, nrmbuf, resultSize);
}
TRACE_OUT(( "Returning %u bytes",resultSize));
//
// Return the number of pixels decoded
//
DebugExitDWORD(DecompressV2Int, resultSize);
return(resultSize);
}

Copy Permalink