ReactOS  0.4.14-dev-50-g13bb5e2
jdarith.c
Go to the documentation of this file.
1 /*
2  * jdarith.c
3  *
4  * Developed 1997-2015 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) == 0x8000) {
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) == 0x8000) {
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  int p1, blkn;
408 
409  /* Process restart marker if needed */
410  if (cinfo->restart_interval) {
411  if (entropy->restarts_to_go == 0)
412  process_restart(cinfo);
413  entropy->restarts_to_go--;
414  }
415 
416  st = entropy->fixed_bin; /* use fixed probability estimation */
417  p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
418 
419  /* Outer loop handles each block in the MCU */
420 
421  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
422  /* Encoded data is simply the next bit of the two's-complement DC value */
423  if (arith_decode(cinfo, st))
424  MCU_data[blkn][0][0] |= p1;
425  }
426 
427  return TRUE;
428 }
429 
430 
431 /*
432  * MCU decoding for AC successive approximation refinement scan.
433  */
434 
435 METHODDEF(boolean)
437 {
438  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
440  JCOEFPTR thiscoef;
441  unsigned char *st;
442  int tbl, k, kex;
443  int p1, m1;
444  const int * natural_order;
445 
446  /* Process restart marker if needed */
447  if (cinfo->restart_interval) {
448  if (entropy->restarts_to_go == 0)
449  process_restart(cinfo);
450  entropy->restarts_to_go--;
451  }
452 
453  if (entropy->ct == -1) return TRUE; /* if error do nothing */
454 
455  natural_order = cinfo->natural_order;
456 
457  /* There is always only one block per MCU */
458  block = MCU_data[0];
459  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
460 
461  p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
462  m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */
463 
464  /* Establish EOBx (previous stage end-of-block) index */
465  kex = cinfo->Se;
466  do {
467  if ((*block)[natural_order[kex]]) break;
468  } while (--kex);
469 
470  k = cinfo->Ss - 1;
471  do {
472  st = entropy->ac_stats[tbl] + 3 * k;
473  if (k >= kex)
474  if (arith_decode(cinfo, st)) break; /* EOB flag */
475  for (;;) {
476  thiscoef = *block + natural_order[++k];
477  if (*thiscoef) { /* previously nonzero coef */
478  if (arith_decode(cinfo, st + 2)) {
479  if (*thiscoef < 0)
480  *thiscoef += m1;
481  else
482  *thiscoef += p1;
483  }
484  break;
485  }
486  if (arith_decode(cinfo, st + 1)) { /* newly nonzero coef */
487  if (arith_decode(cinfo, entropy->fixed_bin))
488  *thiscoef = m1;
489  else
490  *thiscoef = p1;
491  break;
492  }
493  st += 3;
494  if (k >= cinfo->Se) {
495  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
496  entropy->ct = -1; /* spectral overflow */
497  return TRUE;
498  }
499  }
500  } while (k < cinfo->Se);
501 
502  return TRUE;
503 }
504 
505 
506 /*
507  * Decode one MCU's worth of arithmetic-compressed coefficients.
508  */
509 
510 METHODDEF(boolean)
512 {
513  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
516  unsigned char *st;
517  int blkn, ci, tbl, sign, k;
518  int v, m;
519  const int * natural_order;
520 
521  /* Process restart marker if needed */
522  if (cinfo->restart_interval) {
523  if (entropy->restarts_to_go == 0)
524  process_restart(cinfo);
525  entropy->restarts_to_go--;
526  }
527 
528  if (entropy->ct == -1) return TRUE; /* if error do nothing */
529 
530  natural_order = cinfo->natural_order;
531 
532  /* Outer loop handles each block in the MCU */
533 
534  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
535  block = MCU_data[blkn];
536  ci = cinfo->MCU_membership[blkn];
537  compptr = cinfo->cur_comp_info[ci];
538 
539  /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
540 
541  tbl = compptr->dc_tbl_no;
542 
543  /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
544  st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
545 
546  /* Figure F.19: Decode_DC_DIFF */
547  if (arith_decode(cinfo, st) == 0)
548  entropy->dc_context[ci] = 0;
549  else {
550  /* Figure F.21: Decoding nonzero value v */
551  /* Figure F.22: Decoding the sign of v */
552  sign = arith_decode(cinfo, st + 1);
553  st += 2; st += sign;
554  /* Figure F.23: Decoding the magnitude category of v */
555  if ((m = arith_decode(cinfo, st)) != 0) {
556  st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */
557  while (arith_decode(cinfo, st)) {
558  if ((m <<= 1) == 0x8000) {
559  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
560  entropy->ct = -1; /* magnitude overflow */
561  return TRUE;
562  }
563  st += 1;
564  }
565  }
566  /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
567  if (m < (int) ((1L << cinfo->arith_dc_L[tbl]) >> 1))
568  entropy->dc_context[ci] = 0; /* zero diff category */
569  else if (m > (int) ((1L << cinfo->arith_dc_U[tbl]) >> 1))
570  entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
571  else
572  entropy->dc_context[ci] = 4 + (sign * 4); /* small diff category */
573  v = m;
574  /* Figure F.24: Decoding the magnitude bit pattern of v */
575  st += 14;
576  while (m >>= 1)
577  if (arith_decode(cinfo, st)) v |= m;
578  v += 1; if (sign) v = -v;
579  entropy->last_dc_val[ci] += v;
580  }
581 
582  (*block)[0] = (JCOEF) entropy->last_dc_val[ci];
583 
584  /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
585 
586  if (cinfo->lim_Se == 0) continue;
587  tbl = compptr->ac_tbl_no;
588  k = 0;
589 
590  /* Figure F.20: Decode_AC_coefficients */
591  do {
592  st = entropy->ac_stats[tbl] + 3 * k;
593  if (arith_decode(cinfo, st)) break; /* EOB flag */
594  for (;;) {
595  k++;
596  if (arith_decode(cinfo, st + 1)) break;
597  st += 3;
598  if (k >= cinfo->lim_Se) {
599  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
600  entropy->ct = -1; /* spectral overflow */
601  return TRUE;
602  }
603  }
604  /* Figure F.21: Decoding nonzero value v */
605  /* Figure F.22: Decoding the sign of v */
606  sign = arith_decode(cinfo, entropy->fixed_bin);
607  st += 2;
608  /* Figure F.23: Decoding the magnitude category of v */
609  if ((m = arith_decode(cinfo, st)) != 0) {
610  if (arith_decode(cinfo, st)) {
611  m <<= 1;
612  st = entropy->ac_stats[tbl] +
613  (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
614  while (arith_decode(cinfo, st)) {
615  if ((m <<= 1) == 0x8000) {
616  WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
617  entropy->ct = -1; /* magnitude overflow */
618  return TRUE;
619  }
620  st += 1;
621  }
622  }
623  }
624  v = m;
625  /* Figure F.24: Decoding the magnitude bit pattern of v */
626  st += 14;
627  while (m >>= 1)
628  if (arith_decode(cinfo, st)) v |= m;
629  v += 1; if (sign) v = -v;
630  (*block)[natural_order[k]] = (JCOEF) v;
631  } while (k < cinfo->lim_Se);
632  }
633 
634  return TRUE;
635 }
636 
637 
638 /*
639  * Initialize for an arithmetic-compressed scan.
640  */
641 
642 METHODDEF(void)
644 {
645  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
646  int ci, tbl;
648 
649  if (cinfo->progressive_mode) {
650  /* Validate progressive scan parameters */
651  if (cinfo->Ss == 0) {
652  if (cinfo->Se != 0)
653  goto bad;
654  } else {
655  /* need not check Ss/Se < 0 since they came from unsigned bytes */
656  if (cinfo->Se < cinfo->Ss || cinfo->Se > cinfo->lim_Se)
657  goto bad;
658  /* AC scans may have only one component */
659  if (cinfo->comps_in_scan != 1)
660  goto bad;
661  }
662  if (cinfo->Ah != 0) {
663  /* Successive approximation refinement scan: must have Al = Ah-1. */
664  if (cinfo->Ah-1 != cinfo->Al)
665  goto bad;
666  }
667  if (cinfo->Al > 13) { /* need not check for < 0 */
668  bad:
669  ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
670  cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
671  }
672  /* Update progression status, and verify that scan order is legal.
673  * Note that inter-scan inconsistencies are treated as warnings
674  * not fatal errors ... not clear if this is right way to behave.
675  */
676  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
677  int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
678  int *coef_bit_ptr = & cinfo->coef_bits[cindex][0];
679  if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
680  WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
681  for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
682  int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
683  if (cinfo->Ah != expected)
684  WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
685  coef_bit_ptr[coefi] = cinfo->Al;
686  }
687  }
688  /* Select MCU decoding routine */
689  if (cinfo->Ah == 0) {
690  if (cinfo->Ss == 0)
691  entropy->pub.decode_mcu = decode_mcu_DC_first;
692  else
693  entropy->pub.decode_mcu = decode_mcu_AC_first;
694  } else {
695  if (cinfo->Ss == 0)
696  entropy->pub.decode_mcu = decode_mcu_DC_refine;
697  else
698  entropy->pub.decode_mcu = decode_mcu_AC_refine;
699  }
700  } else {
701  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
702  * This ought to be an error condition, but we make it a warning.
703  */
704  if (cinfo->Ss != 0 || cinfo->Ah != 0 || cinfo->Al != 0 ||
705  (cinfo->Se < DCTSIZE2 && cinfo->Se != cinfo->lim_Se))
706  WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
707  /* Select MCU decoding routine */
708  entropy->pub.decode_mcu = decode_mcu;
709  }
710 
711  /* Allocate & initialize requested statistics areas */
712  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
713  compptr = cinfo->cur_comp_info[ci];
714  if (! cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
715  tbl = compptr->dc_tbl_no;
716  if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
717  ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
718  if (entropy->dc_stats[tbl] == NULL)
719  entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
721  MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
722  /* Initialize DC predictions to 0 */
723  entropy->last_dc_val[ci] = 0;
724  entropy->dc_context[ci] = 0;
725  }
726  if ((! cinfo->progressive_mode && cinfo->lim_Se) ||
727  (cinfo->progressive_mode && cinfo->Ss)) {
728  tbl = compptr->ac_tbl_no;
729  if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
730  ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
731  if (entropy->ac_stats[tbl] == NULL)
732  entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
734  MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
735  }
736  }
737 
738  /* Initialize arithmetic decoding variables */
739  entropy->c = 0;
740  entropy->a = 0;
741  entropy->ct = -16; /* force reading 2 initial bytes to fill C */
742 
743  /* Initialize restart counter */
744  entropy->restarts_to_go = cinfo->restart_interval;
745 }
746 
747 
748 /*
749  * Finish up at the end of an arithmetic-compressed scan.
750  */
751 
752 METHODDEF(void)
754 {
755  /* no work necessary here */
756 }
757 
758 
759 /*
760  * Module initialization routine for arithmetic entropy decoding.
761  */
762 
763 GLOBAL(void)
765 {
766  arith_entropy_ptr entropy;
767  int i;
768 
769  entropy = (arith_entropy_ptr)
770  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
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])
789  (*cinfo->mem->alloc_small) ((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:64
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:753
#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:436
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:643
if(!(yy_init))
Definition: macro.lex.yy.c:714
jinit_arith_decoder(j_decompress_ptr cinfo)
Definition: jdarith.c:764
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:511
BOOL expected
Definition: store.c:2063
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31