huffd.c

dicom file 查看工具 DICOM文件是医疗设备使用的文件格式。

/*
 * huffd.c --
 *
 * Code for JPEG lossless decoding.  Large parts are grabbed from the IJG
 * software
 */
/*
 * $Id: huffd.c,v 1.6 2004/08/18 21:38:43 enlf Exp $
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "jpeg.h"
#include "mcu.h"
#include "io.h"
#include "proto.h"
#include "predict.h"


#define RST0    0xD0                /* RST0 marker code */

static long getBuffer;              /* current bit-extraction buffer */
static int  bitsLeft;               /* # of unused bits in it */

/*
 * The following variables keep track of the input buffer
 * for the JPEG data, which is read by ReadJpegData.
 */
Uchar *inputBuffer = 0;           /* Input buffer for JPEG data */
int inputBufferOffset = 0;        /* Offset of current byte */

/*
 * Code for extracting the next N bits from the input stream.
 * (N never exceeds 15 for JPEG data.)
 * This needs to go as fast as possible!
 *
 * We read source bytes into getBuffer and dole out bits as needed.
 * If getBuffer already contains enough bits, they are fetched in-line
 * by the macros get_bits() and get_bit().  When there aren't enough bits,
 * FillBitBuffer is called; it will attempt to fill getBuffer to the
 * "high water mark", then extract the desired number of bits.  The idea,
 * of course, is to minimize the function-call overhead cost of entering
 * FillBitBuffer.
 * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
 * of getBuffer to be used.  (On machines with wider words, an even larger
 * buffer could be used.)  
 */

#define BITS_PER_LONG (8*sizeof(long))
#define MIN_GET_BITS  (BITS_PER_LONG-7) /* max value for long getBuffer */

/*
 * bmask[n] is mask for n rightmost bits
 */
static int bmask[] = {0x0000,
         0x0001, 0x0003, 0x0007, 0x000F,
         0x001F, 0x003F, 0x007F, 0x00FF,
         0x01FF, 0x03FF, 0x07FF, 0x0FFF,
         0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF};

/*
 *--------------------------------------------------------------
 *
 * FillBitBuffer --
 *
 *        Load up the bit buffer with at least nbits
 *        Process any stuffed bytes at this time.
 *
 * Results:
 *        None
 *
 * Side effects:
 *        The bitwise global variables are updated.
 *
 *--------------------------------------------------------------
 */
#define FillBitBuffer(nbits) {                                          \
    int c, c2;                                                          \
    while (bitsLeft < MIN_GET_BITS) {                                   \
        c = GetJpegChar ();                                             \
        /* If it's 0xFF, check and discard stuffed zero byte */         \
        if (c == 0xFF) {                                                \
            c2 = GetJpegChar ();                                        \
            if (c2 != 0) {                                              \
                UnGetJpegChar (c2);                                     \
                UnGetJpegChar (c);                                      \
                c = 0;                                                  \
            }                                                           \
        }/*endif 0xFF*/                                                 \
        /* OK, load c into getBuffer */                                 \
        getBuffer = (getBuffer << 8) | c;                               \
        bitsLeft += 8;                                                  \
    }/*endwhile*/                                                       \
}/*endof FillBitBuffer*/

/* Macros to make things go at some speed! */
/* NB: parameter to get_bits should be simple variable, not expression */

#define show_bits(nbits,rv) {                                           \
    if (bitsLeft < nbits) FillBitBuffer(nbits);                         \
    rv = (getBuffer >> (bitsLeft-(nbits))) & bmask[nbits];              \
}

#define show_bits8(rv) {                                                \
        if (bitsLeft < 8) FillBitBuffer(8);                             \
        rv = (getBuffer >> (bitsLeft-8)) & 0xff;                        \
}

#define flush_bits(nbits) {                                             \
        bitsLeft -= (nbits);                                            \
}

#define get_bits(nbits,rv) {                                            \
        if (bitsLeft < nbits) FillBitBuffer(nbits);                     \
        rv = ((getBuffer >> (bitsLeft -= (nbits)))) & bmask[nbits];     \
}

#define get_bit(rv) {                                                   \
        if (!bitsLeft) FillBitBuffer(1);                                \
        rv = (getBuffer >> (--bitsLeft)) & 1;                           \
}

/*
 *--------------------------------------------------------------
 *
 * PmPutRow --
 *
 *      Output one row of pixels stored in RowBuf.
 *
 * Results:
 *      None
 *
 * Side effects:
 *      One row of pixels are write to file pointed by outFile.
 *
 *--------------------------------------------------------------
 */   


void PmPutRow24(MCU *RowBuf, int numCol, unsigned char **image)
{
        register int col;

        for (col = 0; col < numCol; col++)
    {
             /* take each RGB column */
             **image = (unsigned char) RowBuf[col][0];
             *(*image+1) = (unsigned char) RowBuf[col][1];
             *(*image+2) = (unsigned char) RowBuf[col][2];
             (*image)+=3;
    }
}

                                   
void PmPutRow16(MCU *RowBuf, int numCol, unsigned short **image)
{  
        register int col;          

        for (col = 0; col < numCol; col++)
    {                   
             **image = (unsigned short) RowBuf[col][0];
             (*image)++;                                        
    }
}   


