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