jdphuff.c File Reference

#include "jinclude.h"
#include "jpeglib.h"
#include "jdhuff.h"

Go to the source code of this file.

Data Structures

struct  phuff_entropy_decoder
struct  savable_state

Defines

#define ASSIGN_STATE(dest, src)   ((dest) = (src))
#define HUFF_EXTEND(x, s)   ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
#define JPEG_INTERNALS

Typedefs

typedef phuff_entropy_decoderphuff_entropy_ptr

Functions

 decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 jinit_phuff_decoder (j_decompress_ptr cinfo)
 METHODDEF (boolean)
 process_restart (j_decompress_ptr cinfo)

Variables

static const int extend_offset [16]
static const int extend_test [16]


Define Documentation

#define ASSIGN_STATE ( dest,
src   )     ((dest) = (src))

Definition at line 43 of file jdphuff.c.

#define HUFF_EXTEND ( x,
 )     ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))

Definition at line 207 of file jdphuff.c.

#define JPEG_INTERNALS

Definition at line 17 of file jdphuff.c.


Typedef Documentation

Definition at line 74 of file jdphuff.c.


Function Documentation

decode_mcu_AC_first ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 357 of file jdphuff.c.

References phuff_entropy_decoder::ac_derived_tbl, BITREAD_LOAD_STATE, BITREAD_SAVE_STATE, BITREAD_STATE_VARS, phuff_entropy_decoder::bitstate, CHECK_BIT_BUFFER, savable_state::EOBRUN, FALSE, GET_BITS, HUFF_DECODE, HUFF_EXTEND, jpeg_entropy_decoder::insufficient_data, jpeg_natural_order, process_restart(), phuff_entropy_decoder::pub, phuff_entropy_decoder::restarts_to_go, phuff_entropy_decoder::saved, and TRUE.

Referenced by METHODDEF().

00358 {   
00359   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
00360   int Se = cinfo->Se;
00361   int Al = cinfo->Al;
00362   register int s, k, r;
00363   unsigned int EOBRUN;
00364   JBLOCKROW block;
00365   BITREAD_STATE_VARS;
00366   d_derived_tbl * tbl;
00367 
00368   /* Process restart marker if needed; may have to suspend */
00369   if (cinfo->restart_interval) {
00370     if (entropy->restarts_to_go == 0)
00371       if (! process_restart(cinfo))
00372     return FALSE;
00373   }
00374 
00375   /* If we've run out of data, just leave the MCU set to zeroes.
00376    * This way, we return uniform gray for the remainder of the segment.
00377    */
00378   if (! entropy->pub.insufficient_data) {
00379 
00380     /* Load up working state.
00381      * We can avoid loading/saving bitread state if in an EOB run.
00382      */
00383     EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
00384 
00385     /* There is always only one block per MCU */
00386 
00387     if (EOBRUN > 0)     /* if it's a band of zeroes... */
00388       EOBRUN--;         /* ...process it now (we do nothing) */
00389     else {
00390       BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
00391       block = MCU_data[0];
00392       tbl = entropy->ac_derived_tbl;
00393 
00394       for (k = cinfo->Ss; k <= Se; k++) {
00395     HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
00396     r = s >> 4;
00397     s &= 15;
00398     if (s) {
00399       k += r;
00400       CHECK_BIT_BUFFER(br_state, s, return FALSE);
00401       r = GET_BITS(s);
00402       s = HUFF_EXTEND(r, s);
00403       /* Scale and output coefficient in natural (dezigzagged) order */
00404       (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al);
00405     } else {
00406       if (r == 15) {    /* ZRL */
00407         k += 15;        /* skip 15 zeroes in band */
00408       } else {      /* EOBr, run length is 2^r + appended bits */
00409         EOBRUN = 1 << r;
00410         if (r) {        /* EOBr, r > 0 */
00411           CHECK_BIT_BUFFER(br_state, r, return FALSE);
00412           r = GET_BITS(r);
00413           EOBRUN += r;
00414         }
00415         EOBRUN--;       /* this band is processed at this moment */
00416         break;      /* force end-of-band */
00417       }
00418     }
00419       }
00420 
00421       BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
00422     }
00423 
00424     /* Completed MCU, so update state */
00425     entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
00426   }
00427 
00428   /* Account for restart interval (no-op if not using restarts) */
00429   entropy->restarts_to_go--;
00430 
00431   return TRUE;
00432 }

decode_mcu_AC_refine ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 491 of file jdphuff.c.

