windows-server-2003/enduser/netmeeting/as/cpi32/gdc.cpp

#include "precomp.h"


//
// GDC.CPP
// General Data Compressor
//
// Copyright(c) Microsoft 1997-
//

#define MLZ_FILE_ZONE  ZONE_NET



//
// Tables used by the compression / decompression algorithms
//

const BYTE s_gdcExLenBits[GDC_LEN_SIZE] =
{
    0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8
};


const WORD s_gdcLenBase[GDC_LEN_SIZE] =
{
    0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 14, 22, 38, 70, 134, 262
};


//
// Dist:  Bits, Coded, Decoded
//
const BYTE s_gdcDistBits[GDC_DIST_SIZE] =
{
    2, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8
};


const BYTE s_gdcDistCode[GDC_DIST_SIZE] =
{
    0x03, 0x0d, 0x05, 0x19, 0x09, 0x11, 0x01, 0x3e,
    0x1e, 0x2e, 0x0e, 0x36, 0x16, 0x26, 0x06, 0x3a,
    0x1a, 0x2a, 0x0a, 0x32, 0x12, 0x22, 0x42, 0x02,
    0x7c, 0x3c, 0x5c, 0x1c, 0x6c, 0x2c, 0x4c, 0x0c,

    0x74, 0x34, 0x54, 0x14, 0x64, 0x24, 0x44, 0x04,
    0x78, 0x38, 0x58, 0x18, 0x68, 0x28, 0x48, 0x08,
    0xf0, 0x70, 0xb0, 0x30, 0xd0, 0x50, 0x90, 0x10,
    0xe0, 0x60, 0xa0, 0x20, 0xc0, 0x40, 0x80, 0x00
};



//
// Len:  Bits, Coded, Decoded
//
const BYTE s_gdcLenBits[GDC_LEN_SIZE] =
{
    3, 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7
};


const BYTE s_gdcLenCode[GDC_LEN_SIZE] =
{
    0x05, 0x03, 0x01, 0x06, 0x0A, 0x02, 0x0C, 0x14,
    0x04, 0x18, 0x08, 0x30, 0x10, 0x20, 0x40, 0x00
};




//
// GDC_Init()
//
// BOGUS LAURABU:
// Having one global scratch compression buffer is lousy in multiple
// conference situations.  Maybe allocate it or use caching scheme in
// future, then get rid of mutex.
//
void  GDC_Init(void)
{
    UINT    i, j, k;

    DebugEntry(GDC_Init);

    //
    // Set up the binary data used for PDC compression.  We 'calculate'
    // these since putting this in raw const data is too complicated!
    // The LitBits/LitCodes arrays have 774 entries each, and
    // the LenBits/DistBits arrays have 256 entries.
    //
    // Non-compressed chars take 9 bits in the compressed version:  one
    // bit (zero) to indicate that what follows is not a distance/size
    // code, then the 8 bits of the char.
    //
    for (k = 0; k < GDC_DECODED_SIZE; k++)
    {
        s_gdcLitBits[k] = 9;
        s_gdcLitCode[k] = (WORD)(k << 1);
    }

    for (i = 0; i < GDC_LEN_SIZE; i++)
    {
        for (j = 0; j < (1U << s_gdcExLenBits[i]); j++, k++)
        {
            s_gdcLitBits[k] = (BYTE)(s_gdcLenBits[i] + s_gdcExLenBits[i] + 1);
            s_gdcLitCode[k] = (WORD)((j << (s_gdcLenBits[i] + 1)) |
                                       (s_gdcLenCode[i] << 1) | 1);
        }
    }

    GDCCalcDecode(s_gdcLenBits, s_gdcLenCode, GDC_LEN_SIZE, s_gdcLenDecode);

    GDCCalcDecode(s_gdcDistBits, s_gdcDistCode, GDC_DIST_SIZE, s_gdcDistDecode);


    DebugExitVOID(GDC_Init);
}



//
// GDCCalcDecode()
// This calculates 'const' arrays for s_gdcLenDecode and s_gdcDistDecode.
//
void  GDCCalcDecode
(
    const BYTE *    pSrcBits,
    const BYTE *    pSrcCodes,
    UINT            cSrc,
    LPBYTE          pDstDecodes
)
{
    UINT            j;
    UINT            Incr;
    int             i;

    DebugEntry(GDC_CalcDecode);

    for (i = cSrc-1; i >= 0; i--)
    {
        Incr = 1 << pSrcBits[i];
        j = pSrcCodes[i];
        do
        {
            pDstDecodes[j] = (BYTE)i;
            j += Incr;
        }
        while (j < GDC_DECODED_SIZE);
    }

    DebugExitVOID(GDC_CalcDecode);
}




//
// Optimize compilation for speed (not space)
//
#pragma optimize ("s", off)
#pragma optimize ("t", on)



