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-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   JSAMPLE dummy_sample[1] = { 0 };
 323   JSAMPROW dummy_row = dummy_sample;
 324   JSAMPARRAY scanlines = NULL;
 325   void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 326                          JDIMENSION input_row, JSAMPARRAY output_buf,
 327                          int num_rows) = NULL;
 328   void (*color_quantize) (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 329                           JSAMPARRAY output_buf, int num_rows) = NULL;
 330
 331   if (cinfo->cconvert && cinfo->cconvert->color_convert) {
 332     color_convert = cinfo->cconvert->color_convert;
 333     cinfo->cconvert->color_convert = noop_convert;
 334     /* This just prevents UBSan from complaining about adding 0 to a NULL
 335      * pointer.  The pointer isn't actually used.
 336      */
 337     scanlines = &dummy_row;
 338   }
 339
 340   if (cinfo->cquantize && cinfo->cquantize->color_quantize) {
 341     color_quantize = cinfo->cquantize->color_quantize;
 342     cinfo->cquantize->color_quantize = noop_quantize;
 343   }
 344
 345   if (master->using_merged_upsample && cinfo->max_v_samp_factor == 2) {
 346     my_merged_upsample_ptr upsample = (my_merged_upsample_ptr)cinfo->upsample;
 347     scanlines = &upsample->spare_row;
 348   }
 349
 350   for (n = 0; n < num_lines; n++)
 351     jpeg_read_scanlines(cinfo, scanlines, 1);
 352
 353   if (color_convert)
 354     cinfo->cconvert->color_convert = color_convert;
 355
 356   if (color_quantize)
 357     cinfo->cquantize->color_quantize = color_quantize;
 358 }
 359
 360
 361 /*
 362  * Called by jpeg_skip_scanlines().  This partially skips a decompress block by
 363  * incrementing the rowgroup counter.
 364  */
 365
 366 LOCAL(void)
 367 increment_simple_rowgroup_ctr(j_decompress_ptr cinfo, JDIMENSION rows)
 368 {
 369   JDIMENSION rows_left;
 370   my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
 371   my_master_ptr master = (my_master_ptr)cinfo->master;
 372
 373   if (master->using_merged_upsample && cinfo->max_v_samp_factor == 2) {
 374     read_and_discard_scanlines(cinfo, rows);
 375     return;
 376   }
 377
 378   /* Increment the counter to the next row group after the skipped rows. */
 379   main_ptr->rowgroup_ctr += rows / cinfo->max_v_samp_factor;
 380
 381   /* Partially skipping a row group would involve modifying the internal state
 382    * of the upsampler, so read the remaining rows into a dummy buffer instead.
 383    */
 384   rows_left = rows % cinfo->max_v_samp_factor;
 385   cinfo->output_scanline += rows - rows_left;
 386
 387   read_and_discard_scanlines(cinfo, rows_left);
 388 }
 389
 390 /*
 391  * Skips some scanlines of data from the JPEG decompressor.
 392  *
 393  * The return value will be the number of lines actually skipped.  If skipping
 394  * num_lines would move beyond the end of the image, then the actual number of
 395  * lines remaining in the image is returned.  Otherwise, the return value will
 396  * be equal to num_lines.
 397  *
 398  * Refer to libjpeg.txt for more information.
 399  */
 400
 401 GLOBAL(JDIMENSION)
 402 jpeg_skip_scanlines(j_decompress_ptr cinfo, JDIMENSION num_lines)
 403 {
 404   my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
 405   my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
 406   my_master_ptr master = (my_master_ptr)cinfo->master;
 407   my_upsample_ptr upsample = (my_upsample_ptr)cinfo->upsample;
 408   JDIMENSION i, x;
 409   int y;
 410   JDIMENSION lines_per_iMCU_row, lines_left_in_iMCU_row, lines_after_iMCU_row;
 411   JDIMENSION lines_to_skip, lines_to_read;
 412
 413   /* Two-pass color quantization is not supported. */
 414   if (cinfo->quantize_colors && cinfo->two_pass_quantize)
 415     ERREXIT(cinfo, JERR_NOTIMPL);
 416
 417   if (cinfo->global_state != DSTATE_SCANNING)
 418     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
 419
 420   /* Do not skip past the bottom of the image. */
 421   if (cinfo->output_scanline + num_lines >= cinfo->output_height) {
 422     num_lines = cinfo->output_height - cinfo->output_scanline;
 423     cinfo->output_scanline = cinfo->output_height;
 424     (*cinfo->inputctl->finish_input_pass) (cinfo);
 425     cinfo->inputctl->eoi_reached = TRUE;
 426     return num_lines;
 427   }
 428
 429   if (num_lines == 0)
 430     return 0;
 431
 432   lines_per_iMCU_row = cinfo->_min_DCT_scaled_size * cinfo->max_v_samp_factor;
 433   lines_left_in_iMCU_row =
 434     (lines_per_iMCU_row - (cinfo->output_scanline % lines_per_iMCU_row)) %
 435     lines_per_iMCU_row;
 436   lines_after_iMCU_row = num_lines - lines_left_in_iMCU_row;
 437
 438   /* Skip the lines remaining in the current iMCU row.  When upsampling
 439    * requires context rows, we need the previous and next rows in order to read
 440    * the current row.  This adds some complexity.
 441    */
 442   if (cinfo->upsample->need_context_rows) {
 443     /* If the skipped lines would not move us past the current iMCU row, we
 444      * read the lines and ignore them.  There might be a faster way of doing
 445      * this, but we are facing increasing complexity for diminishing returns.
 446      * The increasing complexity would be a by-product of meddling with the
 447      * state machine used to skip context rows.  Near the end of an iMCU row,
 448      * the next iMCU row may have already been entropy-decoded.  In this unique
 449      * case, we will read the next iMCU row if we cannot skip past it as well.
 450      */
 451     if ((num_lines < lines_left_in_iMCU_row + 1) ||
 452         (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full &&
 453          lines_after_iMCU_row < lines_per_iMCU_row + 1)) {
 454       read_and_discard_scanlines(cinfo, num_lines);
 455       return num_lines;
 456     }
 457
 458     /* If the next iMCU row has already been entropy-decoded, make sure that
 459      * we do not skip too far.
 460      */
 461     if (lines_left_in_iMCU_row <= 1 && main_ptr->buffer_full) {
 462       cinfo->output_scanline += lines_left_in_iMCU_row + lines_per_iMCU_row;
 463       lines_after_iMCU_row -= lines_per_iMCU_row;
 464     } else {
 465       cinfo->output_scanline += lines_left_in_iMCU_row;
 466     }
 467
 468     /* If we have just completed the first block, adjust the buffer pointers */
 469     if (main_ptr->iMCU_row_ctr == 0 ||
 470         (main_ptr->iMCU_row_ctr == 1 && lines_left_in_iMCU_row > 2))
 471       set_wraparound_pointers(cinfo);
 472     main_ptr->buffer_full = FALSE;
 473     main_ptr->rowgroup_ctr = 0;
 474     main_ptr->context_state = CTX_PREPARE_FOR_IMCU;
 475     if (!master->using_merged_upsample) {
 476       upsample->next_row_out = cinfo->max_v_samp_factor;
 477       upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
 478     }
 479   }
 480
 481   /* Skipping is much simpler when context rows are not required. */
 482   else {
 483     if (num_lines < lines_left_in_iMCU_row) {
 484       increment_simple_rowgroup_ctr(cinfo, num_lines);
 485       return num_lines;
 486     } else {
 487       cinfo->output_scanline += lines_left_in_iMCU_row;
 488       main_ptr->buffer_full = FALSE;
 489       main_ptr->rowgroup_ctr = 0;
 490       if (!master->using_merged_upsample) {
 491         upsample->next_row_out = cinfo->max_v_samp_factor;
 492         upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
 493       }
 494     }
 495   }
 496
 497   /* Calculate how many full iMCU rows we can skip. */
 498   if (cinfo->upsample->need_context_rows)
 499     lines_to_skip = ((lines_after_iMCU_row - 1) / lines_per_iMCU_row) *
 500                     lines_per_iMCU_row;
 501   else
 502     lines_to_skip = (lines_after_iMCU_row / lines_per_iMCU_row) *
 503                     lines_per_iMCU_row;
 504   /* Calculate the number of lines that remain to be skipped after skipping all
 505    * of the full iMCU rows that we can.  We will not read these lines unless we
 506    * have to.
 507    */
 508   lines_to_read = lines_after_iMCU_row - lines_to_skip;
 509
 510   /* For images requiring multiple scans (progressive, non-interleaved, etc.),
 511    * all of the entropy decoding occurs in jpeg_start_decompress(), assuming
 512    * that the input data source is non-suspending.  This makes skipping easy.
 513    */
 514   if (cinfo->inputctl->has_multiple_scans) {
 515     if (cinfo->upsample->need_context_rows) {
 516       cinfo->output_scanline += lines_to_skip;
 517       cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row;
 518       main_ptr->iMCU_row_ctr += lines_to_skip / lines_per_iMCU_row;
 519       /* It is complex to properly move to the middle of a context block, so
 520        * read the remaining lines instead of skipping them.
 521        */
 522       read_and_discard_scanlines(cinfo, lines_to_read);
 523     } else {
 524       cinfo->output_scanline += lines_to_skip;
 525       cinfo->output_iMCU_row += lines_to_skip / lines_per_iMCU_row;
 526       increment_simple_rowgroup_ctr(cinfo, lines_to_read);
 527     }
 528     if (!master->using_merged_upsample)
 529       upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
 530     return num_lines;
 531   }
 532
 533   /* Skip the iMCU rows that we can safely skip. */
 534   for (i = 0; i < lines_to_skip; i += lines_per_iMCU_row) {
 535     for (y = 0; y < coef->MCU_rows_per_iMCU_row; y++) {
 536       for (x = 0; x < cinfo->MCUs_per_row; x++) {
 537         /* Calling decode_mcu() with a NULL pointer causes it to discard the
 538          * decoded coefficients.  This is ~5% faster for large subsets, but
 539          * it's tough to tell a difference for smaller images.
 540          */
 541         if (!cinfo->entropy->insufficient_data)
 542           cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
 543         (*cinfo->entropy->decode_mcu) (cinfo, NULL);
 544       }
 545     }
 546     cinfo->input_iMCU_row++;
 547     cinfo->output_iMCU_row++;
 548     if (cinfo->input_iMCU_row < cinfo->total_iMCU_rows)
 549       start_iMCU_row(cinfo);
 550     else
 551       (*cinfo->inputctl->finish_input_pass) (cinfo);
 552   }
 553   cinfo->output_scanline += lines_to_skip;
 554
 555   if (cinfo->upsample->need_context_rows) {
 556     /* Context-based upsampling keeps track of iMCU rows. */
 557     main_ptr->iMCU_row_ctr += lines_to_skip / lines_per_iMCU_row;
 558
 559     /* It is complex to properly move to the middle of a context block, so
 560      * read the remaining lines instead of skipping them.
 561      */
 562     read_and_discard_scanlines(cinfo, lines_to_read);
 563   } else {
 564     increment_simple_rowgroup_ctr(cinfo, lines_to_read);
 565   }
 566
 567   /* Since skipping lines involves skipping the upsampling step, the value of
 568    * "rows_to_go" will become invalid unless we set it here.  NOTE: This is a
 569    * bit odd, since "rows_to_go" seems to be redundantly keeping track of
 570    * output_scanline.
 571    */
 572   if (!master->using_merged_upsample)
 573     upsample->rows_to_go = cinfo->output_height - cinfo->output_scanline;
 574
 575   /* Always skip the requested number of lines. */
 576   return num_lines;
 577 }
 578
 579 /*
 580  * Alternate entry point to read raw data.
 581  * Processes exactly one iMCU row per call, unless suspended.
 582  */
 583
 584 GLOBAL(JDIMENSION)
 585 jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
 586                    JDIMENSION max_lines)
 587 {
 588   JDIMENSION lines_per_iMCU_row;
 589
 590   if (cinfo->global_state != DSTATE_RAW_OK)
 591     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
 592   if (cinfo->output_scanline >= cinfo->output_height) {
 593     WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
 594     return 0;
 595   }
 596
 597   /* Call progress monitor hook if present */
 598   if (cinfo->progress != NULL) {
 599     cinfo->progress->pass_counter = (long)cinfo->output_scanline;
 600     cinfo->progress->pass_limit = (long)cinfo->output_height;
 601     (*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
 602   }
 603
 604   /* Verify that at least one iMCU row can be returned. */
 605   lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->_min_DCT_scaled_size;
 606   if (max_lines < lines_per_iMCU_row)
 607     ERREXIT(cinfo, JERR_BUFFER_SIZE);
 608
 609   /* Decompress directly into user's buffer. */
 610   if (!(*cinfo->coef->decompress_data) (cinfo, data))
 611     return 0;                   /* suspension forced, can do nothing more */
 612
 613   /* OK, we processed one iMCU row. */
 614   cinfo->output_scanline += lines_per_iMCU_row;
 615   return lines_per_iMCU_row;
 616 }
 617
 618
 619 /* Additional entry points for buffered-image mode. */
 620
 621 #ifdef D_MULTISCAN_FILES_SUPPORTED
 622
 623 /*
 624  * Initialize for an output pass in buffered-image mode.
 625  */
 626
 627 GLOBAL(boolean)
 628 jpeg_start_output(j_decompress_ptr cinfo, int scan_number)
 629 {
 630   if (cinfo->global_state != DSTATE_BUFIMAGE &&
 631       cinfo->global_state != DSTATE_PRESCAN)
 632     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
 633   /* Limit scan number to valid range */
 634   if (scan_number <= 0)
 635     scan_number = 1;
 636   if (cinfo->inputctl->eoi_reached && scan_number > cinfo->input_scan_number)
 637     scan_number = cinfo->input_scan_number;
 638   cinfo->output_scan_number = scan_number;
 639   /* Perform any dummy output passes, and set up for the real pass */
 640   return output_pass_setup(cinfo);
 641 }
 642
 643
 644 /*
 645  * Finish up after an output pass in buffered-image mode.
 646  *
 647  * Returns FALSE if suspended.  The return value need be inspected only if
 648  * a suspending data source is used.
 649  */
 650
 651 GLOBAL(boolean)
 652 jpeg_finish_output(j_decompress_ptr cinfo)
 653 {
 654   if ((cinfo->global_state == DSTATE_SCANNING ||
 655        cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
 656     /* Terminate this pass. */
 657     /* We do not require the whole pass to have been completed. */
 658     (*cinfo->master->finish_output_pass) (cinfo);
 659     cinfo->global_state = DSTATE_BUFPOST;
 660   } else if (cinfo->global_state != DSTATE_BUFPOST) {
 661     /* BUFPOST = repeat call after a suspension, anything else is error */
 662     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
 663   }
 664   /* Read markers looking for SOS or EOI */
 665   while (cinfo->input_scan_number <= cinfo->output_scan_number &&
 666          !cinfo->inputctl->eoi_reached) {
 667     if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
 668       return FALSE;             /* Suspend, come back later */
 669   }
 670   cinfo->global_state = DSTATE_BUFIMAGE;
 671   return TRUE;
 672 }
 673
 674 #endif /* D_MULTISCAN_FILES_SUPPORTED */