aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdarith.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdarith.c')
-rw-r--r--libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdarith.c1552
1 files changed, 776 insertions, 776 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdarith.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdarith.c
index 86a4ac7..092f8af 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdarith.c
+++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdarith.c
@@ -1,776 +1,776 @@
1/* 1/*
2 * jdarith.c 2 * jdarith.c
3 * 3 *
4 * Developed 1997-2011 by Guido Vollbeding. 4 * Developed 1997-2011 by Guido Vollbeding.
5 * This file is part of the Independent JPEG Group's software. 5 * This file is part of the Independent JPEG Group's software.
6 * For conditions of distribution and use, see the accompanying README file. 6 * For conditions of distribution and use, see the accompanying README file.
7 * 7 *
8 * This file contains portable arithmetic entropy decoding routines for JPEG 8 * This file contains portable arithmetic entropy decoding routines for JPEG
9 * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81). 9 * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81).
10 * 10 *
11 * Both sequential and progressive modes are supported in this single module. 11 * Both sequential and progressive modes are supported in this single module.
12 * 12 *
13 * Suspension is not currently supported in this module. 13 * Suspension is not currently supported in this module.
14 */ 14 */
15 15
16#define JPEG_INTERNALS 16#define JPEG_INTERNALS
17#include "jinclude.h" 17#include "jinclude.h"
18#include "jpeglib.h" 18#include "jpeglib.h"
19 19
20 20
21/* Expanded entropy decoder object for arithmetic decoding. */ 21/* Expanded entropy decoder object for arithmetic decoding. */
22 22
23typedef struct { 23typedef struct {
24 struct jpeg_entropy_decoder pub; /* public fields */ 24 struct jpeg_entropy_decoder pub; /* public fields */
25 25
26 INT32 c; /* C register, base of coding interval + input bit buffer */ 26 INT32 c; /* C register, base of coding interval + input bit buffer */
27 INT32 a; /* A register, normalized size of coding interval */ 27 INT32 a; /* A register, normalized size of coding interval */
28 int ct; /* bit shift counter, # of bits left in bit buffer part of C */ 28 int ct; /* bit shift counter, # of bits left in bit buffer part of C */
29 /* init: ct = -16 */ 29 /* init: ct = -16 */
30 /* run: ct = 0..7 */ 30 /* run: ct = 0..7 */
31 /* error: ct = -1 */ 31 /* error: ct = -1 */
32 int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ 32 int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
33 int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */ 33 int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
34 34
35 unsigned int restarts_to_go; /* MCUs left in this restart interval */ 35 unsigned int restarts_to_go; /* MCUs left in this restart interval */
36 36
37 /* Pointers to statistics areas (these workspaces have image lifespan) */ 37 /* Pointers to statistics areas (these workspaces have image lifespan) */
38 unsigned char * dc_stats[NUM_ARITH_TBLS]; 38 unsigned char * dc_stats[NUM_ARITH_TBLS];
39 unsigned char * ac_stats[NUM_ARITH_TBLS]; 39 unsigned char * ac_stats[NUM_ARITH_TBLS];
40 40
41 /* Statistics bin for coding with fixed probability 0.5 */ 41 /* Statistics bin for coding with fixed probability 0.5 */
42 unsigned char fixed_bin[4]; 42 unsigned char fixed_bin[4];
43} arith_entropy_decoder; 43} arith_entropy_decoder;
44 44
45typedef arith_entropy_decoder * arith_entropy_ptr; 45typedef arith_entropy_decoder * arith_entropy_ptr;
46 46
47/* The following two definitions specify the allocation chunk size 47/* The following two definitions specify the allocation chunk size
48 * for the statistics area. 48 * for the statistics area.
49 * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least 49 * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
50 * 49 statistics bins for DC, and 245 statistics bins for AC coding. 50 * 49 statistics bins for DC, and 245 statistics bins for AC coding.
51 * 51 *
52 * We use a compact representation with 1 byte per statistics bin, 52 * We use a compact representation with 1 byte per statistics bin,
53 * thus the numbers directly represent byte sizes. 53 * thus the numbers directly represent byte sizes.
54 * This 1 byte per statistics bin contains the meaning of the MPS 54 * This 1 byte per statistics bin contains the meaning of the MPS
55 * (more probable symbol) in the highest bit (mask 0x80), and the 55 * (more probable symbol) in the highest bit (mask 0x80), and the
56 * index into the probability estimation state machine table 56 * index into the probability estimation state machine table
57 * in the lower bits (mask 0x7F). 57 * in the lower bits (mask 0x7F).
58 */ 58 */
59 59
60#define DC_STAT_BINS 64 60#define DC_STAT_BINS 64
61#define AC_STAT_BINS 256 61#define AC_STAT_BINS 256
62 62
63 63
64LOCAL(int) 64LOCAL(int)
65get_byte (j_decompress_ptr cinfo) 65get_byte (j_decompress_ptr cinfo)
66/* Read next input byte; we do not support suspension in this module. */ 66/* Read next input byte; we do not support suspension in this module. */
67{ 67{
68 struct jpeg_source_mgr * src = cinfo->src; 68 struct jpeg_source_mgr * src = cinfo->src;
69 69
70 if (src->bytes_in_buffer == 0) 70 if (src->bytes_in_buffer == 0)
71 if (! (*src->fill_input_buffer) (cinfo)) 71 if (! (*src->fill_input_buffer) (cinfo))
72 ERREXIT(cinfo, JERR_CANT_SUSPEND); 72 ERREXIT(cinfo, JERR_CANT_SUSPEND);
73 src->bytes_in_buffer--; 73 src->bytes_in_buffer--;
74 return GETJOCTET(*src->next_input_byte++); 74 return GETJOCTET(*src->next_input_byte++);
75} 75}
76 76
77 77
78/* 78/*
79 * The core arithmetic decoding routine (common in JPEG and JBIG). 79 * The core arithmetic decoding routine (common in JPEG and JBIG).
80 * This needs to go as fast as possible. 80 * This needs to go as fast as possible.
81 * Machine-dependent optimization facilities 81 * Machine-dependent optimization facilities
82 * are not utilized in this portable implementation. 82 * are not utilized in this portable implementation.
83 * However, this code should be fairly efficient and 83 * However, this code should be fairly efficient and
84 * may be a good base for further optimizations anyway. 84 * may be a good base for further optimizations anyway.
85 * 85 *
86 * Return value is 0 or 1 (binary decision). 86 * Return value is 0 or 1 (binary decision).
87 * 87 *
88 * Note: I've changed the handling of the code base & bit 88 * Note: I've changed the handling of the code base & bit
89 * buffer register C compared to other implementations 89 * buffer register C compared to other implementations
90 * based on the standards layout & procedures. 90 * based on the standards layout & procedures.
91 * While it also contains both the actual base of the 91 * While it also contains both the actual base of the
92 * coding interval (16 bits) and the next-bits buffer, 92 * coding interval (16 bits) and the next-bits buffer,
93 * the cut-point between these two parts is floating 93 * the cut-point between these two parts is floating
94 * (instead of fixed) with the bit shift counter CT. 94 * (instead of fixed) with the bit shift counter CT.
95 * Thus, we also need only one (variable instead of 95 * Thus, we also need only one (variable instead of
96 * fixed size) shift for the LPS/MPS decision, and 96 * fixed size) shift for the LPS/MPS decision, and
97 * we can get away with any renormalization update 97 * we can get away with any renormalization update
98 * of C (except for new data insertion, of course). 98 * of C (except for new data insertion, of course).
99 * 99 *
100 * I've also introduced a new scheme for accessing 100 * I've also introduced a new scheme for accessing
101 * the probability estimation state machine table, 101 * the probability estimation state machine table,
102 * derived from Markus Kuhn's JBIG implementation. 102 * derived from Markus Kuhn's JBIG implementation.
103 */ 103 */
104 104
105LOCAL(int) 105LOCAL(int)
106arith_decode (j_decompress_ptr cinfo, unsigned char *st) 106arith_decode (j_decompress_ptr cinfo, unsigned char *st)
107{ 107{
108 register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy; 108 register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
109 register unsigned char nl, nm; 109 register unsigned char nl, nm;
110 register INT32 qe, temp; 110 register INT32 qe, temp;
111 register int sv, data; 111 register int sv, data;
112 112
113 /* Renormalization & data input per section D.2.6 */ 113 /* Renormalization & data input per section D.2.6 */
114 while (e->a < 0x8000L) { 114 while (e->a < 0x8000L) {
115 if (--e->ct < 0) { 115 if (--e->ct < 0) {
116 /* Need to fetch next data byte */ 116 /* Need to fetch next data byte */
117 if (cinfo->unread_marker) 117 if (cinfo->unread_marker)
118 data = 0; /* stuff zero data */ 118 data = 0; /* stuff zero data */
119 else { 119 else {
120 data = get_byte(cinfo); /* read next input byte */ 120 data = get_byte(cinfo); /* read next input byte */
121 if (data == 0xFF) { /* zero stuff or marker code */ 121 if (data == 0xFF) { /* zero stuff or marker code */
122 do data = get_byte(cinfo); 122 do data = get_byte(cinfo);
123 while (data == 0xFF); /* swallow extra 0xFF bytes */ 123 while (data == 0xFF); /* swallow extra 0xFF bytes */
124 if (data == 0) 124 if (data == 0)
125 data = 0xFF; /* discard stuffed zero byte */ 125 data = 0xFF; /* discard stuffed zero byte */
126 else { 126 else {
127 /* Note: Different from the Huffman decoder, hitting 127 /* Note: Different from the Huffman decoder, hitting
128 * a marker while processing the compressed data 128 * a marker while processing the compressed data
129 * segment is legal in arithmetic coding. 129 * segment is legal in arithmetic coding.
130 * The convention is to supply zero data 130 * The convention is to supply zero data
131 * then until decoding is complete. 131 * then until decoding is complete.
132 */ 132 */
133 cinfo->unread_marker = data; 133 cinfo->unread_marker = data;
134 data = 0; 134 data = 0;
135 } 135 }
136 } 136 }
137 } 137 }
138 e->c = (e->c << 8) | data; /* insert data into C register */ 138 e->c = (e->c << 8) | data; /* insert data into C register */
139 if ((e->ct += 8) < 0) /* update bit shift counter */ 139 if ((e->ct += 8) < 0) /* update bit shift counter */
140 /* Need more initial bytes */ 140 /* Need more initial bytes */
141 if (++e->ct == 0) 141 if (++e->ct == 0)
142 /* Got 2 initial bytes -> re-init A and exit loop */ 142 /* Got 2 initial bytes -> re-init A and exit loop */
143 e->a = 0x8000L; /* => e->a = 0x10000L after loop exit */ 143 e->a = 0x8000L; /* => e->a = 0x10000L after loop exit */
144 } 144 }
145 e->a <<= 1; 145 e->a <<= 1;
146 } 146 }
147 147
148 /* Fetch values from our compact representation of Table D.3(D.2): 148 /* Fetch values from our compact representation of Table D.3(D.2):
149 * Qe values and probability estimation state machine 149 * Qe values and probability estimation state machine
150 */ 150 */
151 sv = *st; 151 sv = *st;
152 qe = jpeg_aritab[sv & 0x7F]; /* => Qe_Value */ 152 qe = jpeg_aritab[sv & 0x7F]; /* => Qe_Value */
153 nl = qe & 0xFF; qe >>= 8; /* Next_Index_LPS + Switch_MPS */ 153 nl = qe & 0xFF; qe >>= 8; /* Next_Index_LPS + Switch_MPS */
154 nm = qe & 0xFF; qe >>= 8; /* Next_Index_MPS */ 154 nm = qe & 0xFF; qe >>= 8; /* Next_Index_MPS */
155 155
156 /* Decode & estimation procedures per sections D.2.4 & D.2.5 */ 156 /* Decode & estimation procedures per sections D.2.4 & D.2.5 */
157 temp = e->a - qe; 157 temp = e->a - qe;
158 e->a = temp; 158 e->a = temp;
159 temp <<= e->ct; 159 temp <<= e->ct;
160 if (e->c >= temp) { 160 if (e->c >= temp) {
161 e->c -= temp; 161 e->c -= temp;
162 /* Conditional LPS (less probable symbol) exchange */ 162 /* Conditional LPS (less probable symbol) exchange */
163 if (e->a < qe) { 163 if (e->a < qe) {
164 e->a = qe; 164 e->a = qe;
165 *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */ 165 *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */
166 } else { 166 } else {
167 e->a = qe; 167 e->a = qe;
168 *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */ 168 *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */
169 sv ^= 0x80; /* Exchange LPS/MPS */ 169 sv ^= 0x80; /* Exchange LPS/MPS */
170 } 170 }
171 } else if (e->a < 0x8000L) { 171 } else if (e->a < 0x8000L) {
172 /* Conditional MPS (more probable symbol) exchange */ 172 /* Conditional MPS (more probable symbol) exchange */
173 if (e->a < qe) { 173 if (e->a < qe) {
174 *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */ 174 *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */
175 sv ^= 0x80; /* Exchange LPS/MPS */ 175 sv ^= 0x80; /* Exchange LPS/MPS */
176 } else { 176 } else {
177 *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */ 177 *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */
178 } 178 }
179 } 179 }
180 180
181 return sv >> 7; 181 return sv >> 7;
182} 182}
183 183
184 184
185/* 185/*
186 * Check for a restart marker & resynchronize decoder. 186 * Check for a restart marker & resynchronize decoder.
187 */ 187 */
188 188
189LOCAL(void) 189LOCAL(void)
190process_restart (j_decompress_ptr cinfo) 190process_restart (j_decompress_ptr cinfo)
191{ 191{
192 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 192 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
193 int ci; 193 int ci;
194 jpeg_component_info * compptr; 194 jpeg_component_info * compptr;
195 195
196 /* Advance past the RSTn marker */ 196 /* Advance past the RSTn marker */
197 if (! (*cinfo->marker->read_restart_marker) (cinfo)) 197 if (! (*cinfo->marker->read_restart_marker) (cinfo))
198 ERREXIT(cinfo, JERR_CANT_SUSPEND); 198 ERREXIT(cinfo, JERR_CANT_SUSPEND);
199 199
200 /* Re-initialize statistics areas */ 200 /* Re-initialize statistics areas */
201 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 201 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
202 compptr = cinfo->cur_comp_info[ci]; 202 compptr = cinfo->cur_comp_info[ci];
203 if (! cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) { 203 if (! cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
204 MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS); 204 MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS);
205 /* Reset DC predictions to 0 */ 205 /* Reset DC predictions to 0 */
206 entropy->last_dc_val[ci] = 0; 206 entropy->last_dc_val[ci] = 0;
207 entropy->dc_context[ci] = 0; 207 entropy->dc_context[ci] = 0;
208 } 208 }
209 if ((! cinfo->progressive_mode && cinfo->lim_Se) || 209 if ((! cinfo->progressive_mode && cinfo->lim_Se) ||
210 (cinfo->progressive_mode && cinfo->Ss)) { 210 (cinfo->progressive_mode && cinfo->Ss)) {
211 MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS); 211 MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS);
212 } 212 }
213 } 213 }
214 214
215 /* Reset arithmetic decoding variables */ 215 /* Reset arithmetic decoding variables */
216 entropy->c = 0; 216 entropy->c = 0;
217 entropy->a = 0; 217 entropy->a = 0;
218 entropy->ct = -16; /* force reading 2 initial bytes to fill C */ 218 entropy->ct = -16; /* force reading 2 initial bytes to fill C */
219 219
220 /* Reset restart counter */ 220 /* Reset restart counter */
221 entropy->restarts_to_go = cinfo->restart_interval; 221 entropy->restarts_to_go = cinfo->restart_interval;
222} 222}
223 223
224 224
225/* 225/*
226 * Arithmetic MCU decoding. 226 * Arithmetic MCU decoding.
227 * Each of these routines decodes and returns one MCU's worth of 227 * Each of these routines decodes and returns one MCU's worth of
228 * arithmetic-compressed coefficients. 228 * arithmetic-compressed coefficients.
229 * The coefficients are reordered from zigzag order into natural array order, 229 * The coefficients are reordered from zigzag order into natural array order,
230 * but are not dequantized. 230 * but are not dequantized.
231 * 231 *
232 * The i'th block of the MCU is stored into the block pointed to by 232 * The i'th block of the MCU is stored into the block pointed to by
233 * MCU_data[i]. WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER. 233 * MCU_data[i]. WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
234 */ 234 */
235 235
236/* 236/*
237 * MCU decoding for DC initial scan (either spectral selection, 237 * MCU decoding for DC initial scan (either spectral selection,
238 * or first pass of successive approximation). 238 * or first pass of successive approximation).
239 */ 239 */
240 240
241METHODDEF(boolean) 241METHODDEF(boolean)
242decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) 242decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
243{ 243{
244 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 244 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
245 JBLOCKROW block; 245 JBLOCKROW block;
246 unsigned char *st; 246 unsigned char *st;
247 int blkn, ci, tbl, sign; 247 int blkn, ci, tbl, sign;
248 int v, m; 248 int v, m;
249 249
250 /* Process restart marker if needed */ 250 /* Process restart marker if needed */
251 if (cinfo->restart_interval) { 251 if (cinfo->restart_interval) {
252 if (entropy->restarts_to_go == 0) 252 if (entropy->restarts_to_go == 0)
253 process_restart(cinfo); 253 process_restart(cinfo);
254 entropy->restarts_to_go--; 254 entropy->restarts_to_go--;
255 } 255 }
256 256
257 if (entropy->ct == -1) return TRUE; /* if error do nothing */ 257 if (entropy->ct == -1) return TRUE; /* if error do nothing */
258 258
259 /* Outer loop handles each block in the MCU */ 259 /* Outer loop handles each block in the MCU */
260 260
261 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { 261 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
262 block = MCU_data[blkn]; 262 block = MCU_data[blkn];
263 ci = cinfo->MCU_membership[blkn]; 263 ci = cinfo->MCU_membership[blkn];
264 tbl = cinfo->cur_comp_info[ci]->dc_tbl_no; 264 tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
265 265
266 /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */ 266 /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
267 267
268 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ 268 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
269 st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; 269 st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
270 270
271 /* Figure F.19: Decode_DC_DIFF */ 271 /* Figure F.19: Decode_DC_DIFF */
272 if (arith_decode(cinfo, st) == 0) 272 if (arith_decode(cinfo, st) == 0)
273 entropy->dc_context[ci] = 0; 273 entropy->dc_context[ci] = 0;
274 else { 274 else {
275 /* Figure F.21: Decoding nonzero value v */ 275 /* Figure F.21: Decoding nonzero value v */
276 /* Figure F.22: Decoding the sign of v */ 276 /* Figure F.22: Decoding the sign of v */
277 sign = arith_decode(cinfo, st + 1); 277 sign = arith_decode(cinfo, st + 1);
278 st += 2; st += sign; 278 st += 2; st += sign;
279 /* Figure F.23: Decoding the magnitude category of v */ 279 /* Figure F.23: Decoding the magnitude category of v */
280 if ((m = arith_decode(cinfo, st)) != 0) { 280 if ((m = arith_decode(cinfo, st)) != 0) {
281 st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ 281 st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
282 while (arith_decode(cinfo, st)) { 282 while (arith_decode(cinfo, st)) {
283 if ((m <<= 1) == 0x8000) { 283 if ((m <<= 1) == 0x8000) {
284 WARNMS(cinfo, JWRN_ARITH_BAD_CODE); 284 WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
285 entropy->ct = -1; /* magnitude overflow */ 285 entropy->ct = -1; /* magnitude overflow */
286 return TRUE; 286 return TRUE;
287 } 287 }
288 st += 1; 288 st += 1;
289 } 289 }
290 } 290 }
291 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ 291 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
292 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) 292 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
293 entropy->dc_context[ci] = 0; /* zero diff category */ 293 entropy->dc_context[ci] = 0; /* zero diff category */
294 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) 294 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
295 entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */ 295 entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
296 else 296 else
297 entropy->dc_context[ci] = 4 + (sign * 4); /* small diff category */ 297 entropy->dc_context[ci] = 4 + (sign * 4); /* small diff category */
298 v = m; 298 v = m;
299 /* Figure F.24: Decoding the magnitude bit pattern of v */ 299 /* Figure F.24: Decoding the magnitude bit pattern of v */
300 st += 14; 300 st += 14;
301 while (m >>= 1) 301 while (m >>= 1)
302 if (arith_decode(cinfo, st)) v |= m; 302 if (arith_decode(cinfo, st)) v |= m;
303 v += 1; if (sign) v = -v; 303 v += 1; if (sign) v = -v;
304 entropy->last_dc_val[ci] += v; 304 entropy->last_dc_val[ci] += v;
305 } 305 }
306 306
307 /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */ 307 /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
308 (*block)[0] = (JCOEF) (entropy->last_dc_val[ci] << cinfo->Al); 308 (*block)[0] = (JCOEF) (entropy->last_dc_val[ci] << cinfo->Al);
309 } 309 }
310 310
311 return TRUE; 311 return TRUE;
312} 312}
313 313
314 314
315/* 315/*
316 * MCU decoding for AC initial scan (either spectral selection, 316 * MCU decoding for AC initial scan (either spectral selection,
317 * or first pass of successive approximation). 317 * or first pass of successive approximation).
318 */ 318 */
319 319
320METHODDEF(boolean) 320METHODDEF(boolean)
321decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) 321decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
322{ 322{
323 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 323 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
324 JBLOCKROW block; 324 JBLOCKROW block;
325 unsigned char *st; 325 unsigned char *st;
326 int tbl, sign, k; 326 int tbl, sign, k;
327 int v, m; 327 int v, m;
328 const int * natural_order; 328 const int * natural_order;
329 329
330 /* Process restart marker if needed */ 330 /* Process restart marker if needed */
331 if (cinfo->restart_interval) { 331 if (cinfo->restart_interval) {
332 if (entropy->restarts_to_go == 0) 332 if (entropy->restarts_to_go == 0)
333 process_restart(cinfo); 333 process_restart(cinfo);
334 entropy->restarts_to_go--; 334 entropy->restarts_to_go--;
335 } 335 }
336 336
337 if (entropy->ct == -1) return TRUE; /* if error do nothing */ 337 if (entropy->ct == -1) return TRUE; /* if error do nothing */
338 338
339 natural_order = cinfo->natural_order; 339 natural_order = cinfo->natural_order;
340 340
341 /* There is always only one block per MCU */ 341 /* There is always only one block per MCU */
342 block = MCU_data[0]; 342 block = MCU_data[0];
343 tbl = cinfo->cur_comp_info[0]->ac_tbl_no; 343 tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
344 344
345 /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */ 345 /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
346 346
347 /* Figure F.20: Decode_AC_coefficients */ 347 /* Figure F.20: Decode_AC_coefficients */
348 for (k = cinfo->Ss; k <= cinfo->Se; k++) { 348 for (k = cinfo->Ss; k <= cinfo->Se; k++) {
349 st = entropy->ac_stats[tbl] + 3 * (k - 1); 349 st = entropy->ac_stats[tbl] + 3 * (k - 1);
350 if (arith_decode(cinfo, st)) break; /* EOB flag */ 350 if (arith_decode(cinfo, st)) break; /* EOB flag */
351 while (arith_decode(cinfo, st + 1) == 0) { 351 while (arith_decode(cinfo, st + 1) == 0) {
352 st += 3; k++; 352 st += 3; k++;
353 if (k > cinfo->Se) { 353 if (k > cinfo->Se) {
354 WARNMS(cinfo, JWRN_ARITH_BAD_CODE); 354 WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
355 entropy->ct = -1; /* spectral overflow */ 355 entropy->ct = -1; /* spectral overflow */
356 return TRUE; 356 return TRUE;
357 } 357 }
358 } 358 }
359 /* Figure F.21: Decoding nonzero value v */ 359 /* Figure F.21: Decoding nonzero value v */
360 /* Figure F.22: Decoding the sign of v */ 360 /* Figure F.22: Decoding the sign of v */
361 sign = arith_decode(cinfo, entropy->fixed_bin); 361 sign = arith_decode(cinfo, entropy->fixed_bin);
362 st += 2; 362 st += 2;
363 /* Figure F.23: Decoding the magnitude category of v */ 363 /* Figure F.23: Decoding the magnitude category of v */
364 if ((m = arith_decode(cinfo, st)) != 0) { 364 if ((m = arith_decode(cinfo, st)) != 0) {
365 if (arith_decode(cinfo, st)) { 365 if (arith_decode(cinfo, st)) {
366 m <<= 1; 366 m <<= 1;
367 st = entropy->ac_stats[tbl] + 367 st = entropy->ac_stats[tbl] +
368 (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); 368 (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
369 while (arith_decode(cinfo, st)) { 369 while (arith_decode(cinfo, st)) {
370 if ((m <<= 1) == 0x8000) { 370 if ((m <<= 1) == 0x8000) {
371 WARNMS(cinfo, JWRN_ARITH_BAD_CODE); 371 WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
372 entropy->ct = -1; /* magnitude overflow */ 372 entropy->ct = -1; /* magnitude overflow */
373 return TRUE; 373 return TRUE;
374 } 374 }
375 st += 1; 375 st += 1;
376 } 376 }
377 } 377 }
378 } 378 }
379 v = m; 379 v = m;
380 /* Figure F.24: Decoding the magnitude bit pattern of v */ 380 /* Figure F.24: Decoding the magnitude bit pattern of v */
381 st += 14; 381 st += 14;
382 while (m >>= 1) 382 while (m >>= 1)
383 if (arith_decode(cinfo, st)) v |= m; 383 if (arith_decode(cinfo, st)) v |= m;
384 v += 1; if (sign) v = -v; 384 v += 1; if (sign) v = -v;
385 /* Scale and output coefficient in natural (dezigzagged) order */ 385 /* Scale and output coefficient in natural (dezigzagged) order */
386 (*block)[natural_order[k]] = (JCOEF) (v << cinfo->Al); 386 (*block)[natural_order[k]] = (JCOEF) (v << cinfo->Al);
387 } 387 }
388 388
389 return TRUE; 389 return TRUE;
390} 390}
391 391
392 392
393/* 393/*
394 * MCU decoding for DC successive approximation refinement scan. 394 * MCU decoding for DC successive approximation refinement scan.
395 */ 395 */
396 396
397METHODDEF(boolean) 397METHODDEF(boolean)
398decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) 398decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
399{ 399{
400 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 400 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
401 unsigned char *st; 401 unsigned char *st;
402 int p1, blkn; 402 int p1, blkn;
403 403
404 /* Process restart marker if needed */ 404 /* Process restart marker if needed */
405 if (cinfo->restart_interval) { 405 if (cinfo->restart_interval) {
406 if (entropy->restarts_to_go == 0) 406 if (entropy->restarts_to_go == 0)
407 process_restart(cinfo); 407 process_restart(cinfo);
408 entropy->restarts_to_go--; 408 entropy->restarts_to_go--;
409 } 409 }
410 410
411 st = entropy->fixed_bin; /* use fixed probability estimation */ 411 st = entropy->fixed_bin; /* use fixed probability estimation */
412 p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */ 412 p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
413 413
414 /* Outer loop handles each block in the MCU */ 414 /* Outer loop handles each block in the MCU */
415 415
416 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { 416 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
417 /* Encoded data is simply the next bit of the two's-complement DC value */ 417 /* Encoded data is simply the next bit of the two's-complement DC value */
418 if (arith_decode(cinfo, st)) 418 if (arith_decode(cinfo, st))
419 MCU_data[blkn][0][0] |= p1; 419 MCU_data[blkn][0][0] |= p1;
420 } 420 }
421 421
422 return TRUE; 422 return TRUE;
423} 423}
424 424
425 425
426/* 426/*
427 * MCU decoding for AC successive approximation refinement scan. 427 * MCU decoding for AC successive approximation refinement scan.
428 */ 428 */
429 429
430METHODDEF(boolean) 430METHODDEF(boolean)
431decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) 431decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
432{ 432{
433 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 433 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
434 JBLOCKROW block; 434 JBLOCKROW block;
435 JCOEFPTR thiscoef; 435 JCOEFPTR thiscoef;
436 unsigned char *st; 436 unsigned char *st;
437 int tbl, k, kex; 437 int tbl, k, kex;
438 int p1, m1; 438 int p1, m1;
439 const int * natural_order; 439 const int * natural_order;
440 440
441 /* Process restart marker if needed */ 441 /* Process restart marker if needed */
442 if (cinfo->restart_interval) { 442 if (cinfo->restart_interval) {
443 if (entropy->restarts_to_go == 0) 443 if (entropy->restarts_to_go == 0)
444 process_restart(cinfo); 444 process_restart(cinfo);
445 entropy->restarts_to_go--; 445 entropy->restarts_to_go--;
446 } 446 }
447 447
448 if (entropy->ct == -1) return TRUE; /* if error do nothing */ 448 if (entropy->ct == -1) return TRUE; /* if error do nothing */
449 449
450 natural_order = cinfo->natural_order; 450 natural_order = cinfo->natural_order;
451 451
452 /* There is always only one block per MCU */ 452 /* There is always only one block per MCU */
453 block = MCU_data[0]; 453 block = MCU_data[0];
454 tbl = cinfo->cur_comp_info[0]->ac_tbl_no; 454 tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
455 455
456 p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */ 456 p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
457 m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */ 457 m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */
458 458
459 /* Establish EOBx (previous stage end-of-block) index */ 459 /* Establish EOBx (previous stage end-of-block) index */
460 for (kex = cinfo->Se; kex > 0; kex--) 460 for (kex = cinfo->Se; kex > 0; kex--)
461 if ((*block)[natural_order[kex]]) break; 461 if ((*block)[natural_order[kex]]) break;
462 462
463 for (k = cinfo->Ss; k <= cinfo->Se; k++) { 463 for (k = cinfo->Ss; k <= cinfo->Se; k++) {
464 st = entropy->ac_stats[tbl] + 3 * (k - 1); 464 st = entropy->ac_stats[tbl] + 3 * (k - 1);
465 if (k > kex) 465 if (k > kex)
466 if (arith_decode(cinfo, st)) break; /* EOB flag */ 466 if (arith_decode(cinfo, st)) break; /* EOB flag */
467 for (;;) { 467 for (;;) {
468 thiscoef = *block + natural_order[k]; 468 thiscoef = *block + natural_order[k];
469 if (*thiscoef) { /* previously nonzero coef */ 469 if (*thiscoef) { /* previously nonzero coef */
470 if (arith_decode(cinfo, st + 2)) { 470 if (arith_decode(cinfo, st + 2)) {
471 if (*thiscoef < 0) 471 if (*thiscoef < 0)
472 *thiscoef += m1; 472 *thiscoef += m1;
473 else 473 else
474 *thiscoef += p1; 474 *thiscoef += p1;
475 } 475 }
476 break; 476 break;
477 } 477 }
478 if (arith_decode(cinfo, st + 1)) { /* newly nonzero coef */ 478 if (arith_decode(cinfo, st + 1)) { /* newly nonzero coef */
479 if (arith_decode(cinfo, entropy->fixed_bin)) 479 if (arith_decode(cinfo, entropy->fixed_bin))
480 *thiscoef = m1; 480 *thiscoef = m1;
481 else 481 else
482 *thiscoef = p1; 482 *thiscoef = p1;
483 break; 483 break;
484 } 484 }
485 st += 3; k++; 485 st += 3; k++;
486 if (k > cinfo->Se) { 486 if (k > cinfo->Se) {
487 WARNMS(cinfo, JWRN_ARITH_BAD_CODE); 487 WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
488 entropy->ct = -1; /* spectral overflow */ 488 entropy->ct = -1; /* spectral overflow */
489 return TRUE; 489 return TRUE;
490 } 490 }
491 } 491 }
492 } 492 }
493 493
494 return TRUE; 494 return TRUE;
495} 495}
496 496
497 497
498/* 498/*
499 * Decode one MCU's worth of arithmetic-compressed coefficients. 499 * Decode one MCU's worth of arithmetic-compressed coefficients.
500 */ 500 */
501 501
502METHODDEF(boolean) 502METHODDEF(boolean)
503decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) 503decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
504{ 504{
505 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 505 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
506 jpeg_component_info * compptr; 506 jpeg_component_info * compptr;
507 JBLOCKROW block; 507 JBLOCKROW block;
508 unsigned char *st; 508 unsigned char *st;
509 int blkn, ci, tbl, sign, k; 509 int blkn, ci, tbl, sign, k;
510 int v, m; 510 int v, m;
511 const int * natural_order; 511 const int * natural_order;
512 512
513 /* Process restart marker if needed */ 513 /* Process restart marker if needed */
514 if (cinfo->restart_interval) { 514 if (cinfo->restart_interval) {
515 if (entropy->restarts_to_go == 0) 515 if (entropy->restarts_to_go == 0)
516 process_restart(cinfo); 516 process_restart(cinfo);
517 entropy->restarts_to_go--; 517 entropy->restarts_to_go--;
518 } 518 }
519 519
520 if (entropy->ct == -1) return TRUE; /* if error do nothing */ 520 if (entropy->ct == -1) return TRUE; /* if error do nothing */
521 521
522 natural_order = cinfo->natural_order; 522 natural_order = cinfo->natural_order;
523 523
524 /* Outer loop handles each block in the MCU */ 524 /* Outer loop handles each block in the MCU */
525 525
526 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { 526 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
527 block = MCU_data[blkn]; 527 block = MCU_data[blkn];
528 ci = cinfo->MCU_membership[blkn]; 528 ci = cinfo->MCU_membership[blkn];
529 compptr = cinfo->cur_comp_info[ci]; 529 compptr = cinfo->cur_comp_info[ci];
530 530
531 /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */ 531 /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
532 532
533 tbl = compptr->dc_tbl_no; 533 tbl = compptr->dc_tbl_no;
534 534
535 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ 535 /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
536 st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; 536 st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
537 537
538 /* Figure F.19: Decode_DC_DIFF */ 538 /* Figure F.19: Decode_DC_DIFF */
539 if (arith_decode(cinfo, st) == 0) 539 if (arith_decode(cinfo, st) == 0)
540 entropy->dc_context[ci] = 0; 540 entropy->dc_context[ci] = 0;
541 else { 541 else {
542 /* Figure F.21: Decoding nonzero value v */ 542 /* Figure F.21: Decoding nonzero value v */
543 /* Figure F.22: Decoding the sign of v */ 543 /* Figure F.22: Decoding the sign of v */
544 sign = arith_decode(cinfo, st + 1); 544 sign = arith_decode(cinfo, st + 1);
545 st += 2; st += sign; 545 st += 2; st += sign;
546 /* Figure F.23: Decoding the magnitude category of v */ 546 /* Figure F.23: Decoding the magnitude category of v */
547 if ((m = arith_decode(cinfo, st)) != 0) { 547 if ((m = arith_decode(cinfo, st)) != 0) {
548 st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ 548 st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
549 while (arith_decode(cinfo, st)) { 549 while (arith_decode(cinfo, st)) {
550 if ((m <<= 1) == 0x8000) { 550 if ((m <<= 1) == 0x8000) {
551 WARNMS(cinfo, JWRN_ARITH_BAD_CODE); 551 WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
552 entropy->ct = -1; /* magnitude overflow */ 552 entropy->ct = -1; /* magnitude overflow */
553 return TRUE; 553 return TRUE;
554 } 554 }
555 st += 1; 555 st += 1;
556 } 556 }
557 } 557 }
558 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ 558 /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
559 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1)) 559 if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
560 entropy->dc_context[ci] = 0; /* zero diff category */ 560 entropy->dc_context[ci] = 0; /* zero diff category */
561 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1)) 561 else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
562 entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */ 562 entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
563 else 563 else
564 entropy->dc_context[ci] = 4 + (sign * 4); /* small diff category */ 564 entropy->dc_context[ci] = 4 + (sign * 4); /* small diff category */
565 v = m; 565 v = m;
566 /* Figure F.24: Decoding the magnitude bit pattern of v */ 566 /* Figure F.24: Decoding the magnitude bit pattern of v */
567 st += 14; 567 st += 14;
568 while (m >>= 1) 568 while (m >>= 1)
569 if (arith_decode(cinfo, st)) v |= m; 569 if (arith_decode(cinfo, st)) v |= m;
570 v += 1; if (sign) v = -v; 570 v += 1; if (sign) v = -v;
571 entropy->last_dc_val[ci] += v; 571 entropy->last_dc_val[ci] += v;
572 } 572 }
573 573
574 (*block)[0] = (JCOEF) entropy->last_dc_val[ci]; 574 (*block)[0] = (JCOEF) entropy->last_dc_val[ci];
575 575
576 /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */ 576 /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
577 577
578 if (cinfo->lim_Se == 0) continue; 578 if (cinfo->lim_Se == 0) continue;
579 tbl = compptr->ac_tbl_no; 579 tbl = compptr->ac_tbl_no;
580 k = 0; 580 k = 0;
581 581
582 /* Figure F.20: Decode_AC_coefficients */ 582 /* Figure F.20: Decode_AC_coefficients */
583 do { 583 do {
584 st = entropy->ac_stats[tbl] + 3 * k; 584 st = entropy->ac_stats[tbl] + 3 * k;
585 if (arith_decode(cinfo, st)) break; /* EOB flag */ 585 if (arith_decode(cinfo, st)) break; /* EOB flag */
586 for (;;) { 586 for (;;) {
587 k++; 587 k++;
588 if (arith_decode(cinfo, st + 1)) break; 588 if (arith_decode(cinfo, st + 1)) break;
589 st += 3; 589 st += 3;
590 if (k >= cinfo->lim_Se) { 590 if (k >= cinfo->lim_Se) {
591 WARNMS(cinfo, JWRN_ARITH_BAD_CODE); 591 WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
592 entropy->ct = -1; /* spectral overflow */ 592 entropy->ct = -1; /* spectral overflow */
593 return TRUE; 593 return TRUE;
594 } 594 }
595 } 595 }
596 /* Figure F.21: Decoding nonzero value v */ 596 /* Figure F.21: Decoding nonzero value v */
597 /* Figure F.22: Decoding the sign of v */ 597 /* Figure F.22: Decoding the sign of v */
598 sign = arith_decode(cinfo, entropy->fixed_bin); 598 sign = arith_decode(cinfo, entropy->fixed_bin);
599 st += 2; 599 st += 2;
600 /* Figure F.23: Decoding the magnitude category of v */ 600 /* Figure F.23: Decoding the magnitude category of v */
601 if ((m = arith_decode(cinfo, st)) != 0) { 601 if ((m = arith_decode(cinfo, st)) != 0) {
602 if (arith_decode(cinfo, st)) { 602 if (arith_decode(cinfo, st)) {
603 m <<= 1; 603 m <<= 1;
604 st = entropy->ac_stats[tbl] + 604 st = entropy->ac_stats[tbl] +
605 (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); 605 (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
606 while (arith_decode(cinfo, st)) { 606 while (arith_decode(cinfo, st)) {
607 if ((m <<= 1) == 0x8000) { 607 if ((m <<= 1) == 0x8000) {
608 WARNMS(cinfo, JWRN_ARITH_BAD_CODE); 608 WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
609 entropy->ct = -1; /* magnitude overflow */ 609 entropy->ct = -1; /* magnitude overflow */
610 return TRUE; 610 return TRUE;
611 } 611 }
612 st += 1; 612 st += 1;
613 } 613 }
614 } 614 }
615 } 615 }
616 v = m; 616 v = m;
617 /* Figure F.24: Decoding the magnitude bit pattern of v */ 617 /* Figure F.24: Decoding the magnitude bit pattern of v */
618 st += 14; 618 st += 14;
619 while (m >>= 1) 619 while (m >>= 1)
620 if (arith_decode(cinfo, st)) v |= m; 620 if (arith_decode(cinfo, st)) v |= m;
621 v += 1; if (sign) v = -v; 621 v += 1; if (sign) v = -v;
622 (*block)[natural_order[k]] = (JCOEF) v; 622 (*block)[natural_order[k]] = (JCOEF) v;
623 } while (k < cinfo->lim_Se); 623 } while (k < cinfo->lim_Se);
624 } 624 }
625 625
626 return TRUE; 626 return TRUE;
627} 627}
628 628
629 629
630/* 630/*
631 * Initialize for an arithmetic-compressed scan. 631 * Initialize for an arithmetic-compressed scan.
632 */ 632 */
633 633
634METHODDEF(void) 634METHODDEF(void)
635start_pass (j_decompress_ptr cinfo) 635start_pass (j_decompress_ptr cinfo)
636{ 636{
637 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy; 637 arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
638 int ci, tbl; 638 int ci, tbl;
639 jpeg_component_info * compptr; 639 jpeg_component_info * compptr;
640 640
641 if (cinfo->progressive_mode) { 641 if (cinfo->progressive_mode) {
642 /* Validate progressive scan parameters */ 642 /* Validate progressive scan parameters */
643 if (cinfo->Ss == 0) { 643 if (cinfo->Ss == 0) {
644 if (cinfo->Se != 0) 644 if (cinfo->Se != 0)
645 goto bad; 645 goto bad;
646 } else { 646 } else {
647 /* need not check Ss/Se < 0 since they came from unsigned bytes */ 647 /* need not check Ss/Se < 0 since they came from unsigned bytes */
648 if (cinfo->Se < cinfo->Ss || cinfo->Se > cinfo->lim_Se) 648 if (cinfo->Se < cinfo->Ss || cinfo->Se > cinfo->lim_Se)
649 goto bad; 649 goto bad;
650 /* AC scans may have only one component */ 650 /* AC scans may have only one component */
651 if (cinfo->comps_in_scan != 1) 651 if (cinfo->comps_in_scan != 1)
652 goto bad; 652 goto bad;
653 } 653 }
654 if (cinfo->Ah != 0) { 654 if (cinfo->Ah != 0) {
655 /* Successive approximation refinement scan: must have Al = Ah-1. */ 655 /* Successive approximation refinement scan: must have Al = Ah-1. */
656 if (cinfo->Ah-1 != cinfo->Al) 656 if (cinfo->Ah-1 != cinfo->Al)
657 goto bad; 657 goto bad;
658 } 658 }
659 if (cinfo->Al > 13) { /* need not check for < 0 */ 659 if (cinfo->Al > 13) { /* need not check for < 0 */
660 bad: 660 bad:
661 ERREXIT4(cinfo, JERR_BAD_PROGRESSION, 661 ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
662 cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al); 662 cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
663 } 663 }
664 /* Update progression status, and verify that scan order is legal. 664 /* Update progression status, and verify that scan order is legal.
665 * Note that inter-scan inconsistencies are treated as warnings 665 * Note that inter-scan inconsistencies are treated as warnings
666 * not fatal errors ... not clear if this is right way to behave. 666 * not fatal errors ... not clear if this is right way to behave.
667 */ 667 */
668 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 668 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
669 int coefi, cindex = cinfo->cur_comp_info[ci]->component_index; 669 int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
670 int *coef_bit_ptr = & cinfo->coef_bits[cindex][0]; 670 int *coef_bit_ptr = & cinfo->coef_bits[cindex][0];
671 if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */ 671 if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
672 WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0); 672 WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
673 for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) { 673 for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
674 int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi]; 674 int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
675 if (cinfo->Ah != expected) 675 if (cinfo->Ah != expected)
676 WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi); 676 WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
677 coef_bit_ptr[coefi] = cinfo->Al; 677 coef_bit_ptr[coefi] = cinfo->Al;
678 } 678 }
679 } 679 }
680 /* Select MCU decoding routine */ 680 /* Select MCU decoding routine */
681 if (cinfo->Ah == 0) { 681 if (cinfo->Ah == 0) {
682 if (cinfo->Ss == 0) 682 if (cinfo->Ss == 0)
683 entropy->pub.decode_mcu = decode_mcu_DC_first; 683 entropy->pub.decode_mcu = decode_mcu_DC_first;
684 else 684 else
685 entropy->pub.decode_mcu = decode_mcu_AC_first; 685 entropy->pub.decode_mcu = decode_mcu_AC_first;
686 } else { 686 } else {
687 if (cinfo->Ss == 0) 687 if (cinfo->Ss == 0)
688 entropy->pub.decode_mcu = decode_mcu_DC_refine; 688 entropy->pub.decode_mcu = decode_mcu_DC_refine;
689 else 689 else
690 entropy->pub.decode_mcu = decode_mcu_AC_refine; 690 entropy->pub.decode_mcu = decode_mcu_AC_refine;
691 } 691 }
692 } else { 692 } else {
693 /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG. 693 /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
694 * This ought to be an error condition, but we make it a warning. 694 * This ought to be an error condition, but we make it a warning.
695 */ 695 */
696 if (cinfo->Ss != 0 || cinfo->Ah != 0 || cinfo->Al != 0 || 696 if (cinfo->Ss != 0 || cinfo->Ah != 0 || cinfo->Al != 0 ||
697 (cinfo->Se < DCTSIZE2 && cinfo->Se != cinfo->lim_Se)) 697 (cinfo->Se < DCTSIZE2 && cinfo->Se != cinfo->lim_Se))
698 WARNMS(cinfo, JWRN_NOT_SEQUENTIAL); 698 WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
699 /* Select MCU decoding routine */ 699 /* Select MCU decoding routine */
700 entropy->pub.decode_mcu = decode_mcu; 700 entropy->pub.decode_mcu = decode_mcu;
701 } 701 }
702 702
703 /* Allocate & initialize requested statistics areas */ 703 /* Allocate & initialize requested statistics areas */
704 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 704 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
705 compptr = cinfo->cur_comp_info[ci]; 705 compptr = cinfo->cur_comp_info[ci];
706 if (! cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) { 706 if (! cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
707 tbl = compptr->dc_tbl_no; 707 tbl = compptr->dc_tbl_no;
708 if (tbl < 0 || tbl >= NUM_ARITH_TBLS) 708 if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
709 ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); 709 ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
710 if (entropy->dc_stats[tbl] == NULL) 710 if (entropy->dc_stats[tbl] == NULL)
711 entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) 711 entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
712 ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS); 712 ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS);
713 MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS); 713 MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
714 /* Initialize DC predictions to 0 */ 714 /* Initialize DC predictions to 0 */
715 entropy->last_dc_val[ci] = 0; 715 entropy->last_dc_val[ci] = 0;
716 entropy->dc_context[ci] = 0; 716 entropy->dc_context[ci] = 0;
717 } 717 }
718 if ((! cinfo->progressive_mode && cinfo->lim_Se) || 718 if ((! cinfo->progressive_mode && cinfo->lim_Se) ||
719 (cinfo->progressive_mode && cinfo->Ss)) { 719 (cinfo->progressive_mode && cinfo->Ss)) {
720 tbl = compptr->ac_tbl_no; 720 tbl = compptr->ac_tbl_no;
721 if (tbl < 0 || tbl >= NUM_ARITH_TBLS) 721 if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
722 ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); 722 ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
723 if (entropy->ac_stats[tbl] == NULL) 723 if (entropy->ac_stats[tbl] == NULL)
724 entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small) 724 entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
725 ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS); 725 ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS);
726 MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS); 726 MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
727 } 727 }
728 } 728 }
729 729
730 /* Initialize arithmetic decoding variables */ 730 /* Initialize arithmetic decoding variables */
731 entropy->c = 0; 731 entropy->c = 0;
732 entropy->a = 0; 732 entropy->a = 0;
733 entropy->ct = -16; /* force reading 2 initial bytes to fill C */ 733 entropy->ct = -16; /* force reading 2 initial bytes to fill C */
734 734
735 /* Initialize restart counter */ 735 /* Initialize restart counter */
736 entropy->restarts_to_go = cinfo->restart_interval; 736 entropy->restarts_to_go = cinfo->restart_interval;
737} 737}
738 738
739 739
740/* 740/*
741 * Module initialization routine for arithmetic entropy decoding. 741 * Module initialization routine for arithmetic entropy decoding.
742 */ 742 */
743 743
744GLOBAL(void) 744GLOBAL(void)
745jinit_arith_decoder (j_decompress_ptr cinfo) 745jinit_arith_decoder (j_decompress_ptr cinfo)
746{ 746{
747 arith_entropy_ptr entropy; 747 arith_entropy_ptr entropy;
748 int i; 748 int i;
749 749
750 entropy = (arith_entropy_ptr) 750 entropy = (arith_entropy_ptr)
751 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 751 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
752 SIZEOF(arith_entropy_decoder)); 752 SIZEOF(arith_entropy_decoder));
753 cinfo->entropy = (struct jpeg_entropy_decoder *) entropy; 753 cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
754 entropy->pub.start_pass = start_pass; 754 entropy->pub.start_pass = start_pass;
755 755
756 /* Mark tables unallocated */ 756 /* Mark tables unallocated */
757 for (i = 0; i < NUM_ARITH_TBLS; i++) { 757 for (i = 0; i < NUM_ARITH_TBLS; i++) {
758 entropy->dc_stats[i] = NULL; 758 entropy->dc_stats[i] = NULL;
759 entropy->ac_stats[i] = NULL; 759 entropy->ac_stats[i] = NULL;
760 } 760 }
761 761
762 /* Initialize index for fixed probability estimation */ 762 /* Initialize index for fixed probability estimation */
763 entropy->fixed_bin[0] = 113; 763 entropy->fixed_bin[0] = 113;
764 764
765 if (cinfo->progressive_mode) { 765 if (cinfo->progressive_mode) {
766 /* Create progression status table */ 766 /* Create progression status table */
767 int *coef_bit_ptr, ci; 767 int *coef_bit_ptr, ci;
768 cinfo->coef_bits = (int (*)[DCTSIZE2]) 768 cinfo->coef_bits = (int (*)[DCTSIZE2])
769 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 769 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
770 cinfo->num_components*DCTSIZE2*SIZEOF(int)); 770 cinfo->num_components*DCTSIZE2*SIZEOF(int));
771 coef_bit_ptr = & cinfo->coef_bits[0][0]; 771 coef_bit_ptr = & cinfo->coef_bits[0][0];
772 for (ci = 0; ci < cinfo->num_components; ci++) 772 for (ci = 0; ci < cinfo->num_components; ci++)
773 for (i = 0; i < DCTSIZE2; i++) 773 for (i = 0; i < DCTSIZE2; i++)
774 *coef_bit_ptr++ = -1; 774 *coef_bit_ptr++ = -1;
775 } 775 }
776} 776}
generated by cgit v1.1 at 2024-11-03 22:57:48 +0000