← Back to branch summary

~ubuntu-branches/ubuntu/karmic/gears/karmic

« back to all changes in this revision

Viewing changes to third_party/libjpeg/jdhuff.c

  • Committer: Bazaar Package Importer
  • Author(s): Stefan Lesicnik
  • Date: 2009-04-30 19:15:25 UTC
  • Revision ID: james.westby@ubuntu.com-20090430191525-0790sb5wzg8ou0xb
Tags: upstream-0.5.21.0~svn3334+dfsg
Import upstream version 0.5.21.0~svn3334+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
third_party/libjpeg/jdhuff.c
 
1
/*
 
2
 * jdhuff.c
 
3
 *
 
4
 * Copyright (C) 1991-1997, Thomas G. Lane.
 
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 Huffman entropy decoding routines.
 
9
 *
 
10
 * Much of the complexity here has to do with supporting input suspension.
 
11
 * If the data source module demands suspension, we want to be able to back
 
12
 * up to the start of the current MCU.  To do this, we copy state variables
 
13
 * into local working storage, and update them back to the permanent
 
14
 * storage only upon successful completion of an MCU.
 
15
 */
 
16
 
 
17
#define JPEG_INTERNALS
 
18
#include "jinclude.h"
 
19
#include "jpeglib.h"
 
20
#include "jdhuff.h"             /* Declarations shared with jdphuff.c */
 
21
 
 
22
 
 
23
/*
 
24
 * Expanded entropy decoder object for Huffman decoding.
 
25
 *
 
26
 * The savable_state subrecord contains fields that change within an MCU,
 
27
 * but must not be updated permanently until we complete the MCU.
 
28
 */
 
29
 
 
30
typedef struct {
 
31
  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
 
32
} savable_state;
 
33
 
 
34
/* This macro is to work around compilers with missing or broken
 
35
 * structure assignment.  You'll need to fix this code if you have
 
36
 * such a compiler and you change MAX_COMPS_IN_SCAN.
 
37
 */
 
38
 
 
39
#ifndef NO_STRUCT_ASSIGN
 
40
#define ASSIGN_STATE(dest,src)  ((dest) = (src))
 
41
#else
 
42
#if MAX_COMPS_IN_SCAN == 4
 
43
#define ASSIGN_STATE(dest,src)  \
 
44
        ((dest).last_dc_val[0] = (src).last_dc_val[0], \
 
45
         (dest).last_dc_val[1] = (src).last_dc_val[1], \
 
46
         (dest).last_dc_val[2] = (src).last_dc_val[2], \
 
47
         (dest).last_dc_val[3] = (src).last_dc_val[3])
 
48
#endif
 
49
#endif
 
50
 
 
51
 
 
52
typedef struct {
 
53
  struct jpeg_entropy_decoder pub; /* public fields */
 
54
 
 
55
  /* These fields are loaded into local variables at start of each MCU.
 
56
   * In case of suspension, we exit WITHOUT updating them.
 
57
   */
 
58
  bitread_perm_state bitstate;  /* Bit buffer at start of MCU */
 
59
  savable_state saved;          /* Other state at start of MCU */
 
60
 
 
61
  /* These fields are NOT loaded into local working state. */
 
62
  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
 
63
 
 
64
  /* Pointers to derived tables (these workspaces have image lifespan) */
 
65
  d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
 
66
  d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
 
67
 
 
68
  /* Precalculated info set up by start_pass for use in decode_mcu: */
 
69
 
 
70
  /* Pointers to derived tables to be used for each block within an MCU */
 
71
  d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
 
72
  d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
 
73
  /* Whether we care about the DC and AC coefficient values for each block */
 
74
  boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
 
75
  boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
 
76
} huff_entropy_decoder;
 
77
 
 
78
typedef huff_entropy_decoder * huff_entropy_ptr;
 
79
 
 
80
 
 
81
/*
 
82
 * Initialize for a Huffman-compressed scan.
 
83
 */
 
84
 
 
85
METHODDEF(void)
 
86
start_pass_huff_decoder (j_decompress_ptr cinfo)
 
87
{
 
88
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
 
89
  int ci, blkn, dctbl, actbl;
 
90
  jpeg_component_info * compptr;
 
91
 
 
92
  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
 
93
   * This ought to be an error condition, but we make it a warning because
 
94
   * there are some baseline files out there with all zeroes in these bytes.
 
95
   */
 
96
  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
 
97
      cinfo->Ah != 0 || cinfo->Al != 0)
 