References phuff_entropy_decoder::ac_derived_tbl, BITREAD_LOAD_STATE, BITREAD_SAVE_STATE, BITREAD_STATE_VARS, phuff_entropy_decoder::bitstate, CHECK_BIT_BUFFER, DCTSIZE2, savable_state::EOBRUN, FALSE, GET_BITS, HUFF_DECODE, jpeg_entropy_decoder::insufficient_data, jpeg_natural_order, process_restart(), phuff_entropy_decoder::pub, phuff_entropy_decoder::restarts_to_go, phuff_entropy_decoder::saved, TRUE, and WARNMS.

Referenced by METHODDEF().

00492 {   
00493   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
00494   int Se = cinfo->Se;
00495   int p1 = 1 << cinfo->Al;  /* 1 in the bit position being coded */
00496   int m1 = (-1) << cinfo->Al;   /* -1 in the bit position being coded */
00497   register int s, k, r;
00498   unsigned int EOBRUN;
00499   JBLOCKROW block;
00500   JCOEFPTR thiscoef;
00501   BITREAD_STATE_VARS;
00502   d_derived_tbl * tbl;
00503   int num_newnz;
00504   int newnz_pos[DCTSIZE2];
00505 
00506   /* Process restart marker if needed; may have to suspend */
00507   if (cinfo->restart_interval) {
00508     if (entropy->restarts_to_go == 0)
00509       if (! process_restart(cinfo))
00510     return FALSE;
00511   }
00512 
00513   /* If we've run out of data, don't modify the MCU.
00514    */
00515   if (! entropy->pub.insufficient_data) {
00516 
00517     /* Load up working state */
00518     BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
00519     EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
00520 
00521     /* There is always only one block per MCU */
00522     block = MCU_data[0];
00523     tbl = entropy->ac_derived_tbl;
00524 
00525     /* If we are forced to suspend, we must undo the assignments to any newly
00526      * nonzero coefficients in the block, because otherwise we'd get confused
00527      * next time about which coefficients were already nonzero.
00528      * But we need not undo addition of bits to already-nonzero coefficients;
00529      * instead, we can test the current bit to see if we already did it.
00530      */
00531     num_newnz = 0;
00532 
00533     /* initialize coefficient loop counter to start of band */
00534     k = cinfo->Ss;
00535 
00536     if (EOBRUN == 0) {
00537       for (; k <= Se; k++) {
00538     HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
00539     r = s >> 4;
00540     s &= 15;
00541     if (s) {
00542       if (s != 1)       /* size of new coef should always be 1 */
00543         WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
00544       CHECK_BIT_BUFFER(br_state, 1, goto undoit);
00545       if (GET_BITS(1))
00546         s = p1;     /* newly nonzero coef is positive */
00547       else
00548         s = m1;     /* newly nonzero coef is negative */
00549     } else {
00550       if (r != 15) {
00551         EOBRUN = 1 << r;    /* EOBr, run length is 2^r + appended bits */
00552         if (r) {
00553           CHECK_BIT_BUFFER(br_state, r, goto undoit);
00554           r = GET_BITS(r);
00555           EOBRUN += r;
00556         }
00557         break;      /* rest of block is handled by EOB logic */
00558       }
00559       /* note s = 0 for processing ZRL */
00560     }
00561     /* Advance over already-nonzero coefs and r still-zero coefs,
00562      * appending correction bits to the nonzeroes.  A correction bit is 1
00563      * if the absolute value of the coefficient must be increased.
00564      */
00565     do {
00566       thiscoef = *block + jpeg_natural_order[k];
00567       if (*thiscoef != 0) {
00568         CHECK_BIT_BUFFER(br_state, 1, goto undoit);
00569         if (GET_BITS(1)) {
00570           if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
00571         if (*thiscoef >= 0)
00572           *thiscoef += p1;
00573         else
00574           *thiscoef += m1;
00575           }
00576         }
00577       } else {
00578         if (--r < 0)
00579           break;        /* reached target zero coefficient */
00580       }
00581       k++;
00582     } while (k <= Se);
00583     if (s) {
00584       int pos = jpeg_natural_order[k];
00585       /* Output newly nonzero coefficient */
00586       (*block)[pos] = (JCOEF) s;
00587       /* Remember its position in case we have to suspend */
00588       newnz_pos[num_newnz++] = pos;
00589     }
00590       }
00591     }
00592 
00593     if (EOBRUN > 0) {
00594       /* Scan any remaining coefficient positions after the end-of-band
00595        * (the last newly nonzero coefficient, if any).  Append a correction
00596        * bit to each already-nonzero coefficient.  A correction bit is 1
00597        * if the absolute value of the coefficient must be increased.
00598        */
00599       for (; k <= Se; k++) {
00600     thiscoef = *block + jpeg_natural_order[k];
00601     if (*thiscoef != 0) {
00602       CHECK_BIT_BUFFER(br_state, 1, goto undoit);
00603       if (GET_BITS(1)) {
00604         if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
00605           if (*thiscoef >= 0)
00606         *thiscoef += p1;
00607           else
00608         *thiscoef += m1;
00609         }
00610       }
00611     }
00612       }
00613       /* Count one block completed in EOB run */
00614       EOBRUN--;
00615     }
00616 
00617     /* Completed MCU, so update state */
00618     BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
00619     entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
00620   }
00621 
00622   /* Account for restart interval (no-op if not using restarts) */
00623   entropy->restarts_to_go--;
00624 
00625   return TRUE;
00626 
00627 undoit:
00628   /* Re-zero any output coefficients that we made newly nonzero */
00629   while (num_newnz > 0)
00630     (*block)[newnz_pos[--num_newnz]] = 0;
00631 
00632   return FALSE;
00633 }

