jdcoefct.c (34360B)
1 /* 2 * jdcoefct.c 3 * 4 * This file was part of the Independent JPEG Group's software: 5 * Copyright (C) 1994-1997, Thomas G. Lane. 6 * libjpeg-turbo Modifications: 7 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB 8 * Copyright (C) 2010, 2015-2016, 2019-2020, 2022-2023, D. R. Commander. 9 * Copyright (C) 2015, 2020, Google, Inc. 10 * For conditions of distribution and use, see the accompanying README.ijg 11 * file. 12 * 13 * This file contains the coefficient buffer controller for decompression. 14 * This controller is the top level of the lossy JPEG decompressor proper. 15 * The coefficient buffer lies between entropy decoding and inverse-DCT steps. 16 * 17 * In buffered-image mode, this controller is the interface between 18 * input-oriented processing and output-oriented processing. 19 * Also, the input side (only) is used when reading a file for transcoding. 20 */ 21 22 #include "jinclude.h" 23 #include "jdcoefct.h" 24 #include "jpegapicomp.h" 25 #include "jsamplecomp.h" 26 27 28 /* Forward declarations */ 29 METHODDEF(int) decompress_onepass(j_decompress_ptr cinfo, 30 _JSAMPIMAGE output_buf); 31 #ifdef D_MULTISCAN_FILES_SUPPORTED 32 METHODDEF(int) decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf); 33 #endif 34 #ifdef BLOCK_SMOOTHING_SUPPORTED 35 LOCAL(boolean) smoothing_ok(j_decompress_ptr cinfo); 36 METHODDEF(int) decompress_smooth_data(j_decompress_ptr cinfo, 37 _JSAMPIMAGE output_buf); 38 #endif 39 40 41 /* 42 * Initialize for an input processing pass. 43 */ 44 45 METHODDEF(void) 46 start_input_pass(j_decompress_ptr cinfo) 47 { 48 cinfo->input_iMCU_row = 0; 49 start_iMCU_row(cinfo); 50 } 51 52 53 /* 54 * Initialize for an output processing pass. 55 */ 56 57 METHODDEF(void) 58 start_output_pass(j_decompress_ptr cinfo) 59 { 60 #ifdef BLOCK_SMOOTHING_SUPPORTED 61 my_coef_ptr coef = (my_coef_ptr)cinfo->coef; 62 63 /* If multipass, check to see whether to use block smoothing on this pass */ 64 if (coef->pub.coef_arrays != NULL) { 65 if (cinfo->do_block_smoothing && smoothing_ok(cinfo)) 66 coef->pub._decompress_data = decompress_smooth_data; 67 else 68 coef->pub._decompress_data = decompress_data; 69 } 70 #endif 71 cinfo->output_iMCU_row = 0; 72 } 73 74 75 /* 76 * Decompress and return some data in the single-pass case. 77 * Always attempts to emit one fully interleaved MCU row ("iMCU" row). 78 * Input and output must run in lockstep since we have only a one-MCU buffer. 79 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. 80 * 81 * NB: output_buf contains a plane for each component in image, 82 * which we index according to the component's SOF position. 83 */ 84 85 METHODDEF(int) 86 decompress_onepass(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) 87 { 88 my_coef_ptr coef = (my_coef_ptr)cinfo->coef; 89 JDIMENSION MCU_col_num; /* index of current MCU within row */ 90 JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; 91 JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; 92 int blkn, ci, xindex, yindex, yoffset, useful_width; 93 _JSAMPARRAY output_ptr; 94 JDIMENSION start_col, output_col; 95 jpeg_component_info *compptr; 96 _inverse_DCT_method_ptr inverse_DCT; 97 98 /* Loop to process as much as one whole iMCU row */ 99 for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; 100 yoffset++) { 101 for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col; 102 MCU_col_num++) { 103 /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */ 104 jzero_far((void *)coef->MCU_buffer[0], 105 (size_t)(cinfo->blocks_in_MCU * sizeof(JBLOCK))); 106 if (!cinfo->entropy->insufficient_data) 107 cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row; 108 if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { 109 /* Suspension forced; update state counters and exit */ 110 coef->MCU_vert_offset = yoffset; 111 coef->MCU_ctr = MCU_col_num; 112 return JPEG_SUSPENDED; 113 } 114 115 /* Only perform the IDCT on blocks that are contained within the desired 116 * cropping region. 117 */ 118 if (MCU_col_num >= cinfo->master->first_iMCU_col && 119 MCU_col_num <= cinfo->master->last_iMCU_col) { 120 /* Determine where data should go in output_buf and do the IDCT thing. 121 * We skip dummy blocks at the right and bottom edges (but blkn gets 122 * incremented past them!). Note the inner loop relies on having 123 * allocated the MCU_buffer[] blocks sequentially. 124 */ 125 blkn = 0; /* index of current DCT block within MCU */ 126 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 127 compptr = cinfo->cur_comp_info[ci]; 128 /* Don't bother to IDCT an uninteresting component. */ 129 if (!compptr->component_needed) { 130 blkn += compptr->MCU_blocks; 131 continue; 132 } 133 inverse_DCT = cinfo->idct->_inverse_DCT[compptr->component_index]; 134 useful_width = (MCU_col_num < last_MCU_col) ? 135 compptr->MCU_width : compptr->last_col_width; 136 output_ptr = output_buf[compptr->component_index] + 137 yoffset * compptr->_DCT_scaled_size; 138 start_col = (MCU_col_num - cinfo->master->first_iMCU_col) * 139 compptr->MCU_sample_width; 140 for (yindex = 0; yindex < compptr->MCU_height; yindex++) { 141 if (cinfo->input_iMCU_row < last_iMCU_row || 142 yoffset + yindex < compptr->last_row_height) { 143 output_col = start_col; 144 for (xindex = 0; xindex < useful_width; xindex++) { 145 (*inverse_DCT) (cinfo, compptr, 146 (JCOEFPTR)coef->MCU_buffer[blkn + xindex], 147 output_ptr, output_col); 148 output_col += compptr->_DCT_scaled_size; 149 } 150 } 151 blkn += compptr->MCU_width; 152 output_ptr += compptr->_DCT_scaled_size; 153 } 154 } 155 } 156 } 157 /* Completed an MCU row, but perhaps not an iMCU row */ 158 coef->MCU_ctr = 0; 159 } 160 /* Completed the iMCU row, advance counters for next one */ 161 cinfo->output_iMCU_row++; 162 if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { 163 start_iMCU_row(cinfo); 164 return JPEG_ROW_COMPLETED; 165 } 166 /* Completed the scan */ 167 (*cinfo->inputctl->finish_input_pass) (cinfo); 168 return JPEG_SCAN_COMPLETED; 169 } 170 171 172 /* 173 * Dummy consume-input routine for single-pass operation. 174 */ 175 176 METHODDEF(int) 177 dummy_consume_data(j_decompress_ptr cinfo) 178 { 179 return JPEG_SUSPENDED; /* Always indicate nothing was done */ 180 } 181 182 183 #ifdef D_MULTISCAN_FILES_SUPPORTED 184 185 /* 186 * Consume input data and store it in the full-image coefficient buffer. 187 * We read as much as one fully interleaved MCU row ("iMCU" row) per call, 188 * ie, v_samp_factor block rows for each component in the scan. 189 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. 190 */ 191 192 METHODDEF(int) 193 consume_data(j_decompress_ptr cinfo) 194 { 195 my_coef_ptr coef = (my_coef_ptr)cinfo->coef; 196 JDIMENSION MCU_col_num; /* index of current MCU within row */ 197 int blkn, ci, xindex, yindex, yoffset; 198 JDIMENSION start_col; 199 JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; 200 JBLOCKROW buffer_ptr; 201 jpeg_component_info *compptr; 202 203 /* Align the virtual buffers for the components used in this scan. */ 204 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 205 compptr = cinfo->cur_comp_info[ci]; 206 buffer[ci] = (*cinfo->mem->access_virt_barray) 207 ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index], 208 cinfo->input_iMCU_row * compptr->v_samp_factor, 209 (JDIMENSION)compptr->v_samp_factor, TRUE); 210 /* Note: entropy decoder expects buffer to be zeroed, 211 * but this is handled automatically by the memory manager 212 * because we requested a pre-zeroed array. 213 */ 214 } 215 216 /* Loop to process one whole iMCU row */ 217 for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; 218 yoffset++) { 219 for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row; 220 MCU_col_num++) { 221 /* Construct list of pointers to DCT blocks belonging to this MCU */ 222 blkn = 0; /* index of current DCT block within MCU */ 223 for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 224 compptr = cinfo->cur_comp_info[ci]; 225 start_col = MCU_col_num * compptr->MCU_width; 226 for (yindex = 0; yindex < compptr->MCU_height; yindex++) { 227 buffer_ptr = buffer[ci][yindex + yoffset] + start_col; 228 for (xindex = 0; xindex < compptr->MCU_width; xindex++) { 229 coef->MCU_buffer[blkn++] = buffer_ptr++; 230 } 231 } 232 } 233 if (!cinfo->entropy->insufficient_data) 234 cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row; 235 /* Try to fetch the MCU. */ 236 if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { 237 /* Suspension forced; update state counters and exit */ 238 coef->MCU_vert_offset = yoffset; 239 coef->MCU_ctr = MCU_col_num; 240 return JPEG_SUSPENDED; 241 } 242 } 243 /* Completed an MCU row, but perhaps not an iMCU row */ 244 coef->MCU_ctr = 0; 245 } 246 /* Completed the iMCU row, advance counters for next one */ 247 if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { 248 start_iMCU_row(cinfo); 249 return JPEG_ROW_COMPLETED; 250 } 251 /* Completed the scan */ 252 (*cinfo->inputctl->finish_input_pass) (cinfo); 253 return JPEG_SCAN_COMPLETED; 254 } 255 256 257 /* 258 * Decompress and return some data in the multi-pass case. 259 * Always attempts to emit one fully interleaved MCU row ("iMCU" row). 260 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. 261 * 262 * NB: output_buf contains a plane for each component in image. 263 */ 264 265 METHODDEF(int) 266 decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) 267 { 268 my_coef_ptr coef = (my_coef_ptr)cinfo->coef; 269 JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; 270 JDIMENSION block_num; 271 int ci, block_row, block_rows; 272 JBLOCKARRAY buffer; 273 JBLOCKROW buffer_ptr; 274 _JSAMPARRAY output_ptr; 275 JDIMENSION output_col; 276 jpeg_component_info *compptr; 277 _inverse_DCT_method_ptr inverse_DCT; 278 279 /* Force some input to be done if we are getting ahead of the input. */ 280 while (cinfo->input_scan_number < cinfo->output_scan_number || 281 (cinfo->input_scan_number == cinfo->output_scan_number && 282 cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) { 283 if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) 284 return JPEG_SUSPENDED; 285 } 286 287 /* OK, output from the virtual arrays. */ 288 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 289 ci++, compptr++) { 290 /* Don't bother to IDCT an uninteresting component. */ 291 if (!compptr->component_needed) 292 continue; 293 /* Align the virtual buffer for this component. */ 294 buffer = (*cinfo->mem->access_virt_barray) 295 ((j_common_ptr)cinfo, coef->whole_image[ci], 296 cinfo->output_iMCU_row * compptr->v_samp_factor, 297 (JDIMENSION)compptr->v_samp_factor, FALSE); 298 /* Count non-dummy DCT block rows in this iMCU row. */ 299 if (cinfo->output_iMCU_row < last_iMCU_row) 300 block_rows = compptr->v_samp_factor; 301 else { 302 /* NB: can't use last_row_height here; it is input-side-dependent! */ 303 block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor); 304 if (block_rows == 0) block_rows = compptr->v_samp_factor; 305 } 306 inverse_DCT = cinfo->idct->_inverse_DCT[ci]; 307 output_ptr = output_buf[ci]; 308 /* Loop over all DCT blocks to be processed. */ 309 for (block_row = 0; block_row < block_rows; block_row++) { 310 buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci]; 311 output_col = 0; 312 for (block_num = cinfo->master->first_MCU_col[ci]; 313 block_num <= cinfo->master->last_MCU_col[ci]; block_num++) { 314 (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)buffer_ptr, output_ptr, 315 output_col); 316 buffer_ptr++; 317 output_col += compptr->_DCT_scaled_size; 318 } 319 output_ptr += compptr->_DCT_scaled_size; 320 } 321 } 322 323 if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) 324 return JPEG_ROW_COMPLETED; 325 return JPEG_SCAN_COMPLETED; 326 } 327 328 #endif /* D_MULTISCAN_FILES_SUPPORTED */ 329 330 331 #ifdef BLOCK_SMOOTHING_SUPPORTED 332 333 /* 334 * This code applies interblock smoothing; the first 9 AC coefficients are 335 * estimated from the DC values of a DCT block and its 24 neighboring blocks. 336 * We apply smoothing only for progressive JPEG decoding, and only if 337 * the coefficients it can estimate are not yet known to full precision. 338 */ 339 340 /* Natural-order array positions of the first 9 zigzag-order coefficients */ 341 #define Q01_POS 1 342 #define Q10_POS 8 343 #define Q20_POS 16 344 #define Q11_POS 9 345 #define Q02_POS 2 346 #define Q03_POS 3 347 #define Q12_POS 10 348 #define Q21_POS 17 349 #define Q30_POS 24 350 351 /* 352 * Determine whether block smoothing is applicable and safe. 353 * We also latch the current states of the coef_bits[] entries for the 354 * AC coefficients; otherwise, if the input side of the decompressor 355 * advances into a new scan, we might think the coefficients are known 356 * more accurately than they really are. 357 */ 358 359 LOCAL(boolean) 360 smoothing_ok(j_decompress_ptr cinfo) 361 { 362 my_coef_ptr coef = (my_coef_ptr)cinfo->coef; 363 boolean smoothing_useful = FALSE; 364 int ci, coefi; 365 jpeg_component_info *compptr; 366 JQUANT_TBL *qtable; 367 int *coef_bits, *prev_coef_bits; 368 int *coef_bits_latch, *prev_coef_bits_latch; 369 370 if (!cinfo->progressive_mode || cinfo->coef_bits == NULL) 371 return FALSE; 372 373 /* Allocate latch area if not already done */ 374 if (coef->coef_bits_latch == NULL) 375 coef->coef_bits_latch = (int *) 376 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, 377 cinfo->num_components * 2 * 378 (SAVED_COEFS * sizeof(int))); 379 coef_bits_latch = coef->coef_bits_latch; 380 prev_coef_bits_latch = 381 &coef->coef_bits_latch[cinfo->num_components * SAVED_COEFS]; 382 383 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 384 ci++, compptr++) { 385 /* All components' quantization values must already be latched. */ 386 if ((qtable = compptr->quant_table) == NULL) 387 return FALSE; 388 /* Verify DC & first 9 AC quantizers are nonzero to avoid zero-divide. */ 389 if (qtable->quantval[0] == 0 || 390 qtable->quantval[Q01_POS] == 0 || 391 qtable->quantval[Q10_POS] == 0 || 392 qtable->quantval[Q20_POS] == 0 || 393 qtable->quantval[Q11_POS] == 0 || 394 qtable->quantval[Q02_POS] == 0 || 395 qtable->quantval[Q03_POS] == 0 || 396 qtable->quantval[Q12_POS] == 0 || 397 qtable->quantval[Q21_POS] == 0 || 398 qtable->quantval[Q30_POS] == 0) 399 return FALSE; 400 /* DC values must be at least partly known for all components. */ 401 coef_bits = cinfo->coef_bits[ci]; 402 prev_coef_bits = cinfo->coef_bits[ci + cinfo->num_components]; 403 if (coef_bits[0] < 0) 404 return FALSE; 405 coef_bits_latch[0] = coef_bits[0]; 406 /* Block smoothing is helpful if some AC coefficients remain inaccurate. */ 407 for (coefi = 1; coefi < SAVED_COEFS; coefi++) { 408 if (cinfo->input_scan_number > 1) 409 prev_coef_bits_latch[coefi] = prev_coef_bits[coefi]; 410 else 411 prev_coef_bits_latch[coefi] = -1; 412 coef_bits_latch[coefi] = coef_bits[coefi]; 413 if (coef_bits[coefi] != 0) 414 smoothing_useful = TRUE; 415 } 416 coef_bits_latch += SAVED_COEFS; 417 prev_coef_bits_latch += SAVED_COEFS; 418 } 419 420 return smoothing_useful; 421 } 422 423 424 /* 425 * Variant of decompress_data for use when doing block smoothing. 426 */ 427 428 METHODDEF(int) 429 decompress_smooth_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) 430 { 431 my_coef_ptr coef = (my_coef_ptr)cinfo->coef; 432 JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; 433 JDIMENSION block_num, last_block_column; 434 int ci, block_row, block_rows, access_rows, image_block_row, 435 image_block_rows; 436 JBLOCKARRAY buffer; 437 JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row; 438 JBLOCKROW next_block_row, next_next_block_row; 439 _JSAMPARRAY output_ptr; 440 JDIMENSION output_col; 441 jpeg_component_info *compptr; 442 _inverse_DCT_method_ptr inverse_DCT; 443 boolean change_dc; 444 JCOEF *workspace; 445 int *coef_bits; 446 JQUANT_TBL *quanttbl; 447 JLONG Q00, Q01, Q02, Q03 = 0, Q10, Q11, Q12 = 0, Q20, Q21 = 0, Q30 = 0, num; 448 int DC01, DC02, DC03, DC04, DC05, DC06, DC07, DC08, DC09, DC10, DC11, DC12, 449 DC13, DC14, DC15, DC16, DC17, DC18, DC19, DC20, DC21, DC22, DC23, DC24, 450 DC25; 451 int Al, pred; 452 453 /* Keep a local variable to avoid looking it up more than once */ 454 workspace = coef->workspace; 455 456 /* Force some input to be done if we are getting ahead of the input. */ 457 while (cinfo->input_scan_number <= cinfo->output_scan_number && 458 !cinfo->inputctl->eoi_reached) { 459 if (cinfo->input_scan_number == cinfo->output_scan_number) { 460 /* If input is working on current scan, we ordinarily want it to 461 * have completed the current row. But if input scan is DC, 462 * we want it to keep two rows ahead so that next two block rows' DC 463 * values are up to date. 464 */ 465 JDIMENSION delta = (cinfo->Ss == 0) ? 2 : 0; 466 if (cinfo->input_iMCU_row > cinfo->output_iMCU_row + delta) 467 break; 468 } 469 if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) 470 return JPEG_SUSPENDED; 471 } 472 473 /* OK, output from the virtual arrays. */ 474 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 475 ci++, compptr++) { 476 /* Don't bother to IDCT an uninteresting component. */ 477 if (!compptr->component_needed) 478 continue; 479 /* Count non-dummy DCT block rows in this iMCU row. */ 480 if (cinfo->output_iMCU_row + 1 < last_iMCU_row) { 481 block_rows = compptr->v_samp_factor; 482 access_rows = block_rows * 3; /* this and next two iMCU rows */ 483 } else if (cinfo->output_iMCU_row < last_iMCU_row) { 484 block_rows = compptr->v_samp_factor; 485 access_rows = block_rows * 2; /* this and next iMCU row */ 486 } else { 487 /* NB: can't use last_row_height here; it is input-side-dependent! */ 488 block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor); 489 if (block_rows == 0) block_rows = compptr->v_samp_factor; 490 access_rows = block_rows; /* this iMCU row only */ 491 } 492 /* Align the virtual buffer for this component. */ 493 if (cinfo->output_iMCU_row > 1) { 494 access_rows += 2 * compptr->v_samp_factor; /* prior two iMCU rows too */ 495 buffer = (*cinfo->mem->access_virt_barray) 496 ((j_common_ptr)cinfo, coef->whole_image[ci], 497 (cinfo->output_iMCU_row - 2) * compptr->v_samp_factor, 498 (JDIMENSION)access_rows, FALSE); 499 buffer += 2 * compptr->v_samp_factor; /* point to current iMCU row */ 500 } else if (cinfo->output_iMCU_row > 0) { 501 access_rows += compptr->v_samp_factor; /* prior iMCU row too */ 502 buffer = (*cinfo->mem->access_virt_barray) 503 ((j_common_ptr)cinfo, coef->whole_image[ci], 504 (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor, 505 (JDIMENSION)access_rows, FALSE); 506 buffer += compptr->v_samp_factor; /* point to current iMCU row */ 507 } else { 508 buffer = (*cinfo->mem->access_virt_barray) 509 ((j_common_ptr)cinfo, coef->whole_image[ci], 510 (JDIMENSION)0, (JDIMENSION)access_rows, FALSE); 511 } 512 /* Fetch component-dependent info. 513 * If the current scan is incomplete, then we use the component-dependent 514 * info from the previous scan. 515 */ 516 if (cinfo->output_iMCU_row > cinfo->master->last_good_iMCU_row) 517 coef_bits = 518 coef->coef_bits_latch + ((ci + cinfo->num_components) * SAVED_COEFS); 519 else 520 coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS); 521 522 /* We only do DC interpolation if no AC coefficient data is available. */ 523 change_dc = 524 coef_bits[1] == -1 && coef_bits[2] == -1 && coef_bits[3] == -1 && 525 coef_bits[4] == -1 && coef_bits[5] == -1 && coef_bits[6] == -1 && 526 coef_bits[7] == -1 && coef_bits[8] == -1 && coef_bits[9] == -1; 527 528 quanttbl = compptr->quant_table; 529 Q00 = quanttbl->quantval[0]; 530 Q01 = quanttbl->quantval[Q01_POS]; 531 Q10 = quanttbl->quantval[Q10_POS]; 532 Q20 = quanttbl->quantval[Q20_POS]; 533 Q11 = quanttbl->quantval[Q11_POS]; 534 Q02 = quanttbl->quantval[Q02_POS]; 535 if (change_dc) { 536 Q03 = quanttbl->quantval[Q03_POS]; 537 Q12 = quanttbl->quantval[Q12_POS]; 538 Q21 = quanttbl->quantval[Q21_POS]; 539 Q30 = quanttbl->quantval[Q30_POS]; 540 } 541 inverse_DCT = cinfo->idct->_inverse_DCT[ci]; 542 output_ptr = output_buf[ci]; 543 /* Loop over all DCT blocks to be processed. */ 544 image_block_rows = block_rows * cinfo->total_iMCU_rows; 545 for (block_row = 0; block_row < block_rows; block_row++) { 546 image_block_row = cinfo->output_iMCU_row * block_rows + block_row; 547 buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci]; 548 549 if (image_block_row > 0) 550 prev_block_row = 551 buffer[block_row - 1] + cinfo->master->first_MCU_col[ci]; 552 else 553 prev_block_row = buffer_ptr; 554 555 if (image_block_row > 1) 556 prev_prev_block_row = 557 buffer[block_row - 2] + cinfo->master->first_MCU_col[ci]; 558 else 559 prev_prev_block_row = prev_block_row; 560 561 if (image_block_row < image_block_rows - 1) 562 next_block_row = 563 buffer[block_row + 1] + cinfo->master->first_MCU_col[ci]; 564 else 565 next_block_row = buffer_ptr; 566 567 if (image_block_row < image_block_rows - 2) 568 next_next_block_row = 569 buffer[block_row + 2] + cinfo->master->first_MCU_col[ci]; 570 else 571 next_next_block_row = next_block_row; 572 573 /* We fetch the surrounding DC values using a sliding-register approach. 574 * Initialize all 25 here so as to do the right thing on narrow pics. 575 */ 576 DC01 = DC02 = DC03 = DC04 = DC05 = (int)prev_prev_block_row[0][0]; 577 DC06 = DC07 = DC08 = DC09 = DC10 = (int)prev_block_row[0][0]; 578 DC11 = DC12 = DC13 = DC14 = DC15 = (int)buffer_ptr[0][0]; 579 DC16 = DC17 = DC18 = DC19 = DC20 = (int)next_block_row[0][0]; 580 DC21 = DC22 = DC23 = DC24 = DC25 = (int)next_next_block_row[0][0]; 581 output_col = 0; 582 last_block_column = compptr->width_in_blocks - 1; 583 for (block_num = cinfo->master->first_MCU_col[ci]; 584 block_num <= cinfo->master->last_MCU_col[ci]; block_num++) { 585 /* Fetch current DCT block into workspace so we can modify it. */ 586 jcopy_block_row(buffer_ptr, (JBLOCKROW)workspace, (JDIMENSION)1); 587 /* Update DC values */ 588 if (block_num == cinfo->master->first_MCU_col[ci] && 589 block_num < last_block_column) { 590 DC04 = DC05 = (int)prev_prev_block_row[1][0]; 591 DC09 = DC10 = (int)prev_block_row[1][0]; 592 DC14 = DC15 = (int)buffer_ptr[1][0]; 593 DC19 = DC20 = (int)next_block_row[1][0]; 594 DC24 = DC25 = (int)next_next_block_row[1][0]; 595 } 596 if (block_num + 1 < last_block_column) { 597 DC05 = (int)prev_prev_block_row[2][0]; 598 DC10 = (int)prev_block_row[2][0]; 599 DC15 = (int)buffer_ptr[2][0]; 600 DC20 = (int)next_block_row[2][0]; 601 DC25 = (int)next_next_block_row[2][0]; 602 } 603 /* If DC interpolation is enabled, compute coefficient estimates using 604 * a Gaussian-like kernel, keeping the averages of the DC values. 605 * 606 * If DC interpolation is disabled, compute coefficient estimates using 607 * an algorithm similar to the one described in Section K.8 of the JPEG 608 * standard, except applied to a 5x5 window rather than a 3x3 window. 609 * 610 * An estimate is applied only if the coefficient is still zero and is 611 * not known to be fully accurate. 612 */ 613 /* AC01 */ 614 if ((Al = coef_bits[1]) != 0 && workspace[1] == 0) { 615 num = Q00 * (change_dc ? 616 (-DC01 - DC02 + DC04 + DC05 - 3 * DC06 + 13 * DC07 - 617 13 * DC09 + 3 * DC10 - 3 * DC11 + 38 * DC12 - 38 * DC14 + 618 3 * DC15 - 3 * DC16 + 13 * DC17 - 13 * DC19 + 3 * DC20 - 619 DC21 - DC22 + DC24 + DC25) : 620 (-7 * DC11 + 50 * DC12 - 50 * DC14 + 7 * DC15)); 621 if (num >= 0) { 622 pred = (int)(((Q01 << 7) + num) / (Q01 << 8)); 623 if (Al > 0 && pred >= (1 << Al)) 624 pred = (1 << Al) - 1; 625 } else { 626 pred = (int)(((Q01 << 7) - num) / (Q01 << 8)); 627 if (Al > 0 && pred >= (1 << Al)) 628 pred = (1 << Al) - 1; 629 pred = -pred; 630 } 631 workspace[1] = (JCOEF)pred; 632 } 633 /* AC10 */ 634 if ((Al = coef_bits[2]) != 0 && workspace[8] == 0) { 635 num = Q00 * (change_dc ? 636 (-DC01 - 3 * DC02 - 3 * DC03 - 3 * DC04 - DC05 - DC06 + 637 13 * DC07 + 38 * DC08 + 13 * DC09 - DC10 + DC16 - 638 13 * DC17 - 38 * DC18 - 13 * DC19 + DC20 + DC21 + 639 3 * DC22 + 3 * DC23 + 3 * DC24 + DC25) : 640 (-7 * DC03 + 50 * DC08 - 50 * DC18 + 7 * DC23)); 641 if (num >= 0) { 642 pred = (int)(((Q10 << 7) + num) / (Q10 << 8)); 643 if (Al > 0 && pred >= (1 << Al)) 644 pred = (1 << Al) - 1; 645 } else { 646 pred = (int)(((Q10 << 7) - num) / (Q10 << 8)); 647 if (Al > 0 && pred >= (1 << Al)) 648 pred = (1 << Al) - 1; 649 pred = -pred; 650 } 651 workspace[8] = (JCOEF)pred; 652 } 653 /* AC20 */ 654 if ((Al = coef_bits[3]) != 0 && workspace[16] == 0) { 655 num = Q00 * (change_dc ? 656 (DC03 + 2 * DC07 + 7 * DC08 + 2 * DC09 - 5 * DC12 - 14 * DC13 - 657 5 * DC14 + 2 * DC17 + 7 * DC18 + 2 * DC19 + DC23) : 658 (-DC03 + 13 * DC08 - 24 * DC13 + 13 * DC18 - DC23)); 659 if (num >= 0) { 660 pred = (int)(((Q20 << 7) + num) / (Q20 << 8)); 661 if (Al > 0 && pred >= (1 << Al)) 662 pred = (1 << Al) - 1; 663 } else { 664 pred = (int)(((Q20 << 7) - num) / (Q20 << 8)); 665 if (Al > 0 && pred >= (1 << Al)) 666 pred = (1 << Al) - 1; 667 pred = -pred; 668 } 669 workspace[16] = (JCOEF)pred; 670 } 671 /* AC11 */ 672 if ((Al = coef_bits[4]) != 0 && workspace[9] == 0) { 673 num = Q00 * (change_dc ? 674 (-DC01 + DC05 + 9 * DC07 - 9 * DC09 - 9 * DC17 + 675 9 * DC19 + DC21 - DC25) : 676 (DC10 + DC16 - 10 * DC17 + 10 * DC19 - DC02 - DC20 + DC22 - 677 DC24 + DC04 - DC06 + 10 * DC07 - 10 * DC09)); 678 if (num >= 0) { 679 pred = (int)(((Q11 << 7) + num) / (Q11 << 8)); 680 if (Al > 0 && pred >= (1 << Al)) 681 pred = (1 << Al) - 1; 682 } else { 683 pred = (int)(((Q11 << 7) - num) / (Q11 << 8)); 684 if (Al > 0 && pred >= (1 << Al)) 685 pred = (1 << Al) - 1; 686 pred = -pred; 687 } 688 workspace[9] = (JCOEF)pred; 689 } 690 /* AC02 */ 691 if ((Al = coef_bits[5]) != 0 && workspace[2] == 0) { 692 num = Q00 * (change_dc ? 693 (2 * DC07 - 5 * DC08 + 2 * DC09 + DC11 + 7 * DC12 - 14 * DC13 + 694 7 * DC14 + DC15 + 2 * DC17 - 5 * DC18 + 2 * DC19) : 695 (-DC11 + 13 * DC12 - 24 * DC13 + 13 * DC14 - DC15)); 696 if (num >= 0) { 697 pred = (int)(((Q02 << 7) + num) / (Q02 << 8)); 698 if (Al > 0 && pred >= (1 << Al)) 699 pred = (1 << Al) - 1; 700 } else { 701 pred = (int)(((Q02 << 7) - num) / (Q02 << 8)); 702 if (Al > 0 && pred >= (1 << Al)) 703 pred = (1 << Al) - 1; 704 pred = -pred; 705 } 706 workspace[2] = (JCOEF)pred; 707 } 708 if (change_dc) { 709 /* AC03 */ 710 if ((Al = coef_bits[6]) != 0 && workspace[3] == 0) { 711 num = Q00 * (DC07 - DC09 + 2 * DC12 - 2 * DC14 + DC17 - DC19); 712 if (num >= 0) { 713 pred = (int)(((Q03 << 7) + num) / (Q03 << 8)); 714 if (Al > 0 && pred >= (1 << Al)) 715 pred = (1 << Al) - 1; 716 } else { 717 pred = (int)(((Q03 << 7) - num) / (Q03 << 8)); 718 if (Al > 0 && pred >= (1 << Al)) 719 pred = (1 << Al) - 1; 720 pred = -pred; 721 } 722 workspace[3] = (JCOEF)pred; 723 } 724 /* AC12 */ 725 if ((Al = coef_bits[7]) != 0 && workspace[10] == 0) { 726 num = Q00 * (DC07 - 3 * DC08 + DC09 - DC17 + 3 * DC18 - DC19); 727 if (num >= 0) { 728 pred = (int)(((Q12 << 7) + num) / (Q12 << 8)); 729 if (Al > 0 && pred >= (1 << Al)) 730 pred = (1 << Al) - 1; 731 } else { 732 pred = (int)(((Q12 << 7) - num) / (Q12 << 8)); 733 if (Al > 0 && pred >= (1 << Al)) 734 pred = (1 << Al) - 1; 735 pred = -pred; 736 } 737 workspace[10] = (JCOEF)pred; 738 } 739 /* AC21 */ 740 if ((Al = coef_bits[8]) != 0 && workspace[17] == 0) { 741 num = Q00 * (DC07 - DC09 - 3 * DC12 + 3 * DC14 + DC17 - DC19); 742 if (num >= 0) { 743 pred = (int)(((Q21 << 7) + num) / (Q21 << 8)); 744 if (Al > 0 && pred >= (1 << Al)) 745 pred = (1 << Al) - 1; 746 } else { 747 pred = (int)(((Q21 << 7) - num) / (Q21 << 8)); 748 if (Al > 0 && pred >= (1 << Al)) 749 pred = (1 << Al) - 1; 750 pred = -pred; 751 } 752 workspace[17] = (JCOEF)pred; 753 } 754 /* AC30 */ 755 if ((Al = coef_bits[9]) != 0 && workspace[24] == 0) { 756 num = Q00 * (DC07 + 2 * DC08 + DC09 - DC17 - 2 * DC18 - DC19); 757 if (num >= 0) { 758 pred = (int)(((Q30 << 7) + num) / (Q30 << 8)); 759 if (Al > 0 && pred >= (1 << Al)) 760 pred = (1 << Al) - 1; 761 } else { 762 pred = (int)(((Q30 << 7) - num) / (Q30 << 8)); 763 if (Al > 0 && pred >= (1 << Al)) 764 pred = (1 << Al) - 1; 765 pred = -pred; 766 } 767 workspace[24] = (JCOEF)pred; 768 } 769 /* coef_bits[0] is non-negative. Otherwise this function would not 770 * be called. 771 */ 772 num = Q00 * 773 (-2 * DC01 - 6 * DC02 - 8 * DC03 - 6 * DC04 - 2 * DC05 - 774 6 * DC06 + 6 * DC07 + 42 * DC08 + 6 * DC09 - 6 * DC10 - 775 8 * DC11 + 42 * DC12 + 152 * DC13 + 42 * DC14 - 8 * DC15 - 776 6 * DC16 + 6 * DC17 + 42 * DC18 + 6 * DC19 - 6 * DC20 - 777 2 * DC21 - 6 * DC22 - 8 * DC23 - 6 * DC24 - 2 * DC25); 778 if (num >= 0) { 779 pred = (int)(((Q00 << 7) + num) / (Q00 << 8)); 780 } else { 781 pred = (int)(((Q00 << 7) - num) / (Q00 << 8)); 782 pred = -pred; 783 } 784 workspace[0] = (JCOEF)pred; 785 } /* change_dc */ 786 787 /* OK, do the IDCT */ 788 (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)workspace, output_ptr, 789 output_col); 790 /* Advance for next column */ 791 DC01 = DC02; DC02 = DC03; DC03 = DC04; DC04 = DC05; 792 DC06 = DC07; DC07 = DC08; DC08 = DC09; DC09 = DC10; 793 DC11 = DC12; DC12 = DC13; DC13 = DC14; DC14 = DC15; 794 DC16 = DC17; DC17 = DC18; DC18 = DC19; DC19 = DC20; 795 DC21 = DC22; DC22 = DC23; DC23 = DC24; DC24 = DC25; 796 buffer_ptr++, prev_block_row++, next_block_row++, 797 prev_prev_block_row++, next_next_block_row++; 798 output_col += compptr->_DCT_scaled_size; 799 } 800 output_ptr += compptr->_DCT_scaled_size; 801 } 802 } 803 804 if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) 805 return JPEG_ROW_COMPLETED; 806 return JPEG_SCAN_COMPLETED; 807 } 808 809 #endif /* BLOCK_SMOOTHING_SUPPORTED */ 810 811 812 /* 813 * Initialize coefficient buffer controller. 814 */ 815 816 GLOBAL(void) 817 _jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer) 818 { 819 my_coef_ptr coef; 820 821 if (cinfo->data_precision != BITS_IN_JSAMPLE) 822 ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); 823 824 coef = (my_coef_ptr) 825 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, 826 sizeof(my_coef_controller)); 827 cinfo->coef = (struct jpeg_d_coef_controller *)coef; 828 coef->pub.start_input_pass = start_input_pass; 829 coef->pub.start_output_pass = start_output_pass; 830 #ifdef BLOCK_SMOOTHING_SUPPORTED 831 coef->coef_bits_latch = NULL; 832 #endif 833 834 /* Create the coefficient buffer. */ 835 if (need_full_buffer) { 836 #ifdef D_MULTISCAN_FILES_SUPPORTED 837 /* Allocate a full-image virtual array for each component, */ 838 /* padded to a multiple of samp_factor DCT blocks in each direction. */ 839 /* Note we ask for a pre-zeroed array. */ 840 int ci, access_rows; 841 jpeg_component_info *compptr; 842 843 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 844 ci++, compptr++) { 845 access_rows = compptr->v_samp_factor; 846 #ifdef BLOCK_SMOOTHING_SUPPORTED 847 /* If block smoothing could be used, need a bigger window */ 848 if (cinfo->progressive_mode) 849 access_rows *= 5; 850 #endif 851 coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) 852 ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE, 853 (JDIMENSION)jround_up((long)compptr->width_in_blocks, 854 (long)compptr->h_samp_factor), 855 (JDIMENSION)jround_up((long)compptr->height_in_blocks, 856 (long)compptr->v_samp_factor), 857 (JDIMENSION)access_rows); 858 } 859 coef->pub.consume_data = consume_data; 860 coef->pub._decompress_data = decompress_data; 861 coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */ 862 #else 863 ERREXIT(cinfo, JERR_NOT_COMPILED); 864 #endif 865 } else { 866 /* We only need a single-MCU buffer. */ 867 JBLOCKROW buffer; 868 int i; 869 870 buffer = (JBLOCKROW) 871 (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE, 872 D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK)); 873 for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) { 874 coef->MCU_buffer[i] = buffer + i; 875 } 876 coef->pub.consume_data = dummy_consume_data; 877 coef->pub._decompress_data = decompress_onepass; 878 coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */ 879 } 880 881 /* Allocate the workspace buffer */ 882 coef->workspace = (JCOEF *) 883 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, 884 sizeof(JCOEF) * DCTSIZE2); 885 }