//
// GDC_Compress()
// Compresses data based on different options.
// This compresses data using PKZIP for both persistent and non-persistent
// types.  The differences between the algorithms are few:
//      * Persistent compression is never used for sources > 4096 bytes
//      * We copy in & update saved dictionary data before starting
//      * We copy back updated dictionary data after ending
//      * One byte of the used DistBits is used for PDC, 2 bytes for
//          plain PKZIP compression in the resulting compressed packet.
//
BOOL  GDC_Compress
(
    PGDC_DICTIONARY pDictionary,            // NULL if not persistent
    UINT            Options,                // Not meaningful if pDictionary
    LPBYTE          pWorkBuf,
    LPBYTE          pSrc,
    UINT            cbSrcSize,
    LPBYTE          pDst,
    UINT *          pcbDstSize
)
{
    BOOL            rc = FALSE;
    UINT            Len;
    UINT            cbRaw;
    UINT            Passes;
    LPBYTE          pCur;
    LPBYTE          pMax;
    PGDC_IMPLODE    pgdcImp;
#ifdef _DEBUG
    UINT            cbSrcOrg;
#endif // _DEBUG

    DebugEntry(GDC_Compress);

    pgdcImp = (PGDC_IMPLODE)pWorkBuf;
    ASSERT(pgdcImp);

#ifdef _DEBUG
    cbSrcOrg = cbSrcSize;
#endif // _DEBUG

    //
    // Figure out what size dictionary to use.
    //
    if (pDictionary)
        pgdcImp->cbDictSize = GDC_DATA_MAX;
    else if (Options == GDCCO_MAXSPEED)
    {
        //
        // Use the smallest for max speed.
        //
        pgdcImp->cbDictSize = GDC_DATA_SMALL;
    }
    else
    {
        ASSERT(Options == GDCCO_MAXCOMPRESSION);

        //
        // Use the nearest dictionary size to the source size.
        //
        if (cbSrcSize <= GDC_DATA_SMALL)
            pgdcImp->cbDictSize = GDC_DATA_SMALL;
        else if (cbSrcSize <= GDC_DATA_MEDIUM)
            pgdcImp->cbDictSize = GDC_DATA_MEDIUM;
        else
            pgdcImp->cbDictSize = GDC_DATA_MAX;
    }

    //
    // How many bits of distance are needed to back the dictionary size
    // # of bytes?
    //
    switch (pgdcImp->cbDictSize)
    {
        case GDC_DATA_SMALL:
            pgdcImp->ExtDistBits = EXT_DIST_BITS_MIN;
            break;

        case GDC_DATA_MEDIUM:
            pgdcImp->ExtDistBits = EXT_DIST_BITS_MEDIUM;
            break;

        case GDC_DATA_MAX:
            pgdcImp->ExtDistBits = EXT_DIST_BITS_MAC;
            break;
    }

    pgdcImp->ExtDistMask = 0xFFFF >> (16 - pgdcImp->ExtDistBits);


    //
    // We need at least 4 bytes (2 max for ExtDistBits, 2 for EOF code).
    //
    ASSERT(*pcbDstSize > 4);

    //
    // Now save the destination info in our struct.  That we we can just
    // pass a pointer to our GDC_IMPLODE routine around with everything
    // we need.
    //
    pgdcImp->pDst     =   pDst;
    pgdcImp->cbDst    =   *pcbDstSize;

    //
    // For non PDC compression, the first little-endian WORD is the ExtDistBits
    // used in decompression.  For PDC compression, just the first BYTE is
    // the ExtDistBits.
    //

    if (!pDictionary)
    {
        *(pgdcImp->pDst)++  = 0;
        --(pgdcImp->cbDst);
    }

    *(pgdcImp->pDst)++    =   (BYTE)pgdcImp->ExtDistBits;
    --(pgdcImp->cbDst);

    //
    // Since pDst could be huge, we don't zero it all out before using.
    // As the pointer into the destination advances, we zero out a byte
    // just before we start writing bits into it.
    //
    pgdcImp->iDstBit      = 0;
    *(pgdcImp->pDst)      = 0;


    //
    // Now, if we have a dictonary, restore the contents into our scratch
    // buffer.
    //
    if (pDictionary && pDictionary->cbUsed)
    {
        TRACE_OUT(("Restoring %u dictionary bytes before compression",
            pDictionary->cbUsed));

        //
        // NOTE:  the data saved in pDictionary->pData is front aligned.
        // But the data in RawData is end aligned so that we can slide up
        // new data chunk by chunk when compressing.  Therefore only copy
        // the part that is valid, but make it end at the back of the
        // space for the dictionary data.
        //
        ASSERT(pDictionary->cbUsed <= pgdcImp->cbDictSize);
        memcpy(pgdcImp->RawData + GDC_MAXREP + pgdcImp->cbDictSize - pDictionary->cbUsed,
            pDictionary->pData,  pDictionary->cbUsed);

        pgdcImp->cbDictUsed = pDictionary->cbUsed;
    }
    else
    {
        pgdcImp->cbDictUsed = 0;
    }

    //
    // We only compress GDC_DATA_MAX bytes at a time.  Therefore we have
    // this loop to grab at most that amount each time around.  Since we
    // only persistently compress packets <= GDC_DATA_MAX, we should never
    // go through it more than once for that compression type.  But normal
    // compression, you betcha since the max packet size is 32K.
    //
    Passes = 0;
    pCur = pgdcImp->RawData + GDC_MAXREP + pgdcImp->cbDictSize;

    do
    {
        //
        // cbRaw will either be GDC_DATA_MAX (if source has >= that to go)
        // or remainder.  Copy that much uncompressed data into our
        // working RawData buffer in the 'new data' space.
        //
        ASSERT(cbSrcSize);
        cbRaw = min(cbSrcSize, GDC_DATA_MAX);

        memcpy(pgdcImp->RawData + GDC_MAXREP + pgdcImp->cbDictSize,
                pSrc, cbRaw);
        pSrc += cbRaw;
        cbSrcSize -= cbRaw;

        //
        // Now get a pointer just past the end of the data we read.  Well,
        // almost.  We fed in cbRaw bytes starting at GDC_MAXREP +
        // pgdcImp->cbDictSize.  So unless this is the last chunk of raw
        // data to process, pMax is GDC_MAXREP before the end of the
        // new raw data.
        //
        // NOTE that in several of the functions that follow, we read
        // a byte or two past the end and the beginning of the valid new
        // raw data.  THIS IS INTENTIONAL.
        //
        // Doing so is the only way to get the beginning and ending bytes
        // indexed, since the hash function uses TWO bytes.  We won't
        // GPF because of padding in our RawData buffer.
        //

        pMax = pgdcImp->RawData + pgdcImp->cbDictSize + cbRaw;
        if (!cbSrcSize)
        {
            pMax += GDC_MAXREP;
        }
        else
        {
            //
            // This better NOT be persistent compression, since we don't
            // let you compress packets bigger than the chunk size we
            // process (GDC_DATA_MAX).
            //
            ASSERT(!pDictionary);
        }

        //
        // Generate the sort buffer, which orders the raw data according
        // to an index calculated using pairs of contiguous bytes that
        // occur within it.  Without a dictionary yet, the first pass
        // only indexes the current chunk.  With a dictionary (a second or
        // greater pass--or PERSISTENT COMPRESSION has saved enough data
        // from last time), we look back into the previous chunk (what we
        // call the dictionary).
        //
        // This takes longer since we go through more bytes, but produces
        // better results.  Hence the dictionary size controls the speed/
        // resulting size.
        //
        switch (Passes)
        {
            case 0:
            {
                if (pgdcImp->cbDictUsed > GDC_MAXREP)
                {
                    //
                    // On the zeroth pass, cbDictUsed is always ZERO
                    // for non-persistent PKZIP.
                    //
                    ASSERT(pDictionary);

                    GDCSortBuffer(pgdcImp, pCur - pgdcImp->cbDictUsed + GDC_MAXREP,
                        pMax + 1);
                }
                else
                {
                    GDCSortBuffer(pgdcImp, pCur, pMax + 1);
                }

                ++Passes;

                //
                // After completing a pass we slide the raw data up into
                // the dictionary slot, bumping out the older dictionary
                // data.
                //
                if (pgdcImp->cbDictSize != GDC_DATA_MAX)
                {
                    ASSERT(pgdcImp->cbDictUsed == 0);
                    ASSERT(!pDictionary);
                    ++Passes;
                }
            }
            break;

            case 1:
            {
                //
                // Start sorting GDC_MAXREP bytes after the start.  NOTE
                // that this is exactly what PERSISTENT compression does
                // on the zeroth pass--it acts like we already have
                // dictionary data, using the bytes from the last time
                // we compressed something.
                //
                GDCSortBuffer(pgdcImp, pCur - pgdcImp->cbDictSize + GDC_MAXREP,
                    pMax + 1);
                ++Passes;
            }
            break;

            default:
            {
                //
                // Start sort from the beginning of the dictionary.
                // This works because we copy raw data around before
                // starting the next pass.
                //
                GDCSortBuffer(pgdcImp, pCur - pgdcImp->cbDictSize, pMax + 1);
            }
            break;
        }


        //
        // Now compress the raw data chunk we ar working on.
        //
        while (pCur < pMax)
        {
            Len = GDCFindRep(pgdcImp, pCur);

SkipFindRep:
            if (!Len || (Len == GDC_MINREP && pgdcImp->Distance >= GDC_DECODED_SIZE))
            {
                if (!GDCOutputBits(pgdcImp, s_gdcLitBits[*pCur],
                        s_gdcLitCode[*pCur]))
                    DC_QUIT;

                pCur++;
                continue;
            }

            //
            // Only do this if we're on the last chunk
            //
            if (!cbSrcSize && (pCur + Len > pMax))
            {
                //
                // Peg run size so it doesn't go past end of raw data.
                //
                Len = (UINT)(pMax - pCur);
                if ((Len < GDC_MINREP) ||
                    (Len == GDC_MINREP && pgdcImp->Distance >= GDC_DECODED_SIZE))
                {
                    if (!GDCOutputBits(pgdcImp, s_gdcLitBits[*pCur],
                            s_gdcLitCode[*pCur]))
                        DC_QUIT;
                    pCur++;
                    continue;
                }
            }
            else if ((Len < 8) && (pCur + 1 < pMax))
            {
                UINT    Save_Distance;
                UINT    Save_Len;

                //
                // Make temp copies of Distance and Len so we can
                // look ahead and see if a better compression run is
                // looming.  If so, we won't bother starting it here,
                // we'll grab the better one next time around.
                //
                Save_Distance = pgdcImp->Distance;
                Save_Len = Len;

                Len = GDCFindRep(pgdcImp, pCur + 1);
                if ((Len > Save_Len) &&
                    ((Len > Save_Len + 1) || (Save_Distance > (GDC_DECODED_SIZE/2))))
                {
                    if (!GDCOutputBits(pgdcImp, s_gdcLitBits[*pCur],
                            s_gdcLitCode[*pCur]))
                        DC_QUIT;
                    ++pCur;
                    goto SkipFindRep;
                }

                //
                // Put back old Len and Distance, we'll take this one.
                //
                Len = Save_Len;
                pgdcImp->Distance = Save_Distance;
            }

            if (!GDCOutputBits(pgdcImp, s_gdcLitBits[256 + Len - GDC_MINREP],
                    s_gdcLitCode[256 + Len - GDC_MINREP]))
                DC_QUIT;

            if (Len == GDC_MINREP)
            {
                //
                // GDC_MINREP is 2, so we right shift Distance by 2
                // (divide by 4).  Then we mask out the last 2 bits
                // of Distance.
                //
                if (!GDCOutputBits(pgdcImp,
                        s_gdcDistBits[pgdcImp->Distance >> GDC_MINREP],
                        s_gdcDistCode[pgdcImp->Distance >> GDC_MINREP]))
                    DC_QUIT;

                if (!GDCOutputBits(pgdcImp, GDC_MINREP, (WORD)(pgdcImp->Distance & 3)))
                    DC_QUIT;
            }
            else
            {
                if (!GDCOutputBits(pgdcImp,
                        s_gdcDistBits[pgdcImp->Distance >> pgdcImp->ExtDistBits],
                        s_gdcDistCode[pgdcImp->Distance >> pgdcImp->ExtDistBits]))
                    DC_QUIT;

                if (!GDCOutputBits(pgdcImp, (WORD)pgdcImp->ExtDistBits,
                        (WORD)(pgdcImp->Distance & pgdcImp->ExtDistMask)))
                    DC_QUIT;
            }

            pCur += Len;
        }


        if (cbSrcSize)
        {
            //
            // There's more data to process.  Here's where we slide up the
            // current raw data into the dictionary space.  This is simply
            // the final cbDictSize + GDC_MAXREP bytes of data.  It
            // begins GDC_DATA_MAX after the start of the bufer.
            //
            // For example, if the dict size is 1K, the current data goes
            // from 1K to 5K, and we slide up the data from 4K to 5K.
            //
            memcpy(pgdcImp->RawData, pgdcImp->RawData + GDC_DATA_MAX,
                pgdcImp->cbDictSize + GDC_MAXREP);

            //
            // Now move our raw data pointer back and update the
            // dictonary used amount.  Since we have GDC_DATA_MAX of data,
            // we fill the dictionary completely.
            //
            pCur -= GDC_DATA_MAX;
            pgdcImp->cbDictUsed = pgdcImp->cbDictSize;
        }
    }
    while (cbSrcSize);

    //
    // Add the end code.
    //
    if (!GDCOutputBits(pgdcImp, s_gdcLitBits[EOF_CODE], s_gdcLitCode[EOF_CODE]))
        DC_QUIT;

    //
    // Return the resulting compressed data size.
    //
    // NOTE that partial bits are already in the destination.  But we
    // need to account for any in the total size.
    //
    if (pgdcImp->iDstBit)
        ++(pgdcImp->pDst);

    *pcbDstSize = (UINT)(pgdcImp->pDst - pDst);

    //
    // We're done.  If we have a persistent dictionary, copy back our
    // last block of raw data into it.  We only copy as much as is actually
    // valid however.
    //
    // We can only get here on successful compression.  NOTE that we do not
    // wipe out our dictionary on failure like we used to.  This helps us
    // by permitting better compression the next time.  The receiver will
    // be OK, since his receive dictionary won't be altered upon reception
    // of a non-compressed packet.
    //
    if (pDictionary)
    {
        pDictionary->cbUsed = min(pgdcImp->cbDictSize, pgdcImp->cbDictUsed + cbRaw);

        TRACE_OUT(("Copying back %u dictionary bytes after compression",
            pDictionary->cbUsed));

        memcpy(pDictionary->pData, pgdcImp->RawData + GDC_MAXREP +
            pgdcImp->cbDictSize + cbRaw - pDictionary->cbUsed,
            pDictionary->cbUsed);

    }

    TRACE_OUT(("%sCompressed %u bytes to %u",
        (pDictionary ? "PDC " : ""), cbSrcOrg, *pcbDstSize));

    rc = TRUE;

DC_EXIT_POINT:
    if (!rc && !pgdcImp->cbDst)
    {
        TRACE_OUT(("GDC_Compress: compressed size is bigger than decompressed size %u.",
            cbSrcOrg));
    }

    DebugExitBOOL(GDC_Compress, rc);
    return(rc);
}



