ReactOS  0.4.15-dev-439-g292f67a
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 
23 typedef 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 
64 LOCAL(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 
105 LOCAL(int)
106 arith_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 
189 LOCAL(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 
241 METHODDEF(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 
320 METHODDEF(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 
402 METHODDEF(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 
436 METHODDEF(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 
511 METHODDEF(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 
643 METHODDEF(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 
753 METHODDEF(void)
755 {
756  /* no work necessary here */
757 }
758 
759 
760 /*
761  * Module initialization routine for arithmetic entropy decoding.
762  */
763 
764 GLOBAL(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 }
static unsigned int block
Definition: xmlmemory.c:118
static size_t double int int int * sign
Definition: printf.c:69
process_restart(j_decompress_ptr cinfo)
Definition: jdarith.c:190
#define TRUE
Definition: types.h:120
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:321
arith_decode(j_decompress_ptr cinfo, unsigned char *st)
Definition: jdarith.c:106
#define GETJOCTET(value)
Definition: jmorecfg.h:171
decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:403
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
unsigned char fixed_bin[4]
Definition: jcarith.c:45
struct jpeg_entropy_encoder pub
Definition: jcarith.c:24
#define MEMZERO(addr, type, size)
Definition: svc_dg.c:324
arith_entropy_decoder * arith_entropy_ptr
Definition: jdarith.c:45
short JCOEF
Definition: jmorecfg.h:151
const GLfloat * m
Definition: glext.h:10848
unsigned int restarts_to_go
Definition: jdarith.c:35
jpeg_component_info * compptr
Definition: jdct.h:238
while(1)
Definition: macro.lex.yy.c:740
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 SIZEOF(_ar)
Definition: calc.h:97
finish_pass(j_decompress_ptr cinfo)
Definition: jdarith.c:754
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define WARNMS2(cinfo, code, p1, p2)
Definition: jerror.h:258
unsigned char * ac_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:42
#define e
Definition: ke_i.h:82
#define ERREXIT4(cinfo, code, p1, p2, p3, p4)
Definition: jerror.h:227
smooth NULL
Definition: ftsmooth.c:416
decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:437
unsigned char * dc_stats[NUM_ARITH_TBLS]
Definition: jcarith.c:41
#define DCTSIZE2
Definition: jpeglib.h:51
#define LOCAL(type)
Definition: jmorecfg.h:289
start_pass(j_decompress_ptr cinfo)
Definition: jdarith.c:644
if(!(yy_init))
Definition: macro.lex.yy.c:714
jinit_arith_decoder(j_decompress_ptr cinfo)
Definition: jdarith.c:765
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:80
#define WARNMS(cinfo, code)
Definition: jerror.h:251
JCOEF FAR * JCOEFPTR
Definition: jpeglib.h:84
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
decode_mcu_DC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:242
unsigned int restarts_to_go
Definition: jcarith.c:37
static const WCHAR L[]
Definition: oid.c:1250
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
GLenum src
Definition: glext.h:6340
#define DC_STAT_BINS
Definition: jdarith.c:60
int last_dc_val[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:34
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define METHODDEF(type)
Definition: jmorecfg.h:287
const GLdouble * v
Definition: gl.h:2040
static calc_node_t temp
Definition: rpn_ieee.c:38
get_byte(j_decompress_ptr cinfo)
Definition: jdarith.c:65
int dc_context[MAX_COMPS_IN_SCAN]
Definition: jcarith.c:35
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
#define AC_STAT_BINS
Definition: jdarith.c:61
signed int INT32
const INT32 jpeg_aritab[113+1]
Definition: jaricom.c:31
int k
Definition: mpi.c:3369
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:55
decode_mcu(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
Definition: jdarith.c:512
BOOL expected
Definition: store.c:2063
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31