Doxygen Source Code Documentation
jcdctmgr.c File Reference
#include "jinclude.h"#include "jpeglib.h"#include "jdct.h"Go to the source code of this file.
Data Structures | |
| struct | my_fdct_controller |
Defines | |
| #define | JPEG_INTERNALS |
| #define | CONST_BITS 14 |
| #define | DIVIDE_BY(a, b) if (a >= b) a /= b; else a = 0 |
Typedefs | |
| typedef my_fdct_controller * | my_fdct_ptr |
Functions | |
| start_pass_fdctmgr (j_compress_ptr cinfo) | |
| forward_DCT (j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks) | |
| forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks) | |
| jinit_forward_dct (j_compress_ptr cinfo) | |
Define Documentation
|
|
|
|
|
|
|
|
Definition at line 14 of file jcdctmgr.c. |
Typedef Documentation
|
|
Definition at line 41 of file jcdctmgr.c. |
Function Documentation
|
||||||||||||||||||||||||||||||||
|
Definition at line 180 of file jcdctmgr.c. References CENTERJSAMPLE, compptr, my_fdct_controller::divisors, my_fdct_controller::do_dct, jpeg_compress_struct::fdct, GETJSAMPLE, i, JBLOCKROW, JCOEFPTR, JDIMENSION, JSAMPARRAY, JSAMPROW, and jpeg_component_info::quant_tbl_no. Referenced by jinit_forward_dct().
00185 {
00186 /* This routine is heavily used, so it's worth coding it tightly. */
00187 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
00188 forward_DCT_method_ptr do_dct = fdct->do_dct;
00189 DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
00190 DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */
00191 JDIMENSION bi;
00192
00193 sample_data += start_row; /* fold in the vertical offset once */
00194
00195 for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
00196 /* Load data into workspace, applying unsigned->signed conversion */
00197 { register DCTELEM *workspaceptr;
00198 register JSAMPROW elemptr;
00199 register int elemr;
00200
00201 workspaceptr = workspace;
00202 for (elemr = 0; elemr < DCTSIZE; elemr++) {
00203 elemptr = sample_data[elemr] + start_col;
00204 #if DCTSIZE == 8 /* unroll the inner loop */
00205 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00206 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00207 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00208 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00209 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00210 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00211 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00212 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00213 #else
00214 { register int elemc;
00215 for (elemc = DCTSIZE; elemc > 0; elemc--) {
00216 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
00217 }
00218 }
00219 #endif
00220 }
00221 }
00222
00223 /* Perform the DCT */
00224 (*do_dct) (workspace);
00225
00226 /* Quantize/descale the coefficients, and store into coef_blocks[] */
00227 { register DCTELEM temp, qval;
00228 register int i;
00229 register JCOEFPTR output_ptr = coef_blocks[bi];
00230
00231 for (i = 0; i < DCTSIZE2; i++) {
00232 qval = divisors[i];
00233 temp = workspace[i];
00234 /* Divide the coefficient value by qval, ensuring proper rounding.
00235 * Since C does not specify the direction of rounding for negative
00236 * quotients, we have to force the dividend positive for portability.
00237 *
00238 * In most files, at least half of the output values will be zero
00239 * (at default quantization settings, more like three-quarters...)
00240 * so we should ensure that this case is fast. On many machines,
00241 * a comparison is enough cheaper than a divide to make a special test
00242 * a win. Since both inputs will be nonnegative, we need only test
00243 * for a < b to discover whether a/b is 0.
00244 * If your machine's division is fast enough, define FAST_DIVIDE.
00245 */
00246 #ifdef FAST_DIVIDE
00247 #define DIVIDE_BY(a,b) a /= b
00248 #else
00249 #define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0
00250 #endif
00251 if (temp < 0) {
00252 temp = -temp;
00253 temp += qval>>1; /* for rounding */
00254 DIVIDE_BY(temp, qval);
00255 temp = -temp;
00256 } else {
00257 temp += qval>>1; /* for rounding */
00258 DIVIDE_BY(temp, qval);
00259 }
00260 output_ptr[i] = (JCOEF) temp;
00261 }
00262 }
00263 }
00264 }
|
|
||||||||||||||||||||||||||||||||
|
Definition at line 270 of file jcdctmgr.c. References CENTERJSAMPLE, compptr, my_fdct_controller::do_float_dct, jpeg_compress_struct::fdct, my_fdct_controller::float_divisors, GETJSAMPLE, i, JBLOCKROW, JCOEFPTR, JDIMENSION, JSAMPARRAY, JSAMPROW, and jpeg_component_info::quant_tbl_no. Referenced by jinit_forward_dct().
00275 {
00276 /* This routine is heavily used, so it's worth coding it tightly. */
00277 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
00278 float_DCT_method_ptr do_dct = fdct->do_float_dct;
00279 FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
00280 FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
00281 JDIMENSION bi;
00282
00283 sample_data += start_row; /* fold in the vertical offset once */
00284
00285 for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
00286 /* Load data into workspace, applying unsigned->signed conversion */
00287 { register FAST_FLOAT *workspaceptr;
00288 register JSAMPROW elemptr;
00289 register int elemr;
00290
00291 workspaceptr = workspace;
00292 for (elemr = 0; elemr < DCTSIZE; elemr++) {
00293 elemptr = sample_data[elemr] + start_col;
00294 #if DCTSIZE == 8 /* unroll the inner loop */
00295 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00296 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00297 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00298 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00299 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00300 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00301 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00302 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00303 #else
00304 { register int elemc;
00305 for (elemc = DCTSIZE; elemc > 0; elemc--) {
00306 *workspaceptr++ = (FAST_FLOAT)
00307 (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
00308 }
00309 }
00310 #endif
00311 }
00312 }
00313
00314 /* Perform the DCT */
00315 (*do_dct) (workspace);
00316
00317 /* Quantize/descale the coefficients, and store into coef_blocks[] */
00318 { register FAST_FLOAT temp;
00319 register int i;
00320 register JCOEFPTR output_ptr = coef_blocks[bi];
00321
00322 for (i = 0; i < DCTSIZE2; i++) {
00323 /* Apply the quantization and scaling factor */
00324 temp = workspace[i] * divisors[i];
00325 /* Round to nearest integer.
00326 * Since C does not specify the direction of rounding for negative
00327 * quotients, we have to force the dividend positive for portability.
00328 * The maximum coefficient size is +-16K (for 12-bit data), so this
00329 * code should work for either 16-bit or 32-bit ints.
00330 */
00331 output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
00332 }
00333 }
00334 }
00335 }
|
|
|
Definition at line 345 of file jcdctmgr.c. References ERREXIT, forward_DCT(), forward_DCT_float(), i, JDCT_FLOAT, JDCT_IFAST, JDCT_ISLOW, jpeg_fdct_float(), jpeg_fdct_ifast(), jpeg_fdct_islow(), JPOOL_IMAGE, NUM_QUANT_TBLS, SIZEOF, and start_pass_fdctmgr(). Referenced by jinit_compress_master().
00346 {
00347 my_fdct_ptr fdct;
00348 int i;
00349
00350 fdct = (my_fdct_ptr)
00351 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
00352 SIZEOF(my_fdct_controller));
00353 cinfo->fdct = (struct jpeg_forward_dct *) fdct;
00354 fdct->pub.start_pass = start_pass_fdctmgr;
00355
00356 switch (cinfo->dct_method) {
00357 #ifdef DCT_ISLOW_SUPPORTED
00358 case JDCT_ISLOW:
00359 fdct->pub.forward_DCT = forward_DCT;
00360 fdct->do_dct = jpeg_fdct_islow;
00361 break;
00362 #endif
00363 #ifdef DCT_IFAST_SUPPORTED
00364 case JDCT_IFAST:
00365 fdct->pub.forward_DCT = forward_DCT;
00366 fdct->do_dct = jpeg_fdct_ifast;
00367 break;
00368 #endif
00369 #ifdef DCT_FLOAT_SUPPORTED
00370 case JDCT_FLOAT:
00371 fdct->pub.forward_DCT = forward_DCT_float;
00372 fdct->do_float_dct = jpeg_fdct_float;
00373 break;
00374 #endif
00375 default:
00376 ERREXIT(cinfo, JERR_NOT_COMPILED);
00377 break;
00378 }
00379
00380 /* Mark divisor tables unallocated */
00381 for (i = 0; i < NUM_QUANT_TBLS; i++) {
00382 fdct->divisors[i] = NULL;
00383 #ifdef DCT_FLOAT_SUPPORTED
00384 fdct->float_divisors[i] = NULL;
00385 #endif
00386 }
00387 }
|
|
|
Definition at line 54 of file jcdctmgr.c. References jpeg_compress_struct::comp_info, compptr, jpeg_compress_struct::dct_method, DESCALE, my_fdct_controller::divisors, ERREXIT, ERREXIT1, jpeg_compress_struct::fdct, my_fdct_controller::float_divisors, i, INT16, INT32, JDCT_FLOAT, JDCT_IFAST, JDCT_ISLOW, JPOOL_IMAGE, MULTIPLY16V16, jpeg_compress_struct::num_components, NUM_QUANT_TBLS, jpeg_component_info::quant_tbl_no, jpeg_compress_struct::quant_tbl_ptrs, JQUANT_TBL::quantval, and SIZEOF. Referenced by jinit_forward_dct().
00055 {
00056 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
00057 int ci, qtblno, i;
00058 jpeg_component_info *compptr;
00059 JQUANT_TBL * qtbl;
00060 DCTELEM * dtbl;
00061
00062 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
00063 ci++, compptr++) {
00064 qtblno = compptr->quant_tbl_no;
00065 /* Make sure specified quantization table is present */
00066 if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
00067 cinfo->quant_tbl_ptrs[qtblno] == NULL)
00068 ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
00069 qtbl = cinfo->quant_tbl_ptrs[qtblno];
00070 /* Compute divisors for this quant table */
00071 /* We may do this more than once for same table, but it's not a big deal */
00072 switch (cinfo->dct_method) {
00073 #ifdef DCT_ISLOW_SUPPORTED
00074 case JDCT_ISLOW:
00075 /* For LL&M IDCT method, divisors are equal to raw quantization
00076 * coefficients multiplied by 8 (to counteract scaling).
00077 */
00078 if (fdct->divisors[qtblno] == NULL) {
00079 fdct->divisors[qtblno] = (DCTELEM *)
00080 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
00081 DCTSIZE2 * SIZEOF(DCTELEM));
00082 }
00083 dtbl = fdct->divisors[qtblno];
00084 for (i = 0; i < DCTSIZE2; i++) {
00085 dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
00086 }
00087 break;
00088 #endif
00089 #ifdef DCT_IFAST_SUPPORTED
00090 case JDCT_IFAST:
00091 {
00092 /* For AA&N IDCT method, divisors are equal to quantization
00093 * coefficients scaled by scalefactor[row]*scalefactor[col], where
00094 * scalefactor[0] = 1
00095 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
00096 * We apply a further scale factor of 8.
00097 */
00098 #define CONST_BITS 14
00099 static const INT16 aanscales[DCTSIZE2] = {
00100 /* precomputed values scaled up by 14 bits */
00101 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
00102 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
00103 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
00104 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
00105 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
00106 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
00107 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
00108 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
00109 };
00110 SHIFT_TEMPS
00111
00112 if (fdct->divisors[qtblno] == NULL) {
00113 fdct->divisors[qtblno] = (DCTELEM *)
00114 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
00115 DCTSIZE2 * SIZEOF(DCTELEM));
00116 }
00117 dtbl = fdct->divisors[qtblno];
00118 for (i = 0; i < DCTSIZE2; i++) {
00119 dtbl[i] = (DCTELEM)
00120 DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
00121 (INT32) aanscales[i]),
00122 CONST_BITS-3);
00123 }
00124 }
00125 break;
00126 #endif
00127 #ifdef DCT_FLOAT_SUPPORTED
00128 case JDCT_FLOAT:
00129 {
00130 /* For float AA&N IDCT method, divisors are equal to quantization
00131 * coefficients scaled by scalefactor[row]*scalefactor[col], where
00132 * scalefactor[0] = 1
00133 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
00134 * We apply a further scale factor of 8.
00135 * What's actually stored is 1/divisor so that the inner loop can
00136 * use a multiplication rather than a division.
00137 */
00138 FAST_FLOAT * fdtbl;
00139 int row, col;
00140 static const double aanscalefactor[DCTSIZE] = {
00141 1.0, 1.387039845, 1.306562965, 1.175875602,
00142 1.0, 0.785694958, 0.541196100, 0.275899379
00143 };
00144
00145 if (fdct->float_divisors[qtblno] == NULL) {
00146 fdct->float_divisors[qtblno] = (FAST_FLOAT *)
00147 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
00148 DCTSIZE2 * SIZEOF(FAST_FLOAT));
00149 }
00150 fdtbl = fdct->float_divisors[qtblno];
00151 i = 0;
00152 for (row = 0; row < DCTSIZE; row++) {
00153 for (col = 0; col < DCTSIZE; col++) {
00154 fdtbl[i] = (FAST_FLOAT)
00155 (1.0 / (((double) qtbl->quantval[i] *
00156 aanscalefactor[row] * aanscalefactor[col] * 8.0)));
00157 i++;
00158 }
00159 }
00160 }
00161 break;
00162 #endif
00163 default:
00164 ERREXIT(cinfo, JERR_NOT_COMPILED);
00165 break;
00166 }
00167 }
00168 }
|