//
// GDCSortBuffer()
//
void  GDCSortBuffer
(
    PGDC_IMPLODE    pgdcImp,
    LPBYTE          pStart,
    LPBYTE          pEnd
)
{
    WORD            Accum;
    WORD *          pHash;
    LPBYTE          pTmp;

    DebugEntry(GDCSortBuffer);

    ASSERT(pStart >= pgdcImp->RawData + pgdcImp->cbDictSize - pgdcImp->cbDictUsed);
    //
    // For each pair of bytes in the raw data, from pStart to pEnd,
    // calculate the hash value for the pair .  The hash value ranges from
    // 0 to GDC_HASH_SIZE-1.  Thus the HashArray structure is an array of
    // GDC_HASH_SIZE WORDs.  Keep a count of how many times a particular
    // hash value occurs in the uncompressed data.
    //
    //
    ZeroMemory(pgdcImp->HashArray, sizeof(pgdcImp->HashArray));

    pTmp = pStart;
    do
    {
        ++(pgdcImp->HashArray[GDC_HASHFN(pTmp)]);
    }
    while (++pTmp < pEnd);


    //
    // Now go back and make each HashArray entry a cumulative total of the
    // occurrences of the hash values up to and including itself.  Kind
    // of like the Fibonacci sequence actually.
    //
    Accum = 0;
    pHash = pgdcImp->HashArray;
    do
    {
        Accum += *pHash;
        *pHash = Accum;
    }
    while (++pHash < pgdcImp->HashArray + GDC_HASH_SIZE);


    //
    // Find the entry in the HashArray containing the accumulated
    // instance count for the current data WORD.  Since these values are
    // calculated from the data in the passed in range, we know that the
    // value in any slot we get to by hashing some bytes in the range is
    // at least 1.
    //
    // We start at the end and work towards the beginning so that we
    // end up with the first instance of such an occurrence in the SortArray.
    //
    pTmp = pEnd - 1;
    do
    {
        pHash = pgdcImp->HashArray + GDC_HASHFN(pTmp);

        ASSERT(*pHash > 0);

        //
        // The count (*pHash) is to be used as an array index, so subtract
        // one from it.  If there was only one instance, put it in array
        // element 0.  If there is more than one instance of a particular
        // hash, then next time we will start with a lower accumulated
        // total.  The array element will be one back, and so on.
        //
        --(*pHash);

        //
        // Store an offset from the beginning of the RawData buffer to
        // each byte of data into the SortArray.  This is inserted
        // using the hash instance count as the index.
        //
        // In other words, the buffer is sorted in ascending order of hash
        // for a particular piece of data.  Where two bytes of data have
        // the same hash, they are referenced in the SortBuffer in the
        // same order as in the RawData since we are scanning backwards.
        //
        pgdcImp->SortArray[*pHash] = (WORD)(pTmp - pgdcImp->RawData);
    }
    while (--pTmp >= pStart);


    //
    // Now all entries in the HashArray index the first occurrence of a byte
    // in the workspace which has a particular index, via the SortArray
    // offset.  That is, the above do-while loop decrements each HashArray
    // entry until all data bytes for that entry are written to SortBuffer.
    //
    DebugExitVOID(GDCSortBuffer);
}



