Coverage Report

Created: 2024-03-28 05:34

/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
1.23M
#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
632k
#define DC_STAT_BINS  64
70
752k
#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
833k
{
77
833k
  struct jpeg_source_mgr *src = cinfo->src;
78
79
833k
  if (src->bytes_in_buffer == 0)
80
3.36k
    if (!(*src->fill_input_buffer) (cinfo))
81
0
      ERREXIT(cinfo, JERR_CANT_SUSPEND);
82
833k
  src->bytes_in_buffer--;
83
833k
  return *src->next_input_byte++;
84
833k
}
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
154M
{
117
154M
  register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy;
118
154M
  register unsigned char nl, nm;
119
154M
  register JLONG qe, temp;
120
154M
  register int sv, data;
121
122
  /* Renormalization & data input per section D.2.6 */
123
220M
  while (e->a < 0x8000L) {
124
65.6M
    if (--e->ct < 0) {
125
      /* Need to fetch next data byte */
126
11.1M
      if (cinfo->unread_marker)
127
10.4M
        data = 0;               /* stuff zero data */
128
766k
      else {
129
766k
        data = get_byte(cinfo); /* read next input byte */
130
766k
        if (data == 0xFF) {     /* zero stuff or marker code */
131
66.2k
          do data = get_byte(cinfo);
132
66.2k
          while (data == 0xFF); /* swallow extra 0xFF bytes */
133
51.4k
          if (data == 0)
134
2.95k
            data = 0xFF;        /* discard stuffed zero byte */
135
48.4k
          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
48.4k
            cinfo->unread_marker = data;
143
48.4k
            data = 0;
144
48.4k
          }
145
51.4k
        }
146
766k
      }
147
11.1M
      e->c = (e->c << 8) | data; /* insert data into C register */
148
11.1M
      if ((e->ct += 8) < 0)      /* update bit shift counter */
149
        /* Need more initial bytes */
150
2.81M
        if (++e->ct == 0)
151
          /* Got 2 initial bytes -> re-init A and exit loop */
152
1.40M
          e->a = 0x8000L; /* => e->a = 0x10000L after loop exit */
153
11.1M
    }
154
65.6M
    e->a <<= 1;
155
65.6M
  }
156
157
  /* Fetch values from our compact representation of Table D.2:
158
   * Qe values and probability estimation state machine
159
   */
160
154M
  sv = *st;
161
154M
  qe = jpeg_aritab[sv & 0x7F];  /* => Qe_Value */
162
154M
  nl = qe & 0xFF;  qe >>= 8;    /* Next_Index_LPS + Switch_MPS */
163
154M
  nm = qe & 0xFF;  qe >>= 8;    /* Next_Index_MPS */
164
165
  /* Decode & estimation procedures per sections D.2.4 & D.2.5 */
166
154M
  temp = e->a - qe;
167
154M
  e->a = temp;
168
154M
  temp <<= e->ct;
169
154M
  if (e->c >= temp) {
170
17.1M
    e->c -= temp;
171
    /* Conditional LPS (less probable symbol) exchange */
172
17.1M
    if (e->a < qe) {
173
4.68M
      e->a = qe;
174
4.68M
      *st = (sv & 0x80) ^ nm;   /* Estimate_after_MPS */
175
12.5M
    } else {
176
12.5M
      e->a = qe;
177
12.5M
      *st = (sv & 0x80) ^ nl;   /* Estimate_after_LPS */
178
12.5M
      sv ^= 0x80;               /* Exchange LPS/MPS */
179
12.5M
    }
180
137M
  } else if (e->a < 0x8000L) {
181
    /* Conditional MPS (more probable symbol) exchange */
182
29.8M
    if (e->a < qe) {
183
12.0M
      *st = (sv & 0x80) ^ nl;   /* Estimate_after_LPS */
184
12.0M
      sv ^= 0x80;               /* Exchange LPS/MPS */
185
17.8M
    } else {
186
17.8M
      *st = (sv & 0x80) ^ nm;   /* Estimate_after_MPS */
187
17.8M
    }
188
29.8M
  }
189
190
154M
  return sv >> 7;
191
154M
}
192
193
194
/*
195
 * Check for a restart marker & resynchronize decoder.
196
 */
