//
// BCD.H
// Bitmap Compression & Decompression
//
// Copyright (c) Microsoft 1997-
//

#ifndef _H_BCD
#define _H_BCD



#define BCD_MATCHCOUNT      8192
#define BCD_NORMALSIZE      65000
#define BCD_XORSIZE         65000


//
// VERSION 2 RLE codes
//
//
// The following codes fill a full single byte address space.  The approach
// is to use the high order bits to identify the code type and the low
// order bits to encode the length of the associated run.  There are two
// forms of order
// - regular orders which have a 5 bit length field (31 bytes of data)
// - "lite" orders with a 4 bit length
//
// A value of 0 in the length field indicates an extended length, where
// the following byte contains the length of the data.  There is also a
// "mega mega" form which has a two byte length field. (See end of
// codespace of the codes that define the megamega form).
//
// A set of codes at the high end of the address space is used to encode
// commonly occuring short sequences, in particular
// - certain single byte FGBG codings
// - single bytes of BLACK and WHITE
//
//
// SUMMARY
// *******
//                      7 6 5 4 3 2 1 0  76543210  76543210  76543210
//
// MEGA_BG_RUN          0 0 0 0 0 0 0 0  <length>
//
// BG_RUN               0 0 0 <length->
//
// MEGA_FG_RUN          0 0 1 0 0 0 0 0  <length>
//
// FG_RUN               0 0 1 <length->
//
// MEGA_FG_BG_IMAGE     0 1 0 0 0 0 0 0  <length>  <-data->  ...
//
// FG_BG_IMAGE          0 1 0 <length->  <-data->  ...
//
// MEGA_COLOR_RUN       0 1 1 0 0 0 0 0  <length>  <-color>
//
// COLOR_RUN            0 1 1 <length->  <color->
//
// MEGA_COLOR_IMAGE     1 0 0 0 0 0 0 0  <length>  <-data->  ...
//
// COLOR_IMAGE          1 0 0 <length->  <-data->  ...
//
// MEGA_PACKED_CLR_IMG  1 0 1 0 0 0 0 0  <length>  <-data->  ...
//
// PACKED COLOR IMAGE   1 0 1 <length->  <-data->  ...
//
// SET_FG_MEGA_FG_RUN   1 1 0 0 0 0 0 0  <length>  <-color>
//
// SET_FG_FG_RUN        1 1 0 0 <-len->  <color->
//
// SET_FG_MEGA_FG_BG    1 1 0 1 0 0 0 0  <length>  <-color>  <-data->  ...
//
// SET_FG_FG_BG         1 1 0 1 <-len->  <color->  <-data->  ...
//
// MEGA_DITHERED_RUN    1 1 1 0 0 0 0 0  <length>  <-data->  <-data->
//
// DITHERED_RUN         1 1 1 0 <-len->  <-data->  <-data->
//
// MEGA_MEGA_BG_RUN     1 1 1 1 0 0 0 0
//
// MEGA_MEGA_FG_RUN     1 1 1 1 0 0 0 1
//
// MEGA_MEGA_FGBG       1 1 1 1 0 0 1 0
//
// MEGA_MEGA_COLOR_RUN  1 1 1 1 0 0 1 1
//
// MEGA_MEGA_CLR_IMG    1 1 1 1 0 1 0 0
//
// MEGA_MEGA_PACKED_CLR 1 1 1 1 0 1 0 1
//
// MEGA_MEGA_SET_FG_RUN 1 1 1 1 0 1 1 0
//
// MEGA_MEGA_SET_FGBG   1 1 1 1 0 1 1 1
//
// MEGA_MEGA_DITHER     1 1 1 1 1 0 0 0
//
// Special FGBG code 1  1 1 1 1 1 0 0 1  FGBG code 0x03 = 11000000
// (Note that 0x01 will generally handled by the single pel insertion code)
//
// Special FBBG code 2  1 1 1 1 1 0 1 0  FGBG code 0x05 = 10100000
//
// Special FBBG code 3  1 1 1 1 1 0 1 1  FGBG code 0x07 = 11100000
//
// Special FBBG code 4  1 1 1 1 1 1 0 0  FGBG code 0x0F = 11110000
//
// BLACK                1 1 1 1 1 1 0 1
//
// WHITE                1 1 1 1 1 1 1 0
//
// START_LOSSY          1 1 1 1 1 1 1 1
//
//
//
// GENERAL NOTES
//
//
// - For MEGA runs the length encoded is the length of the run minus the
//   maximum length of the non-mega form.
//   In  the mega-mega form we encode the plain 16 bit length, to keep
//   encoding/deconding simple.
//
// - The sequence BG_RUN,BG_RUN is not exactly what it appears.  We
//   use the fact that this is not generated in normal encoding to
//   encode <n background><1 foreground><n background>.  The same pel
//   insertion convention applies to any combination of MEGA_BG run and
//   BG_RUN
//
// - A packed image is encoded when we find that all the color fields in a
//   run have 0 in the high order nibble. We do not currently use this code
//   for 8 bit compression, but it is supported by the V2 decoder.
//
// - The set fg color code (Used to exist in V1) has been retired in favor
//   of separate commands for those codes that may embed a color.  Generally
//   This saves one byte for every foreground color transition for 8bpp.
//
// - The color run code is new for V2.  It indicates a color run where the
//   XOR is not performed.  This applies to, for example, the line of bits
//   immediately below a text line.  (There is no special case for runs of
//   the bg color - these are treated as any other color run.)
//
// - Observation shows a high occurrence of BG runs split by single FGBG
//   codes.  In decreasing probability these are 3,5,7,9,f,11,1f,3f (1 is
//   handled by the implicit BG run break). Save 1 byte by encoding as
//   single codes
//
// - There is a relatively high occurrence of single pel color codes ff and
//   00.  Save 1 byte by encoding as special characters
//
// - The length in a FGBG run is slightly strange.  Because they generally
//   occur in multiples of 8 bytes we get a big saving if we encode the
//   length of a short run as length/8.  However, for those special
//   cases where the length is not a multiple of 8 we encode a long run.
//   Therefore the long form can only cover the range 1-256 bytes.
//   beyond that we use the mega-mega form.
//
//
// DETAILS OF COMPRESSION CODES
//
//
// BG_RUN
//
// Represents a background run (black:0) of the specified length.
//
//
//
// FG_BG_IMAGE/SET_FG_FG_BG_IMAGE
//
// Represents a binary image containing only the current foreground(1) and
// background(0) colors.
//
//
//
// FG_RUN/SET_FG_FG_RUN
//
// Represents a continuous foreground run of the specified length.
// The foreground color is white by default, and is changed by the
// SET_FG_FG_RUN version of this code.
//
//
//
// DITHERED_RUN
//
// Represents a run of alternating colors of the specified length.
//
//
//
// COLOR_IMAGE
//
// Represents a color image of the specified length.  No XOR is performed.
// This data is uncompressed, so we hope that we won't see
// many of these codes!
//
//
//
// COLOR_RUN
//
// Represents a color run of the specified length.  No XOR is performed.
// Since the color is not XORed, it is unlikely to match the running
// foreground color information.  Therefore this code always carries a
// color byte and there is no SET_FG_COLOR_RUN form of the code.
//
//
//
// PACKED_COLOR_IMAGE
//
// Represents a color image of the specified length, with pairs of colors
// packed into a single byte.  (This can only be done when the color info
// is zero in the high order nibble.)
//
//
//
// START_LOSSY
//
// Informs the decoder that lossy mode has been established and any of the
// following color runs will need pixel doubling performing.
// RLE decoding will remain in this mode until the end of this block
//
//

