LCOV - code coverage report
Current view: directory - media/libjpeg - jdhuff.c (source / functions) Found Hit Coverage
Test: app.info Lines: 272 216 79.4 %
Date: 2012-06-02 Functions: 9 8 88.9 %

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

Generated by: LCOV version 1.7