197
198
LOCAL(void)
199
process_restart(j_decompress_ptr cinfo)
200
1.31M
{
201
1.31M
  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
202
1.31M
  int ci;
203
1.31M
  jpeg_component_info *compptr;
204
205
  /* Advance past the RSTn marker */
206
1.31M
  if (!(*cinfo->marker->read_restart_marker) (cinfo))
207
0
    ERREXIT(cinfo, JERR_CANT_SUSPEND);
208
209
  /* Re-initialize statistics areas */
210
3.03M
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
211
1.71M
    compptr = cinfo->cur_comp_info[ci];
212
1.71M
    if (!cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
213
497k
      memset(entropy->dc_stats[compptr->dc_tbl_no], 0, DC_STAT_BINS);
214
      /* Reset DC predictions to 0 */
215
497k
      entropy->last_dc_val[ci] = 0;
216
497k
      entropy->dc_context[ci] = 0;
217
497k
    }
218
1.71M
    if (!cinfo->progressive_mode || cinfo->Ss) {
219
670k
      memset(entropy->ac_stats[compptr->ac_tbl_no], 0, AC_STAT_BINS);
220
670k
    }
221
1.71M
  }
222
223
  /* Reset arithmetic decoding variables */
224
1.31M
  entropy->c = 0;
225
1.31M
  entropy->a = 0;
226
1.31M
  entropy->ct = -16;    /* force reading 2 initial bytes to fill C */
227
228
  /* Reset restart counter */
229
1.31M
  entropy->restarts_to_go = cinfo->restart_interval;
230
1.31M
}
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
6.65M
{
252
6.65M
  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
253
6.65M
  JBLOCKROW block;
254
6.65M
  unsigned char *st;
255
6.65M
  int blkn, ci, tbl, sign;
256
6.65M
  int v, m;
257
258
  /* Process restart marker if needed */
259
6.65M
  if (cinfo->restart_interval) {
260
324k
    if (entropy->restarts_to_go == 0)
261
106k
      process_restart(cinfo);
262
324k
    entropy->restarts_to_go--;
263
324k
  }
264
265
6.65M
  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
266
267
  /* Outer loop handles each block in the MCU */
268
269
22.7M
  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
270
16.1M
    block = MCU_data[blkn];
271
16.1M
    ci = cinfo->MCU_membership[blkn];
272
16.1M
    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
16.1M
    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
278
279
    /* Figure F.19: Decode_DC_DIFF */
280
16.1M
    if (arith_decode(cinfo, st) == 0)
281
7.41M
      entropy->dc_context[ci] = 0;
282
8.76M
    else {
283
      /* Figure F.21: Decoding nonzero value v */
284
      /* Figure F.22: Decoding the sign of v */
285
8.76M
      sign = arith_decode(cinfo, st + 1);
286
8.76M
      st += 2;  st += sign;
287
      /* Figure F.23: Decoding the magnitude category of v */
288
8.76M
      if ((m = arith_decode(cinfo, st)) != 0) {
289
4.85M
        st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
290
11.8M
        while (arith_decode(cinfo, st)) {
291
7.01M
          if ((m <<= 1) == 0x8000) {
292
2.29k
            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
293
2.29k
            entropy->ct = -1;                   /* magnitude overflow */
294
2.29k
            return TRUE;
295
2.29k
          }
296
7.01M
          st += 1;
297
7.01M
        }
298
4.85M
      }
299
      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
300
8.76M
      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
301
13.5k
        entropy->dc_context[ci] = 0;               /* zero diff category */
302
8.75M
      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
303
3.01M
        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
304
5.73M
      else
305
5.73M
        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
306
8.76M
      v = m;
307
      /* Figure F.24: Decoding the magnitude bit pattern of v */
308
8.76M
      st += 14;
309
15.7M
      while (m >>= 1)
310
6.97M
        if (arith_decode(cinfo, st)) v |= m;
311
8.76M
      v += 1;  if (sign) v = -v;
312
8.76M
      entropy->last_dc_val[ci] = (entropy->last_dc_val[ci] + v) & 0xffff;
313
8.76M
    }
314
315
    /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
316
16.1M
    (*block)[0] = (JCOEF)LEFT_SHIFT(entropy->last_dc_val[ci], cinfo->Al);
317
16.1M
  }
318
319
6.58M
  return TRUE;