decode_mcu_DC_first ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 286 of file jdphuff.c.

References ASSIGN_STATE, BITREAD_LOAD_STATE, BITREAD_SAVE_STATE, BITREAD_STATE_VARS, phuff_entropy_decoder::bitstate, CHECK_BIT_BUFFER, compptr, jpeg_component_info::dc_tbl_no, phuff_entropy_decoder::derived_tbls, FALSE, GET_BITS, HUFF_DECODE, HUFF_EXTEND, jpeg_entropy_decoder::insufficient_data, process_restart(), phuff_entropy_decoder::pub, phuff_entropy_decoder::restarts_to_go, phuff_entropy_decoder::saved, and TRUE.

Referenced by METHODDEF().

00287 {   
00288   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
00289   int Al = cinfo->Al;
00290   register int s, r;
00291   int blkn, ci;
00292   JBLOCKROW block;
00293   BITREAD_STATE_VARS;
00294   savable_state state;
00295   d_derived_tbl * tbl;
00296   jpeg_component_info * compptr;
00297 
00298   /* Process restart marker if needed; may have to suspend */
00299   if (cinfo->restart_interval) {
00300     if (entropy->restarts_to_go == 0)
00301       if (! process_restart(cinfo))
00302     return FALSE;
00303   }
00304 
00305   /* If we've run out of data, just leave the MCU set to zeroes.
00306    * This way, we return uniform gray for the remainder of the segment.
00307    */
00308   if (! entropy->pub.insufficient_data) {
00309 
00310     /* Load up working state */
00311     BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
00312     ASSIGN_STATE(state, entropy->saved);
00313 
00314     /* Outer loop handles each block in the MCU */
00315 
00316     for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
00317       block = MCU_data[blkn];
00318       ci = cinfo->MCU_membership[blkn];
00319       compptr = cinfo->cur_comp_info[ci];
00320       tbl = entropy->derived_tbls[compptr->dc_tbl_no];
00321 
00322       /* Decode a single block's worth of coefficients */
00323 
00324       /* Section F.2.2.1: decode the DC coefficient difference */
00325       HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
00326       if (s) {
00327     CHECK_BIT_BUFFER(br_state, s, return FALSE);
00328     r = GET_BITS(s);
00329     s = HUFF_EXTEND(r, s);
00330       }
00331 
00332       /* Convert DC difference to actual value, update last_dc_val */
00333       s += state.last_dc_val[ci];
00334       state.last_dc_val[ci] = s;
00335       /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */
00336       (*block)[0] = (JCOEF) (s << Al);
00337     }
00338 
00339     /* Completed MCU, so update state */
00340     BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
00341     ASSIGN_STATE(entropy->saved, state);
00342   }
00343 
00344   /* Account for restart interval (no-op if not using restarts) */
00345   entropy->restarts_to_go--;
00346 
00347   return TRUE;
00348 }

decode_mcu_DC_refine ( j_decompress_ptr  cinfo,
JBLOCKROW MCU_data 
)

Definition at line 442 of file jdphuff.c.

References BITREAD_LOAD_STATE, BITREAD_SAVE_STATE, BITREAD_STATE_VARS, phuff_entropy_decoder::bitstate, CHECK_BIT_BUFFER, FALSE, GET_BITS, process_restart(), phuff_entropy_decoder::restarts_to_go, and TRUE.

Referenced by METHODDEF().

