|
|
|
|
@ -5,7 +5,7 @@ |
|
|
|
|
* Copyright (C) 1994-1997, Thomas G. Lane. |
|
|
|
|
* libjpeg-turbo Modifications: |
|
|
|
|
* Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB |
|
|
|
|
* Copyright (C) 2010, 2015-2016, D. R. Commander. |
|
|
|
|
* Copyright (C) 2010, 2015-2016, 2019-2020, D. R. Commander. |
|
|
|
|
* Copyright (C) 2015, 2020, Google, Inc. |
|
|
|
|
* For conditions of distribution and use, see the accompanying README.ijg |
|
|
|
|
* file. |
|
|
|
|
@ -102,6 +102,8 @@ decompress_onepass(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
/* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */ |
|
|
|
|
jzero_far((void *)coef->MCU_buffer[0], |
|
|
|
|
(size_t)(cinfo->blocks_in_MCU * sizeof(JBLOCK))); |
|
|
|
|
if (!cinfo->entropy->insufficient_data) |
|
|
|
|
cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row; |
|
|
|
|
if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { |
|
|
|
|
/* Suspension forced; update state counters and exit */ |
|
|
|
|
coef->MCU_vert_offset = yoffset; |
|
|
|
|
@ -227,6 +229,8 @@ consume_data(j_decompress_ptr cinfo) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
if (!cinfo->entropy->insufficient_data) |
|
|
|
|
cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row; |
|
|
|
|
/* Try to fetch the MCU. */ |
|
|
|
|
if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { |
|
|
|
|
/* Suspension forced; update state counters and exit */ |
|
|
|
|
@ -326,19 +330,22 @@ decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
#ifdef BLOCK_SMOOTHING_SUPPORTED |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This code applies interblock smoothing as described by section K.8 |
|
|
|
|
* of the JPEG standard: the first 5 AC coefficients are estimated from |
|
|
|
|
* the DC values of a DCT block and its 8 neighboring blocks. |
|
|
|
|
* This code applies interblock smoothing; the first 9 AC coefficients are |
|
|
|
|
* estimated from the DC values of a DCT block and its 24 neighboring blocks. |
|
|
|
|
* We apply smoothing only for progressive JPEG decoding, and only if |
|
|
|
|
* the coefficients it can estimate are not yet known to full precision. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/* Natural-order array positions of the first 5 zigzag-order coefficients */ |
|
|
|
|
/* Natural-order array positions of the first 9 zigzag-order coefficients */ |
|
|
|
|
#define Q01_POS 1 |
|
|
|
|
#define Q10_POS 8 |
|
|
|
|
#define Q20_POS 16 |
|
|
|
|
#define Q11_POS 9 |
|
|
|
|
#define Q02_POS 2 |
|
|
|
|
#define Q03_POS 3 |
|
|
|
|
#define Q12_POS 10 |
|
|
|
|
#define Q21_POS 17 |
|
|
|
|
#define Q30_POS 24 |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Determine whether block smoothing is applicable and safe. |
|
|
|
|
@ -356,8 +363,8 @@ smoothing_ok(j_decompress_ptr cinfo) |
|
|
|
|
int ci, coefi; |
|
|
|
|
jpeg_component_info *compptr; |
|
|
|
|
JQUANT_TBL *qtable; |
|
|
|
|
int *coef_bits; |
|
|
|
|
int *coef_bits_latch; |
|
|
|
|
int *coef_bits, *prev_coef_bits; |
|
|
|
|
int *coef_bits_latch, *prev_coef_bits_latch; |
|
|
|
|
|
|
|
|
|
if (!cinfo->progressive_mode || cinfo->coef_bits == NULL) |
|
|
|
|
return FALSE; |
|
|
|
|
@ -366,34 +373,47 @@ smoothing_ok(j_decompress_ptr cinfo) |
|
|
|
|
if (coef->coef_bits_latch == NULL) |
|
|
|
|
coef->coef_bits_latch = (int *) |
|
|
|
|
(*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
|
|
|
|
cinfo->num_components * |
|
|
|
|
cinfo->num_components * 2 * |
|
|
|
|
(SAVED_COEFS * sizeof(int))); |
|
|
|
|
coef_bits_latch = coef->coef_bits_latch; |
|
|
|
|
prev_coef_bits_latch = |
|
|
|
|
&coef->coef_bits_latch[cinfo->num_components * SAVED_COEFS]; |
|
|
|
|
|
|
|
|
|
for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
|
|
|
|
ci++, compptr++) { |
|
|
|
|
/* All components' quantization values must already be latched. */ |
|
|
|
|
if ((qtable = compptr->quant_table) == NULL) |
|
|
|
|
return FALSE; |
|
|
|
|
/* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */ |
|
|
|
|
/* Verify DC & first 9 AC quantizers are nonzero to avoid zero-divide. */ |
|
|
|
|
if (qtable->quantval[0] == 0 || |
|
|
|
|
qtable->quantval[Q01_POS] == 0 || |
|
|
|
|
qtable->quantval[Q10_POS] == 0 || |
|
|
|
|
qtable->quantval[Q20_POS] == 0 || |
|
|
|
|
qtable->quantval[Q11_POS] == 0 || |
|
|
|
|
qtable->quantval[Q02_POS] == 0) |
|
|
|
|
qtable->quantval[Q02_POS] == 0 || |
|
|
|
|
qtable->quantval[Q03_POS] == 0 || |
|
|
|
|
qtable->quantval[Q12_POS] == 0 || |
|
|
|
|
qtable->quantval[Q21_POS] == 0 || |
|
|
|
|
qtable->quantval[Q30_POS] == 0) |
|
|
|
|
return FALSE; |
|
|
|
|
/* DC values must be at least partly known for all components. */ |
|
|
|
|
coef_bits = cinfo->coef_bits[ci]; |
|
|
|
|
prev_coef_bits = cinfo->coef_bits[ci + cinfo->num_components]; |
|
|
|
|
if (coef_bits[0] < 0) |
|
|
|
|
return FALSE; |
|
|
|
|
coef_bits_latch[0] = coef_bits[0]; |
|
|
|
|
/* Block smoothing is helpful if some AC coefficients remain inaccurate. */ |
|
|
|
|
for (coefi = 1; coefi <= 5; coefi++) { |
|
|
|
|
for (coefi = 1; coefi < SAVED_COEFS; coefi++) { |
|
|
|
|
if (cinfo->input_scan_number > 1) |
|
|
|
|
prev_coef_bits_latch[coefi] = prev_coef_bits[coefi]; |
|
|
|
|
else |
|
|
|
|
prev_coef_bits_latch[coefi] = -1; |
|
|
|
|
coef_bits_latch[coefi] = coef_bits[coefi]; |
|
|
|
|
if (coef_bits[coefi] != 0) |
|
|
|
|
smoothing_useful = TRUE; |
|
|
|
|
} |
|
|
|
|
coef_bits_latch += SAVED_COEFS; |
|
|
|
|
prev_coef_bits_latch += SAVED_COEFS; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return smoothing_useful; |
|
|
|
|
@ -412,17 +432,20 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
JDIMENSION block_num, last_block_column; |
|
|
|
|
int ci, block_row, block_rows, access_rows; |
|
|
|
|
JBLOCKARRAY buffer; |
|
|
|
|
JBLOCKROW buffer_ptr, prev_block_row, next_block_row; |
|
|
|
|
JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row; |
|
|
|
|
JBLOCKROW next_block_row, next_next_block_row; |
|
|
|
|
JSAMPARRAY output_ptr; |
|
|
|
|
JDIMENSION output_col; |
|
|
|
|
jpeg_component_info *compptr; |
|
|
|
|
inverse_DCT_method_ptr inverse_DCT; |
|
|
|
|
boolean first_row, last_row; |
|
|
|
|
boolean change_dc; |
|
|
|
|
JCOEF *workspace; |
|
|
|
|
int *coef_bits; |
|
|
|
|
JQUANT_TBL *quanttbl; |
|
|
|
|
JLONG Q00, Q01, Q02, Q10, Q11, Q20, num; |
|
|
|
|
int DC1, DC2, DC3, DC4, DC5, DC6, DC7, DC8, DC9; |
|
|
|
|
JLONG Q00, Q01, Q02, Q03 = 0, Q10, Q11, Q12 = 0, Q20, Q21 = 0, Q30 = 0, num; |
|
|
|
|
int DC01, DC02, DC03, DC04, DC05, DC06, DC07, DC08, DC09, DC10, DC11, DC12, |
|
|
|
|
DC13, DC14, DC15, DC16, DC17, DC18, DC19, DC20, DC21, DC22, DC23, DC24, |
|
|
|
|
DC25; |
|
|
|
|
int Al, pred; |
|
|
|
|
|
|
|
|
|
/* Keep a local variable to avoid looking it up more than once */ |
|
|
|
|
@ -434,10 +457,10 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
if (cinfo->input_scan_number == cinfo->output_scan_number) { |
|
|
|
|
/* If input is working on current scan, we ordinarily want it to
|
|
|
|
|
* have completed the current row. But if input scan is DC, |
|
|
|
|
* we want it to keep one row ahead so that next block row's DC |
|
|
|
|
* we want it to keep two rows ahead so that next two block rows' DC |
|
|
|
|
* values are up to date. |
|
|
|
|
*/ |
|
|
|
|
JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0; |
|
|
|
|
JDIMENSION delta = (cinfo->Ss == 0) ? 2 : 0; |
|
|
|
|
if (cinfo->input_iMCU_row > cinfo->output_iMCU_row + delta) |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
@ -452,34 +475,53 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
if (!compptr->component_needed) |
|
|
|
|
continue; |
|
|
|
|
/* Count non-dummy DCT block rows in this iMCU row. */ |
|
|
|
|
if (cinfo->output_iMCU_row < last_iMCU_row) { |
|
|
|
|
if (cinfo->output_iMCU_row < last_iMCU_row - 1) { |
|
|
|
|
block_rows = compptr->v_samp_factor; |
|
|
|
|
access_rows = block_rows * 3; /* this and next two iMCU rows */ |
|
|
|
|
} else if (cinfo->output_iMCU_row < last_iMCU_row) { |
|
|
|
|
block_rows = compptr->v_samp_factor; |
|
|
|
|
access_rows = block_rows * 2; /* this and next iMCU row */ |
|
|
|
|
last_row = FALSE; |
|
|
|
|
} else { |
|
|
|
|
/* NB: can't use last_row_height here; it is input-side-dependent! */ |
|
|
|
|
block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor); |
|
|
|
|
if (block_rows == 0) block_rows = compptr->v_samp_factor; |
|
|
|
|
access_rows = block_rows; /* this iMCU row only */ |
|
|
|
|
last_row = TRUE; |
|
|
|
|
} |
|
|
|
|
/* Align the virtual buffer for this component. */ |
|
|
|
|
if (cinfo->output_iMCU_row > 0) { |
|
|
|
|
access_rows += compptr->v_samp_factor; /* prior iMCU row too */ |
|
|
|
|
if (cinfo->output_iMCU_row > 1) { |
|
|
|
|
access_rows += 2 * compptr->v_samp_factor; /* prior two iMCU rows too */ |
|
|
|
|
buffer = (*cinfo->mem->access_virt_barray) |
|
|
|
|
((j_common_ptr)cinfo, coef->whole_image[ci], |
|
|
|
|
(cinfo->output_iMCU_row - 2) * compptr->v_samp_factor, |
|
|
|
|
(JDIMENSION)access_rows, FALSE); |
|
|
|
|
buffer += 2 * compptr->v_samp_factor; /* point to current iMCU row */ |
|
|
|
|
} else if (cinfo->output_iMCU_row > 0) { |
|
|
|
|
buffer = (*cinfo->mem->access_virt_barray) |
|
|
|
|
((j_common_ptr)cinfo, coef->whole_image[ci], |
|
|
|
|
(cinfo->output_iMCU_row - 1) * compptr->v_samp_factor, |
|
|
|
|
(JDIMENSION)access_rows, FALSE); |
|
|
|
|
buffer += compptr->v_samp_factor; /* point to current iMCU row */ |
|
|
|
|
first_row = FALSE; |
|
|
|
|
} else { |
|
|
|
|
buffer = (*cinfo->mem->access_virt_barray) |
|
|
|
|
((j_common_ptr)cinfo, coef->whole_image[ci], |
|
|
|
|
(JDIMENSION)0, (JDIMENSION)access_rows, FALSE); |
|
|
|
|
first_row = TRUE; |
|
|
|
|
} |
|
|
|
|
/* Fetch component-dependent info */ |
|
|
|
|
coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS); |
|
|
|
|
/* Fetch component-dependent info.
|
|
|
|
|
* If the current scan is incomplete, then we use the component-dependent |
|
|
|
|
* info from the previous scan. |
|
|
|
|
*/ |
|
|
|
|
if (cinfo->output_iMCU_row > cinfo->master->last_good_iMCU_row) |
|
|
|
|
coef_bits = |
|
|
|
|
coef->coef_bits_latch + ((ci + cinfo->num_components) * SAVED_COEFS); |
|
|
|
|
else |
|
|
|
|
coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS); |
|
|
|
|
|
|
|
|
|
/* We only do DC interpolation if no AC coefficient data is available. */ |
|
|
|
|
change_dc = |
|
|
|
|
coef_bits[1] == -1 && coef_bits[2] == -1 && coef_bits[3] == -1 && |
|
|
|
|
coef_bits[4] == -1 && coef_bits[5] == -1 && coef_bits[6] == -1 && |
|
|
|
|
coef_bits[7] == -1 && coef_bits[8] == -1 && coef_bits[9] == -1; |
|
|
|
|
|
|
|
|
|
quanttbl = compptr->quant_table; |
|
|
|
|
Q00 = quanttbl->quantval[0]; |
|
|
|
|
Q01 = quanttbl->quantval[Q01_POS]; |
|
|
|
|
@ -487,27 +529,51 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
Q20 = quanttbl->quantval[Q20_POS]; |
|
|
|
|
Q11 = quanttbl->quantval[Q11_POS]; |
|
|
|
|
Q02 = quanttbl->quantval[Q02_POS]; |
|
|
|
|
if (change_dc) { |
|
|
|
|
Q03 = quanttbl->quantval[Q03_POS]; |
|
|
|
|
Q12 = quanttbl->quantval[Q12_POS]; |
|
|
|
|
Q21 = quanttbl->quantval[Q21_POS]; |
|
|
|
|
Q30 = quanttbl->quantval[Q30_POS]; |
|
|
|
|
} |
|
|
|
|
inverse_DCT = cinfo->idct->inverse_DCT[ci]; |
|
|
|
|
output_ptr = output_buf[ci]; |
|
|
|
|
/* Loop over all DCT blocks to be processed. */ |
|
|
|
|
for (block_row = 0; block_row < block_rows; block_row++) { |
|
|
|
|
buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci]; |
|
|
|
|
if (first_row && block_row == 0) |
|
|
|
|
|
|
|
|
|
if (block_row > 0 || cinfo->output_iMCU_row > 0) |
|
|
|
|
prev_block_row = |
|
|
|
|
buffer[block_row - 1] + cinfo->master->first_MCU_col[ci]; |
|
|
|
|
else |
|
|
|
|
prev_block_row = buffer_ptr; |
|
|
|
|
|
|
|
|
|
if (block_row > 1 || cinfo->output_iMCU_row > 1) |
|
|
|
|
prev_prev_block_row = |
|
|
|
|
buffer[block_row - 2] + cinfo->master->first_MCU_col[ci]; |
|
|
|
|
else |
|
|
|
|
prev_prev_block_row = prev_block_row; |
|
|
|
|
|
|
|
|
|
if (block_row < block_rows - 1 || cinfo->output_iMCU_row < last_iMCU_row) |
|
|
|
|
next_block_row = |
|
|
|
|
buffer[block_row + 1] + cinfo->master->first_MCU_col[ci]; |
|
|
|
|
else |
|
|
|
|
prev_block_row = buffer[block_row - 1] + |
|
|
|
|
cinfo->master->first_MCU_col[ci]; |
|
|
|
|
if (last_row && block_row == block_rows - 1) |
|
|
|
|
next_block_row = buffer_ptr; |
|
|
|
|
|
|
|
|
|
if (block_row < block_rows - 2 || |
|
|
|
|
cinfo->output_iMCU_row < last_iMCU_row - 1) |
|
|
|
|
next_next_block_row = |
|
|
|
|
buffer[block_row + 2] + cinfo->master->first_MCU_col[ci]; |
|
|
|
|
else |
|
|
|
|
next_block_row = buffer[block_row + 1] + |
|
|
|
|
cinfo->master->first_MCU_col[ci]; |
|
|
|
|
next_next_block_row = next_block_row; |
|
|
|
|
|
|
|
|
|
/* We fetch the surrounding DC values using a sliding-register approach.
|
|
|
|
|
* Initialize all nine here so as to do the right thing on narrow pics. |
|
|
|
|
* Initialize all 25 here so as to do the right thing on narrow pics. |
|
|
|
|
*/ |
|
|
|
|
DC1 = DC2 = DC3 = (int)prev_block_row[0][0]; |
|
|
|
|
DC4 = DC5 = DC6 = (int)buffer_ptr[0][0]; |
|
|
|
|
DC7 = DC8 = DC9 = (int)next_block_row[0][0]; |
|
|
|
|
DC01 = DC02 = DC03 = DC04 = DC05 = (int)prev_prev_block_row[0][0]; |
|
|
|
|
DC06 = DC07 = DC08 = DC09 = DC10 = (int)prev_block_row[0][0]; |
|
|
|
|
DC11 = DC12 = DC13 = DC14 = DC15 = (int)buffer_ptr[0][0]; |
|
|
|
|
DC16 = DC17 = DC18 = DC19 = DC20 = (int)next_block_row[0][0]; |
|
|
|
|
DC21 = DC22 = DC23 = DC24 = DC25 = (int)next_next_block_row[0][0]; |
|
|
|
|
output_col = 0; |
|
|
|
|
last_block_column = compptr->width_in_blocks - 1; |
|
|
|
|
for (block_num = cinfo->master->first_MCU_col[ci]; |
|
|
|
|
@ -515,18 +581,39 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
/* Fetch current DCT block into workspace so we can modify it. */ |
|
|
|
|
jcopy_block_row(buffer_ptr, (JBLOCKROW)workspace, (JDIMENSION)1); |
|
|
|
|
/* Update DC values */ |
|
|
|
|
if (block_num < last_block_column) { |
|
|
|
|
DC3 = (int)prev_block_row[1][0]; |
|
|
|
|
DC6 = (int)buffer_ptr[1][0]; |
|
|
|
|
DC9 = (int)next_block_row[1][0]; |
|
|
|
|
if (block_num == cinfo->master->first_MCU_col[ci] && |
|
|
|
|
block_num < last_block_column) { |
|
|
|
|
DC04 = (int)prev_prev_block_row[1][0]; |
|
|
|
|
DC09 = (int)prev_block_row[1][0]; |
|
|
|
|
DC14 = (int)buffer_ptr[1][0]; |
|
|
|
|
DC19 = (int)next_block_row[1][0]; |
|
|
|
|
DC24 = (int)next_next_block_row[1][0]; |
|
|
|
|
} |
|
|
|
|
/* Compute coefficient estimates per K.8.
|
|
|
|
|
* An estimate is applied only if coefficient is still zero, |
|
|
|
|
* and is not known to be fully accurate. |
|
|
|
|
if (block_num + 1 < last_block_column) { |
|
|
|
|
DC05 = (int)prev_prev_block_row[2][0]; |
|
|
|
|
DC10 = (int)prev_block_row[2][0]; |
|
|
|
|
DC15 = (int)buffer_ptr[2][0]; |
|
|
|
|
DC20 = (int)next_block_row[2][0]; |
|
|
|
|
DC25 = (int)next_next_block_row[2][0]; |
|
|
|
|
} |
|
|
|
|
/* If DC interpolation is enabled, compute coefficient estimates using
|
|
|
|
|
* a Gaussian-like kernel, keeping the averages of the DC values. |
|
|
|
|
* |
|
|
|
|
* If DC interpolation is disabled, compute coefficient estimates using |
|
|
|
|
* an algorithm similar to the one described in Section K.8 of the JPEG |
|
|
|
|
* standard, except applied to a 5x5 window rather than a 3x3 window. |
|
|
|
|
* |
|
|
|
|
* An estimate is applied only if the coefficient is still zero and is |
|
|
|
|
* not known to be fully accurate. |
|
|
|
|
*/ |
|
|
|
|
/* AC01 */ |
|
|
|
|
if ((Al = coef_bits[1]) != 0 && workspace[1] == 0) { |
|
|
|
|
num = 36 * Q00 * (DC4 - DC6); |
|
|
|
|
num = Q00 * (change_dc ? |
|
|
|
|
(-DC01 - DC02 + DC04 + DC05 - 3 * DC06 + 13 * DC07 - |
|
|
|
|
13 * DC09 + 3 * DC10 - 3 * DC11 + 38 * DC12 - 38 * DC14 + |
|
|
|
|
3 * DC15 - 3 * DC16 + 13 * DC17 - 13 * DC19 + 3 * DC20 - |
|
|
|
|
DC21 - DC22 + DC24 + DC25) : |
|
|
|
|
(-7 * DC11 + 50 * DC12 - 50 * DC14 + 7 * DC15)); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q01 << 7) + num) / (Q01 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
@ -541,7 +628,12 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
} |
|
|
|
|
/* AC10 */ |
|
|
|
|
if ((Al = coef_bits[2]) != 0 && workspace[8] == 0) { |
|
|
|
|
num = 36 * Q00 * (DC2 - DC8); |
|
|
|
|
num = Q00 * (change_dc ? |
|
|
|
|
(-DC01 - 3 * DC02 - 3 * DC03 - 3 * DC04 - DC05 - DC06 + |
|
|
|
|
13 * DC07 + 38 * DC08 + 13 * DC09 - DC10 + DC16 - |
|
|
|
|
13 * DC17 - 38 * DC18 - 13 * DC19 + DC20 + DC21 + |
|
|
|
|
3 * DC22 + 3 * DC23 + 3 * DC24 + DC25) : |
|
|
|
|
(-7 * DC03 + 50 * DC08 - 50 * DC18 + 7 * DC23)); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q10 << 7) + num) / (Q10 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
@ -556,7 +648,10 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
} |
|
|
|
|
/* AC20 */ |
|
|
|
|
if ((Al = coef_bits[3]) != 0 && workspace[16] == 0) { |
|
|
|
|
num = 9 * Q00 * (DC2 + DC8 - 2 * DC5); |
|
|
|
|
num = Q00 * (change_dc ? |
|
|
|
|
(DC03 + 2 * DC07 + 7 * DC08 + 2 * DC09 - 5 * DC12 - 14 * DC13 - |
|
|
|
|
5 * DC14 + 2 * DC17 + 7 * DC18 + 2 * DC19 + DC23) : |
|
|
|
|
(-DC03 + 13 * DC08 - 24 * DC13 + 13 * DC18 - DC23)); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q20 << 7) + num) / (Q20 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
@ -571,7 +666,11 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
} |
|
|
|
|
/* AC11 */ |
|
|
|
|
if ((Al = coef_bits[4]) != 0 && workspace[9] == 0) { |
|
|
|
|
num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9); |
|
|
|
|
num = Q00 * (change_dc ? |
|
|
|
|
(-DC01 + DC05 + 9 * DC07 - 9 * DC09 - 9 * DC17 + |
|
|
|
|
9 * DC19 + DC21 - DC25) : |
|
|
|
|
(DC10 + DC16 - 10 * DC17 + 10 * DC19 - DC02 - DC20 + DC22 - |
|
|
|
|
DC24 + DC04 - DC06 + 10 * DC07 - 10 * DC09)); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q11 << 7) + num) / (Q11 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
@ -586,7 +685,10 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
} |
|
|
|
|
/* AC02 */ |
|
|
|
|
if ((Al = coef_bits[5]) != 0 && workspace[2] == 0) { |
|
|
|
|
num = 9 * Q00 * (DC4 + DC6 - 2 * DC5); |
|
|
|
|
num = Q00 * (change_dc ? |
|
|
|
|
(2 * DC07 - 5 * DC08 + 2 * DC09 + DC11 + 7 * DC12 - 14 * DC13 + |
|
|
|
|
7 * DC14 + DC15 + 2 * DC17 - 5 * DC18 + 2 * DC19) : |
|
|
|
|
(-DC11 + 13 * DC12 - 24 * DC13 + 13 * DC14 - DC15)); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q02 << 7) + num) / (Q02 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
@ -599,14 +701,96 @@ decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf) |
|
|
|
|
} |
|
|
|
|
workspace[2] = (JCOEF)pred; |
|
|
|
|
} |
|
|
|
|
if (change_dc) { |
|
|
|
|
/* AC03 */ |
|
|
|
|
if ((Al = coef_bits[6]) != 0 && workspace[3] == 0) { |
|
|
|
|
num = Q00 * (DC07 - DC09 + 2 * DC12 - 2 * DC14 + DC17 - DC19); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q03 << 7) + num) / (Q03 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
} else { |
|
|
|
|
pred = (int)(((Q03 << 7) - num) / (Q03 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
pred = -pred; |
|
|
|
|
} |
|
|
|
|
workspace[3] = (JCOEF)pred; |
|
|
|
|
} |
|
|
|
|
/* AC12 */ |
|
|
|
|
if ((Al = coef_bits[7]) != 0 && workspace[10] == 0) { |
|
|
|
|
num = Q00 * (DC07 - 3 * DC08 + DC09 - DC17 + 3 * DC18 - DC19); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q12 << 7) + num) / (Q12 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
} else { |
|
|
|
|
pred = (int)(((Q12 << 7) - num) / (Q12 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
pred = -pred; |
|
|
|
|
} |
|
|
|
|
workspace[10] = (JCOEF)pred; |
|
|
|
|
} |
|
|
|
|
/* AC21 */ |
|
|
|
|
if ((Al = coef_bits[8]) != 0 && workspace[17] == 0) { |
|
|
|
|
num = Q00 * (DC07 - DC09 - 3 * DC12 + 3 * DC14 + DC17 - DC19); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q21 << 7) + num) / (Q21 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
} else { |
|
|
|
|
pred = (int)(((Q21 << 7) - num) / (Q21 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
pred = -pred; |
|
|
|
|
} |
|
|
|
|
workspace[17] = (JCOEF)pred; |
|
|
|
|
} |
|
|
|
|
/* AC30 */ |
|
|
|
|
if ((Al = coef_bits[9]) != 0 && workspace[24] == 0) { |
|
|
|
|
num = Q00 * (DC07 + 2 * DC08 + DC09 - DC17 - 2 * DC18 - DC19); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q30 << 7) + num) / (Q30 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
} else { |
|
|
|
|
pred = (int)(((Q30 << 7) - num) / (Q30 << 8)); |
|
|
|
|
if (Al > 0 && pred >= (1 << Al)) |
|
|
|
|
pred = (1 << Al) - 1; |
|
|
|
|
pred = -pred; |
|
|
|
|
} |
|
|
|
|
workspace[24] = (JCOEF)pred; |
|
|
|
|
} |
|
|
|
|
/* coef_bits[0] is non-negative. Otherwise this function would not
|
|
|
|
|
* be called. |
|
|
|
|
*/ |
|
|
|
|
num = Q00 * |
|
|
|
|
(-2 * DC01 - 6 * DC02 - 8 * DC03 - 6 * DC04 - 2 * DC05 - |
|
|
|
|
6 * DC06 + 6 * DC07 + 42 * DC08 + 6 * DC09 - 6 * DC10 - |
|
|
|
|
8 * DC11 + 42 * DC12 + 152 * DC13 + 42 * DC14 - 8 * DC15 - |
|
|
|
|
6 * DC16 + 6 * DC17 + 42 * DC18 + 6 * DC19 - 6 * DC20 - |
|
|
|
|
2 * DC21 - 6 * DC22 - 8 * DC23 - 6 * DC24 - 2 * DC25); |
|
|
|
|
if (num >= 0) { |
|
|
|
|
pred = (int)(((Q00 << 7) + num) / (Q00 << 8)); |
|
|
|
|
} else { |
|
|
|
|
pred = (int)(((Q00 << 7) - num) / (Q00 << 8)); |
|
|
|
|
pred = -pred; |
|
|
|
|
} |
|
|
|
|
workspace[0] = (JCOEF)pred; |
|
|
|
|
} /* change_dc */ |
|
|
|
|
|
|
|
|
|
/* OK, do the IDCT */ |
|
|
|
|
(*inverse_DCT) (cinfo, compptr, (JCOEFPTR)workspace, output_ptr, |
|
|
|
|
output_col); |
|
|
|
|
/* Advance for next column */ |
|
|
|
|
DC1 = DC2; DC2 = DC3; |
|
|
|
|
DC4 = DC5; DC5 = DC6; |
|
|
|
|
DC7 = DC8; DC8 = DC9; |
|
|
|
|
buffer_ptr++, prev_block_row++, next_block_row++; |
|
|
|
|
DC01 = DC02; DC02 = DC03; DC03 = DC04; DC04 = DC05; |
|
|
|
|
DC06 = DC07; DC07 = DC08; DC08 = DC09; DC09 = DC10; |
|
|
|
|
DC11 = DC12; DC12 = DC13; DC13 = DC14; DC14 = DC15; |
|
|
|
|
DC16 = DC17; DC17 = DC18; DC18 = DC19; DC19 = DC20; |
|
|
|
|
DC21 = DC22; DC22 = DC23; DC23 = DC24; DC24 = DC25; |
|
|
|
|
buffer_ptr++, prev_block_row++, next_block_row++, |
|
|
|
|
prev_prev_block_row++, next_next_block_row++; |
|
|
|
|
output_col += compptr->_DCT_scaled_size; |
|
|
|
|
} |
|
|
|
|
output_ptr += compptr->_DCT_scaled_size; |
|
|
|
|
@ -655,7 +839,7 @@ jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer) |
|
|
|
|
#ifdef BLOCK_SMOOTHING_SUPPORTED |
|
|
|
|
/* If block smoothing could be used, need a bigger window */ |
|
|
|
|
if (cinfo->progressive_mode) |
|
|
|
|
access_rows *= 3; |
|
|
|
|
access_rows *= 5; |
|
|
|
|
#endif |
|
|
|
|
coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) |
|
|
|
|
((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE, |
|
|
|
|
|
Alexander Alekhin
4 years ago