98
    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
 
99
 
 
100
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 
101
    compptr = cinfo->cur_comp_info[ci];
 
102
    dctbl = compptr->dc_tbl_no;
 
103
    actbl = compptr->ac_tbl_no;
 
104
    /* Compute derived values for Huffman tables */
 
105
    /* We may do this more than once for a table, but it's not expensive */
 
106
    jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
 
107
                            & entropy->dc_derived_tbls[dctbl]);
 
108
    jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
 
109
                            & entropy->ac_derived_tbls[actbl]);
 
110
    /* Initialize DC predictions to 0 */
 
111
    entropy->saved.last_dc_val[ci] = 0;
 
112
  }
 
113
 
 
114
  /* Precalculate decoding info for each block in an MCU of this scan */
 
115
  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
 
116
    ci = cinfo->MCU_membership[blkn];
 
117
    compptr = cinfo->cur_comp_info[ci];
 
118
    /* Precalculate which table to use for each block */
 
119
    entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
 
120
    entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
 
121
    /* Decide whether we really care about the coefficient values */
 
122
    if (compptr->component_needed) {
 
123
      entropy->dc_needed[blkn] = TRUE;
 
124
      /* we don't need the ACs if producing a 1/8th-size image */
 
125
      entropy->ac_needed[blkn] = (compptr->DCT_scaled_size > 1);
 
126
    } else {
 
127
      entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
 
128
    }
 
129
  }
 
130
 
 
131
  /* Initialize bitread state variables */
 
132
  entropy->bitstate.bits_left = 0;
 
133
  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
 
134
  entropy->pub.insufficient_data = FALSE;
 
135
 
 
136
  /* Initialize restart counter */
 
137
  entropy->restarts_to_go = cinfo->restart_interval;
 
138
}
 
139
 
 
140
 
 
141
/*
 
142
 * Compute the derived values for a Huffman table.
 
143
 * This routine also performs some validation checks on the table.
 
144
 *
 
145
 * Note this is also used by jdphuff.c.
 
146
 */
 
147
 
 
148
GLOBAL(void)
 
149
jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
 
150
                         d_derived_tbl ** pdtbl)
 
151
{
 
152
  JHUFF_TBL *htbl;
 
153
  d_derived_tbl *dtbl;
 
154
  int p, i, l, si, numsymbols;
 
155
  int lookbits, ctr;
 
156
  char huffsize[257];
 
157
  unsigned int huffcode[257];
 
158
  unsigned int code;
 
159
 
 
160
  /* Note that huffsize[] and huffcode[] are filled in code-length order,
 
161
   * paralleling the order of the symbols themselves in htbl->huffval[].
 
162
   */
 
163
 
 
164
  /* Find the input Huffman table */
 
165
  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
 
166
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
 
167
  htbl =
 
168
    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
 
169
  if (htbl == NULL)
 
170
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
 
171
 
 
172
  /* Allocate a workspace if we haven't already done so. */
 
173
  if (*pdtbl == NULL)
 
174
    *pdtbl = (d_derived_tbl *)
 
175
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 
176
                                  SIZEOF(d_derived_tbl));
 
177
  dtbl = *pdtbl;
 
178
  dtbl->pub = htbl;             /* fill in back link */
 
179
  
 
180
  /* Figure C.1: make table of Huffman code length for each symbol */
 
181
 
 
182
  p = 0;
 
183
  for (l = 1; l <= 16; l++) {
 
184
    i = (int) htbl->bits[l];
 
185
    if (i < 0 || p + i > 256)   /* protect against table overrun */
 
186
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
 
187
    while (i--)
 
188
      huffsize[p++] = (char) l;
 
189
  }
 
190
  huffsize[p] = 0;
 
191
  numsymbols = p;
 
192
  
 
193
  /* Figure C.2: generate the codes themselves */
 
194
  /* We also validate that the counts represent a legal Huffman code tree. */
 
195
  
 
196
  code = 0;
 
197
  si = huffsize[0];
 
198
  p = 0;
 
199
  while (huffsize[p]) {
 
200
    while (((int) huffsize[p]) == si) {
 
201
      huffcode[p++] = code;
 
202
      code++;
 
203
    }
 
204
    /* code is now 1 more than the last code used for codelength si; but
 
205
     * it must still fit in si bits, since no code is allowed to be all ones.
 
206
     */
 
207
    if (((INT32) code) >= (((INT32) 1) << si))
 
208
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
 
209
    code <<= 1;
 
210
    si++;
 
211
  }
 