00443 {   
00444   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
00445   int p1 = 1 << cinfo->Al;  /* 1 in the bit position being coded */
00446   int blkn;
00447   JBLOCKROW block;
00448   BITREAD_STATE_VARS;
00449 
00450   /* Process restart marker if needed; may have to suspend */
00451   if (cinfo->restart_interval) {
00452     if (entropy->restarts_to_go == 0)
00453       if (! process_restart(cinfo))
00454     return FALSE;
00455   }
00456 
00457   /* Not worth the cycles to check insufficient_data here,
00458    * since we will not change the data anyway if we read zeroes.
00459    */
00460 
00461   /* Load up working state */
00462   BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
00463 
00464   /* Outer loop handles each block in the MCU */
00465 
00466   for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
00467     block = MCU_data[blkn];
00468 
00469     /* Encoded data is simply the next bit of the two's-complement DC value */
00470     CHECK_BIT_BUFFER(br_state, 1, return FALSE);
00471     if (GET_BITS(1))
00472       (*block)[0] |= p1;
00473     /* Note: since we use |=, repeating the assignment later is safe */
00474   }
00475 
00476   /* Completed MCU, so update state */
00477   BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
00478 
00479   /* Account for restart interval (no-op if not using restarts) */
00480   entropy->restarts_to_go--;
00481 
00482   return TRUE;
00483 }

jinit_phuff_decoder ( j_decompress_ptr  cinfo  ) 

Definition at line 641 of file jdphuff.c.

References DCTSIZE2, phuff_entropy_decoder::derived_tbls, JPOOL_IMAGE, NUM_HUFF_TBLS, phuff_entropy_decoder::pub, and SIZEOF.

Referenced by master_selection(), and transdecode_master_selection().

00642 {
00643   phuff_entropy_ptr entropy;
00644   int *coef_bit_ptr;
00645   int ci, i;
00646 
00647   entropy = (phuff_entropy_ptr)
00648     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
00649                 SIZEOF(phuff_entropy_decoder));
00650   cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
00651   entropy->pub.start_pass = start_pass_phuff_decoder;
00652 
00653   /* Mark derived tables unallocated */
00654   for (i = 0; i < NUM_HUFF_TBLS; i++) {
00655     entropy->derived_tbls[i] = NULL;
00656   }
00657 
00658   /* Create progression status table */
00659   cinfo->coef_bits = (int (*)[DCTSIZE2])
00660     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
00661                 cinfo->num_components*DCTSIZE2*SIZEOF(int));
00662   coef_bit_ptr = & cinfo->coef_bits[0][0];
00663   for (ci = 0; ci < cinfo->num_components; ci++) 
00664     for (i = 0; i < DCTSIZE2; i++)
00665       *coef_bit_ptr++ = -1;
00666 }

METHODDEF ( boolean   ) 

Definition at line 77 of file jdphuff.c.

References phuff_entropy_decoder::ac_derived_tbl, jpeg_component_info::ac_tbl_no, bitread_perm_state::bits_left, phuff_entropy_decoder::bitstate, compptr, jpeg_component_info::dc_tbl_no, DCTSIZE2, decode_mcu_AC_first(), decode_mcu_AC_refine(), decode_mcu_DC_first(), decode_mcu_DC_refine(), phuff_entropy_decoder::derived_tbls, savable_state::EOBRUN, ERREXIT4, FALSE, bitread_perm_state::get_buffer, jpeg_entropy_decoder::insufficient_data, jpeg_make_d_derived_tbl(), savable_state::last_dc_val, phuff_entropy_decoder::pub, phuff_entropy_decoder::restarts_to_go, phuff_entropy_decoder::saved, TRUE, and WARNMS2.

