The Ecere SDK - sdk/blob - deps/jpeg-9a/jidctint.c

   1 /*
   2  * jidctint.c
   3  *
   4  * Copyright (C) 1991-1998, Thomas G. Lane.
   5  * Modification developed 2002-2013 by Guido Vollbeding.
   6  * This file is part of the Independent JPEG Group's software.
   7  * For conditions of distribution and use, see the accompanying README file.
   8  *
   9  * This file contains a slow-but-accurate integer implementation of the
  10  * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
  11  * must also perform dequantization of the input coefficients.
  12  *
  13  * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
  14  * on each row (or vice versa, but it's more convenient to emit a row at
  15  * a time).  Direct algorithms are also available, but they are much more
  16  * complex and seem not to be any faster when reduced to code.
  17  *
  18  * This implementation is based on an algorithm described in
  19  *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
  20  *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
  21  *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
  22  * The primary algorithm described there uses 11 multiplies and 29 adds.
  23  * We use their alternate method with 12 multiplies and 32 adds.
  24  * The advantage of this method is that no data path contains more than one
  25  * multiplication; this allows a very simple and accurate implementation in
  26  * scaled fixed-point arithmetic, with a minimal number of shifts.
  27  *
  28  * We also provide IDCT routines with various output sample block sizes for
  29  * direct resolution reduction or enlargement and for direct resolving the
  30  * common 2x1 and 1x2 subsampling cases without additional resampling: NxN
  31  * (N=1...16), 2NxN, and Nx2N (N=1...8) pixels for one 8x8 input DCT block.
  32  *
  33  * For N<8 we simply take the corresponding low-frequency coefficients of
  34  * the 8x8 input DCT block and apply an NxN point IDCT on the sub-block
  35  * to yield the downscaled outputs.
  36  * This can be seen as direct low-pass downsampling from the DCT domain
  37  * point of view rather than the usual spatial domain point of view,
  38  * yielding significant computational savings and results at least
  39  * as good as common bilinear (averaging) spatial downsampling.
  40  *
  41  * For N>8 we apply a partial NxN IDCT on the 8 input coefficients as
  42  * lower frequencies and higher frequencies assumed to be zero.
  43  * It turns out that the computational effort is similar to the 8x8 IDCT
  44  * regarding the output size.
  45  * Furthermore, the scaling and descaling is the same for all IDCT sizes.
  46  *
  47  * CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
  48  * since there would be too many additional constants to pre-calculate.
  49  */
  50
  51 #define JPEG_INTERNALS
  52 #include "jinclude.h"
  53 #include "jpeglib.h"
  54 #include "jdct.h"               /* Private declarations for DCT subsystem */
  55
  56 #ifdef DCT_ISLOW_SUPPORTED
  57
  58
  59 /*
  60  * This module is specialized to the case DCTSIZE = 8.
  61  */
  62
  63 #if DCTSIZE != 8
  64   Sorry, this code only copes with 8x8 DCT blocks. /* deliberate syntax err */
  65 #endif
  66
  67
  68 /*
  69  * The poop on this scaling stuff is as follows:
  70  *
  71  * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
  72  * larger than the true IDCT outputs.  The final outputs are therefore
  73  * a factor of N larger than desired; since N=8 this can be cured by
  74  * a simple right shift at the end of the algorithm.  The advantage of
  75  * this arrangement is that we save two multiplications per 1-D IDCT,
  76  * because the y0 and y4 inputs need not be divided by sqrt(N).
  77  *
  78  * We have to do addition and subtraction of the integer inputs, which
  79  * is no problem, and multiplication by fractional constants, which is
  80  * a problem to do in integer arithmetic.  We multiply all the constants
  81  * by CONST_SCALE and convert them to integer constants (thus retaining
  82  * CONST_BITS bits of precision in the constants).  After doing a
  83  * multiplication we have to divide the product by CONST_SCALE, with proper
  84  * rounding, to produce the correct output.  This division can be done
  85  * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
  86  * as long as possible so that partial sums can be added together with
  87  * full fractional precision.
  88  *
  89  * The outputs of the first pass are scaled up by PASS1_BITS bits so that
  90  * they are represented to better-than-integral precision.  These outputs
  91  * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
  92  * with the recommended scaling.  (To scale up 12-bit sample data further, an
  93  * intermediate INT32 array would be needed.)
  94  *
  95  * To avoid overflow of the 32-bit intermediate results in pass 2, we must
  96  * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
  97  * shows that the values given below are the most effective.
  98  */
  99
 100 #if BITS_IN_JSAMPLE == 8
 101 #define CONST_BITS  13
 102 #define PASS1_BITS  2
 103 #else
 104 #define CONST_BITS  13
 105 #define PASS1_BITS  1           /* lose a little precision to avoid overflow */
 106 #endif
 107
 108 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
 109  * causing a lot of useless floating-point operations at run time.
 110  * To get around this we use the following pre-calculated constants.
 111  * If you change CONST_BITS you may want to add appropriate values.
 112  * (With a reasonable C compiler, you can just rely on the FIX() macro...)
 113  */
 114
 115 #if CONST_BITS == 13
 116 #define FIX_0_298631336  ((INT32)  2446)        /* FIX(0.298631336) */
 117 #define FIX_0_390180644  ((INT32)  3196)        /* FIX(0.390180644) */
 118 #define FIX_0_541196100  ((INT32)  4433)        /* FIX(0.541196100) */
 119 #define FIX_0_765366865  ((INT32)  6270)        /* FIX(0.765366865) */
 120 #define FIX_0_899976223  ((INT32)  7373)        /* FIX(0.899976223) */
 121 #define FIX_1_175875602  ((INT32)  9633)        /* FIX(1.175875602) */
 122 #define FIX_1_501321110  ((INT32)  12299)       /* FIX(1.501321110) */
 123 #define FIX_1_847759065  ((INT32)  15137)       /* FIX(1.847759065) */
 124 #define FIX_1_961570560  ((INT32)  16069)       /* FIX(1.961570560) */
 125 #define FIX_2_053119869  ((INT32)  16819)       /* FIX(2.053119869) */
 126 #define FIX_2_562915447  ((INT32)  20995)       /* FIX(2.562915447) */
 127 #define FIX_3_072711026  ((INT32)  25172)       /* FIX(3.072711026) */
 128 #else
 129 #define FIX_0_298631336  FIX(0.298631336)
 130 #define FIX_0_390180644  FIX(0.390180644)
 131 #define FIX_0_541196100  FIX(0.541196100)
 132 #define FIX_0_765366865  FIX(0.765366865)
 133 #define FIX_0_899976223  FIX(0.899976223)
 134 #define FIX_1_175875602  FIX(1.175875602)
 135 #define FIX_1_501321110  FIX(1.501321110)
 136 #define FIX_1_847759065  FIX(1.847759065)
 137 #define FIX_1_961570560  FIX(1.961570560)
 138 #define FIX_2_053119869  FIX(2.053119869)
 139 #define FIX_2_562915447  FIX(2.562915447)
 140 #define FIX_3_072711026  FIX(3.072711026)
 141 #endif
 142
 143
 144 /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
 145  * For 8-bit samples with the recommended scaling, all the variable
 146  * and constant values involved are no more than 16 bits wide, so a
 147  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
 148  * For 12-bit samples, a full 32-bit multiplication will be needed.
 149  */
 150
 151 #if BITS_IN_JSAMPLE == 8
 152 #define MULTIPLY(var,const)  MULTIPLY16C16(var,const)
 153 #else
 154 #define MULTIPLY(var,const)  ((var) * (const))
 155 #endif
 156
 157
 158 /* Dequantize a coefficient by multiplying it by the multiplier-table
 159  * entry; produce an int result.  In this module, both inputs and result
 160  * are 16 bits or less, so either int or short multiply will work.
 161  */
 162
 163 #define DEQUANTIZE(coef,quantval)  (((ISLOW_MULT_TYPE) (coef)) * (quantval))
 164
 165
 166 /*
 167  * Perform dequantization and inverse DCT on one block of coefficients.
 168  *
 169  * cK represents sqrt(2) * cos(K*pi/16).
 170  */
 171
 172 GLOBAL(void)
 173 jpeg_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 174                  JCOEFPTR coef_block,
 175                  JSAMPARRAY output_buf, JDIMENSION output_col)
 176 {
 177   INT32 tmp0, tmp1, tmp2, tmp3;
 178   INT32 tmp10, tmp11, tmp12, tmp13;
 179   INT32 z1, z2, z3;
 180   JCOEFPTR inptr;
 181   ISLOW_MULT_TYPE * quantptr;
 182   int * wsptr;
 183   JSAMPROW outptr;
 184   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
 185   int ctr;
 186   int workspace[DCTSIZE2];      /* buffers data between passes */
 187   SHIFT_TEMPS
 188
 189   /* Pass 1: process columns from input, store into work array.
 190    * Note results are scaled up by sqrt(8) compared to a true IDCT;
 191    * furthermore, we scale the results by 2**PASS1_BITS.
 192    */
 193
 194   inptr = coef_block;
 195   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
 196   wsptr = workspace;
 197   for (ctr = DCTSIZE; ctr > 0; ctr--) {
 198     /* Due to quantization, we will usually find that many of the input
 199      * coefficients are zero, especially the AC terms.  We can exploit this
 200      * by short-circuiting the IDCT calculation for any column in which all
 201      * the AC terms are zero.  In that case each output is equal to the
 202      * DC coefficient (with scale factor as needed).
 203      * With typical images and quantization tables, half or more of the
 204      * column DCT calculations can be simplified this way.
 205      */
 206
 207     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
 208         inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
 209         inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
 210         inptr[DCTSIZE*7] == 0) {
 211       /* AC terms all zero */
 212       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
 213
 214       wsptr[DCTSIZE*0] = dcval;
 215       wsptr[DCTSIZE*1] = dcval;
 216       wsptr[DCTSIZE*2] = dcval;
 217       wsptr[DCTSIZE*3] = dcval;
 218       wsptr[DCTSIZE*4] = dcval;
 219       wsptr[DCTSIZE*5] = dcval;
 220       wsptr[DCTSIZE*6] = dcval;
 221       wsptr[DCTSIZE*7] = dcval;
 222
 223       inptr++;                  /* advance pointers to next column */
 224       quantptr++;
 225       wsptr++;
 226       continue;
 227     }
 228
 229     /* Even part: reverse the even part of the forward DCT.
 230      * The rotator is c(-6).
 231      */
 232
 233     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
 234     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
 235
 236     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
 237     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
 238     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
 239
 240     z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
 241     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
 242     z2 <<= CONST_BITS;
 243     z3 <<= CONST_BITS;
 244     /* Add fudge factor here for final descale. */
 245     z2 += ONE << (CONST_BITS-PASS1_BITS-1);
 246
 247     tmp0 = z2 + z3;
 248     tmp1 = z2 - z3;
 249
 250     tmp10 = tmp0 + tmp2;
 251     tmp13 = tmp0 - tmp2;
 252     tmp11 = tmp1 + tmp3;
 253     tmp12 = tmp1 - tmp3;
 254
 255     /* Odd part per figure 8; the matrix is unitary and hence its
 256      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
 257      */
 258
 259     tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
 260     tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
 261     tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
 262     tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
 263
 264     z2 = tmp0 + tmp2;
 265     z3 = tmp1 + tmp3;
 266
 267     z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
 268     z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
 269     z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
 270     z2 += z1;
 271     z3 += z1;
 272
 273     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
 274     tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
 275     tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
 276     tmp0 += z1 + z2;
 277     tmp3 += z1 + z3;
 278
 279     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
 280     tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
 281     tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
 282     tmp1 += z1 + z3;
 283     tmp2 += z1 + z2;
 284
 285     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
 286
 287     wsptr[DCTSIZE*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
 288     wsptr[DCTSIZE*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
 289     wsptr[DCTSIZE*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
 290     wsptr[DCTSIZE*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
 291     wsptr[DCTSIZE*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
 292     wsptr[DCTSIZE*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
 293     wsptr[DCTSIZE*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
 294     wsptr[DCTSIZE*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
 295
 296     inptr++;                    /* advance pointers to next column */
 297     quantptr++;
 298     wsptr++;
 299   }
 300
 301   /* Pass 2: process rows from work array, store into output array.
 302    * Note that we must descale the results by a factor of 8 == 2**3,
 303    * and also undo the PASS1_BITS scaling.
 304    */
 305
 306   wsptr = workspace;
 307   for (ctr = 0; ctr < DCTSIZE; ctr++) {
 308     outptr = output_buf[ctr] + output_col;
 309     /* Rows of zeroes can be exploited in the same way as we did with columns.
 310      * However, the column calculation has created many nonzero AC terms, so
 311      * the simplification applies less often (typically 5% to 10% of the time).
 312      * On machines with very fast multiplication, it's possible that the
 313      * test takes more time than it's worth.  In that case this section
 314      * may be commented out.
 315      */
 316
 317 #ifndef NO_ZERO_ROW_TEST
 318     if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
 319         wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
 320       /* AC terms all zero */
 321       JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
 322                                   & RANGE_MASK];
 323
 324       outptr[0] = dcval;
 325       outptr[1] = dcval;
 326       outptr[2] = dcval;
 327       outptr[3] = dcval;
 328       outptr[4] = dcval;
 329       outptr[5] = dcval;
 330       outptr[6] = dcval;
 331       outptr[7] = dcval;
 332
 333       wsptr += DCTSIZE;         /* advance pointer to next row */
 334       continue;
 335     }
 336 #endif
 337
 338     /* Even part: reverse the even part of the forward DCT.
 339      * The rotator is c(-6).
 340      */
 341
 342     z2 = (INT32) wsptr[2];
 343     z3 = (INT32) wsptr[6];
 344
 345     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
 346     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
 347     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
 348
 349     /* Add fudge factor here for final descale. */
 350     z2 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
 351     z3 = (INT32) wsptr[4];
 352
 353     tmp0 = (z2 + z3) << CONST_BITS;
 354     tmp1 = (z2 - z3) << CONST_BITS;
 355
 356     tmp10 = tmp0 + tmp2;
 357     tmp13 = tmp0 - tmp2;
 358     tmp11 = tmp1 + tmp3;
 359     tmp12 = tmp1 - tmp3;
 360
 361     /* Odd part per figure 8; the matrix is unitary and hence its
 362      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
 363      */
 364
 365     tmp0 = (INT32) wsptr[7];
 366     tmp1 = (INT32) wsptr[5];
 367     tmp2 = (INT32) wsptr[3];
 368     tmp3 = (INT32) wsptr[1];
 369
 370     z2 = tmp0 + tmp2;
 371     z3 = tmp1 + tmp3;
 372
 373     z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
 374     z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
 375     z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
 376     z2 += z1;
 377     z3 += z1;
 378
 379     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
 380     tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
 381     tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
 382     tmp0 += z1 + z2;
 383     tmp3 += z1 + z3;
 384
 385     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
 386     tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
 387     tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
 388     tmp1 += z1 + z3;
 389     tmp2 += z1 + z2;
 390
 391     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
 392
 393     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
 394                                               CONST_BITS+PASS1_BITS+3)
 395                             & RANGE_MASK];
 396     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
 397                                               CONST_BITS+PASS1_BITS+3)
 398                             & RANGE_MASK];
 399     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
 400                                               CONST_BITS+PASS1_BITS+3)
 401                             & RANGE_MASK];
 402     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
 403                                               CONST_BITS+PASS1_BITS+3)
 404                             & RANGE_MASK];
 405     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
 406                                               CONST_BITS+PASS1_BITS+3)
 407                             & RANGE_MASK];
 408     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
 409                                               CONST_BITS+PASS1_BITS+3)
 410                             & RANGE_MASK];
 411     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
 412                                               CONST_BITS+PASS1_BITS+3)
 413                             & RANGE_MASK];
 414     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
 415                                               CONST_BITS+PASS1_BITS+3)
 416                             & RANGE_MASK];
 417
 418     wsptr += DCTSIZE;           /* advance pointer to next row */
 419   }
 420 }
 421
 422 #ifdef IDCT_SCALING_SUPPORTED
 423
 424
 425 /*
 426  * Perform dequantization and inverse DCT on one block of coefficients,
 427  * producing a 7x7 output block.
 428  *
 429  * Optimized algorithm with 12 multiplications in the 1-D kernel.
 430  * cK represents sqrt(2) * cos(K*pi/14).
 431  */
 432
 433 GLOBAL(void)
 434 jpeg_idct_7x7 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 435                JCOEFPTR coef_block,
 436                JSAMPARRAY output_buf, JDIMENSION output_col)
 437 {
 438   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12, tmp13;
 439   INT32 z1, z2, z3;
 440   JCOEFPTR inptr;
 441   ISLOW_MULT_TYPE * quantptr;
 442   int * wsptr;
 443   JSAMPROW outptr;
 444   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
 445   int ctr;
 446   int workspace[7*7];   /* buffers data between passes */
 447   SHIFT_TEMPS
 448
 449   /* Pass 1: process columns from input, store into work array. */
 450
 451   inptr = coef_block;
 452   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
 453   wsptr = workspace;
 454   for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
 455     /* Even part */
 456
 457     tmp13 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
 458     tmp13 <<= CONST_BITS;
 459     /* Add fudge factor here for final descale. */
 460     tmp13 += ONE << (CONST_BITS-PASS1_BITS-1);
 461
 462     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
 463     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
 464     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
 465
 466     tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
 467     tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
 468     tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
 469     tmp0 = z1 + z3;
 470     z2 -= tmp0;
 471     tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
 472     tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
 473     tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
 474     tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
 475
 476     /* Odd part */
 477
 478     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
 479     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
 480     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
 481
 482     tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
 483     tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
 484     tmp0 = tmp1 - tmp2;
 485     tmp1 += tmp2;
 486     tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276));    /* -c1 */
 487     tmp1 += tmp2;
 488     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
 489     tmp0 += z2;
 490     tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
 491
 492     /* Final output stage */
 493
 494     wsptr[7*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
 495     wsptr[7*6] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
 496     wsptr[7*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
 497     wsptr[7*5] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
 498     wsptr[7*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
 499     wsptr[7*4] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
 500     wsptr[7*3] = (int) RIGHT_SHIFT(tmp13, CONST_BITS-PASS1_BITS);
 501   }
 502
 503   /* Pass 2: process 7 rows from work array, store into output array. */
 504
 505   wsptr = workspace;
 506   for (ctr = 0; ctr < 7; ctr++) {
 507     outptr = output_buf[ctr] + output_col;
 508
 509     /* Even part */
 510
 511     /* Add fudge factor here for final descale. */
 512     tmp13 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
 513     tmp13 <<= CONST_BITS;
 514
 515     z1 = (INT32) wsptr[2];
 516     z2 = (INT32) wsptr[4];
 517     z3 = (INT32) wsptr[6];
 518
 519     tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
 520     tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
 521     tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
 522     tmp0 = z1 + z3;
 523     z2 -= tmp0;
 524     tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
 525     tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
 526     tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
 527     tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
 528
 529     /* Odd part */
 530
 531     z1 = (INT32) wsptr[1];
 532     z2 = (INT32) wsptr[3];
 533     z3 = (INT32) wsptr[5];
 534
 535     tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
 536     tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
 537     tmp0 = tmp1 - tmp2;
 538     tmp1 += tmp2;
 539     tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276));    /* -c1 */
 540     tmp1 += tmp2;
 541     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
 542     tmp0 += z2;
 543     tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
 544
 545     /* Final output stage */
 546
 547     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
 548                                               CONST_BITS+PASS1_BITS+3)
 549                             & RANGE_MASK];
 550     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
 551                                               CONST_BITS+PASS1_BITS+3)
 552                             & RANGE_MASK];
 553     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
 554                                               CONST_BITS+PASS1_BITS+3)
 555                             & RANGE_MASK];
 556     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
 557                                               CONST_BITS+PASS1_BITS+3)
 558                             & RANGE_MASK];
 559     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
 560                                               CONST_BITS+PASS1_BITS+3)
 561                             & RANGE_MASK];
 562     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
 563                                               CONST_BITS+PASS1_BITS+3)
 564                             & RANGE_MASK];
 565     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13,
 566                                               CONST_BITS+PASS1_BITS+3)
 567                             & RANGE_MASK];
 568
 569     wsptr += 7;         /* advance pointer to next row */
 570   }
 571 }
 572
 573
 574 /*
 575  * Perform dequantization and inverse DCT on one block of coefficients,
 576  * producing a reduced-size 6x6 output block.
 577  *
 578  * Optimized algorithm with 3 multiplications in the 1-D kernel.
 579  * cK represents sqrt(2) * cos(K*pi/12).
 580  */
 581
 582 GLOBAL(void)
 583 jpeg_idct_6x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 584                JCOEFPTR coef_block,
 585                JSAMPARRAY output_buf, JDIMENSION output_col)
 586 {
 587   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
 588   INT32 z1, z2, z3;
 589   JCOEFPTR inptr;
 590   ISLOW_MULT_TYPE * quantptr;
 591   int * wsptr;
 592   JSAMPROW outptr;
 593   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
 594   int ctr;
 595   int workspace[6*6];   /* buffers data between passes */
 596   SHIFT_TEMPS
 597
 598   /* Pass 1: process columns from input, store into work array. */
 599
 600   inptr = coef_block;
 601   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
 602   wsptr = workspace;
 603   for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
 604     /* Even part */
 605
 606     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
 607     tmp0 <<= CONST_BITS;
 608     /* Add fudge factor here for final descale. */
 609     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
 610     tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
 611     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
 612     tmp1 = tmp0 + tmp10;
 613     tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS-PASS1_BITS);
 614     tmp10 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
 615     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
 616     tmp10 = tmp1 + tmp0;
 617     tmp12 = tmp1 - tmp0;
 618
 619     /* Odd part */
 620
 621     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
 622     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
 623     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
 624     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
 625     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
 626     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
 627     tmp1 = (z1 - z2 - z3) << PASS1_BITS;
 628
 629     /* Final output stage */
 630
 631     wsptr[6*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
 632     wsptr[6*5] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
 633     wsptr[6*1] = (int) (tmp11 + tmp1);
 634     wsptr[6*4] = (int) (tmp11 - tmp1);
 635     wsptr[6*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
 636     wsptr[6*3] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
 637   }
 638
 639   /* Pass 2: process 6 rows from work array, store into output array. */
 640
 641   wsptr = workspace;
 642   for (ctr = 0; ctr < 6; ctr++) {
 643     outptr = output_buf[ctr] + output_col;
 644
 645     /* Even part */
 646
 647     /* Add fudge factor here for final descale. */
 648     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
 649     tmp0 <<= CONST_BITS;
 650     tmp2 = (INT32) wsptr[4];
 651     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
 652     tmp1 = tmp0 + tmp10;
 653     tmp11 = tmp0 - tmp10 - tmp10;
 654     tmp10 = (INT32) wsptr[2];
 655     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
 656     tmp10 = tmp1 + tmp0;
 657     tmp12 = tmp1 - tmp0;
 658
 659     /* Odd part */
 660
 661     z1 = (INT32) wsptr[1];
 662     z2 = (INT32) wsptr[3];
 663     z3 = (INT32) wsptr[5];
 664     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
 665     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
 666     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
 667     tmp1 = (z1 - z2 - z3) << CONST_BITS;
 668
 669     /* Final output stage */
 670
 671     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
 672                                               CONST_BITS+PASS1_BITS+3)
 673                             & RANGE_MASK];
 674     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
 675                                               CONST_BITS+PASS1_BITS+3)
 676                             & RANGE_MASK];
 677     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
 678                                               CONST_BITS+PASS1_BITS+3)
 679                             & RANGE_MASK];
 680     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
 681                                               CONST_BITS+PASS1_BITS+3)
 682                             & RANGE_MASK];
 683     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
 684                                               CONST_BITS+PASS1_BITS+3)
 685                             & RANGE_MASK];
 686     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
 687                                               CONST_BITS+PASS1_BITS+3)
 688                             & RANGE_MASK];
 689
 690     wsptr += 6;         /* advance pointer to next row */
 691   }
 692 }
 693
 694
 695 /*
 696  * Perform dequantization and inverse DCT on one block of coefficients,
 697  * producing a reduced-size 5x5 output block.
 698  *
 699  * Optimized algorithm with 5 multiplications in the 1-D kernel.
 700  * cK represents sqrt(2) * cos(K*pi/10).
 701  */
 702
 703 GLOBAL(void)
 704 jpeg_idct_5x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 705                JCOEFPTR coef_block,
 706                JSAMPARRAY output_buf, JDIMENSION output_col)
 707 {
 708   INT32 tmp0, tmp1, tmp10, tmp11, tmp12;
 709   INT32 z1, z2, z3;
 710   JCOEFPTR inptr;
 711   ISLOW_MULT_TYPE * quantptr;
 712   int * wsptr;
 713   JSAMPROW outptr;
 714   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
 715   int ctr;
 716   int workspace[5*5];   /* buffers data between passes */
 717   SHIFT_TEMPS
 718
 719   /* Pass 1: process columns from input, store into work array. */
 720
 721   inptr = coef_block;
 722   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
 723   wsptr = workspace;
 724   for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
 725     /* Even part */
 726
 727     tmp12 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
 728     tmp12 <<= CONST_BITS;
 729     /* Add fudge factor here for final descale. */
 730     tmp12 += ONE << (CONST_BITS-PASS1_BITS-1);
 731     tmp0 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
 732     tmp1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
 733     z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
 734     z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
 735     z3 = tmp12 + z2;
 736     tmp10 = z3 + z1;
 737     tmp11 = z3 - z1;
 738     tmp12 -= z2 << 2;
 739
 740     /* Odd part */
 741
 742     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
 743     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
 744
 745     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
 746     tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
 747     tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
 748
 749     /* Final output stage */
 750
 751     wsptr[5*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
 752     wsptr[5*4] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
 753     wsptr[5*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
 754     wsptr[5*3] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
 755     wsptr[5*2] = (int) RIGHT_SHIFT(tmp12, CONST_BITS-PASS1_BITS);
 756   }
 757
 758   /* Pass 2: process 5 rows from work array, store into output array. */
 759
 760   wsptr = workspace;
 761   for (ctr = 0; ctr < 5; ctr++) {
 762     outptr = output_buf[ctr] + output_col;
 763
 764     /* Even part */
 765
 766     /* Add fudge factor here for final descale. */
 767     tmp12 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
 768     tmp12 <<= CONST_BITS;
 769     tmp0 = (INT32) wsptr[2];
 770     tmp1 = (INT32) wsptr[4];
 771     z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
 772     z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
 773     z3 = tmp12 + z2;
 774     tmp10 = z3 + z1;
 775     tmp11 = z3 - z1;
 776     tmp12 -= z2 << 2;
 777
 778     /* Odd part */
 779
 780     z2 = (INT32) wsptr[1];
 781     z3 = (INT32) wsptr[3];
 782
 783     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
 784     tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
 785     tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
 786
 787     /* Final output stage */
 788
 789     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
 790                                               CONST_BITS+PASS1_BITS+3)
 791                             & RANGE_MASK];
 792     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
 793                                               CONST_BITS+PASS1_BITS+3)
 794                             & RANGE_MASK];
 795     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
 796                                               CONST_BITS+PASS1_BITS+3)
 797                             & RANGE_MASK];
 798     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
 799                                               CONST_BITS+PASS1_BITS+3)
 800                             & RANGE_MASK];
 801     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12,
 802                                               CONST_BITS+PASS1_BITS+3)
 803                             & RANGE_MASK];
 804
 805     wsptr += 5;         /* advance pointer to next row */
 806   }
 807 }
 808
 809
 810 /*
 811  * Perform dequantization and inverse DCT on one block of coefficients,
 812  * producing a reduced-size 4x4 output block.
 813  *
 814  * Optimized algorithm with 3 multiplications in the 1-D kernel.
 815  * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
 816  */
 817
 818 GLOBAL(void)
 819 jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 820                JCOEFPTR coef_block,
 821                JSAMPARRAY output_buf, JDIMENSION output_col)
 822 {
 823   INT32 tmp0, tmp2, tmp10, tmp12;
 824   INT32 z1, z2, z3;
 825   JCOEFPTR inptr;
 826   ISLOW_MULT_TYPE * quantptr;
 827   int * wsptr;
 828   JSAMPROW outptr;
 829   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
 830   int ctr;
 831   int workspace[4*4];   /* buffers data between passes */
 832   SHIFT_TEMPS
 833
 834   /* Pass 1: process columns from input, store into work array. */
 835
 836   inptr = coef_block;
 837   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
 838   wsptr = workspace;
 839   for (ctr = 0; ctr < 4; ctr++, inptr++, quantptr++, wsptr++) {
 840     /* Even part */
 841
 842     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
 843     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
 844
 845     tmp10 = (tmp0 + tmp2) << PASS1_BITS;
 846     tmp12 = (tmp0 - tmp2) << PASS1_BITS;
 847
 848     /* Odd part */
 849     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
 850
 851     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
 852     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
 853
 854     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);               /* c6 */
 855     /* Add fudge factor here for final descale. */
 856     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
 857     tmp0 = RIGHT_SHIFT(z1 + MULTIPLY(z2, FIX_0_765366865), /* c2-c6 */
 858                        CONST_BITS-PASS1_BITS);
 859     tmp2 = RIGHT_SHIFT(z1 - MULTIPLY(z3, FIX_1_847759065), /* c2+c6 */
 860                        CONST_BITS-PASS1_BITS);
 861
 862     /* Final output stage */
 863
 864     wsptr[4*0] = (int) (tmp10 + tmp0);
 865     wsptr[4*3] = (int) (tmp10 - tmp0);
 866     wsptr[4*1] = (int) (tmp12 + tmp2);
 867     wsptr[4*2] = (int) (tmp12 - tmp2);
 868   }
 869
 870   /* Pass 2: process 4 rows from work array, store into output array. */
 871
 872   wsptr = workspace;
 873   for (ctr = 0; ctr < 4; ctr++) {
 874     outptr = output_buf[ctr] + output_col;
 875
 876     /* Even part */
 877
 878     /* Add fudge factor here for final descale. */
 879     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
 880     tmp2 = (INT32) wsptr[2];
 881
 882     tmp10 = (tmp0 + tmp2) << CONST_BITS;
 883     tmp12 = (tmp0 - tmp2) << CONST_BITS;
 884
 885     /* Odd part */
 886     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
 887
 888     z2 = (INT32) wsptr[1];
 889     z3 = (INT32) wsptr[3];
 890
 891     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
 892     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
 893     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
 894
 895     /* Final output stage */
 896
 897     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
 898                                               CONST_BITS+PASS1_BITS+3)
 899                             & RANGE_MASK];
 900     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
 901                                               CONST_BITS+PASS1_BITS+3)
 902                             & RANGE_MASK];
 903     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
 904                                               CONST_BITS+PASS1_BITS+3)
 905                             & RANGE_MASK];
 906     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
 907                                               CONST_BITS+PASS1_BITS+3)
 908                             & RANGE_MASK];
 909
 910     wsptr += 4;         /* advance pointer to next row */
 911   }
 912 }
 913
 914
 915 /*
 916  * Perform dequantization and inverse DCT on one block of coefficients,
 917  * producing a reduced-size 3x3 output block.
 918  *
 919  * Optimized algorithm with 2 multiplications in the 1-D kernel.
 920  * cK represents sqrt(2) * cos(K*pi/6).
 921  */
 922
 923 GLOBAL(void)
 924 jpeg_idct_3x3 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 925                JCOEFPTR coef_block,
 926                JSAMPARRAY output_buf, JDIMENSION output_col)
 927 {
 928   INT32 tmp0, tmp2, tmp10, tmp12;
 929   JCOEFPTR inptr;
 930   ISLOW_MULT_TYPE * quantptr;
 931   int * wsptr;
 932   JSAMPROW outptr;
 933   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
 934   int ctr;
 935   int workspace[3*3];   /* buffers data between passes */
 936   SHIFT_TEMPS
 937
 938   /* Pass 1: process columns from input, store into work array. */
 939
 940   inptr = coef_block;
 941   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
 942   wsptr = workspace;
 943   for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
 944     /* Even part */
 945
 946     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
 947     tmp0 <<= CONST_BITS;
 948     /* Add fudge factor here for final descale. */
 949     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
 950     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
 951     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
 952     tmp10 = tmp0 + tmp12;
 953     tmp2 = tmp0 - tmp12 - tmp12;
 954
 955     /* Odd part */
 956
 957     tmp12 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
 958     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
 959
 960     /* Final output stage */
 961
 962     wsptr[3*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
 963     wsptr[3*2] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
 964     wsptr[3*1] = (int) RIGHT_SHIFT(tmp2, CONST_BITS-PASS1_BITS);
 965   }
 966
 967   /* Pass 2: process 3 rows from work array, store into output array. */
 968
 969   wsptr = workspace;
 970   for (ctr = 0; ctr < 3; ctr++) {
 971     outptr = output_buf[ctr] + output_col;
 972
 973     /* Even part */
 974
 975     /* Add fudge factor here for final descale. */
 976     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
 977     tmp0 <<= CONST_BITS;
 978     tmp2 = (INT32) wsptr[2];
 979     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
 980     tmp10 = tmp0 + tmp12;
 981     tmp2 = tmp0 - tmp12 - tmp12;
 982
 983     /* Odd part */
 984
 985     tmp12 = (INT32) wsptr[1];
 986     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
 987
 988     /* Final output stage */
 989
 990     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
 991                                               CONST_BITS+PASS1_BITS+3)
 992                             & RANGE_MASK];
 993     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
 994                                               CONST_BITS+PASS1_BITS+3)
 995                             & RANGE_MASK];
 996     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2,
 997                                               CONST_BITS+PASS1_BITS+3)
 998                             & RANGE_MASK];
 999
