2727 lines
103 KiB
C++
2727 lines
103 KiB
C++
#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 screw 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);
|
|
}
|
|
|