Home | History | Annotate | Download | only in jpeg
      1 /*
      2  * jidctred.c
      3  *
      4  * Copyright (C) 1994-1998, Thomas G. Lane.
      5  * This file is part of the Independent JPEG Group's software.
      6  * For conditions of distribution and use, see the accompanying README file.
      7  *
      8  * This file contains inverse-DCT routines that produce reduced-size output:
      9  * either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block.
     10  *
     11  * The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&M)
     12  * algorithm used in jidctint.c.  We simply replace each 8-to-8 1-D IDCT step
     13  * with an 8-to-4 step that produces the four averages of two adjacent outputs
     14  * (or an 8-to-2 step producing two averages of four outputs, for 2x2 output).
     15  * These steps were derived by computing the corresponding values at the end
     16  * of the normal LL&M code, then simplifying as much as possible.
     17  *
     18  * 1x1 is trivial: just take the DC coefficient divided by 8.
     19  *
     20  * See jidctint.c for additional comments.
     21  */
     22 
     23 #define JPEG_INTERNALS
     24 #include "jinclude.h"
     25 #include "jpeglib.h"
     26 #include "jdct.h"		/* Private declarations for DCT subsystem */
     27 
     28 #ifdef IDCT_SCALING_SUPPORTED
     29 
     30 
     31 /*
     32  * This module is specialized to the case DCTSIZE = 8.
     33  */
     34 
     35 #if DCTSIZE != 8
     36   Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
     37 #endif
     38 
     39 
     40 /* Scaling is the same as in jidctint.c. */
     41 
     42 #if BITS_IN_JSAMPLE == 8
     43 #define CONST_BITS  13
     44 #define PASS1_BITS  2
     45 #else
     46 #define CONST_BITS  13
     47 #define PASS1_BITS  1		/* lose a little precision to avoid overflow */
     48 #endif
     49 
     50 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
     51  * causing a lot of useless floating-point operations at run time.
     52  * To get around this we use the following pre-calculated constants.
     53  * If you change CONST_BITS you may want to add appropriate values.
     54  * (With a reasonable C compiler, you can just rely on the FIX() macro...)
     55  */
     56 
     57 #if CONST_BITS == 13
     58 #define FIX_0_211164243  ((INT32)  1730)	/* FIX(0.211164243) */
     59 #define FIX_0_509795579  ((INT32)  4176)	/* FIX(0.509795579) */
     60 #define FIX_0_601344887  ((INT32)  4926)	/* FIX(0.601344887) */
     61 #define FIX_0_720959822  ((INT32)  5906)	/* FIX(0.720959822) */
     62 #define FIX_0_765366865  ((INT32)  6270)	/* FIX(0.765366865) */
     63 #define FIX_0_850430095  ((INT32)  6967)	/* FIX(0.850430095) */
     64 #define FIX_0_899976223  ((INT32)  7373)	/* FIX(0.899976223) */
     65 #define FIX_1_061594337  ((INT32)  8697)	/* FIX(1.061594337) */
     66 #define FIX_1_272758580  ((INT32)  10426)	/* FIX(1.272758580) */
     67 #define FIX_1_451774981  ((INT32)  11893)	/* FIX(1.451774981) */
     68 #define FIX_1_847759065  ((INT32)  15137)	/* FIX(1.847759065) */
     69 #define FIX_2_172734803  ((INT32)  17799)	/* FIX(2.172734803) */
     70 #define FIX_2_562915447  ((INT32)  20995)	/* FIX(2.562915447) */
     71 #define FIX_3_624509785  ((INT32)  29692)	/* FIX(3.624509785) */
     72 #else
     73 #define FIX_0_211164243  FIX(0.211164243)
     74 #define FIX_0_509795579  FIX(0.509795579)
     75 #define FIX_0_601344887  FIX(0.601344887)
     76 #define FIX_0_720959822  FIX(0.720959822)
     77 #define FIX_0_765366865  FIX(0.765366865)
     78 #define FIX_0_850430095  FIX(0.850430095)
     79 #define FIX_0_899976223  FIX(0.899976223)
     80 #define FIX_1_061594337  FIX(1.061594337)
     81 #define FIX_1_272758580  FIX(1.272758580)
     82 #define FIX_1_451774981  FIX(1.451774981)
     83 #define FIX_1_847759065  FIX(1.847759065)
     84 #define FIX_2_172734803  FIX(2.172734803)
     85 #define FIX_2_562915447  FIX(2.562915447)
     86 #define FIX_3_624509785  FIX(3.624509785)
     87 #endif
     88 
     89 
     90 /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
     91  * For 8-bit samples with the recommended scaling, all the variable
     92  * and constant values involved are no more than 16 bits wide, so a
     93  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
     94  * For 12-bit samples, a full 32-bit multiplication will be needed.
     95  */
     96 
     97 #if BITS_IN_JSAMPLE == 8
     98 #define MULTIPLY(var,const)  MULTIPLY16C16(var,const)
     99 #else
    100 #define MULTIPLY(var,const)  ((var) * (const))
    101 #endif
    102 
    103 
    104 /* Dequantize a coefficient by multiplying it by the multiplier-table
    105  * entry; produce an int result.  In this module, both inputs and result
    106  * are 16 bits or less, so either int or short multiply will work.
    107  */
    108 
    109 #define DEQUANTIZE(coef,quantval)  (((ISLOW_MULT_TYPE) (coef)) * (quantval))
    110 
    111 
    112 /*
    113  * Perform dequantization and inverse DCT on one block of coefficients,
    114  * producing a reduced-size 4x4 output block.
    115  */
    116 
    117 GLOBAL(void)
    118 jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    119 	       JCOEFPTR coef_block,
    120 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    121 {
    122   INT32 tmp0, tmp2, tmp10, tmp12;
    123   INT32 z1, z2, z3, z4;
    124   JCOEFPTR inptr;
    125   ISLOW_MULT_TYPE * quantptr;
    126   int * wsptr;
    127   JSAMPROW outptr;
    128   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    129   int ctr;
    130   int workspace[DCTSIZE*4];	/* buffers data between passes */
    131   SHIFT_TEMPS
    132 
    133   /* Pass 1: process columns from input, store into work array. */
    134 
    135   inptr = coef_block;
    136   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    137   wsptr = workspace;
    138   for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
    139     /* Don't bother to process column 4, because second pass won't use it */
    140     if (ctr == DCTSIZE-4)
    141       continue;
    142     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
    143 	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*5] == 0 &&
    144 	inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) {
    145       /* AC terms all zero; we need not examine term 4 for 4x4 output */
    146       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
    147 
    148       wsptr[DCTSIZE*0] = dcval;
    149       wsptr[DCTSIZE*1] = dcval;
    150       wsptr[DCTSIZE*2] = dcval;
    151       wsptr[DCTSIZE*3] = dcval;
    152 
    153       continue;
    154     }
    155 
    156     /* Even part */
    157 
    158     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    159     tmp0 <<= (CONST_BITS+1);
    160 
    161     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    162     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    163 
    164     tmp2 = MULTIPLY(z2, FIX_1_847759065) + MULTIPLY(z3, - FIX_0_765366865);
    165 
    166     tmp10 = tmp0 + tmp2;
    167     tmp12 = tmp0 - tmp2;
    168 
    169     /* Odd part */
    170 
    171     z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    172     z2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    173     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    174     z4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    175 
    176     tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */
    177 	 + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */
    178 	 + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */
    179 	 + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */
    180 
    181     tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */
    182 	 + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */
    183 	 + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */
    184 	 + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */
    185 
    186     /* Final output stage */
    187 
    188     wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp2, CONST_BITS-PASS1_BITS+1);
    189     wsptr[DCTSIZE*3] = (int) DESCALE(tmp10 - tmp2, CONST_BITS-PASS1_BITS+1);
    190     wsptr[DCTSIZE*1] = (int) DESCALE(tmp12 + tmp0, CONST_BITS-PASS1_BITS+1);
    191     wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 - tmp0, CONST_BITS-PASS1_BITS+1);
    192   }
    193 
    194   /* Pass 2: process 4 rows from work array, store into output array. */
    195 
    196   wsptr = workspace;
    197   for (ctr = 0; ctr < 4; ctr++) {
    198     outptr = output_buf[ctr] + output_col;
    199     /* It's not clear whether a zero row test is worthwhile here ... */
    200 
    201 #ifndef NO_ZERO_ROW_TEST
    202     if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 &&
    203 	wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
    204       /* AC terms all zero */
    205       JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
    206 				  & RANGE_MASK];
    207 
    208       outptr[0] = dcval;
    209       outptr[1] = dcval;
    210       outptr[2] = dcval;
    211       outptr[3] = dcval;
    212 
    213       wsptr += DCTSIZE;		/* advance pointer to next row */
    214       continue;
    215     }
    216 #endif
    217 
    218     /* Even part */
    219 
    220     tmp0 = ((INT32) wsptr[0]) << (CONST_BITS+1);
    221 
    222     tmp2 = MULTIPLY((INT32) wsptr[2], FIX_1_847759065)
    223 	 + MULTIPLY((INT32) wsptr[6], - FIX_0_765366865);
    224 
    225     tmp10 = tmp0 + tmp2;
    226     tmp12 = tmp0 - tmp2;
    227 
    228     /* Odd part */
    229 
    230     z1 = (INT32) wsptr[7];
    231     z2 = (INT32) wsptr[5];
    232     z3 = (INT32) wsptr[3];
    233     z4 = (INT32) wsptr[1];
    234 
    235     tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */
    236 	 + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */
    237 	 + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */
    238 	 + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */
    239 
    240     tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */
    241 	 + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */
    242 	 + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */
    243 	 + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */
    244 
    245     /* Final output stage */
    246 
    247     outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp2,
    248 					  CONST_BITS+PASS1_BITS+3+1)
    249 			    & RANGE_MASK];
    250     outptr[3] = range_limit[(int) DESCALE(tmp10 - tmp2,
    251 					  CONST_BITS+PASS1_BITS+3+1)
    252 			    & RANGE_MASK];
    253     outptr[1] = range_limit[(int) DESCALE(tmp12 + tmp0,
    254 					  CONST_BITS+PASS1_BITS+3+1)
    255 			    & RANGE_MASK];
    256     outptr[2] = range_limit[(int) DESCALE(tmp12 - tmp0,
    257 					  CONST_BITS+PASS1_BITS+3+1)
    258 			    & RANGE_MASK];
    259 
    260     wsptr += DCTSIZE;		/* advance pointer to next row */
    261   }
    262 }
    263 
    264 
    265 /*
    266  * Perform dequantization and inverse DCT on one block of coefficients,
    267  * producing a reduced-size 2x2 output block.
    268  */
    269 
    270 GLOBAL(void)
    271 jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    272 	       JCOEFPTR coef_block,
    273 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    274 {
    275   INT32 tmp0, tmp10, z1;
    276   JCOEFPTR inptr;
    277   ISLOW_MULT_TYPE * quantptr;
    278   int * wsptr;
    279   JSAMPROW outptr;
    280   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    281   int ctr;
    282   int workspace[DCTSIZE*2];	/* buffers data between passes */
    283   SHIFT_TEMPS
    284 
    285   /* Pass 1: process columns from input, store into work array. */
    286 
    287   inptr = coef_block;
    288   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    289   wsptr = workspace;
    290   for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
    291     /* Don't bother to process columns 2,4,6 */
    292     if (ctr == DCTSIZE-2 || ctr == DCTSIZE-4 || ctr == DCTSIZE-6)
    293       continue;
    294     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*3] == 0 &&
    295 	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*7] == 0) {
    296       /* AC terms all zero; we need not examine terms 2,4,6 for 2x2 output */
    297       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
    298 
    299       wsptr[DCTSIZE*0] = dcval;
    300       wsptr[DCTSIZE*1] = dcval;
    301 
    302       continue;
    303     }
    304 
    305     /* Even part */
    306 
    307     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    308     tmp10 = z1 << (CONST_BITS+2);
    309 
    310     /* Odd part */
    311 
    312     z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    313     tmp0 = MULTIPLY(z1, - FIX_0_720959822); /* sqrt(2) * (c7-c5+c3-c1) */
    314     z1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    315     tmp0 += MULTIPLY(z1, FIX_0_850430095); /* sqrt(2) * (-c1+c3+c5+c7) */
    316     z1 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    317     tmp0 += MULTIPLY(z1, - FIX_1_272758580); /* sqrt(2) * (-c1+c3-c5-c7) */
    318     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    319     tmp0 += MULTIPLY(z1, FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */
    320 
    321     /* Final output stage */
    322 
    323     wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp0, CONST_BITS-PASS1_BITS+2);
    324     wsptr[DCTSIZE*1] = (int) DESCALE(tmp10 - tmp0, CONST_BITS-PASS1_BITS+2);
    325   }
    326 
    327   /* Pass 2: process 2 rows from work array, store into output array. */
    328 
    329   wsptr = workspace;
    330   for (ctr = 0; ctr < 2; ctr++) {
    331     outptr = output_buf[ctr] + output_col;
    332     /* It's not clear whether a zero row test is worthwhile here ... */
    333 
    334 #ifndef NO_ZERO_ROW_TEST
    335     if (wsptr[1] == 0 && wsptr[3] == 0 && wsptr[5] == 0 && wsptr[7] == 0) {
    336       /* AC terms all zero */
    337       JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
    338 				  & RANGE_MASK];
    339 
    340       outptr[0] = dcval;
    341       outptr[1] = dcval;
    342 
    343       wsptr += DCTSIZE;		/* advance pointer to next row */
    344       continue;
    345     }
    346 #endif
    347 
    348     /* Even part */
    349 
    350     tmp10 = ((INT32) wsptr[0]) << (CONST_BITS+2);
    351 
    352     /* Odd part */
    353 
    354     tmp0 = MULTIPLY((INT32) wsptr[7], - FIX_0_720959822) /* sqrt(2) * (c7-c5+c3-c1) */
    355 	 + MULTIPLY((INT32) wsptr[5], FIX_0_850430095) /* sqrt(2) * (-c1+c3+c5+c7) */
    356 	 + MULTIPLY((INT32) wsptr[3], - FIX_1_272758580) /* sqrt(2) * (-c1+c3-c5-c7) */
    357 	 + MULTIPLY((INT32) wsptr[1], FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */
    358 
    359     /* Final output stage */
    360 
    361     outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp0,
    362 					  CONST_BITS+PASS1_BITS+3+2)
    363 			    & RANGE_MASK];
    364     outptr[1] = range_limit[(int) DESCALE(tmp10 - tmp0,
    365 					  CONST_BITS+PASS1_BITS+3+2)
    366 			    & RANGE_MASK];
    367 
    368     wsptr += DCTSIZE;		/* advance pointer to next row */
    369   }
    370 }
    371 
    372 
    373 /*
    374  * Perform dequantization and inverse DCT on one block of coefficients,
    375  * producing a reduced-size 1x1 output block.
    376  */
    377 
    378 GLOBAL(void)
    379 jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    380 	       JCOEFPTR coef_block,
    381 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    382 {
    383   int dcval;
    384   ISLOW_MULT_TYPE * quantptr;
    385   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    386   SHIFT_TEMPS
    387 
    388   /* We hardly need an inverse DCT routine for this: just take the
    389    * average pixel value, which is one-eighth of the DC coefficient.
    390    */
    391   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    392   dcval = DEQUANTIZE(coef_block[0], quantptr[0]);
    393   dcval = (int) DESCALE((INT32) dcval, 3);
    394 
    395   output_buf[0][output_col] = range_limit[dcval & RANGE_MASK];
    396 }
    397 
    398 #endif /* IDCT_SCALING_SUPPORTED */
    399