00093 {
00094   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
00095   boolean is_DC_band, bad;
00096   int ci, coefi, tbl;
00097   int *coef_bit_ptr;
00098   jpeg_component_info * compptr;
00099 
00100   is_DC_band = (cinfo->Ss == 0);
00101 
00102   /* Validate scan parameters */
00103   bad = FALSE;
00104   if (is_DC_band) {
00105     if (cinfo->Se != 0)
00106       bad = TRUE;
00107   } else {
00108     /* need not check Ss/Se < 0 since they came from unsigned bytes */
00109     if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2)
00110       bad = TRUE;
00111     /* AC scans may have only one component */
00112     if (cinfo->comps_in_scan != 1)
00113       bad = TRUE;
00114   }
00115   if (cinfo->Ah != 0) {
00116     /* Successive approximation refinement scan: must have Al = Ah-1. */
00117     if (cinfo->Al != cinfo->Ah-1)
00118       bad = TRUE;
00119   }
00120   if (cinfo->Al > 13)       /* need not check for < 0 */
00121     bad = TRUE;
00122   /* Arguably the maximum Al value should be less than 13 for 8-bit precision,
00123    * but the spec doesn't say so, and we try to be liberal about what we
00124    * accept.  Note: large Al values could result in out-of-range DC
00125    * coefficients during early scans, leading to bizarre displays due to
00126    * overflows in the IDCT math.  But we won't crash.
00127    */
00128   if (bad)
00129     ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
00130          cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
00131   /* Update progression status, and verify that scan order is legal.
00132    * Note that inter-scan inconsistencies are treated as warnings
00133    * not fatal errors ... not clear if this is right way to behave.
00134    */
00135   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
00136     int cindex = cinfo->cur_comp_info[ci]->component_index;
00137     coef_bit_ptr = & cinfo->coef_bits[cindex][0];
00138     if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
00139       WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
00140     for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
00141       int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
00142       if (cinfo->Ah != expected)
00143     WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
00144       coef_bit_ptr[coefi] = cinfo->Al;
00145     }
00146   }
00147 
00148   /* Select MCU decoding routine */
00149   if (cinfo->Ah == 0) {
00150     if (is_DC_band)
00151       entropy->pub.decode_mcu = decode_mcu_DC_first;
00152     else
00153       entropy->pub.decode_mcu = decode_mcu_AC_first;
00154   } else {
00155     if (is_DC_band)
00156       entropy->pub.decode_mcu = decode_mcu_DC_refine;
00157     else
00158       entropy->pub.decode_mcu = decode_mcu_AC_refine;
00159   }
00160 
00161   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
00162     compptr = cinfo->cur_comp_info[ci];
00163     /* Make sure requested tables are present, and compute derived tables.
00164      * We may build same derived table more than once, but it's not expensive.
00165      */
00166     if (is_DC_band) {
00167       if (cinfo->Ah == 0) { /* DC refinement needs no table */
00168     tbl = compptr->dc_tbl_no;
00169     jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
00170                 & entropy->derived_tbls[tbl]);
00171       }
00172     } else {
00173       tbl = compptr->ac_tbl_no;
00174       jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
00175                   & entropy->derived_tbls[tbl]);
00176       /* remember the single active table */
00177       entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
00178     }
00179     /* Initialize DC predictions to 0 */
00180     entropy->saved.last_dc_val[ci] = 0;
00181   }
00182 
00183   /* Initialize bitread state variables */
00184   entropy->bitstate.bits_left = 0;
00185   entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
00186   entropy->pub.insufficient_data = FALSE;
00187 
00188   /* Initialize private state variables */
00189   entropy->saved.EOBRUN = 0;
00190 
00191   /* Initialize restart counter */
00192   entropy->restarts_to_go = cinfo->restart_interval;
00193 }

process_restart ( j_decompress_ptr  cinfo  ) 

Definition at line 228 of file jdphuff.c.

References bitread_perm_state::bits_left, phuff_entropy_decoder::bitstate, savable_state::EOBRUN, FALSE, jpeg_entropy_decoder::insufficient_data, savable_state::last_dc_val, phuff_entropy_decoder::pub, phuff_entropy_decoder::restarts_to_go, phuff_entropy_decoder::saved, and TRUE.

00229 {
00230   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
00231   int ci;
00232 
00233   /* Throw away any unused bits remaining in bit buffer; */
00234   /* include any full bytes in next_marker's count of discarded bytes */
00235   cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
00236   entropy->bitstate.bits_left = 0;
00237 
00238   /* Advance past the RSTn marker */
00239   if (! (*cinfo->marker->read_restart_marker) (cinfo))
00240     return FALSE;
00241 
00242   /* Re-initialize DC predictions to 0 */
00243   for (ci = 0; ci < cinfo->comps_in_scan; ci++)
00244     entropy->saved.last_dc_val[ci] = 0;
00245   /* Re-init EOB run count, too */
00246   entropy->saved.EOBRUN = 0;
00247 
00248   /* Reset restart counter */
00249   entropy->restarts_to_go = cinfo->restart_interval;
00250 
00251   /* Reset out-of-data flag, unless read_restart_marker left us smack up
00252    * against a marker.  In that case we will end up treating the next data
00253    * segment as empty, and we can avoid producing bogus output pixels by
00254    * leaving the flag set.
00255    */
00256   if (cinfo->unread_marker == 0)
00257     entropy->pub.insufficient_data = FALSE;
00258 
00259   return TRUE;
00260 }


Variable Documentation

const int extend_offset[16] [static]

Initial value:

 
  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 }

Definition at line 213 of file jdphuff.c.

const int extend_test[16] [static]

Initial value:

   
  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 }

Definition at line 209 of file jdphuff.c.


Generated on Fri Feb 19 02:31:03 2010 for AVR32 - IJG JPEG Decoder Example by  doxygen 1.5.5