/* * jdhuff.h * * This file was part of the Independent JPEG Group's software: * Copyright (C) 1991-1997, Thomas G. Lane. * libjpeg-turbo Modifications: * Copyright (C) 2010-2011, 2015-2016, 2021, D. R. Commander. * Copyright (C) 2018, Matthias Räncker. * For conditions of distribution and use, see the accompanying README.ijg * file. * * This file contains declarations for Huffman entropy decoding routines * that are shared between the sequential decoder (jdhuff.c) and the * progressive decoder (jdphuff.c). No other modules need to see these. */ #include "jconfigint.h" /* Derived data constructed for each Huffman table */ #define HUFF_LOOKAHEAD … d_derived_tbl; /* Expand a Huffman table definition into the derived format */ EXTERN(void) jpeg_make_d_derived_tbl(j_decompress_ptr cinfo, boolean isDC, int tblno, d_derived_tbl **pdtbl); /* * Fetching the next N bits from the input stream is a time-critical operation * for the Huffman decoders. We implement it with a combination of inline * macros and out-of-line subroutines. Note that N (the number of bits * demanded at one time) never exceeds 15 for JPEG use. * * We read source bytes into get_buffer and dole out bits as needed. * If get_buffer already contains enough bits, they are fetched in-line * by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer * as full as possible (not just to the number of bits needed; this * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer). * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension. * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains * at least the requested number of bits --- dummy zeroes are inserted if * necessary. */ #if !defined(_WIN32) && !defined(SIZEOF_SIZE_T) #error Cannot determine word size #endif #if SIZEOF_SIZE_T == 8 || defined(_WIN64) bit_buf_type; /* type of bit-extraction buffer */ #define BIT_BUF_SIZE … #elif defined(__x86_64__) && defined(__ILP32__) typedef unsigned long long bit_buf_type; /* type of bit-extraction buffer */ #define BIT_BUF_SIZE … #else typedef unsigned long bit_buf_type; /* type of bit-extraction buffer */ #define BIT_BUF_SIZE … #endif /* If long is > 32 bits on your machine, and shifting/masking longs is * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE * appropriately should be a win. Unfortunately we can't define the size * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8) * because not all machines measure sizeof in 8-bit bytes. */ bitread_perm_state; bitread_working_state; /* Macros to declare and load/save bitread local variables. */ #define BITREAD_STATE_VARS … #define BITREAD_LOAD_STATE(cinfop, permstate) … #define BITREAD_SAVE_STATE(cinfop, permstate) … /* * These macros provide the in-line portion of bit fetching. * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer * before using GET_BITS, PEEK_BITS, or DROP_BITS. * The variables get_buffer and bits_left are assumed to be locals, * but the state struct might not be (jpeg_huff_decode needs this). * CHECK_BIT_BUFFER(state, n, action); * Ensure there are N bits in get_buffer; if suspend, take action. * val = GET_BITS(n); * Fetch next N bits. * val = PEEK_BITS(n); * Fetch next N bits without removing them from the buffer. * DROP_BITS(n); * Discard next N bits. * The value N should be a simple variable, not an expression, because it * is evaluated multiple times. */ #define CHECK_BIT_BUFFER(state, nbits, action) … #define GET_BITS(nbits) … #define PEEK_BITS(nbits) … #define DROP_BITS(nbits) … /* Load up the bit buffer to a depth of at least nbits */ EXTERN(boolean) jpeg_fill_bit_buffer(bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, int nbits); /* * Code for extracting next Huffman-coded symbol from input bit stream. * Again, this is time-critical and we make the main paths be macros. * * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits * without looping. Usually, more than 95% of the Huffman codes will be 8 * or fewer bits long. The few overlength codes are handled with a loop, * which need not be inline code. * * Notes about the HUFF_DECODE macro: * 1. Near the end of the data segment, we may fail to get enough bits * for a lookahead. In that case, we do it the hard way. * 2. If the lookahead table contains no entry, the next code must be * more than HUFF_LOOKAHEAD bits long. * 3. jpeg_huff_decode returns -1 if forced to suspend. */ #define HUFF_DECODE(result, state, htbl, failaction, slowlabel) … #define HUFF_DECODE_FAST(s, nb, htbl) … /* Out-of-line case for Huffman code fetching */ EXTERN(int) jpeg_huff_decode(bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, d_derived_tbl *htbl, int min_bits);