//
// GDCFindRep
//
// This looks for byte patterns in the uncompressed data that can be
// represented in the compressed data with smaller sequences.  The biggest
// wins come from repeating byte sequences; later sequences can be
// compressed into a few bytes referring to an earlier sequence (how big,
// how many bytes back).
//
// This returns the length of the uncompressed data to be replaced.
//
UINT  GDCFindRep
(
    PGDC_IMPLODE    pgdcImp,
    LPBYTE          pDataStart
)
{
    UINT            CurLen;
    UINT            Len;
    LPBYTE          pDataPat;
    LPBYTE          pData;
    UINT            iDataMin;
    UINT            SortIndex;
    LPBYTE          pDataMax;
    UINT            HashVal;
    UINT            i1;
    short           j1;
    LPBYTE          pBase;

    DebugEntry(GDCFindRep);

    //
    // See GDCSortBuffer for a description of the contents of the
    // Index array.  GDC_HASHFN() returns a hash value for a byte
    // using it and its successor in the uncompressed data stream.
    //

    HashVal = GDC_HASHFN(pDataStart);
    ASSERT(HashVal < GDC_HASH_SIZE);

    SortIndex = pgdcImp->HashArray[HashVal];

    //
    // Find the minimum sort buffer value.  This is the offset of the
    // first byte of data.
    //
    iDataMin = (UINT)(pDataStart - pgdcImp->cbDictSize + 1 - pgdcImp->RawData);

    if (pgdcImp->SortArray[SortIndex] < iDataMin)
    {
        //
        // The SortArray is referencing stale data, data that is no
        // longer in the range we are processing.  Move forward until
        // we hit the first entry that's in the current chunk.
        //
        do
        {
            ++SortIndex;
        }
        while (pgdcImp->SortArray[SortIndex] < iDataMin);

        //
        // Save this new sort value in the hash.
        //
        pgdcImp->HashArray[HashVal] = (WORD)SortIndex;
    }

    //
    // Need more than 2 bytes with the same index before processing it.
    //
    pDataMax = pDataStart - 1;

    //
    // Get a Ptr to the first byte in the compression buffer referenced by
    // the SortBuffer offset indexed by the SortIndex we just calculated.
    // If this Ptr is not at least 2 bytes before pDataStart then return 0.
    // This means that the byte pointed to by Start does not share the
    // index with earlier bytes.
    //
    pData = pgdcImp->RawData + pgdcImp->SortArray[SortIndex];
    if (pData >= pDataMax)
       return 0;

    //
    // Now the current bytes have the same index as at least 2 other
    // sequences.  Ptr points to the first compress buffer byte with
    // the same index as that pointed to by pDataStart.
    //
    pDataPat = pDataStart;
    CurLen = 1;

    do
    {
        if (*(pData + CurLen - 1) == *(pDataPat + CurLen - 1) &&
            *(pData) == *(pDataPat))
        {
            //
            // This processes a sequence of identical bytes, one starting
            // at pDataPat, the other at pData.
            //
            ++pData;
            ++pDataPat;
            Len = 2;

            // Skip past matching bytes, keeping a count.
            while ((*++pData == *++pDataPat) && (++Len < GDC_MAXREP))
                ;

            pDataPat = pDataStart;
            if (Len >= CurLen)
            {
                pgdcImp->Distance = (UINT)(pDataPat - pData + Len - 1);
                if ((CurLen = Len) > KMP_THRESHOLD)
                {
                    if (Len == GDC_MAXREP)
                    {
                        --(pgdcImp->Distance);
                        return Len;
                    }
                    goto DoKMP;
                }
            }
        }

        //
        // Get a pointer to the next compress buffer byte having the same
        // hash.  If this byte comes before pDataMax, go back around the
        // loop and look for a matching sequence.
        //
        pData = pgdcImp->RawData + pgdcImp->SortArray[++SortIndex];

    }
    while (pData < pDataMax);

    return (CurLen >= GDC_MINREP) ? CurLen : 0;


DoKMP:
    if (pgdcImp->RawData + pgdcImp->SortArray[SortIndex+1] >= pDataMax)
        return CurLen;

    j1 = pgdcImp->Next[1] = 0;
    pgdcImp->Next[0] = -1;

    i1 = 1;
    do
    {
        if ((pDataPat[i1] == pDataPat[j1]) ||  ((j1 = pgdcImp->Next[j1]) == -1))
            pgdcImp->Next[++i1] = ++j1;
    }
    while (i1 < CurLen);

    Len = CurLen;
    pData = pgdcImp->RawData + pgdcImp->SortArray[SortIndex] + CurLen;

    while (TRUE)
    {
        if ((Len = pgdcImp->Next[Len]) == -1)
            Len = 0;

        do
        {
            pBase = pgdcImp->RawData + pgdcImp->SortArray[++SortIndex];
            if (pBase >= pDataMax)
                return CurLen;
        }
        while (pBase + Len < pData);

        if (*(pBase + CurLen - 2) != *(pDataPat + CurLen - 2))
        {
            do
            {
                pBase = pgdcImp->RawData + pgdcImp->SortArray[++SortIndex];
                if (pBase >= pDataMax)
                    return CurLen;
            }
            while ((*(pBase + CurLen - 2) != *(pDataPat + CurLen - 2)) ||
                   (*(pBase) != *(pDataPat)));

            Len = 2;
            pData = pBase + Len;
        }
        else if (pBase + Len != pData)
        {
            Len = 0;
            pData = pBase;
        }

        while ((*pData == pDataPat[Len]) && (++Len < GDC_MAXREP))
            pData++;

        if (Len >= CurLen)
        {
            ASSERT(pBase < pDataStart);
            pgdcImp->Distance = (UINT)(pDataStart - pBase - 1);

            if (Len > CurLen)
            {
                if (Len == GDC_MAXREP)
                    return Len;

                CurLen = Len;

                do
                {
                    if ((pDataPat[i1] == pDataPat[j1]) ||
                        ((j1 = pgdcImp->Next[j1]) == -1))
                        pgdcImp->Next[++i1] = ++j1;
                }
                while (i1 < CurLen);
            }
        }
    }

    DebugExitVOID(GDCFindRep);
}


