OLD | NEW |
1 /* | 1 /* |
2 * jdhuff.h | 2 * jdhuff.h |
3 * | 3 * |
4 * This file was part of the Independent JPEG Group's software: | 4 * This file was part of the Independent JPEG Group's software: |
5 * Copyright (C) 1991-1997, Thomas G. Lane. | 5 * Copyright (C) 1991-1997, Thomas G. Lane. |
6 * Modifications: | 6 * libjpeg-turbo Modifications: |
7 * Copyright (C) 2010-2011, D. R. Commander. | 7 * Copyright (C) 2010-2011, 2015-2016, D. R. Commander. |
8 * For conditions of distribution and use, see the accompanying README file. | 8 * For conditions of distribution and use, see the accompanying README.ijg |
| 9 * file. |
9 * | 10 * |
10 * This file contains declarations for Huffman entropy decoding routines | 11 * This file contains declarations for Huffman entropy decoding routines |
11 * that are shared between the sequential decoder (jdhuff.c) and the | 12 * that are shared between the sequential decoder (jdhuff.c) and the |
12 * progressive decoder (jdphuff.c). No other modules need to see these. | 13 * progressive decoder (jdphuff.c). No other modules need to see these. |
13 */ | 14 */ |
14 | 15 |
15 /* Short forms of external names for systems with brain-damaged linkers. */ | 16 #include "jconfigint.h" |
16 | |
17 #ifdef NEED_SHORT_EXTERNAL_NAMES | |
18 #define jpeg_make_d_derived_tbl»jMkDDerived | |
19 #define jpeg_fill_bit_buffer» jFilBitBuf | |
20 #define jpeg_huff_decode» jHufDecode | |
21 #endif /* NEED_SHORT_EXTERNAL_NAMES */ | |
22 | 17 |
23 | 18 |
24 /* Derived data constructed for each Huffman table */ | 19 /* Derived data constructed for each Huffman table */ |
25 | 20 |
26 #define HUFF_LOOKAHEAD» 8» /* # of bits of lookahead */ | 21 #define HUFF_LOOKAHEAD 8 /* # of bits of lookahead */ |
27 | 22 |
28 typedef struct { | 23 typedef struct { |
29 /* Basic tables: (element [0] of each array is unused) */ | 24 /* Basic tables: (element [0] of each array is unused) */ |
30 INT32 maxcode[18];» » /* largest code of length k (-1 if none) */ | 25 JLONG maxcode[18]; /* largest code of length k (-1 if none) */ |
31 /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */ | 26 /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */ |
32 INT32 valoffset[18];» » /* huffval[] offset for codes of length k */ | 27 JLONG valoffset[18]; /* huffval[] offset for codes of length k */ |
33 /* valoffset[k] = huffval[] index of 1st symbol of code length k, less | 28 /* valoffset[k] = huffval[] index of 1st symbol of code length k, less |
34 * the smallest code of length k; so given a code of length k, the | 29 * the smallest code of length k; so given a code of length k, the |
35 * corresponding symbol is huffval[code + valoffset[k]] | 30 * corresponding symbol is huffval[code + valoffset[k]] |
36 */ | 31 */ |
37 | 32 |
38 /* Link to public Huffman table (needed only in jpeg_huff_decode) */ | 33 /* Link to public Huffman table (needed only in jpeg_huff_decode) */ |
39 JHUFF_TBL *pub; | 34 JHUFF_TBL *pub; |
40 | 35 |
41 /* Lookahead table: indexed by the next HUFF_LOOKAHEAD bits of | 36 /* Lookahead table: indexed by the next HUFF_LOOKAHEAD bits of |
42 * the input data stream. If the next Huffman code is no more | 37 * the input data stream. If the next Huffman code is no more |
43 * than HUFF_LOOKAHEAD bits long, we can obtain its length and | 38 * than HUFF_LOOKAHEAD bits long, we can obtain its length and |
44 * the corresponding symbol directly from this tables. | 39 * the corresponding symbol directly from this tables. |
45 * | 40 * |
46 * The lower 8 bits of each table entry contain the number of | 41 * The lower 8 bits of each table entry contain the number of |
47 * bits in the corresponding Huffman code, or HUFF_LOOKAHEAD + 1 | 42 * bits in the corresponding Huffman code, or HUFF_LOOKAHEAD + 1 |
48 * if too long. The next 8 bits of each entry contain the | 43 * if too long. The next 8 bits of each entry contain the |
49 * symbol. | 44 * symbol. |
50 */ | 45 */ |
51 int lookup[1<<HUFF_LOOKAHEAD]; | 46 int lookup[1<<HUFF_LOOKAHEAD]; |
52 } d_derived_tbl; | 47 } d_derived_tbl; |
53 | 48 |
54 /* Expand a Huffman table definition into the derived format */ | 49 /* Expand a Huffman table definition into the derived format */ |
55 EXTERN(void) jpeg_make_d_derived_tbl | 50 EXTERN(void) jpeg_make_d_derived_tbl |
56 » JPP((j_decompress_ptr cinfo, boolean isDC, int tblno, | 51 (j_decompress_ptr cinfo, boolean isDC, int tblno, |
57 » d_derived_tbl ** pdtbl)); | 52 d_derived_tbl ** pdtbl); |
58 | 53 |
59 | 54 |
60 /* | 55 /* |
61 * Fetching the next N bits from the input stream is a time-critical operation | 56 * Fetching the next N bits from the input stream is a time-critical operation |
62 * for the Huffman decoders. We implement it with a combination of inline | 57 * for the Huffman decoders. We implement it with a combination of inline |
63 * macros and out-of-line subroutines. Note that N (the number of bits | 58 * macros and out-of-line subroutines. Note that N (the number of bits |
64 * demanded at one time) never exceeds 15 for JPEG use. | 59 * demanded at one time) never exceeds 15 for JPEG use. |
65 * | 60 * |
66 * We read source bytes into get_buffer and dole out bits as needed. | 61 * We read source bytes into get_buffer and dole out bits as needed. |
67 * If get_buffer already contains enough bits, they are fetched in-line | 62 * If get_buffer already contains enough bits, they are fetched in-line |
68 * by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough | 63 * by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough |
69 * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer | 64 * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer |
70 * as full as possible (not just to the number of bits needed; this | 65 * as full as possible (not just to the number of bits needed; this |
71 * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer). | 66 * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer). |
72 * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension. | 67 * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension. |
73 * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains | 68 * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains |
74 * at least the requested number of bits --- dummy zeroes are inserted if | 69 * at least the requested number of bits --- dummy zeroes are inserted if |
75 * necessary. | 70 * necessary. |
76 */ | 71 */ |
77 | 72 |
78 #if __WORDSIZE == 64 || defined(_WIN64) | 73 #if !defined(_WIN32) && !defined(SIZEOF_SIZE_T) |
| 74 #error Cannot determine word size |
| 75 #endif |
79 | 76 |
80 typedef size_t bit_buf_type;» /* type of bit-extraction buffer */ | 77 #if SIZEOF_SIZE_T==8 || defined(_WIN64) |
81 #define BIT_BUF_SIZE 64» » /* size of buffer in bits */ | 78 |
| 79 typedef size_t bit_buf_type; /* type of bit-extraction buffer */ |
| 80 #define BIT_BUF_SIZE 64 /* size of buffer in bits */ |
82 | 81 |
83 #else | 82 #else |
84 | 83 |
85 typedef INT32 bit_buf_type;» /* type of bit-extraction buffer */ | 84 typedef unsigned long bit_buf_type; /* type of bit-extraction buffer */ |
86 #define BIT_BUF_SIZE 32» » /* size of buffer in bits */ | 85 #define BIT_BUF_SIZE 32 /* size of buffer in bits */ |
87 | 86 |
88 #endif | 87 #endif |
89 | 88 |
90 /* If long is > 32 bits on your machine, and shifting/masking longs is | 89 /* If long is > 32 bits on your machine, and shifting/masking longs is |
91 * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE | 90 * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE |
92 * appropriately should be a win. Unfortunately we can't define the size | 91 * appropriately should be a win. Unfortunately we can't define the size |
93 * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8) | 92 * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8) |
94 * because not all machines measure sizeof in 8-bit bytes. | 93 * because not all machines measure sizeof in 8-bit bytes. |
95 */ | 94 */ |
96 | 95 |
97 typedef struct {» » /* Bitreading state saved across MCUs */ | 96 typedef struct { /* Bitreading state saved across MCUs */ |
98 bit_buf_type get_buffer;» /* current bit-extraction buffer */ | 97 bit_buf_type get_buffer; /* current bit-extraction buffer */ |
99 int bits_left;» » /* # of unused bits in it */ | 98 int bits_left; /* # of unused bits in it */ |
100 } bitread_perm_state; | 99 } bitread_perm_state; |
101 | 100 |
102 typedef struct {» » /* Bitreading working state within an MCU */ | 101 typedef struct { /* Bitreading working state within an MCU */ |
103 /* Current data source location */ | 102 /* Current data source location */ |
104 /* We need a copy, rather than munging the original, in case of suspension */ | 103 /* We need a copy, rather than munging the original, in case of suspension */ |
105 const JOCTET * next_input_byte; /* => next byte to read from source */ | 104 const JOCTET *next_input_byte; /* => next byte to read from source */ |
106 size_t bytes_in_buffer;» /* # of bytes remaining in source buffer */ | 105 size_t bytes_in_buffer; /* # of bytes remaining in source buffer */ |
107 /* Bit input buffer --- note these values are kept in register variables, | 106 /* Bit input buffer --- note these values are kept in register variables, |
108 * not in this struct, inside the inner loops. | 107 * not in this struct, inside the inner loops. |
109 */ | 108 */ |
110 bit_buf_type get_buffer;» /* current bit-extraction buffer */ | 109 bit_buf_type get_buffer; /* current bit-extraction buffer */ |
111 int bits_left;» » /* # of unused bits in it */ | 110 int bits_left; /* # of unused bits in it */ |
112 /* Pointer needed by jpeg_fill_bit_buffer. */ | 111 /* Pointer needed by jpeg_fill_bit_buffer. */ |
113 j_decompress_ptr cinfo;» /* back link to decompress master record */ | 112 j_decompress_ptr cinfo; /* back link to decompress master record */ |
114 } bitread_working_state; | 113 } bitread_working_state; |
115 | 114 |
116 /* Macros to declare and load/save bitread local variables. */ | 115 /* Macros to declare and load/save bitread local variables. */ |
117 #define BITREAD_STATE_VARS \ | 116 #define BITREAD_STATE_VARS \ |
118 » register bit_buf_type get_buffer; \ | 117 register bit_buf_type get_buffer; \ |
119 » register int bits_left; \ | 118 register int bits_left; \ |
120 » bitread_working_state br_state | 119 bitread_working_state br_state |
121 | 120 |
122 #define BITREAD_LOAD_STATE(cinfop,permstate) \ | 121 #define BITREAD_LOAD_STATE(cinfop,permstate) \ |
123 » br_state.cinfo = cinfop; \ | 122 br_state.cinfo = cinfop; \ |
124 » br_state.next_input_byte = cinfop->src->next_input_byte; \ | 123 br_state.next_input_byte = cinfop->src->next_input_byte; \ |
125 » br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \ | 124 br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \ |
126 » get_buffer = permstate.get_buffer; \ | 125 get_buffer = permstate.get_buffer; \ |
127 » bits_left = permstate.bits_left; | 126 bits_left = permstate.bits_left; |
128 | 127 |
129 #define BITREAD_SAVE_STATE(cinfop,permstate) \ | 128 #define BITREAD_SAVE_STATE(cinfop,permstate) \ |
130 » cinfop->src->next_input_byte = br_state.next_input_byte; \ | 129 cinfop->src->next_input_byte = br_state.next_input_byte; \ |
131 » cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \ | 130 cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \ |
132 » permstate.get_buffer = get_buffer; \ | 131 permstate.get_buffer = get_buffer; \ |
133 » permstate.bits_left = bits_left | 132 permstate.bits_left = bits_left |
134 | 133 |
135 /* | 134 /* |
136 * These macros provide the in-line portion of bit fetching. | 135 * These macros provide the in-line portion of bit fetching. |
137 * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer | 136 * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer |
138 * before using GET_BITS, PEEK_BITS, or DROP_BITS. | 137 * before using GET_BITS, PEEK_BITS, or DROP_BITS. |
139 * The variables get_buffer and bits_left are assumed to be locals, | 138 * The variables get_buffer and bits_left are assumed to be locals, |
140 * but the state struct might not be (jpeg_huff_decode needs this). | 139 * but the state struct might not be (jpeg_huff_decode needs this). |
141 *» CHECK_BIT_BUFFER(state,n,action); | 140 * CHECK_BIT_BUFFER(state,n,action); |
142 *» » Ensure there are N bits in get_buffer; if suspend, take action. | 141 * Ensure there are N bits in get_buffer; if suspend, take action. |
143 * val = GET_BITS(n); | 142 * val = GET_BITS(n); |
144 *» » Fetch next N bits. | 143 * Fetch next N bits. |
145 * val = PEEK_BITS(n); | 144 * val = PEEK_BITS(n); |
146 *» » Fetch next N bits without removing them from the buffer. | 145 * Fetch next N bits without removing them from the buffer. |
147 *» DROP_BITS(n); | 146 * DROP_BITS(n); |
148 *» » Discard next N bits. | 147 * Discard next N bits. |
149 * The value N should be a simple variable, not an expression, because it | 148 * The value N should be a simple variable, not an expression, because it |
150 * is evaluated multiple times. | 149 * is evaluated multiple times. |
151 */ | 150 */ |
152 | 151 |
153 #define CHECK_BIT_BUFFER(state,nbits,action) \ | 152 #define CHECK_BIT_BUFFER(state,nbits,action) \ |
154 » { if (bits_left < (nbits)) { \ | 153 { if (bits_left < (nbits)) { \ |
155 » if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) \ | 154 if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) \ |
156 » { action; } \ | 155 { action; } \ |
157 » get_buffer = (state).get_buffer; bits_left = (state).bits_left; } } | 156 get_buffer = (state).get_buffer; bits_left = (state).bits_left; } } |
158 | 157 |
159 #define GET_BITS(nbits) \ | 158 #define GET_BITS(nbits) \ |
160 » (((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1)) | 159 (((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1)) |
161 | 160 |
162 #define PEEK_BITS(nbits) \ | 161 #define PEEK_BITS(nbits) \ |
163 » (((int) (get_buffer >> (bits_left - (nbits)))) & ((1<<(nbits))-1)) | 162 (((int) (get_buffer >> (bits_left - (nbits)))) & ((1<<(nbits))-1)) |
164 | 163 |
165 #define DROP_BITS(nbits) \ | 164 #define DROP_BITS(nbits) \ |
166 » (bits_left -= (nbits)) | 165 (bits_left -= (nbits)) |
167 | 166 |
168 /* Load up the bit buffer to a depth of at least nbits */ | 167 /* Load up the bit buffer to a depth of at least nbits */ |
169 EXTERN(boolean) jpeg_fill_bit_buffer | 168 EXTERN(boolean) jpeg_fill_bit_buffer |
170 » JPP((bitread_working_state * state, register bit_buf_type get_buffer, | 169 (bitread_working_state *state, register bit_buf_type get_buffer, |
171 » register int bits_left, int nbits)); | 170 register int bits_left, int nbits); |
172 | 171 |
173 | 172 |
174 /* | 173 /* |
175 * Code for extracting next Huffman-coded symbol from input bit stream. | 174 * Code for extracting next Huffman-coded symbol from input bit stream. |
176 * Again, this is time-critical and we make the main paths be macros. | 175 * Again, this is time-critical and we make the main paths be macros. |
177 * | 176 * |
178 * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits | 177 * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits |
179 * without looping. Usually, more than 95% of the Huffman codes will be 8 | 178 * without looping. Usually, more than 95% of the Huffman codes will be 8 |
180 * or fewer bits long. The few overlength codes are handled with a loop, | 179 * or fewer bits long. The few overlength codes are handled with a loop, |
181 * which need not be inline code. | 180 * which need not be inline code. |
(...skipping 15 matching lines...) Expand all Loading... |
197 nb = 1; goto slowlabel; \ | 196 nb = 1; goto slowlabel; \ |
198 } \ | 197 } \ |
199 } \ | 198 } \ |
200 look = PEEK_BITS(HUFF_LOOKAHEAD); \ | 199 look = PEEK_BITS(HUFF_LOOKAHEAD); \ |
201 if ((nb = (htbl->lookup[look] >> HUFF_LOOKAHEAD)) <= HUFF_LOOKAHEAD) { \ | 200 if ((nb = (htbl->lookup[look] >> HUFF_LOOKAHEAD)) <= HUFF_LOOKAHEAD) { \ |
202 DROP_BITS(nb); \ | 201 DROP_BITS(nb); \ |
203 result = htbl->lookup[look] & ((1 << HUFF_LOOKAHEAD) - 1); \ | 202 result = htbl->lookup[look] & ((1 << HUFF_LOOKAHEAD) - 1); \ |
204 } else { \ | 203 } else { \ |
205 slowlabel: \ | 204 slowlabel: \ |
206 if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \ | 205 if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \ |
207 » { failaction; } \ | 206 { failaction; } \ |
208 get_buffer = state.get_buffer; bits_left = state.bits_left; \ | 207 get_buffer = state.get_buffer; bits_left = state.bits_left; \ |
209 } \ | 208 } \ |
210 } | 209 } |
211 | 210 |
212 #define HUFF_DECODE_FAST(s,nb,htbl,slowlabel) \ | 211 #define HUFF_DECODE_FAST(s,nb,htbl) \ |
213 FILL_BIT_BUFFER_FAST; \ | 212 FILL_BIT_BUFFER_FAST; \ |
214 s = PEEK_BITS(HUFF_LOOKAHEAD); \ | 213 s = PEEK_BITS(HUFF_LOOKAHEAD); \ |
215 s = htbl->lookup[s]; \ | 214 s = htbl->lookup[s]; \ |
216 nb = s >> HUFF_LOOKAHEAD; \ | 215 nb = s >> HUFF_LOOKAHEAD; \ |
217 /* Pre-execute the common case of nb <= HUFF_LOOKAHEAD */ \ | 216 /* Pre-execute the common case of nb <= HUFF_LOOKAHEAD */ \ |
218 DROP_BITS(nb); \ | 217 DROP_BITS(nb); \ |
219 s = s & ((1 << HUFF_LOOKAHEAD) - 1); \ | 218 s = s & ((1 << HUFF_LOOKAHEAD) - 1); \ |
220 if (nb > HUFF_LOOKAHEAD) { \ | 219 if (nb > HUFF_LOOKAHEAD) { \ |
221 /* Equivalent of jpeg_huff_decode() */ \ | 220 /* Equivalent of jpeg_huff_decode() */ \ |
222 /* Don't use GET_BITS() here because we don't want to modify bits_left */ \ | 221 /* Don't use GET_BITS() here because we don't want to modify bits_left */ \ |
223 s = (get_buffer >> bits_left) & ((1 << (nb)) - 1); \ | 222 s = (get_buffer >> bits_left) & ((1 << (nb)) - 1); \ |
224 while (s > htbl->maxcode[nb]) { \ | 223 while (s > htbl->maxcode[nb]) { \ |
225 s <<= 1; \ | 224 s <<= 1; \ |
226 s |= GET_BITS(1); \ | 225 s |= GET_BITS(1); \ |
227 nb++; \ | 226 nb++; \ |
228 } \ | 227 } \ |
229 if (nb > 16) \ | 228 s = htbl->pub->huffval[ (int) (s + htbl->valoffset[nb]) & 0xFF ]; \ |
230 goto slowlabel; \ | |
231 s = htbl->pub->huffval[ (int) (s + htbl->valoffset[nb]) ]; \ | |
232 } | 229 } |
233 | 230 |
234 /* Out-of-line case for Huffman code fetching */ | 231 /* Out-of-line case for Huffman code fetching */ |
235 EXTERN(int) jpeg_huff_decode | 232 EXTERN(int) jpeg_huff_decode |
236 » JPP((bitread_working_state * state, register bit_buf_type get_buffer, | 233 (bitread_working_state *state, register bit_buf_type get_buffer, |
237 » register int bits_left, d_derived_tbl * htbl, int min_bits)); | 234 register int bits_left, d_derived_tbl *htbl, int min_bits); |
OLD | NEW |