开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
JCDCTMGR.c
资源名称：jpeg_Source_lib.rar　[点击查看]
上传用户：qiutianh
上传日期：2022-08-08
资源大小：939k
文件大小：13k
源码类别：

图形图象

开发平台：

Visual C++

JCDCTMGR.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.  * jcdctmgr.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 forward-DCT management logic.
  28.  * This code selects a particular DCT implementation to be used,
  29.  * and it performs related housekeeping chores including coefficient
  30.  * quantization.
  31.  */
  33. #define JPEG_INTERNALS
  34. #include "jinclude.h"
  35. #include "jpeglib.h"
  36. #include "jdct.h" /* Private declarations for DCT subsystem */
  39. /* Private subobject for this module */
  41. typedef struct {
  42.   struct jpeg_forward_dct pub; /* public fields */
  44.   /* Pointer to the DCT routine actually in use */
  45.   forward_DCT_method_ptr do_dct;
  47.   /* The actual post-DCT divisors --- not identical to the quant table
  48.    * entries, because of scaling (especially for an unnormalized DCT).
  49.    * Each table is given in normal array order.
  50.    */
  51.   DCTELEM * divisors[NUM_QUANT_TBLS];
  53. #ifdef DCT_FLOAT_SUPPORTED
  54.   /* Same as above for the floating-point case. */
  55.   float_DCT_method_ptr do_float_dct;
  56.   FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
  57. #endif
  58. } my_fdct_controller;
  60. typedef my_fdct_controller * my_fdct_ptr;
  63. /*
  64.  * Initialize for a processing pass.
  65.  * Verify that all referenced Q-tables are present, and set up
  66.  * the divisor table for each one.
  67.  * In the current implementation, DCT of all components is done during
  68.  * the first pass, even if only some components will be output in the
  69.  * first scan.  Hence all components should be examined here.
  70.  */
  72. METHODDEF(void)
  73. start_pass_fdctmgr (j_compress_ptr cinfo)
  74. {
  75.   my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  76.   int ci, qtblno, i;
  77.   jpeg_component_info *compptr;
  78.   JQUANT_TBL * qtbl;
  79.   DCTELEM * dtbl;
  81.   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
  82.        ci++, compptr++) {
  83.     qtblno = compptr->quant_tbl_no;
  84.     /* Make sure specified quantization table is present */
  85.     if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
  86. cinfo->quant_tbl_ptrs[qtblno] == NULL)
  87.       ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
  88.     qtbl = cinfo->quant_tbl_ptrs[qtblno];
  89.     /* Compute divisors for this quant table */
  90.     /* We may do this more than once for same table, but it's not a big deal */
  91.     switch (cinfo->dct_method) {
  92. #ifdef DCT_ISLOW_SUPPORTED
  93.     case JDCT_ISLOW:
  94.       /* For LL&M IDCT method, divisors are equal to raw quantization
  95.        * coefficients multiplied by 8 (to counteract scaling).
  96.        */
  97.       if (fdct->divisors[qtblno] == NULL) {
  98. fdct->divisors[qtblno] = (DCTELEM *)
  99.   (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  100.       DCTSIZE2 * SIZEOF(DCTELEM));
  101.       }
  102.       dtbl = fdct->divisors[qtblno];
  103.       for (i = 0; i < DCTSIZE2; i++) {
  104. dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
  105.       }
  106.       break;
  107. #endif
  108. #ifdef DCT_IFAST_SUPPORTED
  109.     case JDCT_IFAST:
  110.       {
  111. /* For AA&N IDCT method, divisors are equal to quantization
  112.  * coefficients scaled by scalefactor[row]*scalefactor[col], where
  113.  *   scalefactor[0] = 1
  114.  *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
  115.  * We apply a further scale factor of 8.
  116.  */
  117. #define CONST_BITS 14
  118. static const short aanscales[DCTSIZE2] = {
  119.   /* precomputed values scaled up by 14 bits */
  120.   16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  121.   22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  122.   21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  123.   19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  124.   16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  125.   12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  126.    8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  127.    4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  128. };
  129. SHIFT_TEMPS
  131. if (fdct->divisors[qtblno] == NULL) {
  132.   fdct->divisors[qtblno] = (DCTELEM *)
  133.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  134. DCTSIZE2 * SIZEOF(DCTELEM));
  135. }
  136. dtbl = fdct->divisors[qtblno];
  137. for (i = 0; i < DCTSIZE2; i++) {
  138.   dtbl[i] = (DCTELEM)
  139.     DESCALE(MULTIPLY16V16((long) qtbl->quantval[i],
  140.   (long) aanscales[i]),
  141.     CONST_BITS-3);
  142. }
  143.       }
  144.       break;
  145. #endif
  146. #ifdef DCT_FLOAT_SUPPORTED
  147.     case JDCT_FLOAT:
  148.       {
  149. /* For float AA&N IDCT method, divisors are equal to quantization
  150.  * coefficients scaled by scalefactor[row]*scalefactor[col], where
  151.  *   scalefactor[0] = 1
  152.  *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
  153.  * We apply a further scale factor of 8.
  154.  * What's actually stored is 1/divisor so that the inner loop can
  155.  * use a multiplication rather than a division.
  156.  */
  157. FAST_FLOAT * fdtbl;
  158. int row, col;
  159. static const double aanscalefactor[DCTSIZE] = {
  160.   1.0, 1.387039845, 1.306562965, 1.175875602,
  161.   1.0, 0.785694958, 0.541196100, 0.275899379
  162. };
  164. if (fdct->float_divisors[qtblno] == NULL) {
  165.   fdct->float_divisors[qtblno] = (FAST_FLOAT *)
  166.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  167. DCTSIZE2 * SIZEOF(FAST_FLOAT));
  168. }
  169. fdtbl = fdct->float_divisors[qtblno];
  170. i = 0;
  171. for (row = 0; row < DCTSIZE; row++) {
  172.   for (col = 0; col < DCTSIZE; col++) {
  173.     fdtbl[i] = (FAST_FLOAT)
  174.       (1.0 / (((double) qtbl->quantval[i] *
  175.        aanscalefactor[row] * aanscalefactor[col] * 8.0)));
  176.     i++;
  177.   }
  178. }
  179.       }
  180.       break;
  181. #endif
  182.     default:
  183.       ERREXIT(cinfo, JERR_NOT_COMPILED);
  184.       break;
  185.     }
  186.   }
  187. }
  190. /*
  191.  * Perform forward DCT on one or more blocks of a component.
  192.  *
  193.  * The input samples are taken from the sample_data[] array starting at
  194.  * position start_row/start_col, and moving to the right for any additional
  195.  * blocks. The quantized coefficients are returned in coef_blocks[].
  196.  */
  198. METHODDEF(void)
  199. forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
  200.      JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
  201.      JDIMENSION start_row, JDIMENSION start_col,
  202.      JDIMENSION num_blocks)
  203. /* This version is used for integer DCT implementations. */
  204. {
  205.   /* This routine is heavily used, so it's worth coding it tightly. */
  206.   my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  207.   forward_DCT_method_ptr do_dct = fdct->do_dct;
  208.   DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
  209.   DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */
  210.   JDIMENSION bi;
  212.   sample_data += start_row; /* fold in the vertical offset once */
  214.   for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
  215.     /* Load data into workspace, applying unsigned->signed conversion */
  216.     { register DCTELEM *workspaceptr;
  217.       register JSAMPROW elemptr;
  218.       register int elemr;
  220.       workspaceptr = workspace;
  221.       for (elemr = 0; elemr < DCTSIZE; elemr++) {
  222. elemptr = sample_data[elemr] + start_col;
  223. #if DCTSIZE == 8 /* unroll the inner loop */
  224. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  225. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  226. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  227. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  228. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  229. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  230. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  231. *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  232. #else
  233. { register int elemc;
  234.   for (elemc = DCTSIZE; elemc > 0; elemc--) {
  235.     *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
  236.   }
  237. }
  238. #endif
  239.       }
  240.     }
  242.     /* Perform the DCT */
  243.     (*do_dct) (workspace);
  245.     /* Quantize/descale the coefficients, and store into coef_blocks[] */
  246.     { register DCTELEM temp, qval;
  247.       register int i;
  248.       register JCOEFPTR output_ptr = coef_blocks[bi];
  250.       for (i = 0; i < DCTSIZE2; i++) {
  251. qval = divisors[i];
  252. temp = workspace[i];
  253. /* Divide the coefficient value by qval, ensuring proper rounding.
  254.  * Since C does not specify the direction of rounding for negative
  255.  * quotients, we have to force the dividend positive for portability.
  256.  *
  257.  * In most files, at least half of the output values will be zero
  258.  * (at default quantization settings, more like three-quarters...)
  259.  * so we should ensure that this case is fast.  On many machines,
  260.  * a comparison is enough cheaper than a divide to make a special test
  261.  * a win.  Since both inputs will be nonnegative, we need only test
  262.  * for a < b to discover whether a/b is 0.
  263.  * If your machine's division is fast enough, define FAST_DIVIDE.
  264.  */
  265. #ifdef FAST_DIVIDE
  266. #define DIVIDE_BY(a,b) a /= b
  267. #else
  268. #define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0
  269. #endif
  270. if (temp < 0) {
  271.   temp = -temp;
  272.   temp += qval>>1; /* for rounding */
  273.   DIVIDE_BY(temp, qval);
  274.   temp = -temp;
  275. } else {
  276.   temp += qval>>1; /* for rounding */
  277.   DIVIDE_BY(temp, qval);
  278. }
  279. output_ptr[i] = (JCOEF) temp;
  280.       }
  281.     }
  282.   }
  283. }
  286. #ifdef DCT_FLOAT_SUPPORTED
  288. METHODDEF(void)
  289. forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
  290.    JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
  291.    JDIMENSION start_row, JDIMENSION start_col,
  292.    JDIMENSION num_blocks)
  293. /* This version is used for floating-point DCT implementations. */
  294. {
  295.   /* This routine is heavily used, so it's worth coding it tightly. */
  296.   my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
  297.   float_DCT_method_ptr do_dct = fdct->do_float_dct;
  298.   FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
  299.   FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
  300.   JDIMENSION bi;
  302.   sample_data += start_row; /* fold in the vertical offset once */
  304.   for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
  305.     /* Load data into workspace, applying unsigned->signed conversion */
  306.     { register FAST_FLOAT *workspaceptr;
  307.       register JSAMPROW elemptr;
  308.       register int elemr;
  310.       workspaceptr = workspace;
  311.       for (elemr = 0; elemr < DCTSIZE; elemr++) {
  312. elemptr = sample_data[elemr] + start_col;
  313. #if DCTSIZE == 8 /* unroll the inner loop */
  314. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  315. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  316. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  317. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  318. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  319. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  320. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  321. *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  322. #else
  323. { register int elemc;
  324.   for (elemc = DCTSIZE; elemc > 0; elemc--) {
  325.     *workspaceptr++ = (FAST_FLOAT)
  326.       (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
  327.   }
  328. }
  329. #endif
  330.       }
  331.     }
  333.     /* Perform the DCT */
  334.     (*do_dct) (workspace);
  336.     /* Quantize/descale the coefficients, and store into coef_blocks[] */
  337.     { register FAST_FLOAT temp;
  338.       register int i;
  339.       register JCOEFPTR output_ptr = coef_blocks[bi];
  341.       for (i = 0; i < DCTSIZE2; i++) {
  342. /* Apply the quantization and scaling factor */
  343. temp = workspace[i] * divisors[i];
  344. /* Round to nearest integer.
  345.  * Since C does not specify the direction of rounding for negative
  346.  * quotients, we have to force the dividend positive for portability.
  347.  * The maximum coefficient size is +-16K (for 12-bit data), so this
  348.  * code should work for either 16-bit or 32-bit ints.
  349.  */
  350. output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
  351.       }
  352.     }
  353.   }
  354. }
  356. #endif /* DCT_FLOAT_SUPPORTED */
  359. /*
  360.  * Initialize FDCT manager.
  361.  */
  363. GLOBAL(void)
  364. jinit_forward_dct (j_compress_ptr cinfo)
  365. {
  366.   my_fdct_ptr fdct;
  367.   int i;
  369.   fdct = (my_fdct_ptr)
  370.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  371. SIZEOF(my_fdct_controller));
  372.   cinfo->fdct = (struct jpeg_forward_dct *) fdct;
  373.   fdct->pub.start_pass = start_pass_fdctmgr;
  375.   switch (cinfo->dct_method) {
  376. #ifdef DCT_ISLOW_SUPPORTED
  377.   case JDCT_ISLOW:
  378.     fdct->pub.forward_DCT = forward_DCT;
  379.     fdct->do_dct = jpeg_fdct_islow;
  380.     break;
  381. #endif
  382. #ifdef DCT_IFAST_SUPPORTED
  383.   case JDCT_IFAST:
  384.     fdct->pub.forward_DCT = forward_DCT;
  385.     fdct->do_dct = jpeg_fdct_ifast;
  386.     break;
  387. #endif
  388. #ifdef DCT_FLOAT_SUPPORTED
  389.   case JDCT_FLOAT:
  390.     fdct->pub.forward_DCT = forward_DCT_float;
  391.     fdct->do_float_dct = jpeg_fdct_float;
  392.     break;
  393. #endif
  394.   default:
  395.     ERREXIT(cinfo, JERR_NOT_COMPILED);
  396.     break;
  397.   }
  399.   /* Mark divisor tables unallocated */
  400.   for (i = 0; i < NUM_QUANT_TBLS; i++) {
  401.     fdct->divisors[i] = NULL;
  402. #ifdef DCT_FLOAT_SUPPORTED
  403.     fdct->float_divisors[i] = NULL;
  404. #endif
  405.   }
  406. }