#define CODE_MASK                   0xE0
#define CODE_MASK_LITE              0xF0

#define CODE_BG_RUN                 0x00   // 20
#define CODE_FG_RUN                 0x20   // 20
#define CODE_FG_BG_IMAGE            0x40   // 20
#define CODE_COLOR_RUN              0x60   // 20
#define CODE_COLOR_IMAGE            0x80   // 20
#define CODE_PACKED_COLOR_IMAGE     0xA0   // 20
#define CODE_SET_FG_FG_RUN          0xC0   // 10
#define CODE_SET_FG_FG_BG           0xD0   // 10
#define CODE_DITHERED_RUN           0xE0   // 10
#define CODE_MEGA_MEGA_BG_RUN       0xF0
#define CODE_MEGA_MEGA_FG_RUN       0xF1
#define CODE_MEGA_MEGA_FGBG         0xF2
#define CODE_MEGA_MEGA_COLOR_RUN    0xF3
#define CODE_MEGA_MEGA_CLR_IMG      0xF4
#define CODE_MEGA_MEGA_PACKED_CLR   0xF5
#define CODE_MEGA_MEGA_SET_FG_RUN   0xF6
#define CODE_MEGA_MEGA_SET_FGBG     0xF7
#define CODE_MEGA_MEGA_DITHER       0xF8
#define CODE_SPECIAL_FGBG_1         0xF9
#define CODE_SPECIAL_FGBG_2         0xFA
#define CODE_SPECIAL_FGBG_3         0xFB
#define CODE_SPECIAL_FGBG_4         0xFC
#define CODE_WHITE                  0xFD
#define CODE_BLACK                  0xFE
#define CODE_START_LOSSY            0xFF

