| 1 | /*
|
|---|
| 2 | * jdhuff.h
|
|---|
| 3 | *
|
|---|
| 4 | * Copyright (C) 1991-1997, Thomas G. Lane.
|
|---|
| 5 | * This file is part of the Independent JPEG Group's software.
|
|---|
| 6 | * For conditions of distribution and use, see the accompanying README file.
|
|---|
| 7 | *
|
|---|
| 8 | * This file contains declarations for Huffman entropy decoding routines
|
|---|
| 9 | * that are shared between the sequential decoder (jdhuff.c) and the
|
|---|
| 10 | * progressive decoder (jdphuff.c). No other modules need to see these.
|
|---|
| 11 | */
|
|---|
| 12 |
|
|---|
| 13 | /* Short forms of external names for systems with brain-damaged linkers. */
|
|---|
| 14 |
|
|---|
| 15 | #ifdef NEED_SHORT_EXTERNAL_NAMES
|
|---|
| 16 | #define jpeg_make_d_derived_tbl jMkDDerived
|
|---|
| 17 | #define jpeg_fill_bit_buffer jFilBitBuf
|
|---|
| 18 | #define jpeg_huff_decode jHufDecode
|
|---|
| 19 | #endif /* NEED_SHORT_EXTERNAL_NAMES */
|
|---|
| 20 |
|
|---|
| 21 |
|
|---|
| 22 | /* Derived data constructed for each Huffman table */
|
|---|
| 23 |
|
|---|
| 24 | #define HUFF_LOOKAHEAD 8 /* # of bits of lookahead */
|
|---|
| 25 |
|
|---|
| 26 | typedef struct {
|
|---|
| 27 | /* Basic tables: (element [0] of each array is unused) */
|
|---|
| 28 | INT32 maxcode[18]; /* largest code of length k (-1 if none) */
|
|---|
| 29 | /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
|
|---|
| 30 | INT32 valoffset[17]; /* huffval[] offset for codes of length k */
|
|---|
| 31 | /* valoffset[k] = huffval[] index of 1st symbol of code length k, less
|
|---|
| 32 | * the smallest code of length k; so given a code of length k, the
|
|---|
| 33 | * corresponding symbol is huffval[code + valoffset[k]]
|
|---|
| 34 | */
|
|---|
| 35 |
|
|---|
| 36 | /* Link to public Huffman table (needed only in jpeg_huff_decode) */
|
|---|
| 37 | JHUFF_TBL *pub;
|
|---|
| 38 |
|
|---|
| 39 | /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of
|
|---|
| 40 | * the input data stream. If the next Huffman code is no more
|
|---|
| 41 | * than HUFF_LOOKAHEAD bits long, we can obtain its length and
|
|---|
| 42 | * the corresponding symbol directly from these tables.
|
|---|
| 43 | */
|
|---|
| 44 | int look_nbits[1<<HUFF_LOOKAHEAD]; /* # bits, or 0 if too long */
|
|---|
| 45 | UINT8 look_sym[1<<HUFF_LOOKAHEAD]; /* symbol, or unused */
|
|---|
| 46 | } d_derived_tbl;
|
|---|
| 47 |
|
|---|
| 48 | /* Expand a Huffman table definition into the derived format */
|
|---|
| 49 | EXTERN(void) jpeg_make_d_derived_tbl
|
|---|
| 50 | JPP((j_decompress_ptr cinfo, boolean isDC, int tblno,
|
|---|
| 51 | d_derived_tbl ** pdtbl));
|
|---|
| 52 |
|
|---|
| 53 |
|
|---|
| 54 | /*
|
|---|
| 55 | * Fetching the next N bits from the input stream is a time-critical operation
|
|---|
| 56 | * for the Huffman decoders. We implement it with a combination of inline
|
|---|
| 57 | * macros and out-of-line subroutines. Note that N (the number of bits
|
|---|
| 58 | * demanded at one time) never exceeds 15 for JPEG use.
|
|---|
| 59 | *
|
|---|
| 60 | * We read source bytes into get_buffer and dole out bits as needed.
|
|---|
| 61 | * If get_buffer already contains enough bits, they are fetched in-line
|
|---|
| 62 | * by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough
|
|---|
| 63 | * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
|
|---|
| 64 | * as full as possible (not just to the number of bits needed; this
|
|---|
| 65 | * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
|
|---|
| 66 | * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
|
|---|
| 67 | * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
|
|---|
| 68 | * at least the requested number of bits --- dummy zeroes are inserted if
|
|---|
| 69 | * necessary.
|
|---|
| 70 | */
|
|---|
| 71 |
|
|---|
| 72 | typedef INT32 bit_buf_type; /* type of bit-extraction buffer */
|
|---|
| 73 | #define BIT_BUF_SIZE 32 /* size of buffer in bits */
|
|---|
| 74 |
|
|---|
| 75 | /* If long is > 32 bits on your machine, and shifting/masking longs is
|
|---|
| 76 | * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
|
|---|
| 77 | * appropriately should be a win. Unfortunately we can't define the size
|
|---|
| 78 | * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
|
|---|
| 79 | * because not all machines measure sizeof in 8-bit bytes.
|
|---|
| 80 | */
|
|---|
| 81 |
|
|---|
| 82 | typedef struct { /* Bitreading state saved across MCUs */
|
|---|
| 83 | bit_buf_type get_buffer; /* current bit-extraction buffer */
|
|---|
| 84 | int bits_left; /* # of unused bits in it */
|
|---|
| 85 | } bitread_perm_state;
|
|---|
| 86 |
|
|---|
| 87 | typedef struct { /* Bitreading working state within an MCU */
|
|---|
| 88 | /* Current data source location */
|
|---|
| 89 | /* We need a copy, rather than munging the original, in case of suspension */
|
|---|
| 90 | const JOCTET * next_input_byte; /* => next byte to read from source */
|
|---|
| 91 | size_t bytes_in_buffer; /* # of bytes remaining in source buffer */
|
|---|
| 92 | /* Bit input buffer --- note these values are kept in register variables,
|
|---|
| 93 | * not in this struct, inside the inner loops.
|
|---|
| 94 | */
|
|---|
| 95 | bit_buf_type get_buffer; /* current bit-extraction buffer */
|
|---|
| 96 | int bits_left; /* # of unused bits in it */
|
|---|
| 97 | /* Pointer needed by jpeg_fill_bit_buffer. */
|
|---|
| 98 | j_decompress_ptr cinfo; /* back link to decompress master record */
|
|---|
| 99 | } bitread_working_state;
|
|---|
| 100 |
|
|---|
| 101 | /* Macros to declare and load/save bitread local variables. */
|
|---|
| 102 | #define BITREAD_STATE_VARS \
|
|---|
| 103 | register bit_buf_type get_buffer; \
|
|---|
| 104 | register int bits_left; \
|
|---|
| 105 | bitread_working_state br_state
|
|---|
| 106 |
|
|---|
| 107 | #define BITREAD_LOAD_STATE(cinfop,permstate) \
|
|---|
| 108 | br_state.cinfo = cinfop; \
|
|---|
| 109 | br_state.next_input_byte = cinfop->src->next_input_byte; \
|
|---|
| 110 | br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
|
|---|
| 111 | get_buffer = permstate.get_buffer; \
|
|---|
| 112 | bits_left = permstate.bits_left;
|
|---|
| 113 |
|
|---|
| 114 | #define BITREAD_SAVE_STATE(cinfop,permstate) \
|
|---|
| 115 | cinfop->src->next_input_byte = br_state.next_input_byte; \
|
|---|
| 116 | cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
|
|---|
| 117 | permstate.get_buffer = get_buffer; \
|
|---|
| 118 | permstate.bits_left = bits_left
|
|---|
| 119 |
|
|---|
| 120 | /*
|
|---|
| 121 | * These macros provide the in-line portion of bit fetching.
|
|---|
| 122 | * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
|
|---|
| 123 | * before using GET_BITS, PEEK_BITS, or DROP_BITS.
|
|---|
| 124 | * The variables get_buffer and bits_left are assumed to be locals,
|
|---|
| 125 | * but the state struct might not be (jpeg_huff_decode needs this).
|
|---|
|
|---|
