1 /* 2 * jdapistd.c 3 * 4 * This file was part of the Independent JPEG Group's software: 5 * Copyright (C) 1994-1996, Thomas G. Lane. 6 * libjpeg-turbo Modifications: 7 * Copyright (C) 2010, 2015-2017, D. R. Commander. 8 * Copyright (C) 2015, Google, Inc. 9 * For conditions of distribution and use, see the accompanying README.ijg 10 * file. 11 * 12 * This file contains application interface code for the decompression half 13 * of the JPEG library. These are the "standard" API routines that are 14 * used in the normal full-decompression case. They are not used by a 15 * transcoding-only application. Note that if an application links in 16 * jpeg_start_decompress, it will end up linking in the entire decompressor. 17 * We thus must separate this file from jdapimin.c to avoid linking the 18 * whole decompression library into a transcoder. 19 */ 20 21 #include "jinclude.h" 22 #include "jdmainct.h" 23 #include "jdcoefct.h" 24 #include "jdsample.h" 25 #include "jmemsys.h" 26 27 /* Forward declarations */ 28 LOCAL(boolean) output_pass_setup (j_decompress_ptr cinfo); 29 30 31 /* 32 * Decompression initialization. 33 * jpeg_read_header must be completed before calling this. 34 * 35 * If a multipass operating mode was selected, this will do all but the 36 * last pass, and thus may take a great deal of time. 37 * 38 * Returns FALSE if suspended. The return value need be inspected only if 39 * a suspending data source is used. 40 */ 41 42 GLOBAL(boolean) 43 jpeg_start_decompress (j_decompress_ptr cinfo) 44 { 45 if (cinfo->global_state == DSTATE_READY) { 46 /* First call: initialize master control, select active modules */ 47 jinit_master_decompress(cinfo); 48 if (cinfo->buffered_image) { 49 /* No more work here; expecting jpeg_start_output next */ 50 cinfo->global_state = DSTATE_BUFIMAGE; 51 return TRUE; 52 } 53 cinfo->global_state = DSTATE_PRELOAD; 54 } 55 if (cinfo->global_state == DSTATE_PRELOAD) { 56 /* If file has multiple scans, absorb them all into the coef buffer */ 57 if (cinfo->inputctl->has_multiple_scans) { 58 #ifdef D_MULTISCAN_FILES_SUPPORTED 59 for (;;) { 60 int retcode; 61 /* Call progress monitor hook if present */ 62 if (cinfo->progress != NULL) 63 (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); 64 /* Absorb some more input */ 65 retcode = (*cinfo->inputctl->consume_input) (cinfo); 66 if (retcode == JPEG_SUSPENDED) 67 return FALSE; 68 if (retcode == JPEG_REACHED_EOI) 69 break; 70 /* Advance progress counter if appropriate */ 71 if (cinfo->progress != NULL && 72 (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) { 73 if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) { 74 /* jdmaster underestimated number of scans; ratchet up one scan */ 75 cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows; 76 } 77 } 78 } 79 #else 80 ERREXIT(cinfo, JERR_NOT_COMPILED); 81 #endif /* D_MULTISCAN_FILES_SUPPORTED */ 82 } 83 cinfo->output_scan_number = cinfo->input_scan_number; 84 } else if (cinfo->global_state != DSTATE_PRESCAN) 85 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 86 /* Perform any dummy output passes, and set up for the final pass */ 87 return output_pass_setup(cinfo); 88 } 89 90 91 /* 92 * Set up for an output pass, and perform any dummy pass(es) needed. 93 * Common subroutine for jpeg_start_decompress and jpeg_start_output. 94 * Entry: global_state = DSTATE_PRESCAN only if previously suspended. 95 * Exit: If done, returns TRUE and sets global_state for proper output mode. 96 * If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN. 97 */ 98 99 LOCAL(boolean) 100 output_pass_setup (j_decompress_ptr cinfo) 101 { 102 if (cinfo->global_state != DSTATE_PRESCAN) { 103 /* First call: do pass setup */ 104 (*cinfo->master->prepare_for_output_pass) (cinfo); 105 cinfo->output_scanline = 0; 106 cinfo->global_state = DSTATE_PRESCAN; 107 } 108 /* Loop over any required dummy passes */ 109 while (cinfo->master->is_dummy_pass) { 110 #ifdef QUANT_2PASS_SUPPORTED 111 /* Crank through the dummy pass */ 112 while (cinfo->output_scanline < cinfo->output_height) { 113 JDIMENSION last_scanline; 114 /* Call progress monitor hook if present */ 115 if (cinfo->progress != NULL) { 116 cinfo->progress->pass_counter = (long) cinfo->output_scanline; 117 cinfo->progress->pass_limit = (long) cinfo->output_height; 118 (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); 119 } 120 /* Process some data */ 121 last_scanline = cinfo->output_scanline; 122 (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL, 123 &cinfo->output_scanline, (JDIMENSION) 0); 124 if (cinfo->output_scanline == last_scanline) 125 return FALSE; /* No progress made, must suspend */ 126 } 127 /* Finish up dummy pass, and set up for another one */ 128 (*cinfo->master->finish_output_pass) (cinfo); 129 (*cinfo->master->prepare_for_output_pass) (cinfo); 130 cinfo->output_scanline = 0; 131 #else 132 ERREXIT(cinfo, JERR_NOT_COMPILED); 133 #endif /* QUANT_2PASS_SUPPORTED */ 134 } 135 /* Ready for application to drive output pass through 136 * jpeg_read_scanlines or jpeg_read_raw_data. 137 */ 138 cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING; 139 return TRUE; 140 } 141 142 143 /* 144 * Enable partial scanline decompression 145 * 146 * Must be called after jpeg_start_decompress() and before any calls to 147 * jpeg_read_scanlines() or jpeg_skip_scanlines(). 148 * 149 * Refer to libjpeg.txt for more information. 150 */ 151 152 GLOBAL(void) 153 jpeg_crop_scanline (j_decompress_ptr cinfo, JDIMENSION *xoffset, 154 JDIMENSION *width) 155 { 156 int ci, align, orig_downsampled_width; 157 JDIMENSION input_xoffset; 158 boolean reinit_upsampler = FALSE; 159 jpeg_component_info *compptr; 160 161 if (cinfo->global_state != DSTATE_SCANNING || cinfo->output_scanline != 0) 162 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 163 164 if (!xoffset || !width) 165 ERREXIT(cinfo, JERR_BAD_CROP_SPEC); 166 167 /* xoffset and width must fall within the output image dimensions. */ 168 if (*width == 0 || *xoffset + *width > cinfo->output_width) 169 ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); 170 171 /* No need to do anything if the caller wants the entire width. */ 172 if (*width == cinfo->output_width) 173 return; 174 175 /* Ensuring the proper alignment of xoffset is tricky. At minimum, it 176 * must align with an MCU boundary, because: 177 * 178 * (1) The IDCT is performed in blocks, and it is not feasible to modify 179 * the algorithm so that it can transform partial blocks. 180 * (2) Because of the SIMD extensions, any input buffer passed to the 181 * upsampling and color conversion routines must be aligned to the 182 * SIMD word size (for instance, 128-bit in the case of SSE2.) The 183 * easiest way to accomplish this without copying data is to ensure 184 * that upsampling and color conversion begin at the start of the 185 * first MCU column that will be inverse transformed. 186 * 187 * In practice, we actually impose a stricter alignment requirement. We 188 * require that xoffset be a multiple of the maximum MCU column width of all 189 * of the components (the "iMCU column width.") This is to simplify the 190 * single-pass decompression case, allowing us to use the same MCU column 191 * width for all of the components. 192 */ 193 if (cinfo->comps_in_scan == 1 && cinfo->num_components == 1) 194 align = cinfo->_min_DCT_scaled_size; 195 else 196 align = cinfo->_min_DCT_scaled_size * cinfo->max_h_samp_factor; 197 198 /* Adjust xoffset to the nearest iMCU boundary <= the requested value */ 199 input_xoffset = *xoffset; 200 *xoffset = (input_xoffset / align) * align; 201 202 /* Adjust the width so that the right edge of the output image is as 203 * requested (only the left edge is altered.) It is important that calling 204 * programs check this value after this function returns, so that they can 205 * allocate an output buffer with the appropriate size. 206 */ 207 *width = *width + input_xoffset - *xoffset; 208 cinfo->output_width = *width; 209 210 /* Set the first and last iMCU columns that we must decompress. These values 211 * will be used in single-scan decompressions. 212 */ 213 cinfo->master->first_iMCU_col = 214 (JDIMENSION) (long) (*xoffset) / (long) align; 215 cinfo->master->last_iMCU_col = 216 (JDIMENSION) jdiv_round_up((long) (*xoffset + cinfo->output_width), 217 (long) align) - 1; 218 219 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 220 ci++, compptr++) { 221 int hsf = (cinfo->comps_in_scan == 1 && cinfo->num_components == 1) ? 222 1 : compptr->h_samp_factor; 223 224 /* Set downsampled_width to the new output width. */ 225 orig_downsampled_width = compptr->downsampled_width; 226 compptr->downsampled_width = 227 (JDIMENSION) jdiv_round_up((long) (cinfo->output_width * 228 compptr->h_samp_factor), 229 (long) cinfo->max_h_samp_factor); 230 if (compptr->downsampled_width < 2 && orig_downsampled_width >= 2) 231 reinit_upsampler = TRUE; 232 233 /* Set the first and last iMCU columns that we must decompress. These 234 * values will be used in multi-scan decompressions. 235 */ 236 cinfo->master->first_MCU_col[ci] = 237 (JDIMENSION) (long) (*xoffset * hsf) / (long) align; 238 cinfo->master->last_MCU_col[ci] = 239 (JDIMENSION) jdiv_round_up((long) ((*xoffset + cinfo->output_width) * 240 hsf), 241 (long) align) - 1; 242 } 243 244 if (reinit_upsampler) { 245 cinfo->master->jinit_upsampler_no_alloc = TRUE; 246 jinit_upsampler(cinfo); 247 cinfo->master->jinit_upsampler_no_alloc = FALSE; 248 } 249 } 250 251 252 /* 253 * Read some scanlines of data from the JPEG decompressor. 254 * 255 * The return value will be the number of lines actually read. 256 * This may be less than the number requested in several cases, 257 * including bottom of image, data source suspension, and operating 258 * modes that emit multiple scanlines at a time. 259 * 260 * Note: we warn about excess calls to jpeg_read_scanlines() since 261 * this likely signals an application programmer error. However, 262 * an oversize buffer (max_lines > scanlines remaining) is not an error. 263 */ 264 265 GLOBAL(JDIMENSION) 266 jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines, 267 JDIMENSION max_lines) 268 { 269 JDIMENSION row_ctr; 270 271 if (cinfo->global_state != DSTATE_SCANNING) 272 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 273 if (cinfo->output_scanline >= cinfo->output_height) { 274 WARNMS(cinfo, JWRN_TOO_MUCH_DATA); 275 return 0; 276 } 277 278 /* Call progress monitor hook if present */ 279 if (cinfo->progress != NULL) { 280 cinfo->progress->pass_counter = (long) cinfo->output_scanline; 281 cinfo->progress->pass_limit = (long) cinfo->output_height; 282 (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); 283 } 284 285 /* Process some data */ 286 row_ctr = 0; 287 (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines); 288 cinfo->output_scanline += row_ctr; 289 return row_ctr; 290 } 291 292 293 /* Dummy color convert function used by jpeg_skip_scanlines() */ 294 LOCAL(void) 295 noop_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, 296 JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows) 297 { 298 } 299 300 301 /* Dummy quantize function used by jpeg_skip_scanlines() */ 302 LOCAL(void) 303 noop_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf, 304 JSAMPARRAY output_buf, int num_rows) 305 { 306 } 307 308 309 /* 310 * In some cases, it is best to call jpeg_read_scanlines() and discard the 311 * output, rather than skipping the scanlines, because this allows us to 312 * maintain the internal state of the context-based upsampler. In these cases, 313 * we set up and tear down a dummy color converter in order to avoid valgrind 314 * errors and to achieve the best possible performance. 315 */ 316 317 LOCAL(void) 318 read_and_discard_scanlines (j_decompress_ptr cinfo, JDIMENSION num_lines) 319 { 320 JDIMENSION n; 321 void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, 322 JDIMENSION input_row, JSAMPARRAY output_buf, 323 int num_rows); 324 void (*color_quantize) (j_decompress_ptr cinfo, JSAMPARRAY input_buf, 325 JSAMPARRAY output_buf, int num_rows) = NULL; 326 327 color_convert = cinfo->cconvert->color_convert; 328 cinfo->cconvert->color_convert = noop_convert; 329 if (cinfo->cquantize && cinfo->cquantize->color_quantize) { 330 color_quantize = cinfo->cquantize->color_quantize; 331 cinfo->cquantize->color_quantize = noop_quantize; 332 } 333 334 for (n = 0; n < num_lines; n++) 335 jpeg_read_scanlines(cinfo, NULL, 1); 336 337 cinfo->cconvert->color_convert = color_convert; 338 if (color_quantize) 339 cinfo->cquantize->color_quantize = color_quantize; 340 } 341 342 343 /* 344 * Called by jpeg_skip_scanlines(). This partially skips a decompress block by 345 * incrementing the rowgroup counter. 346 */ 347 348 LOCAL(void) 349 increment_simple_rowgroup_ctr (j_decompress_ptr cinfo, JDIMENSION rows) 350 { 351 JDIMENSION rows_left; 352 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; 353 354 /* Increment the counter to the next row group after the skipped rows. */ 355 main_ptr->rowgroup_ctr += rows / cinfo->max_v_samp_factor; 356 357 /* Partially skipping a row group would involve modifying the internal state 358 * of the upsampler, so read the remaining rows into a dummy buffer instead. 359 */ 360 rows_left = rows % cinfo->max_v_samp_factor; 361 cinfo->output_scanline += rows - rows_left; 362 363 read_and_discard_scanlines(cinfo, rows_left); 364 } 365 366 /* 367 * Skips some scanlines of data from the JPEG decompressor. 368 * 369 * The return value will be the number of lines actually skipped. If skipping 370 * num_lines would move beyond the end of the image, then the actual number of 371 * lines remaining in the image is returned. Otherwise, the return value will 372 * be equal to num_lines. 373 * 374 * Refer to libjpeg.txt for more information. 375 */ 376 377 GLOBAL(JDIMENSION) 378 jpeg_skip_scanlines (j_decompress_ptr cinfo, JDIMENSION num_lines) 379 { 380 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; 381 my_coef_ptr coef = (my_coef_ptr) cinfo->coef; 382 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; 383 JDIMENSION i, x; 384 int y; 385 JDIMENSION lines_per_iMCU_row, lines_left_in_iMCU_row, lines_after_iMCU_row; 386 JDIMENSION lines_to_skip, lines_to_read; 387 388 if (cinfo->global_state != DSTATE_SCANNING) 389 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 390 391 /* Do not skip past the bottom of the image. */ 392 if (cinfo->output_scanline + num_lines >= cinfo->output_height) { 393 cinfo->output_scanline = cinfo->output_height; 394 (*cinfo->inputctl->finish_input_pass) (cinfo); 395 cinfo->inputctl->eoi_reached = TRUE; 396 return cinfo->output_height - cinfo->output_scanline; 397 } 398 399 if (num_lines == 0) 400 return 0; 401 402 lines_per_iMCU_row = cinfo->_min_DCT_scaled_size * cinfo->max_v_samp_factor; 403 lines_left_in_iMCU_row = 404 (lines_per_iMCU_row - (cinfo->output_scanline % lines_per_iMCU_row)) % 405 lines_per_iMCU_row; 406 lines_after_iMCU_row = num_lines - lines_left_in_iMCU_row; 407 408 /* Skip the lines remaining in the current iMCU row. When upsampling 409 * requires context rows, we need the previous and next rows in order to read 410 * the current row. This adds some complexity. 411 */ 412 if (cinfo->upsample->need_context_rows) { 413 /* If the skipped lines would not move us past the current iMCU row, we 414 * read the lines and ignore them. There might be a faster way of doing 415 * this, but we are facing increasing complexity for diminishing returns. 416 * The increasing complexity would be a by-product of meddling with the 417 * state machine used to skip context rows. Near the end of an iMCU row, 418 * the next iMCU row may have already been entropy-decoded. In this unique 419 * case, we will read the next iMCU row if we cannot skip past it as well. 420 */ 421 if ((num_lines < lines_left_in_iMCU_row + 1) || 422 (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full && 423 lines_after_iMCU_row < lines_per_iMCU_row + 1)) { 424 read_and_discard_scanlines(cinfo, num_lines); 425 return num_lines; 426 } 427 428 /* If the next iMCU row has already been entropy-decoded, make sure that 429 * we do not skip too far. 430 */ 431 if (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full) { 432 cinfo->output_scanline += lines_left_in_iMCU_row + lines_per_iMCU_row; 433 lines_after_iMCU_row -= lines_per_iMCU_row; 434 } else { 435 cinfo->output_scanline += lines_left_in_iMCU_row; 436 } 437 438 /* If we have just completed the first block, adjust the buffer pointers */ 439 if (main_ptr->iMCU_row_ctr == 0 || 440 (main_ptr->iMCU_row_ctr == 1 && lines_left_in_iMCU_row > 2)) 441 set_wraparound_pointers(cinfo); 442 main_ptr->buffer_full = FALSE; 443 main_ptr->rowgroup_ctr = 0; 444 main_ptr->context_state = CTX_PREPARE_FOR_IMCU; 445 upsample->next_row_out = cinfo->max_v_samp_factor; 446 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 447 } 448 449 /* Skipping is much simpler when context rows are not required. */ 450 else { 451 if (num_lines < lines_left_in_iMCU_row) { 452 increment_simple_rowgroup_ctr(cinfo, num_lines); 453 return num_lines; 454 } else { 455 cinfo->output_scanline += lines_left_in_iMCU_row; 456 main_ptr->buffer_full = FALSE; 457 main_ptr->rowgroup_ctr = 0; 458 upsample->next_row_out = cinfo->max_v_samp_factor; 459 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 460 } 461 } 462 463 /* Calculate how many full iMCU rows we can skip. */ 464 if (cinfo->upsample->need_context_rows) 465 lines_to_skip = ((lines_after_iMCU_row - 1) / lines_per_iMCU_row) * 466 lines_per_iMCU_row; 467 else 468 lines_to_skip = (lines_after_iMCU_row / lines_per_iMCU_row) * 469 lines_per_iMCU_row; 470 /* Calculate the number of lines that remain to be skipped after skipping all 471 * of the full iMCU rows that we can. We will not read these lines unless we 472 * have to. 473 */ 474 lines_to_read = lines_after_iMCU_row - lines_to_skip; 475 476 /* For images requiring multiple scans (progressive, non-interleaved, etc.), 477 * all of the entropy decoding occurs in jpeg_start_decompress(), assuming 478 * that the input data source is non-suspending. This makes skipping easy. 479 */ 480 if (cinfo->inputctl->has_multiple_scans) { 481 if (cinfo->upsample->need_context_rows) { 482 cinfo->output_scanline += lines_to_skip; 483 cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row; 484 main_ptr->iMCU_row_ctr += lines_after_iMCU_row / lines_per_iMCU_row; 485 /* It is complex to properly move to the middle of a context block, so 486 * read the remaining lines instead of skipping them. 487 */ 488 read_and_discard_scanlines(cinfo, lines_to_read); 489 } else { 490 cinfo->output_scanline += lines_to_skip; 491 cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row; 492 increment_simple_rowgroup_ctr(cinfo, lines_to_read); 493 } 494 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 495 return num_lines; 496 } 497 498 /* Skip the iMCU rows that we can safely skip. */ 499 for (i = 0; i < lines_to_skip; i += lines_per_iMCU_row) { 500 for (y = 0; y < coef->MCU_rows_per_iMCU_row; y++) { 501 for (x = 0; x < cinfo->MCUs_per_row; x++) { 502 /* Calling decode_mcu() with a NULL pointer causes it to discard the 503 * decoded coefficients. This is ~5% faster for large subsets, but 504 * it's tough to tell a difference for smaller images. 505 */ 506 (*cinfo->entropy->decode_mcu) (cinfo, NULL); 507 } 508 } 509 cinfo->input_iMCU_row++; 510 cinfo->output_iMCU_row++; 511 if (cinfo->input_iMCU_row < cinfo->total_iMCU_rows) 512 start_iMCU_row(cinfo); 513 else 514 (*cinfo->inputctl->finish_input_pass) (cinfo); 515 } 516 cinfo->output_scanline += lines_to_skip; 517 518 if (cinfo->upsample->need_context_rows) { 519 /* Context-based upsampling keeps track of iMCU rows. */ 520 main_ptr->iMCU_row_ctr += lines_to_skip / lines_per_iMCU_row; 521 522 /* It is complex to properly move to the middle of a context block, so 523 * read the remaining lines instead of skipping them. 524 */ 525 read_and_discard_scanlines(cinfo, lines_to_read); 526 } else { 527 increment_simple_rowgroup_ctr(cinfo, lines_to_read); 528 } 529 530 /* Since skipping lines involves skipping the upsampling step, the value of 531 * "rows_to_go" will become invalid unless we set it here. NOTE: This is a 532 * bit odd, since "rows_to_go" seems to be redundantly keeping track of 533 * output_scanline. 534 */ 535 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 536 537 /* Always skip the requested number of lines. */ 538 return num_lines; 539 } 540 541 /* 542 * Alternate entry point to read raw data. 543 * Processes exactly one iMCU row per call, unless suspended. 544 */ 545 546 GLOBAL(JDIMENSION) 547 jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data, 548 JDIMENSION max_lines) 549 { 550 JDIMENSION lines_per_iMCU_row; 551 552 if (cinfo->global_state != DSTATE_RAW_OK) 553 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 554 if (cinfo->output_scanline >= cinfo->output_height) { 555 WARNMS(cinfo, JWRN_TOO_MUCH_DATA); 556 return 0; 557 } 558 559 /* Call progress monitor hook if present */ 560 if (cinfo->progress != NULL) { 561 cinfo->progress->pass_counter = (long) cinfo->output_scanline; 562 cinfo->progress->pass_limit = (long) cinfo->output_height; 563 (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); 564 } 565 566 /* Verify that at least one iMCU row can be returned. */ 567 lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size; 568 if (max_lines < lines_per_iMCU_row) 569 ERREXIT(cinfo, JERR_BUFFER_SIZE); 570 571 /* Decompress directly into user's buffer. */ 572 if (! (*cinfo->coef->decompress_data) (cinfo, data)) 573 return 0; /* suspension forced, can do nothing more */ 574 575 /* OK, we processed one iMCU row. */ 576 cinfo->output_scanline += lines_per_iMCU_row; 577 return lines_per_iMCU_row; 578 } 579 580 581 /* Additional entry points for buffered-image mode. */ 582 583 #ifdef D_MULTISCAN_FILES_SUPPORTED 584 585 /* 586 * Initialize for an output pass in buffered-image mode. 587 */ 588 589 GLOBAL(boolean) 590 jpeg_start_output (j_decompress_ptr cinfo, int scan_number) 591 { 592 if (cinfo->global_state != DSTATE_BUFIMAGE && 593 cinfo->global_state != DSTATE_PRESCAN) 594 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 595 /* Limit scan number to valid range */ 596 if (scan_number <= 0) 597 scan_number = 1; 598 if (cinfo->inputctl->eoi_reached && 599 scan_number > cinfo->input_scan_number) 600 scan_number = cinfo->input_scan_number; 601 cinfo->output_scan_number = scan_number; 602 /* Perform any dummy output passes, and set up for the real pass */ 603 return output_pass_setup(cinfo); 604 } 605 606 607 /* 608 * Finish up after an output pass in buffered-image mode. 609 * 610 * Returns FALSE if suspended. The return value need be inspected only if 611 * a suspending data source is used. 612 */ 613 614 GLOBAL(boolean) 615 jpeg_finish_output (j_decompress_ptr cinfo) 616 { 617 if ((cinfo->global_state == DSTATE_SCANNING || 618 cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) { 619 /* Terminate this pass. */ 620 /* We do not require the whole pass to have been completed. */ 621 (*cinfo->master->finish_output_pass) (cinfo); 622 cinfo->global_state = DSTATE_BUFPOST; 623 } else if (cinfo->global_state != DSTATE_BUFPOST) { 624 /* BUFPOST = repeat call after a suspension, anything else is error */ 625 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 626 } 627 /* Read markers looking for SOS or EOI */ 628 while (cinfo->input_scan_number <= cinfo->output_scan_number && 629 ! cinfo->inputctl->eoi_reached) { 630 if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) 631 return FALSE; /* Suspend, come back later */ 632 } 633 cinfo->global_state = DSTATE_BUFIMAGE; 634 return TRUE; 635 } 636 637 #endif /* D_MULTISCAN_FILES_SUPPORTED */ 638