320
6.59M
}
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
4.59M
{
331
4.59M
  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
332
4.59M
  JBLOCKROW block;
333
4.59M
  unsigned char *st;
334
4.59M
  int tbl, sign, k;
335
4.59M
  int v, m;
336
337
  /* Process restart marker if needed */
338
4.59M
  if (cinfo->restart_interval) {
339
575k
    if (entropy->restarts_to_go == 0)
340
199k
      process_restart(cinfo);
341
575k
    entropy->restarts_to_go--;
342
575k
  }
343
344
4.59M
  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
345
346
  /* There is always only one block per MCU */
347
3.21M
  block = MCU_data[0];
348
3.21M
  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
5.46M
  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
354
5.37M
    st = entropy->ac_stats[tbl] + 3 * (k - 1);
355
5.37M
    if (arith_decode(cinfo, st)) break;         /* EOB flag */
356
4.62M
    while (arith_decode(cinfo, st + 1) == 0) {
357
2.37M
      st += 3;  k++;
358
2.37M
      if (k > cinfo->Se) {
359
1.84k
        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
360
1.84k
        entropy->ct = -1;                       /* spectral overflow */
361
1.84k
        return TRUE;
362
1.84k
      }
363
2.37M
    }
364
    /* Figure F.21: Decoding nonzero value v */
365
    /* Figure F.22: Decoding the sign of v */
366
2.24M
    sign = arith_decode(cinfo, entropy->fixed_bin);
367
2.24M
    st += 2;
368
    /* Figure F.23: Decoding the magnitude category of v */
369
2.24M
    if ((m = arith_decode(cinfo, st)) != 0) {
370
1.06M
      if (arith_decode(cinfo, st)) {
371
831k
        m <<= 1;
372
831k
        st = entropy->ac_stats[tbl] +
373
831k
             (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
374
1.66M
        while (arith_decode(cinfo, st)) {
375
833k
          if ((m <<= 1) == 0x8000) {
376
230
            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
377
230
            entropy->ct = -1;                   /* magnitude overflow */
378
230
            return TRUE;
379
230
          }
380
833k
          st += 1;
381
833k
        }
382
831k
      }
383
1.06M
    }
384
2.24M
    v = m;
385
    /* Figure F.24: Decoding the magnitude bit pattern of v */
386
2.24M
    st += 14;
387
3.90M
    while (m >>= 1)
388
1.66M
      if (arith_decode(cinfo, st)) v |= m;
389
2.24M
    v += 1;  if (sign) v = -v;
390
    /* Scale and output coefficient in natural (dezigzagged) order */
391
2.24M
    (*block)[jpeg_natural_order[k]] = (JCOEF)((unsigned)v << cinfo->Al);
392
2.24M
  }
393
394
3.21M
  return TRUE;
395
3.21M
}
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
2.43M
{
405
2.43M
  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
406
2.43M
  unsigned char *st;
407
2.43M
  int p1, blkn;
408
409
  /* Process restart marker if needed */
410
2.43M
  if (cinfo->restart_interval) {
411
1.47M
    if (entropy->restarts_to_go == 0)
412
610k
      process_restart(cinfo);
413
1.47M
    entropy->restarts_to_go--;
414
1.47M
  }
415
416
2.43M
  st = entropy->fixed_bin;      /* use fixed probability estimation */
417
2.43M
  p1 = 1 << cinfo->Al;          /* 1 in the bit position being coded */
418
419
  /* Outer loop handles each block in the MCU */
420
421
9.53M
  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
7.10M
    if (arith_decode(cinfo, st))
424
3.72M
      MCU_data[blkn][0][0] |= p1;
425
7.10M
  }
426
427
2.43M
  return TRUE;