212
 
 
213
  /* Figure F.15: generate decoding tables for bit-sequential decoding */
 
214
 
 
215
  p = 0;
 
216
  for (l = 1; l <= 16; l++) {
 
217
    if (htbl->bits[l]) {
 
218
      /* valoffset[l] = huffval[] index of 1st symbol of code length l,
 
219
       * minus the minimum code of length l
 
220
       */
 
221
      dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
 
222
      p += htbl->bits[l];
 
223
      dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
 
224
    } else {
 
225
      dtbl->maxcode[l] = -1;    /* -1 if no codes of this length */
 
226
    }
 
227
  }
 
228
  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
 
229
 
 
230
  /* Compute lookahead tables to speed up decoding.
 
231
   * First we set all the table entries to 0, indicating "too long";
 
232
   * then we iterate through the Huffman codes that are short enough and
 
233
   * fill in all the entries that correspond to bit sequences starting
 
234
   * with that code.
 
235
   */
 
236
 
 
237
  MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));
 
238
 
 
239
  p = 0;
 
240
  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
 
241
    for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
 
242
      /* l = current code's length, p = its index in huffcode[] & huffval[]. */
 
243
      /* Generate left-justified code followed by all possible bit sequences */
 
244
      lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
 
245
      for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
 
246
        dtbl->look_nbits[lookbits] = l;
 
247
        dtbl->look_sym[lookbits] = htbl->huffval[p];
 
248
        lookbits++;
 
249
      }
 
250
    }
 
251
  }
 
252
 
 
253
  /* Validate symbols as being reasonable.
 
254
   * For AC tables, we make no check, but accept all byte values 0..255.
 
255
   * For DC tables, we require the symbols to be in range 0..15.
 
256
   * (Tighter bounds could be applied depending on the data depth and mode,
 
257
   * but this is sufficient to ensure safe decoding.)
 
258
   */
 
259
  if (isDC) {
 
260
    for (i = 0; i < numsymbols; i++) {
 
261
      int sym = htbl->huffval[i];
 
262
      if (sym < 0 || sym > 15)
 
263
        ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
 
264
    }
 
265
  }
 
266
}
 
267
 
 
268
 
 
269
/*
 
270
 * Out-of-line code for bit fetching (shared with jdphuff.c).
 
271
 * See jdhuff.h for info about usage.
 
272
 * Note: current values of get_buffer and bits_left are passed as parameters,
 
273
 * but are returned in the corresponding fields of the state struct.
 
274
 *
 
275
 * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
 
276
 * of get_buffer to be used.  (On machines with wider words, an even larger
 
277
 * buffer could be used.)  However, on some machines 32-bit shifts are
 
278
 * quite slow and take time proportional to the number of places shifted.
 
279
 * (This is true with most PC compilers, for instance.)  In this case it may
 
280
 * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
 
281
 * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
 
282
 */
 
283
 
 
284
#ifdef SLOW_SHIFT_32
 
285
#define MIN_GET_BITS  15        /* minimum allowable value */
 
286
#else
 
287
#define MIN_GET_BITS  (BIT_BUF_SIZE-7)
 
288
#endif
 
289
 
 
290
 
 
291
GLOBAL(boolean)
 
292
jpeg_fill_bit_buffer (bitread_working_state * state,
 
293
                      register bit_buf_type get_buffer, register int bits_left,
 
294
                      int nbits)
 
295
/* Load up the bit buffer to a depth of at least nbits */
 
