JCCOEFCT.c
上传用户:cjw5120
上传日期:2022-05-11
资源大小:5032k
文件大小:17k
源码类别:

网络截获/分析

开发平台:

Visual C++

  1. ////////////////////////////////////////////////////////////////////////
  2. //
  3. // Note : this file is included as part of the Smaller Animals Software
  4. // JpegFile package. Though this file has not been modified from it's 
  5. // original IJG 6a form, it is not the responsibility on the Independent
  6. // JPEG Group to answer questions regarding this code.
  7. //
  8. // Any questions you have about this code should be addressed to :
  9. //
  10. // CHRISDL@PAGESZ.NET - the distributor of this package.
  11. //
  12. // Remember, by including this code in the JpegFile package, Smaller 
  13. // Animals Software assumes all responsibilities for answering questions
  14. // about it. If we (SA Software) can't answer your questions ourselves, we 
  15. // will direct you to people who can.
  16. //
  17. // Thanks, CDL.
  18. //
  19. ////////////////////////////////////////////////////////////////////////
  20. /*
  21.  * jccoefct.c
  22.  *
  23.  * Copyright (C) 1994-1996, Thomas G. Lane.
  24.  * This file is part of the Independent JPEG Group's software.
  25.  * For conditions of distribution and use, see the accompanying README file.
  26.  *
  27.  * This file contains the coefficient buffer controller for compression.
  28.  * This controller is the top level of the JPEG compressor proper.
  29.  * The coefficient buffer lies between forward-DCT and entropy encoding steps.
  30.  */
  31. #define JPEG_INTERNALS
  32. #include "jinclude.h"
  33. #include "jpeglib.h"
  34. /* We use a full-image coefficient buffer when doing Huffman optimization,
  35.  * and also for writing multiple-scan JPEG files.  In all cases, the DCT
  36.  * step is run during the first pass, and subsequent passes need only read
  37.  * the buffered coefficients.
  38.  */
  39. #ifdef ENTROPY_OPT_SUPPORTED
  40. #define FULL_COEF_BUFFER_SUPPORTED
  41. #else
  42. #ifdef C_MULTISCAN_FILES_SUPPORTED
  43. #define FULL_COEF_BUFFER_SUPPORTED
  44. #endif
  45. #endif
  46. /* Private buffer controller object */
  47. typedef struct {
  48.   struct jpeg_c_coef_controller pub; /* public fields */
  49.   JDIMENSION iMCU_row_num; /* iMCU row # within image */
  50.   JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
  51.   int MCU_vert_offset; /* counts MCU rows within iMCU row */
  52.   int MCU_rows_per_iMCU_row; /* number of such rows needed */
  53.   /* For single-pass compression, it's sufficient to buffer just one MCU
  54.    * (although this may prove a bit slow in practice).  We allocate a
  55.    * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
  56.    * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
  57.    * it's not really very big; this is to keep the module interfaces unchanged
  58.    * when a large coefficient buffer is necessary.)
  59.    * In multi-pass modes, this array points to the current MCU's blocks
  60.    * within the virtual arrays.
  61.    */
  62.   JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
  63.   /* In multi-pass modes, we need a virtual block array for each component. */
  64.   jvirt_barray_ptr whole_image[MAX_COMPONENTS];
  65. } my_coef_controller;
  66. typedef my_coef_controller * my_coef_ptr;
  67. /* Forward declarations */
  68. METHODDEF(unsigned int) compress_data
  69.     JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
  70. #ifdef FULL_COEF_BUFFER_SUPPORTED
  71. METHODDEF(unsigned int) compress_first_pass
  72.     JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
  73. METHODDEF(unsigned int) compress_output
  74.     JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
  75. #endif
  76. LOCAL(void)
  77. start_iMCU_row (j_compress_ptr cinfo)
  78. /* Reset within-iMCU-row counters for a new row */
  79. {
  80.   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  81.   /* In an interleaved scan, an MCU row is the same as an iMCU row.
  82.    * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
  83.    * But at the bottom of the image, process only what's left.
  84.    */
  85.   if (cinfo->comps_in_scan > 1) {
  86.     coef->MCU_rows_per_iMCU_row = 1;
  87.   } else {
  88.     if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
  89.       coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
  90.     else
  91.       coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
  92.   }
  93.   coef->mcu_ctr = 0;
  94.   coef->MCU_vert_offset = 0;
  95. }
  96. /*
  97.  * Initialize for a processing pass.
  98.  */
  99. METHODDEF(void)
  100. start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
  101. {
  102.   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  103.   coef->iMCU_row_num = 0;
  104.   start_iMCU_row(cinfo);
  105.   switch (pass_mode) {
  106.   case JBUF_PASS_THRU:
  107.     if (coef->whole_image[0] != NULL)
  108.       ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  109.     coef->pub.compress_data = compress_data;
  110.     break;
  111. #ifdef FULL_COEF_BUFFER_SUPPORTED
  112.   case JBUF_SAVE_AND_PASS:
  113.     if (coef->whole_image[0] == NULL)
  114.       ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  115.     coef->pub.compress_data = compress_first_pass;
  116.     break;
  117.   case JBUF_CRANK_DEST:
  118.     if (coef->whole_image[0] == NULL)
  119.       ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  120.     coef->pub.compress_data = compress_output;
  121.     break;
  122. #endif
  123.   default:
  124.     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  125.     break;
  126.   }
  127. }
  128. /*
  129.  * Process some data in the single-pass case.
  130.  * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  131.  * per call, ie, v_samp_factor block rows for each component in the image.
  132.  * Returns TRUE if the iMCU row is completed, FALSE if suspended.
  133.  *
  134.  * NB: input_buf contains a plane for each component in image.
  135.  * For single pass, this is the same as the components in the scan.
  136.  */
  137. METHODDEF(unsigned int)
  138. compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  139. {
  140.   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  141.   JDIMENSION MCU_col_num; /* index of current MCU within row */
  142.   JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  143.   JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  144.   int blkn, bi, ci, yindex, yoffset, blockcnt;
  145.   JDIMENSION ypos, xpos;
  146.   jpeg_component_info *compptr;
  147.   /* Loop to write as much as one whole iMCU row */
  148.   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
  149.        yoffset++) {
  150.     for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
  151.  MCU_col_num++) {
  152.       /* Determine where data comes from in input_buf and do the DCT thing.
  153.        * Each call on forward_DCT processes a horizontal row of DCT blocks
  154.        * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
  155.        * sequentially.  Dummy blocks at the right or bottom edge are filled in
  156.        * specially.  The data in them does not matter for image reconstruction,
  157.        * so we fill them with values that will encode to the smallest amount of
  158.        * data, viz: all zeroes in the AC entries, DC entries equal to previous
  159.        * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
  160.        */
  161.       blkn = 0;
  162.       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  163. compptr = cinfo->cur_comp_info[ci];
  164. blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
  165. : compptr->last_col_width;
  166. xpos = MCU_col_num * compptr->MCU_sample_width;
  167. ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
  168. for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
  169.   if (coef->iMCU_row_num < last_iMCU_row ||
  170.       yoffset+yindex < compptr->last_row_height) {
  171.     (*cinfo->fdct->forward_DCT) (cinfo, compptr,
  172.  input_buf[ci], coef->MCU_buffer[blkn],
  173.  ypos, xpos, (JDIMENSION) blockcnt);
  174.     if (blockcnt < compptr->MCU_width) {
  175.       /* Create some dummy blocks at the right edge of the image. */
  176.       jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
  177. (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
  178.       for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
  179. coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
  180.       }
  181.     }
  182.   } else {
  183.     /* Create a row of dummy blocks at the bottom of the image. */
  184.     jzero_far((void FAR *) coef->MCU_buffer[blkn],
  185.       compptr->MCU_width * SIZEOF(JBLOCK));
  186.     for (bi = 0; bi < compptr->MCU_width; bi++) {
  187.       coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
  188.     }
  189.   }
  190.   blkn += compptr->MCU_width;
  191.   ypos += DCTSIZE;
  192. }
  193.       }
  194.       /* Try to write the MCU.  In event of a suspension failure, we will
  195.        * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
  196.        */
  197.       if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
  198. /* Suspension forced; update state counters and exit */
  199. coef->MCU_vert_offset = yoffset;
  200. coef->mcu_ctr = MCU_col_num;
  201. return FALSE;
  202.       }
  203.     }
  204.     /* Completed an MCU row, but perhaps not an iMCU row */
  205.     coef->mcu_ctr = 0;
  206.   }
  207.   /* Completed the iMCU row, advance counters for next one */
  208.   coef->iMCU_row_num++;
  209.   start_iMCU_row(cinfo);
  210.   return TRUE;
  211. }
  212. #ifdef FULL_COEF_BUFFER_SUPPORTED
  213. /*
  214.  * Process some data in the first pass of a multi-pass case.
  215.  * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  216.  * per call, ie, v_samp_factor block rows for each component in the image.
  217.  * This amount of data is read from the source buffer, DCT'd and quantized,
  218.  * and saved into the virtual arrays.  We also generate suitable dummy blocks
  219.  * as needed at the right and lower edges.  (The dummy blocks are constructed
  220.  * in the virtual arrays, which have been padded appropriately.)  This makes
  221.  * it possible for subsequent passes not to worry about real vs. dummy blocks.
  222.  *
  223.  * We must also emit the data to the entropy encoder.  This is conveniently
  224.  * done by calling compress_output() after we've loaded the current strip
  225.  * of the virtual arrays.
  226.  *
  227.  * NB: input_buf contains a plane for each component in image.  All
  228.  * components are DCT'd and loaded into the virtual arrays in this pass.
  229.  * However, it may be that only a subset of the components are emitted to
  230.  * the entropy encoder during this first pass; be careful about looking
  231.  * at the scan-dependent variables (MCU dimensions, etc).
  232.  */
  233. METHODDEF(unsigned int)
  234. compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  235. {
  236.   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  237.   JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  238.   JDIMENSION blocks_across, MCUs_across, MCUindex;
  239.   int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
  240.   JCOEF lastDC;
  241.   jpeg_component_info *compptr;
  242.   JBLOCKARRAY buffer;
  243.   JBLOCKROW thisblockrow, lastblockrow;
  244.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  245.        ci++, compptr++) {
  246.     /* Align the virtual buffer for this component. */
  247.     buffer = (*cinfo->mem->access_virt_barray)
  248.       ((j_common_ptr) cinfo, coef->whole_image[ci],
  249.        coef->iMCU_row_num * compptr->v_samp_factor,
  250.        (JDIMENSION) compptr->v_samp_factor, TRUE);
  251.     /* Count non-dummy DCT block rows in this iMCU row. */
  252.     if (coef->iMCU_row_num < last_iMCU_row)
  253.       block_rows = compptr->v_samp_factor;
  254.     else {
  255.       /* NB: can't use last_row_height here, since may not be set! */
  256.       block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
  257.       if (block_rows == 0) block_rows = compptr->v_samp_factor;
  258.     }
  259.     blocks_across = compptr->width_in_blocks;
  260.     h_samp_factor = compptr->h_samp_factor;
  261.     /* Count number of dummy blocks to be added at the right margin. */
  262.     ndummy = (int) (blocks_across % h_samp_factor);
  263.     if (ndummy > 0)
  264.       ndummy = h_samp_factor - ndummy;
  265.     /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
  266.      * on forward_DCT processes a complete horizontal row of DCT blocks.
  267.      */
  268.     for (block_row = 0; block_row < block_rows; block_row++) {
  269.       thisblockrow = buffer[block_row];
  270.       (*cinfo->fdct->forward_DCT) (cinfo, compptr,
  271.    input_buf[ci], thisblockrow,
  272.    (JDIMENSION) (block_row * DCTSIZE),
  273.    (JDIMENSION) 0, blocks_across);
  274.       if (ndummy > 0) {
  275. /* Create dummy blocks at the right edge of the image. */
  276. thisblockrow += blocks_across; /* => first dummy block */
  277. jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
  278. lastDC = thisblockrow[-1][0];
  279. for (bi = 0; bi < ndummy; bi++) {
  280.   thisblockrow[bi][0] = lastDC;
  281. }
  282.       }
  283.     }
  284.     /* If at end of image, create dummy block rows as needed.
  285.      * The tricky part here is that within each MCU, we want the DC values
  286.      * of the dummy blocks to match the last real block's DC value.
  287.      * This squeezes a few more bytes out of the resulting file...
  288.      */
  289.     if (coef->iMCU_row_num == last_iMCU_row) {
  290.       blocks_across += ndummy; /* include lower right corner */
  291.       MCUs_across = blocks_across / h_samp_factor;
  292.       for (block_row = block_rows; block_row < compptr->v_samp_factor;
  293.    block_row++) {
  294. thisblockrow = buffer[block_row];
  295. lastblockrow = buffer[block_row-1];
  296. jzero_far((void FAR *) thisblockrow,
  297.   (size_t) (blocks_across * SIZEOF(JBLOCK)));
  298. for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
  299.   lastDC = lastblockrow[h_samp_factor-1][0];
  300.   for (bi = 0; bi < h_samp_factor; bi++) {
  301.     thisblockrow[bi][0] = lastDC;
  302.   }
  303.   thisblockrow += h_samp_factor; /* advance to next MCU in row */
  304.   lastblockrow += h_samp_factor;
  305. }
  306.       }
  307.     }
  308.   }
  309.   /* NB: compress_output will increment iMCU_row_num if successful.
  310.    * A suspension return will result in redoing all the work above next time.
  311.    */
  312.   /* Emit data to the entropy encoder, sharing code with subsequent passes */
  313.   return compress_output(cinfo, input_buf);
  314. }
  315. /*
  316.  * Process some data in subsequent passes of a multi-pass case.
  317.  * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  318.  * per call, ie, v_samp_factor block rows for each component in the scan.
  319.  * The data is obtained from the virtual arrays and fed to the entropy coder.
  320.  * Returns TRUE if the iMCU row is completed, FALSE if suspended.
  321.  *
  322.  * NB: input_buf is ignored; it is likely to be a NULL pointer.
  323.  */
  324. METHODDEF(unsigned int)
  325. compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
  326. {
  327.   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  328.   JDIMENSION MCU_col_num; /* index of current MCU within row */
  329.   int blkn, ci, xindex, yindex, yoffset;
  330.   JDIMENSION start_col;
  331.   JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
  332.   JBLOCKROW buffer_ptr;
  333.   jpeg_component_info *compptr;
  334.   /* Align the virtual buffers for the components used in this scan.
  335.    * NB: during first pass, this is safe only because the buffers will
  336.    * already be aligned properly, so jmemmgr.c won't need to do any I/O.
  337.    */
  338.   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  339.     compptr = cinfo->cur_comp_info[ci];
  340.     buffer[ci] = (*cinfo->mem->access_virt_barray)
  341.       ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
  342.        coef->iMCU_row_num * compptr->v_samp_factor,
  343.        (JDIMENSION) compptr->v_samp_factor, FALSE);
  344.   }
  345.   /* Loop to process one whole iMCU row */
  346.   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
  347.        yoffset++) {
  348.     for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
  349.  MCU_col_num++) {
  350.       /* Construct list of pointers to DCT blocks belonging to this MCU */
  351.       blkn = 0; /* index of current DCT block within MCU */
  352.       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  353. compptr = cinfo->cur_comp_info[ci];
  354. start_col = MCU_col_num * compptr->MCU_width;
  355. for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
  356.   buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
  357.   for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
  358.     coef->MCU_buffer[blkn++] = buffer_ptr++;
  359.   }
  360. }
  361.       }
  362.       /* Try to write the MCU. */
  363.       if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
  364. /* Suspension forced; update state counters and exit */
  365. coef->MCU_vert_offset = yoffset;
  366. coef->mcu_ctr = MCU_col_num;
  367. return FALSE;
  368.       }
  369.     }
  370.     /* Completed an MCU row, but perhaps not an iMCU row */
  371.     coef->mcu_ctr = 0;
  372.   }
  373.   /* Completed the iMCU row, advance counters for next one */
  374.   coef->iMCU_row_num++;
  375.   start_iMCU_row(cinfo);
  376.   return TRUE;
  377. }
  378. #endif /* FULL_COEF_BUFFER_SUPPORTED */
  379. /*
  380.  * Initialize coefficient buffer controller.
  381.  */
  382. GLOBAL(void)
  383. jinit_c_coef_controller (j_compress_ptr cinfo, unsigned int need_full_buffer)
  384. {
  385.   my_coef_ptr coef;
  386.   coef = (my_coef_ptr)
  387.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  388. SIZEOF(my_coef_controller));
  389.   cinfo->coef = (struct jpeg_c_coef_controller *) coef;
  390.   coef->pub.start_pass = start_pass_coef;
  391.   /* Create the coefficient buffer. */
  392.   if (need_full_buffer) {
  393. #ifdef FULL_COEF_BUFFER_SUPPORTED
  394.     /* Allocate a full-image virtual array for each component, */
  395.     /* padded to a multiple of samp_factor DCT blocks in each direction. */
  396.     int ci;
  397.     jpeg_component_info *compptr;
  398.     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  399.  ci++, compptr++) {
  400.       coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
  401. ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
  402.  (JDIMENSION) jround_up((long) compptr->width_in_blocks,
  403. (long) compptr->h_samp_factor),
  404.  (JDIMENSION) jround_up((long) compptr->height_in_blocks,
  405. (long) compptr->v_samp_factor),
  406.  (JDIMENSION) compptr->v_samp_factor);
  407.     }
  408. #else
  409.     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  410. #endif
  411.   } else {
  412.     /* We only need a single-MCU buffer. */
  413.     JBLOCKROW buffer;
  414.     int i;
  415.     buffer = (JBLOCKROW)
  416.       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  417.   C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
  418.     for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
  419.       coef->MCU_buffer[i] = buffer + i;
  420.     }
  421.     coef->whole_image[0] = NULL; /* flag for no virtual arrays */
  422.   }
  423. }