428
2.43M
}
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
2.28M
{
438
2.28M
  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
439
2.28M
  JBLOCKROW block;
440
2.28M
  JCOEFPTR thiscoef;
441
2.28M
  unsigned char *st;
442
2.28M
  int tbl, k, kex;
443
2.28M
  int p1, m1;
444
445
  /* Process restart marker if needed */
446
2.28M
  if (cinfo->restart_interval) {
447
879k
    if (entropy->restarts_to_go == 0)
448
197k
      process_restart(cinfo);
449
879k
    entropy->restarts_to_go--;
450
879k
  }
451
452
2.28M
  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
453
454
  /* There is always only one block per MCU */
455
1.23M
  block = MCU_data[0];
456
1.23M
  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
457
458
1.23M
  p1 = 1 << cinfo->Al;          /* 1 in the bit position being coded */
459
1.23M
  m1 = (NEG_1) << cinfo->Al;    /* -1 in the bit position being coded */
460
461
  /* Establish EOBx (previous stage end-of-block) index */
462
29.2M
  for (kex = cinfo->Se; kex > 0; kex--)
463
28.3M
    if ((*block)[jpeg_natural_order[kex]]) break;
464
465
3.79M
  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
466
3.69M
    st = entropy->ac_stats[tbl] + 3 * (k - 1);
467
3.69M
    if (k > kex)
468
1.96M
      if (arith_decode(cinfo, st)) break;       /* EOB flag */
469
3.26M
    for (;;) {
470
3.26M
      thiscoef = *block + jpeg_natural_order[k];
471
3.26M
      if (*thiscoef) {                          /* previously nonzero coef */
472
1.40M
        if (arith_decode(cinfo, st + 2)) {
473
747k
          if (*thiscoef < 0)
474
325k
            *thiscoef += (JCOEF)m1;
475
422k
          else
476
422k
            *thiscoef += (JCOEF)p1;
477
747k
        }
478
1.40M
        break;
479
1.40M
      }
480
1.85M
      if (arith_decode(cinfo, st + 1)) {        /* newly nonzero coef */
481
1.15M
        if (arith_decode(cinfo, entropy->fixed_bin))
482
648k
          *thiscoef = (JCOEF)m1;
483
505k
        else
484
505k
          *thiscoef = (JCOEF)p1;
485
1.15M
        break;
486
1.15M
      }
487
697k
      st += 3;  k++;
488
697k
      if (k > cinfo->Se) {
489
3.69k
        WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
490
3.69k
        entropy->ct = -1;                       /* spectral overflow */
491
3.69k
        return TRUE;
492
3.69k
      }
493
697k
    }
494
2.56M
  }
495
496
1.22M
  return TRUE;
497
1.23M
}
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
3.87M
{
507
3.87M
  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
508
3.87M
  jpeg_component_info *compptr;
509
3.87M
  JBLOCKROW block;
510
3.87M
  unsigned char *st;
511
3.87M
  int blkn, ci, tbl, sign, k;
512
3.87M
  int v, m;
513
514
  /* Process restart marker if needed */
515
3.87M
  if (cinfo->restart_interval) {
516
885k
    if (entropy->restarts_to_go == 0)
517
202k
      process_restart(cinfo);
518
885k
    entropy->restarts_to_go--;
519
885k
  }
520
521
3.87M
  if (entropy->ct == -1) return TRUE;   /* if error do nothing */
522
523
  /* Outer loop handles each block in the MCU */
524
525
9.72M
  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
526
6.30M
    block = MCU_data ? MCU_data[blkn] : NULL;
527
6.30M
    ci = cinfo->MCU_membership[blkn];
528
6.30M
    compptr = cinfo->cur_comp_info[ci];
529
530
    /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
531
532
6.30M
    tbl = compptr->dc_tbl_no;
533
534
    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
535
6.30M
    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
536
537
    /* Figure F.19: Decode_DC_DIFF */
538
6.30M
    if (arith_decode(cinfo, st) == 0)
539
2.98M
      entropy->dc_context[ci] = 0;
540
3.31M
    else {
541
      /* Figure F.21: Decoding nonzero value v */
542
      /* Figure F.22: Decoding the sign of v */
543
3.31M
      sign = arith_decode(cinfo, st + 1);
544
3.31M
      st += 2;  st += sign;
545
      /* Figure F.23: Decoding the magnitude category of v */
546
3.31M
      if ((m = arith_decode(cinfo, st)) != 0) {
547
2.12M
        st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
548
8.14M
        while (arith_decode(cinfo, st)) {
549
6.02M
          if ((m <<= 1) == 0x8000) {
550
927
            WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
551
927
            entropy->ct = -1;                   /* magnitude overflow */
552
927
            return TRUE;
553
927
          }
554
6.01M
          st += 1;
555
6.01M
        }
556
2.12M
      }
557
      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
558
3.31M
      if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1))
559
42.0k
        entropy->dc_context[ci] = 0;               /* zero diff category */
560
3.27M
      else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1))
561
1.61M
        entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
562
1.65M
      else
563
1.65M
        entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
564
3.31M
      v = m;
565
      /* Figure F.24: Decoding the magnitude bit pattern of v */
566
3.31M
      st += 14;
567
9.32M
      while (m >>= 1)
568
6.00M
        if (arith_decode(cinfo, st)) v |= m;
569
3.31M
      v += 1;  if (sign) v = -v;
570
3.31M
      entropy->last_dc_val[ci] = (entropy->last_dc_val[ci] + v) & 0xffff;
571
3.31M
    }
572
573
6.30M
    if (block)