296
{
 
297
  /* Copy heavily used state fields into locals (hopefully registers) */
 
298
  register const JOCTET * next_input_byte = state->next_input_byte;
 
299
  register size_t bytes_in_buffer = state->bytes_in_buffer;
 
300
  j_decompress_ptr cinfo = state->cinfo;
 
301
 
 
302
  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
 
303
  /* (It is assumed that no request will be for more than that many bits.) */
 
304
  /* We fail to do so only if we hit a marker or are forced to suspend. */
 
305
 
 
306
  if (cinfo->unread_marker == 0) {      /* cannot advance past a marker */
 
307
    while (bits_left < MIN_GET_BITS) {
 
308
      register int c;
 
309
 
 
310
      /* Attempt to read a byte */
 
311
      if (bytes_in_buffer == 0) {
 
312
        if (! (*cinfo->src->fill_input_buffer) (cinfo))
 
313
          return FALSE;
 
314
        next_input_byte = cinfo->src->next_input_byte;
 
315
        bytes_in_buffer = cinfo->src->bytes_in_buffer;
 
316
      }
 
317
      bytes_in_buffer--;
 
318
      c = GETJOCTET(*next_input_byte++);
 
319
 
 
320
      /* If it's 0xFF, check and discard stuffed zero byte */
 
321
      if (c == 0xFF) {
 
322
        /* Loop here to discard any padding FF's on terminating marker,
 
323
         * so that we can save a valid unread_marker value.  NOTE: we will
 
324
         * accept multiple FF's followed by a 0 as meaning a single FF data
 
325
         * byte.  This data pattern is not valid according to the standard.
 
326
         */
 
327
        do {
 
328
          if (bytes_in_buffer == 0) {
 
329
            if (! (*cinfo->src->fill_input_buffer) (cinfo))
 
330
              return FALSE;
 
331
            next_input_byte = cinfo->src->next_input_byte;
 
332
            bytes_in_buffer = cinfo->src->bytes_in_buffer;
 
333
          }
 
334
          bytes_in_buffer--;
 
335
          c = GETJOCTET(*next_input_byte++);
 
336
        } while (c == 0xFF);
 
337
 
 
338
        if (c == 0) {
 
339
          /* Found FF/00, which represents an FF data byte */
 
340
          c = 0xFF;
 
341
        } else {
 
342
          /* Oops, it's actually a marker indicating end of compressed data.
 
343
           * Save the marker code for later use.
 
344
           * Fine point: it might appear that we should save the marker into
 
345
           * bitread working state, not straight into permanent state.  But
 
346
           * once we have hit a marker, we cannot need to suspend within the
 
347
           * current MCU, because we will read no more bytes from the data
 
348
           * source.  So it is OK to update permanent state right away.
 
349
           */
 
350
          cinfo->unread_marker = c;
 
351
          /* See if we need to insert some fake zero bits. */
 
352
          goto no_more_bytes;
 
353
        }
 
354
      }
 
355
 
 
356
      /* OK, load c into get_buffer */
 
357
      get_buffer = (get_buffer << 8) | c;
 
358
      bits_left += 8;
 
359
    } /* end while */
 
360
  } else {
 
361
  no_more_bytes:
 
362
    /* We get here if we've read the marker that terminates the compressed
 
363
     * data segment.  There should be enough bits in the buffer register
 
364
     * to satisfy the request; if so, no problem.
 
365
     */
 
366
    if (nbits > bits_left) {
 
367
      /* Uh-oh.  Report corrupted data to user and stuff zeroes into
 
368
       * the data stream, so that we can produce some kind of image.
 
369
       * We use a nonvolatile flag to ensure that only one warning message
 
370
       * appears per data segment.
 
371
       */
 
372
      if (! cinfo->entropy->insufficient_data) {
 
373
        WARNMS(cinfo, JWRN_HIT_MARKER);
 
374
        cinfo->entropy->insufficient_data = TRUE;
 
375
      }
 
376
      /* Fill the buffer with zero bits */
 
377
      get_buffer <<= MIN_GET_BITS - bits_left;
 
378
      bits_left = MIN_GET_BITS;
 
379
    }
 
380
  }
 
381
 
 
382
  /* Unload the local registers */
 
383
  state->next_input_byte = next_input_byte;
 
384
  state->bytes_in_buffer = bytes_in_buffer;
 
385
  state->get_buffer = get_buffer;
 
386
  state->bits_left = bits_left;
 
387
 
 
388
  return TRUE;
 
389
}
 
390
 
 
391
 
 
392
/*
 
393
 * Out-of-line code for Huffman code decoding.
 
394
 * See jdhuff.h for info about usage.
 
395
 */
 
396
 
 
397
GLOBAL(int)
 
398
jpeg_huff_decode (bitread_working_state * state,
 
399
                  register bit_buf_type get_buffer, register int bits_left,
 
400
                  d_derived_tbl * htbl, int min_bits)
 
