jjj1comp.c

[随书类]Dos6.0源代码

    LONG     libSrcStart = tell(fhSrc);
    LONG     libDestStart = tell(fhDest);
    LONG     lReturn;
    static   SHORT    b8Bit, b6Bit, b5Bit, b4aBit, b4bBit;
    SHORT    cb8Hdr, cb6Hdr, cb5Hdr, cb4aHdr, cb4bHdr;
    int      isPtr = FALSE;
    int      iJmpReturn;

    bBitHold = cbBitHold = 0;
    ibLitBuf = 0;

    if (bPassCnt == 0)
        {
        if (!FAllocateJJJGlobals(lcbDestMax, (BOOL)TRUE))
            return((LONG)rcOutOfMemory);

        if ((lcbSrcStart = lseek(fhSrc, 0L, SEEK_CUR)) == -1L)
            {
            FreeJJJGlobals();
            return((LONG)rcReadSeekError);
            }

        if ((iJmpReturn = setjmp(jmpEnv)) != 0)
            {
            fJmpEnvSet = FALSE;
            FreeJJJGlobals();
            return((LONG)iJmpReturn);
            }
        fJmpEnvSet = TRUE;

        if (lcbDestMax != NIL && (LONG)(fpbOutBufEnd - fpbOutBuf) > lcbDestMax)
              fpbOutBufEnd = fpbOutBuf + (SHORT)lcbDestMax;

        fhDestGlobal = fhDest;
        lcbSkipOut = 0L;
        fpbBufDest = NULL;

        InitAnalyze();
        }
    else
        {
        // Output the header info and tables
        WriteByte((BYTE) ((b4aBit<<4) | b4bBit));
        WriteByte((BYTE) ((b5Bit<<4)  | b6Bit));  
        WriteByte((BYTE) ((b8Bit<<4)  | 0));  

        WriteTable(fpct4a, 16, b4aBit);
        WriteTable(fpct4b, 16, b4bBit);
        WriteTable(fpct5,  32, b5Bit);
        WriteTable(fpct6,  64, b6Bit);
        WriteTable(fpct8, 256, b8Bit);
        }

    LZInitTree();

    /* Clear the buffer with any character that will appear often. */
    ibStringCur = 0;
    _fmemset(ringBuf, ' ', (ibCharCur = cbBufMax - cbStrMax));

    /* Read cbStrMax bytes into the last cbStrMax bytes of the buffer */
    for (cbLen = 0; (USHORT)cbLen < cbStrMax && (ch = ReadByte(fhSrc)) != EOF;
            cbLen++)
        ringBuf[ibCharCur + cbLen] = (BYTE)ch;

    /* Insert the cbStrMax strings,
    ** each of which begins with one or more 'space' characters.  Note
    ** the order in which these strings are inserted.  This way,
    ** degenerate trees will be less likely to occur.
    */
    for (us = 1; us <= cbStrMax; us++)
        LZInsertNode(ibCharCur - us);

    /* Finally, insert the whole string just read.  The
    ** global variables cbMatchCur and iMatchCur are set.
    */
    LZInsertNode(ibCharCur);

    do  {
        /* cbMatchCur may be spuriously long near the end of text. */
        if ((SHORT) cbMatchCur > cbLen)
            cbMatchCur = cbLen;

        if (cbMatchCur <= cbIndex)
            {  /* Not long enough match. Send one byte. */
               /* 'send one byte' flag.  Send uncoded. */
            cbMatchCur = 1;
            rgbLitBuf[ibLitBuf++] = ringBuf[ibCharCur];
            if (ibLitBuf >= cbLitMax)
                {
                if (ibLitBuf)  // Flush Literals
                    {
                    if (ibLitBuf == cbLitMax)
                        isPtr = FALSE;
                    else
                        isPtr = TRUE;

                    if (bPassCnt == 0)  // Analyze phase
                        {
                        fpbAnalysis4a[0]++;
                        fpbAnalysis5[ibLitBuf-1]++;
                        }
                    else
                        {
                        WriteHuffman4a(0);
                        WriteHuffman5((BYTE) (ibLitBuf-1));
                        }
                    if (fWriteError || fDestFull)
                        goto LExit;

                    for (cnt = 0; cnt < ibLitBuf; cnt++)
                        {
                        if (bPassCnt == 0) // Analyze phase
                            fpbAnalysis8[rgbLitBuf[cnt]]++;
                        else
                            WriteHuffman8(rgbLitBuf[cnt]);

                        if (fWriteError || fDestFull)
                            goto LExit;
                        }
                    ibLitBuf = 0; 
                    }
                }
            }
        else
            {  /* Send position and length pair. Note cbMatchCur > cbIndex. */
            if (ibLitBuf)  // Flush Literals
                {
                if (ibLitBuf == cbLitMax)
                    isPtr = FALSE;
                else
                    isPtr = TRUE;

                if (bPassCnt == 0)  // Analyze phase
                    {
                    fpbAnalysis4a[0]++;
                    fpbAnalysis5[ibLitBuf-1]++;
                    }
                else
                    {
                    WriteHuffman4a(0);
                    WriteHuffman5((BYTE) (ibLitBuf-1));
                    }
                if (fWriteError || fDestFull)
                    goto LExit;

                for (cnt = 0; cnt < ibLitBuf; cnt++)
                    {
                    if (bPassCnt == 0) // Analyze phase
                        fpbAnalysis8[rgbLitBuf[cnt]]++;
                    else
                        WriteHuffman8(rgbLitBuf[cnt]);

                    if (fWriteError || fDestFull)
                        goto LExit;
                    }
                ibLitBuf = 0; 
                }

            iMatchRel = (ibCharCur + cbBufMax - iMatchCur) & (cbBufMax-1);
            if (bPassCnt == 0) // Analyze Phase
                {
                if (isPtr)
                    fpbAnalysis4b[cbMatchCur-cbIndex]++;
                else
                    fpbAnalysis4a[cbMatchCur-cbIndex]++;

                fpbAnalysis6 [iMatchRel>>6]++;
                }
            else
                {
                if (isPtr)
                    WriteHuffman4b((BYTE) (cbMatchCur-cbIndex));
                else
                    WriteHuffman4a((BYTE) (cbMatchCur-cbIndex));

                WriteHuffman6((BYTE) (iMatchRel>>6));
                WriteBits(iMatchRel, 6);
                }
            isPtr = FALSE;
            }

        cbMatchLast = cbMatchCur;

        for (us = 0; us < (USHORT)cbMatchLast && (ch=ReadByte(fhSrc))!=EOF;us++)
            {
            LZDeleteNode(ibStringCur);      /* Delete old strings and */
            ringBuf[ibStringCur] = (BYTE)ch;        /* read new bytes */

              /* If the position is near the end of buffer, extend the
              ** buffer to make string comparison easier.
              */
            if ((USHORT)ibStringCur < cbStrMax - 1)
                ringBuf[ibStringCur + cbBufMax] = (BYTE)ch;

              /* ring buffer, increment the position modulo N. */
            ibStringCur = ibStringCur+1 & (cbBufMax - 1);
            ibCharCur = ibCharCur+1 & (cbBufMax - 1);

              /* Register the string in ringBuf[r..r+cbStrMax-1] */
            LZInsertNode(ibCharCur);
            }

        while (us++ < (USHORT) cbMatchLast)      /* After the end of text, */
            {
            LZDeleteNode(ibStringCur);        /* no need to read, but */

            ibStringCur = ibStringCur+1 & (cbBufMax - 1);
            ibCharCur = ibCharCur+1 & (cbBufMax - 1);
            if (--cbLen)
                LZInsertNode(ibCharCur);          /* buffer may not be empty. */
            }
        } while (cbLen > 0); /* length of string to be processed is zero */

    if (ibLitBuf)  // Flush Literals
        {
        if (ibLitBuf == cbLitMax)
            isPtr = FALSE;
        else
            isPtr = TRUE;

        if (bPassCnt == 0)  // Analyze phase
            {
            fpbAnalysis4a[0]++;
            fpbAnalysis5[ibLitBuf-1]++;
            }
        else
            {
            WriteHuffman4a(0);
            WriteHuffman5((BYTE) (ibLitBuf-1));
            }
        if (fWriteError || fDestFull)
            goto LExit;
        for (cnt = 0; cnt < ibLitBuf; cnt++)
            {
            if (bPassCnt == 0) // Analyze phase
                fpbAnalysis8[rgbLitBuf[cnt]]++;
            else
                WriteHuffman8(rgbLitBuf[cnt]);

            if (fWriteError || fDestFull)
                goto LExit;
            }
        ibLitBuf = 0; 
        }

    if (bPassCnt > 0)  // Not the analyze phase
        {
        if (cbBitHold)  // There are a few bits left in the stream
            if (isPtr)
                // Make sure extraneous bits aren't interpeted as a 0
                if (fpct4b[0].usCode&1)
                    WriteBits(0,   8-cbBitHold);
                else
                    WriteBits(255, 8-cbBitHold);
            else
                if (fpct4a[0].usCode&1)
                    WriteBits(0,   8-cbBitHold);
                else
                    WriteBits(255, 8-cbBitHold);

        WriteOutBuff(0);
        }
    else
        {
        BuildHTree(fpbAnalysis4a, 16, fpct4a);
        if (!BuildCodeTable(fpct4a, 16))
            {
            fJmpEnvSet = FALSE;
            FreeJJJGlobals();
            return(rcGenericCompError);
            }

        BuildHTree(fpbAnalysis4b, 16, fpct4b);  
        if (!BuildCodeTable(fpct4b, 16)) 
            {
            fJmpEnvSet = FALSE;
            FreeJJJGlobals();
            return(rcGenericCompError);
            }

        BuildHTree(fpbAnalysis5, 32, fpct5);
        if (!BuildCodeTable(fpct5, 32))
            {
            fJmpEnvSet = FALSE;
            FreeJJJGlobals();
            return(rcGenericCompError);
            }

        BuildHTree(fpbAnalysis6, 64, fpct6);
        if (!BuildCodeTable(fpct6, 64))
            {
            fJmpEnvSet = FALSE;
            FreeJJJGlobals();
            return(rcGenericCompError);
            }

        BuildHTree(fpbAnalysis8, 256, fpct8);
        if (!BuildCodeTable(fpct8, 256))
            {
            fJmpEnvSet = FALSE;
            FreeJJJGlobals();
            return(rcGenericCompError);
            }
      
        cb4aHdr = TableComp(fpct4a, 16, &b4aBit);
        cb4bHdr = TableComp(fpct4b, 16, &b4bBit);
        cb5Hdr  = TableComp(fpct5,  32, &b5Bit);
        cb6Hdr  = TableComp(fpct6,  64, &b6Bit);
        cb8Hdr  = TableComp(fpct8, 256, &b8Bit);
      
        CodeTradeoff(fpbAnalysis4a, fpct4a, 16, cb4aHdr, &b4aBit);
        CodeTradeoff(fpbAnalysis4b, fpct4b, 16, cb4bHdr, &b4bBit);
        CodeTradeoff(fpbAnalysis5 , fpct5,  32, cb5Hdr,  &b5Bit);
        CodeTradeoff(fpbAnalysis6 , fpct6,  64, cb6Hdr,  &b6Bit);
        CodeTradeoff(fpbAnalysis8 , fpct8, 256, cb8Hdr,  &b8Bit);

        if (lseek(fhSrc, lcbSrcStart, SEEK_SET) == -1L)
            {
            fJmpEnvSet = FALSE;
            FreeJJJGlobals();
            return((LONG)rcReadSeekError);
            }

        bPassCnt = 1;
        lReturn  = Lcb_JJJ1_CompressToFile(fhSrc, fhDest, lcbDestMax);
        bPassCnt = 0;
        return(lReturn);
        }
LExit:
    fJmpEnvSet = FALSE;
    FreeJJJGlobals();
 
    if (fWriteError)
        return((LONG)rcWriteError);

    if (lcbDestMax == NIL || fhDest == -1)
        return(lcbDest);

      /* fix fhSrc because we split */
    lReturn = lcbDest;             /* lcbDest gets altered by the Decomp call */

    /* reset fhDest (after header) */
    if (lseek(fhDest, libDestStart, SEEK_SET) == -1L)
        return((LONG)rcWriteSeekError);

    /* lcbDest = uncompressed length of this current piece */
    lcbDest = Lcb_JJJ1_DecompressToFile(fhDest, -1, NIL, 0L, NULL, 0L);
    if (lcbDest < rcNoError)
        return(lcbDest);

    /* reset fhSrc */
    if (lseek(fhSrc, libSrcStart + lcbDest, SEEK_SET) == -1L)
        return((LONG)rcReadSeekError);

    return(lReturn);
}