574
6.30M
      (*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
6.30M
    tbl = compptr->ac_tbl_no;
579
580
    /* Figure F.20: Decode_AC_coefficients */
581
11.3M
    for (k = 1; k <= DCTSIZE2 - 1; k++) {
582
11.3M
      st = entropy->ac_stats[tbl] + 3 * (k - 1);
583
11.3M
      if (arith_decode(cinfo, st)) break;       /* EOB flag */
584
11.3M
      while (arith_decode(cinfo, st + 1) == 0) {
585
6.26M
        st += 3;  k++;
586
6.26M
        if (k > DCTSIZE2 - 1) {
587
18
          WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
588
18
          entropy->ct = -1;                     /* spectral overflow */
589
18
          return TRUE;
590
18
        }
591
6.26M
      }
592
      /* Figure F.21: Decoding nonzero value v */
593
      /* Figure F.22: Decoding the sign of v */
594
5.08M
      sign = arith_decode(cinfo, entropy->fixed_bin);
595
5.08M
      st += 2;
596
      /* Figure F.23: Decoding the magnitude category of v */
597
5.08M
      if ((m = arith_decode(cinfo, st)) != 0) {
598
2.75M
        if (arith_decode(cinfo, st)) {
599
2.20M
          m <<= 1;
600
2.20M
          st = entropy->ac_stats[tbl] +
601
2.20M
               (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
602
3.50M
          while (arith_decode(cinfo, st)) {
603
1.30M
            if ((m <<= 1) == 0x8000) {
604
476
              WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
605
476
              entropy->ct = -1;                 /* magnitude overflow */
606
476
              return TRUE;
607
476
            }
608
1.29M
            st += 1;
609
1.29M
          }
610
2.20M
        }
611
2.75M
      }
612
5.08M
      v = m;
613
      /* Figure F.24: Decoding the magnitude bit pattern of v */
614
5.08M
      st += 14;
615
8.58M
      while (m >>= 1)
616
3.50M
        if (arith_decode(cinfo, st)) v |= m;
617
5.08M
      v += 1;  if (sign) v = -v;
618
5.08M
      if (block)
619
5.08M
        (*block)[jpeg_natural_order[k]] = (JCOEF)v;
620
5.08M
    }
621
6.30M
  }
622
623
3.42M
  return TRUE;
624
3.42M
}
625
626
627
/*
628
 * Initialize for an arithmetic-compressed scan.
629
 */
630
631
METHODDEF(void)
632
start_pass(j_decompress_ptr cinfo)
633
90.3k
{
634
90.3k
  arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy;
635
90.3k
  int ci, tbl;
636
90.3k
  jpeg_component_info *compptr;
637
638
90.3k
  if (cinfo->progressive_mode) {
639
    /* Validate progressive scan parameters */
640
61.0k
    if (cinfo->Ss == 0) {
641
36.2k
      if (cinfo->Se != 0)
642
73
        goto bad;
643
36.2k
    } else {
644
      /* need not check Ss/Se < 0 since they came from unsigned bytes */
645
24.8k
      if (cinfo->Se < cinfo->Ss || cinfo->Se > DCTSIZE2 - 1)
646
130
        goto bad;
647
      /* AC scans may have only one component */
648
24.7k
      if (cinfo->comps_in_scan != 1)
649
17
        goto bad;
650
24.7k
    }
651
60.8k
    if (cinfo->Ah != 0) {
652
      /* Successive approximation refinement scan: must have Al = Ah-1. */
653
18.3k
      if (cinfo->Ah - 1 != cinfo->Al)
654
68
        goto bad;
655
18.3k
    }
656
60.8k
    if (cinfo->Al > 13) {       /* need not check for < 0 */
657
321
bad:
658
321
      ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
659
321
               cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
660
321
    }
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
164k
    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
666
103k
      int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
667
103k
      int *coef_bit_ptr = &cinfo->coef_bits[cindex][0];
668
103k
      int *prev_coef_bit_ptr =
669
103k
        &cinfo->coef_bits[cindex + cinfo->num_components][0];
670
103k
      if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
671
13.1k
        WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
672
1.64M
      for (coefi = MIN(cinfo->Ss, 1); coefi <= MAX(cinfo->Se, 9); coefi++) {
673
1.54M
        if (cinfo->input_scan_number > 1)
674
1.16M
          prev_coef_bit_ptr[coefi] = coef_bit_ptr[coefi];
675
383k
        else
676
383k
          prev_coef_bit_ptr[coefi] = 0;
677
1.54M
      }
678
721k
      for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
679
617k
        int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
680
617k
        if (cinfo->Ah != expected)
681
225k
          WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
682
617k
        coef_bit_ptr[coefi] = cinfo->Al;
683
617k
      }
684
103k
    }
