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

网络截获/分析

开发平台:

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.  * jddctmgr.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 inverse-DCT management logic.
  28.  * This code selects a particular IDCT implementation to be used,
  29.  * and it performs related housekeeping chores.  No code in this file
  30.  * is executed per IDCT step, only during output pass setup.
  31.  *
  32.  * Note that the IDCT routines are responsible for performing coefficient
  33.  * dequantization as well as the IDCT proper.  This module sets up the
  34.  * dequantization multiplier table needed by the IDCT routine.
  35.  */
  36. #define JPEG_INTERNALS
  37. #include "jinclude.h"
  38. #include "jpeglib.h"
  39. #include "jdct.h" /* Private declarations for DCT subsystem */
  40. /*
  41.  * The decompressor input side (jdinput.c) saves away the appropriate
  42.  * quantization table for each component at the start of the first scan
  43.  * involving that component.  (This is necessary in order to correctly
  44.  * decode files that reuse Q-table slots.)
  45.  * When we are ready to make an output pass, the saved Q-table is converted
  46.  * to a multiplier table that will actually be used by the IDCT routine.
  47.  * The multiplier table contents are IDCT-method-dependent.  To support
  48.  * application changes in IDCT method between scans, we can remake the
  49.  * multiplier tables if necessary.
  50.  * In buffered-image mode, the first output pass may occur before any data
  51.  * has been seen for some components, and thus before their Q-tables have
  52.  * been saved away.  To handle this case, multiplier tables are preset
  53.  * to zeroes; the result of the IDCT will be a neutral gray level.
  54.  */
  55. /* Private subobject for this module */
  56. typedef struct {
  57.   struct jpeg_inverse_dct pub; /* public fields */
  58.   /* This array contains the IDCT method code that each multiplier table
  59.    * is currently set up for, or -1 if it's not yet set up.
  60.    * The actual multiplier tables are pointed to by dct_table in the
  61.    * per-component comp_info structures.
  62.    */
  63.   int cur_method[MAX_COMPONENTS];
  64. } my_idct_controller;
  65. typedef my_idct_controller * my_idct_ptr;
  66. /* Allocated multiplier tables: big enough for any supported variant */
  67. typedef union {
  68.   ISLOW_MULT_TYPE islow_array[DCTSIZE2];
  69. #ifdef DCT_IFAST_SUPPORTED
  70.   IFAST_MULT_TYPE ifast_array[DCTSIZE2];
  71. #endif
  72. #ifdef DCT_FLOAT_SUPPORTED
  73.   FLOAT_MULT_TYPE float_array[DCTSIZE2];
  74. #endif
  75. } multiplier_table;
  76. /* The current scaled-IDCT routines require ISLOW-style multiplier tables,
  77.  * so be sure to compile that code if either ISLOW or SCALING is requested.
  78.  */
  79. #ifdef DCT_ISLOW_SUPPORTED
  80. #define PROVIDE_ISLOW_TABLES
  81. #else
  82. #ifdef IDCT_SCALING_SUPPORTED
  83. #define PROVIDE_ISLOW_TABLES
  84. #endif
  85. #endif
  86. /*
  87.  * Prepare for an output pass.
  88.  * Here we select the proper IDCT routine for each component and build
  89.  * a matching multiplier table.
  90.  */
  91. METHODDEF(void)
  92. start_pass (j_decompress_ptr cinfo)
  93. {
  94.   my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
  95.   int ci, i;
  96.   jpeg_component_info *compptr;
  97.   int method = 0;
  98.   inverse_DCT_method_ptr method_ptr = NULL;
  99.   JQUANT_TBL * qtbl;
  100.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  101.        ci++, compptr++) {
  102.     /* Select the proper IDCT routine for this component's scaling */
  103.     switch (compptr->DCT_scaled_size) {
  104. #ifdef IDCT_SCALING_SUPPORTED
  105.     case 1:
  106.       method_ptr = jpeg_idct_1x1;
  107.       method = JDCT_ISLOW; /* jidctred uses islow-style table */
  108.       break;
  109.     case 2:
  110.       method_ptr = jpeg_idct_2x2;
  111.       method = JDCT_ISLOW; /* jidctred uses islow-style table */
  112.       break;
  113.     case 4:
  114.       method_ptr = jpeg_idct_4x4;
  115.       method = JDCT_ISLOW; /* jidctred uses islow-style table */
  116.       break;
  117. #endif
  118.     case DCTSIZE:
  119.       switch (cinfo->dct_method) {
  120. #ifdef DCT_ISLOW_SUPPORTED
  121.       case JDCT_ISLOW:
  122. method_ptr = jpeg_idct_islow;
  123. method = JDCT_ISLOW;
  124. break;
  125. #endif
  126. #ifdef DCT_IFAST_SUPPORTED
  127.       case JDCT_IFAST:
  128. method_ptr = jpeg_idct_ifast;
  129. method = JDCT_IFAST;
  130. break;
  131. #endif
  132. #ifdef DCT_FLOAT_SUPPORTED
  133.       case JDCT_FLOAT:
  134. method_ptr = jpeg_idct_float;
  135. method = JDCT_FLOAT;
  136. break;
  137. #endif
  138.       default:
  139. ERREXIT(cinfo, JERR_NOT_COMPILED);
  140. break;
  141.       }
  142.       break;
  143.     default:
  144.       ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
  145.       break;
  146.     }
  147.     idct->pub.inverse_DCT[ci] = method_ptr;
  148.     /* Create multiplier table from quant table.
  149.      * However, we can skip this if the component is uninteresting
  150.      * or if we already built the table.  Also, if no quant table
  151.      * has yet been saved for the component, we leave the
  152.      * multiplier table all-zero; we'll be reading zeroes from the
  153.      * coefficient controller's buffer anyway.
  154.      */
  155.     if (! compptr->component_needed || idct->cur_method[ci] == method)
  156.       continue;
  157.     qtbl = compptr->quant_table;
  158.     if (qtbl == NULL) /* happens if no data yet for component */
  159.       continue;
  160.     idct->cur_method[ci] = method;
  161.     switch (method) {
  162. #ifdef PROVIDE_ISLOW_TABLES
  163.     case JDCT_ISLOW:
  164.       {
  165. /* For LL&M IDCT method, multipliers are equal to raw quantization
  166.  * coefficients, but are stored as ints to ensure access efficiency.
  167.  */
  168. ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
  169. for (i = 0; i < DCTSIZE2; i++) {
  170.   ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
  171. }
  172.       }
  173.       break;
  174. #endif
  175. #ifdef DCT_IFAST_SUPPORTED
  176.     case JDCT_IFAST:
  177.       {
  178. /* For AA&N IDCT method, multipliers are equal to quantization
  179.  * coefficients scaled by scalefactor[row]*scalefactor[col], where
  180.  *   scalefactor[0] = 1
  181.  *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
  182.  * For integer operation, the multiplier table is to be scaled by
  183.  * IFAST_SCALE_BITS.
  184.  */
  185. IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
  186. #define CONST_BITS 14
  187. static const short aanscales[DCTSIZE2] = {
  188.   /* precomputed values scaled up by 14 bits */
  189.   16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  190.   22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  191.   21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  192.   19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  193.   16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  194.   12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  195.    8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  196.    4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  197. };
  198. SHIFT_TEMPS
  199. for (i = 0; i < DCTSIZE2; i++) {
  200.   ifmtbl[i] = (IFAST_MULT_TYPE)
  201.     DESCALE(MULTIPLY16V16((long) qtbl->quantval[i],
  202.   (long) aanscales[i]),
  203.     CONST_BITS-IFAST_SCALE_BITS);
  204. }
  205.       }
  206.       break;
  207. #endif
  208. #ifdef DCT_FLOAT_SUPPORTED
  209.     case JDCT_FLOAT:
  210.       {
  211. /* For float AA&N IDCT method, multipliers are equal to quantization
  212.  * coefficients scaled by scalefactor[row]*scalefactor[col], where
  213.  *   scalefactor[0] = 1
  214.  *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
  215.  */
  216. FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
  217. int row, col;
  218. static const double aanscalefactor[DCTSIZE] = {
  219.   1.0, 1.387039845, 1.306562965, 1.175875602,
  220.   1.0, 0.785694958, 0.541196100, 0.275899379
  221. };
  222. i = 0;
  223. for (row = 0; row < DCTSIZE; row++) {
  224.   for (col = 0; col < DCTSIZE; col++) {
  225.     fmtbl[i] = (FLOAT_MULT_TYPE)
  226.       ((double) qtbl->quantval[i] *
  227.        aanscalefactor[row] * aanscalefactor[col]);
  228.     i++;
  229.   }
  230. }
  231.       }
  232.       break;
  233. #endif
  234.     default:
  235.       ERREXIT(cinfo, JERR_NOT_COMPILED);
  236.       break;
  237.     }
  238.   }
  239. }
  240. /*
  241.  * Initialize IDCT manager.
  242.  */
  243. GLOBAL(void)
  244. jinit_inverse_dct (j_decompress_ptr cinfo)
  245. {
  246.   my_idct_ptr idct;
  247.   int ci;
  248.   jpeg_component_info *compptr;
  249.   idct = (my_idct_ptr)
  250.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  251. SIZEOF(my_idct_controller));
  252.   cinfo->idct = (struct jpeg_inverse_dct *) idct;
  253.   idct->pub.start_pass = start_pass;
  254.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  255.        ci++, compptr++) {
  256.     /* Allocate and pre-zero a multiplier table for each component */
  257.     compptr->dct_table =
  258.       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  259.   SIZEOF(multiplier_table));
  260.     MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
  261.     /* Mark multiplier table not yet set up for any method */
  262.     idct->cur_method[ci] = -1;
  263.   }
  264. }