jdapistd.c

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