#define MAX_LENGTH_ORDER            31
#define MAX_LENGTH_LONG_ORDER       287

#define MAX_LENGTH_ORDER_LITE       15
#define MAX_LENGTH_LONG_ORDER_LITE  271

#define MAX_LENGTH_FGBG_ORDER       (31*8)
#define MAX_LENGTH_FGBG_ORDER_LITE  (15*8)
#define MAX_LENGTH_LONG_FGBG_ORDER  255

//
// The special FGBG codes that correspond to codes F0-F7
//
#define SPECIAL_FGBG_CODE_1         0x03
#define SPECIAL_FGBG_CODE_2         0x05
#define SPECIAL_FGBG_CODE_3         0x07
#define SPECIAL_FGBG_CODE_4         0x0F

//
// Run types as stored in the run index array
//
#define RUN_BG                      1
#define RUN_BG_PEL                  2
#define RUN_FG                      3
#define RUN_COLOR                   4
#define RUN_DITHER                  5
#define IMAGE_FGBG                  6
#define IMAGE_COLOR                 7
#define IMAGE_LOSSY_ODD             8


//
// The following structure contains the results of our intermediate scan of
// the buffer.  The offset field contains the expected offset into the
// target buffer following decompression of the associated order and is
// used for self-diagnosis.
//
typedef struct
{
    WORD    length;
    BYTE    type;
    BYTE    fgChar;
}
MATCH;



//
// Function Prototypes
//
// Note that the function compresses the whole bitmap in one call.  However
// it performs two cycles internally, once for the first line and once for
// all subsequent lines.  pelsPerLine (the number of pels on a row) MUST be
// supplied.
//
// The paremeters should be obvious, save
//
// pLossy = pointer to flag indicating we maydiscard part of incompressible
//          data
//
// When lossy compression is enabled any color run carries only half the
// pels and they must be doubled up.  (Also the encoder replaces color on
// alternate lines with BG_RUN thus giving a fourfold reduction in the
// data, but the decoder does not need any special code to handle this).
//
// The encoder may decide not to honor the lossy request because the data
// is highly compressible anyway.  If it determines this then the lossy
// flag is reset so that the caller may determine whether a subsequent
// non-lossy transmission is required or not.
//
//


//
// Unpack4bpp
//
// Convert a 4bpp bitmap into an 8bpp one
//
void Unpack4bpp(LPBYTE destbuf,
                             LPBYTE srcbuf,
                             UINT   srclen);

//
// Pack4bpp
//
// Convert an 8bpp bitmap back to 4bpp
//
void Pack4bpp(LPBYTE destbuf,
                           LPBYTE srcbuf,
                           UINT   srclen);

//
// XORBuffer
//
// Create an XOR image of the input bitmap
//
void XORBuffer(LPBYTE destbuf, LPBYTE srcbuf, UINT srclen, int rowDelta);

//
// 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);

UINT    DecompressV2Int(LPBYTE pSrc,
                                  LPBYTE pDst,
                                  UINT   bytes,
                                  UINT   bpp,
                                  UINT   rowDelta,
                                  LPBYTE nrmbuf);



//
// The Compressed Data header structure.
//
// Rather than add a field to indicate V1 vs V2 compression we use the
// fact that V2 compression treats all the bitmap as main body and sets
// the first row size to zero to distinguish them.  I hesitate to do this
// but any bandwidth saving is important.
//
typedef struct _CD_HEADER
{
    TSHR_UINT16     cbCompFirstRowSize;
    TSHR_UINT16     cbCompMainBodySize;
    TSHR_UINT16     cbScanWidth;
    TSHR_UINT16     cbUncompressedSize;
} CD_HEADER;
typedef CD_HEADER *PCD_HEADER;

#define IsV2CompressedDataHeader(p)  ((p)->cbCompFirstRowSize == 0)
#define SetV2CompressedDataHeader(p) ((p)->cbCompFirstRowSize = 0)


//
// Types of bitmap compression.
//
#ifdef _DEBUG // for assertion
#define RLE_V1     1
#endif
#define RLE_V2     2



//
//
// PROTOTYPES
//
//


#endif // _H_BCD