< prev index next >
modules/javafx.graphics/src/main/native-iio/libjpeg7/jdhuff.c
Print this page
*** 1,10 ****
/*
* jdhuff.c
*
* Copyright (C) 1991-1997, Thomas G. Lane.
! * Modified 2006-2009 by Guido Vollbeding.
* This file is part of the Independent JPEG Group's software.
* For conditions of distribution and use, see the accompanying README file.
*
* This file contains Huffman entropy decoding routines.
* Both sequential and progressive modes are supported in this single module.
--- 1,10 ----
/*
* jdhuff.c
*
* Copyright (C) 1991-1997, Thomas G. Lane.
! * Modified 2006-2016 by Guido Vollbeding.
* This file is part of the Independent JPEG Group's software.
* For conditions of distribution and use, see the accompanying README file.
*
* This file contains Huffman entropy decoding routines.
* Both sequential and progressive modes are supported in this single module.
*** 227,236 ****
--- 227,237 ----
*/
bitread_perm_state bitstate; /* Bit buffer at start of MCU */
savable_state saved; /* Other state at start of MCU */
/* These fields are NOT loaded into local working state. */
+ boolean insufficient_data; /* set TRUE after emitting warning */
unsigned int restarts_to_go; /* MCUs left in this restart interval */
/* Following two fields used only in progressive mode */
/* Pointers to derived tables (these workspaces have image lifespan) */
*** 265,274 ****
--- 266,320 ----
{ 20, 22, 33, 38, 46, 51, 55, 60 },
{ 21, 34, 37, 47, 50, 56, 59, 61 },
{ 35, 36, 48, 49, 57, 58, 62, 63 }
};
+ static const int jpeg_zigzag_order7[7][7] = {
+ { 0, 1, 5, 6, 14, 15, 27 },
+ { 2, 4, 7, 13, 16, 26, 28 },
+ { 3, 8, 12, 17, 25, 29, 38 },
+ { 9, 11, 18, 24, 30, 37, 39 },
+ { 10, 19, 23, 31, 36, 40, 45 },
+ { 20, 22, 32, 35, 41, 44, 46 },
+ { 21, 33, 34, 42, 43, 47, 48 }
+ };
+
+ static const int jpeg_zigzag_order6[6][6] = {
+ { 0, 1, 5, 6, 14, 15 },
+ { 2, 4, 7, 13, 16, 25 },
+ { 3, 8, 12, 17, 24, 26 },
+ { 9, 11, 18, 23, 27, 32 },
+ { 10, 19, 22, 28, 31, 33 },
+ { 20, 21, 29, 30, 34, 35 }
+ };
+
+ static const int jpeg_zigzag_order5[5][5] = {
+ { 0, 1, 5, 6, 14 },
+ { 2, 4, 7, 13, 15 },
+ { 3, 8, 12, 16, 21 },
+ { 9, 11, 17, 20, 22 },
+ { 10, 18, 19, 23, 24 }
+ };
+
+ static const int jpeg_zigzag_order4[4][4] = {
+ { 0, 1, 5, 6 },
+ { 2, 4, 7, 12 },
+ { 3, 8, 11, 13 },
+ { 9, 10, 14, 15 }
+ };
+
+ static const int jpeg_zigzag_order3[3][3] = {
+ { 0, 1, 5 },
+ { 2, 4, 6 },
+ { 3, 7, 8 }
+ };
+
+ static const int jpeg_zigzag_order2[2][2] = {
+ { 0, 1 },
+ { 2, 3 }
+ };
+
/*
* Compute the derived values for a Huffman table.
* This routine also performs some validation checks on the table.
*/
*** 283,295 ****
int lookbits, ctr;
char huffsize[257];
unsigned int huffcode[257];
unsigned int code;
- MEMZERO(huffsize, SIZEOF(huffsize));
- MEMZERO(huffcode, SIZEOF(huffcode));
-
/* Note that huffsize[] and huffcode[] are filled in code-length order,
* paralleling the order of the symbols themselves in htbl->huffval[].
*/
/* Find the input Huffman table */
--- 329,338 ----
*** 497,509 ****
/* Uh-oh. Report corrupted data to user and stuff zeroes into
* the data stream, so that we can produce some kind of image.
* We use a nonvolatile flag to ensure that only one warning message
* appears per data segment.
*/
! if (! cinfo->entropy->insufficient_data) {
WARNMS(cinfo, JWRN_HIT_MARKER);
! cinfo->entropy->insufficient_data = TRUE;
}
/* Fill the buffer with zero bits */
get_buffer <<= MIN_GET_BITS - bits_left;
bits_left = MIN_GET_BITS;
}
--- 540,552 ----
/* Uh-oh. Report corrupted data to user and stuff zeroes into
* the data stream, so that we can produce some kind of image.
* We use a nonvolatile flag to ensure that only one warning message
* appears per data segment.
*/
! if (! ((huff_entropy_ptr) cinfo->entropy)->insufficient_data) {
WARNMS(cinfo, JWRN_HIT_MARKER);
! ((huff_entropy_ptr) cinfo->entropy)->insufficient_data = TRUE;
}
/* Fill the buffer with zero bits */
get_buffer <<= MIN_GET_BITS - bits_left;
bits_left = MIN_GET_BITS;
}
*** 574,608 ****
state->bits_left = bits_left;
/* With garbage input we may reach the sentinel value l = 17. */
if (l > 16) {
- int br_offset = state->next_input_byte - state->cinfo->src->next_input_byte;
WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
- state->next_input_byte = state->cinfo->src->next_input_byte + br_offset;
return 0; /* fake a zero as the safest result */
}
return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
}
/*
* Check for a restart marker & resynchronize decoder.
* Returns FALSE if must suspend.
*/
LOCAL(boolean)
process_restart (j_decompress_ptr cinfo)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
int ci;
! /* Throw away any unused bits remaining in bit buffer; */
! /* include any full bytes in next_marker's count of discarded bytes */
! cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
! entropy->bitstate.bits_left = 0;
/* Advance past the RSTn marker */
if (! (*cinfo->marker->read_restart_marker) (cinfo))
return FALSE;
--- 617,662 ----
state->bits_left = bits_left;
/* With garbage input we may reach the sentinel value l = 17. */
if (l > 16) {
WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
return 0; /* fake a zero as the safest result */
}
return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
}
/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+ METHODDEF(void)
+ finish_pass_huff (j_decompress_ptr cinfo)
+ {
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+
+ /* Throw away any unused bits remaining in bit buffer; */
+ /* include any full bytes in next_marker's count of discarded bytes */
+ cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+ entropy->bitstate.bits_left = 0;
+ }
+
+
+ /*
* Check for a restart marker & resynchronize decoder.
* Returns FALSE if must suspend.
*/
LOCAL(boolean)
process_restart (j_decompress_ptr cinfo)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
int ci;
! finish_pass_huff(cinfo);
/* Advance past the RSTn marker */
if (! (*cinfo->marker->read_restart_marker) (cinfo))
return FALSE;
*** 619,629 ****
* against a marker. In that case we will end up treating the next data
* segment as empty, and we can avoid producing bogus output pixels by
* leaving the flag set.
*/
if (cinfo->unread_marker == 0)
! entropy->pub.insufficient_data = FALSE;
return TRUE;
}
--- 673,683 ----
* against a marker. In that case we will end up treating the next data
* segment as empty, and we can avoid producing bogus output pixels by
* leaving the flag set.
*/
if (cinfo->unread_marker == 0)
! entropy->insufficient_data = FALSE;
return TRUE;
}
*** 671,681 ****
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
! if (! entropy->pub.insufficient_data) {
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
ASSIGN_STATE(state, entropy->saved);
--- 725,735 ----
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
! if (! entropy->insufficient_data) {
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
ASSIGN_STATE(state, entropy->saved);
*** 723,736 ****
METHODDEF(boolean)
decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
- int Se = cinfo->Se;
- int Al = cinfo->Al;
register int s, k, r;
unsigned int EOBRUN;
JBLOCKROW block;
BITREAD_STATE_VARS;
d_derived_tbl * tbl;
/* Process restart marker if needed; may have to suspend */
--- 777,790 ----
METHODDEF(boolean)
decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
register int s, k, r;
unsigned int EOBRUN;
+ int Se, Al;
+ const int * natural_order;
JBLOCKROW block;
BITREAD_STATE_VARS;
d_derived_tbl * tbl;
/* Process restart marker if needed; may have to suspend */
*** 741,763 ****
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
! if (! entropy->pub.insufficient_data) {
/* Load up working state.
* We can avoid loading/saving bitread state if in an EOB run.
*/
EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
/* There is always only one block per MCU */
! if (EOBRUN > 0) /* if it's a band of zeroes... */
EOBRUN--; /* ...process it now (we do nothing) */
else {
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
block = MCU_data[0];
tbl = entropy->ac_derived_tbl;
for (k = cinfo->Ss; k <= Se; k++) {
HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
--- 795,820 ----
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
! if (! entropy->insufficient_data) {
/* Load up working state.
* We can avoid loading/saving bitread state if in an EOB run.
*/
EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
/* There is always only one block per MCU */
! if (EOBRUN) /* if it's a band of zeroes... */
EOBRUN--; /* ...process it now (we do nothing) */
else {
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ Se = cinfo->Se;
+ Al = cinfo->Al;
+ natural_order = cinfo->natural_order;
block = MCU_data[0];
tbl = entropy->ac_derived_tbl;
for (k = cinfo->Ss; k <= Se; k++) {
HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
*** 767,790 ****
k += r;
CHECK_BIT_BUFFER(br_state, s, return FALSE);
r = GET_BITS(s);
s = HUFF_EXTEND(r, s);
/* Scale and output coefficient in natural (dezigzagged) order */
! (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al);
} else {
! if (r == 15) { /* ZRL */
! k += 15; /* skip 15 zeroes in band */
! } else { /* EOBr, run length is 2^r + appended bits */
! EOBRUN = 1 << r;
if (r) { /* EOBr, r > 0 */
CHECK_BIT_BUFFER(br_state, r, return FALSE);
r = GET_BITS(r);
EOBRUN += r;
- }
EOBRUN--; /* this band is processed at this moment */
break; /* force end-of-band */
}
}
}
BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
}
--- 824,846 ----
k += r;
CHECK_BIT_BUFFER(br_state, s, return FALSE);
r = GET_BITS(s);
s = HUFF_EXTEND(r, s);
/* Scale and output coefficient in natural (dezigzagged) order */
! (*block)[natural_order[k]] = (JCOEF) (s << Al);
} else {
! if (r != 15) { /* EOBr, run length is 2^r + appended bits */
if (r) { /* EOBr, r > 0 */
+ EOBRUN = 1 << r;
CHECK_BIT_BUFFER(br_state, r, return FALSE);
r = GET_BITS(r);
EOBRUN += r;
EOBRUN--; /* this band is processed at this moment */
+ }
break; /* force end-of-band */
}
+ k += 15; /* ZRL: skip 15 zeroes in band */
}
}
BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
}
*** 800,820 ****
}
/*
* MCU decoding for DC successive approximation refinement scan.
! * Note: we assume such scans can be multi-component, although the spec
! * is not very clear on the point.
*/
METHODDEF(boolean)
decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
! int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
! int blkn;
! JBLOCKROW block;
BITREAD_STATE_VARS;
/* Process restart marker if needed; may have to suspend */
if (cinfo->restart_interval) {
if (entropy->restarts_to_go == 0)
--- 856,874 ----
}
/*
* MCU decoding for DC successive approximation refinement scan.
! * Note: we assume such scans can be multi-component,
! * although the spec is not very clear on the point.
*/
METHODDEF(boolean)
decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
! int p1, blkn;
BITREAD_STATE_VARS;
/* Process restart marker if needed; may have to suspend */
if (cinfo->restart_interval) {
if (entropy->restarts_to_go == 0)
*** 827,845 ****
*/
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
/* Outer loop handles each block in the MCU */
for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
- block = MCU_data[blkn];
-
/* Encoded data is simply the next bit of the two's-complement DC value */
CHECK_BIT_BUFFER(br_state, 1, return FALSE);
if (GET_BITS(1))
! (*block)[0] |= p1;
/* Note: since we use |=, repeating the assignment later is safe */
}
/* Completed MCU, so update state */
BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
--- 881,899 ----
*/
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
+
/* Outer loop handles each block in the MCU */
for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
/* Encoded data is simply the next bit of the two's-complement DC value */
CHECK_BIT_BUFFER(br_state, 1, return FALSE);
if (GET_BITS(1))
! MCU_data[blkn][0][0] |= p1;
/* Note: since we use |=, repeating the assignment later is safe */
}
/* Completed MCU, so update state */
BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
*** 857,871 ****
METHODDEF(boolean)
decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
- int Se = cinfo->Se;
- int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
- int m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */
register int s, k, r;
unsigned int EOBRUN;
JBLOCKROW block;
JCOEFPTR thiscoef;
BITREAD_STATE_VARS;
d_derived_tbl * tbl;
int num_newnz;
--- 911,924 ----
METHODDEF(boolean)
decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
register int s, k, r;
unsigned int EOBRUN;
+ int Se, p1, m1;
+ const int * natural_order;
JBLOCKROW block;
JCOEFPTR thiscoef;
BITREAD_STATE_VARS;
d_derived_tbl * tbl;
int num_newnz;
*** 878,888 ****
return FALSE;
}
/* If we've run out of data, don't modify the MCU.
*/
! if (! entropy->pub.insufficient_data) {
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
--- 931,946 ----
return FALSE;
}
/* If we've run out of data, don't modify the MCU.
*/
! if (! entropy->insufficient_data) {
!
! Se = cinfo->Se;
! p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
! m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */
! natural_order = cinfo->natural_order;
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
*** 900,910 ****
/* initialize coefficient loop counter to start of band */
k = cinfo->Ss;
if (EOBRUN == 0) {
! for (; k <= Se; k++) {
HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
r = s >> 4;
s &= 15;
if (s) {
if (s != 1) /* size of new coef should always be 1 */
--- 958,968 ----
/* initialize coefficient loop counter to start of band */
k = cinfo->Ss;
if (EOBRUN == 0) {
! do {
HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
r = s >> 4;
s &= 15;
if (s) {
if (s != 1) /* size of new coef should always be 1 */
*** 929,940 ****
/* Advance over already-nonzero coefs and r still-zero coefs,
* appending correction bits to the nonzeroes. A correction bit is 1
* if the absolute value of the coefficient must be increased.
*/
do {
! thiscoef = *block + jpeg_natural_order[k];
! if (*thiscoef != 0) {
CHECK_BIT_BUFFER(br_state, 1, goto undoit);
if (GET_BITS(1)) {
if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
if (*thiscoef >= 0)
*thiscoef += p1;
--- 987,998 ----
/* Advance over already-nonzero coefs and r still-zero coefs,
* appending correction bits to the nonzeroes. A correction bit is 1
* if the absolute value of the coefficient must be increased.
*/
do {
! thiscoef = *block + natural_order[k];
! if (*thiscoef) {
CHECK_BIT_BUFFER(br_state, 1, goto undoit);
if (GET_BITS(1)) {
if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
if (*thiscoef >= 0)
*thiscoef += p1;
*** 947,985 ****
break; /* reached target zero coefficient */
}
k++;
} while (k <= Se);
if (s) {
! int pos = jpeg_natural_order[k];
/* Output newly nonzero coefficient */
(*block)[pos] = (JCOEF) s;
/* Remember its position in case we have to suspend */
newnz_pos[num_newnz++] = pos;
}
! }
}
! if (EOBRUN > 0) {
/* Scan any remaining coefficient positions after the end-of-band
* (the last newly nonzero coefficient, if any). Append a correction
* bit to each already-nonzero coefficient. A correction bit is 1
* if the absolute value of the coefficient must be increased.
*/
! for (; k <= Se; k++) {
! thiscoef = *block + jpeg_natural_order[k];
! if (*thiscoef != 0) {
CHECK_BIT_BUFFER(br_state, 1, goto undoit);
if (GET_BITS(1)) {
if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
if (*thiscoef >= 0)
*thiscoef += p1;
else
*thiscoef += m1;
}
}
}
! }
/* Count one block completed in EOB run */
EOBRUN--;
}
/* Completed MCU, so update state */
--- 1005,1045 ----
break; /* reached target zero coefficient */
}
k++;
} while (k <= Se);
if (s) {
! int pos = natural_order[k];
/* Output newly nonzero coefficient */
(*block)[pos] = (JCOEF) s;
/* Remember its position in case we have to suspend */
newnz_pos[num_newnz++] = pos;
}
! k++;
! } while (k <= Se);
}
! if (EOBRUN) {
/* Scan any remaining coefficient positions after the end-of-band
* (the last newly nonzero coefficient, if any). Append a correction
* bit to each already-nonzero coefficient. A correction bit is 1
* if the absolute value of the coefficient must be increased.
*/
! do {
! thiscoef = *block + natural_order[k];
! if (*thiscoef) {
CHECK_BIT_BUFFER(br_state, 1, goto undoit);
if (GET_BITS(1)) {
if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
if (*thiscoef >= 0)
*thiscoef += p1;
else
*thiscoef += m1;
}
}
}
! k++;
! } while (k <= Se);
/* Count one block completed in EOB run */
EOBRUN--;
}
/* Completed MCU, so update state */
*** 992,1010 ****
return TRUE;
undoit:
/* Re-zero any output coefficients that we made newly nonzero */
! while (num_newnz > 0)
(*block)[newnz_pos[--num_newnz]] = 0;
return FALSE;
}
/*
! * Decode one MCU's worth of Huffman-compressed coefficients.
*/
METHODDEF(boolean)
decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
--- 1052,1199 ----
return TRUE;
undoit:
/* Re-zero any output coefficients that we made newly nonzero */
! while (num_newnz)
(*block)[newnz_pos[--num_newnz]] = 0;
return FALSE;
}
/*
! * Decode one MCU's worth of Huffman-compressed coefficients,
! * partial blocks.
! */
!
! METHODDEF(boolean)
! decode_mcu_sub (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
! {
! huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
! const int * natural_order;
! int Se, blkn;
! BITREAD_STATE_VARS;
! savable_state state;
!
! /* Process restart marker if needed; may have to suspend */
! if (cinfo->restart_interval) {
! if (entropy->restarts_to_go == 0)
! if (! process_restart(cinfo))
! return FALSE;
! }
!
! /* If we've run out of data, just leave the MCU set to zeroes.
! * This way, we return uniform gray for the remainder of the segment.
! */
! if (! entropy->insufficient_data) {
!
! natural_order = cinfo->natural_order;
! Se = cinfo->lim_Se;
!
! /* Load up working state */
! BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
! ASSIGN_STATE(state, entropy->saved);
!
! /* Outer loop handles each block in the MCU */
!
! for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
! JBLOCKROW block = MCU_data[blkn];
! d_derived_tbl * htbl;
! register int s, k, r;
! int coef_limit, ci;
!
! /* Decode a single block's worth of coefficients */
!
! /* Section F.2.2.1: decode the DC coefficient difference */
! htbl = entropy->dc_cur_tbls[blkn];
! HUFF_DECODE(s, br_state, htbl, return FALSE, label1);
!
! htbl = entropy->ac_cur_tbls[blkn];
! k = 1;
! coef_limit = entropy->coef_limit[blkn];
! if (coef_limit) {
! /* Convert DC difference to actual value, update last_dc_val */
! if (s) {
! CHECK_BIT_BUFFER(br_state, s, return FALSE);
! r = GET_BITS(s);
! s = HUFF_EXTEND(r, s);
! }
! ci = cinfo->MCU_membership[blkn];
! s += state.last_dc_val[ci];
! state.last_dc_val[ci] = s;
! /* Output the DC coefficient */
! (*block)[0] = (JCOEF) s;
!
! /* Section F.2.2.2: decode the AC coefficients */
! /* Since zeroes are skipped, output area must be cleared beforehand */
! for (; k < coef_limit; k++) {
! HUFF_DECODE(s, br_state, htbl, return FALSE, label2);
!
! r = s >> 4;
! s &= 15;
!
! if (s) {
! k += r;
! CHECK_BIT_BUFFER(br_state, s, return FALSE);
! r = GET_BITS(s);
! s = HUFF_EXTEND(r, s);
! /* Output coefficient in natural (dezigzagged) order.
! * Note: the extra entries in natural_order[] will save us
! * if k > Se, which could happen if the data is corrupted.
! */
! (*block)[natural_order[k]] = (JCOEF) s;
! } else {
! if (r != 15)
! goto EndOfBlock;
! k += 15;
! }
! }
! } else {
! if (s) {
! CHECK_BIT_BUFFER(br_state, s, return FALSE);
! DROP_BITS(s);
! }
! }
!
! /* Section F.2.2.2: decode the AC coefficients */
! /* In this path we just discard the values */
! for (; k <= Se; k++) {
! HUFF_DECODE(s, br_state, htbl, return FALSE, label3);
!
! r = s >> 4;
! s &= 15;
!
! if (s) {
! k += r;
! CHECK_BIT_BUFFER(br_state, s, return FALSE);
! DROP_BITS(s);
! } else {
! if (r != 15)
! break;
! k += 15;
! }
! }
!
! EndOfBlock: ;
! }
!
! /* Completed MCU, so update state */
! BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
! ASSIGN_STATE(entropy->saved, state);
! }
!
! /* Account for restart interval (no-op if not using restarts) */
! entropy->restarts_to_go--;
!
! return TRUE;
! }
!
!
! /*
! * Decode one MCU's worth of Huffman-compressed coefficients,
! * full-size blocks.
*/
METHODDEF(boolean)
decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
*** 1021,1031 ****
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
! if (! entropy->pub.insufficient_data) {
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
ASSIGN_STATE(state, entropy->saved);
--- 1210,1220 ----
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
! if (! entropy->insufficient_data) {
/* Load up working state */
BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
ASSIGN_STATE(state, entropy->saved);
*** 1130,1150 ****
METHODDEF(void)
start_pass_huff_decoder (j_decompress_ptr cinfo)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
! int ci, blkn, dctbl, actbl, i;
jpeg_component_info * compptr;
if (cinfo->progressive_mode) {
/* Validate progressive scan parameters */
if (cinfo->Ss == 0) {
if (cinfo->Se != 0)
goto bad;
} else {
/* need not check Ss/Se < 0 since they came from unsigned bytes */
! if (cinfo->Se < cinfo->Ss || cinfo->Se >= DCTSIZE2)
goto bad;
/* AC scans may have only one component */
if (cinfo->comps_in_scan != 1)
goto bad;
}
--- 1319,1339 ----
METHODDEF(void)
start_pass_huff_decoder (j_decompress_ptr cinfo)
{
huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
! int ci, blkn, tbl, i;
jpeg_component_info * compptr;
if (cinfo->progressive_mode) {
/* Validate progressive scan parameters */
if (cinfo->Ss == 0) {
if (cinfo->Se != 0)
goto bad;
} else {
/* need not check Ss/Se < 0 since they came from unsigned bytes */
! if (cinfo->Se < cinfo->Ss || cinfo->Se > cinfo->lim_Se)
goto bad;
/* AC scans may have only one component */
if (cinfo->comps_in_scan != 1)
goto bad;
}
*** 1199,1218 ****
/* Make sure requested tables are present, and compute derived tables.
* We may build same derived table more than once, but it's not expensive.
*/
if (cinfo->Ss == 0) {
if (cinfo->Ah == 0) { /* DC refinement needs no table */
! i = compptr->dc_tbl_no;
! jpeg_make_d_derived_tbl(cinfo, TRUE, i,
! & entropy->derived_tbls[i]);
}
} else {
! i = compptr->ac_tbl_no;
! jpeg_make_d_derived_tbl(cinfo, FALSE, i,
! & entropy->derived_tbls[i]);
/* remember the single active table */
! entropy->ac_derived_tbl = entropy->derived_tbls[i];
}
/* Initialize DC predictions to 0 */
entropy->saved.last_dc_val[ci] = 0;
}
--- 1388,1407 ----
/* Make sure requested tables are present, and compute derived tables.
* We may build same derived table more than once, but it's not expensive.
*/
if (cinfo->Ss == 0) {
if (cinfo->Ah == 0) { /* DC refinement needs no table */
! tbl = compptr->dc_tbl_no;
! jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
! & entropy->derived_tbls[tbl]);
}
} else {
! tbl = compptr->ac_tbl_no;
! jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
! & entropy->derived_tbls[tbl]);
/* remember the single active table */
! entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
}
/* Initialize DC predictions to 0 */
entropy->saved.last_dc_val[ci] = 0;
}
*** 1221,1247 ****
} else {
/* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
* This ought to be an error condition, but we make it a warning because
* there are some baseline files out there with all zeroes in these bytes.
*/
! if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
! cinfo->Ah != 0 || cinfo->Al != 0)
WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
/* Select MCU decoding routine */
entropy->pub.decode_mcu = decode_mcu;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
compptr = cinfo->cur_comp_info[ci];
- dctbl = compptr->dc_tbl_no;
- actbl = compptr->ac_tbl_no;
/* Compute derived values for Huffman tables */
/* We may do this more than once for a table, but it's not expensive */
! jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
! & entropy->dc_derived_tbls[dctbl]);
! jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
! & entropy->ac_derived_tbls[actbl]);
/* Initialize DC predictions to 0 */
entropy->saved.last_dc_val[ci] = 0;
}
/* Precalculate decoding info for each block in an MCU of this scan */
--- 1410,1448 ----
} else {
/* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
* This ought to be an error condition, but we make it a warning because
* there are some baseline files out there with all zeroes in these bytes.
*/
! if (cinfo->Ss != 0 || cinfo->Ah != 0 || cinfo->Al != 0 ||
! ((cinfo->is_baseline || cinfo->Se < DCTSIZE2) &&
! cinfo->Se != cinfo->lim_Se))
WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
/* Select MCU decoding routine */
+ /* We retain the hard-coded case for full-size blocks.
+ * This is not necessary, but it appears that this version is slightly
+ * more performant in the given implementation.
+ * With an improved implementation we would prefer a single optimized
+ * function.
+ */
+ if (cinfo->lim_Se != DCTSIZE2-1)
+ entropy->pub.decode_mcu = decode_mcu_sub;
+ else
entropy->pub.decode_mcu = decode_mcu;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
compptr = cinfo->cur_comp_info[ci];
/* Compute derived values for Huffman tables */
/* We may do this more than once for a table, but it's not expensive */
! tbl = compptr->dc_tbl_no;
! jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
! & entropy->dc_derived_tbls[tbl]);
! if (cinfo->lim_Se) { /* AC needs no table when not present */
! tbl = compptr->ac_tbl_no;
! jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
! & entropy->ac_derived_tbls[tbl]);
! }
/* Initialize DC predictions to 0 */
entropy->saved.last_dc_val[ci] = 0;
}
/* Precalculate decoding info for each block in an MCU of this scan */
*** 1252,1275 ****
entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
/* Decide whether we really care about the coefficient values */
if (compptr->component_needed) {
ci = compptr->DCT_v_scaled_size;
- if (ci <= 0 || ci > 8) ci = 8;
i = compptr->DCT_h_scaled_size;
if (i <= 0 || i > 8) i = 8;
entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order[ci - 1][i - 1];
} else {
entropy->coef_limit[blkn] = 0;
}
}
}
/* Initialize bitread state variables */
entropy->bitstate.bits_left = 0;
entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
! entropy->pub.insufficient_data = FALSE;
/* Initialize restart counter */
entropy->restarts_to_go = cinfo->restart_interval;
}
--- 1453,1513 ----
entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
/* Decide whether we really care about the coefficient values */
if (compptr->component_needed) {
ci = compptr->DCT_v_scaled_size;
i = compptr->DCT_h_scaled_size;
+ switch (cinfo->lim_Se) {
+ case (1*1-1):
+ entropy->coef_limit[blkn] = 1;
+ break;
+ case (2*2-1):
+ if (ci <= 0 || ci > 2) ci = 2;
+ if (i <= 0 || i > 2) i = 2;
+ entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order2[ci - 1][i - 1];
+ break;
+ case (3*3-1):
+ if (ci <= 0 || ci > 3) ci = 3;
+ if (i <= 0 || i > 3) i = 3;
+ entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order3[ci - 1][i - 1];
+ break;
+ case (4*4-1):
+ if (ci <= 0 || ci > 4) ci = 4;
+ if (i <= 0 || i > 4) i = 4;
+ entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order4[ci - 1][i - 1];
+ break;
+ case (5*5-1):
+ if (ci <= 0 || ci > 5) ci = 5;
+ if (i <= 0 || i > 5) i = 5;
+ entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order5[ci - 1][i - 1];
+ break;
+ case (6*6-1):
+ if (ci <= 0 || ci > 6) ci = 6;
+ if (i <= 0 || i > 6) i = 6;
+ entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order6[ci - 1][i - 1];
+ break;
+ case (7*7-1):
+ if (ci <= 0 || ci > 7) ci = 7;
+ if (i <= 0 || i > 7) i = 7;
+ entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order7[ci - 1][i - 1];
+ break;
+ default:
+ if (ci <= 0 || ci > 8) ci = 8;
if (i <= 0 || i > 8) i = 8;
entropy->coef_limit[blkn] = 1 + jpeg_zigzag_order[ci - 1][i - 1];
+ break;
+ }
} else {
entropy->coef_limit[blkn] = 0;
}
}
}
/* Initialize bitread state variables */
entropy->bitstate.bits_left = 0;
entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
! entropy->insufficient_data = FALSE;
/* Initialize restart counter */
entropy->restarts_to_go = cinfo->restart_interval;
}
*** 1285,1296 ****
int i;
entropy = (huff_entropy_ptr)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
SIZEOF(huff_entropy_decoder));
! cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
entropy->pub.start_pass = start_pass_huff_decoder;
if (cinfo->progressive_mode) {
/* Create progression status table */
int *coef_bit_ptr, ci;
cinfo->coef_bits = (int (*)[DCTSIZE2])
--- 1523,1535 ----
int i;
entropy = (huff_entropy_ptr)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
SIZEOF(huff_entropy_decoder));
! cinfo->entropy = &entropy->pub;
entropy->pub.start_pass = start_pass_huff_decoder;
+ entropy->pub.finish_pass = finish_pass_huff;
if (cinfo->progressive_mode) {
/* Create progression status table */
int *coef_bit_ptr, ci;
cinfo->coef_bits = (int (*)[DCTSIZE2])
< prev index next >