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-2016, 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 */ 28LOCAL(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 42GLOBAL(boolean) 43jpeg_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 99LOCAL(boolean) 100output_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 152GLOBAL(void) 153jpeg_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 align = cinfo->_min_DCT_scaled_size * cinfo->max_h_samp_factor; 194 195 /* Adjust xoffset to the nearest iMCU boundary <= the requested value */ 196 input_xoffset = *xoffset; 197 *xoffset = (input_xoffset / align) * align; 198 199 /* Adjust the width so that the right edge of the output image is as 200 * requested (only the left edge is altered.) It is important that calling 201 * programs check this value after this function returns, so that they can 202 * allocate an output buffer with the appropriate size. 203 */ 204 *width = *width + input_xoffset - *xoffset; 205 cinfo->output_width = *width; 206 207 /* Set the first and last iMCU columns that we must decompress. These values 208 * will be used in single-scan decompressions. 209 */ 210 cinfo->master->first_iMCU_col = 211 (JDIMENSION) (long) (*xoffset) / (long) align; 212 cinfo->master->last_iMCU_col = 213 (JDIMENSION) jdiv_round_up((long) (*xoffset + cinfo->output_width), 214 (long) align) - 1; 215 216 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 217 ci++, compptr++) { 218 /* Set downsampled_width to the new output width. */ 219 orig_downsampled_width = compptr->downsampled_width; 220 compptr->downsampled_width = 221 (JDIMENSION) jdiv_round_up((long) (cinfo->output_width * 222 compptr->h_samp_factor), 223 (long) cinfo->max_h_samp_factor); 224 if (compptr->downsampled_width < 2 && orig_downsampled_width >= 2) 225 reinit_upsampler = TRUE; 226 227 /* Set the first and last iMCU columns that we must decompress. These 228 * values will be used in multi-scan decompressions. 229 */ 230 cinfo->master->first_MCU_col[ci] = 231 (JDIMENSION) (long) (*xoffset * compptr->h_samp_factor) / 232 (long) align; 233 cinfo->master->last_MCU_col[ci] = 234 (JDIMENSION) jdiv_round_up((long) ((*xoffset + cinfo->output_width) * 235 compptr->h_samp_factor), 236 (long) align) - 1; 237 } 238 239 if (reinit_upsampler) { 240 cinfo->master->jinit_upsampler_no_alloc = TRUE; 241 jinit_upsampler(cinfo); 242 cinfo->master->jinit_upsampler_no_alloc = FALSE; 243 } 244} 245 246 247/* 248 * Read some scanlines of data from the JPEG decompressor. 249 * 250 * The return value will be the number of lines actually read. 251 * This may be less than the number requested in several cases, 252 * including bottom of image, data source suspension, and operating 253 * modes that emit multiple scanlines at a time. 254 * 255 * Note: we warn about excess calls to jpeg_read_scanlines() since 256 * this likely signals an application programmer error. However, 257 * an oversize buffer (max_lines > scanlines remaining) is not an error. 258 */ 259 260GLOBAL(JDIMENSION) 261jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines, 262 JDIMENSION max_lines) 263{ 264 JDIMENSION row_ctr; 265 266 if (cinfo->global_state != DSTATE_SCANNING) 267 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 268 if (cinfo->output_scanline >= cinfo->output_height) { 269 WARNMS(cinfo, JWRN_TOO_MUCH_DATA); 270 return 0; 271 } 272 273 /* Call progress monitor hook if present */ 274 if (cinfo->progress != NULL) { 275 cinfo->progress->pass_counter = (long) cinfo->output_scanline; 276 cinfo->progress->pass_limit = (long) cinfo->output_height; 277 (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); 278 } 279 280 /* Process some data */ 281 row_ctr = 0; 282 (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines); 283 cinfo->output_scanline += row_ctr; 284 return row_ctr; 285} 286 287 288/* Dummy color convert function used by jpeg_skip_scanlines() */ 289LOCAL(void) 290noop_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, 291 JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows) 292{ 293} 294 295 296/* 297 * In some cases, it is best to call jpeg_read_scanlines() and discard the 298 * output, rather than skipping the scanlines, because this allows us to 299 * maintain the internal state of the context-based upsampler. In these cases, 300 * we set up and tear down a dummy color converter in order to avoid valgrind 301 * errors and to achieve the best possible performance. 302 */ 303 304LOCAL(void) 305read_and_discard_scanlines (j_decompress_ptr cinfo, JDIMENSION num_lines) 306{ 307 JDIMENSION n; 308 void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, 309 JDIMENSION input_row, JSAMPARRAY output_buf, 310 int num_rows); 311 312 color_convert = cinfo->cconvert->color_convert; 313 cinfo->cconvert->color_convert = noop_convert; 314 315 for (n = 0; n < num_lines; n++) 316 jpeg_read_scanlines(cinfo, NULL, 1); 317 318 cinfo->cconvert->color_convert = color_convert; 319} 320 321 322/* 323 * Called by jpeg_skip_scanlines(). This partially skips a decompress block by 324 * incrementing the rowgroup counter. 325 */ 326 327LOCAL(void) 328increment_simple_rowgroup_ctr (j_decompress_ptr cinfo, JDIMENSION rows) 329{ 330 JDIMENSION rows_left; 331 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; 332 333 /* Increment the counter to the next row group after the skipped rows. */ 334 main_ptr->rowgroup_ctr += rows / cinfo->max_v_samp_factor; 335 336 /* Partially skipping a row group would involve modifying the internal state 337 * of the upsampler, so read the remaining rows into a dummy buffer instead. 338 */ 339 rows_left = rows % cinfo->max_v_samp_factor; 340 cinfo->output_scanline += rows - rows_left; 341 342 read_and_discard_scanlines(cinfo, rows_left); 343} 344 345/* 346 * Skips some scanlines of data from the JPEG decompressor. 347 * 348 * The return value will be the number of lines actually skipped. If skipping 349 * num_lines would move beyond the end of the image, then the actual number of 350 * lines remaining in the image is returned. Otherwise, the return value will 351 * be equal to num_lines. 352 * 353 * Refer to libjpeg.txt for more information. 354 */ 355 356GLOBAL(JDIMENSION) 357jpeg_skip_scanlines (j_decompress_ptr cinfo, JDIMENSION num_lines) 358{ 359 my_main_ptr main_ptr = (my_main_ptr) cinfo->main; 360 my_coef_ptr coef = (my_coef_ptr) cinfo->coef; 361 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; 362 JDIMENSION i, x; 363 int y; 364 JDIMENSION lines_per_iMCU_row, lines_left_in_iMCU_row, lines_after_iMCU_row; 365 JDIMENSION lines_to_skip, lines_to_read; 366 367 if (cinfo->global_state != DSTATE_SCANNING) 368 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 369 370 /* Do not skip past the bottom of the image. */ 371 if (cinfo->output_scanline + num_lines >= cinfo->output_height) { 372 cinfo->output_scanline = cinfo->output_height; 373 return cinfo->output_height - cinfo->output_scanline; 374 } 375 376 if (num_lines == 0) 377 return 0; 378 379 lines_per_iMCU_row = cinfo->_min_DCT_scaled_size * cinfo->max_v_samp_factor; 380 lines_left_in_iMCU_row = 381 (lines_per_iMCU_row - (cinfo->output_scanline % lines_per_iMCU_row)) % 382 lines_per_iMCU_row; 383 lines_after_iMCU_row = num_lines - lines_left_in_iMCU_row; 384 385 /* Skip the lines remaining in the current iMCU row. When upsampling 386 * requires context rows, we need the previous and next rows in order to read 387 * the current row. This adds some complexity. 388 */ 389 if (cinfo->upsample->need_context_rows) { 390 /* If the skipped lines would not move us past the current iMCU row, we 391 * read the lines and ignore them. There might be a faster way of doing 392 * this, but we are facing increasing complexity for diminishing returns. 393 * The increasing complexity would be a by-product of meddling with the 394 * state machine used to skip context rows. Near the end of an iMCU row, 395 * the next iMCU row may have already been entropy-decoded. In this unique 396 * case, we will read the next iMCU row if we cannot skip past it as well. 397 */ 398 if ((num_lines < lines_left_in_iMCU_row + 1) || 399 (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full && 400 lines_after_iMCU_row < lines_per_iMCU_row + 1)) { 401 read_and_discard_scanlines(cinfo, num_lines); 402 return num_lines; 403 } 404 405 /* If the next iMCU row has already been entropy-decoded, make sure that 406 * we do not skip too far. 407 */ 408 if (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full) { 409 cinfo->output_scanline += lines_left_in_iMCU_row + lines_per_iMCU_row; 410 lines_after_iMCU_row -= lines_per_iMCU_row; 411 } else { 412 cinfo->output_scanline += lines_left_in_iMCU_row; 413 } 414 415 /* If we have just completed the first block, adjust the buffer pointers */ 416 if (main_ptr->iMCU_row_ctr == 0 || 417 (main_ptr->iMCU_row_ctr == 1 && lines_left_in_iMCU_row > 2)) 418 set_wraparound_pointers(cinfo); 419 main_ptr->buffer_full = FALSE; 420 main_ptr->rowgroup_ctr = 0; 421 main_ptr->context_state = CTX_PREPARE_FOR_IMCU; 422 upsample->next_row_out = cinfo->max_v_samp_factor; 423 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 424 } 425 426 /* Skipping is much simpler when context rows are not required. */ 427 else { 428 if (num_lines < lines_left_in_iMCU_row) { 429 increment_simple_rowgroup_ctr(cinfo, num_lines); 430 return num_lines; 431 } else { 432 cinfo->output_scanline += lines_left_in_iMCU_row; 433 main_ptr->buffer_full = FALSE; 434 main_ptr->rowgroup_ctr = 0; 435 upsample->next_row_out = cinfo->max_v_samp_factor; 436 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 437 } 438 } 439 440 /* Calculate how many full iMCU rows we can skip. */ 441 if (cinfo->upsample->need_context_rows) 442 lines_to_skip = ((lines_after_iMCU_row - 1) / lines_per_iMCU_row) * 443 lines_per_iMCU_row; 444 else 445 lines_to_skip = (lines_after_iMCU_row / lines_per_iMCU_row) * 446 lines_per_iMCU_row; 447 /* Calculate the number of lines that remain to be skipped after skipping all 448 * of the full iMCU rows that we can. We will not read these lines unless we 449 * have to. 450 */ 451 lines_to_read = lines_after_iMCU_row - lines_to_skip; 452 453 /* For images requiring multiple scans (progressive, non-interleaved, etc.), 454 * all of the entropy decoding occurs in jpeg_start_decompress(), assuming 455 * that the input data source is non-suspending. This makes skipping easy. 456 */ 457 if (cinfo->inputctl->has_multiple_scans) { 458 if (cinfo->upsample->need_context_rows) { 459 cinfo->output_scanline += lines_to_skip; 460 cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row; 461 main_ptr->iMCU_row_ctr += lines_after_iMCU_row / lines_per_iMCU_row; 462 /* It is complex to properly move to the middle of a context block, so 463 * read the remaining lines instead of skipping them. 464 */ 465 read_and_discard_scanlines(cinfo, lines_to_read); 466 } else { 467 cinfo->output_scanline += lines_to_skip; 468 cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row; 469 increment_simple_rowgroup_ctr(cinfo, lines_to_read); 470 } 471 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 472 return num_lines; 473 } 474 475 /* Skip the iMCU rows that we can safely skip. */ 476 for (i = 0; i < lines_to_skip; i += lines_per_iMCU_row) { 477 for (y = 0; y < coef->MCU_rows_per_iMCU_row; y++) { 478 for (x = 0; x < cinfo->MCUs_per_row; x++) { 479 /* Calling decode_mcu() with a NULL pointer causes it to discard the 480 * decoded coefficients. This is ~5% faster for large subsets, but 481 * it's tough to tell a difference for smaller images. 482 */ 483 (*cinfo->entropy->decode_mcu) (cinfo, NULL); 484 } 485 } 486 cinfo->input_iMCU_row++; 487 cinfo->output_iMCU_row++; 488 if (cinfo->input_iMCU_row < cinfo->total_iMCU_rows) 489 start_iMCU_row(cinfo); 490 else 491 (*cinfo->inputctl->finish_input_pass) (cinfo); 492 } 493 cinfo->output_scanline += lines_to_skip; 494 495 if (cinfo->upsample->need_context_rows) { 496 /* Context-based upsampling keeps track of iMCU rows. */ 497 main_ptr->iMCU_row_ctr += lines_to_skip / lines_per_iMCU_row; 498 499 /* It is complex to properly move to the middle of a context block, so 500 * read the remaining lines instead of skipping them. 501 */ 502 read_and_discard_scanlines(cinfo, lines_to_read); 503 } else { 504 increment_simple_rowgroup_ctr(cinfo, lines_to_read); 505 } 506 507 /* Since skipping lines involves skipping the upsampling step, the value of 508 * "rows_to_go" will become invalid unless we set it here. NOTE: This is a 509 * bit odd, since "rows_to_go" seems to be redundantly keeping track of 510 * output_scanline. 511 */ 512 upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline; 513 514 /* Always skip the requested number of lines. */ 515 return num_lines; 516} 517 518/* 519 * Alternate entry point to read raw data. 520 * Processes exactly one iMCU row per call, unless suspended. 521 */ 522 523GLOBAL(JDIMENSION) 524jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data, 525 JDIMENSION max_lines) 526{ 527 JDIMENSION lines_per_iMCU_row; 528 529 if (cinfo->global_state != DSTATE_RAW_OK) 530 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 531 if (cinfo->output_scanline >= cinfo->output_height) { 532 WARNMS(cinfo, JWRN_TOO_MUCH_DATA); 533 return 0; 534 } 535 536 /* Call progress monitor hook if present */ 537 if (cinfo->progress != NULL) { 538 cinfo->progress->pass_counter = (long) cinfo->output_scanline; 539 cinfo->progress->pass_limit = (long) cinfo->output_height; 540 (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); 541 } 542 543 /* Verify that at least one iMCU row can be returned. */ 544 lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size; 545 if (max_lines < lines_per_iMCU_row) 546 ERREXIT(cinfo, JERR_BUFFER_SIZE); 547 548 /* Decompress directly into user's buffer. */ 549 if (! (*cinfo->coef->decompress_data) (cinfo, data)) 550 return 0; /* suspension forced, can do nothing more */ 551 552 /* OK, we processed one iMCU row. */ 553 cinfo->output_scanline += lines_per_iMCU_row; 554 return lines_per_iMCU_row; 555} 556 557 558/* Additional entry points for buffered-image mode. */ 559 560#ifdef D_MULTISCAN_FILES_SUPPORTED 561 562/* 563 * Initialize for an output pass in buffered-image mode. 564 */ 565 566GLOBAL(boolean) 567jpeg_start_output (j_decompress_ptr cinfo, int scan_number) 568{ 569 if (cinfo->global_state != DSTATE_BUFIMAGE && 570 cinfo->global_state != DSTATE_PRESCAN) 571 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 572 /* Limit scan number to valid range */ 573 if (scan_number <= 0) 574 scan_number = 1; 575 if (cinfo->inputctl->eoi_reached && 576 scan_number > cinfo->input_scan_number) 577 scan_number = cinfo->input_scan_number; 578 cinfo->output_scan_number = scan_number; 579 /* Perform any dummy output passes, and set up for the real pass */ 580 return output_pass_setup(cinfo); 581} 582 583 584/* 585 * Finish up after an output pass in buffered-image mode. 586 * 587 * Returns FALSE if suspended. The return value need be inspected only if 588 * a suspending data source is used. 589 */ 590 591GLOBAL(boolean) 592jpeg_finish_output (j_decompress_ptr cinfo) 593{ 594 if ((cinfo->global_state == DSTATE_SCANNING || 595 cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) { 596 /* Terminate this pass. */ 597 /* We do not require the whole pass to have been completed. */ 598 (*cinfo->master->finish_output_pass) (cinfo); 599 cinfo->global_state = DSTATE_BUFPOST; 600 } else if (cinfo->global_state != DSTATE_BUFPOST) { 601 /* BUFPOST = repeat call after a suspension, anything else is error */ 602 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 603 } 604 /* Read markers looking for SOS or EOI */ 605 while (cinfo->input_scan_number <= cinfo->output_scan_number && 606 ! cinfo->inputctl->eoi_reached) { 607 if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) 608 return FALSE; /* Suspend, come back later */ 609 } 610 cinfo->global_state = DSTATE_BUFIMAGE; 611 return TRUE; 612} 613 614#endif /* D_MULTISCAN_FILES_SUPPORTED */ 615