//
// GDCOutputBits()
//
// This writes compressed output into our output buffer.  If the total
// goes past the max compressed chunk we have workspace for, we flush
// our buffer into the apps'destination.
//
// It returns FALSE on failure, i.e. we would go past the end of the
// destination.
//
BOOL  GDCOutputBits
(
    PGDC_IMPLODE    pgdcImp,
    WORD            Cnt,
    WORD            Code
)
{
    UINT            iDstBit;
    BOOL            rc = FALSE;

    DebugEntry(GDCOutputBits);

    //
    // If we are writing more than a byte's worth of bits, call ourself
    // recursively to write just 8.  NOTE THAT WE NEVER OUTPUT MORE THAN
    // A WORD'S WORTH, since Code is a WORD sized object.
    //
    if (Cnt > 8)
    {
        if (!GDCOutputBits(pgdcImp, 8, Code))
            DC_QUIT;

        Cnt -= 8;
        Code >>= 8;
    }

    ASSERT(pgdcImp->cbDst > 0);

    //
    // OR on the bits of the Code (Cnt of them).  Then advance our
    // current bit pointer and current byte pointer in the output buffer.
    //
    iDstBit = pgdcImp->iDstBit;
    ASSERT(iDstBit < 8);

    //
    // NOTE:  This is why it is extremely important to have zeroed out
    // the current destination byte when we advance.  We OR on bit
    // sequences to the current byte.
    //
    *(pgdcImp->pDst) |= (BYTE)(Code << iDstBit);
    pgdcImp->iDstBit += Cnt;

    if (pgdcImp->iDstBit >= 8)
    {
        //
        // We've gone past a byte.  Advance the destination ptr to the next
        // one.
        //
        ++(pgdcImp->pDst);
        if (--(pgdcImp->cbDst) == 0)
        {
            //
            // We just filled the last byte and are trying to move past
            // the end of the destination.  Bail out now
            //
            DC_QUIT;
        }

        //
        // Phew, we have room left.  Carry over the slop bits.
        //
        if (pgdcImp->iDstBit > 8)
        {
            //
            // Carry over slop.
            //
            *(pgdcImp->pDst) = (BYTE)(Code >> (8 - iDstBit));
        }
        else
            *(pgdcImp->pDst) = 0;

        // Now the new byte is fullly initialized.

        pgdcImp->iDstBit &= 7;
    }

    rc= TRUE;

DC_EXIT_POINT:
    DebugExitBOOL(GDCOutputBits, rc);
    return(rc);
}