1000     wsptr += 3;         /* advance pointer to next row */
1001   }
1002 }
1003
1004
1005 /*
1006  * Perform dequantization and inverse DCT on one block of coefficients,
1007  * producing a reduced-size 2x2 output block.
1008  *
1009  * Multiplication-less algorithm.
1010  */
1011
1012 GLOBAL(void)
1013 jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1014                JCOEFPTR coef_block,
1015                JSAMPARRAY output_buf, JDIMENSION output_col)
1016 {
1017   INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
1018   ISLOW_MULT_TYPE * quantptr;
1019   JSAMPROW outptr;
1020   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1021   SHIFT_TEMPS
1022
1023   /* Pass 1: process columns from input. */
1024
1025   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1026
1027   /* Column 0 */
1028   tmp4 = DEQUANTIZE(coef_block[DCTSIZE*0], quantptr[DCTSIZE*0]);
1029   tmp5 = DEQUANTIZE(coef_block[DCTSIZE*1], quantptr[DCTSIZE*1]);
1030   /* Add fudge factor here for final descale. */
1031   tmp4 += ONE << 2;
1032
1033   tmp0 = tmp4 + tmp5;
1034   tmp2 = tmp4 - tmp5;
1035
1036   /* Column 1 */
1037   tmp4 = DEQUANTIZE(coef_block[DCTSIZE*0+1], quantptr[DCTSIZE*0+1]);
1038   tmp5 = DEQUANTIZE(coef_block[DCTSIZE*1+1], quantptr[DCTSIZE*1+1]);
1039
1040   tmp1 = tmp4 + tmp5;
1041   tmp3 = tmp4 - tmp5;
1042
1043   /* Pass 2: process 2 rows, store into output array. */
1044
1045   /* Row 0 */
1046   outptr = output_buf[0] + output_col;
1047
1048   outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp0 + tmp1, 3) & RANGE_MASK];
1049   outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp0 - tmp1, 3) & RANGE_MASK];
1050
1051   /* Row 1 */
1052   outptr = output_buf[1] + output_col;
1053
1054   outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp2 + tmp3, 3) & RANGE_MASK];
1055   outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2 - tmp3, 3) & RANGE_MASK];
1056 }
1057
1058
1059 /*
1060  * Perform dequantization and inverse DCT on one block of coefficients,
1061  * producing a reduced-size 1x1 output block.
1062  *
1063  * We hardly need an inverse DCT routine for this: just take the
1064  * average pixel value, which is one-eighth of the DC coefficient.
1065  */
1066
1067 GLOBAL(void)
1068 jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1069                JCOEFPTR coef_block,
1070                JSAMPARRAY output_buf, JDIMENSION output_col)
1071 {
1072   int dcval;
1073   ISLOW_MULT_TYPE * quantptr;
1074   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1075   SHIFT_TEMPS
1076
1077   /* 1x1 is trivial: just take the DC coefficient divided by 8. */
1078   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1079   dcval = DEQUANTIZE(coef_block[0], quantptr[0]);
1080   dcval = (int) DESCALE((INT32) dcval, 3);
1081
1082   output_buf[0][output_col] = range_limit[dcval & RANGE_MASK];
1083 }
1084
1085
1086 /*
1087  * Perform dequantization and inverse DCT on one block of coefficients,
1088  * producing a 9x9 output block.
1089  *
1090  * Optimized algorithm with 10 multiplications in the 1-D kernel.
1091  * cK represents sqrt(2) * cos(K*pi/18).
1092  */
1093
1094 GLOBAL(void)
1095 jpeg_idct_9x9 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1096                JCOEFPTR coef_block,
1097                JSAMPARRAY output_buf, JDIMENSION output_col)
1098 {
1099   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13, tmp14;
1100   INT32 z1, z2, z3, z4;
1101   JCOEFPTR inptr;
1102   ISLOW_MULT_TYPE * quantptr;
1103   int * wsptr;
1104   JSAMPROW outptr;
1105   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1106   int ctr;
1107   int workspace[8*9];   /* buffers data between passes */
1108   SHIFT_TEMPS
1109
1110   /* Pass 1: process columns from input, store into work array. */
1111
1112   inptr = coef_block;
1113   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1114   wsptr = workspace;
1115   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1116     /* Even part */
1117
1118     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1119     tmp0 <<= CONST_BITS;
1120     /* Add fudge factor here for final descale. */
1121     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
1122
1123     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1124     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1125     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1126
1127     tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
1128     tmp1 = tmp0 + tmp3;
1129     tmp2 = tmp0 - tmp3 - tmp3;
1130
1131     tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
1132     tmp11 = tmp2 + tmp0;
1133     tmp14 = tmp2 - tmp0 - tmp0;
1134
1135     tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
1136     tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
1137     tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
1138
1139     tmp10 = tmp1 + tmp0 - tmp3;
1140     tmp12 = tmp1 - tmp0 + tmp2;
1141     tmp13 = tmp1 - tmp2 + tmp3;
1142
1143     /* Odd part */
1144
1145     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1146     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1147     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1148     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1149
1150     z2 = MULTIPLY(z2, - FIX(1.224744871));           /* -c3 */
1151
1152     tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
1153     tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
1154     tmp0 = tmp2 + tmp3 - z2;
1155     tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
1156     tmp2 += z2 - tmp1;
1157     tmp3 += z2 + tmp1;
1158     tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
1159
1160     /* Final output stage */
1161
1162     wsptr[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
1163     wsptr[8*8] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
1164     wsptr[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
1165     wsptr[8*7] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
1166     wsptr[8*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
1167     wsptr[8*6] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
1168     wsptr[8*3] = (int) RIGHT_SHIFT(tmp13 + tmp3, CONST_BITS-PASS1_BITS);
1169     wsptr[8*5] = (int) RIGHT_SHIFT(tmp13 - tmp3, CONST_BITS-PASS1_BITS);
1170     wsptr[8*4] = (int) RIGHT_SHIFT(tmp14, CONST_BITS-PASS1_BITS);
1171   }
1172
1173   /* Pass 2: process 9 rows from work array, store into output array. */
1174
1175   wsptr = workspace;
1176   for (ctr = 0; ctr < 9; ctr++) {
1177     outptr = output_buf[ctr] + output_col;
1178
1179     /* Even part */
1180
1181     /* Add fudge factor here for final descale. */
1182     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1183     tmp0 <<= CONST_BITS;
1184
1185     z1 = (INT32) wsptr[2];
1186     z2 = (INT32) wsptr[4];
1187     z3 = (INT32) wsptr[6];
1188
1189     tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
1190     tmp1 = tmp0 + tmp3;
1191     tmp2 = tmp0 - tmp3 - tmp3;
1192
1193     tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
1194     tmp11 = tmp2 + tmp0;
1195     tmp14 = tmp2 - tmp0 - tmp0;
1196
1197     tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
1198     tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
1199     tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
1200
1201     tmp10 = tmp1 + tmp0 - tmp3;
1202     tmp12 = tmp1 - tmp0 + tmp2;
1203     tmp13 = tmp1 - tmp2 + tmp3;
1204
1205     /* Odd part */
1206
1207     z1 = (INT32) wsptr[1];
1208     z2 = (INT32) wsptr[3];
1209     z3 = (INT32) wsptr[5];
1210     z4 = (INT32) wsptr[7];
1211
1212     z2 = MULTIPLY(z2, - FIX(1.224744871));           /* -c3 */
1213
1214     tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
1215     tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
1216     tmp0 = tmp2 + tmp3 - z2;
1217     tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
1218     tmp2 += z2 - tmp1;
1219     tmp3 += z2 + tmp1;
1220     tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
1221
1222     /* Final output stage */
1223
1224     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
1225                                               CONST_BITS+PASS1_BITS+3)
1226                             & RANGE_MASK];
1227     outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
1228                                               CONST_BITS+PASS1_BITS+3)
1229                             & RANGE_MASK];
1230     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
1231                                               CONST_BITS+PASS1_BITS+3)
1232                             & RANGE_MASK];
1233     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
1234                                               CONST_BITS+PASS1_BITS+3)
1235                             & RANGE_MASK];
1236     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
1237                                               CONST_BITS+PASS1_BITS+3)
1238                             & RANGE_MASK];
1239     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
1240                                               CONST_BITS+PASS1_BITS+3)
1241                             & RANGE_MASK];
1242     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp3,
1243                                               CONST_BITS+PASS1_BITS+3)
1244                             & RANGE_MASK];
1245     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp3,
1246                                               CONST_BITS+PASS1_BITS+3)
1247                             & RANGE_MASK];
1248     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp14,
1249                                               CONST_BITS+PASS1_BITS+3)
1250                             & RANGE_MASK];
1251
1252     wsptr += 8;         /* advance pointer to next row */
1253   }
1254 }
1255
1256
1257 /*
1258  * Perform dequantization and inverse DCT on one block of coefficients,
1259  * producing a 10x10 output block.
1260  *
1261  * Optimized algorithm with 12 multiplications in the 1-D kernel.
1262  * cK represents sqrt(2) * cos(K*pi/20).
1263  */
1264
1265 GLOBAL(void)
1266 jpeg_idct_10x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1267                  JCOEFPTR coef_block,
1268                  JSAMPARRAY output_buf, JDIMENSION output_col)
1269 {
1270   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1271   INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
1272   INT32 z1, z2, z3, z4, z5;
1273   JCOEFPTR inptr;
1274   ISLOW_MULT_TYPE * quantptr;
1275   int * wsptr;
1276   JSAMPROW outptr;
1277   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1278   int ctr;
1279   int workspace[8*10];  /* buffers data between passes */
1280   SHIFT_TEMPS
1281
1282   /* Pass 1: process columns from input, store into work array. */
1283
1284   inptr = coef_block;
1285   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1286   wsptr = workspace;
1287   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1288     /* Even part */
1289
1290     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1291     z3 <<= CONST_BITS;
1292     /* Add fudge factor here for final descale. */
1293     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
1294     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1295     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
1296     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
1297     tmp10 = z3 + z1;
1298     tmp11 = z3 - z2;
1299
1300     tmp22 = RIGHT_SHIFT(z3 - ((z1 - z2) << 1),   /* c0 = (c4-c8)*2 */
1301                         CONST_BITS-PASS1_BITS);
1302
1303     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1304     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1305
1306     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
1307     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
1308     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
1309
1310     tmp20 = tmp10 + tmp12;
1311     tmp24 = tmp10 - tmp12;
1312     tmp21 = tmp11 + tmp13;
1313     tmp23 = tmp11 - tmp13;
1314
1315     /* Odd part */
1316
1317     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1318     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1319     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1320     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1321
1322     tmp11 = z2 + z4;
1323     tmp13 = z2 - z4;
1324
1325     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
1326     z5 = z3 << CONST_BITS;
1327
1328     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
1329     z4 = z5 + tmp12;
1330
1331     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
1332     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
1333
1334     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
1335     z4 = z5 - tmp12 - (tmp13 << (CONST_BITS - 1));
1336
1337     tmp12 = (z1 - tmp13 - z3) << PASS1_BITS;
1338
1339     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
1340     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
1341
1342     /* Final output stage */
1343
1344     wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1345     wsptr[8*9] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1346     wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1347     wsptr[8*8] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1348     wsptr[8*2] = (int) (tmp22 + tmp12);
1349     wsptr[8*7] = (int) (tmp22 - tmp12);
1350     wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1351     wsptr[8*6] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1352     wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1353     wsptr[8*5] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1354   }
1355
1356   /* Pass 2: process 10 rows from work array, store into output array. */
1357
1358   wsptr = workspace;
1359   for (ctr = 0; ctr < 10; ctr++) {
1360     outptr = output_buf[ctr] + output_col;
1361
1362     /* Even part */
1363
1364     /* Add fudge factor here for final descale. */
1365     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1366     z3 <<= CONST_BITS;
1367     z4 = (INT32) wsptr[4];
1368     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
1369     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
1370     tmp10 = z3 + z1;
1371     tmp11 = z3 - z2;
1372
1373     tmp22 = z3 - ((z1 - z2) << 1);               /* c0 = (c4-c8)*2 */
1374
1375     z2 = (INT32) wsptr[2];
1376     z3 = (INT32) wsptr[6];
1377
1378     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
1379     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
1380     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
1381
1382     tmp20 = tmp10 + tmp12;
1383     tmp24 = tmp10 - tmp12;
1384     tmp21 = tmp11 + tmp13;
1385     tmp23 = tmp11 - tmp13;
1386
1387     /* Odd part */
1388
1389     z1 = (INT32) wsptr[1];
1390     z2 = (INT32) wsptr[3];
1391     z3 = (INT32) wsptr[5];
1392     z3 <<= CONST_BITS;
1393     z4 = (INT32) wsptr[7];
1394
1395     tmp11 = z2 + z4;
1396     tmp13 = z2 - z4;
1397
1398     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
1399
1400     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
1401     z4 = z3 + tmp12;
1402
1403     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
1404     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
1405
1406     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
1407     z4 = z3 - tmp12 - (tmp13 << (CONST_BITS - 1));
1408
1409     tmp12 = ((z1 - tmp13) << CONST_BITS) - z3;
1410
1411     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
1412     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
1413
1414     /* Final output stage */
1415
1416     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1417                                               CONST_BITS+PASS1_BITS+3)
1418                             & RANGE_MASK];
1419     outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1420                                               CONST_BITS+PASS1_BITS+3)
1421                             & RANGE_MASK];
1422     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1423                                               CONST_BITS+PASS1_BITS+3)
1424                             & RANGE_MASK];
1425     outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1426                                               CONST_BITS+PASS1_BITS+3)
1427                             & RANGE_MASK];
1428     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1429                                               CONST_BITS+PASS1_BITS+3)
1430                             & RANGE_MASK];
1431     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1432                                               CONST_BITS+PASS1_BITS+3)
1433                             & RANGE_MASK];
1434     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1435                                               CONST_BITS+PASS1_BITS+3)
1436                             & RANGE_MASK];
1437     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1438                                               CONST_BITS+PASS1_BITS+3)
1439                             & RANGE_MASK];
1440     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1441                                               CONST_BITS+PASS1_BITS+3)
1442                             & RANGE_MASK];
1443     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1444                                               CONST_BITS+PASS1_BITS+3)
1445                             & RANGE_MASK];
1446
1447     wsptr += 8;         /* advance pointer to next row */
1448   }
1449 }
1450
1451
1452 /*
1453  * Perform dequantization and inverse DCT on one block of coefficients,
1454  * producing a 11x11 output block.
1455  *
1456  * Optimized algorithm with 24 multiplications in the 1-D kernel.
1457  * cK represents sqrt(2) * cos(K*pi/22).
1458  */
1459
1460 GLOBAL(void)
1461 jpeg_idct_11x11 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1462                  JCOEFPTR coef_block,
1463                  JSAMPARRAY output_buf, JDIMENSION output_col)
1464 {
1465   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1466   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
1467   INT32 z1, z2, z3, z4;
1468   JCOEFPTR inptr;
1469   ISLOW_MULT_TYPE * quantptr;
1470   int * wsptr;
1471   JSAMPROW outptr;
1472   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1473   int ctr;
1474   int workspace[8*11];  /* buffers data between passes */
1475   SHIFT_TEMPS
1476
1477   /* Pass 1: process columns from input, store into work array. */
1478
1479   inptr = coef_block;
1480   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1481   wsptr = workspace;
1482   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1483     /* Even part */
1484
1485     tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1486     tmp10 <<= CONST_BITS;
1487     /* Add fudge factor here for final descale. */
1488     tmp10 += ONE << (CONST_BITS-PASS1_BITS-1);
1489
1490     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1491     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1492     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1493
1494     tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
1495     tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
1496     z4 = z1 + z3;
1497     tmp24 = MULTIPLY(z4, - FIX(1.155664402));        /* -(c2-c10) */
1498     z4 -= z2;
1499     tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
1500     tmp21 = tmp20 + tmp23 + tmp25 -
1501             MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
1502     tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
1503     tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
1504     tmp24 += tmp25;
1505     tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
1506     tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
1507              MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
1508     tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
1509
1510     /* Odd part */
1511
1512     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1513     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1514     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1515     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1516
1517     tmp11 = z1 + z2;
1518     tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
1519     tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
1520     tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
1521     tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
1522     tmp10 = tmp11 + tmp12 + tmp13 -
1523             MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
1524     z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
1525     tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
1526     tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
1527     z1    = MULTIPLY(z2 + z4, - FIX(1.798248910));       /* -(c1+c9) */
1528     tmp11 += z1;
1529     tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
1530     tmp14 += MULTIPLY(z2, - FIX(1.467221301)) +          /* -(c5+c9) */
1531              MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
1532              MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
1533
1534     /* Final output stage */
1535
1536     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1537     wsptr[8*10] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1538     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1539     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1540     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1541     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1542     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1543     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1544     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1545     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1546     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25, CONST_BITS-PASS1_BITS);
1547   }
1548
1549   /* Pass 2: process 11 rows from work array, store into output array. */
1550
1551   wsptr = workspace;
1552   for (ctr = 0; ctr < 11; ctr++) {
1553     outptr = output_buf[ctr] + output_col;
1554
1555     /* Even part */
1556
1557     /* Add fudge factor here for final descale. */
1558     tmp10 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1559     tmp10 <<= CONST_BITS;
1560
1561     z1 = (INT32) wsptr[2];
1562     z2 = (INT32) wsptr[4];
1563     z3 = (INT32) wsptr[6];
1564
1565     tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
1566     tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
1567     z4 = z1 + z3;
1568     tmp24 = MULTIPLY(z4, - FIX(1.155664402));        /* -(c2-c10) */
1569     z4 -= z2;
1570     tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
1571     tmp21 = tmp20 + tmp23 + tmp25 -
1572             MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
1573     tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
1574     tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
1575     tmp24 += tmp25;
1576     tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
1577     tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
1578              MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
1579     tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
1580
1581     /* Odd part */
1582
1583     z1 = (INT32) wsptr[1];
1584     z2 = (INT32) wsptr[3];
1585     z3 = (INT32) wsptr[5];
1586     z4 = (INT32) wsptr[7];
1587
1588     tmp11 = z1 + z2;
1589     tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
1590     tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
1591     tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
1592     tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
1593     tmp10 = tmp11 + tmp12 + tmp13 -
1594             MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
1595     z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
1596     tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
1597     tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
1598     z1    = MULTIPLY(z2 + z4, - FIX(1.798248910));       /* -(c1+c9) */
1599     tmp11 += z1;
1600     tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
1601     tmp14 += MULTIPLY(z2, - FIX(1.467221301)) +          /* -(c5+c9) */
1602              MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
1603              MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
1604
1605     /* Final output stage */
1606
1607     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1608                                                CONST_BITS+PASS1_BITS+3)
1609                              & RANGE_MASK];
1610     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1611                                                CONST_BITS+PASS1_BITS+3)
1612                              & RANGE_MASK];
1613     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1614                                                CONST_BITS+PASS1_BITS+3)
1615                              & RANGE_MASK];
1616     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1617                                                CONST_BITS+PASS1_BITS+3)
1618                              & RANGE_MASK];
1619     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1620                                                CONST_BITS+PASS1_BITS+3)
1621                              & RANGE_MASK];
1622     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1623                                                CONST_BITS+PASS1_BITS+3)
1624                              & RANGE_MASK];
1625     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1626                                                CONST_BITS+PASS1_BITS+3)
1627                              & RANGE_MASK];
1628     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1629                                                CONST_BITS+PASS1_BITS+3)
1630                              & RANGE_MASK];
1631     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1632                                                CONST_BITS+PASS1_BITS+3)
1633                              & RANGE_MASK];
1634     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1635                                                CONST_BITS+PASS1_BITS+3)
1636                              & RANGE_MASK];
1637     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25,
1638                                                CONST_BITS+PASS1_BITS+3)
1639                              & RANGE_MASK];
1640
1641     wsptr += 8;         /* advance pointer to next row */
1642   }
1643 }
1644
1645
1646 /*
1647  * Perform dequantization and inverse DCT on one block of coefficients,
1648  * producing a 12x12 output block.
1649  *
1650  * Optimized algorithm with 15 multiplications in the 1-D kernel.
1651  * cK represents sqrt(2) * cos(K*pi/24).
1652  */
1653
1654 GLOBAL(void)
1655 jpeg_idct_12x12 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1656                  JCOEFPTR coef_block,
1657                  JSAMPARRAY output_buf, JDIMENSION output_col)
1658 {
1659   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1660   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
1661   INT32 z1, z2, z3, z4;
1662   JCOEFPTR inptr;
1663   ISLOW_MULT_TYPE * quantptr;
1664   int * wsptr;
1665   JSAMPROW outptr;
1666   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1667   int ctr;
1668   int workspace[8*12];  /* buffers data between passes */
1669   SHIFT_TEMPS
1670
1671   /* Pass 1: process columns from input, store into work array. */
1672
1673   inptr = coef_block;
1674   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1675   wsptr = workspace;
1676   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1677     /* Even part */
1678
1679     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1680     z3 <<= CONST_BITS;
1681     /* Add fudge factor here for final descale. */
1682     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
1683
1684     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1685     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
1686
1687     tmp10 = z3 + z4;
1688     tmp11 = z3 - z4;
1689
1690     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1691     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
1692     z1 <<= CONST_BITS;
1693     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1694     z2 <<= CONST_BITS;
1695
1696     tmp12 = z1 - z2;
1697
1698     tmp21 = z3 + tmp12;
1699     tmp24 = z3 - tmp12;
1700
1701     tmp12 = z4 + z2;
1702
1703     tmp20 = tmp10 + tmp12;
1704     tmp25 = tmp10 - tmp12;
1705
1706     tmp12 = z4 - z1 - z2;
1707
1708     tmp22 = tmp11 + tmp12;
1709     tmp23 = tmp11 - tmp12;
1710
1711     /* Odd part */
1712
1713     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1714     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1715     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1716     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1717
1718     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
1719     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
1720
1721     tmp10 = z1 + z3;
1722     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
1723     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
1724     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
1725     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
1726     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
1727     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
1728     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
1729              MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
1730
1731     z1 -= z4;
1732     z2 -= z3;
1733     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
1734     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
1735     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
1736
1737     /* Final output stage */
1738
1739     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1740     wsptr[8*11] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1741     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1742     wsptr[8*10] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1743     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1744     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1745     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1746     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1747     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1748     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1749     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
1750     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
1751   }
1752
1753   /* Pass 2: process 12 rows from work array, store into output array. */
1754
1755   wsptr = workspace;
1756   for (ctr = 0; ctr < 12; ctr++) {
1757     outptr = output_buf[ctr] + output_col;
1758
1759     /* Even part */
1760
1761     /* Add fudge factor here for final descale. */
1762     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1763     z3 <<= CONST_BITS;
1764
1765     z4 = (INT32) wsptr[4];
1766     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
1767
1768     tmp10 = z3 + z4;
1769     tmp11 = z3 - z4;
1770
1771     z1 = (INT32) wsptr[2];
1772     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
1773     z1 <<= CONST_BITS;
1774     z2 = (INT32) wsptr[6];
1775     z2 <<= CONST_BITS;
1776
1777     tmp12 = z1 - z2;
1778
1779     tmp21 = z3 + tmp12;
1780     tmp24 = z3 - tmp12;
1781
1782     tmp12 = z4 + z2;
1783
1784     tmp20 = tmp10 + tmp12;
1785     tmp25 = tmp10 - tmp12;
1786
1787     tmp12 = z4 - z1 - z2;
1788
1789     tmp22 = tmp11 + tmp12;
1790     tmp23 = tmp11 - tmp12;
1791
1792     /* Odd part */
1793
1794     z1 = (INT32) wsptr[1];
1795     z2 = (INT32) wsptr[3];
1796     z3 = (INT32) wsptr[5];
1797     z4 = (INT32) wsptr[7];
1798
1799     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
1800     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
1801
1802     tmp10 = z1 + z3;
1803     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
1804     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
1805     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
1806     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
1807     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
1808     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
1809     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
1810              MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
1811
1812     z1 -= z4;
1813     z2 -= z3;
1814     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
1815     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
1816     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
1817
1818     /* Final output stage */
1819
1820     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1821                                                CONST_BITS+PASS1_BITS+3)
1822                              & RANGE_MASK];
1823     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1824                                                CONST_BITS+PASS1_BITS+3)
1825                              & RANGE_MASK];
1826     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1827                                                CONST_BITS+PASS1_BITS+3)
1828                              & RANGE_MASK];
1829     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1830                                                CONST_BITS+PASS1_BITS+3)
1831                              & RANGE_MASK];
1832     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1833                                                CONST_BITS+PASS1_BITS+3)
1834                              & RANGE_MASK];
1835     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1836                                                CONST_BITS+PASS1_BITS+3)
1837                              & RANGE_MASK];
1838     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1839                                                CONST_BITS+PASS1_BITS+3)
1840                              & RANGE_MASK];
1841     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1842                                                CONST_BITS+PASS1_BITS+3)
1843                              & RANGE_MASK];
1844     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1845                                                CONST_BITS+PASS1_BITS+3)
1846                              & RANGE_MASK];
1847     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1848                                                CONST_BITS+PASS1_BITS+3)
1849                              & RANGE_MASK];
1850     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
1851                                                CONST_BITS+PASS1_BITS+3)
1852                              & RANGE_MASK];
1853     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
1854                                                CONST_BITS+PASS1_BITS+3)
1855                              & RANGE_MASK];
1856
1857     wsptr += 8;         /* advance pointer to next row */
1858   }
1859 }
1860
1861
1862 /*
1863  * Perform dequantization and inverse DCT on one block of coefficients,
1864  * producing a 13x13 output block.
1865  *
1866  * Optimized algorithm with 29 multiplications in the 1-D kernel.
1867  * cK represents sqrt(2) * cos(K*pi/26).
1868  */
1869
1870 GLOBAL(void)
1871 jpeg_idct_13x13 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1872                  JCOEFPTR coef_block,
1873                  JSAMPARRAY output_buf, JDIMENSION output_col)
1874 {
1875   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1876   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
1877   INT32 z1, z2, z3, z4;
1878   JCOEFPTR inptr;
1879   ISLOW_MULT_TYPE * quantptr;
1880   int * wsptr;
1881   JSAMPROW outptr;
1882   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1883   int ctr;
1884   int workspace[8*13];  /* buffers data between passes */
1885   SHIFT_TEMPS
1886
1887   /* Pass 1: process columns from input, store into work array. */
1888
1889   inptr = coef_block;
1890   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1891   wsptr = workspace;
1892   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1893     /* Even part */
1894
1895     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1896     z1 <<= CONST_BITS;
1897     /* Add fudge factor here for final descale. */
1898     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
1899
1900     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1901     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1902     z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1903
1904     tmp10 = z3 + z4;
1905     tmp11 = z3 - z4;
1906
1907     tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
1908     tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
1909
1910     tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
1911     tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
1912
1913     tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
1914     tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
1915
1916     tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
1917     tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
1918
1919     tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
1920     tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
1921
1922     tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
1923     tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
1924
1925     tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
1926
1927     /* Odd part */
1928
1929     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1930     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1931     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1932     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1933
1934     tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
1935     tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
1936     tmp15 = z1 + z4;
1937     tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
1938     tmp10 = tmp11 + tmp12 + tmp13 -
1939             MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
1940     tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458));   /* -c11 */
1941     tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
1942     tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
1943     tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945));   /* -c5 */
1944     tmp11 += tmp14;
1945     tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
1946     tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813));   /* -c9 */
1947     tmp12 += tmp14;
1948     tmp13 += tmp14;
1949     tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
1950     tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
1951             MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
1952     z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
1953     tmp14 += z1;
1954     tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
1955              MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
1956
1957     /* Final output stage */
1958
1959     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1960     wsptr[8*12] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1961     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1962     wsptr[8*11] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1963     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1964     wsptr[8*10] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1965     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1966     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1967     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1968     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1969     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
1970     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
1971     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26, CONST_BITS-PASS1_BITS);
1972   }
1973
1974   /* Pass 2: process 13 rows from work array, store into output array. */
1975
1976   wsptr = workspace;
1977   for (ctr = 0; ctr < 13; ctr++) {
1978     outptr = output_buf[ctr] + output_col;
1979
1980     /* Even part */
1981
1982     /* Add fudge factor here for final descale. */
1983     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1984     z1 <<= CONST_BITS;
1985
1986     z2 = (INT32) wsptr[2];
1987     z3 = (INT32) wsptr[4];
1988     z4 = (INT32) wsptr[6];
1989
1990     tmp10 = z3 + z4;
1991     tmp11 = z3 - z4;
1992
1993     tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
1994     tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
1995
1996     tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
1997     tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
1998
1999     tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
2000     tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
2001
2002     tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
2003     tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
2004
2005     tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
2006     tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
2007
2008     tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
2009     tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
2010
2011     tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
2012
2013     /* Odd part */
2014
2015     z1 = (INT32) wsptr[1];
2016     z2 = (INT32) wsptr[3];
2017     z3 = (INT32) wsptr[5];
2018     z4 = (INT32) wsptr[7];
2019
2020     tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
2021     tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
2022     tmp15 = z1 + z4;
2023     tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
2024     tmp10 = tmp11 + tmp12 + tmp13 -
2025             MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
2026     tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458));   /* -c11 */
2027     tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
2028     tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
2029     tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945));   /* -c5 */
2030     tmp11 += tmp14;
2031     tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
2032     tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813));   /* -c9 */
2033     tmp12 += tmp14;
2034     tmp13 += tmp14;
2035     tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
2036     tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
2037             MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
2038     z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
2039     tmp14 += z1;
2040     tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
2041              MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
2042
2043     /* Final output stage */
2044
2045     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2046                                                CONST_BITS+PASS1_BITS+3)
2047                              & RANGE_MASK];
2048     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2049                                                CONST_BITS+PASS1_BITS+3)
2050                              & RANGE_MASK];
2051     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2052                                                CONST_BITS+PASS1_BITS+3)
2053                              & RANGE_MASK];
2054     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2055                                                CONST_BITS+PASS1_BITS+3)
2056                              & RANGE_MASK];
2057     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2058                                                CONST_BITS+PASS1_BITS+3)
2059                              & RANGE_MASK];
2060     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2061                                                CONST_BITS+PASS1_BITS+3)
2062                              & RANGE_MASK];
2063     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2064                                                CONST_BITS+PASS1_BITS+3)
2065                              & RANGE_MASK];
2066     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2067                                                CONST_BITS+PASS1_BITS+3)
2068                              & RANGE_MASK];
2069     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2070                                                CONST_BITS+PASS1_BITS+3)
2071                              & RANGE_MASK];
2072     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2073                                                CONST_BITS+PASS1_BITS+3)
2074                              & RANGE_MASK];
2075     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2076                                                CONST_BITS+PASS1_BITS+3)
2077                              & RANGE_MASK];
2078     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2079                                                CONST_BITS+PASS1_BITS+3)
2080                              & RANGE_MASK];
2081     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26,
2082                                                CONST_BITS+PASS1_BITS+3)
2083                              & RANGE_MASK];
2084
2085     wsptr += 8;         /* advance pointer to next row */
2086   }
2087 }
2088
2089
2090 /*
2091  * Perform dequantization and inverse DCT on one block of coefficients,
2092  * producing a 14x14 output block.
2093  *
2094  * Optimized algorithm with 20 multiplications in the 1-D kernel.
2095  * cK represents sqrt(2) * cos(K*pi/28).
2096  */
2097
2098 GLOBAL(void)
2099 jpeg_idct_14x14 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2100                  JCOEFPTR coef_block,
2101                  JSAMPARRAY output_buf, JDIMENSION output_col)
2102 {
2103   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
2104   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
2105   INT32 z1, z2, z3, z4;
2106   JCOEFPTR inptr;
2107   ISLOW_MULT_TYPE * quantptr;
2108   int * wsptr;
2109   JSAMPROW outptr;
2110   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2111   int ctr;
2112   int workspace[8*14];  /* buffers data between passes */
2113   SHIFT_TEMPS
2114
2115   /* Pass 1: process columns from input, store into work array. */
2116
2117   inptr = coef_block;
2118   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2119   wsptr = workspace;
2120   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2121     /* Even part */
2122
2123     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2124     z1 <<= CONST_BITS;
2125     /* Add fudge factor here for final descale. */
2126     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
2127     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2128     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
2129     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
2130     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
2131
2132     tmp10 = z1 + z2;
2133     tmp11 = z1 + z3;
2134     tmp12 = z1 - z4;
2135
2136     tmp23 = RIGHT_SHIFT(z1 - ((z2 + z3 - z4) << 1), /* c0 = (c4+c12-c8)*2 */
2137                         CONST_BITS-PASS1_BITS);
2138
2139     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2140     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2141
2142     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
2143
2144     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
2145     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
2146     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
2147             MULTIPLY(z2, FIX(1.378756276));      /* c2 */
2148
2149     tmp20 = tmp10 + tmp13;
2150     tmp26 = tmp10 - tmp13;
2151     tmp21 = tmp11 + tmp14;
2152     tmp25 = tmp11 - tmp14;
2153     tmp22 = tmp12 + tmp15;
2154     tmp24 = tmp12 - tmp15;
2155
2156     /* Odd part */
2157
2158     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2159     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2160     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2161     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2162     tmp13 = z4 << CONST_BITS;
2163
2164     tmp14 = z1 + z3;
2165     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
2166     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
2167     tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
2168     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
2169     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
2170     z1    -= z2;
2171     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13;        /* c11 */
2172     tmp16 += tmp15;
2173     z1    += z4;
2174     z4    = MULTIPLY(z2 + z3, - FIX(0.158341681)) - tmp13; /* -c13 */
2175     tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948));          /* c3-c9-c13 */
2176     tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773));          /* c3+c5-c13 */
2177     z4    = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
2178     tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
2179     tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567));          /* c1+c11-c5 */
2180
2181     tmp13 = (z1 - z3) << PASS1_BITS;
2182
2183     /* Final output stage */
2184
2185     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
2186     wsptr[8*13] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
2187     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
2188     wsptr[8*12] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
2189     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
2190     wsptr[8*11] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
2191     wsptr[8*3]  = (int) (tmp23 + tmp13);
2192     wsptr[8*10] = (int) (tmp23 - tmp13);
2193     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
2194     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
2195     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
2196     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
2197     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
2198     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
2199   }
2200
2201   /* Pass 2: process 14 rows from work array, store into output array. */
2202
2203   wsptr = workspace;
2204   for (ctr = 0; ctr < 14; ctr++) {
2205     outptr = output_buf[ctr] + output_col;
2206
2207     /* Even part */
2208
2209     /* Add fudge factor here for final descale. */
2210     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
2211     z1 <<= CONST_BITS;
2212     z4 = (INT32) wsptr[4];
2213     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
2214     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
2215     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
2216
2217     tmp10 = z1 + z2;
2218     tmp11 = z1 + z3;
2219     tmp12 = z1 - z4;
2220
2221     tmp23 = z1 - ((z2 + z3 - z4) << 1);          /* c0 = (c4+c12-c8)*2 */
2222
2223     z1 = (INT32) wsptr[2];
2224     z2 = (INT32) wsptr[6];
2225
2226     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
2227
2228     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
2229     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
2230     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
2231             MULTIPLY(z2, FIX(1.378756276));      /* c2 */
2232
2233     tmp20 = tmp10 + tmp13;
2234     tmp26 = tmp10 - tmp13;
2235     tmp21 = tmp11 + tmp14;
2236     tmp25 = tmp11 - tmp14;
2237     tmp22 = tmp12 + tmp15;
2238     tmp24 = tmp12 - tmp15;
2239
2240     /* Odd part */
2241
2242     z1 = (INT32) wsptr[1];
2243     z2 = (INT32) wsptr[3];
2244     z3 = (INT32) wsptr[5];
2245     z4 = (INT32) wsptr[7];
2246     z4 <<= CONST_BITS;
2247
2248     tmp14 = z1 + z3;
2249     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
2250     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
2251     tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
2252     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
2253     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
2254     z1    -= z2;
2255     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4;           /* c11 */
2256     tmp16 += tmp15;
2257     tmp13 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - z4;    /* -c13 */
2258     tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948));       /* c3-c9-c13 */
2259     tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773));       /* c3+c5-c13 */
2260     tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
2261     tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
2262     tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567));       /* c1+c11-c5 */
2263
2264     tmp13 = ((z1 - z3) << CONST_BITS) + z4;
2265
2266     /* Final output stage */
2267
2268     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2269                                                CONST_BITS+PASS1_BITS+3)
2270                              & RANGE_MASK];
2271     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2272                                                CONST_BITS+PASS1_BITS+3)
2273                              & RANGE_MASK];
2274     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2275                                                CONST_BITS+PASS1_BITS+3)
2276                              & RANGE_MASK];
2277     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2278                                                CONST_BITS+PASS1_BITS+3)
2279                              & RANGE_MASK];
2280     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2281                                                CONST_BITS+PASS1_BITS+3)
2282                              & RANGE_MASK];
2283     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2284                                                CONST_BITS+PASS1_BITS+3)
2285                              & RANGE_MASK];
2286     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2287                                                CONST_BITS+PASS1_BITS+3)
2288                              & RANGE_MASK];
2289     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2290                                                CONST_BITS+PASS1_BITS+3)
2291                              & RANGE_MASK];
2292     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2293                                                CONST_BITS+PASS1_BITS+3)
2294                              & RANGE_MASK];
2295     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2296                                                CONST_BITS+PASS1_BITS+3)
2297                              & RANGE_MASK];
2298     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2299                                                CONST_BITS+PASS1_BITS+3)
2300                              & RANGE_MASK];
2301     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2302                                                CONST_BITS+PASS1_BITS+3)
2303                              & RANGE_MASK];
2304     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
2305                                                CONST_BITS+PASS1_BITS+3)
2306                              & RANGE_MASK];
2307     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
2308                                                CONST_BITS+PASS1_BITS+3)
2309                              & RANGE_MASK];
2310
2311     wsptr += 8;         /* advance pointer to next row */
2312   }
2313 }
2314
2315
2316 /*
2317  * Perform dequantization and inverse DCT on one block of coefficients,
2318  * producing a 15x15 output block.
2319  *
2320  * Optimized algorithm with 22 multiplications in the 1-D kernel.
2321  * cK represents sqrt(2) * cos(K*pi/30).
2322  */
2323
2324 GLOBAL(void)
2325 jpeg_idct_15x15 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2326                  JCOEFPTR coef_block,
2327                  JSAMPARRAY output_buf, JDIMENSION output_col)
2328 {
2329   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
2330   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2331   INT32 z1, z2, z3, z4;
2332   JCOEFPTR inptr;
2333   ISLOW_MULT_TYPE * quantptr;
2334   int * wsptr;
2335   JSAMPROW outptr;
2336   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2337   int ctr;
2338   int workspace[8*15];  /* buffers data between passes */
2339   SHIFT_TEMPS
2340
2341   /* Pass 1: process columns from input, store into work array. */
2342
2343   inptr = coef_block;
2344   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2345   wsptr = workspace;
2346   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2347     /* Even part */
2348
2349     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2350     z1 <<= CONST_BITS;
2351     /* Add fudge factor here for final descale. */
2352     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
2353
2354     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2355     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2356     z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2357
2358     tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
2359     tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
2360
2361     tmp12 = z1 - tmp10;
2362     tmp13 = z1 + tmp11;
2363     z1 -= (tmp11 - tmp10) << 1;             /* c0 = (c6-c12)*2 */
2364
2365     z4 = z2 - z3;
2366     z3 += z2;
2367     tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
2368     tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
2369     z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
2370
2371     tmp20 = tmp13 + tmp10 + tmp11;
2372     tmp23 = tmp12 - tmp10 + tmp11 + z2;
2373
2374     tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
2375     tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
2376
2377     tmp25 = tmp13 - tmp10 - tmp11;
2378     tmp26 = tmp12 + tmp10 - tmp11 - z2;
2379
2380     tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
2381     tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
2382
2383     tmp21 = tmp12 + tmp10 + tmp11;
2384     tmp24 = tmp13 - tmp10 + tmp11;
2385     tmp11 += tmp11;
2386     tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
2387     tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
2388
2389     /* Odd part */
2390
2391     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2392     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2393     z4 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2394     z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
2395     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2396
2397     tmp13 = z2 - z4;
2398     tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
2399     tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
2400     tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
2401
2402     tmp13 = MULTIPLY(z2, - FIX(0.831253876));               /* -c9 */
2403     tmp15 = MULTIPLY(z2, - FIX(1.344997024));               /* -c3 */
2404     z2 = z1 - z4;
2405     tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
2406
2407     tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
2408     tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
2409     tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
2410     z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
2411     tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
2412     tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
2413
2414     /* Final output stage */
2415
2416     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
2417     wsptr[8*14] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
2418     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
2419     wsptr[8*13] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
2420     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
2421     wsptr[8*12] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
2422     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
2423     wsptr[8*11] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
2424     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
2425     wsptr[8*10] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
2426     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
2427     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
2428     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
2429     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
2430     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27, CONST_BITS-PASS1_BITS);
2431   }
2432
2433   /* Pass 2: process 15 rows from work array, store into output array. */
2434
2435   wsptr = workspace;
2436   for (ctr = 0; ctr < 15; ctr++) {
2437     outptr = output_buf[ctr] + output_col;
2438
2439     /* Even part */
2440
2441     /* Add fudge factor here for final descale. */
2442     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
2443     z1 <<= CONST_BITS;
2444
2445     z2 = (INT32) wsptr[2];
2446     z3 = (INT32) wsptr[4];
2447     z4 = (INT32) wsptr[6];
2448
2449     tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
2450     tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
2451
2452     tmp12 = z1 - tmp10;
2453     tmp13 = z1 + tmp11;
2454     z1 -= (tmp11 - tmp10) << 1;             /* c0 = (c6-c12)*2 */
2455
2456     z4 = z2 - z3;
2457     z3 += z2;
2458     tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
2459     tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
2460     z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
2461
2462     tmp20 = tmp13 + tmp10 + tmp11;
2463     tmp23 = tmp12 - tmp10 + tmp11 + z2;
2464
2465     tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
2466     tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
2467
2468     tmp25 = tmp13 - tmp10 - tmp11;
2469     tmp26 = tmp12 + tmp10 - tmp11 - z2;
2470
2471     tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
2472     tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
2473
2474     tmp21 = tmp12 + tmp10 + tmp11;
2475     tmp24 = tmp13 - tmp10 + tmp11;
2476     tmp11 += tmp11;
2477     tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
2478     tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
2479
2480     /* Odd part */
2481
2482     z1 = (INT32) wsptr[1];
2483     z2 = (INT32) wsptr[3];
2484     z4 = (INT32) wsptr[5];
2485     z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
2486     z4 = (INT32) wsptr[7];
2487
2488     tmp13 = z2 - z4;
2489     tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
2490     tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
2491     tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
2492
2493     tmp13 = MULTIPLY(z2, - FIX(0.831253876));               /* -c9 */
2494     tmp15 = MULTIPLY(z2, - FIX(1.344997024));               /* -c3 */
2495     z2 = z1 - z4;
2496     tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
2497
2498     tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
2499     tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
2500     tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
2501     z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
2502     tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
2503     tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
2504
2505     /* Final output stage */
2506
2507     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2508                                                CONST_BITS+PASS1_BITS+3)
2509                              & RANGE_MASK];
2510     outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2511                                                CONST_BITS+PASS1_BITS+3)
2512                              & RANGE_MASK];
2513     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2514                                                CONST_BITS+PASS1_BITS+3)
2515                              & RANGE_MASK];
2516     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2517                                                CONST_BITS+PASS1_BITS+3)
2518                              & RANGE_MASK];
2519     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2520                                                CONST_BITS+PASS1_BITS+3)
2521                              & RANGE_MASK];
2522     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2523                                                CONST_BITS+PASS1_BITS+3)
2524                              & RANGE_MASK];
2525     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2526                                                CONST_BITS+PASS1_BITS+3)
2527                              & RANGE_MASK];
2528     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2529                                                CONST_BITS+PASS1_BITS+3)
2530                              & RANGE_MASK];
2531     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2532                                                CONST_BITS+PASS1_BITS+3)
2533                              & RANGE_MASK];
2534     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2535                                                CONST_BITS+PASS1_BITS+3)
2536                              & RANGE_MASK];
2537     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2538                                                CONST_BITS+PASS1_BITS+3)
2539                              & RANGE_MASK];
2540     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2541                                                CONST_BITS+PASS1_BITS+3)
2542                              & RANGE_MASK];
2543     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
2544                                                CONST_BITS+PASS1_BITS+3)
2545                              & RANGE_MASK];
2546     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
2547                                                CONST_BITS+PASS1_BITS+3)
2548                              & RANGE_MASK];
2549     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27,
2550                                                CONST_BITS+PASS1_BITS+3)
2551                              & RANGE_MASK];
2552
2553     wsptr += 8;         /* advance pointer to next row */
2554   }
2555 }
2556
2557
2558 /*
2559  * Perform dequantization and inverse DCT on one block of coefficients,
2560  * producing a 16x16 output block.
2561  *
2562  * Optimized algorithm with 28 multiplications in the 1-D kernel.
2563  * cK represents sqrt(2) * cos(K*pi/32).
2564  */
2565
2566 GLOBAL(void)
2567 jpeg_idct_16x16 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2568                  JCOEFPTR coef_block,
2569                  JSAMPARRAY output_buf, JDIMENSION output_col)
2570 {
2571   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
2572   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2573   INT32 z1, z2, z3, z4;
2574   JCOEFPTR inptr;
2575   ISLOW_MULT_TYPE * quantptr;
2576   int * wsptr;
2577   JSAMPROW outptr;
2578   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2579   int ctr;
2580   int workspace[8*16];  /* buffers data between passes */
2581   SHIFT_TEMPS
2582
2583   /* Pass 1: process columns from input, store into work array. */
2584
2585   inptr = coef_block;
2586   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2587   wsptr = workspace;
2588   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2589     /* Even part */
2590
2591     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2592     tmp0 <<= CONST_BITS;
2593     /* Add fudge factor here for final descale. */
2594     tmp0 += 1 << (CONST_BITS-PASS1_BITS-1);
2595
2596     z1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2597     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
2598     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
2599
2600     tmp10 = tmp0 + tmp1;
2601     tmp11 = tmp0 - tmp1;
2602     tmp12 = tmp0 + tmp2;
2603     tmp13 = tmp0 - tmp2;
2604
2605     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2606     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2607     z3 = z1 - z2;
2608     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
2609     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
2610
2611     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
2612     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
2613     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
2614     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
2615
2616     tmp20 = tmp10 + tmp0;
2617     tmp27 = tmp10 - tmp0;
2618     tmp21 = tmp12 + tmp1;
2619     tmp26 = tmp12 - tmp1;
2620     tmp22 = tmp13 + tmp2;
2621     tmp25 = tmp13 - tmp2;
2622     tmp23 = tmp11 + tmp3;
2623     tmp24 = tmp11 - tmp3;
2624
2625     /* Odd part */
2626
2627     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2628     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2629     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2630     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2631
2632     tmp11 = z1 + z3;
2633
2634     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
2635     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
2636     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
2637     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
2638     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
2639     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
2640     tmp0  = tmp1 + tmp2 + tmp3 -
2641             MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
2642     tmp13 = tmp10 + tmp11 + tmp12 -
2643             MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
2644     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
2645     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
2646     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
2647     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
2648     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
2649     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
2650     z2    += z4;
2651     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
2652     tmp1  += z1;
2653     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
2654     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
2655     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
2656     tmp12 += z2;
2657     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
2658     tmp2  += z2;
2659     tmp3  += z2;
2660     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
2661     tmp10 += z2;
2662     tmp11 += z2;
2663
2664     /* Final output stage */
2665
2666     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp0,  CONST_BITS-PASS1_BITS);
2667     wsptr[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0,  CONST_BITS-PASS1_BITS);
2668     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp1,  CONST_BITS-PASS1_BITS);
2669     wsptr[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1,  CONST_BITS-PASS1_BITS);
2670     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp2,  CONST_BITS-PASS1_BITS);
2671     wsptr[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2,  CONST_BITS-PASS1_BITS);
2672     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp3,  CONST_BITS-PASS1_BITS);
2673     wsptr[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3,  CONST_BITS-PASS1_BITS);
2674     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
2675     wsptr[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
2676     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
2677     wsptr[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
2678     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
2679     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
2680     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
2681     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
2682   }
2683
2684   /* Pass 2: process 16 rows from work array, store into output array. */
2685
2686   wsptr = workspace;
2687   for (ctr = 0; ctr < 16; ctr++) {
2688     outptr = output_buf[ctr] + output_col;
2689
2690     /* Even part */
2691
2692     /* Add fudge factor here for final descale. */
2693     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
2694     tmp0 <<= CONST_BITS;
2695
2696     z1 = (INT32) wsptr[4];
2697     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
2698     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
2699
2700     tmp10 = tmp0 + tmp1;
2701     tmp11 = tmp0 - tmp1;
2702     tmp12 = tmp0 + tmp2;
2703     tmp13 = tmp0 - tmp2;
2704
2705     z1 = (INT32) wsptr[2];
2706     z2 = (INT32) wsptr[6];
2707     z3 = z1 - z2;
2708     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
2709     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
2710
2711     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
2712     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
2713     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
2714     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
2715
2716     tmp20 = tmp10 + tmp0;
2717     tmp27 = tmp10 - tmp0;
2718     tmp21 = tmp12 + tmp1;
2719     tmp26 = tmp12 - tmp1;
2720     tmp22 = tmp13 + tmp2;
2721     tmp25 = tmp13 - tmp2;
2722     tmp23 = tmp11 + tmp3;
2723     tmp24 = tmp11 - tmp3;
2724
2725     /* Odd part */
2726
2727     z1 = (INT32) wsptr[1];
2728     z2 = (INT32) wsptr[3];
2729     z3 = (INT32) wsptr[5];
2730     z4 = (INT32) wsptr[7];
2731
2732     tmp11 = z1 + z3;
2733
2734     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
2735     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
2736     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
2737     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
2738     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
2739     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
2740     tmp0  = tmp1 + tmp2 + tmp3 -
2741             MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
2742     tmp13 = tmp10 + tmp11 + tmp12 -
2743             MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
2744     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
2745     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
2746     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
2747     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
2748     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
2749     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
2750     z2    += z4;
2751     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
2752     tmp1  += z1;
2753     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
2754     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
2755     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
2756     tmp12 += z2;
2757     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
2758     tmp2  += z2;
2759     tmp3  += z2;
2760     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
2761     tmp10 += z2;
2762     tmp11 += z2;
2763
2764     /* Final output stage */
2765
2766     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp0,
2767                                                CONST_BITS+PASS1_BITS+3)
2768                              & RANGE_MASK];
2769     outptr[15] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp0,
2770                                                CONST_BITS+PASS1_BITS+3)
2771                              & RANGE_MASK];
2772     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp1,
2773                                                CONST_BITS+PASS1_BITS+3)
2774                              & RANGE_MASK];
2775     outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp1,
2776                                                CONST_BITS+PASS1_BITS+3)
2777                              & RANGE_MASK];
2778     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp2,
2779                                                CONST_BITS+PASS1_BITS+3)
2780                              & RANGE_MASK];
2781     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp2,
2782                                                CONST_BITS+PASS1_BITS+3)
2783                              & RANGE_MASK];
2784     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp3,
2785                                                CONST_BITS+PASS1_BITS+3)
2786                              & RANGE_MASK];
2787     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp3,
2788                                                CONST_BITS+PASS1_BITS+3)
2789                              & RANGE_MASK];
2790     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp10,
2791                                                CONST_BITS+PASS1_BITS+3)
2792                              & RANGE_MASK];
2793     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp10,
2794                                                CONST_BITS+PASS1_BITS+3)
2795                              & RANGE_MASK];
2796     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp11,
2797                                                CONST_BITS+PASS1_BITS+3)
2798                              & RANGE_MASK];
2799     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp11,
2800                                                CONST_BITS+PASS1_BITS+3)
2801                              & RANGE_MASK];
2802     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp12,
2803                                                CONST_BITS+PASS1_BITS+3)
2804                              & RANGE_MASK];
2805     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp12,
2806                                                CONST_BITS+PASS1_BITS+3)
2807                              & RANGE_MASK];
2808     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27 + tmp13,
2809                                                CONST_BITS+PASS1_BITS+3)
2810                              & RANGE_MASK];
2811     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp27 - tmp13,
2812                                                CONST_BITS+PASS1_BITS+3)
2813                              & RANGE_MASK];
2814
2815     wsptr += 8;         /* advance pointer to next row */
2816   }
2817 }
2818
2819
2820 /*
2821  * Perform dequantization and inverse DCT on one block of coefficients,
2822  * producing a 16x8 output block.
2823  *
2824  * 8-point IDCT in pass 1 (columns), 16-point in pass 2 (rows).
2825  */
2826
2827 GLOBAL(void)
2828 jpeg_idct_16x8 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2829                 JCOEFPTR coef_block,
2830                 JSAMPARRAY output_buf, JDIMENSION output_col)
2831 {
2832   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
2833   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2834   INT32 z1, z2, z3, z4;
2835   JCOEFPTR inptr;
2836   ISLOW_MULT_TYPE * quantptr;
2837   int * wsptr;
2838   JSAMPROW outptr;
2839   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2840   int ctr;
2841   int workspace[8*8];   /* buffers data between passes */
2842   SHIFT_TEMPS
2843
2844   /* Pass 1: process columns from input, store into work array.
2845    * Note results are scaled up by sqrt(8) compared to a true IDCT;
2846    * furthermore, we scale the results by 2**PASS1_BITS.
2847    * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
2848    */
2849
2850   inptr = coef_block;
2851   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2852   wsptr = workspace;
2853   for (ctr = DCTSIZE; ctr > 0; ctr--) {
2854     /* Due to quantization, we will usually find that many of the input
2855      * coefficients are zero, especially the AC terms.  We can exploit this
2856      * by short-circuiting the IDCT calculation for any column in which all
2857      * the AC terms are zero.  In that case each output is equal to the
2858      * DC coefficient (with scale factor as needed).
2859      * With typical images and quantization tables, half or more of the
2860      * column DCT calculations can be simplified this way.
2861      */
2862
2863     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
2864         inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
2865         inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
2866         inptr[DCTSIZE*7] == 0) {
2867       /* AC terms all zero */
2868       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
2869
2870       wsptr[DCTSIZE*0] = dcval;
2871       wsptr[DCTSIZE*1] = dcval;
2872       wsptr[DCTSIZE*2] = dcval;
2873       wsptr[DCTSIZE*3] = dcval;
2874       wsptr[DCTSIZE*4] = dcval;
2875       wsptr[DCTSIZE*5] = dcval;
2876       wsptr[DCTSIZE*6] = dcval;
2877       wsptr[DCTSIZE*7] = dcval;
2878
2879       inptr++;                  /* advance pointers to next column */
2880       quantptr++;
2881       wsptr++;
2882       continue;
2883     }
2884
2885     /* Even part: reverse the even part of the forward DCT.
2886      * The rotator is c(-6).
2887      */
2888
2889     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2890     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2891
2892     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
2893     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
2894     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
2895
2896     z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2897     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2898     z2 <<= CONST_BITS;
2899     z3 <<= CONST_BITS;
2900     /* Add fudge factor here for final descale. */
2901     z2 += ONE << (CONST_BITS-PASS1_BITS-1);
2902
2903     tmp0 = z2 + z3;
2904     tmp1 = z2 - z3;
2905
2906     tmp10 = tmp0 + tmp2;
2907     tmp13 = tmp0 - tmp2;
2908     tmp11 = tmp1 + tmp3;
2909     tmp12 = tmp1 - tmp3;
2910
2911     /* Odd part per figure 8; the matrix is unitary and hence its
2912      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
2913      */
2914
2915     tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2916     tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2917     tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2918     tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2919
2920     z2 = tmp0 + tmp2;
2921     z3 = tmp1 + tmp3;
2922
2923     z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
2924     z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
2925     z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
2926     z2 += z1;
2927     z3 += z1;
2928
2929     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
2930     tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
2931     tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
2932     tmp0 += z1 + z2;
2933     tmp3 += z1 + z3;
2934
2935     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
2936     tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
2937     tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
2938     tmp1 += z1 + z3;
2939     tmp2 += z1 + z2;
2940
2941     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
2942
2943     wsptr[DCTSIZE*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
2944     wsptr[DCTSIZE*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
2945     wsptr[DCTSIZE*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
2946     wsptr[DCTSIZE*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
2947     wsptr[DCTSIZE*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
2948     wsptr[DCTSIZE*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
2949     wsptr[DCTSIZE*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
2950     wsptr[DCTSIZE*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
2951
2952     inptr++;                    /* advance pointers to next column */
2953     quantptr++;
2954     wsptr++;
2955   }
2956
2957   /* Pass 2: process 8 rows from work array, store into output array.
2958    * 16-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
2959    */
2960
2961   wsptr = workspace;
2962   for (ctr = 0; ctr < 8; ctr++) {
2963     outptr = output_buf[ctr] + output_col;
2964
2965     /* Even part */
2966
2967     /* Add fudge factor here for final descale. */
2968     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
2969     tmp0 <<= CONST_BITS;
2970
2971     z1 = (INT32) wsptr[4];
2972     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
2973     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
2974
2975     tmp10 = tmp0 + tmp1;
2976     tmp11 = tmp0 - tmp1;
2977     tmp12 = tmp0 + tmp2;
2978     tmp13 = tmp0 - tmp2;
2979
2980     z1 = (INT32) wsptr[2];
2981     z2 = (INT32) wsptr[6];
2982     z3 = z1 - z2;
2983     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
2984     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
2985
2986     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
2987     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
2988     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
2989     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
2990
2991     tmp20 = tmp10 + tmp0;
2992     tmp27 = tmp10 - tmp0;
2993     tmp21 = tmp12 + tmp1;
2994     tmp26 = tmp12 - tmp1;
2995     tmp22 = tmp13 + tmp2;
2996     tmp25 = tmp13 - tmp2;
2997     tmp23 = tmp11 + tmp3;
2998     tmp24 = tmp11 - tmp3;
2999
3000     /* Odd part */
3001
3002     z1 = (INT32) wsptr[1];
3003     z2 = (INT32) wsptr[3];
3004     z3 = (INT32) wsptr[5];
3005     z4 = (INT32) wsptr[7];
3006
3007     tmp11 = z1 + z3;
3008
3009     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
3010     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
3011     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
3012     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
3013     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
3014     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
3015     tmp0  = tmp1 + tmp2 + tmp3 -
3016             MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
3017     tmp13 = tmp10 + tmp11 + tmp12 -
3018             MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
3019     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
3020     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
3021     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
3022     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
3023     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
3024     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
3025     z2    += z4;
3026     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
3027     tmp1  += z1;
3028     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
3029     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
3030     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
3031     tmp12 += z2;
3032     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
3033     tmp2  += z2;
3034     tmp3  += z2;
3035     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
3036     tmp10 += z2;
3037     tmp11 += z2;
3038
3039     /* Final output stage */
3040
3041     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp0,
3042                                                CONST_BITS+PASS1_BITS+3)
3043                              & RANGE_MASK];
3044     outptr[15] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp0,
3045                                                CONST_BITS+PASS1_BITS+3)
3046                              & RANGE_MASK];
3047     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp1,
3048                                                CONST_BITS+PASS1_BITS+3)
3049                              & RANGE_MASK];
3050     outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp1,
3051                                                CONST_BITS+PASS1_BITS+3)
3052                              & RANGE_MASK];
3053     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp2,
3054                                                CONST_BITS+PASS1_BITS+3)
3055                              & RANGE_MASK];
3056     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp2,
3057                                                CONST_BITS+PASS1_BITS+3)
3058                              & RANGE_MASK];
3059     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp3,
3060                                                CONST_BITS+PASS1_BITS+3)
3061                              & RANGE_MASK];
3062     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp3,
3063                                                CONST_BITS+PASS1_BITS+3)
3064                              & RANGE_MASK];
3065     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp10,
3066                                                CONST_BITS+PASS1_BITS+3)
3067                              & RANGE_MASK];
3068     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp10,
3069                                                CONST_BITS+PASS1_BITS+3)
3070                              & RANGE_MASK];
3071     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp11,
3072                                                CONST_BITS+PASS1_BITS+3)
3073                              & RANGE_MASK];
3074     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp11,
3075                                                CONST_BITS+PASS1_BITS+3)
3076                              & RANGE_MASK];
3077     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp12,
3078                                                CONST_BITS+PASS1_BITS+3)
3079                              & RANGE_MASK];
3080     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp12,
3081                                                CONST_BITS+PASS1_BITS+3)
3082                              & RANGE_MASK];
3083     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27 + tmp13,
3084                                                CONST_BITS+PASS1_BITS+3)
3085                              & RANGE_MASK];
3086     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp27 - tmp13,
3087                                                CONST_BITS+PASS1_BITS+3)
3088                              & RANGE_MASK];
3089
3090     wsptr += 8;         /* advance pointer to next row */
3091   }
3092 }
3093
3094
3095 /*
3096  * Perform dequantization and inverse DCT on one block of coefficients,
3097  * producing a 14x7 output block.
3098  *
3099  * 7-point IDCT in pass 1 (columns), 14-point in pass 2 (rows).
3100  */
3101
3102 GLOBAL(void)
3103 jpeg_idct_14x7 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3104                 JCOEFPTR coef_block,
3105                 JSAMPARRAY output_buf, JDIMENSION output_col)
3106 {
3107   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
3108   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
3109   INT32 z1, z2, z3, z4;
3110   JCOEFPTR inptr;
3111   ISLOW_MULT_TYPE * quantptr;
3112   int * wsptr;
3113   JSAMPROW outptr;
3114   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3115   int ctr;
3116   int workspace[8*7];   /* buffers data between passes */
3117   SHIFT_TEMPS
3118
3119   /* Pass 1: process columns from input, store into work array.
3120    * 7-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
3121    */
3122
3123   inptr = coef_block;
3124   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3125   wsptr = workspace;
3126   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3127     /* Even part */
3128
3129     tmp23 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3130     tmp23 <<= CONST_BITS;
3131     /* Add fudge factor here for final descale. */
3132     tmp23 += ONE << (CONST_BITS-PASS1_BITS-1);
3133
3134     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3135     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
3136     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
3137
3138     tmp20 = MULTIPLY(z2 - z3, FIX(0.881747734));       /* c4 */
3139     tmp22 = MULTIPLY(z1 - z2, FIX(0.314692123));       /* c6 */
3140     tmp21 = tmp20 + tmp22 + tmp23 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
3141     tmp10 = z1 + z3;
3142     z2 -= tmp10;
3143     tmp10 = MULTIPLY(tmp10, FIX(1.274162392)) + tmp23; /* c2 */
3144     tmp20 += tmp10 - MULTIPLY(z3, FIX(0.077722536));   /* c2-c4-c6 */
3145     tmp22 += tmp10 - MULTIPLY(z1, FIX(2.470602249));   /* c2+c4+c6 */
3146     tmp23 += MULTIPLY(z2, FIX(1.414213562));           /* c0 */
3147
3148     /* Odd part */
3149
3150     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3151     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3152     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
3153
3154     tmp11 = MULTIPLY(z1 + z2, FIX(0.935414347));       /* (c3+c1-c5)/2 */
3155     tmp12 = MULTIPLY(z1 - z2, FIX(0.170262339));       /* (c3+c5-c1)/2 */
3156     tmp10 = tmp11 - tmp12;
3157     tmp11 += tmp12;
3158     tmp12 = MULTIPLY(z2 + z3, - FIX(1.378756276));     /* -c1 */
3159     tmp11 += tmp12;
3160     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));          /* c5 */
3161     tmp10 += z2;
3162     tmp12 += z2 + MULTIPLY(z3, FIX(1.870828693));      /* c3+c1-c5 */
3163
3164     /* Final output stage */
3165
3166     wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
3167     wsptr[8*6] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
3168     wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
3169     wsptr[8*5] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
3170     wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
3171     wsptr[8*4] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
3172     wsptr[8*3] = (int) RIGHT_SHIFT(tmp23, CONST_BITS-PASS1_BITS);
3173   }
3174
3175   /* Pass 2: process 7 rows from work array, store into output array.
3176    * 14-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/28).
3177    */
3178
3179   wsptr = workspace;
3180   for (ctr = 0; ctr < 7; ctr++) {
3181     outptr = output_buf[ctr] + output_col;
3182
3183     /* Even part */
3184
3185     /* Add fudge factor here for final descale. */
3186     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
3187     z1 <<= CONST_BITS;
3188     z4 = (INT32) wsptr[4];
3189     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
3190     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
3191     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
3192
3193     tmp10 = z1 + z2;
3194     tmp11 = z1 + z3;
3195     tmp12 = z1 - z4;
3196
3197     tmp23 = z1 - ((z2 + z3 - z4) << 1);          /* c0 = (c4+c12-c8)*2 */
3198
3199     z1 = (INT32) wsptr[2];
3200     z2 = (INT32) wsptr[6];
3201
3202     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
3203
3204     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
3205     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
3206     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
3207             MULTIPLY(z2, FIX(1.378756276));      /* c2 */
3208
3209     tmp20 = tmp10 + tmp13;
3210     tmp26 = tmp10 - tmp13;
3211     tmp21 = tmp11 + tmp14;
3212     tmp25 = tmp11 - tmp14;
3213     tmp22 = tmp12 + tmp15;
3214     tmp24 = tmp12 - tmp15;
3215
3216     /* Odd part */
3217
3218     z1 = (INT32) wsptr[1];
3219     z2 = (INT32) wsptr[3];
3220     z3 = (INT32) wsptr[5];
3221     z4 = (INT32) wsptr[7];
3222     z4 <<= CONST_BITS;
3223
3224     tmp14 = z1 + z3;
3225     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
3226     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
3227     tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
3228     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
3229     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
3230     z1    -= z2;
3231     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4;           /* c11 */
3232     tmp16 += tmp15;
3233     tmp13 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - z4;    /* -c13 */
3234     tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948));       /* c3-c9-c13 */
3235     tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773));       /* c3+c5-c13 */
3236     tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
3237     tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
3238     tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567));       /* c1+c11-c5 */
3239
3240     tmp13 = ((z1 - z3) << CONST_BITS) + z4;
3241
3242     /* Final output stage */
3243
3244     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
3245                                                CONST_BITS+PASS1_BITS+3)
3246                              & RANGE_MASK];
3247     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
3248                                                CONST_BITS+PASS1_BITS+3)
3249                              & RANGE_MASK];
3250     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
3251                                                CONST_BITS+PASS1_BITS+3)
3252                              & RANGE_MASK];
3253     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
3254                                                CONST_BITS+PASS1_BITS+3)
3255                              & RANGE_MASK];
3256     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
3257                                                CONST_BITS+PASS1_BITS+3)
3258                              & RANGE_MASK];
3259     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
3260                                                CONST_BITS+PASS1_BITS+3)
3261                              & RANGE_MASK];
3262     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
3263                                                CONST_BITS+PASS1_BITS+3)
3264                              & RANGE_MASK];
3265     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
3266                                                CONST_BITS+PASS1_BITS+3)
3267                              & RANGE_MASK];
3268     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
3269                                                CONST_BITS+PASS1_BITS+3)
3270                              & RANGE_MASK];
3271     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
3272                                                CONST_BITS+PASS1_BITS+3)
3273                              & RANGE_MASK];
3274     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
3275                                                CONST_BITS+PASS1_BITS+3)
3276                              & RANGE_MASK];
3277     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
3278                                                CONST_BITS+PASS1_BITS+3)
3279                              & RANGE_MASK];
3280     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
3281                                                CONST_BITS+PASS1_BITS+3)
3282                              & RANGE_MASK];
3283     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
3284                                                CONST_BITS+PASS1_BITS+3)
3285                              & RANGE_MASK];
3286
3287     wsptr += 8;         /* advance pointer to next row */
3288   }
3289 }
3290
3291
3292 /*
3293  * Perform dequantization and inverse DCT on one block of coefficients,
3294  * producing a 12x6 output block.
3295  *
3296  * 6-point IDCT in pass 1 (columns), 12-point in pass 2 (rows).
3297  */
3298
3299 GLOBAL(void)
3300 jpeg_idct_12x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3301                 JCOEFPTR coef_block,
3302                 JSAMPARRAY output_buf, JDIMENSION output_col)
3303 {
3304   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
3305   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
3306   INT32 z1, z2, z3, z4;
3307   JCOEFPTR inptr;
3308   ISLOW_MULT_TYPE * quantptr;
3309   int * wsptr;
3310   JSAMPROW outptr;
3311   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3312   int ctr;
3313   int workspace[8*6];   /* buffers data between passes */
3314   SHIFT_TEMPS
3315
3316   /* Pass 1: process columns from input, store into work array.
3317    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
3318    */
3319
3320   inptr = coef_block;
3321   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3322   wsptr = workspace;
3323   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3324     /* Even part */
3325
3326     tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3327     tmp10 <<= CONST_BITS;
3328     /* Add fudge factor here for final descale. */
3329     tmp10 += ONE << (CONST_BITS-PASS1_BITS-1);
3330     tmp12 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
3331     tmp20 = MULTIPLY(tmp12, FIX(0.707106781));   /* c4 */
3332     tmp11 = tmp10 + tmp20;
3333     tmp21 = RIGHT_SHIFT(tmp10 - tmp20 - tmp20, CONST_BITS-PASS1_BITS);
3334     tmp20 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3335     tmp10 = MULTIPLY(tmp20, FIX(1.224744871));   /* c2 */
3336     tmp20 = tmp11 + tmp10;
3337     tmp22 = tmp11 - tmp10;
3338
3339     /* Odd part */
3340
3341     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3342     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3343     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
3344     tmp11 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
3345     tmp10 = tmp11 + ((z1 + z2) << CONST_BITS);
3346     tmp12 = tmp11 + ((z3 - z2) << CONST_BITS);
3347     tmp11 = (z1 - z2 - z3) << PASS1_BITS;
3348
3349     /* Final output stage */
3350
3351     wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
3352     wsptr[8*5] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
3353     wsptr[8*1] = (int) (tmp21 + tmp11);
3354     wsptr[8*4] = (int) (tmp21 - tmp11);
3355     wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
3356     wsptr[8*3] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
3357   }
3358
3359   /* Pass 2: process 6 rows from work array, store into output array.
3360    * 12-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/24).
3361    */
3362
3363   wsptr = workspace;
3364   for (ctr = 0; ctr < 6; ctr++) {
3365     outptr = output_buf[ctr] + output_col;
3366
3367     /* Even part */
3368
3369     /* Add fudge factor here for final descale. */
3370     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
3371     z3 <<= CONST_BITS;
3372
3373     z4 = (INT32) wsptr[4];
3374     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
3375
3376     tmp10 = z3 + z4;
3377     tmp11 = z3 - z4;
3378
3379     z1 = (INT32) wsptr[2];
3380     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
3381     z1 <<= CONST_BITS;
3382     z2 = (INT32) wsptr[6];
3383     z2 <<= CONST_BITS;
3384
3385     tmp12 = z1 - z2;
3386
3387     tmp21 = z3 + tmp12;
3388     tmp24 = z3 - tmp12;
3389
3390     tmp12 = z4 + z2;
3391
3392     tmp20 = tmp10 + tmp12;
3393     tmp25 = tmp10 - tmp12;
3394
3395     tmp12 = z4 - z1 - z2;
3396
3397     tmp22 = tmp11 + tmp12;
3398     tmp23 = tmp11 - tmp12;
3399
3400     /* Odd part */
3401
3402     z1 = (INT32) wsptr[1];
3403     z2 = (INT32) wsptr[3];
3404     z3 = (INT32) wsptr[5];
3405     z4 = (INT32) wsptr[7];
3406
3407     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
3408     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
3409
3410     tmp10 = z1 + z3;
3411     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
3412     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
3413     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
3414     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
3415     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
3416     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
3417     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
3418              MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
3419
3420     z1 -= z4;
3421     z2 -= z3;
3422     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
3423     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
3424     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
3425
3426     /* Final output stage */
3427
3428     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
3429                                                CONST_BITS+PASS1_BITS+3)
3430                              & RANGE_MASK];
3431     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
3432                                                CONST_BITS+PASS1_BITS+3)
3433                              & RANGE_MASK];
3434     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
3435                                                CONST_BITS+PASS1_BITS+3)
3436                              & RANGE_MASK];
3437     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
3438                                                CONST_BITS+PASS1_BITS+3)
3439                              & RANGE_MASK];
3440     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
3441                                                CONST_BITS+PASS1_BITS+3)
3442                              & RANGE_MASK];
3443     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
3444                                                CONST_BITS+PASS1_BITS+3)
3445                              & RANGE_MASK];
3446     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
3447                                                CONST_BITS+PASS1_BITS+3)
3448                              & RANGE_MASK];
3449     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
3450                                                CONST_BITS+PASS1_BITS+3)
3451                              & RANGE_MASK];
3452     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
3453                                                CONST_BITS+PASS1_BITS+3)
3454                              & RANGE_MASK];
3455     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
3456                                                CONST_BITS+PASS1_BITS+3)
3457                              & RANGE_MASK];
3458     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
3459                                                CONST_BITS+PASS1_BITS+3)
3460                              & RANGE_MASK];
3461     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
3462                                                CONST_BITS+PASS1_BITS+3)
3463                              & RANGE_MASK];
3464
3465     wsptr += 8;         /* advance pointer to next row */
3466   }
3467 }
3468
3469
3470 /*
3471  * Perform dequantization and inverse DCT on one block of coefficients,
3472  * producing a 10x5 output block.
3473  *
3474  * 5-point IDCT in pass 1 (columns), 10-point in pass 2 (rows).
3475  */
3476
3477 GLOBAL(void)
3478 jpeg_idct_10x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3479                 JCOEFPTR coef_block,
3480                 JSAMPARRAY output_buf, JDIMENSION output_col)
3481 {
3482   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
3483   INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
3484   INT32 z1, z2, z3, z4;
3485   JCOEFPTR inptr;
3486   ISLOW_MULT_TYPE * quantptr;
3487   int * wsptr;
3488   JSAMPROW outptr;
3489   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3490   int ctr;
3491   int workspace[8*5];   /* buffers data between passes */
3492   SHIFT_TEMPS
3493
3494   /* Pass 1: process columns from input, store into work array.
3495    * 5-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
3496    */
3497
3498   inptr = coef_block;
3499   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3500   wsptr = workspace;
3501   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3502     /* Even part */
3503
3504     tmp12 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3505     tmp12 <<= CONST_BITS;
3506     /* Add fudge factor here for final descale. */
3507     tmp12 += ONE << (CONST_BITS-PASS1_BITS-1);
3508     tmp13 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3509     tmp14 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
3510     z1 = MULTIPLY(tmp13 + tmp14, FIX(0.790569415)); /* (c2+c4)/2 */
3511     z2 = MULTIPLY(tmp13 - tmp14, FIX(0.353553391)); /* (c2-c4)/2 */
3512     z3 = tmp12 + z2;
3513     tmp10 = z3 + z1;
3514     tmp11 = z3 - z1;
3515     tmp12 -= z2 << 2;
3516
3517     /* Odd part */
3518
3519     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3520     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3521
3522     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));       /* c3 */
3523     tmp13 = z1 + MULTIPLY(z2, FIX(0.513743148));    /* c1-c3 */
3524     tmp14 = z1 - MULTIPLY(z3, FIX(2.176250899));    /* c1+c3 */
3525
3526     /* Final output stage */
3527
3528     wsptr[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp13, CONST_BITS-PASS1_BITS);
3529     wsptr[8*4] = (int) RIGHT_SHIFT(tmp10 - tmp13, CONST_BITS-PASS1_BITS);
3530     wsptr[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp14, CONST_BITS-PASS1_BITS);
3531     wsptr[8*3] = (int) RIGHT_SHIFT(tmp11 - tmp14, CONST_BITS-PASS1_BITS);
3532     wsptr[8*2] = (int) RIGHT_SHIFT(tmp12, CONST_BITS-PASS1_BITS);
3533   }
3534
3535   /* Pass 2: process 5 rows from work array, store into output array.
3536    * 10-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/20).
3537    */
3538
3539   wsptr = workspace;
3540   for (ctr = 0; ctr < 5; ctr++) {
3541     outptr = output_buf[ctr] + output_col;
3542
3543     /* Even part */
3544
3545     /* Add fudge factor here for final descale. */
3546     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
3547     z3 <<= CONST_BITS;
3548     z4 = (INT32) wsptr[4];
3549     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
3550     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
3551     tmp10 = z3 + z1;
3552     tmp11 = z3 - z2;
3553
3554     tmp22 = z3 - ((z1 - z2) << 1);               /* c0 = (c4-c8)*2 */
3555
3556     z2 = (INT32) wsptr[2];
3557     z3 = (INT32) wsptr[6];
3558
3559     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
3560     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
3561     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
3562
3563     tmp20 = tmp10 + tmp12;
3564     tmp24 = tmp10 - tmp12;
3565     tmp21 = tmp11 + tmp13;
3566     tmp23 = tmp11 - tmp13;
3567
3568     /* Odd part */
3569
3570     z1 = (INT32) wsptr[1];
3571     z2 = (INT32) wsptr[3];
3572     z3 = (INT32) wsptr[5];
3573     z3 <<= CONST_BITS;
3574     z4 = (INT32) wsptr[7];
3575
3576     tmp11 = z2 + z4;
3577     tmp13 = z2 - z4;
3578
3579     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
3580
3581     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
3582     z4 = z3 + tmp12;
3583
3584     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
3585     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
3586
3587     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
3588     z4 = z3 - tmp12 - (tmp13 << (CONST_BITS - 1));
3589
3590     tmp12 = ((z1 - tmp13) << CONST_BITS) - z3;
3591
3592     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
3593     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
3594
3595     /* Final output stage */
3596
3597     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
3598                                               CONST_BITS+PASS1_BITS+3)
3599                             & RANGE_MASK];
3600     outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
3601                                               CONST_BITS+PASS1_BITS+3)
3602                             & RANGE_MASK];
3603     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
3604                                               CONST_BITS+PASS1_BITS+3)
3605                             & RANGE_MASK];
3606     outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
3607                                               CONST_BITS+PASS1_BITS+3)
3608                             & RANGE_MASK];
3609     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
3610                                               CONST_BITS+PASS1_BITS+3)
3611                             & RANGE_MASK];
3612     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
3613                                               CONST_BITS+PASS1_BITS+3)
3614                             & RANGE_MASK];
3615     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
3616                                               CONST_BITS+PASS1_BITS+3)
3617                             & RANGE_MASK];
3618     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
3619                                               CONST_BITS+PASS1_BITS+3)
3620                             & RANGE_MASK];
3621     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
3622                                               CONST_BITS+PASS1_BITS+3)
3623                             & RANGE_MASK];
3624     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
3625                                               CONST_BITS+PASS1_BITS+3)
3626                             & RANGE_MASK];
3627
3628     wsptr += 8;         /* advance pointer to next row */
3629   }
3630 }
3631
3632
3633 /*
3634  * Perform dequantization and inverse DCT on one block of coefficients,
3635  * producing a 8x4 output block.
3636  *
3637  * 4-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
3638  */
3639
3640 GLOBAL(void)
3641 jpeg_idct_8x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3642                JCOEFPTR coef_block,
3643                JSAMPARRAY output_buf, JDIMENSION output_col)
3644 {
3645   INT32 tmp0, tmp1, tmp2, tmp3;
3646   INT32 tmp10, tmp11, tmp12, tmp13;
3647   INT32 z1, z2, z3;
3648   JCOEFPTR inptr;
3649   ISLOW_MULT_TYPE * quantptr;
3650   int * wsptr;
3651   JSAMPROW outptr;
3652   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3653   int ctr;
3654   int workspace[8*4];   /* buffers data between passes */
3655   SHIFT_TEMPS
3656
3657   /* Pass 1: process columns from input, store into work array.
3658    * 4-point IDCT kernel,
3659    * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
3660    */
3661
3662   inptr = coef_block;
3663   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3664   wsptr = workspace;
3665   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3666     /* Even part */
3667
3668     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3669     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3670
3671     tmp10 = (tmp0 + tmp2) << PASS1_BITS;
3672     tmp12 = (tmp0 - tmp2) << PASS1_BITS;
3673
3674     /* Odd part */
3675     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
3676
3677     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3678     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3679
3680     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);               /* c6 */
3681     /* Add fudge factor here for final descale. */
3682     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
3683     tmp0 = RIGHT_SHIFT(z1 + MULTIPLY(z2, FIX_0_765366865), /* c2-c6 */
3684                        CONST_BITS-PASS1_BITS);
3685     tmp2 = RIGHT_SHIFT(z1 - MULTIPLY(z3, FIX_1_847759065), /* c2+c6 */
3686                        CONST_BITS-PASS1_BITS);
3687
3688     /* Final output stage */
3689
3690     wsptr[8*0] = (int) (tmp10 + tmp0);
3691     wsptr[8*3] = (int) (tmp10 - tmp0);
3692     wsptr[8*1] = (int) (tmp12 + tmp2);
3693     wsptr[8*2] = (int) (tmp12 - tmp2);
3694   }
3695
3696   /* Pass 2: process rows from work array, store into output array.
3697    * Note that we must descale the results by a factor of 8 == 2**3,
3698    * and also undo the PASS1_BITS scaling.
3699    * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
3700    */
3701
3702   wsptr = workspace;
3703   for (ctr = 0; ctr < 4; ctr++) {
3704     outptr = output_buf[ctr] + output_col;
3705
3706     /* Even part: reverse the even part of the forward DCT.
3707      * The rotator is c(-6).
3708      */
3709
3710     z2 = (INT32) wsptr[2];
3711     z3 = (INT32) wsptr[6];
3712
3713     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
3714     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
3715     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
3716
3717     /* Add fudge factor here for final descale. */
3718     z2 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
3719     z3 = (INT32) wsptr[4];
3720
3721     tmp0 = (z2 + z3) << CONST_BITS;
3722     tmp1 = (z2 - z3) << CONST_BITS;
3723
3724     tmp10 = tmp0 + tmp2;
3725     tmp13 = tmp0 - tmp2;
3726     tmp11 = tmp1 + tmp3;
3727     tmp12 = tmp1 - tmp3;
3728
3729     /* Odd part per figure 8; the matrix is unitary and hence its
3730      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
3731      */
3732
3733     tmp0 = (INT32) wsptr[7];
3734     tmp1 = (INT32) wsptr[5];
3735     tmp2 = (INT32) wsptr[3];
3736     tmp3 = (INT32) wsptr[1];
3737
3738     z2 = tmp0 + tmp2;
3739     z3 = tmp1 + tmp3;
3740
3741     z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
3742     z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
3743     z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
3744     z2 += z1;
3745     z3 += z1;
3746
3747     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
3748     tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
3749     tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
3750     tmp0 += z1 + z2;
3751     tmp3 += z1 + z3;
3752
3753     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
3754     tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
3755     tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
3756     tmp1 += z1 + z3;
3757     tmp2 += z1 + z2;
3758
3759     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
3760
3761     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
3762                                               CONST_BITS+PASS1_BITS+3)
3763                             & RANGE_MASK];
3764     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
3765                                               CONST_BITS+PASS1_BITS+3)
3766                             & RANGE_MASK];
3767     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
3768                                               CONST_BITS+PASS1_BITS+3)
3769                             & RANGE_MASK];
3770     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
3771                                               CONST_BITS+PASS1_BITS+3)
3772                             & RANGE_MASK];
3773     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
3774                                               CONST_BITS+PASS1_BITS+3)
3775                             & RANGE_MASK];
3776     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
3777                                               CONST_BITS+PASS1_BITS+3)
3778                             & RANGE_MASK];
3779     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
3780                                               CONST_BITS+PASS1_BITS+3)
3781                             & RANGE_MASK];
3782     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
3783                                               CONST_BITS+PASS1_BITS+3)
3784                             & RANGE_MASK];
3785
3786     wsptr += DCTSIZE;           /* advance pointer to next row */
3787   }
3788 }
3789
3790
3791 /*
3792  * Perform dequantization and inverse DCT on one block of coefficients,
3793  * producing a reduced-size 6x3 output block.
3794  *
3795  * 3-point IDCT in pass 1 (columns), 6-point in pass 2 (rows).
3796  */
3797
3798 GLOBAL(void)
3799 jpeg_idct_6x3 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3800                JCOEFPTR coef_block,
3801                JSAMPARRAY output_buf, JDIMENSION output_col)
3802 {
3803   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
3804   INT32 z1, z2, z3;
3805   JCOEFPTR inptr;
3806   ISLOW_MULT_TYPE * quantptr;
3807   int * wsptr;
3808   JSAMPROW outptr;
3809   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3810   int ctr;
3811   int workspace[6*3];   /* buffers data between passes */
3812   SHIFT_TEMPS
3813
3814   /* Pass 1: process columns from input, store into work array.
3815    * 3-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
3816    */
3817
3818   inptr = coef_block;
3819   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3820   wsptr = workspace;
3821   for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
3822     /* Even part */
3823
3824     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3825     tmp0 <<= CONST_BITS;
3826     /* Add fudge factor here for final descale. */
3827     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
3828     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3829     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
3830     tmp10 = tmp0 + tmp12;
3831     tmp2 = tmp0 - tmp12 - tmp12;
3832
3833     /* Odd part */
3834
3835     tmp12 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3836     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
3837
3838     /* Final output stage */
3839
3840     wsptr[6*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
3841     wsptr[6*2] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
3842     wsptr[6*1] = (int) RIGHT_SHIFT(tmp2, CONST_BITS-PASS1_BITS);
3843   }
3844
3845   /* Pass 2: process 3 rows from work array, store into output array.
3846    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
3847    */
3848
3849   wsptr = workspace;
3850   for (ctr = 0; ctr < 3; ctr++) {
3851     outptr = output_buf[ctr] + output_col;
3852
3853     /* Even part */
3854
3855     /* Add fudge factor here for final descale. */
3856     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
3857     tmp0 <<= CONST_BITS;
3858     tmp2 = (INT32) wsptr[4];
3859     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
3860     tmp1 = tmp0 + tmp10;
3861     tmp11 = tmp0 - tmp10 - tmp10;
3862     tmp10 = (INT32) wsptr[2];
3863     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
3864     tmp10 = tmp1 + tmp0;
3865     tmp12 = tmp1 - tmp0;
3866
3867     /* Odd part */
3868
3869     z1 = (INT32) wsptr[1];
3870     z2 = (INT32) wsptr[3];
3871     z3 = (INT32) wsptr[5];
3872     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
3873     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
3874     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
3875     tmp1 = (z1 - z2 - z3) << CONST_BITS;
3876
3877     /* Final output stage */
3878
3879     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
3880                                               CONST_BITS+PASS1_BITS+3)
3881                             & RANGE_MASK];
3882     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
3883                                               CONST_BITS+PASS1_BITS+3)
3884                             & RANGE_MASK];
3885     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
3886                                               CONST_BITS+PASS1_BITS+3)
3887                             & RANGE_MASK];
3888     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
3889                                               CONST_BITS+PASS1_BITS+3)
3890                             & RANGE_MASK];
3891     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
3892                                               CONST_BITS+PASS1_BITS+3)
3893                             & RANGE_MASK];
3894     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
3895                                               CONST_BITS+PASS1_BITS+3)
3896                             & RANGE_MASK];
3897
3898     wsptr += 6;         /* advance pointer to next row */
3899   }
3900 }
3901
3902
3903 /*
3904  * Perform dequantization and inverse DCT on one block of coefficients,
3905  * producing a 4x2 output block.
3906  *
3907  * 2-point IDCT in pass 1 (columns), 4-point in pass 2 (rows).
3908  */
3909
3910 GLOBAL(void)
3911 jpeg_idct_4x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3912                JCOEFPTR coef_block,
3913                JSAMPARRAY output_buf, JDIMENSION output_col)
3914 {
3915   INT32 tmp0, tmp2, tmp10, tmp12;
3916   INT32 z1, z2, z3;
3917   JCOEFPTR inptr;
3918   ISLOW_MULT_TYPE * quantptr;
3919   INT32 * wsptr;
3920   JSAMPROW outptr;
3921   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3922   int ctr;
3923   INT32 workspace[4*2]; /* buffers data between passes */
3924   SHIFT_TEMPS
3925
3926   /* Pass 1: process columns from input, store into work array. */
3927
3928   inptr = coef_block;
3929   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3930   wsptr = workspace;
3931   for (ctr = 0; ctr < 4; ctr++, inptr++, quantptr++, wsptr++) {
3932     /* Even part */
3933
3934     tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3935
3936     /* Odd part */
3937
3938     tmp0 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3939
3940     /* Final output stage */
3941
3942     wsptr[4*0] = tmp10 + tmp0;
3943     wsptr[4*1] = tmp10 - tmp0;
3944   }
3945
3946   /* Pass 2: process 2 rows from work array, store into output array.
3947    * 4-point IDCT kernel,
3948    * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
3949    */
3950
3951   wsptr = workspace;
3952   for (ctr = 0; ctr < 2; ctr++) {
3953     outptr = output_buf[ctr] + output_col;
3954
3955     /* Even part */
3956
3957     /* Add fudge factor here for final descale. */
3958     tmp0 = wsptr[0] + (ONE << 2);
3959     tmp2 = wsptr[2];
3960
3961     tmp10 = (tmp0 + tmp2) << CONST_BITS;
3962     tmp12 = (tmp0 - tmp2) << CONST_BITS;
3963
3964     /* Odd part */
3965     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
3966
3967     z2 = wsptr[1];
3968     z3 = wsptr[3];
3969
3970     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
3971     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
3972     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
3973
3974     /* Final output stage */
3975
3976     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
3977                                               CONST_BITS+3)
3978                             & RANGE_MASK];
3979     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
3980                                               CONST_BITS+3)
3981                             & RANGE_MASK];
3982     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
3983                                               CONST_BITS+3)
3984                             & RANGE_MASK];
3985     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
3986                                               CONST_BITS+3)
3987                             & RANGE_MASK];
3988
3989     wsptr += 4;         /* advance pointer to next row */
3990   }
3991 }
3992
3993
3994 /*
3995  * Perform dequantization and inverse DCT on one block of coefficients,
3996  * producing a 2x1 output block.
3997  *
3998  * 1-point IDCT in pass 1 (columns), 2-point in pass 2 (rows).
3999  */
4000
4001 GLOBAL(void)
4002 jpeg_idct_2x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4003                JCOEFPTR coef_block,
4004                JSAMPARRAY output_buf, JDIMENSION output_col)
4005 {
4006   INT32 tmp0, tmp1;
4007   ISLOW_MULT_TYPE * quantptr;
4008   JSAMPROW outptr;
4009   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4010   SHIFT_TEMPS
4011
4012   /* Pass 1: empty. */
4013
4014   /* Pass 2: process 1 row from input, store into output array. */
4015
4016   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4017   outptr = output_buf[0] + output_col;
4018
4019   /* Even part */
4020
4021   tmp0 = DEQUANTIZE(coef_block[0], quantptr[0]);
4022   /* Add fudge factor here for final descale. */
4023   tmp0 += ONE << 2;
4024
4025   /* Odd part */
4026
4027   tmp1 = DEQUANTIZE(coef_block[1], quantptr[1]);
4028
4029   /* Final output stage */
4030
4031   outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp0 + tmp1, 3) & RANGE_MASK];
4032   outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp0 - tmp1, 3) & RANGE_MASK];
4033 }
4034
4035
4036 /*
4037  * Perform dequantization and inverse DCT on one block of coefficients,
4038  * producing a 8x16 output block.
4039  *
4040  * 16-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
4041  */
4042
4043 GLOBAL(void)
4044 jpeg_idct_8x16 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4045                 JCOEFPTR coef_block,
4046                 JSAMPARRAY output_buf, JDIMENSION output_col)
4047 {
4048   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
4049   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
4050   INT32 z1, z2, z3, z4;
4051   JCOEFPTR inptr;
4052   ISLOW_MULT_TYPE * quantptr;
4053   int * wsptr;
4054   JSAMPROW outptr;
4055   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4056   int ctr;
4057   int workspace[8*16];  /* buffers data between passes */
4058   SHIFT_TEMPS
4059
4060   /* Pass 1: process columns from input, store into work array.
4061    * 16-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
4062    */
4063
4064   inptr = coef_block;
4065   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4066   wsptr = workspace;
4067   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
4068     /* Even part */
4069
4070     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4071     tmp0 <<= CONST_BITS;
4072     /* Add fudge factor here for final descale. */
4073     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
4074
4075     z1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4076     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
4077     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
4078
4079     tmp10 = tmp0 + tmp1;
4080     tmp11 = tmp0 - tmp1;
4081     tmp12 = tmp0 + tmp2;
4082     tmp13 = tmp0 - tmp2;
4083
4084     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4085     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4086     z3 = z1 - z2;
4087     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
4088     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
4089
4090     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
4091     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
4092     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
4093     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
4094
4095     tmp20 = tmp10 + tmp0;
4096     tmp27 = tmp10 - tmp0;
4097     tmp21 = tmp12 + tmp1;
4098     tmp26 = tmp12 - tmp1;
4099     tmp22 = tmp13 + tmp2;
4100     tmp25 = tmp13 - tmp2;
4101     tmp23 = tmp11 + tmp3;
4102     tmp24 = tmp11 - tmp3;
4103
4104     /* Odd part */
4105
4106     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4107     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4108     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4109     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4110
4111     tmp11 = z1 + z3;
4112
4113     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
4114     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
4115     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
4116     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
4117     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
4118     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
4119     tmp0  = tmp1 + tmp2 + tmp3 -
4120             MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
4121     tmp13 = tmp10 + tmp11 + tmp12 -
4122             MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
4123     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
4124     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
4125     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
4126     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
4127     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
4128     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
4129     z2    += z4;
4130     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
4131     tmp1  += z1;
4132     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
4133     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
4134     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
4135     tmp12 += z2;
4136     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
4137     tmp2  += z2;
4138     tmp3  += z2;
4139     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
4140     tmp10 += z2;
4141     tmp11 += z2;
4142
4143     /* Final output stage */
4144
4145     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp0,  CONST_BITS-PASS1_BITS);
4146     wsptr[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0,  CONST_BITS-PASS1_BITS);
4147     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp1,  CONST_BITS-PASS1_BITS);
4148     wsptr[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1,  CONST_BITS-PASS1_BITS);
4149     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp2,  CONST_BITS-PASS1_BITS);
4150     wsptr[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2,  CONST_BITS-PASS1_BITS);
4151     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp3,  CONST_BITS-PASS1_BITS);
4152     wsptr[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3,  CONST_BITS-PASS1_BITS);
4153     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
4154     wsptr[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
4155     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
4156     wsptr[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
4157     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
4158     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
4159     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
4160     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
4161   }
4162
4163   /* Pass 2: process rows from work array, store into output array.
4164    * Note that we must descale the results by a factor of 8 == 2**3,
4165    * and also undo the PASS1_BITS scaling.
4166    * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
4167    */
4168
4169   wsptr = workspace;
4170   for (ctr = 0; ctr < 16; ctr++) {
4171     outptr = output_buf[ctr] + output_col;
4172
4173     /* Even part: reverse the even part of the forward DCT.
4174      * The rotator is c(-6).
4175      */
4176
4177     z2 = (INT32) wsptr[2];
4178     z3 = (INT32) wsptr[6];
4179
4180     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
4181     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
4182     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
4183
4184     /* Add fudge factor here for final descale. */
4185     z2 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
4186     z3 = (INT32) wsptr[4];
4187
4188     tmp0 = (z2 + z3) << CONST_BITS;
4189     tmp1 = (z2 - z3) << CONST_BITS;
4190
4191     tmp10 = tmp0 + tmp2;
4192     tmp13 = tmp0 - tmp2;
4193     tmp11 = tmp1 + tmp3;
4194     tmp12 = tmp1 - tmp3;
4195
4196     /* Odd part per figure 8; the matrix is unitary and hence its
4197      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
4198      */
4199
4200     tmp0 = (INT32) wsptr[7];
4201     tmp1 = (INT32) wsptr[5];
4202     tmp2 = (INT32) wsptr[3];
4203     tmp3 = (INT32) wsptr[1];
4204
4205     z2 = tmp0 + tmp2;
4206     z3 = tmp1 + tmp3;
4207
4208     z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
4209     z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
4210     z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
4211     z2 += z1;
4212     z3 += z1;
4213
4214     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
4215     tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
4216     tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
4217     tmp0 += z1 + z2;
4218     tmp3 += z1 + z3;
4219
4220     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
4221     tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
4222     tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
4223     tmp1 += z1 + z3;
4224     tmp2 += z1 + z2;
4225
4226     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
4227
4228     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
4229                                               CONST_BITS+PASS1_BITS+3)
4230                             & RANGE_MASK];
4231     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
4232                                               CONST_BITS+PASS1_BITS+3)
4233                             & RANGE_MASK];
4234     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
4235                                               CONST_BITS+PASS1_BITS+3)
4236                             & RANGE_MASK];
4237     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
4238                                               CONST_BITS+PASS1_BITS+3)
4239                             & RANGE_MASK];
4240     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
4241                                               CONST_BITS+PASS1_BITS+3)
4242                             & RANGE_MASK];
4243     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
4244                                               CONST_BITS+PASS1_BITS+3)
4245                             & RANGE_MASK];
4246     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
4247                                               CONST_BITS+PASS1_BITS+3)
4248                             & RANGE_MASK];
4249     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
4250                                               CONST_BITS+PASS1_BITS+3)
4251                             & RANGE_MASK];
4252
4253     wsptr += DCTSIZE;           /* advance pointer to next row */
4254   }
4255 }
4256
4257
4258 /*
4259  * Perform dequantization and inverse DCT on one block of coefficients,
4260  * producing a 7x14 output block.
4261  *
4262  * 14-point IDCT in pass 1 (columns), 7-point in pass 2 (rows).
4263  */
4264
4265 GLOBAL(void)
4266 jpeg_idct_7x14 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4267                 JCOEFPTR coef_block,
4268                 JSAMPARRAY output_buf, JDIMENSION output_col)
4269 {
4270   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
4271   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
4272   INT32 z1, z2, z3, z4;
4273   JCOEFPTR inptr;
4274   ISLOW_MULT_TYPE * quantptr;
4275   int * wsptr;
4276   JSAMPROW outptr;
4277   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4278   int ctr;
4279   int workspace[7*14];  /* buffers data between passes */
4280   SHIFT_TEMPS
4281
4282   /* Pass 1: process columns from input, store into work array.
4283    * 14-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/28).
4284    */
4285
4286   inptr = coef_block;
4287   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4288   wsptr = workspace;
4289   for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
4290     /* Even part */
4291
4292     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4293     z1 <<= CONST_BITS;
4294     /* Add fudge factor here for final descale. */
4295     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
4296     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4297     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
4298     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
4299     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
4300
4301     tmp10 = z1 + z2;
4302     tmp11 = z1 + z3;
4303     tmp12 = z1 - z4;
4304
4305     tmp23 = RIGHT_SHIFT(z1 - ((z2 + z3 - z4) << 1), /* c0 = (c4+c12-c8)*2 */
4306                         CONST_BITS-PASS1_BITS);
4307
4308     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4309     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4310
4311     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
4312
4313     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
4314     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
4315     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
4316             MULTIPLY(z2, FIX(1.378756276));      /* c2 */
4317
4318     tmp20 = tmp10 + tmp13;
4319     tmp26 = tmp10 - tmp13;
4320     tmp21 = tmp11 + tmp14;
4321     tmp25 = tmp11 - tmp14;
4322     tmp22 = tmp12 + tmp15;
4323     tmp24 = tmp12 - tmp15;
4324
4325     /* Odd part */
4326
4327     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4328     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4329     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4330     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4331     tmp13 = z4 << CONST_BITS;
4332
4333     tmp14 = z1 + z3;
4334     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
4335     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
4336     tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
4337     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
4338     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
4339     z1    -= z2;
4340     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13;        /* c11 */
4341     tmp16 += tmp15;
4342     z1    += z4;
4343     z4    = MULTIPLY(z2 + z3, - FIX(0.158341681)) - tmp13; /* -c13 */
4344     tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948));          /* c3-c9-c13 */
4345     tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773));          /* c3+c5-c13 */
4346     z4    = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
4347     tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
4348     tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567));          /* c1+c11-c5 */
4349
4350     tmp13 = (z1 - z3) << PASS1_BITS;
4351
4352     /* Final output stage */
4353
4354     wsptr[7*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
4355     wsptr[7*13] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
4356     wsptr[7*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
4357     wsptr[7*12] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
4358     wsptr[7*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
4359     wsptr[7*11] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
4360     wsptr[7*3]  = (int) (tmp23 + tmp13);
4361     wsptr[7*10] = (int) (tmp23 - tmp13);
4362     wsptr[7*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
4363     wsptr[7*9]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
4364     wsptr[7*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
4365     wsptr[7*8]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
4366     wsptr[7*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
4367     wsptr[7*7]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
4368   }
4369
4370   /* Pass 2: process 14 rows from work array, store into output array.
4371    * 7-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
4372    */
4373
4374   wsptr = workspace;
4375   for (ctr = 0; ctr < 14; ctr++) {
4376     outptr = output_buf[ctr] + output_col;
4377
4378     /* Even part */
4379
4380     /* Add fudge factor here for final descale. */
4381     tmp23 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
4382     tmp23 <<= CONST_BITS;
4383
4384     z1 = (INT32) wsptr[2];
4385     z2 = (INT32) wsptr[4];
4386     z3 = (INT32) wsptr[6];
4387
4388     tmp20 = MULTIPLY(z2 - z3, FIX(0.881747734));       /* c4 */
4389     tmp22 = MULTIPLY(z1 - z2, FIX(0.314692123));       /* c6 */
4390     tmp21 = tmp20 + tmp22 + tmp23 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
4391     tmp10 = z1 + z3;
4392     z2 -= tmp10;
4393     tmp10 = MULTIPLY(tmp10, FIX(1.274162392)) + tmp23; /* c2 */
4394     tmp20 += tmp10 - MULTIPLY(z3, FIX(0.077722536));   /* c2-c4-c6 */
4395     tmp22 += tmp10 - MULTIPLY(z1, FIX(2.470602249));   /* c2+c4+c6 */
4396     tmp23 += MULTIPLY(z2, FIX(1.414213562));           /* c0 */
4397
4398     /* Odd part */
4399
4400     z1 = (INT32) wsptr[1];
4401     z2 = (INT32) wsptr[3];
4402     z3 = (INT32) wsptr[5];
4403
4404     tmp11 = MULTIPLY(z1 + z2, FIX(0.935414347));       /* (c3+c1-c5)/2 */
4405     tmp12 = MULTIPLY(z1 - z2, FIX(0.170262339));       /* (c3+c5-c1)/2 */
4406     tmp10 = tmp11 - tmp12;
4407     tmp11 += tmp12;
4408     tmp12 = MULTIPLY(z2 + z3, - FIX(1.378756276));     /* -c1 */
4409     tmp11 += tmp12;
4410     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));          /* c5 */
4411     tmp10 += z2;
4412     tmp12 += z2 + MULTIPLY(z3, FIX(1.870828693));      /* c3+c1-c5 */
4413
4414     /* Final output stage */
4415
4416     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
4417                                               CONST_BITS+PASS1_BITS+3)
4418                             & RANGE_MASK];
4419     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
4420                                               CONST_BITS+PASS1_BITS+3)
4421                             & RANGE_MASK];
4422     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
4423                                               CONST_BITS+PASS1_BITS+3)
4424                             & RANGE_MASK];
4425     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
4426                                               CONST_BITS+PASS1_BITS+3)
4427                             & RANGE_MASK];
4428     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
4429                                               CONST_BITS+PASS1_BITS+3)
4430                             & RANGE_MASK];
4431     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
4432                                               CONST_BITS+PASS1_BITS+3)
4433                             & RANGE_MASK];
4434     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23,
4435                                               CONST_BITS+PASS1_BITS+3)
4436                             & RANGE_MASK];
4437
4438     wsptr += 7;         /* advance pointer to next row */
4439   }
4440 }
4441
4442
4443 /*
4444  * Perform dequantization and inverse DCT on one block of coefficients,
4445  * producing a 6x12 output block.
4446  *
4447  * 12-point IDCT in pass 1 (columns), 6-point in pass 2 (rows).
4448  */
4449
4450 GLOBAL(void)
4451 jpeg_idct_6x12 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4452                 JCOEFPTR coef_block,
4453                 JSAMPARRAY output_buf, JDIMENSION output_col)
4454 {
4455   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
4456   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
4457   INT32 z1, z2, z3, z4;
4458   JCOEFPTR inptr;
4459   ISLOW_MULT_TYPE * quantptr;
4460   int * wsptr;
4461   JSAMPROW outptr;
4462   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4463   int ctr;
4464   int workspace[6*12];  /* buffers data between passes */
4465   SHIFT_TEMPS
4466
4467   /* Pass 1: process columns from input, store into work array.
4468    * 12-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/24).
4469    */
4470
4471   inptr = coef_block;
4472   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4473   wsptr = workspace;
4474   for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
4475     /* Even part */
4476
4477     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4478     z3 <<= CONST_BITS;
4479     /* Add fudge factor here for final descale. */
4480     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
4481
4482     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4483     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
4484
4485     tmp10 = z3 + z4;
4486     tmp11 = z3 - z4;
4487
4488     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4489     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
4490     z1 <<= CONST_BITS;
4491     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4492     z2 <<= CONST_BITS;
4493
4494     tmp12 = z1 - z2;
4495
4496     tmp21 = z3 + tmp12;
4497     tmp24 = z3 - tmp12;
4498
4499     tmp12 = z4 + z2;
4500
4501     tmp20 = tmp10 + tmp12;
4502     tmp25 = tmp10 - tmp12;
4503
4504     tmp12 = z4 - z1 - z2;
4505
4506     tmp22 = tmp11 + tmp12;
4507     tmp23 = tmp11 - tmp12;
4508
4509     /* Odd part */
4510
4511     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4512     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4513     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4514     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4515
4516     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
4517     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
4518
4519     tmp10 = z1 + z3;
4520     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
4521     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
4522     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
4523     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
4524     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
4525     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
4526     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
4527              MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
4528
4529     z1 -= z4;
4530     z2 -= z3;
4531     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
4532     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
4533     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
4534
4535     /* Final output stage */
4536
4537     wsptr[6*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
4538     wsptr[6*11] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
4539     wsptr[6*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
4540     wsptr[6*10] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
4541     wsptr[6*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
4542     wsptr[6*9]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
4543     wsptr[6*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
4544     wsptr[6*8]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
4545     wsptr[6*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
4546     wsptr[6*7]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
4547     wsptr[6*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
4548     wsptr[6*6]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
4549   }
4550
4551   /* Pass 2: process 12 rows from work array, store into output array.
4552    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
4553    */
4554
4555   wsptr = workspace;
4556   for (ctr = 0; ctr < 12; ctr++) {
4557     outptr = output_buf[ctr] + output_col;
4558
4559     /* Even part */
4560
4561     /* Add fudge factor here for final descale. */
4562     tmp10 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
4563     tmp10 <<= CONST_BITS;
4564     tmp12 = (INT32) wsptr[4];
4565     tmp20 = MULTIPLY(tmp12, FIX(0.707106781));   /* c4 */
4566     tmp11 = tmp10 + tmp20;
4567     tmp21 = tmp10 - tmp20 - tmp20;
4568     tmp20 = (INT32) wsptr[2];
4569     tmp10 = MULTIPLY(tmp20, FIX(1.224744871));   /* c2 */
4570     tmp20 = tmp11 + tmp10;
4571     tmp22 = tmp11 - tmp10;
4572
4573     /* Odd part */
4574
4575     z1 = (INT32) wsptr[1];
4576     z2 = (INT32) wsptr[3];
4577     z3 = (INT32) wsptr[5];
4578     tmp11 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
4579     tmp10 = tmp11 + ((z1 + z2) << CONST_BITS);
4580     tmp12 = tmp11 + ((z3 - z2) << CONST_BITS);
4581     tmp11 = (z1 - z2 - z3) << CONST_BITS;
4582
4583     /* Final output stage */
4584
4585     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
4586                                               CONST_BITS+PASS1_BITS+3)
4587                             & RANGE_MASK];
4588     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
4589                                               CONST_BITS+PASS1_BITS+3)
4590                             & RANGE_MASK];
4591     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
4592                                               CONST_BITS+PASS1_BITS+3)
4593                             & RANGE_MASK];
4594     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
4595                                               CONST_BITS+PASS1_BITS+3)
4596                             & RANGE_MASK];
4597     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
4598                                               CONST_BITS+PASS1_BITS+3)
4599                             & RANGE_MASK];
4600     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
4601                                               CONST_BITS+PASS1_BITS+3)
4602                             & RANGE_MASK];
4603
4604     wsptr += 6;         /* advance pointer to next row */
4605   }
4606 }
4607
4608
4609 /*
4610  * Perform dequantization and inverse DCT on one block of coefficients,
4611  * producing a 5x10 output block.
4612  *
4613  * 10-point IDCT in pass 1 (columns), 5-point in pass 2 (rows).
4614  */
4615
4616 GLOBAL(void)
4617 jpeg_idct_5x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4618                 JCOEFPTR coef_block,
4619                 JSAMPARRAY output_buf, JDIMENSION output_col)
4620 {
4621   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
4622   INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
4623   INT32 z1, z2, z3, z4, z5;
4624   JCOEFPTR inptr;
4625   ISLOW_MULT_TYPE * quantptr;
4626   int * wsptr;
4627   JSAMPROW outptr;
4628   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4629   int ctr;
4630   int workspace[5*10];  /* buffers data between passes */
4631   SHIFT_TEMPS
4632
4633   /* Pass 1: process columns from input, store into work array.
4634    * 10-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/20).
4635    */
4636
4637   inptr = coef_block;
4638   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4639   wsptr = workspace;
4640   for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
4641     /* Even part */
4642
4643     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4644     z3 <<= CONST_BITS;
4645     /* Add fudge factor here for final descale. */
4646     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
4647     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4648     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
4649     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
4650     tmp10 = z3 + z1;
4651     tmp11 = z3 - z2;
4652
4653     tmp22 = RIGHT_SHIFT(z3 - ((z1 - z2) << 1),   /* c0 = (c4-c8)*2 */
4654                         CONST_BITS-PASS1_BITS);
4655
4656     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4657     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4658
4659     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
4660     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
4661     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
4662
4663     tmp20 = tmp10 + tmp12;
4664     tmp24 = tmp10 - tmp12;
4665     tmp21 = tmp11 + tmp13;
4666     tmp23 = tmp11 - tmp13;
4667
4668     /* Odd part */
4669
4670     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4671     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4672     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4673     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4674
4675     tmp11 = z2 + z4;
4676     tmp13 = z2 - z4;
4677
4678     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
4679     z5 = z3 << CONST_BITS;
4680
4681     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
4682     z4 = z5 + tmp12;
4683
4684     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
4685     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
4686
4687     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
4688     z4 = z5 - tmp12 - (tmp13 << (CONST_BITS - 1));
4689
4690     tmp12 = (z1 - tmp13 - z3) << PASS1_BITS;
4691
4692     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
4693     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
4694
4695     /* Final output stage */
4696
4697     wsptr[5*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
4698     wsptr[5*9] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
4699     wsptr[5*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
4700     wsptr[5*8] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
4701     wsptr[5*2] = (int) (tmp22 + tmp12);
4702     wsptr[5*7] = (int) (tmp22 - tmp12);
4703     wsptr[5*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
4704     wsptr[5*6] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
4705     wsptr[5*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
4706     wsptr[5*5] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
4707   }
4708
4709   /* Pass 2: process 10 rows from work array, store into output array.
4710    * 5-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
4711    */
4712
4713   wsptr = workspace;
4714   for (ctr = 0; ctr < 10; ctr++) {
4715     outptr = output_buf[ctr] + output_col;
4716
4717     /* Even part */
4718
4719     /* Add fudge factor here for final descale. */
4720     tmp12 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
4721     tmp12 <<= CONST_BITS;
4722     tmp13 = (INT32) wsptr[2];
4723     tmp14 = (INT32) wsptr[4];
4724     z1 = MULTIPLY(tmp13 + tmp14, FIX(0.790569415)); /* (c2+c4)/2 */
4725     z2 = MULTIPLY(tmp13 - tmp14, FIX(0.353553391)); /* (c2-c4)/2 */
4726     z3 = tmp12 + z2;
4727     tmp10 = z3 + z1;
4728     tmp11 = z3 - z1;
4729     tmp12 -= z2 << 2;
4730
4731     /* Odd part */
4732
4733     z2 = (INT32) wsptr[1];
4734     z3 = (INT32) wsptr[3];
4735
4736     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));       /* c3 */
4737     tmp13 = z1 + MULTIPLY(z2, FIX(0.513743148));    /* c1-c3 */
4738     tmp14 = z1 - MULTIPLY(z3, FIX(2.176250899));    /* c1+c3 */
4739
4740     /* Final output stage */
4741
4742     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp13,
4743                                               CONST_BITS+PASS1_BITS+3)
4744                             & RANGE_MASK];
4745     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp13,
4746                                               CONST_BITS+PASS1_BITS+3)
4747                             & RANGE_MASK];
4748     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp14,
4749                                               CONST_BITS+PASS1_BITS+3)
4750                             & RANGE_MASK];
4751     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp14,
4752                                               CONST_BITS+PASS1_BITS+3)
4753                             & RANGE_MASK];
4754     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12,
4755                                               CONST_BITS+PASS1_BITS+3)
4756                             & RANGE_MASK];
4757
4758     wsptr += 5;         /* advance pointer to next row */
4759   }
4760 }
4761
4762
4763 /*
4764  * Perform dequantization and inverse DCT on one block of coefficients,
4765  * producing a 4x8 output block.
4766  *
4767  * 8-point IDCT in pass 1 (columns), 4-point in pass 2 (rows).
4768  */
4769
4770 GLOBAL(void)
4771 jpeg_idct_4x8 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4772                JCOEFPTR coef_block,
4773                JSAMPARRAY output_buf, JDIMENSION output_col)
4774 {
4775   INT32 tmp0, tmp1, tmp2, tmp3;
4776   INT32 tmp10, tmp11, tmp12, tmp13;
4777   INT32 z1, z2, z3;
4778   JCOEFPTR inptr;
4779   ISLOW_MULT_TYPE * quantptr;
4780   int * wsptr;
4781   JSAMPROW outptr;
4782   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4783   int ctr;
4784   int workspace[4*8];   /* buffers data between passes */
4785   SHIFT_TEMPS
4786
4787   /* Pass 1: process columns from input, store into work array.
4788    * Note results are scaled up by sqrt(8) compared to a true IDCT;
4789    * furthermore, we scale the results by 2**PASS1_BITS.
4790    * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
4791    */
4792
4793   inptr = coef_block;
4794   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4795   wsptr = workspace;
4796   for (ctr = 4; ctr > 0; ctr--) {
4797     /* Due to quantization, we will usually find that many of the input
4798      * coefficients are zero, especially the AC terms.  We can exploit this
4799      * by short-circuiting the IDCT calculation for any column in which all
4800      * the AC terms are zero.  In that case each output is equal to the
4801      * DC coefficient (with scale factor as needed).
4802      * With typical images and quantization tables, half or more of the
4803      * column DCT calculations can be simplified this way.
4804      */
4805
4806     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
4807         inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
4808         inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
4809         inptr[DCTSIZE*7] == 0) {
4810       /* AC terms all zero */
4811       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
4812
4813       wsptr[4*0] = dcval;
4814       wsptr[4*1] = dcval;
4815       wsptr[4*2] = dcval;
4816       wsptr[4*3] = dcval;
4817       wsptr[4*4] = dcval;
4818       wsptr[4*5] = dcval;
4819       wsptr[4*6] = dcval;
4820       wsptr[4*7] = dcval;
4821
4822       inptr++;                  /* advance pointers to next column */
4823       quantptr++;
4824       wsptr++;
4825       continue;
4826     }
4827
4828     /* Even part: reverse the even part of the forward DCT.
4829      * The rotator is c(-6).
4830      */
4831
4832     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4833     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4834
4835     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
4836     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
4837     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
4838
4839     z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4840     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4841     z2 <<= CONST_BITS;
4842     z3 <<= CONST_BITS;
4843     /* Add fudge factor here for final descale. */
4844     z2 += ONE << (CONST_BITS-PASS1_BITS-1);
4845
4846     tmp0 = z2 + z3;
4847     tmp1 = z2 - z3;
4848
4849     tmp10 = tmp0 + tmp2;
4850     tmp13 = tmp0 - tmp2;
4851     tmp11 = tmp1 + tmp3;
4852     tmp12 = tmp1 - tmp3;
4853
4854     /* Odd part per figure 8; the matrix is unitary and hence its
4855      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
4856      */
4857
4858     tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4859     tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4860     tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4861     tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4862
4863     z2 = tmp0 + tmp2;
4864     z3 = tmp1 + tmp3;
4865
4866     z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
4867     z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
4868     z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
4869     z2 += z1;
4870     z3 += z1;
4871
4872     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
4873     tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
4874     tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
4875     tmp0 += z1 + z2;
4876     tmp3 += z1 + z3;
4877
4878     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
4879     tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
4880     tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
4881     tmp1 += z1 + z3;
4882     tmp2 += z1 + z2;
4883
4884     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
4885
4886     wsptr[4*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
4887     wsptr[4*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
4888     wsptr[4*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
4889     wsptr[4*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
4890     wsptr[4*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
4891     wsptr[4*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
4892     wsptr[4*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
4893     wsptr[4*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
4894
4895     inptr++;                    /* advance pointers to next column */
4896     quantptr++;
4897     wsptr++;
4898   }
4899
4900   /* Pass 2: process 8 rows from work array, store into output array.
4901    * 4-point IDCT kernel,
4902    * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
4903    */
4904
4905   wsptr = workspace;
4906   for (ctr = 0; ctr < 8; ctr++) {
4907     outptr = output_buf[ctr] + output_col;
4908
4909     /* Even part */
4910
4911     /* Add fudge factor here for final descale. */
4912     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
4913     tmp2 = (INT32) wsptr[2];
4914
4915     tmp10 = (tmp0 + tmp2) << CONST_BITS;
4916     tmp12 = (tmp0 - tmp2) << CONST_BITS;
4917
4918     /* Odd part */
4919     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
4920
4921     z2 = (INT32) wsptr[1];
4922     z3 = (INT32) wsptr[3];
4923
4924     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
4925     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
4926     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
4927
4928     /* Final output stage */
4929
4930     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
4931                                               CONST_BITS+PASS1_BITS+3)
4932                             & RANGE_MASK];
4933     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
4934                                               CONST_BITS+PASS1_BITS+3)
4935                             & RANGE_MASK];
4936     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
4937                                               CONST_BITS+PASS1_BITS+3)
4938                             & RANGE_MASK];
4939     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
4940                                               CONST_BITS+PASS1_BITS+3)
4941                             & RANGE_MASK];
4942
4943     wsptr += 4;         /* advance pointer to next row */
4944   }
4945 }
4946
4947
4948 /*
4949  * Perform dequantization and inverse DCT on one block of coefficients,
4950  * producing a reduced-size 3x6 output block.
4951  *
4952  * 6-point IDCT in pass 1 (columns), 3-point in pass 2 (rows).
4953  */
4954
4955 GLOBAL(void)
4956 jpeg_idct_3x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4957                JCOEFPTR coef_block,
4958                JSAMPARRAY output_buf, JDIMENSION output_col)
4959 {
4960   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
4961   INT32 z1, z2, z3;
4962   JCOEFPTR inptr;
4963   ISLOW_MULT_TYPE * quantptr;
4964   int * wsptr;
4965   JSAMPROW outptr;
4966   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4967   int ctr;
4968   int workspace[3*6];   /* buffers data between passes */
4969   SHIFT_TEMPS
4970
4971   /* Pass 1: process columns from input, store into work array.
4972    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
4973    */
4974
4975   inptr = coef_block;
4976   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4977   wsptr = workspace;
4978   for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
4979     /* Even part */
4980
4981     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4982     tmp0 <<= CONST_BITS;
4983     /* Add fudge factor here for final descale. */
4984     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
4985     tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4986     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
4987     tmp1 = tmp0 + tmp10;
4988     tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS-PASS1_BITS);
4989     tmp10 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4990     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
4991     tmp10 = tmp1 + tmp0;
4992     tmp12 = tmp1 - tmp0;
4993
4994     /* Odd part */
4995
4996     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4997     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4998     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4999     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
5000     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
5001     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
5002     tmp1 = (z1 - z2 - z3) << PASS1_BITS;
5003
5004     /* Final output stage */
5005
5006     wsptr[3*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
5007     wsptr[3*5] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
5008     wsptr[3*1] = (int) (tmp11 + tmp1);
5009     wsptr[3*4] = (int) (tmp11 - tmp1);
5010     wsptr[3*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
5011     wsptr[3*3] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
5012   }
5013
5014   /* Pass 2: process 6 rows from work array, store into output array.
5015    * 3-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
5016    */
5017
5018   wsptr = workspace;
5019   for (ctr = 0; ctr < 6; ctr++) {
5020     outptr = output_buf[ctr] + output_col;
5021
5022     /* Even part */
5023
5024     /* Add fudge factor here for final descale. */
5025     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
5026     tmp0 <<= CONST_BITS;
5027     tmp2 = (INT32) wsptr[2];
5028     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
5029     tmp10 = tmp0 + tmp12;
5030     tmp2 = tmp0 - tmp12 - tmp12;
5031
5032     /* Odd part */
5033
5034     tmp12 = (INT32) wsptr[1];
5035     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
5036
5037     /* Final output stage */
5038
5039     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
5040                                               CONST_BITS+PASS1_BITS+3)
5041                             & RANGE_MASK];
5042     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
5043                                               CONST_BITS+PASS1_BITS+3)
5044                             & RANGE_MASK];
5045     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2,
5046                                               CONST_BITS+PASS1_BITS+3)
5047                             & RANGE_MASK];
5048
5049     wsptr += 3;         /* advance pointer to next row */
5050   }
5051 }
5052
5053
5054 /*
5055  * Perform dequantization and inverse DCT on one block of coefficients,
5056  * producing a 2x4 output block.
5057  *
5058  * 4-point IDCT in pass 1 (columns), 2-point in pass 2 (rows).
5059  */
5060
5061 GLOBAL(void)
5062 jpeg_idct_2x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
5063                JCOEFPTR coef_block,
5064                JSAMPARRAY output_buf, JDIMENSION output_col)
5065 {
5066   INT32 tmp0, tmp2, tmp10, tmp12;
5067   INT32 z1, z2, z3;
5068   JCOEFPTR inptr;
5069   ISLOW_MULT_TYPE * quantptr;
5070   INT32 * wsptr;
5071   JSAMPROW outptr;
5072   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
5073   int ctr;
5074   INT32 workspace[2*4]; /* buffers data between passes */
5075   SHIFT_TEMPS
5076
5077   /* Pass 1: process columns from input, store into work array.
5078    * 4-point IDCT kernel,
5079    * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
5080    */
5081
5082   inptr = coef_block;
5083   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
5084   wsptr = workspace;
5085   for (ctr = 0; ctr < 2; ctr++, inptr++, quantptr++, wsptr++) {
5086     /* Even part */
5087
5088     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
5089     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
5090
5091     tmp10 = (tmp0 + tmp2) << CONST_BITS;
5092     tmp12 = (tmp0 - tmp2) << CONST_BITS;
5093
5094     /* Odd part */
5095     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
5096
5097     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
5098     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
5099
5100     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
5101     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
5102     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
5103
5104     /* Final output stage */
5105
5106     wsptr[2*0] = tmp10 + tmp0;
5107     wsptr[2*3] = tmp10 - tmp0;
5108     wsptr[2*1] = tmp12 + tmp2;
5109     wsptr[2*2] = tmp12 - tmp2;
5110   }
5111
5112   /* Pass 2: process 4 rows from work array, store into output array. */
5113
5114   wsptr = workspace;
5115   for (ctr = 0; ctr < 4; ctr++) {
5116     outptr = output_buf[ctr] + output_col;
5117
5118     /* Even part */
5119
5120     /* Add fudge factor here for final descale. */
5121     tmp10 = wsptr[0] + (ONE << (CONST_BITS+2));
5122
5123     /* Odd part */
5124
5125     tmp0 = wsptr[1];
5126
5127     /* Final output stage */
5128
5129     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS+3)
5130                             & RANGE_MASK];
5131     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS+3)
5132                             & RANGE_MASK];
5133
5134     wsptr += 2;         /* advance pointer to next row */
5135   }
5136 }
5137
5138
5139 /*
5140  * Perform dequantization and inverse DCT on one block of coefficients,
5141  * producing a 1x2 output block.
5142  *
5143  * 2-point IDCT in pass 1 (columns), 1-point in pass 2 (rows).
5144  */
5145
5146 GLOBAL(void)
5147 jpeg_idct_1x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
5148                JCOEFPTR coef_block,
5149                JSAMPARRAY output_buf, JDIMENSION output_col)
5150 {
5151   INT32 tmp0, tmp1;
5152   ISLOW_MULT_TYPE * quantptr;
5153   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
5154   SHIFT_TEMPS
5155
5156   /* Process 1 column from input, store into output array. */
5157
5158   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
5159
5160   /* Even part */
5161
5162   tmp0 = DEQUANTIZE(coef_block[DCTSIZE*0], quantptr[DCTSIZE*0]);
5163   /* Add fudge factor here for final descale. */
5164   tmp0 += ONE << 2;
5165
5166   /* Odd part */
5167
5168   tmp1 = DEQUANTIZE(coef_block[DCTSIZE*1], quantptr[DCTSIZE*1]);
5169
5170   /* Final output stage */
5171
5172   output_buf[0][output_col] = range_limit[(int) RIGHT_SHIFT(tmp0 + tmp1, 3)
5173                                           & RANGE_MASK];
5174   output_buf[1][output_col] = range_limit[(int) RIGHT_SHIFT(tmp0 - tmp1, 3)
5175                                           & RANGE_MASK];
5176 }
5177
5178 #endif /* IDCT_SCALING_SUPPORTED */
5179 #endif /* DCT_ISLOW_SUPPORTED */