LCOV - app.info - media/libjpeg/jdhuff.c

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-07-07 | 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