//
// GDC_Decompress()
//
BOOL  GDC_Decompress
(
    PGDC_DICTIONARY     pDictionary,
    LPBYTE              pWorkBuf,
    LPBYTE              pSrc,
    UINT                cbSrcSize,
    LPBYTE              pDst,
    UINT *              pcbDstSize
)
{
    BOOL                rc = FALSE;
    UINT                Len;
    UINT                Dist;
    UINT                i;
    UINT                cbDstSize;
    LPBYTE              pDstOrg;
    LPBYTE              pEarlier;
    LPBYTE              pNow;
    PGDC_EXPLODE        pgdcExp;
#ifdef _DEBUG
    UINT                cbSrcOrg;
#endif // _DEBUG

    DebugEntry(GDC_Decompress);

    pgdcExp = (PGDC_EXPLODE)pWorkBuf;
    ASSERT(pgdcExp);

#ifdef _DEBUG
    cbSrcOrg = cbSrcSize;
#endif // _DEBUG

    //
    // This shouldn't be possible--but since this compressed data
    // comes from another machine, we want to make sure _we_ don't blow
    // up if that machine flaked out.
    //
    if (cbSrcSize <= 4)
    {
        ERROR_OUT(("GDC_Decompress:  bogus compressed data"));
        DC_QUIT;
    }

    //
    // Get the distance bits and calculate the mask needed for that many.
    //
    // NOTE:  For PDC compression, the ExtDistBits are just in the first
    // byte.  For plain compression, the ExtDistBits are in the first
    // little-endian word.  Either way, we only allow from 4 to 6, so
    // the high byte in the non-PDC case is not useful.
    //
    if (!pDictionary)
    {
        // First byte better be zero
        if (*pSrc != 0)
        {
            ERROR_OUT(("GDC_Decompress:  unrecognized distance bits"));
            DC_QUIT;
        }

        ++pSrc;
        --cbSrcSize;
    }

    pgdcExp->ExtDistBits = *pSrc;
    if ((pgdcExp->ExtDistBits < EXT_DIST_BITS_MIN) ||
        (pgdcExp->ExtDistBits > EXT_DIST_BITS_MAC))
    {
        ERROR_OUT(("GDC_Decompress:  unrecognized distance bits"));
        DC_QUIT;
    }
    pgdcExp->ExtDistMask = 0xFFFF >> (16 - pgdcExp->ExtDistBits);


    //
    // Set up source data info (compressed goop).  SrcByte is the current
    // byte & bits we're reading from.  pSrc is the pointer to the next
    // byte.
    //
    pgdcExp->SrcByte  = *(pSrc+1);
    pgdcExp->SrcBits  = 0;
    pgdcExp->pSrc     = pSrc + 2;
    pgdcExp->cbSrc    = cbSrcSize - 2;

    //
    // Save the beginning of the result buffer so we can calculate how
    // many bytes we wrote into it afterwards.
    //
    pDstOrg = pDst;
    cbDstSize = *pcbDstSize;

    //
    // If we have a dictionary, put its data into our work area--the
    // compression might be referencing byte sequences in it (that's the
    // whole point, you get better compression that way when you send
    // packets with the same info over and over).
    //
    // We remember and update cbDictUsed to do the minimal dictionary
    // byte copying back and forth.
    //
    if (pDictionary && pDictionary->cbUsed)
    {
        TRACE_OUT(("Restoring %u dictionary bytes before decompression",
            pDictionary->cbUsed));

        memcpy(pgdcExp->RawData + GDC_DATA_MAX - pDictionary->cbUsed,
            pDictionary->pData, pDictionary->cbUsed);
        pgdcExp->cbDictUsed   = pDictionary->cbUsed;
    }
    else
    {
        pgdcExp->cbDictUsed = 0;
    }

    //
    // The decompressed data starts filling in at GDC_DATA_MAX bytes into
    // the RawData array.  We have to double buffer the output (just
    // like we double buffer the input during compression) because
    // decompressing may require reaching backwards into the decompressed
    // byte stream to pull out sequences.
    //
    pgdcExp->iRawData = GDC_DATA_MAX;

    while ((Len = GDCDecodeLit(pgdcExp)) < EOF_CODE)
    {
        if (Len < 256)
        {
            pgdcExp->RawData[pgdcExp->iRawData++] = (BYTE)Len;
        }
        else
        {
            Len -= (256 - GDC_MINREP);
            Dist = GDCDecodeDist(pgdcExp, Len);
            if (!Dist)
                DC_QUIT;

            //
            // Now we're reaching back, this may in fact spill into the
            // dictionary data that preceded us.
            //
            pNow = pgdcExp->RawData + pgdcExp->iRawData;
            pEarlier = pNow - Dist;

            ASSERT(pEarlier >= pgdcExp->RawData + GDC_DATA_MAX - pgdcExp->cbDictUsed);


            pgdcExp->iRawData += Len;
            do
            {
                *pNow++ = *pEarlier++;
            }
            while (--Len > 0);
        }

        //
        // We've gone past the end of our workspace, flush the decompressed
        // data out.  This is why RawData in GDC_EXPLODE has an extra pad of
        // GDC_MAXREP at the end.  This prevents us from spilling out of
        // the RawData buffer, we will never go more than GDC_MAXREP beyond
        // the last GDC_DATA_MAX chunk.
        //
        if (pgdcExp->iRawData >= 2*GDC_DATA_MAX)
        {
            //
            // Do we have enough space left in the destination?
            //
            if (cbDstSize < GDC_DATA_MAX)
            {
                cbDstSize = 0;
                DC_QUIT;
            }

            // Yup.
            memcpy(pDst, pgdcExp->RawData + GDC_DATA_MAX, GDC_DATA_MAX);

            pDst += GDC_DATA_MAX;
            cbDstSize -= GDC_DATA_MAX;

            //
            // Slide decoded data up to be used for decoding the next
            // chunk ofcompressed source.  It's convenient that the
            // dictionary size and flush size are the same.
            //
            pgdcExp->iRawData -= GDC_DATA_MAX;
            memcpy(pgdcExp->RawData, pgdcExp->RawData + GDC_DATA_MAX,
                pgdcExp->iRawData);
            pgdcExp->cbDictUsed = GDC_DATA_MAX;
        }
    }

    if (Len == ABORT_CODE)
        DC_QUIT;

    i = pgdcExp->iRawData - GDC_DATA_MAX;

    if (i > 0)
    {
        //
        // This is the remaining decompressed data--can we we right it
        // out?
        //
        if (cbDstSize < i)
        {
            cbDstSize = 0;
            DC_QUIT;
        }

        memcpy(pDst, pgdcExp->RawData + GDC_DATA_MAX, i);

        //
        // Advance pDst so that the delta between it and the original is
        // the resulting uncompressed size.
        //
        pDst += i;

        //
        // And update the dictionary used size
        //
        pgdcExp->cbDictUsed = min(pgdcExp->cbDictUsed + i, GDC_DATA_MAX);
    }

    //
    // If we make it to here, we've successfully decompressed the input.
    // So fill in the resulting uncompressed size.
    //
    *pcbDstSize = (UINT)(pDst - pDstOrg);

    //
    // If a persistent dictionary was passed in, save the current contents
    // back into the thing for next time.
    //
    if (pDictionary)
    {
        TRACE_OUT(("Copying back %u dictionary bytes after decompression",
            pgdcExp->cbDictUsed));

        memcpy(pDictionary->pData, pgdcExp->RawData + GDC_DATA_MAX +
            i - pgdcExp->cbDictUsed, pgdcExp->cbDictUsed);
        pDictionary->cbUsed = pgdcExp->cbDictUsed;
    }

    TRACE_OUT(("%sExploded %u bytes from %u",
        (pDictionary ? "PDC " : ""), *pcbDstSize, cbSrcOrg));

    rc = TRUE;

DC_EXIT_POINT:
    if (!rc && !cbDstSize)
    {
        ERROR_OUT(("GDC_Decompress:  decompressed data too big"));
    }

    DebugExitBOOL(GDC_Decompress, rc);
    return(rc);
}




