Coverage Report

Created: 2023-03-23 11:52

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