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