685
    /* Select MCU decoding routine */
686
61.0k
    if (cinfo->Ah == 0) {
687
42.4k
      if (cinfo->Ss == 0)
688
28.4k
        entropy->pub.decode_mcu = decode_mcu_DC_first;
689
14.0k
      else
690
14.0k
        entropy->pub.decode_mcu = decode_mcu_AC_first;
691
42.4k
    } else {
692
18.6k
      if (cinfo->Ss == 0)
693
7.70k
        entropy->pub.decode_mcu = decode_mcu_DC_refine;
694
10.9k
      else
695
10.9k
        entropy->pub.decode_mcu = decode_mcu_AC_refine;
696
18.6k
    }
697
61.0k
  } 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
29.2k
    if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2 - 1 ||
702
29.2k
        cinfo->Ah != 0 || cinfo->Al != 0)
703
27.5k
      WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
704
    /* Select MCU decoding routine */
705
29.2k
    entropy->pub.decode_mcu = decode_mcu;
706
29.2k
  }
707
708
  /* Allocate & initialize requested statistics areas */
709
236k
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
710
145k
    compptr = cinfo->cur_comp_info[ci];
711
145k
    if (!cinfo->progressive_mode || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
712
107k
      tbl = compptr->dc_tbl_no;
713
107k
      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
714
0
        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
715
107k
      if (entropy->dc_stats[tbl] == NULL)
716
27.6k
        entropy->dc_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
717
27.6k
          ((j_common_ptr)cinfo, JPOOL_IMAGE, DC_STAT_BINS);
718
107k
      memset(entropy->dc_stats[tbl], 0, DC_STAT_BINS);
719
      /* Initialize DC predictions to 0 */
720
107k
      entropy->last_dc_val[ci] = 0;
721
107k
      entropy->dc_context[ci] = 0;
722
107k
    }
723
145k
    if (!cinfo->progressive_mode || cinfo->Ss) {
724
67.3k
      tbl = compptr->ac_tbl_no;
725
67.3k
      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
726
0
        ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
727
67.3k
      if (entropy->ac_stats[tbl] == NULL)
728
14.6k
        entropy->ac_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small)
729
14.6k
          ((j_common_ptr)cinfo, JPOOL_IMAGE, AC_STAT_BINS);
730
67.3k
      memset(entropy->ac_stats[tbl], 0, AC_STAT_BINS);
731
67.3k
    }
732
145k
  }
733
734
  /* Initialize arithmetic decoding variables */
735
90.3k
  entropy->c = 0;
736
90.3k
  entropy->a = 0;
737
90.3k
  entropy->ct = -16;    /* force reading 2 initial bytes to fill C */
738
90.3k
  entropy->pub.insufficient_data = FALSE;
739
740
  /* Initialize restart counter */
741
90.3k
  entropy->restarts_to_go = cinfo->restart_interval;
742
90.3k
}
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
23.1k
{
752
23.1k
  arith_entropy_ptr entropy;
753
23.1k
  int i;
754
755
23.1k
  entropy = (arith_entropy_ptr)
756
23.1k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
757
23.1k
                                sizeof(arith_entropy_decoder));
758
23.1k
  cinfo->entropy = (struct jpeg_entropy_decoder *)entropy;
759
23.1k
  entropy->pub.start_pass = start_pass;
760
761
  /* Mark tables unallocated */
762
394k
  for (i = 0; i < NUM_ARITH_TBLS; i++) {
763
371k
    entropy->dc_stats[i] = NULL;
764
371k
    entropy->ac_stats[i] = NULL;
765
371k
  }
766
767
  /* Initialize index for fixed probability estimation */
768
23.1k
  entropy->fixed_bin[0] = 113;
769
770
23.1k
  if (cinfo->progressive_mode) {
771
    /* Create progression status table */
772
19.9k
    int *coef_bit_ptr, ci;
773
19.9k
    cinfo->coef_bits = (int (*)[DCTSIZE2])
774
19.9k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
775
19.9k
                                  cinfo->num_components * 2 * DCTSIZE2 *
776
19.9k
                                  sizeof(int));
777
19.9k
    coef_bit_ptr = &cinfo->coef_bits[0][0];
778
78.9k
    for (ci = 0; ci < cinfo->num_components; ci++)
779
3.83M
      for (i = 0; i < DCTSIZE2; i++)
780
3.77M
        *coef_bit_ptr++ = -1;
781
19.9k
  }
782
23.1k
}