401
{
 
402
  register int l = min_bits;
 
403
  register INT32 code;
 
404
 
 
405
  /* HUFF_DECODE has determined that the code is at least min_bits */
 
406
  /* bits long, so fetch that many bits in one swoop. */
 
407
 
 
408
  CHECK_BIT_BUFFER(*state, l, return -1);
 
409
  code = GET_BITS(l);
 
410
 
 
411
  /* Collect the rest of the Huffman code one bit at a time. */
 
412
  /* This is per Figure F.16 in the JPEG spec. */
 
413
 
 
414
  while (code > htbl->maxcode[l]) {
 
415
    code <<= 1;
 
416
    CHECK_BIT_BUFFER(*state, 1, return -1);
 
417
    code |= GET_BITS(1);
 
418
    l++;
 
419
  }
 
420
 
 
421
  /* Unload the local registers */
 
422
  state->get_buffer = get_buffer;
 
423
  state->bits_left = bits_left;
 
424
 
 
425
  /* With garbage input we may reach the sentinel value l = 17. */
 
426
 
 
427
  if (l > 16) {
 
428
    WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
 
429
    return 0;                   /* fake a zero as the safest result */
 
430
  }
 
431
 
 
432
  return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
 
433
}
 
434
 
 
435
 
 
436
/*
 
437
 * Figure F.12: extend sign bit.
 
438
 * On some machines, a shift and add will be faster than a table lookup.
 
439
 */
 
440
 
 
441
#ifdef AVOID_TABLES
 
442
 
 
443
#define HUFF_EXTEND(x,s)  ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
 
444
 
 
445
#else
 
446
 
 
447
#define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
 
448
 
 
449
static const int extend_test[16] =   /* entry n is 2**(n-1) */
 
450
  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
 
451
    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
 
452
 
 
453
static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
 
454
  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
 
455
    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
 
456
    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
 
457
    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
 
458
 
 
459
#endif /* AVOID_TABLES */
 
460
 
 
461
 
 
462
/*
 
463
 * Check for a restart marker & resynchronize decoder.
 
464
 * Returns FALSE if must suspend.
 
465
 */
 
466
 
 
467
LOCAL(boolean)
 
468
process_restart (j_decompress_ptr cinfo)
 
469
{
 
470
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
 
471
  int ci;
 
472
 
 
473
  /* Throw away any unused bits remaining in bit buffer; */
 
474
  /* include any full bytes in next_marker's count of discarded bytes */
 
475
  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
 
476
  entropy->bitstate.bits_left = 0;
 
477
 
 
478
  /* Advance past the RSTn marker */
 
479
  if (! (*cinfo->marker->read_restart_marker) (cinfo))
 
480
    return FALSE;
 
481
 
 
482
  /* Re-initialize DC predictions to 0 */
 
483
  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
 
484
    entropy->saved.last_dc_val[ci] = 0;
 
485
 
 
486
  /* Reset restart counter */
 
487
  entropy->restarts_to_go = cinfo->restart_interval;
 
488
 
 
489
  /* Reset out-of-data flag, unless read_restart_marker left us smack up
 
490
   * against a marker.  In that case we will end up treating the next data
 
491
   * segment as empty, and we can avoid producing bogus output pixels by
 
492
   * leaving the flag set.
 
493
   */
 
494
  if (cinfo->unread_marker == 0)
 
495
    entropy->pub.insufficient_data = FALSE;
 
496
 
 
497
  return TRUE;
 
498
}
 
499
 
 
500
 
 
501
/*
 
502
 * Decode and return one MCU's worth of Huffman-compressed coefficients.
 
503
 * The coefficients are reordered from zigzag order into natural array order,
 
504
 * but are not dequantized.
 
505
 *
 
506
 * The i'th block of the MCU is stored into the block pointed to by
 
507
 * MCU_data[i].  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
 
508
 * (Wholesale zeroing is usually a little faster than retail...)
 
509
 *
 
510
 * Returns FALSE if data source requested suspension.  In that case no
 
511
 * changes have been made to permanent state.  (Exception: some output
 
512
 * coefficients may already have been assigned.  This is harmless for
 
513
 * this module, since we'll just re-assign them on the next call.)
 
514
 */
 
515
 
 
516
METHODDEF(boolean)
 