//
// GDCDecodeLit()
//
UINT  GDCDecodeLit
(
    PGDC_EXPLODE    pgdcExp
)
{
    UINT            LitChar, i;

    if (pgdcExp->SrcByte & 0x01)
    {
        // Length found
        if (!GDCWasteBits(pgdcExp, 1))
            return ABORT_CODE;

        LitChar = s_gdcLenDecode[pgdcExp->SrcByte & 0xFF];

        if (!GDCWasteBits(pgdcExp, s_gdcLenBits[LitChar]))
            return ABORT_CODE;

        if (s_gdcExLenBits[LitChar])
        {
            i = pgdcExp->SrcByte & ((1 << s_gdcExLenBits[LitChar]) - 1);

            if (!GDCWasteBits(pgdcExp, s_gdcExLenBits[LitChar]))
            {
                // If this isn't EOF, something is wrong
                if (LitChar + i != 15 + 255)
                    return ABORT_CODE;
            }

            LitChar = s_gdcLenBase[LitChar] + i;
        }

        LitChar += 256;
    }
    else
    {
        // Char found
        if (!GDCWasteBits(pgdcExp, 1))
            return ABORT_CODE;

        LitChar = (pgdcExp->SrcByte & 0xFF);

        if (!GDCWasteBits(pgdcExp, 8))
             return ABORT_CODE;
    }

    return LitChar;
}


