home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / jlib / jdcoefct.cpp < prev    next >
C/C++ Source or Header  |  2000-05-16  |  26KB  |  844 lines
  1. //-------------------------------------------------------------------------//
  2. //          Windows Graphics Programming: Win32 GDI and DirectDraw         //
  3. //                        ISBN  0-13-086985-6                              //
  4. //                                                                         //
  5. //  Modified by: Yuan, Feng                             www.fengyuan.com   //
  6. //  Changes    : C++, exception, in-memory source, BGR byte order          //
  7. //  Version    : 1.00.000, May 31, 2000                                    //
  8. //-------------------------------------------------------------------------//
  9.  
  10. /*
  11.  * jdcoefct.c
  12.  *
  13.  * Copyright (C) 1994-1997, Thomas G. Lane.
  14.  * This file is part of the Independent JPEG Group's software.
  15.  * For conditions of distribution and use, see the accompanying README file.
  16.  *
  17.  * This file contains the coefficient buffer controller for decompression.
  18.  * This controller is the top level of the JPEG decompressor proper.
  19.  * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
  20.  *
  21.  * In buffered-image mode, this controller is the interface between
  22.  * input-oriented processing and output-oriented processing.
  23.  * Also, the input side (only) is used when reading a file for transcoding.
  24.  */
  25.  
  26. #define JPEG_INTERNALS
  27. #include "jinclude.h"
  28. #include "jpeglib.h"
  29.  
  30. /* Block smoothing is only applicable for progressive JPEG, so: */
  31. #ifndef D_PROGRESSIVE_SUPPORTED
  32. #undef BLOCK_SMOOTHING_SUPPORTED
  33. #endif
  34.  
  35. /* Private buffer controller object */
  36.  
  37. typedef struct {
  38.   struct jpeg_d_coef_controller pub; /* public fields */
  39.  
  40.   /* These variables keep track of the current location of the input side. */
  41.   /* cinfo->input_iMCU_row is also used for this. */
  42.   JDIMENSION MCU_ctr;        /* counts MCUs processed in current row */
  43.   int MCU_vert_offset;        /* counts MCU rows within iMCU row */
  44.   int MCU_rows_per_iMCU_row;    /* number of such rows needed */
  45.  
  46.   /* The output side's location is represented by cinfo->output_iMCU_row. */
  47.  
  48.   /* In single-pass modes, it's sufficient to buffer just one MCU.
  49.    * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
  50.    * and let the entropy decoder write into that workspace each time.
  51.    * (On 80x86, the workspace is FAR even though it's not really very big;
  52.    * this is to keep the module interfaces unchanged when a large coefficient
  53.    * buffer is necessary.)
  54.    * In multi-pass modes, this array points to the current MCU's blocks
  55.    * within the virtual arrays; it is used only by the input side.
  56.    */
  57.   JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
  58.  
  59. #ifdef D_MULTISCAN_FILES_SUPPORTED
  60.   /* In multi-pass modes, we need a virtual block array for each component. */
  61.   jvirt_barray_ptr whole_image[MAX_COMPONENTS];
  62. #endif
  63.  
  64. #ifdef BLOCK_SMOOTHING_SUPPORTED
  65.   /* When doing block smoothing, we latch coefficient Al values here */
  66.   int * coef_bits_latch;
  67. #define SAVED_COEFS  6        /* we save coef_bits[0..5] */
  68. #endif
  69. } my_coef_controller;
  70.  
  71. typedef my_coef_controller * my_coef_ptr;
  72.  
  73. /* Forward declarations */
  74. int decompress_onepass
  75.     (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
  76.  
  77. #ifdef D_MULTISCAN_FILES_SUPPORTED
  78. int decompress_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
  79. #endif
  80.  
  81. #ifdef BLOCK_SMOOTHING_SUPPORTED
  82. LOCAL(boolean) smoothing_ok (j_decompress_ptr cinfo);
  83. int decompress_smooth_data(j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
  84. #endif
  85.  
  86.  
  87. LOCAL(void) start_iMCU_row (j_decompress_ptr cinfo)
  88. /* Reset within-iMCU-row counters for a new row (input side) */
  89. {
  90.     my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  91.  
  92.     /* In an interleaved scan, an MCU row is the same as an iMCU row.
  93.     * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
  94.     * But at the bottom of the image, process only what's left.
  95.     */
  96.     if (cinfo->comps_in_scan > 1) 
  97.     {
  98.         coef->MCU_rows_per_iMCU_row = 1;
  99.     } 
  100.     else 
  101.     {
  102.         if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
  103.             coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
  104.         else
  105.             coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
  106.     }
  107.  
  108.     coef->MCU_ctr = 0;
  109.     coef->MCU_vert_offset = 0;
  110. }
  111.  
  112.  
  113. /*
  114.  * Initialize for an input processing pass.
  115.  */
  116.  
  117. void start_input_pass (j_decompress_ptr cinfo)
  118. {
  119.     cinfo->input_iMCU_row = 0;
  120.     start_iMCU_row(cinfo);
  121. }
  122.  
  123.  
  124. /*
  125.  * Initialize for an output processing pass.
  126.  */
  127.  
  128. void start_output_pass (j_decompress_ptr cinfo)
  129. {
  130. #ifdef BLOCK_SMOOTHING_SUPPORTED
  131.     my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  132.  
  133.     /* If multipass, check to see whether to use block smoothing on this pass */
  134.     if (coef->pub.coef_arrays != NULL) 
  135.     {
  136.         if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
  137.             coef->pub.decompress_data = decompress_smooth_data;
  138.         else
  139.             coef->pub.decompress_data = decompress_data;
  140.     }
  141. #endif
  142.     
  143.     cinfo->output_iMCU_row = 0;
  144. }
  145.  
  146.  
  147. /*
  148.  * Decompress and return some data in the single-pass case.
  149.  * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
  150.  * Input and output must run in lockstep since we have only a one-MCU buffer.
  151.  * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
  152.  *
  153.  * NB: output_buf contains a plane for each component in image,
  154.  * which we index according to the component's SOF position.
  155.  */
  156.  
  157. int decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
  158. {
  159.     my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  160.     JDIMENSION MCU_col_num;    /* index of current MCU within row */
  161.     JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  162.     JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  163.     int blkn, ci, xindex, yindex, yoffset, useful_width;
  164.     JSAMPARRAY output_ptr;
  165.     JDIMENSION start_col, output_col;
  166.     jpeg_component_info *compptr;
  167.     inverse_DCT_method_ptr inverse_DCT;
  168.  
  169.     /* Loop to process as much as one whole iMCU row */
  170.     for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; yoffset++) 
  171.     {
  172.         for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col; MCU_col_num++) 
  173.         {
  174.             /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
  175.             jzero_far((void *) coef->MCU_buffer[0],    (size_t) (cinfo->blocks_in_MCU * sizeof(JBLOCK)));
  176.  
  177.             if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) 
  178.             {
  179.                 /* Suspension forced; update state counters and exit */
  180.                 coef->MCU_vert_offset = yoffset;
  181.                 coef->MCU_ctr = MCU_col_num;
  182.                 return JPEG_SUSPENDED;
  183.             }
  184.       
  185.             /* Determine where data should go in output_buf and do the IDCT thing.
  186.             * We skip dummy blocks at the right and bottom edges (but blkn gets
  187.             * incremented past them!).  Note the inner loop relies on having
  188.             * allocated the MCU_buffer[] blocks sequentially.
  189.             */
  190.             blkn = 0;            /* index of current DCT block within MCU */
  191.             for (ci = 0; ci < cinfo->comps_in_scan; ci++) 
  192.             {
  193.                 compptr = cinfo->cur_comp_info[ci];
  194.                 /* Don't bother to IDCT an uninteresting component. */
  195.                 if (! compptr->component_needed) 
  196.                 {
  197.                     blkn += compptr->MCU_blocks;
  198.                     continue;
  199.                 }
  200.     
  201.                 inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
  202.                 useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width : compptr->last_col_width;
  203.     
  204.                 output_ptr = output_buf[compptr->component_index] +
  205.                   yoffset * compptr->DCT_scaled_size;
  206.     
  207.                 start_col = MCU_col_num * compptr->MCU_sample_width;
  208.                 for (yindex = 0; yindex < compptr->MCU_height; yindex++) 
  209.                 {
  210.                     if (cinfo->input_iMCU_row < last_iMCU_row ||
  211.                         yoffset+yindex < compptr->last_row_height) 
  212.                     {
  213.                         output_col = start_col;
  214.                         
  215.                         for (xindex = 0; xindex < useful_width; xindex++) 
  216.                         {
  217.                             (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
  218.                                 output_ptr, output_col);
  219.                             output_col += compptr->DCT_scaled_size;
  220.                         }
  221.                     }
  222.       
  223.                     blkn += compptr->MCU_width;
  224.                     output_ptr += compptr->DCT_scaled_size;
  225.                 }
  226.             }
  227.         }
  228.     
  229.         /* Completed an MCU row, but perhaps not an iMCU row */
  230.         coef->MCU_ctr = 0;
  231.     }
  232.   
  233.     /* Completed the iMCU row, advance counters for next one */
  234.     cinfo->output_iMCU_row++;
  235.     
  236.     if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) 
  237.     {
  238.         start_iMCU_row(cinfo);
  239.         return JPEG_ROW_COMPLETED;
  240.     }
  241.   
  242.     /* Completed the scan */
  243.     (*cinfo->inputctl->finish_input_pass) (cinfo);
  244.     
  245.     return JPEG_SCAN_COMPLETED;
  246. }
  247.  
  248.  
  249. /*
  250.  * Dummy consume-input routine for single-pass operation.
  251.  */
  252.  
  253. int dummy_consume_data (j_decompress_ptr cinfo)
  254. {
  255.     return JPEG_SUSPENDED;    /* Always indicate nothing was done */
  256. }
  257.  
  258.  
  259. #ifdef D_MULTISCAN_FILES_SUPPORTED
  260.  
  261. /*
  262.  * Consume input data and store it in the full-image coefficient buffer.
  263.  * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
  264.  * ie, v_samp_factor block rows for each component in the scan.
  265.  * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
  266.  */
  267.  
  268. int consume_data (j_decompress_ptr cinfo)
  269. {
  270.     my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  271.     JDIMENSION MCU_col_num;    /* index of current MCU within row */
  272.     int blkn, ci, xindex, yindex, yoffset;
  273.     JDIMENSION start_col;
  274.     JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
  275.     JBLOCKROW buffer_ptr;
  276.     jpeg_component_info *compptr;
  277.  
  278.     /* Align the virtual buffers for the components used in this scan. */
  279.     for (ci = 0; ci < cinfo->comps_in_scan; ci++) 
  280.     {
  281.         compptr = cinfo->cur_comp_info[ci];
  282.         buffer[ci] = cinfo->mem->access_virt_barray
  283.             (coef->whole_image[compptr->component_index],
  284.             cinfo->input_iMCU_row * compptr->v_samp_factor,
  285.             (JDIMENSION) compptr->v_samp_factor, TRUE);
  286.     
  287.         /* Note: entropy decoder expects buffer to be zeroed,
  288.         * but this is handled automatically by the memory manager
  289.         * because we requested a pre-zeroed array.
  290.         */
  291.     }
  292.  
  293.     /* Loop to process one whole iMCU row */
  294.     for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; yoffset++) 
  295.     {
  296.         for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row; MCU_col_num++) 
  297.         {
  298.             /* Construct list of pointers to DCT blocks belonging to this MCU */
  299.             blkn = 0;            /* index of current DCT block within MCU */
  300.       
  301.             for (ci = 0; ci < cinfo->comps_in_scan; ci++) 
  302.             {
  303.                 compptr = cinfo->cur_comp_info[ci];
  304.                 start_col = MCU_col_num * compptr->MCU_width;
  305.                 for (yindex = 0; yindex < compptr->MCU_height; yindex++) 
  306.                 {
  307.                     buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
  308.                     for (xindex = 0; xindex < compptr->MCU_width; xindex++) 
  309.                     {
  310.                         coef->MCU_buffer[blkn++] = buffer_ptr++;
  311.                     }
  312.                 }
  313.             }
  314.       
  315.             /* Try to fetch the MCU. */
  316.             if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) 
  317.             {
  318.                 /* Suspension forced; update state counters and exit */
  319.                 coef->MCU_vert_offset = yoffset;
  320.                 coef->MCU_ctr = MCU_col_num;
  321.                 return JPEG_SUSPENDED;
  322.             }
  323.         }
  324.     
  325.         /* Completed an MCU row, but perhaps not an iMCU row */
  326.         coef->MCU_ctr = 0;
  327.     }
  328.   
  329.     /* Completed the iMCU row, advance counters for next one */
  330.     if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) 
  331.     {
  332.         start_iMCU_row(cinfo);
  333.         return JPEG_ROW_COMPLETED;
  334.     }
  335.   
  336.     /* Completed the scan */
  337.     (*cinfo->inputctl->finish_input_pass) (cinfo);
  338.     return JPEG_SCAN_COMPLETED;
  339. }
  340.  
  341.  
  342. /*
  343.  * Decompress and return some data in the multi-pass case.
  344.  * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
  345.  * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
  346.  *
  347.  * NB: output_buf contains a plane for each component in image.
  348.  */
  349.  
  350. int decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
  351. {
  352.     my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  353.     JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  354.     JDIMENSION block_num;
  355.     int ci, block_row, block_rows;
  356.     JBLOCKARRAY buffer;
  357.     JBLOCKROW buffer_ptr;
  358.     JSAMPARRAY output_ptr;
  359.     JDIMENSION output_col;
  360.     jpeg_component_info *compptr;
  361.     inverse_DCT_method_ptr inverse_DCT;
  362.  
  363.     /* Force some input to be done if we are getting ahead of the input. */
  364.     while (cinfo->input_scan_number < cinfo->output_scan_number ||
  365.          (cinfo->input_scan_number == cinfo->output_scan_number &&
  366.           cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) 
  367.     {
  368.         if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
  369.             return JPEG_SUSPENDED;
  370.     }
  371.  
  372.     /* OK, output from the virtual arrays. */
  373.     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) 
  374.     {
  375.         /* Don't bother to IDCT an uninteresting component. */
  376.         if (! compptr->component_needed)
  377.             continue;
  378.     
  379.         /* Align the virtual buffer for this component. */
  380.         buffer = cinfo->mem->access_virt_barray(coef->whole_image[ci],
  381.             cinfo->output_iMCU_row * compptr->v_samp_factor,
  382.             (JDIMENSION) compptr->v_samp_factor, FALSE);
  383.     
  384.         /* Count non-dummy DCT block rows in this iMCU row. */
  385.         if (cinfo->output_iMCU_row < last_iMCU_row)
  386.             block_rows = compptr->v_samp_factor;
  387.         else 
  388.         {
  389.             /* NB: can't use last_row_height here; it is input-side-dependent! */
  390.             block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
  391.             
  392.             if (block_rows == 0) 
  393.                 block_rows = compptr->v_samp_factor;
  394.         }
  395.     
  396.         inverse_DCT = cinfo->idct->inverse_DCT[ci];
  397.         output_ptr = output_buf[ci];
  398.     
  399.         /* Loop over all DCT blocks to be processed. */
  400.         for (block_row = 0; block_row < block_rows; block_row++) 
  401.         {
  402.             buffer_ptr = buffer[block_row];
  403.             output_col = 0;
  404.       
  405.             for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) 
  406.             {
  407.                 (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr, output_ptr, output_col);
  408.     
  409.                 buffer_ptr++;
  410.                 output_col += compptr->DCT_scaled_size;
  411.             }
  412.             output_ptr += compptr->DCT_scaled_size;
  413.         }
  414.     }
  415.  
  416.     if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
  417.         return JPEG_ROW_COMPLETED;
  418.   
  419.     return JPEG_SCAN_COMPLETED;
  420. }
  421.  
  422. #endif /* D_MULTISCAN_FILES_SUPPORTED */
  423.  
  424.  
  425. #ifdef BLOCK_SMOOTHING_SUPPORTED
  426.  
  427. /*
  428.  * This code applies interblock smoothing as described by section K.8
  429.  * of the JPEG standard: the first 5 AC coefficients are estimated from
  430.  * the DC values of a DCT block and its 8 neighboring blocks.
  431.  * We apply smoothing only for progressive JPEG decoding, and only if
  432.  * the coefficients it can estimate are not yet known to full precision.
  433.  */
  434.  
  435. /* Natural-order array positions of the first 5 zigzag-order coefficients */
  436. #define Q01_POS  1
  437. #define Q10_POS  8
  438. #define Q20_POS  16
  439. #define Q11_POS  9
  440. #define Q02_POS  2
  441.  
  442. /*
  443.  * Determine whether block smoothing is applicable and safe.
  444.  * We also latch the current states of the coef_bits[] entries for the
  445.  * AC coefficients; otherwise, if the input side of the decompressor
  446.  * advances into a new scan, we might think the coefficients are known
  447.  * more accurately than they really are.
  448.  */
  449.  
  450. LOCAL(boolean)
  451. smoothing_ok (j_decompress_ptr cinfo)
  452. {
  453.     my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  454.     boolean smoothing_useful = FALSE;
  455.     int ci, coefi;
  456.     jpeg_component_info *compptr;
  457.     JQUANT_TBL * qtable;
  458.     int * coef_bits;
  459.     int * coef_bits_latch;
  460.  
  461.     if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
  462.         return FALSE;
  463.  
  464.     /* Allocate latch area if not already done */
  465.     if (coef->coef_bits_latch == NULL)
  466.         coef->coef_bits_latch = (int *) cinfo->mem->alloc_small(JPOOL_IMAGE,
  467.                                 cinfo->num_components * (SAVED_COEFS * sizeof(int)));
  468.     
  469.     coef_bits_latch = coef->coef_bits_latch;
  470.  
  471.     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) 
  472.     {
  473.         /* All components' quantization values must already be latched. */
  474.         if ((qtable = compptr->quant_table) == NULL)
  475.             return FALSE;
  476.     
  477.         /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
  478.         if (qtable->quantval[0] == 0 ||
  479.             qtable->quantval[Q01_POS] == 0 ||
  480.             qtable->quantval[Q10_POS] == 0 ||
  481.             qtable->quantval[Q20_POS] == 0 ||
  482.             qtable->quantval[Q11_POS] == 0 ||
  483.             qtable->quantval[Q02_POS] == 0)
  484.             return FALSE;
  485.     
  486.         /* DC values must be at least partly known for all components. */
  487.         coef_bits = cinfo->coef_bits[ci];
  488.         if (coef_bits[0] < 0)
  489.             return FALSE;
  490.     
  491.         /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
  492.         for (coefi = 1; coefi <= 5; coefi++) 
  493.         {
  494.             coef_bits_latch[coefi] = coef_bits[coefi];
  495.         
  496.             if (coef_bits[coefi] != 0)
  497.                 smoothing_useful = TRUE;
  498.         }
  499.         
  500.         coef_bits_latch += SAVED_COEFS;
  501.     }
  502.  
  503.     return smoothing_useful;
  504. }
  505.  
  506.  
  507. /*
  508.  * Variant of decompress_data for use when doing block smoothing.
  509.  */
  510.  
  511. int decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
  512. {
  513.     my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  514.     JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  515.     JDIMENSION block_num, last_block_column;
  516.     int ci, block_row, block_rows, access_rows;
  517.     JBLOCKARRAY buffer;
  518.     JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
  519.     JSAMPARRAY output_ptr;
  520.     JDIMENSION output_col;
  521.     jpeg_component_info *compptr;
  522.     inverse_DCT_method_ptr inverse_DCT;
  523.     boolean first_row, last_row;
  524.     JBLOCK workspace;
  525.     int *coef_bits;
  526.     JQUANT_TBL *quanttbl;
  527.     long Q00,Q01,Q02,Q10,Q11,Q20, num;
  528.     int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
  529.     int Al, pred;
  530.  
  531.     /* Force some input to be done if we are getting ahead of the input. */
  532.     while (cinfo->input_scan_number <= cinfo->output_scan_number && ! cinfo->inputctl->eoi_reached) 
  533.     {
  534.         if (cinfo->input_scan_number == cinfo->output_scan_number) 
  535.         {
  536.             /* If input is working on current scan, we ordinarily want it to
  537.             * have completed the current row.  But if input scan is DC,
  538.             * we want it to keep one row ahead so that next block row's DC
  539.             * values are up to date.
  540.             */
  541.             JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
  542.             if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
  543.                 break;
  544.         }
  545.         if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
  546.             return JPEG_SUSPENDED;
  547.     }
  548.  
  549.     /* OK, output from the virtual arrays. */
  550.     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) 
  551.     {
  552.         /* Don't bother to IDCT an uninteresting component. */
  553.         if (! compptr->component_needed)
  554.             continue;
  555.     
  556.         /* Count non-dummy DCT block rows in this iMCU row. */
  557.         if (cinfo->output_iMCU_row < last_iMCU_row) 
  558.         {
  559.             block_rows = compptr->v_samp_factor;
  560.             access_rows = block_rows * 2; /* this and next iMCU row */
  561.             last_row = FALSE;
  562.         } 
  563.         else 
  564.         {
  565.             /* NB: can't use last_row_height here; it is input-side-dependent! */
  566.             block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
  567.             if (block_rows == 0) 
  568.                 block_rows = compptr->v_samp_factor;
  569.             
  570.             access_rows = block_rows; /* this iMCU row only */
  571.             last_row = TRUE;
  572.         }
  573.     
  574.         /* Align the virtual buffer for this component. */
  575.         if (cinfo->output_iMCU_row > 0) 
  576.         {
  577.             access_rows += compptr->v_samp_factor; /* prior iMCU row too */
  578.             buffer = cinfo->mem->access_virt_barray
  579.                 (coef->whole_image[ci],
  580.                 (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
  581.                 (JDIMENSION) access_rows, FALSE);
  582.       
  583.             buffer += compptr->v_samp_factor;    /* point to current iMCU row */
  584.             first_row = FALSE;
  585.         } 
  586.         else 
  587.         {
  588.             buffer = cinfo->mem->access_virt_barray
  589.                     (coef->whole_image[ci],
  590.                     (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
  591.       
  592.             first_row = TRUE;
  593.         }
  594.     
  595.         /* Fetch component-dependent info */
  596.         coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
  597.         quanttbl = compptr->quant_table;
  598.         Q00 = quanttbl->quantval[0];
  599.         Q01 = quanttbl->quantval[Q01_POS];
  600.         Q10 = quanttbl->quantval[Q10_POS];
  601.         Q20 = quanttbl->quantval[Q20_POS];
  602.         Q11 = quanttbl->quantval[Q11_POS];
  603.         Q02 = quanttbl->quantval[Q02_POS];
  604.     
  605.         inverse_DCT = cinfo->idct->inverse_DCT[ci];
  606.         output_ptr = output_buf[ci];
  607.     
  608.         /* Loop over all DCT blocks to be processed. */
  609.         for (block_row = 0; block_row < block_rows; block_row++) 
  610.         {
  611.             buffer_ptr = buffer[block_row];
  612.             
  613.             if (first_row && block_row == 0)
  614.                 prev_block_row = buffer_ptr;
  615.             else
  616.                 prev_block_row = buffer[block_row-1];
  617.       
  618.             if (last_row && block_row == block_rows-1)
  619.                 next_block_row = buffer_ptr;
  620.             else
  621.                 next_block_row = buffer[block_row+1];
  622.       
  623.             /* We fetch the surrounding DC values using a sliding-register approach.
  624.             * Initialize all nine here so as to do the right thing on narrow pics.
  625.             */
  626.             DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
  627.             DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
  628.             DC7 = DC8 = DC9 = (int) next_block_row[0][0];
  629.             output_col = 0;
  630.             last_block_column = compptr->width_in_blocks - 1;
  631.       
  632.             for (block_num = 0; block_num <= last_block_column; block_num++) 
  633.             {
  634.                 /* Fetch current DCT block into workspace so we can modify it. */
  635.                 jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
  636.                 
  637.                 /* Update DC values */
  638.                 if (block_num < last_block_column) 
  639.                 {
  640.                     DC3 = (int) prev_block_row[1][0];
  641.                     DC6 = (int) buffer_ptr[1][0];
  642.                     DC9 = (int) next_block_row[1][0];
  643.                 }
  644.     
  645.                 /* Compute coefficient estimates per K.8.
  646.                 * An estimate is applied only if coefficient is still zero,
  647.                 * and is not known to be fully accurate.
  648.                 */
  649.                 /* AC01 */
  650.                 if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) 
  651.                 {
  652.                     num = 36 * Q00 * (DC4 - DC6);
  653.                     if (num >= 0) 
  654.                     {
  655.                         pred = (int) (((Q01<<7) + num) / (Q01<<8));
  656.                         if (Al > 0 && pred >= (1<<Al))
  657.                             pred = (1<<Al)-1;
  658.                     } 
  659.                     else 
  660.                     {
  661.                         pred = (int) (((Q01<<7) - num) / (Q01<<8));
  662.                         if (Al > 0 && pred >= (1<<Al))
  663.                             pred = (1<<Al)-1;
  664.                         pred = -pred;
  665.                     }
  666.       
  667.                     workspace[1] = (JCOEF) pred;
  668.                 }
  669.                 
  670.                 /* AC10 */
  671.                 if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) 
  672.                 {
  673.                     num = 36 * Q00 * (DC2 - DC8);
  674.                     if (num >= 0) 
  675.                     {
  676.                         pred = (int) (((Q10<<7) + num) / (Q10<<8));
  677.                         
  678.                         if (Al > 0 && pred >= (1<<Al))
  679.                             pred = (1<<Al)-1;
  680.                     } 
  681.                     else 
  682.                     {
  683.                         pred = (int) (((Q10<<7) - num) / (Q10<<8));
  684.                         if (Al > 0 && pred >= (1<<Al))
  685.                             pred = (1<<Al)-1;
  686.                         pred = -pred;
  687.                     }
  688.                     workspace[8] = (JCOEF) pred;
  689.                 }
  690.     
  691.                 /* AC20 */
  692.                 if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) 
  693.                 {
  694.                     num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
  695.                     if (num >= 0) 
  696.                     {
  697.                         pred = (int) (((Q20<<7) + num) / (Q20<<8));
  698.                         if (Al > 0 && pred >= (1<<Al))
  699.                             pred = (1<<Al)-1;
  700.                     } 
  701.                     else 
  702.                     {
  703.                         pred = (int) (((Q20<<7) - num) / (Q20<<8));
  704.                         if (Al > 0 && pred >= (1<<Al))
  705.                             pred = (1<<Al)-1;
  706.                         pred = -pred;
  707.                     }
  708.       
  709.                     workspace[16] = (JCOEF) pred;
  710.                 }
  711.     
  712.                 /* AC11 */
  713.                 if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) 
  714.                 {
  715.                     num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
  716.                     if (num >= 0) 
  717.                     {
  718.                         pred = (int) (((Q11<<7) + num) / (Q11<<8));
  719.                         if (Al > 0 && pred >= (1<<Al))
  720.                             pred = (1<<Al)-1;
  721.                     } 
  722.                     else 
  723.                     {
  724.                         pred = (int) (((Q11<<7) - num) / (Q11<<8));
  725.                         if (Al > 0 && pred >= (1<<Al))
  726.                             pred = (1<<Al)-1;
  727.                         pred = -pred;
  728.                     }
  729.                     workspace[9] = (JCOEF) pred;
  730.                 }
  731.     
  732.                 /* AC02 */
  733.                 if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) 
  734.                 {
  735.                     num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
  736.                     if (num >= 0) 
  737.                     {
  738.                         pred = (int) (((Q02<<7) + num) / (Q02<<8));
  739.                         
  740.                         if (Al > 0 && pred >= (1<<Al))
  741.                             pred = (1<<Al)-1;
  742.                     } 
  743.                     else 
  744.                     {
  745.                         pred = (int) (((Q02<<7) - num) / (Q02<<8));
  746.                         
  747.                         if (Al > 0 && pred >= (1<<Al))
  748.                             pred = (1<<Al)-1;
  749.                         pred = -pred;
  750.                     }
  751.                 
  752.                     workspace[2] = (JCOEF) pred;
  753.                 }
  754.     
  755.                 /* OK, do the IDCT */
  756.                 (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace, output_ptr, output_col);
  757.     
  758.                 /* Advance for next column */
  759.                 DC1 = DC2; DC2 = DC3;
  760.                 DC4 = DC5; DC5 = DC6;
  761.                 DC7 = DC8; DC8 = DC9;
  762.                 buffer_ptr++, prev_block_row++, next_block_row++;
  763.                 output_col += compptr->DCT_scaled_size;
  764.             }
  765.             output_ptr += compptr->DCT_scaled_size;
  766.         }
  767.     }
  768.  
  769.     if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
  770.         return JPEG_ROW_COMPLETED;
  771.   
  772.     return JPEG_SCAN_COMPLETED;
  773. }
  774.  
  775. #endif /* BLOCK_SMOOTHING_SUPPORTED */
  776.  
  777.  
  778. /*
  779.  * Initialize coefficient buffer controller.
  780.  */
  781.  
  782. GLOBAL(void)
  783. jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
  784. {
  785.     my_coef_ptr coef;
  786.  
  787.     coef = (my_coef_ptr) cinfo->mem->alloc_small (JPOOL_IMAGE, sizeof(my_coef_controller));
  788.   
  789.     cinfo->coef = (struct jpeg_d_coef_controller *) coef;
  790.     coef->pub.start_input_pass = start_input_pass;
  791.     coef->pub.start_output_pass = start_output_pass;
  792.  
  793. #ifdef BLOCK_SMOOTHING_SUPPORTED
  794.     coef->coef_bits_latch = NULL;
  795. #endif
  796.  
  797.     /* Create the coefficient buffer. */
  798.     if (need_full_buffer) 
  799.     {
  800. #ifdef D_MULTISCAN_FILES_SUPPORTED
  801.         /* Allocate a full-image virtual array for each component, */
  802.         /* padded to a multiple of samp_factor DCT blocks in each direction. */
  803.         /* Note we ask for a pre-zeroed array. */
  804.         int ci, access_rows;
  805.         jpeg_component_info *compptr;
  806.  
  807.         for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) 
  808.         {
  809.             access_rows = compptr->v_samp_factor;
  810. #ifdef BLOCK_SMOOTHING_SUPPORTED
  811.             /* If block smoothing could be used, need a bigger window */
  812.             if (cinfo->progressive_mode)
  813.                 access_rows *= 3;
  814. #endif
  815.             coef->whole_image[ci] = cinfo->mem->request_virt_barray
  816.                 (JPOOL_IMAGE, TRUE,
  817.                 (JDIMENSION) jround_up((long) compptr->width_in_blocks,  (long) compptr->h_samp_factor),
  818.                 (JDIMENSION) jround_up((long) compptr->height_in_blocks, (long) compptr->v_samp_factor),
  819.                 (JDIMENSION) access_rows);
  820.         }
  821.     
  822.         coef->pub.consume_data = consume_data;
  823.         coef->pub.decompress_data = decompress_data;
  824.         coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
  825. #else
  826.         ERREXIT(cinfo, JERR_NOT_COMPILED);
  827. #endif
  828.     } 
  829.     else 
  830.     {
  831.         /* We only need a single-MCU buffer. */
  832.         JBLOCKROW buffer = (JBLOCKROW) cinfo->mem->alloc_large(JPOOL_IMAGE, D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
  833.     
  834.         for (int i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) 
  835.         {
  836.             coef->MCU_buffer[i] = buffer + i;
  837.         }
  838.     
  839.         coef->pub.consume_data = dummy_consume_data;
  840.         coef->pub.decompress_data = decompress_onepass;
  841.         coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
  842.     }
  843. }
  844.