517
decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
518
{
 
519
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
 
520
  int blkn;
 
521
  BITREAD_STATE_VARS;
 
522
  savable_state state;
 
523
 
 
524
  /* Process restart marker if needed; may have to suspend */
 
525
  if (cinfo->restart_interval) {
 
526
    if (entropy->restarts_to_go == 0)
 
527
      if (! process_restart(cinfo))
 
528
        return FALSE;
 
529
  }
 
530
 
 
531
  /* If we've run out of data, just leave the MCU set to zeroes.
 
532
   * This way, we return uniform gray for the remainder of the segment.
 
533
   */
 
534
  if (! entropy->pub.insufficient_data) {
 
535
 
 
536
    /* Load up working state */
 
537
    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
 
538
    ASSIGN_STATE(state, entropy->saved);
 
539
 
 
540
    /* Outer loop handles each block in the MCU */
 
541
 
 
542
    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
 
543
      JBLOCKROW block = MCU_data[blkn];
 
544
      d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
 
545
      d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
 
546
      register int s, k, r;
 
547
 
 
548
      /* Decode a single block's worth of coefficients */
 
549
 
 
550
      /* Section F.2.2.1: decode the DC coefficient difference */
 
551
      HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
 
552
      if (s) {
 
553
        CHECK_BIT_BUFFER(br_state, s, return FALSE);
 
554
        r = GET_BITS(s);
 
555
        s = HUFF_EXTEND(r, s);
 
556
      }
 
557
 
 
558
      if (entropy->dc_needed[blkn]) {
 
559
        /* Convert DC difference to actual value, update last_dc_val */
 
560
        int ci = cinfo->MCU_membership[blkn];
 
561
        s += state.last_dc_val[ci];
 
562
        state.last_dc_val[ci] = s;
 
563
        /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
 
564
        (*block)[0] = (JCOEF) s;
 
565
      }
 
566
 
 
567
      if (entropy->ac_needed[blkn]) {
 
568
 
 
569
        /* Section F.2.2.2: decode the AC coefficients */
 
570
        /* Since zeroes are skipped, output area must be cleared beforehand */
 
571
        for (k = 1; k < DCTSIZE2; k++) {
 
572
          HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
 
573
      
 
574
          r = s >> 4;
 
575
          s &= 15;
 
576
      
 
577
          if (s) {
 
578
            k += r;
 
579
            CHECK_BIT_BUFFER(br_state, s, return FALSE);
 
580
            r = GET_BITS(s);
 
581
            s = HUFF_EXTEND(r, s);
 
582
            /* Output coefficient in natural (dezigzagged) order.
 
583
             * Note: the extra entries in jpeg_natural_order[] will save us
 
584
             * if k >= DCTSIZE2, which could happen if the data is corrupted.
 
585
             */
 
586
            (*block)[jpeg_natural_order[k]] = (JCOEF) s;
 
587
          } else {
 
588
            if (r != 15)
 
589
              break;
 
590
            k += 15;
 
591
          }
 
592
        }
 
593
 
 
594
      } else {
 
595
 
 
596
        /* Section F.2.2.2: decode the AC coefficients */
 
597
        /* In this path we just discard the values */
 
598
        for (k = 1; k < DCTSIZE2; k++) {
 
599
          HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
 
600
      
 
601
          r = s >> 4;
 
602
          s &= 15;
 
603
      
 
604
          if (s) {
 
605
            k += r;
 
606
            CHECK_BIT_BUFFER(br_state, s, return FALSE);
 
607
            DROP_BITS(s);
 
608
          } else {
 
609
            if (r != 15)
 
610
              break;
 
611
            k += 15;
 
612
          }
 
613
        }
 
614
 
 
615
      }
 
616
    }
 
617
 
 
618
    /* Completed MCU, so update state */
 
619
    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
 
620
    ASSIGN_STATE(entropy->saved, state);
 
621
  }
 
622
 
 
623
  /* Account for restart interval (no-op if not using restarts) */
 
624
  entropy->restarts_to_go--;
 
625
 
 
626
  return TRUE;
 
627
}
 
628
 
 
629
 
 
630
/*
 
631
 * Module initialization routine for Huffman entropy decoding.
 
632
 */
 
633
 
 
634
GLOBAL(void)
 
635
jinit_huff_decoder (j_decompress_ptr cinfo)
 
636
{
 
637
  huff_entropy_ptr entropy;
 
638
  int i;
 
639
 
 
640
  entropy = (huff_entropy_ptr)
 
641
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 
642
                                SIZEOF(huff_entropy_decoder));
 
643
  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
 
644
  entropy->pub.start_pass = start_pass_huff_decoder;
 
645
  entropy->pub.decode_mcu = decode_mcu;
 
646
 
 
647
  /* Mark tables unallocated */
 
648
  for (i = 0; i < NUM_HUFF_TBLS; i++) {
 
649
    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
 
650
  }
 
651
}