//
// GDCDecodeDist()
//
UINT  GDCDecodeDist
(
    PGDC_EXPLODE    pgdcExp,
    UINT            Len
)
{
    UINT            Dist;

    Dist = s_gdcDistDecode[pgdcExp->SrcByte & 0xFF];

    if (!GDCWasteBits(pgdcExp, s_gdcDistBits[Dist]))
        return 0;

    if (Len == GDC_MINREP)
    {
        // GDC_MINREP is 2, hence we shift over by 2 then mask the low 2 bits
        Dist <<= GDC_MINREP;
        Dist |= (pgdcExp->SrcByte & 3);
        if (!GDCWasteBits(pgdcExp, GDC_MINREP))
            return 0;
    }
    else
    {
        Dist <<= pgdcExp->ExtDistBits;
        Dist |=( pgdcExp->SrcByte & pgdcExp->ExtDistMask);
        if (!GDCWasteBits(pgdcExp, pgdcExp->ExtDistBits))
            return 0;
    }

    return Dist+1;
}


//
// GDCWasteBits()
//
BOOL  GDCWasteBits
(
    PGDC_EXPLODE    pgdcExp,
    UINT            cBits
)
{
    if (cBits <= pgdcExp->SrcBits)
    {
        pgdcExp->SrcByte >>= cBits;
        pgdcExp->SrcBits -= cBits;
    }
    else
    {
        pgdcExp->SrcByte >>= pgdcExp->SrcBits;

        //
        // We need to advance to the next source byte.  Can we, or have
        // we reached the end already?
        //
        if (!pgdcExp->cbSrc)
            return(FALSE);

        pgdcExp->SrcByte |= (*pgdcExp->pSrc) << 8;

        //
        // Move these to the next byte in the compressed source
        //
        ++(pgdcExp->pSrc);
        --(pgdcExp->cbSrc);

        pgdcExp->SrcByte >>= (cBits - pgdcExp->SrcBits);
        pgdcExp->SrcBits = 8 - (cBits - pgdcExp->SrcBits);
    }

    return(TRUE);
}