void PmPutRow8(MCU *RowBuf, int numCol, unsigned char **image)
{  
        register int col;          

        for (col = 0; col < numCol; col++)
    {                   
             **image = (unsigned char) RowBuf[col][0];
             (*image)++;                                        
    }   
}   
                                                                           



/*
 *--------------------------------------------------------------
 *
 * HuffDecode --
 *
 *        Taken from Figure F.16: extract next coded symbol from
 *        input stream.  This should becode a macro.
 *
 * Results:
 *        Next coded symbol
 *
 * Side effects:
 *        Bitstream is parsed.
 *
 *--------------------------------------------------------------
 */
#define HuffDecode(htbl,rv)                                             \
{                                                                       \
    int l, code, temp;                                                  \
                                                                        \
    /*                                                                  \
     * If the huffman code is less than 8 bits, we can use the fast     \
     * table lookup to get its value.  It's more than 8 bits about      \
     * 3-4% of the time.                                                \
     */                                                                 \
    show_bits8(code);                                                   \
    if (htbl->numbits[code]) {                                          \
        flush_bits(htbl->numbits[code]);                                \
        rv=htbl->value[code];                                           \
    }                                                                   \
    else {                                                              \
        flush_bits(8);                                                  \
        l = 8;                                                          \
        while (code > htbl->maxcode[l]) {                               \
            get_bit(temp);                                              \
            code = (code << 1) | temp;                                  \
            l++;                                                        \
        }                                                               \
                                                                        \
        /*                                                              \
         * With garbage input we may reach the sentinel value l = 17.   \
         */                                                             \
                                                                        \
        if (l > 16) {                                                   \
            fprintf (stderr, "Corrupt JPEG data: bad Huffman code\n");  \
            rv = 0; /* fake a zero as the safest result */              \
        } else {                                                        \
            rv = htbl->huffval[htbl->valptr[l] +                        \
                ((int)(code - htbl->mincode[l]))];                      \
        }                                                               \
    }/*endelse*/                                                        \
}/*HuffDecode*/

/*
 *--------------------------------------------------------------
 *
 * HuffExtend --
 *
 *        Code and table for Figure F.12: extend sign bit
 *
 * Results:
 *        The extended value.
 *
 * Side effects:
 *        None.
 *
 *--------------------------------------------------------------
 */
static int extendTest[16] =        /* entry n is 2**(n-1) */
{0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000};

static int extendOffset[16] =        /* entry n is (-1 << n) + 1 */
{0, ((-1) << 1) + 1, ((-1) << 2) + 1, ((-1) << 3) + 1, ((-1) << 4) + 1,
 ((-1) << 5) + 1, ((-1) << 6) + 1, ((-1) << 7) + 1, ((-1) << 8) + 1,
 ((-1) << 9) + 1, ((-1) << 10) + 1, ((-1) << 11) + 1, ((-1) << 12) + 1,
 ((-1) << 13) + 1, ((-1) << 14) + 1, ((-1) << 15) + 1};

#define HuffExtend(x,s) {                                               \
    if ((x) < extendTest[s]) {                                          \
        (x) += extendOffset[s];                                         \
    }                                                                   \
}

/*
 *--------------------------------------------------------------
 *
 * HuffDecoderInit --
 *
 *        Initialize for a Huffman-compressed scan.
 *        This is invoked after reading the SOS marker.
 *
 * Results:
 *        None
 *
 * Side effects:
 *        None.
 *
 *--------------------------------------------------------------
 */
void HuffDecoderInit (DecompressInfo *dcPtr)
{
    short ci;
    JpegComponentInfo *compptr;

    /*
     * Initialize static variables
     */
    bitsLeft = 0;

    for (ci = 0; ci < dcPtr->compsInScan; ci++) {
        compptr = dcPtr->curCompInfo[ci];
        /*
         * Make sure requested tables are present
         */
        if (dcPtr->dcHuffTblPtrs[compptr->dcTblNo] == NULL) { 
            fprintf (stderr, "Error: Use of undefined Huffman table\n");
            /* exit (1); */
            dcPtr->error = -1; return;
        }

        /*
         * Compute derived values for Huffman tables.
         * We may do this more than once for same table, but it's not a
         * big deal
         */
        FixHuffTbl (dcPtr->dcHuffTblPtrs[compptr->dcTblNo]);
    }

    /*
     * Initialize restart stuff
     */
    dcPtr->restartInRows = (dcPtr->restartInterval)/(dcPtr->imageWidth);
    dcPtr->restartRowsToGo = dcPtr->restartInRows;
    dcPtr->nextRestartNum = 0;
}

/*
 *--------------------------------------------------------------
 *
 * ProcessRestart --
 *
 *        Check for a restart marker & resynchronize decoder.
 *
 * Results:
 *        None.
 *
 * Side effects:
 *        BitStream is parsed, bit buffer is reset, etc.
 *
 *--------------------------------------------------------------
 */
static void ProcessRestart(DecompressInfo *dcPtr)
{
    int c, nbytes;
    /*short ci;*/

    /*
     * Throw away any unused bits remaining in bit buffer
     */
    nbytes = bitsLeft / 8;
    bitsLeft = 0;

    /*
     * Scan for next JPEG marker
     */
    do 
        {