PageRenderTime 79ms CodeModel.GetById 13ms RepoModel.GetById 0ms app.codeStats 1ms

/src/FreeImage/Source/LibJPEG/jidctint.c

https://bitbucket.org/cabalistic/ogredeps/
C | 5137 lines | 3541 code | 880 blank | 716 comment | 106 complexity | 4ea27dba5316cdba15d8294ad0364aa8 MD5 | raw file
Possible License(s): LGPL-3.0, BSD-3-Clause, CPL-1.0, Unlicense, GPL-2.0, GPL-3.0, LGPL-2.0, MPL-2.0-no-copyleft-exception, BSD-2-Clause, LGPL-2.1 
    

  1. /*
    2. 

  2.  * jidctint.c
    3. 

  3.  *
    4. 

  4.  * Copyright (C) 1991-1998, Thomas G. Lane.
    5. 

  5.  * Modification developed 2002-2009 by Guido Vollbeding.
    6. 

  6.  * This file is part of the Independent JPEG Group's software.
    7. 

  7.  * For conditions of distribution and use, see the accompanying README file.
    8. 

  8.  *
    9. 

  9.  * This file contains a slow-but-accurate integer implementation of the
    10. 

  10.  * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
    11. 

  11.  * must also perform dequantization of the input coefficients.
    12. 

  12.  *
    13. 

  13.  * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
    14. 

  14.  * on each row (or vice versa, but it's more convenient to emit a row at
    15. 

  15.  * a time).  Direct algorithms are also available, but they are much more
    16. 

  16.  * complex and seem not to be any faster when reduced to code.
    17. 

  17.  *
    18. 

  18.  * This implementation is based on an algorithm described in
    19. 

  19.  *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
    20. 

  20.  *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
    21. 

  21.  *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
    22. 

  22.  * The primary algorithm described there uses 11 multiplies and 29 adds.
    23. 

  23.  * We use their alternate method with 12 multiplies and 32 adds.
    24. 

  24.  * The advantage of this method is that no data path contains more than one
    25. 

  25.  * multiplication; this allows a very simple and accurate implementation in
    26. 

  26.  * scaled fixed-point arithmetic, with a minimal number of shifts.
    27. 

  27.  *
    28. 

  28.  * We also provide IDCT routines with various output sample block sizes for
    29. 

  29.  * direct resolution reduction or enlargement and for direct resolving the
    30. 

  30.  * common 2x1 and 1x2 subsampling cases without additional resampling: NxN
    31. 

  31.  * (N=1...16), 2NxN, and Nx2N (N=1...8) pixels for one 8x8 input DCT block.
    32. 

  32.  *
    33. 

  33.  * For N<8 we simply take the corresponding low-frequency coefficients of
    34. 

  34.  * the 8x8 input DCT block and apply an NxN point IDCT on the sub-block
    35. 

  35.  * to yield the downscaled outputs.
    36. 

  36.  * This can be seen as direct low-pass downsampling from the DCT domain
    37. 

  37.  * point of view rather than the usual spatial domain point of view,
    38. 

  38.  * yielding significant computational savings and results at least
    39. 

  39.  * as good as common bilinear (averaging) spatial downsampling.
    40. 

  40.  *
    41. 

  41.  * For N>8 we apply a partial NxN IDCT on the 8 input coefficients as
    42. 

  42.  * lower frequencies and higher frequencies assumed to be zero.
    43. 

  43.  * It turns out that the computational effort is similar to the 8x8 IDCT
    44. 

  44.  * regarding the output size.
    45. 

  45.  * Furthermore, the scaling and descaling is the same for all IDCT sizes.
    46. 

  46.  *
    47. 

  47.  * CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
    48. 

  48.  * since there would be too many additional constants to pre-calculate.
    49. 

  49.  */
    50. 

  50. 

  51. #define JPEG_INTERNALS
    52. 

  52. #include "jinclude.h"
    53. 

  53. #include "jpeglib.h"
    54. 

  54. #include "jdct.h"		/* Private declarations for DCT subsystem */
    55. 

  55. 

  56. #ifdef DCT_ISLOW_SUPPORTED
    57. 

  57. 

  58. 

  59. /*
    60. 

  60.  * This module is specialized to the case DCTSIZE = 8.
    61. 

  61.  */
    62. 

  62. 

  63. #if DCTSIZE != 8
    64. 

  64.   Sorry, this code only copes with 8x8 DCT blocks. /* deliberate syntax err */
    65. 

  65. #endif
    66. 

  66. 

  67. 

  68. /*
    69. 

  69.  * The poop on this scaling stuff is as follows:
    70. 

  70.  *
    71. 

  71.  * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
    72. 

  72.  * larger than the true IDCT outputs.  The final outputs are therefore
    73. 

  73.  * a factor of N larger than desired; since N=8 this can be cured by
    74. 

  74.  * a simple right shift at the end of the algorithm.  The advantage of
    75. 

  75.  * this arrangement is that we save two multiplications per 1-D IDCT,
    76. 

  76.  * because the y0 and y4 inputs need not be divided by sqrt(N).
    77. 

  77.  *
    78. 

  78.  * We have to do addition and subtraction of the integer inputs, which
    79. 

  79.  * is no problem, and multiplication by fractional constants, which is
    80. 

  80.  * a problem to do in integer arithmetic.  We multiply all the constants
    81. 

  81.  * by CONST_SCALE and convert them to integer constants (thus retaining
    82. 

  82.  * CONST_BITS bits of precision in the constants).  After doing a
    83. 

  83.  * multiplication we have to divide the product by CONST_SCALE, with proper
    84. 

  84.  * rounding, to produce the correct output.  This division can be done
    85. 

  85.  * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
    86. 

  86.  * as long as possible so that partial sums can be added together with
    87. 

  87.  * full fractional precision.
    88. 

  88.  *
    89. 

  89.  * The outputs of the first pass are scaled up by PASS1_BITS bits so that
    90. 

  90.  * they are represented to better-than-integral precision.  These outputs
    91. 

  91.  * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
    92. 

  92.  * with the recommended scaling.  (To scale up 12-bit sample data further, an
    93. 

  93.  * intermediate INT32 array would be needed.)
    94. 

  94.  *
    95. 

  95.  * To avoid overflow of the 32-bit intermediate results in pass 2, we must
    96. 

  96.  * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
    97. 

  97.  * shows that the values given below are the most effective.
    98. 

  98.  */
    99. 

  99. 

  100. #if BITS_IN_JSAMPLE == 8
    101. 

  101. #define CONST_BITS  13
    102. 

  102. #define PASS1_BITS  2
    103. 

  103. #else
    104. 

  104. #define CONST_BITS  13
    105. 

  105. #define PASS1_BITS  1		/* lose a little precision to avoid overflow */
    106. 

  106. #endif
    107. 

  107. 

  108. /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
    109. 

  109.  * causing a lot of useless floating-point operations at run time.
    110. 

  110.  * To get around this we use the following pre-calculated constants.
    111. 

  111.  * If you change CONST_BITS you may want to add appropriate values.
    112. 

  112.  * (With a reasonable C compiler, you can just rely on the FIX() macro...)
    113. 

  113.  */
    114. 

  114. 

  115. #if CONST_BITS == 13
    116. 

  116. #define FIX_0_298631336  ((INT32)  2446)	/* FIX(0.298631336) */
    117. 

  117. #define FIX_0_390180644  ((INT32)  3196)	/* FIX(0.390180644) */
    118. 

  118. #define FIX_0_541196100  ((INT32)  4433)	/* FIX(0.541196100) */
    119. 

  119. #define FIX_0_765366865  ((INT32)  6270)	/* FIX(0.765366865) */
    120. 

  120. #define FIX_0_899976223  ((INT32)  7373)	/* FIX(0.899976223) */
    121. 

  121. #define FIX_1_175875602  ((INT32)  9633)	/* FIX(1.175875602) */
    122. 

  122. #define FIX_1_501321110  ((INT32)  12299)	/* FIX(1.501321110) */
    123. 

  123. #define FIX_1_847759065  ((INT32)  15137)	/* FIX(1.847759065) */
    124. 

  124. #define FIX_1_961570560  ((INT32)  16069)	/* FIX(1.961570560) */
    125. 

  125. #define FIX_2_053119869  ((INT32)  16819)	/* FIX(2.053119869) */
    126. 

  126. #define FIX_2_562915447  ((INT32)  20995)	/* FIX(2.562915447) */
    127. 

  127. #define FIX_3_072711026  ((INT32)  25172)	/* FIX(3.072711026) */
    128. 

  128. #else
    129. 

  129. #define FIX_0_298631336  FIX(0.298631336)
    130. 

  130. #define FIX_0_390180644  FIX(0.390180644)
    131. 

  131. #define FIX_0_541196100  FIX(0.541196100)
    132. 

  132. #define FIX_0_765366865  FIX(0.765366865)
    133. 

  133. #define FIX_0_899976223  FIX(0.899976223)
    134. 

  134. #define FIX_1_175875602  FIX(1.175875602)
    135. 

  135. #define FIX_1_501321110  FIX(1.501321110)
    136. 

  136. #define FIX_1_847759065  FIX(1.847759065)
    137. 

  137. #define FIX_1_961570560  FIX(1.961570560)
    138. 

  138. #define FIX_2_053119869  FIX(2.053119869)
    139. 

  139. #define FIX_2_562915447  FIX(2.562915447)
    140. 

  140. #define FIX_3_072711026  FIX(3.072711026)
    141. 

  141. #endif
    142. 

  142. 

  143. 

  144. /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
    145. 

  145.  * For 8-bit samples with the recommended scaling, all the variable
    146. 

  146.  * and constant values involved are no more than 16 bits wide, so a
    147. 

  147.  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
    148. 

  148.  * For 12-bit samples, a full 32-bit multiplication will be needed.
    149. 

  149.  */
    150. 

  150. 

  151. #if BITS_IN_JSAMPLE == 8
    152. 

  152. #define MULTIPLY(var,const)  MULTIPLY16C16(var,const)
    153. 

  153. #else
    154. 

  154. #define MULTIPLY(var,const)  ((var) * (const))
    155. 

  155. #endif
    156. 

  156. 

  157. 

  158. /* Dequantize a coefficient by multiplying it by the multiplier-table
    159. 

  159.  * entry; produce an int result.  In this module, both inputs and result
    160. 

  160.  * are 16 bits or less, so either int or short multiply will work.
    161. 

  161.  */
    162. 

  162. 

  163. #define DEQUANTIZE(coef,quantval)  (((ISLOW_MULT_TYPE) (coef)) * (quantval))
    164. 

  164. 

  165. 

  166. /*
    167. 

  167.  * Perform dequantization and inverse DCT on one block of coefficients.
    168. 

  168.  */
    169. 

  169. 

  170. GLOBAL(void)
    171. 

  171. jpeg_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    172. 

  172. 		 JCOEFPTR coef_block,
    173. 

  173. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    174. 

  174. {
    175. 

  175.   INT32 tmp0, tmp1, tmp2, tmp3;
    176. 

  176.   INT32 tmp10, tmp11, tmp12, tmp13;
    177. 

  177.   INT32 z1, z2, z3;
    178. 

  178.   JCOEFPTR inptr;
    179. 

  179.   ISLOW_MULT_TYPE * quantptr;
    180. 

  180.   int * wsptr;
    181. 

  181.   JSAMPROW outptr;
    182. 

  182.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    183. 

  183.   int ctr;
    184. 

  184.   int workspace[DCTSIZE2];	/* buffers data between passes */
    185. 

  185.   SHIFT_TEMPS
    186. 

  186. 

  187.   /* Pass 1: process columns from input, store into work array. */
    188. 

  188.   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
    189. 

  189.   /* furthermore, we scale the results by 2**PASS1_BITS. */
    190. 

  190. 

  191.   inptr = coef_block;
    192. 

  192.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    193. 

  193.   wsptr = workspace;
    194. 

  194.   for (ctr = DCTSIZE; ctr > 0; ctr--) {
    195. 

  195.     /* Due to quantization, we will usually find that many of the input
    196. 

  196.      * coefficients are zero, especially the AC terms.  We can exploit this
    197. 

  197.      * by short-circuiting the IDCT calculation for any column in which all
    198. 

  198.      * the AC terms are zero.  In that case each output is equal to the
    199. 

  199.      * DC coefficient (with scale factor as needed).
    200. 

  200.      * With typical images and quantization tables, half or more of the
    201. 

  201.      * column DCT calculations can be simplified this way.
    202. 

  202.      */
    203. 

  203. 

  204.     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
    205. 

  205. 	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
    206. 

  206. 	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
    207. 

  207. 	inptr[DCTSIZE*7] == 0) {
    208. 

  208.       /* AC terms all zero */
    209. 

  209.       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
    210. 

  210. 

  211.       wsptr[DCTSIZE*0] = dcval;
    212. 

  212.       wsptr[DCTSIZE*1] = dcval;
    213. 

  213.       wsptr[DCTSIZE*2] = dcval;
    214. 

  214.       wsptr[DCTSIZE*3] = dcval;
    215. 

  215.       wsptr[DCTSIZE*4] = dcval;
    216. 

  216.       wsptr[DCTSIZE*5] = dcval;
    217. 

  217.       wsptr[DCTSIZE*6] = dcval;
    218. 

  218.       wsptr[DCTSIZE*7] = dcval;
    219. 

  219. 

  220.       inptr++;			/* advance pointers to next column */
    221. 

  221.       quantptr++;
    222. 

  222.       wsptr++;
    223. 

  223.       continue;
    224. 

  224.     }
    225. 

  225. 

  226.     /* Even part: reverse the even part of the forward DCT. */
    227. 

  227.     /* The rotator is sqrt(2)*c(-6). */
    228. 

  228.     
    229. 

  229.     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    230. 

  230.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    231. 

  231. 

  232.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
    233. 

  233.     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);
    234. 

  234.     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);
    235. 

  235. 

  236.     z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    237. 

  237.     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    238. 

  238.     z2 <<= CONST_BITS;
    239. 

  239.     z3 <<= CONST_BITS;
    240. 

  240.     /* Add fudge factor here for final descale. */
    241. 

  241.     z2 += ONE << (CONST_BITS-PASS1_BITS-1);
    242. 

  242. 

  243.     tmp0 = z2 + z3;
    244. 

  244.     tmp1 = z2 - z3;
    245. 

  245. 

  246.     tmp10 = tmp0 + tmp2;
    247. 

  247.     tmp13 = tmp0 - tmp2;
    248. 

  248.     tmp11 = tmp1 + tmp3;
    249. 

  249.     tmp12 = tmp1 - tmp3;
    250. 

  250. 

  251.     /* Odd part per figure 8; the matrix is unitary and hence its
    252. 

  252.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
    253. 

  253.      */
    254. 

  254. 

  255.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    256. 

  256.     tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    257. 

  257.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    258. 

  258.     tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    259. 

  259.     
    260. 

  260.     z2 = tmp0 + tmp2;
    261. 

  261.     z3 = tmp1 + tmp3;
    262. 

  262. 

  263.     z1 = MULTIPLY(z2 + z3, FIX_1_175875602); /* sqrt(2) * c3 */
    264. 

  264.     z2 = MULTIPLY(z2, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
    265. 

  265.     z3 = MULTIPLY(z3, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
    266. 

  266.     z2 += z1;
    267. 

  267.     z3 += z1;
    268. 

  268. 

  269.     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
    270. 

  270.     tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
    271. 

  271.     tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
    272. 

  272.     tmp0 += z1 + z2;
    273. 

  273.     tmp3 += z1 + z3;
    274. 

  274. 

  275.     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
    276. 

  276.     tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    277. 

  277.     tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    278. 

  278.     tmp1 += z1 + z3;
    279. 

  279.     tmp2 += z1 + z2;
    280. 

  280. 

  281.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
    282. 

  282. 

  283.     wsptr[DCTSIZE*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
    284. 

  284.     wsptr[DCTSIZE*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
    285. 

  285.     wsptr[DCTSIZE*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
    286. 

  286.     wsptr[DCTSIZE*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
    287. 

  287.     wsptr[DCTSIZE*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
    288. 

  288.     wsptr[DCTSIZE*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
    289. 

  289.     wsptr[DCTSIZE*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
    290. 

  290.     wsptr[DCTSIZE*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
    291. 

  291.     
    292. 

  292.     inptr++;			/* advance pointers to next column */
    293. 

  293.     quantptr++;
    294. 

  294.     wsptr++;
    295. 

  295.   }
    296. 

  296. 

  297.   /* Pass 2: process rows from work array, store into output array. */
    298. 

  298.   /* Note that we must descale the results by a factor of 8 == 2**3, */
    299. 

  299.   /* and also undo the PASS1_BITS scaling. */
    300. 

  300. 

  301.   wsptr = workspace;
    302. 

  302.   for (ctr = 0; ctr < DCTSIZE; ctr++) {
    303. 

  303.     outptr = output_buf[ctr] + output_col;
    304. 

  304.     /* Rows of zeroes can be exploited in the same way as we did with columns.
    305. 

  305.      * However, the column calculation has created many nonzero AC terms, so
    306. 

  306.      * the simplification applies less often (typically 5% to 10% of the time).
    307. 

  307.      * On machines with very fast multiplication, it's possible that the
    308. 

  308.      * test takes more time than it's worth.  In that case this section
    309. 

  309.      * may be commented out.
    310. 

  310.      */
    311. 

  311. 

  312. #ifndef NO_ZERO_ROW_TEST
    313. 

  313.     if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
    314. 

  314. 	wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
    315. 

  315.       /* AC terms all zero */
    316. 

  316.       JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
    317. 

  317. 				  & RANGE_MASK];
    318. 

  318. 

  319.       outptr[0] = dcval;
    320. 

  320.       outptr[1] = dcval;
    321. 

  321.       outptr[2] = dcval;
    322. 

  322.       outptr[3] = dcval;
    323. 

  323.       outptr[4] = dcval;
    324. 

  324.       outptr[5] = dcval;
    325. 

  325.       outptr[6] = dcval;
    326. 

  326.       outptr[7] = dcval;
    327. 

  327. 

  328.       wsptr += DCTSIZE;		/* advance pointer to next row */
    329. 

  329.       continue;
    330. 

  330.     }
    331. 

  331. #endif
    332. 

  332. 

  333.     /* Even part: reverse the even part of the forward DCT. */
    334. 

  334.     /* The rotator is sqrt(2)*c(-6). */
    335. 

  335.     
    336. 

  336.     z2 = (INT32) wsptr[2];
    337. 

  337.     z3 = (INT32) wsptr[6];
    338. 

  338. 

  339.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
    340. 

  340.     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);
    341. 

  341.     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);
    342. 

  342. 

  343.     /* Add fudge factor here for final descale. */
    344. 

  344.     z2 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    345. 

  345.     z3 = (INT32) wsptr[4];
    346. 

  346. 

  347.     tmp0 = (z2 + z3) << CONST_BITS;
    348. 

  348.     tmp1 = (z2 - z3) << CONST_BITS;
    349. 

  349.     
    350. 

  350.     tmp10 = tmp0 + tmp2;
    351. 

  351.     tmp13 = tmp0 - tmp2;
    352. 

  352.     tmp11 = tmp1 + tmp3;
    353. 

  353.     tmp12 = tmp1 - tmp3;
    354. 

  354. 

  355.     /* Odd part per figure 8; the matrix is unitary and hence its
    356. 

  356.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
    357. 

  357.      */
    358. 

  358. 

  359.     tmp0 = (INT32) wsptr[7];
    360. 

  360.     tmp1 = (INT32) wsptr[5];
    361. 

  361.     tmp2 = (INT32) wsptr[3];
    362. 

  362.     tmp3 = (INT32) wsptr[1];
    363. 

  363. 

  364.     z2 = tmp0 + tmp2;
    365. 

  365.     z3 = tmp1 + tmp3;
    366. 

  366. 

  367.     z1 = MULTIPLY(z2 + z3, FIX_1_175875602); /* sqrt(2) * c3 */
    368. 

  368.     z2 = MULTIPLY(z2, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
    369. 

  369.     z3 = MULTIPLY(z3, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
    370. 

  370.     z2 += z1;
    371. 

  371.     z3 += z1;
    372. 

  372. 

  373.     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
    374. 

  374.     tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
    375. 

  375.     tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
    376. 

  376.     tmp0 += z1 + z2;
    377. 

  377.     tmp3 += z1 + z3;
    378. 

  378. 

  379.     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
    380. 

  380.     tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    381. 

  381.     tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    382. 

  382.     tmp1 += z1 + z3;
    383. 

  383.     tmp2 += z1 + z2;
    384. 

  384. 

  385.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
    386. 

  386. 

  387.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
    388. 

  388. 					      CONST_BITS+PASS1_BITS+3)
    389. 

  389. 			    & RANGE_MASK];
    390. 

  390.     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
    391. 

  391. 					      CONST_BITS+PASS1_BITS+3)
    392. 

  392. 			    & RANGE_MASK];
    393. 

  393.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
    394. 

  394. 					      CONST_BITS+PASS1_BITS+3)
    395. 

  395. 			    & RANGE_MASK];
    396. 

  396.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
    397. 

  397. 					      CONST_BITS+PASS1_BITS+3)
    398. 

  398. 			    & RANGE_MASK];
    399. 

  399.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
    400. 

  400. 					      CONST_BITS+PASS1_BITS+3)
    401. 

  401. 			    & RANGE_MASK];
    402. 

  402.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
    403. 

  403. 					      CONST_BITS+PASS1_BITS+3)
    404. 

  404. 			    & RANGE_MASK];
    405. 

  405.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
    406. 

  406. 					      CONST_BITS+PASS1_BITS+3)
    407. 

  407. 			    & RANGE_MASK];
    408. 

  408.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
    409. 

  409. 					      CONST_BITS+PASS1_BITS+3)
    410. 

  410. 			    & RANGE_MASK];
    411. 

  411. 

  412.     wsptr += DCTSIZE;		/* advance pointer to next row */
    413. 

  413.   }
    414. 

  414. }
    415. 

  415. 

  416. #ifdef IDCT_SCALING_SUPPORTED
    417. 

  417. 

  418. 

  419. /*
    420. 

  420.  * Perform dequantization and inverse DCT on one block of coefficients,
    421. 

  421.  * producing a 7x7 output block.
    422. 

  422.  *
    423. 

  423.  * Optimized algorithm with 12 multiplications in the 1-D kernel.
    424. 

  424.  * cK represents sqrt(2) * cos(K*pi/14).
    425. 

  425.  */
    426. 

  426. 

  427. GLOBAL(void)
    428. 

  428. jpeg_idct_7x7 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    429. 

  429. 	       JCOEFPTR coef_block,
    430. 

  430. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    431. 

  431. {
    432. 

  432.   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12, tmp13;
    433. 

  433.   INT32 z1, z2, z3;
    434. 

  434.   JCOEFPTR inptr;
    435. 

  435.   ISLOW_MULT_TYPE * quantptr;
    436. 

  436.   int * wsptr;
    437. 

  437.   JSAMPROW outptr;
    438. 

  438.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    439. 

  439.   int ctr;
    440. 

  440.   int workspace[7*7];	/* buffers data between passes */
    441. 

  441.   SHIFT_TEMPS
    442. 

  442. 

  443.   /* Pass 1: process columns from input, store into work array. */
    444. 

  444. 

  445.   inptr = coef_block;
    446. 

  446.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    447. 

  447.   wsptr = workspace;
    448. 

  448.   for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
    449. 

  449.     /* Even part */
    450. 

  450. 

  451.     tmp13 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    452. 

  452.     tmp13 <<= CONST_BITS;
    453. 

  453.     /* Add fudge factor here for final descale. */
    454. 

  454.     tmp13 += ONE << (CONST_BITS-PASS1_BITS-1);
    455. 

  455. 

  456.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    457. 

  457.     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    458. 

  458.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    459. 

  459. 

  460.     tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
    461. 

  461.     tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
    462. 

  462.     tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
    463. 

  463.     tmp0 = z1 + z3;
    464. 

  464.     z2 -= tmp0;
    465. 

  465.     tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
    466. 

  466.     tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
    467. 

  467.     tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
    468. 

  468.     tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
    469. 

  469. 

  470.     /* Odd part */
    471. 

  471. 

  472.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    473. 

  473.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    474. 

  474.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    475. 

  475. 

  476.     tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
    477. 

  477.     tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
    478. 

  478.     tmp0 = tmp1 - tmp2;
    479. 

  479.     tmp1 += tmp2;
    480. 

  480.     tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276));    /* -c1 */
    481. 

  481.     tmp1 += tmp2;
    482. 

  482.     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
    483. 

  483.     tmp0 += z2;
    484. 

  484.     tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
    485. 

  485. 

  486.     /* Final output stage */
    487. 

  487. 

  488.     wsptr[7*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
    489. 

  489.     wsptr[7*6] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
    490. 

  490.     wsptr[7*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
    491. 

  491.     wsptr[7*5] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
    492. 

  492.     wsptr[7*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
    493. 

  493.     wsptr[7*4] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
    494. 

  494.     wsptr[7*3] = (int) RIGHT_SHIFT(tmp13, CONST_BITS-PASS1_BITS);
    495. 

  495.   }
    496. 

  496. 

  497.   /* Pass 2: process 7 rows from work array, store into output array. */
    498. 

  498. 

  499.   wsptr = workspace;
    500. 

  500.   for (ctr = 0; ctr < 7; ctr++) {
    501. 

  501.     outptr = output_buf[ctr] + output_col;
    502. 

  502. 

  503.     /* Even part */
    504. 

  504. 

  505.     /* Add fudge factor here for final descale. */
    506. 

  506.     tmp13 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    507. 

  507.     tmp13 <<= CONST_BITS;
    508. 

  508. 

  509.     z1 = (INT32) wsptr[2];
    510. 

  510.     z2 = (INT32) wsptr[4];
    511. 

  511.     z3 = (INT32) wsptr[6];
    512. 

  512. 

  513.     tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
    514. 

  514.     tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
    515. 

  515.     tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
    516. 

  516.     tmp0 = z1 + z3;
    517. 

  517.     z2 -= tmp0;
    518. 

  518.     tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
    519. 

  519.     tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
    520. 

  520.     tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
    521. 

  521.     tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
    522. 

  522. 

  523.     /* Odd part */
    524. 

  524. 

  525.     z1 = (INT32) wsptr[1];
    526. 

  526.     z2 = (INT32) wsptr[3];
    527. 

  527.     z3 = (INT32) wsptr[5];
    528. 

  528. 

  529.     tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
    530. 

  530.     tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
    531. 

  531.     tmp0 = tmp1 - tmp2;
    532. 

  532.     tmp1 += tmp2;
    533. 

  533.     tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276));    /* -c1 */
    534. 

  534.     tmp1 += tmp2;
    535. 

  535.     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
    536. 

  536.     tmp0 += z2;
    537. 

  537.     tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
    538. 

  538. 

  539.     /* Final output stage */
    540. 

  540. 

  541.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    542. 

  542. 					      CONST_BITS+PASS1_BITS+3)
    543. 

  543. 			    & RANGE_MASK];
    544. 

  544.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    545. 

  545. 					      CONST_BITS+PASS1_BITS+3)
    546. 

  546. 			    & RANGE_MASK];
    547. 

  547.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
    548. 

  548. 					      CONST_BITS+PASS1_BITS+3)
    549. 

  549. 			    & RANGE_MASK];
    550. 

  550.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
    551. 

  551. 					      CONST_BITS+PASS1_BITS+3)
    552. 

  552. 			    & RANGE_MASK];
    553. 

  553.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
    554. 

  554. 					      CONST_BITS+PASS1_BITS+3)
    555. 

  555. 			    & RANGE_MASK];
    556. 

  556.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
    557. 

  557. 					      CONST_BITS+PASS1_BITS+3)
    558. 

  558. 			    & RANGE_MASK];
    559. 

  559.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13,
    560. 

  560. 					      CONST_BITS+PASS1_BITS+3)
    561. 

  561. 			    & RANGE_MASK];
    562. 

  562. 

  563.     wsptr += 7;		/* advance pointer to next row */
    564. 

  564.   }
    565. 

  565. }
    566. 

  566. 

  567. 

  568. /*
    569. 

  569.  * Perform dequantization and inverse DCT on one block of coefficients,
    570. 

  570.  * producing a reduced-size 6x6 output block.
    571. 

  571.  *
    572. 

  572.  * Optimized algorithm with 3 multiplications in the 1-D kernel.
    573. 

  573.  * cK represents sqrt(2) * cos(K*pi/12).
    574. 

  574.  */
    575. 

  575. 

  576. GLOBAL(void)
    577. 

  577. jpeg_idct_6x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    578. 

  578. 	       JCOEFPTR coef_block,
    579. 

  579. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    580. 

  580. {
    581. 

  581.   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
    582. 

  582.   INT32 z1, z2, z3;
    583. 

  583.   JCOEFPTR inptr;
    584. 

  584.   ISLOW_MULT_TYPE * quantptr;
    585. 

  585.   int * wsptr;
    586. 

  586.   JSAMPROW outptr;
    587. 

  587.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    588. 

  588.   int ctr;
    589. 

  589.   int workspace[6*6];	/* buffers data between passes */
    590. 

  590.   SHIFT_TEMPS
    591. 

  591. 

  592.   /* Pass 1: process columns from input, store into work array. */
    593. 

  593. 

  594.   inptr = coef_block;
    595. 

  595.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    596. 

  596.   wsptr = workspace;
    597. 

  597.   for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
    598. 

  598.     /* Even part */
    599. 

  599. 

  600.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    601. 

  601.     tmp0 <<= CONST_BITS;
    602. 

  602.     /* Add fudge factor here for final descale. */
    603. 

  603.     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
    604. 

  604.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    605. 

  605.     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
    606. 

  606.     tmp1 = tmp0 + tmp10;
    607. 

  607.     tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS-PASS1_BITS);
    608. 

  608.     tmp10 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    609. 

  609.     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
    610. 

  610.     tmp10 = tmp1 + tmp0;
    611. 

  611.     tmp12 = tmp1 - tmp0;
    612. 

  612. 

  613.     /* Odd part */
    614. 

  614. 

  615.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    616. 

  616.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    617. 

  617.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    618. 

  618.     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
    619. 

  619.     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
    620. 

  620.     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
    621. 

  621.     tmp1 = (z1 - z2 - z3) << PASS1_BITS;
    622. 

  622. 

  623.     /* Final output stage */
    624. 

  624. 

  625.     wsptr[6*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
    626. 

  626.     wsptr[6*5] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
    627. 

  627.     wsptr[6*1] = (int) (tmp11 + tmp1);
    628. 

  628.     wsptr[6*4] = (int) (tmp11 - tmp1);
    629. 

  629.     wsptr[6*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
    630. 

  630.     wsptr[6*3] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
    631. 

  631.   }
    632. 

  632. 

  633.   /* Pass 2: process 6 rows from work array, store into output array. */
    634. 

  634. 

  635.   wsptr = workspace;
    636. 

  636.   for (ctr = 0; ctr < 6; ctr++) {
    637. 

  637.     outptr = output_buf[ctr] + output_col;
    638. 

  638. 

  639.     /* Even part */
    640. 

  640. 

  641.     /* Add fudge factor here for final descale. */
    642. 

  642.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    643. 

  643.     tmp0 <<= CONST_BITS;
    644. 

  644.     tmp2 = (INT32) wsptr[4];
    645. 

  645.     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
    646. 

  646.     tmp1 = tmp0 + tmp10;
    647. 

  647.     tmp11 = tmp0 - tmp10 - tmp10;
    648. 

  648.     tmp10 = (INT32) wsptr[2];
    649. 

  649.     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
    650. 

  650.     tmp10 = tmp1 + tmp0;
    651. 

  651.     tmp12 = tmp1 - tmp0;
    652. 

  652. 

  653.     /* Odd part */
    654. 

  654. 

  655.     z1 = (INT32) wsptr[1];
    656. 

  656.     z2 = (INT32) wsptr[3];
    657. 

  657.     z3 = (INT32) wsptr[5];
    658. 

  658.     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
    659. 

  659.     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
    660. 

  660.     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
    661. 

  661.     tmp1 = (z1 - z2 - z3) << CONST_BITS;
    662. 

  662. 

  663.     /* Final output stage */
    664. 

  664. 

  665.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    666. 

  666. 					      CONST_BITS+PASS1_BITS+3)
    667. 

  667. 			    & RANGE_MASK];
    668. 

  668.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    669. 

  669. 					      CONST_BITS+PASS1_BITS+3)
    670. 

  670. 			    & RANGE_MASK];
    671. 

  671.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
    672. 

  672. 					      CONST_BITS+PASS1_BITS+3)
    673. 

  673. 			    & RANGE_MASK];
    674. 

  674.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
    675. 

  675. 					      CONST_BITS+PASS1_BITS+3)
    676. 

  676. 			    & RANGE_MASK];
    677. 

  677.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
    678. 

  678. 					      CONST_BITS+PASS1_BITS+3)
    679. 

  679. 			    & RANGE_MASK];
    680. 

  680.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
    681. 

  681. 					      CONST_BITS+PASS1_BITS+3)
    682. 

  682. 			    & RANGE_MASK];
    683. 

  683. 

  684.     wsptr += 6;		/* advance pointer to next row */
    685. 

  685.   }
    686. 

  686. }
    687. 

  687. 

  688. 

  689. /*
    690. 

  690.  * Perform dequantization and inverse DCT on one block of coefficients,
    691. 

  691.  * producing a reduced-size 5x5 output block.
    692. 

  692.  *
    693. 

  693.  * Optimized algorithm with 5 multiplications in the 1-D kernel.
    694. 

  694.  * cK represents sqrt(2) * cos(K*pi/10).
    695. 

  695.  */
    696. 

  696. 

  697. GLOBAL(void)
    698. 

  698. jpeg_idct_5x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    699. 

  699. 	       JCOEFPTR coef_block,
    700. 

  700. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    701. 

  701. {
    702. 

  702.   INT32 tmp0, tmp1, tmp10, tmp11, tmp12;
    703. 

  703.   INT32 z1, z2, z3;
    704. 

  704.   JCOEFPTR inptr;
    705. 

  705.   ISLOW_MULT_TYPE * quantptr;
    706. 

  706.   int * wsptr;
    707. 

  707.   JSAMPROW outptr;
    708. 

  708.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    709. 

  709.   int ctr;
    710. 

  710.   int workspace[5*5];	/* buffers data between passes */
    711. 

  711.   SHIFT_TEMPS
    712. 

  712. 

  713.   /* Pass 1: process columns from input, store into work array. */
    714. 

  714. 

  715.   inptr = coef_block;
    716. 

  716.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    717. 

  717.   wsptr = workspace;
    718. 

  718.   for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
    719. 

  719.     /* Even part */
    720. 

  720. 

  721.     tmp12 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    722. 

  722.     tmp12 <<= CONST_BITS;
    723. 

  723.     /* Add fudge factor here for final descale. */
    724. 

  724.     tmp12 += ONE << (CONST_BITS-PASS1_BITS-1);
    725. 

  725.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    726. 

  726.     tmp1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    727. 

  727.     z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
    728. 

  728.     z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
    729. 

  729.     z3 = tmp12 + z2;
    730. 

  730.     tmp10 = z3 + z1;
    731. 

  731.     tmp11 = z3 - z1;
    732. 

  732.     tmp12 -= z2 << 2;
    733. 

  733. 

  734.     /* Odd part */
    735. 

  735. 

  736.     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    737. 

  737.     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    738. 

  738. 

  739.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
    740. 

  740.     tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
    741. 

  741.     tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
    742. 

  742. 

  743.     /* Final output stage */
    744. 

  744. 

  745.     wsptr[5*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
    746. 

  746.     wsptr[5*4] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
    747. 

  747.     wsptr[5*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
    748. 

  748.     wsptr[5*3] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
    749. 

  749.     wsptr[5*2] = (int) RIGHT_SHIFT(tmp12, CONST_BITS-PASS1_BITS);
    750. 

  750.   }
    751. 

  751. 

  752.   /* Pass 2: process 5 rows from work array, store into output array. */
    753. 

  753. 

  754.   wsptr = workspace;
    755. 

  755.   for (ctr = 0; ctr < 5; ctr++) {
    756. 

  756.     outptr = output_buf[ctr] + output_col;
    757. 

  757. 

  758.     /* Even part */
    759. 

  759. 

  760.     /* Add fudge factor here for final descale. */
    761. 

  761.     tmp12 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    762. 

  762.     tmp12 <<= CONST_BITS;
    763. 

  763.     tmp0 = (INT32) wsptr[2];
    764. 

  764.     tmp1 = (INT32) wsptr[4];
    765. 

  765.     z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
    766. 

  766.     z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
    767. 

  767.     z3 = tmp12 + z2;
    768. 

  768.     tmp10 = z3 + z1;
    769. 

  769.     tmp11 = z3 - z1;
    770. 

  770.     tmp12 -= z2 << 2;
    771. 

  771. 

  772.     /* Odd part */
    773. 

  773. 

  774.     z2 = (INT32) wsptr[1];
    775. 

  775.     z3 = (INT32) wsptr[3];
    776. 

  776. 

  777.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
    778. 

  778.     tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
    779. 

  779.     tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
    780. 

  780. 

  781.     /* Final output stage */
    782. 

  782. 

  783.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    784. 

  784. 					      CONST_BITS+PASS1_BITS+3)
    785. 

  785. 			    & RANGE_MASK];
    786. 

  786.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    787. 

  787. 					      CONST_BITS+PASS1_BITS+3)
    788. 

  788. 			    & RANGE_MASK];
    789. 

  789.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
    790. 

  790. 					      CONST_BITS+PASS1_BITS+3)
    791. 

  791. 			    & RANGE_MASK];
    792. 

  792.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
    793. 

  793. 					      CONST_BITS+PASS1_BITS+3)
    794. 

  794. 			    & RANGE_MASK];
    795. 

  795.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12,
    796. 

  796. 					      CONST_BITS+PASS1_BITS+3)
    797. 

  797. 			    & RANGE_MASK];
    798. 

  798. 

  799.     wsptr += 5;		/* advance pointer to next row */
    800. 

  800.   }
    801. 

  801. }
    802. 

  802. 

  803. 

  804. /*
    805. 

  805.  * Perform dequantization and inverse DCT on one block of coefficients,
    806. 

  806.  * producing a reduced-size 4x4 output block.
    807. 

  807.  *
    808. 

  808.  * Optimized algorithm with 3 multiplications in the 1-D kernel.
    809. 

  809.  * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
    810. 

  810.  */
    811. 

  811. 

  812. GLOBAL(void)
    813. 

  813. jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    814. 

  814. 	       JCOEFPTR coef_block,
    815. 

  815. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    816. 

  816. {
    817. 

  817.   INT32 tmp0, tmp2, tmp10, tmp12;
    818. 

  818.   INT32 z1, z2, z3;
    819. 

  819.   JCOEFPTR inptr;
    820. 

  820.   ISLOW_MULT_TYPE * quantptr;
    821. 

  821.   int * wsptr;
    822. 

  822.   JSAMPROW outptr;
    823. 

  823.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    824. 

  824.   int ctr;
    825. 

  825.   int workspace[4*4];	/* buffers data between passes */
    826. 

  826.   SHIFT_TEMPS
    827. 

  827. 

  828.   /* Pass 1: process columns from input, store into work array. */
    829. 

  829. 

  830.   inptr = coef_block;
    831. 

  831.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    832. 

  832.   wsptr = workspace;
    833. 

  833.   for (ctr = 0; ctr < 4; ctr++, inptr++, quantptr++, wsptr++) {
    834. 

  834.     /* Even part */
    835. 

  835. 

  836.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    837. 

  837.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    838. 

  838.     
    839. 

  839.     tmp10 = (tmp0 + tmp2) << PASS1_BITS;
    840. 

  840.     tmp12 = (tmp0 - tmp2) << PASS1_BITS;
    841. 

  841. 

  842.     /* Odd part */
    843. 

  843.     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
    844. 

  844. 

  845.     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    846. 

  846.     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    847. 

  847. 

  848.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);               /* c6 */
    849. 

  849.     /* Add fudge factor here for final descale. */
    850. 

  850.     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
    851. 

  851.     tmp0 = RIGHT_SHIFT(z1 + MULTIPLY(z2, FIX_0_765366865), /* c2-c6 */
    852. 

  852. 		       CONST_BITS-PASS1_BITS);
    853. 

  853.     tmp2 = RIGHT_SHIFT(z1 - MULTIPLY(z3, FIX_1_847759065), /* c2+c6 */
    854. 

  854. 		       CONST_BITS-PASS1_BITS);
    855. 

  855. 

  856.     /* Final output stage */
    857. 

  857. 

  858.     wsptr[4*0] = (int) (tmp10 + tmp0);
    859. 

  859.     wsptr[4*3] = (int) (tmp10 - tmp0);
    860. 

  860.     wsptr[4*1] = (int) (tmp12 + tmp2);
    861. 

  861.     wsptr[4*2] = (int) (tmp12 - tmp2);
    862. 

  862.   }
    863. 

  863. 

  864.   /* Pass 2: process 4 rows from work array, store into output array. */
    865. 

  865. 

  866.   wsptr = workspace;
    867. 

  867.   for (ctr = 0; ctr < 4; ctr++) {
    868. 

  868.     outptr = output_buf[ctr] + output_col;
    869. 

  869. 

  870.     /* Even part */
    871. 

  871. 

  872.     /* Add fudge factor here for final descale. */
    873. 

  873.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    874. 

  874.     tmp2 = (INT32) wsptr[2];
    875. 

  875. 

  876.     tmp10 = (tmp0 + tmp2) << CONST_BITS;
    877. 

  877.     tmp12 = (tmp0 - tmp2) << CONST_BITS;
    878. 

  878. 

  879.     /* Odd part */
    880. 

  880.     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
    881. 

  881. 

  882.     z2 = (INT32) wsptr[1];
    883. 

  883.     z3 = (INT32) wsptr[3];
    884. 

  884. 

  885.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
    886. 

  886.     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
    887. 

  887.     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
    888. 

  888. 

  889.     /* Final output stage */
    890. 

  890. 

  891.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    892. 

  892. 					      CONST_BITS+PASS1_BITS+3)
    893. 

  893. 			    & RANGE_MASK];
    894. 

  894.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    895. 

  895. 					      CONST_BITS+PASS1_BITS+3)
    896. 

  896. 			    & RANGE_MASK];
    897. 

  897.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
    898. 

  898. 					      CONST_BITS+PASS1_BITS+3)
    899. 

  899. 			    & RANGE_MASK];
    900. 

  900.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
    901. 

  901. 					      CONST_BITS+PASS1_BITS+3)
    902. 

  902. 			    & RANGE_MASK];
    903. 

  903. 

  904.     wsptr += 4;		/* advance pointer to next row */
    905. 

  905.   }
    906. 

  906. }
    907. 

  907. 

  908. 

  909. /*
    910. 

  910.  * Perform dequantization and inverse DCT on one block of coefficients,
    911. 

  911.  * producing a reduced-size 3x3 output block.
    912. 

  912.  *
    913. 

  913.  * Optimized algorithm with 2 multiplications in the 1-D kernel.
    914. 

  914.  * cK represents sqrt(2) * cos(K*pi/6).
    915. 

  915.  */
    916. 

  916. 

  917. GLOBAL(void)
    918. 

  918. jpeg_idct_3x3 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    919. 

  919. 	       JCOEFPTR coef_block,
    920. 

  920. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    921. 

  921. {
    922. 

  922.   INT32 tmp0, tmp2, tmp10, tmp12;
    923. 

  923.   JCOEFPTR inptr;
    924. 

  924.   ISLOW_MULT_TYPE * quantptr;
    925. 

  925.   int * wsptr;
    926. 

  926.   JSAMPROW outptr;
    927. 

  927.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    928. 

  928.   int ctr;
    929. 

  929.   int workspace[3*3];	/* buffers data between passes */
    930. 

  930.   SHIFT_TEMPS
    931. 

  931. 

  932.   /* Pass 1: process columns from input, store into work array. */
    933. 

  933. 

  934.   inptr = coef_block;
    935. 

  935.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    936. 

  936.   wsptr = workspace;
    937. 

  937.   for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
    938. 

  938.     /* Even part */
    939. 

  939. 

  940.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    941. 

  941.     tmp0 <<= CONST_BITS;
    942. 

  942.     /* Add fudge factor here for final descale. */
    943. 

  943.     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
    944. 

  944.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    945. 

  945.     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
    946. 

  946.     tmp10 = tmp0 + tmp12;
    947. 

  947.     tmp2 = tmp0 - tmp12 - tmp12;
    948. 

  948. 

  949.     /* Odd part */
    950. 

  950. 

  951.     tmp12 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    952. 

  952.     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
    953. 

  953. 

  954.     /* Final output stage */
    955. 

  955. 

  956.     wsptr[3*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
    957. 

  957.     wsptr[3*2] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
    958. 

  958.     wsptr[3*1] = (int) RIGHT_SHIFT(tmp2, CONST_BITS-PASS1_BITS);
    959. 

  959.   }
    960. 

  960. 

  961.   /* Pass 2: process 3 rows from work array, store into output array. */
    962. 

  962. 

  963.   wsptr = workspace;
    964. 

  964.   for (ctr = 0; ctr < 3; ctr++) {
    965. 

  965.     outptr = output_buf[ctr] + output_col;
    966. 

  966. 

  967.     /* Even part */
    968. 

  968. 

  969.     /* Add fudge factor here for final descale. */
    970. 

  970.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    971. 

  971.     tmp0 <<= CONST_BITS;
    972. 

  972.     tmp2 = (INT32) wsptr[2];
    973. 

  973.     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
    974. 

  974.     tmp10 = tmp0 + tmp12;
    975. 

  975.     tmp2 = tmp0 - tmp12 - tmp12;
    976. 

  976. 

  977.     /* Odd part */
    978. 

  978. 

  979.     tmp12 = (INT32) wsptr[1];
    980. 

  980.     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
    981. 

  981. 

  982.     /* Final output stage */
    983. 

  983. 

  984.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    985. 

  985. 					      CONST_BITS+PASS1_BITS+3)
    986. 

  986. 			    & RANGE_MASK];
    987. 

  987.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    988. 

  988. 					      CONST_BITS+PASS1_BITS+3)
    989. 

  989. 			    & RANGE_MASK];
    990. 

  990.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2,
    991. 

  991. 					      CONST_BITS+PASS1_BITS+3)
    992. 

  992. 			    & RANGE_MASK];
    993. 

  993. 

  994.     wsptr += 3;		/* advance pointer to next row */
    995. 

  995.   }
    996. 

  996. }
    997. 

  997. 

  998. 

  999. /*
    1000. 

  1000.  * Perform dequantization and inverse DCT on one block of coefficients,
    1001. 

  1001.  * producing a reduced-size 2x2 output block.
    1002. 

  1002.  *
    1003. 

  1003.  * Multiplication-less algorithm.
    1004. 

  1004.  */
    1005. 

  1005. 

  1006. GLOBAL(void)
    1007. 

  1007. jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    1008. 

  1008. 	       JCOEFPTR coef_block,
    1009. 

  1009. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    1010. 

  1010. {
    1011. 

  1011.   INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
    1012. 

  1012.   ISLOW_MULT_TYPE * quantptr;
    1013. 

  1013.   JSAMPROW outptr;
    1014. 

  1014.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    1015. 

  1015.   SHIFT_TEMPS
    1016. 

  1016. 

  1017.   /* Pass 1: process columns from input. */
    1018. 

  1018. 

  1019.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    1020. 

  1020. 

  1021.   /* Column 0 */
    1022. 

  1022.   tmp4 = DEQUANTIZE(coef_block[DCTSIZE*0], quantptr[DCTSIZE*0]);
    1023. 

  1023.   tmp5 = DEQUANTIZE(coef_block[DCTSIZE*1], quantptr[DCTSIZE*1]);
    1024. 

  1024.   /* Add fudge factor here for final descale. */
    1025. 

  1025.   tmp4 += ONE << 2;
    1026. 

  1026. 

  1027.   tmp0 = tmp4 + tmp5;
    1028. 

  1028.   tmp2 = tmp4 - tmp5;
    1029. 

  1029. 

  1030.   /* Column 1 */
    1031. 

  1031.   tmp4 = DEQUANTIZE(coef_block[DCTSIZE*0+1], quantptr[DCTSIZE*0+1]);
    1032. 

  1032.   tmp5 = DEQUANTIZE(coef_block[DCTSIZE*1+1], quantptr[DCTSIZE*1+1]);
    1033. 

  1033. 

  1034.   tmp1 = tmp4 + tmp5;
    1035. 

  1035.   tmp3 = tmp4 - tmp5;
    1036. 

  1036. 

  1037.   /* Pass 2: process 2 rows, store into output array. */
    1038. 

  1038. 

  1039.   /* Row 0 */
    1040. 

  1040.   outptr = output_buf[0] + output_col;
    1041. 

  1041. 

  1042.   outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp0 + tmp1, 3) & RANGE_MASK];
    1043. 

  1043.   outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp0 - tmp1, 3) & RANGE_MASK];
    1044. 

  1044. 

  1045.   /* Row 1 */
    1046. 

  1046.   outptr = output_buf[1] + output_col;
    1047. 

  1047. 

  1048.   outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp2 + tmp3, 3) & RANGE_MASK];
    1049. 

  1049.   outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2 - tmp3, 3) & RANGE_MASK];
    1050. 

  1050. }
    1051. 

  1051. 

  1052. 

  1053. /*
    1054. 

  1054.  * Perform dequantization and inverse DCT on one block of coefficients,
    1055. 

  1055.  * producing a reduced-size 1x1 output block.
    1056. 

  1056.  *
    1057. 

  1057.  * We hardly need an inverse DCT routine for this: just take the
    1058. 

  1058.  * average pixel value, which is one-eighth of the DC coefficient.
    1059. 

  1059.  */
    1060. 

  1060. 

  1061. GLOBAL(void)
    1062. 

  1062. jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    1063. 

  1063. 	       JCOEFPTR coef_block,
    1064. 

  1064. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    1065. 

  1065. {
    1066. 

  1066.   int dcval;
    1067. 

  1067.   ISLOW_MULT_TYPE * quantptr;
    1068. 

  1068.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    1069. 

  1069.   SHIFT_TEMPS
    1070. 

  1070. 

  1071.   /* 1x1 is trivial: just take the DC coefficient divided by 8. */
    1072. 

  1072.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    1073. 

  1073.   dcval = DEQUANTIZE(coef_block[0], quantptr[0]);
    1074. 

  1074.   dcval = (int) DESCALE((INT32) dcval, 3);
    1075. 

  1075. 

  1076.   output_buf[0][output_col] = range_limit[dcval & RANGE_MASK];
    1077. 

  1077. }
    1078. 

  1078. 

  1079. 

  1080. /*
    1081. 

  1081.  * Perform dequantization and inverse DCT on one block of coefficients,
    1082. 

  1082.  * producing a 9x9 output block.
    1083. 

  1083.  *
    1084. 

  1084.  * Optimized algorithm with 10 multiplications in the 1-D kernel.
    1085. 

  1085.  * cK represents sqrt(2) * cos(K*pi/18).
    1086. 

  1086.  */
    1087. 

  1087. 

  1088. GLOBAL(void)
    1089. 

  1089. jpeg_idct_9x9 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    1090. 

  1090. 	       JCOEFPTR coef_block,
    1091. 

  1091. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    1092. 

  1092. {
    1093. 

  1093.   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13, tmp14;
    1094. 

  1094.   INT32 z1, z2, z3, z4;
    1095. 

  1095.   JCOEFPTR inptr;
    1096. 

  1096.   ISLOW_MULT_TYPE * quantptr;
    1097. 

  1097.   int * wsptr;
    1098. 

  1098.   JSAMPROW outptr;
    1099. 

  1099.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    1100. 

  1100.   int ctr;
    1101. 

  1101.   int workspace[8*9];	/* buffers data between passes */
    1102. 

  1102.   SHIFT_TEMPS
    1103. 

  1103. 

  1104.   /* Pass 1: process columns from input, store into work array. */
    1105. 

  1105. 

  1106.   inptr = coef_block;
    1107. 

  1107.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    1108. 

  1108.   wsptr = workspace;
    1109. 

  1109.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    1110. 

  1110.     /* Even part */
    1111. 

  1111. 

  1112.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    1113. 

  1113.     tmp0 <<= CONST_BITS;
    1114. 

  1114.     /* Add fudge factor here for final descale. */
    1115. 

  1115.     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
    1116. 

  1116. 

  1117.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    1118. 

  1118.     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    1119. 

  1119.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    1120. 

  1120. 

  1121.     tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
    1122. 

  1122.     tmp1 = tmp0 + tmp3;
    1123. 

  1123.     tmp2 = tmp0 - tmp3 - tmp3;
    1124. 

  1124. 

  1125.     tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
    1126. 

  1126.     tmp11 = tmp2 + tmp0;
    1127. 

  1127.     tmp14 = tmp2 - tmp0 - tmp0;
    1128. 

  1128. 

  1129.     tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
    1130. 

  1130.     tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
    1131. 

  1131.     tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
    1132. 

  1132. 

  1133.     tmp10 = tmp1 + tmp0 - tmp3;
    1134. 

  1134.     tmp12 = tmp1 - tmp0 + tmp2;
    1135. 

  1135.     tmp13 = tmp1 - tmp2 + tmp3;
    1136. 

  1136. 

  1137.     /* Odd part */
    1138. 

  1138. 

  1139.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    1140. 

  1140.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    1141. 

  1141.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    1142. 

  1142.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    1143. 

  1143. 

  1144.     z2 = MULTIPLY(z2, - FIX(1.224744871));           /* -c3 */
    1145. 

  1145. 

  1146.     tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
    1147. 

  1147.     tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
    1148. 

  1148.     tmp0 = tmp2 + tmp3 - z2;
    1149. 

  1149.     tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
    1150. 

  1150.     tmp2 += z2 - tmp1;
    1151. 

  1151.     tmp3 += z2 + tmp1;
    1152. 

  1152.     tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
    1153. 

  1153. 

  1154.     /* Final output stage */
    1155. 

  1155. 

  1156.     wsptr[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
    1157. 

  1157.     wsptr[8*8] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
    1158. 

  1158.     wsptr[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
    1159. 

  1159.     wsptr[8*7] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
    1160. 

  1160.     wsptr[8*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
    1161. 

  1161.     wsptr[8*6] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
    1162. 

  1162.     wsptr[8*3] = (int) RIGHT_SHIFT(tmp13 + tmp3, CONST_BITS-PASS1_BITS);
    1163. 

  1163.     wsptr[8*5] = (int) RIGHT_SHIFT(tmp13 - tmp3, CONST_BITS-PASS1_BITS);
    1164. 

  1164.     wsptr[8*4] = (int) RIGHT_SHIFT(tmp14, CONST_BITS-PASS1_BITS);
    1165. 

  1165.   }
    1166. 

  1166. 

  1167.   /* Pass 2: process 9 rows from work array, store into output array. */
    1168. 

  1168. 

  1169.   wsptr = workspace;
    1170. 

  1170.   for (ctr = 0; ctr < 9; ctr++) {
    1171. 

  1171.     outptr = output_buf[ctr] + output_col;
    1172. 

  1172. 

  1173.     /* Even part */
    1174. 

  1174. 

  1175.     /* Add fudge factor here for final descale. */
    1176. 

  1176.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    1177. 

  1177.     tmp0 <<= CONST_BITS;
    1178. 

  1178. 

  1179.     z1 = (INT32) wsptr[2];
    1180. 

  1180.     z2 = (INT32) wsptr[4];
    1181. 

  1181.     z3 = (INT32) wsptr[6];
    1182. 

  1182. 

  1183.     tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
    1184. 

  1184.     tmp1 = tmp0 + tmp3;
    1185. 

  1185.     tmp2 = tmp0 - tmp3 - tmp3;
    1186. 

  1186. 

  1187.     tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
    1188. 

  1188.     tmp11 = tmp2 + tmp0;
    1189. 

  1189.     tmp14 = tmp2 - tmp0 - tmp0;
    1190. 

  1190. 

  1191.     tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
    1192. 

  1192.     tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
    1193. 

  1193.     tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
    1194. 

  1194. 

  1195.     tmp10 = tmp1 + tmp0 - tmp3;
    1196. 

  1196.     tmp12 = tmp1 - tmp0 + tmp2;
    1197. 

  1197.     tmp13 = tmp1 - tmp2 + tmp3;
    1198. 

  1198. 

  1199.     /* Odd part */
    1200. 

  1200. 

  1201.     z1 = (INT32) wsptr[1];
    1202. 

  1202.     z2 = (INT32) wsptr[3];
    1203. 

  1203.     z3 = (INT32) wsptr[5];
    1204. 

  1204.     z4 = (INT32) wsptr[7];
    1205. 

  1205. 

  1206.     z2 = MULTIPLY(z2, - FIX(1.224744871));           /* -c3 */
    1207. 

  1207. 

  1208.     tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
    1209. 

  1209.     tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
    1210. 

  1210.     tmp0 = tmp2 + tmp3 - z2;
    1211. 

  1211.     tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
    1212. 

  1212.     tmp2 += z2 - tmp1;
    1213. 

  1213.     tmp3 += z2 + tmp1;
    1214. 

  1214.     tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
    1215. 

  1215. 

  1216.     /* Final output stage */
    1217. 

  1217. 

  1218.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    1219. 

  1219. 					      CONST_BITS+PASS1_BITS+3)
    1220. 

  1220. 			    & RANGE_MASK];
    1221. 

  1221.     outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    1222. 

  1222. 					      CONST_BITS+PASS1_BITS+3)
    1223. 

  1223. 			    & RANGE_MASK];
    1224. 

  1224.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
    1225. 

  1225. 					      CONST_BITS+PASS1_BITS+3)
    1226. 

  1226. 			    & RANGE_MASK];
    1227. 

  1227.     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
    1228. 

  1228. 					      CONST_BITS+PASS1_BITS+3)
    1229. 

  1229. 			    & RANGE_MASK];
    1230. 

  1230.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
    1231. 

  1231. 					      CONST_BITS+PASS1_BITS+3)
    1232. 

  1232. 			    & RANGE_MASK];
    1233. 

  1233.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
    1234. 

  1234. 					      CONST_BITS+PASS1_BITS+3)
    1235. 

  1235. 			    & RANGE_MASK];
    1236. 

  1236.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp3,
    1237. 

  1237. 					      CONST_BITS+PASS1_BITS+3)
    1238. 

  1238. 			    & RANGE_MASK];
    1239. 

  1239.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp3,
    1240. 

  1240. 					      CONST_BITS+PASS1_BITS+3)
    1241. 

  1241. 			    & RANGE_MASK];
    1242. 

  1242.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp14,
    1243. 

  1243. 					      CONST_BITS+PASS1_BITS+3)
    1244. 

  1244. 			    & RANGE_MASK];
    1245. 

  1245. 

  1246.     wsptr += 8;		/* advance pointer to next row */
    1247. 

  1247.   }
    1248. 

  1248. }
    1249. 

  1249. 

  1250. 

  1251. /*
    1252. 

  1252.  * Perform dequantization and inverse DCT on one block of coefficients,
    1253. 

  1253.  * producing a 10x10 output block.
    1254. 

  1254.  *
    1255. 

  1255.  * Optimized algorithm with 12 multiplications in the 1-D kernel.
    1256. 

  1256.  * cK represents sqrt(2) * cos(K*pi/20).
    1257. 

  1257.  */
    1258. 

  1258. 

  1259. GLOBAL(void)
    1260. 

  1260. jpeg_idct_10x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    1261. 

  1261. 		 JCOEFPTR coef_block,
    1262. 

  1262. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    1263. 

  1263. {
    1264. 

  1264.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
    1265. 

  1265.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
    1266. 

  1266.   INT32 z1, z2, z3, z4, z5;
    1267. 

  1267.   JCOEFPTR inptr;
    1268. 

  1268.   ISLOW_MULT_TYPE * quantptr;
    1269. 

  1269.   int * wsptr;
    1270. 

  1270.   JSAMPROW outptr;
    1271. 

  1271.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    1272. 

  1272.   int ctr;
    1273. 

  1273.   int workspace[8*10];	/* buffers data between passes */
    1274. 

  1274.   SHIFT_TEMPS
    1275. 

  1275. 

  1276.   /* Pass 1: process columns from input, store into work array. */
    1277. 

  1277. 

  1278.   inptr = coef_block;
    1279. 

  1279.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    1280. 

  1280.   wsptr = workspace;
    1281. 

  1281.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    1282. 

  1282.     /* Even part */
    1283. 

  1283. 

  1284.     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    1285. 

  1285.     z3 <<= CONST_BITS;
    1286. 

  1286.     /* Add fudge factor here for final descale. */
    1287. 

  1287.     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
    1288. 

  1288.     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    1289. 

  1289.     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
    1290. 

  1290.     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
    1291. 

  1291.     tmp10 = z3 + z1;
    1292. 

  1292.     tmp11 = z3 - z2;
    1293. 

  1293. 

  1294.     tmp22 = RIGHT_SHIFT(z3 - ((z1 - z2) << 1),   /* c0 = (c4-c8)*2 */
    1295. 

  1295. 			CONST_BITS-PASS1_BITS);
    1296. 

  1296. 

  1297.     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    1298. 

  1298.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    1299. 

  1299. 

  1300.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
    1301. 

  1301.     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
    1302. 

  1302.     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
    1303. 

  1303. 

  1304.     tmp20 = tmp10 + tmp12;
    1305. 

  1305.     tmp24 = tmp10 - tmp12;
    1306. 

  1306.     tmp21 = tmp11 + tmp13;
    1307. 

  1307.     tmp23 = tmp11 - tmp13;
    1308. 

  1308. 

  1309.     /* Odd part */
    1310. 

  1310. 

  1311.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    1312. 

  1312.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    1313. 

  1313.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    1314. 

  1314.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    1315. 

  1315. 

  1316.     tmp11 = z2 + z4;
    1317. 

  1317.     tmp13 = z2 - z4;
    1318. 

  1318. 

  1319.     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
    1320. 

  1320.     z5 = z3 << CONST_BITS;
    1321. 

  1321. 

  1322.     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
    1323. 

  1323.     z4 = z5 + tmp12;
    1324. 

  1324. 

  1325.     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
    1326. 

  1326.     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
    1327. 

  1327. 

  1328.     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
    1329. 

  1329.     z4 = z5 - tmp12 - (tmp13 << (CONST_BITS - 1));
    1330. 

  1330. 

  1331.     tmp12 = (z1 - tmp13 - z3) << PASS1_BITS;
    1332. 

  1332. 

  1333.     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
    1334. 

  1334.     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
    1335. 

  1335. 

  1336.     /* Final output stage */
    1337. 

  1337. 

  1338.     wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    1339. 

  1339.     wsptr[8*9] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    1340. 

  1340.     wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    1341. 

  1341.     wsptr[8*8] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    1342. 

  1342.     wsptr[8*2] = (int) (tmp22 + tmp12);
    1343. 

  1343.     wsptr[8*7] = (int) (tmp22 - tmp12);
    1344. 

  1344.     wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
    1345. 

  1345.     wsptr[8*6] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
    1346. 

  1346.     wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    1347. 

  1347.     wsptr[8*5] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    1348. 

  1348.   }
    1349. 

  1349. 

  1350.   /* Pass 2: process 10 rows from work array, store into output array. */
    1351. 

  1351. 

  1352.   wsptr = workspace;
    1353. 

  1353.   for (ctr = 0; ctr < 10; ctr++) {
    1354. 

  1354.     outptr = output_buf[ctr] + output_col;
    1355. 

  1355. 

  1356.     /* Even part */
    1357. 

  1357. 

  1358.     /* Add fudge factor here for final descale. */
    1359. 

  1359.     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    1360. 

  1360.     z3 <<= CONST_BITS;
    1361. 

  1361.     z4 = (INT32) wsptr[4];
    1362. 

  1362.     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
    1363. 

  1363.     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
    1364. 

  1364.     tmp10 = z3 + z1;
    1365. 

  1365.     tmp11 = z3 - z2;
    1366. 

  1366. 

  1367.     tmp22 = z3 - ((z1 - z2) << 1);               /* c0 = (c4-c8)*2 */
    1368. 

  1368. 

  1369.     z2 = (INT32) wsptr[2];
    1370. 

  1370.     z3 = (INT32) wsptr[6];
    1371. 

  1371. 

  1372.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
    1373. 

  1373.     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
    1374. 

  1374.     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
    1375. 

  1375. 

  1376.     tmp20 = tmp10 + tmp12;
    1377. 

  1377.     tmp24 = tmp10 - tmp12;
    1378. 

  1378.     tmp21 = tmp11 + tmp13;
    1379. 

  1379.     tmp23 = tmp11 - tmp13;
    1380. 

  1380. 

  1381.     /* Odd part */
    1382. 

  1382. 

  1383.     z1 = (INT32) wsptr[1];
    1384. 

  1384.     z2 = (INT32) wsptr[3];
    1385. 

  1385.     z3 = (INT32) wsptr[5];
    1386. 

  1386.     z3 <<= CONST_BITS;
    1387. 

  1387.     z4 = (INT32) wsptr[7];
    1388. 

  1388. 

  1389.     tmp11 = z2 + z4;
    1390. 

  1390.     tmp13 = z2 - z4;
    1391. 

  1391. 

  1392.     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
    1393. 

  1393. 

  1394.     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
    1395. 

  1395.     z4 = z3 + tmp12;
    1396. 

  1396. 

  1397.     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
    1398. 

  1398.     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
    1399. 

  1399. 

  1400.     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
    1401. 

  1401.     z4 = z3 - tmp12 - (tmp13 << (CONST_BITS - 1));
    1402. 

  1402. 

  1403.     tmp12 = ((z1 - tmp13) << CONST_BITS) - z3;
    1404. 

  1404. 

  1405.     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
    1406. 

  1406.     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
    1407. 

  1407. 

  1408.     /* Final output stage */
    1409. 

  1409. 

  1410.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    1411. 

  1411. 					      CONST_BITS+PASS1_BITS+3)
    1412. 

  1412. 			    & RANGE_MASK];
    1413. 

  1413.     outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    1414. 

  1414. 					      CONST_BITS+PASS1_BITS+3)
    1415. 

  1415. 			    & RANGE_MASK];
    1416. 

  1416.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    1417. 

  1417. 					      CONST_BITS+PASS1_BITS+3)
    1418. 

  1418. 			    & RANGE_MASK];
    1419. 

  1419.     outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    1420. 

  1420. 					      CONST_BITS+PASS1_BITS+3)
    1421. 

  1421. 			    & RANGE_MASK];
    1422. 

  1422.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    1423. 

  1423. 					      CONST_BITS+PASS1_BITS+3)
    1424. 

  1424. 			    & RANGE_MASK];
    1425. 

  1425.     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    1426. 

  1426. 					      CONST_BITS+PASS1_BITS+3)
    1427. 

  1427. 			    & RANGE_MASK];
    1428. 

  1428.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    1429. 

  1429. 					      CONST_BITS+PASS1_BITS+3)
    1430. 

  1430. 			    & RANGE_MASK];
    1431. 

  1431.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    1432. 

  1432. 					      CONST_BITS+PASS1_BITS+3)
    1433. 

  1433. 			    & RANGE_MASK];
    1434. 

  1434.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    1435. 

  1435. 					      CONST_BITS+PASS1_BITS+3)
    1436. 

  1436. 			    & RANGE_MASK];
    1437. 

  1437.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    1438. 

  1438. 					      CONST_BITS+PASS1_BITS+3)
    1439. 

  1439. 			    & RANGE_MASK];
    1440. 

  1440. 

  1441.     wsptr += 8;		/* advance pointer to next row */
    1442. 

  1442.   }
    1443. 

  1443. }
    1444. 

  1444. 

  1445. 

  1446. /*
    1447. 

  1447.  * Perform dequantization and inverse DCT on one block of coefficients,
    1448. 

  1448.  * producing a 11x11 output block.
    1449. 

  1449.  *
    1450. 

  1450.  * Optimized algorithm with 24 multiplications in the 1-D kernel.
    1451. 

  1451.  * cK represents sqrt(2) * cos(K*pi/22).
    1452. 

  1452.  */
    1453. 

  1453. 

  1454. GLOBAL(void)
    1455. 

  1455. jpeg_idct_11x11 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    1456. 

  1456. 		 JCOEFPTR coef_block,
    1457. 

  1457. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    1458. 

  1458. {
    1459. 

  1459.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
    1460. 

  1460.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
    1461. 

  1461.   INT32 z1, z2, z3, z4;
    1462. 

  1462.   JCOEFPTR inptr;
    1463. 

  1463.   ISLOW_MULT_TYPE * quantptr;
    1464. 

  1464.   int * wsptr;
    1465. 

  1465.   JSAMPROW outptr;
    1466. 

  1466.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    1467. 

  1467.   int ctr;
    1468. 

  1468.   int workspace[8*11];	/* buffers data between passes */
    1469. 

  1469.   SHIFT_TEMPS
    1470. 

  1470. 

  1471.   /* Pass 1: process columns from input, store into work array. */
    1472. 

  1472. 

  1473.   inptr = coef_block;
    1474. 

  1474.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    1475. 

  1475.   wsptr = workspace;
    1476. 

  1476.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    1477. 

  1477.     /* Even part */
    1478. 

  1478. 

  1479.     tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    1480. 

  1480.     tmp10 <<= CONST_BITS;
    1481. 

  1481.     /* Add fudge factor here for final descale. */
    1482. 

  1482.     tmp10 += ONE << (CONST_BITS-PASS1_BITS-1);
    1483. 

  1483. 

  1484.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    1485. 

  1485.     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    1486. 

  1486.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    1487. 

  1487. 

  1488.     tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
    1489. 

  1489.     tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
    1490. 

  1490.     z4 = z1 + z3;
    1491. 

  1491.     tmp24 = MULTIPLY(z4, - FIX(1.155664402));        /* -(c2-c10) */
    1492. 

  1492.     z4 -= z2;
    1493. 

  1493.     tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
    1494. 

  1494.     tmp21 = tmp20 + tmp23 + tmp25 -
    1495. 

  1495. 	    MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
    1496. 

  1496.     tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
    1497. 

  1497.     tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
    1498. 

  1498.     tmp24 += tmp25;
    1499. 

  1499.     tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
    1500. 

  1500.     tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
    1501. 

  1501. 	     MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
    1502. 

  1502.     tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
    1503. 

  1503. 

  1504.     /* Odd part */
    1505. 

  1505. 

  1506.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    1507. 

  1507.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    1508. 

  1508.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    1509. 

  1509.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    1510. 

  1510. 

  1511.     tmp11 = z1 + z2;
    1512. 

  1512.     tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
    1513. 

  1513.     tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
    1514. 

  1514.     tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
    1515. 

  1515.     tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
    1516. 

  1516.     tmp10 = tmp11 + tmp12 + tmp13 -
    1517. 

  1517. 	    MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
    1518. 

  1518.     z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
    1519. 

  1519.     tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
    1520. 

  1520.     tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
    1521. 

  1521.     z1    = MULTIPLY(z2 + z4, - FIX(1.798248910));       /* -(c1+c9) */
    1522. 

  1522.     tmp11 += z1;
    1523. 

  1523.     tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
    1524. 

  1524.     tmp14 += MULTIPLY(z2, - FIX(1.467221301)) +          /* -(c5+c9) */
    1525. 

  1525. 	     MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
    1526. 

  1526. 	     MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
    1527. 

  1527. 

  1528.     /* Final output stage */
    1529. 

  1529. 

  1530.     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    1531. 

  1531.     wsptr[8*10] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    1532. 

  1532.     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    1533. 

  1533.     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    1534. 

  1534.     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    1535. 

  1535.     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    1536. 

  1536.     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
    1537. 

  1537.     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
    1538. 

  1538.     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    1539. 

  1539.     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    1540. 

  1540.     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25, CONST_BITS-PASS1_BITS);
    1541. 

  1541.   }
    1542. 

  1542. 

  1543.   /* Pass 2: process 11 rows from work array, store into output array. */
    1544. 

  1544. 

  1545.   wsptr = workspace;
    1546. 

  1546.   for (ctr = 0; ctr < 11; ctr++) {
    1547. 

  1547.     outptr = output_buf[ctr] + output_col;
    1548. 

  1548. 

  1549.     /* Even part */
    1550. 

  1550. 

  1551.     /* Add fudge factor here for final descale. */
    1552. 

  1552.     tmp10 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    1553. 

  1553.     tmp10 <<= CONST_BITS;
    1554. 

  1554. 

  1555.     z1 = (INT32) wsptr[2];
    1556. 

  1556.     z2 = (INT32) wsptr[4];
    1557. 

  1557.     z3 = (INT32) wsptr[6];
    1558. 

  1558. 

  1559.     tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
    1560. 

  1560.     tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
    1561. 

  1561.     z4 = z1 + z3;
    1562. 

  1562.     tmp24 = MULTIPLY(z4, - FIX(1.155664402));        /* -(c2-c10) */
    1563. 

  1563.     z4 -= z2;
    1564. 

  1564.     tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
    1565. 

  1565.     tmp21 = tmp20 + tmp23 + tmp25 -
    1566. 

  1566. 	    MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
    1567. 

  1567.     tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
    1568. 

  1568.     tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
    1569. 

  1569.     tmp24 += tmp25;
    1570. 

  1570.     tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
    1571. 

  1571.     tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
    1572. 

  1572. 	     MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
    1573. 

  1573.     tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
    1574. 

  1574. 

  1575.     /* Odd part */
    1576. 

  1576. 

  1577.     z1 = (INT32) wsptr[1];
    1578. 

  1578.     z2 = (INT32) wsptr[3];
    1579. 

  1579.     z3 = (INT32) wsptr[5];
    1580. 

  1580.     z4 = (INT32) wsptr[7];
    1581. 

  1581. 

  1582.     tmp11 = z1 + z2;
    1583. 

  1583.     tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
    1584. 

  1584.     tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
    1585. 

  1585.     tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
    1586. 

  1586.     tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
    1587. 

  1587.     tmp10 = tmp11 + tmp12 + tmp13 -
    1588. 

  1588. 	    MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
    1589. 

  1589.     z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
    1590. 

  1590.     tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
    1591. 

  1591.     tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
    1592. 

  1592.     z1    = MULTIPLY(z2 + z4, - FIX(1.798248910));       /* -(c1+c9) */
    1593. 

  1593.     tmp11 += z1;
    1594. 

  1594.     tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
    1595. 

  1595.     tmp14 += MULTIPLY(z2, - FIX(1.467221301)) +          /* -(c5+c9) */
    1596. 

  1596. 	     MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
    1597. 

  1597. 	     MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
    1598. 

  1598. 

  1599.     /* Final output stage */
    1600. 

  1600. 

  1601.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    1602. 

  1602. 					       CONST_BITS+PASS1_BITS+3)
    1603. 

  1603. 			     & RANGE_MASK];
    1604. 

  1604.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    1605. 

  1605. 					       CONST_BITS+PASS1_BITS+3)
    1606. 

  1606. 			     & RANGE_MASK];
    1607. 

  1607.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    1608. 

  1608. 					       CONST_BITS+PASS1_BITS+3)
    1609. 

  1609. 			     & RANGE_MASK];
    1610. 

  1610.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    1611. 

  1611. 					       CONST_BITS+PASS1_BITS+3)
    1612. 

  1612. 			     & RANGE_MASK];
    1613. 

  1613.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    1614. 

  1614. 					       CONST_BITS+PASS1_BITS+3)
    1615. 

  1615. 			     & RANGE_MASK];
    1616. 

  1616.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    1617. 

  1617. 					       CONST_BITS+PASS1_BITS+3)
    1618. 

  1618. 			     & RANGE_MASK];
    1619. 

  1619.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    1620. 

  1620. 					       CONST_BITS+PASS1_BITS+3)
    1621. 

  1621. 			     & RANGE_MASK];
    1622. 

  1622.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    1623. 

  1623. 					       CONST_BITS+PASS1_BITS+3)
    1624. 

  1624. 			     & RANGE_MASK];
    1625. 

  1625.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    1626. 

  1626. 					       CONST_BITS+PASS1_BITS+3)
    1627. 

  1627. 			     & RANGE_MASK];
    1628. 

  1628.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    1629. 

  1629. 					       CONST_BITS+PASS1_BITS+3)
    1630. 

  1630. 			     & RANGE_MASK];
    1631. 

  1631.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25,
    1632. 

  1632. 					       CONST_BITS+PASS1_BITS+3)
    1633. 

  1633. 			     & RANGE_MASK];
    1634. 

  1634. 

  1635.     wsptr += 8;		/* advance pointer to next row */
    1636. 

  1636.   }
    1637. 

  1637. }
    1638. 

  1638. 

  1639. 

  1640. /*
    1641. 

  1641.  * Perform dequantization and inverse DCT on one block of coefficients,
    1642. 

  1642.  * producing a 12x12 output block.
    1643. 

  1643.  *
    1644. 

  1644.  * Optimized algorithm with 15 multiplications in the 1-D kernel.
    1645. 

  1645.  * cK represents sqrt(2) * cos(K*pi/24).
    1646. 

  1646.  */
    1647. 

  1647. 

  1648. GLOBAL(void)
    1649. 

  1649. jpeg_idct_12x12 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    1650. 

  1650. 		 JCOEFPTR coef_block,
    1651. 

  1651. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    1652. 

  1652. {
    1653. 

  1653.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
    1654. 

  1654.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
    1655. 

  1655.   INT32 z1, z2, z3, z4;
    1656. 

  1656.   JCOEFPTR inptr;
    1657. 

  1657.   ISLOW_MULT_TYPE * quantptr;
    1658. 

  1658.   int * wsptr;
    1659. 

  1659.   JSAMPROW outptr;
    1660. 

  1660.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    1661. 

  1661.   int ctr;
    1662. 

  1662.   int workspace[8*12];	/* buffers data between passes */
    1663. 

  1663.   SHIFT_TEMPS
    1664. 

  1664. 

  1665.   /* Pass 1: process columns from input, store into work array. */
    1666. 

  1666. 

  1667.   inptr = coef_block;
    1668. 

  1668.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    1669. 

  1669.   wsptr = workspace;
    1670. 

  1670.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    1671. 

  1671.     /* Even part */
    1672. 

  1672. 

  1673.     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    1674. 

  1674.     z3 <<= CONST_BITS;
    1675. 

  1675.     /* Add fudge factor here for final descale. */
    1676. 

  1676.     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
    1677. 

  1677. 

  1678.     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    1679. 

  1679.     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
    1680. 

  1680. 

  1681.     tmp10 = z3 + z4;
    1682. 

  1682.     tmp11 = z3 - z4;
    1683. 

  1683. 

  1684.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    1685. 

  1685.     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
    1686. 

  1686.     z1 <<= CONST_BITS;
    1687. 

  1687.     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    1688. 

  1688.     z2 <<= CONST_BITS;
    1689. 

  1689. 

  1690.     tmp12 = z1 - z2;
    1691. 

  1691. 

  1692.     tmp21 = z3 + tmp12;
    1693. 

  1693.     tmp24 = z3 - tmp12;
    1694. 

  1694. 

  1695.     tmp12 = z4 + z2;
    1696. 

  1696. 

  1697.     tmp20 = tmp10 + tmp12;
    1698. 

  1698.     tmp25 = tmp10 - tmp12;
    1699. 

  1699. 

  1700.     tmp12 = z4 - z1 - z2;
    1701. 

  1701. 

  1702.     tmp22 = tmp11 + tmp12;
    1703. 

  1703.     tmp23 = tmp11 - tmp12;
    1704. 

  1704. 

  1705.     /* Odd part */
    1706. 

  1706. 

  1707.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    1708. 

  1708.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    1709. 

  1709.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    1710. 

  1710.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    1711. 

  1711. 

  1712.     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
    1713. 

  1713.     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
    1714. 

  1714. 

  1715.     tmp10 = z1 + z3;
    1716. 

  1716.     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
    1717. 

  1717.     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
    1718. 

  1718.     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
    1719. 

  1719.     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
    1720. 

  1720.     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
    1721. 

  1721.     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
    1722. 

  1722.     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
    1723. 

  1723. 	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
    1724. 

  1724. 

  1725.     z1 -= z4;
    1726. 

  1726.     z2 -= z3;
    1727. 

  1727.     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
    1728. 

  1728.     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
    1729. 

  1729.     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
    1730. 

  1730. 

  1731.     /* Final output stage */
    1732. 

  1732. 

  1733.     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    1734. 

  1734.     wsptr[8*11] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    1735. 

  1735.     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    1736. 

  1736.     wsptr[8*10] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    1737. 

  1737.     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    1738. 

  1738.     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    1739. 

  1739.     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
    1740. 

  1740.     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
    1741. 

  1741.     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    1742. 

  1742.     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    1743. 

  1743.     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
    1744. 

  1744.     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
    1745. 

  1745.   }
    1746. 

  1746. 

  1747.   /* Pass 2: process 12 rows from work array, store into output array. */
    1748. 

  1748. 

  1749.   wsptr = workspace;
    1750. 

  1750.   for (ctr = 0; ctr < 12; ctr++) {
    1751. 

  1751.     outptr = output_buf[ctr] + output_col;
    1752. 

  1752. 

  1753.     /* Even part */
    1754. 

  1754. 

  1755.     /* Add fudge factor here for final descale. */
    1756. 

  1756.     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    1757. 

  1757.     z3 <<= CONST_BITS;
    1758. 

  1758. 

  1759.     z4 = (INT32) wsptr[4];
    1760. 

  1760.     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
    1761. 

  1761. 

  1762.     tmp10 = z3 + z4;
    1763. 

  1763.     tmp11 = z3 - z4;
    1764. 

  1764. 

  1765.     z1 = (INT32) wsptr[2];
    1766. 

  1766.     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
    1767. 

  1767.     z1 <<= CONST_BITS;
    1768. 

  1768.     z2 = (INT32) wsptr[6];
    1769. 

  1769.     z2 <<= CONST_BITS;
    1770. 

  1770. 

  1771.     tmp12 = z1 - z2;
    1772. 

  1772. 

  1773.     tmp21 = z3 + tmp12;
    1774. 

  1774.     tmp24 = z3 - tmp12;
    1775. 

  1775. 

  1776.     tmp12 = z4 + z2;
    1777. 

  1777. 

  1778.     tmp20 = tmp10 + tmp12;
    1779. 

  1779.     tmp25 = tmp10 - tmp12;
    1780. 

  1780. 

  1781.     tmp12 = z4 - z1 - z2;
    1782. 

  1782. 

  1783.     tmp22 = tmp11 + tmp12;
    1784. 

  1784.     tmp23 = tmp11 - tmp12;
    1785. 

  1785. 

  1786.     /* Odd part */
    1787. 

  1787. 

  1788.     z1 = (INT32) wsptr[1];
    1789. 

  1789.     z2 = (INT32) wsptr[3];
    1790. 

  1790.     z3 = (INT32) wsptr[5];
    1791. 

  1791.     z4 = (INT32) wsptr[7];
    1792. 

  1792. 

  1793.     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
    1794. 

  1794.     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
    1795. 

  1795. 

  1796.     tmp10 = z1 + z3;
    1797. 

  1797.     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
    1798. 

  1798.     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
    1799. 

  1799.     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
    1800. 

  1800.     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
    1801. 

  1801.     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
    1802. 

  1802.     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
    1803. 

  1803.     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
    1804. 

  1804. 	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
    1805. 

  1805. 

  1806.     z1 -= z4;
    1807. 

  1807.     z2 -= z3;
    1808. 

  1808.     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
    1809. 

  1809.     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
    1810. 

  1810.     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
    1811. 

  1811. 

  1812.     /* Final output stage */
    1813. 

  1813. 

  1814.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    1815. 

  1815. 					       CONST_BITS+PASS1_BITS+3)
    1816. 

  1816. 			     & RANGE_MASK];
    1817. 

  1817.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    1818. 

  1818. 					       CONST_BITS+PASS1_BITS+3)
    1819. 

  1819. 			     & RANGE_MASK];
    1820. 

  1820.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    1821. 

  1821. 					       CONST_BITS+PASS1_BITS+3)
    1822. 

  1822. 			     & RANGE_MASK];
    1823. 

  1823.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    1824. 

  1824. 					       CONST_BITS+PASS1_BITS+3)
    1825. 

  1825. 			     & RANGE_MASK];
    1826. 

  1826.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    1827. 

  1827. 					       CONST_BITS+PASS1_BITS+3)
    1828. 

  1828. 			     & RANGE_MASK];
    1829. 

  1829.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    1830. 

  1830. 					       CONST_BITS+PASS1_BITS+3)
    1831. 

  1831. 			     & RANGE_MASK];
    1832. 

  1832.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    1833. 

  1833. 					       CONST_BITS+PASS1_BITS+3)
    1834. 

  1834. 			     & RANGE_MASK];
    1835. 

  1835.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    1836. 

  1836. 					       CONST_BITS+PASS1_BITS+3)
    1837. 

  1837. 			     & RANGE_MASK];
    1838. 

  1838.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    1839. 

  1839. 					       CONST_BITS+PASS1_BITS+3)
    1840. 

  1840. 			     & RANGE_MASK];
    1841. 

  1841.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    1842. 

  1842. 					       CONST_BITS+PASS1_BITS+3)
    1843. 

  1843. 			     & RANGE_MASK];
    1844. 

  1844.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
    1845. 

  1845. 					       CONST_BITS+PASS1_BITS+3)
    1846. 

  1846. 			     & RANGE_MASK];
    1847. 

  1847.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
    1848. 

  1848. 					       CONST_BITS+PASS1_BITS+3)
    1849. 

  1849. 			     & RANGE_MASK];
    1850. 

  1850. 

  1851.     wsptr += 8;		/* advance pointer to next row */
    1852. 

  1852.   }
    1853. 

  1853. }
    1854. 

  1854. 

  1855. 

  1856. /*
    1857. 

  1857.  * Perform dequantization and inverse DCT on one block of coefficients,
    1858. 

  1858.  * producing a 13x13 output block.
    1859. 

  1859.  *
    1860. 

  1860.  * Optimized algorithm with 29 multiplications in the 1-D kernel.
    1861. 

  1861.  * cK represents sqrt(2) * cos(K*pi/26).
    1862. 

  1862.  */
    1863. 

  1863. 

  1864. GLOBAL(void)
    1865. 

  1865. jpeg_idct_13x13 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    1866. 

  1866. 		 JCOEFPTR coef_block,
    1867. 

  1867. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    1868. 

  1868. {
    1869. 

  1869.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
    1870. 

  1870.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
    1871. 

  1871.   INT32 z1, z2, z3, z4;
    1872. 

  1872.   JCOEFPTR inptr;
    1873. 

  1873.   ISLOW_MULT_TYPE * quantptr;
    1874. 

  1874.   int * wsptr;
    1875. 

  1875.   JSAMPROW outptr;
    1876. 

  1876.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    1877. 

  1877.   int ctr;
    1878. 

  1878.   int workspace[8*13];	/* buffers data between passes */
    1879. 

  1879.   SHIFT_TEMPS
    1880. 

  1880. 

  1881.   /* Pass 1: process columns from input, store into work array. */
    1882. 

  1882. 

  1883.   inptr = coef_block;
    1884. 

  1884.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    1885. 

  1885.   wsptr = workspace;
    1886. 

  1886.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    1887. 

  1887.     /* Even part */
    1888. 

  1888. 

  1889.     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    1890. 

  1890.     z1 <<= CONST_BITS;
    1891. 

  1891.     /* Add fudge factor here for final descale. */
    1892. 

  1892.     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
    1893. 

  1893. 

  1894.     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    1895. 

  1895.     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    1896. 

  1896.     z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    1897. 

  1897. 

  1898.     tmp10 = z3 + z4;
    1899. 

  1899.     tmp11 = z3 - z4;
    1900. 

  1900. 

  1901.     tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
    1902. 

  1902.     tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
    1903. 

  1903. 

  1904.     tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
    1905. 

  1905.     tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
    1906. 

  1906. 

  1907.     tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
    1908. 

  1908.     tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
    1909. 

  1909. 

  1910.     tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
    1911. 

  1911.     tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
    1912. 

  1912. 

  1913.     tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
    1914. 

  1914.     tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
    1915. 

  1915. 

  1916.     tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
    1917. 

  1917.     tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
    1918. 

  1918. 

  1919.     tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
    1920. 

  1920. 

  1921.     /* Odd part */
    1922. 

  1922. 

  1923.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    1924. 

  1924.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    1925. 

  1925.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    1926. 

  1926.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    1927. 

  1927. 

  1928.     tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
    1929. 

  1929.     tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
    1930. 

  1930.     tmp15 = z1 + z4;
    1931. 

  1931.     tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
    1932. 

  1932.     tmp10 = tmp11 + tmp12 + tmp13 -
    1933. 

  1933. 	    MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
    1934. 

  1934.     tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458));   /* -c11 */
    1935. 

  1935.     tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
    1936. 

  1936.     tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
    1937. 

  1937.     tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945));   /* -c5 */
    1938. 

  1938.     tmp11 += tmp14;
    1939. 

  1939.     tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
    1940. 

  1940.     tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813));   /* -c9 */
    1941. 

  1941.     tmp12 += tmp14;
    1942. 

  1942.     tmp13 += tmp14;
    1943. 

  1943.     tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
    1944. 

  1944.     tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
    1945. 

  1945. 	    MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
    1946. 

  1946.     z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
    1947. 

  1947.     tmp14 += z1;
    1948. 

  1948.     tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
    1949. 

  1949. 	     MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
    1950. 

  1950. 

  1951.     /* Final output stage */
    1952. 

  1952. 

  1953.     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    1954. 

  1954.     wsptr[8*12] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    1955. 

  1955.     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    1956. 

  1956.     wsptr[8*11] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    1957. 

  1957.     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    1958. 

  1958.     wsptr[8*10] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    1959. 

  1959.     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
    1960. 

  1960.     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
    1961. 

  1961.     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    1962. 

  1962.     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    1963. 

  1963.     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
    1964. 

  1964.     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
    1965. 

  1965.     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26, CONST_BITS-PASS1_BITS);
    1966. 

  1966.   }
    1967. 

  1967. 

  1968.   /* Pass 2: process 13 rows from work array, store into output array. */
    1969. 

  1969. 

  1970.   wsptr = workspace;
    1971. 

  1971.   for (ctr = 0; ctr < 13; ctr++) {
    1972. 

  1972.     outptr = output_buf[ctr] + output_col;
    1973. 

  1973. 

  1974.     /* Even part */
    1975. 

  1975. 

  1976.     /* Add fudge factor here for final descale. */
    1977. 

  1977.     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    1978. 

  1978.     z1 <<= CONST_BITS;
    1979. 

  1979. 

  1980.     z2 = (INT32) wsptr[2];
    1981. 

  1981.     z3 = (INT32) wsptr[4];
    1982. 

  1982.     z4 = (INT32) wsptr[6];
    1983. 

  1983. 

  1984.     tmp10 = z3 + z4;
    1985. 

  1985.     tmp11 = z3 - z4;
    1986. 

  1986. 

  1987.     tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
    1988. 

  1988.     tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
    1989. 

  1989. 

  1990.     tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
    1991. 

  1991.     tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
    1992. 

  1992. 

  1993.     tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
    1994. 

  1994.     tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
    1995. 

  1995. 

  1996.     tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
    1997. 

  1997.     tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
    1998. 

  1998. 

  1999.     tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
    2000. 

  2000.     tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
    2001. 

  2001. 

  2002.     tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
    2003. 

  2003.     tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
    2004. 

  2004. 

  2005.     tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
    2006. 

  2006. 

  2007.     /* Odd part */
    2008. 

  2008. 

  2009.     z1 = (INT32) wsptr[1];
    2010. 

  2010.     z2 = (INT32) wsptr[3];
    2011. 

  2011.     z3 = (INT32) wsptr[5];
    2012. 

  2012.     z4 = (INT32) wsptr[7];
    2013. 

  2013. 

  2014.     tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
    2015. 

  2015.     tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
    2016. 

  2016.     tmp15 = z1 + z4;
    2017. 

  2017.     tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
    2018. 

  2018.     tmp10 = tmp11 + tmp12 + tmp13 -
    2019. 

  2019. 	    MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
    2020. 

  2020.     tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458));   /* -c11 */
    2021. 

  2021.     tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
    2022. 

  2022.     tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
    2023. 

  2023.     tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945));   /* -c5 */
    2024. 

  2024.     tmp11 += tmp14;
    2025. 

  2025.     tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
    2026. 

  2026.     tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813));   /* -c9 */
    2027. 

  2027.     tmp12 += tmp14;
    2028. 

  2028.     tmp13 += tmp14;
    2029. 

  2029.     tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
    2030. 

  2030.     tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
    2031. 

  2031. 	    MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
    2032. 

  2032.     z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
    2033. 

  2033.     tmp14 += z1;
    2034. 

  2034.     tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
    2035. 

  2035. 	     MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
    2036. 

  2036. 

  2037.     /* Final output stage */
    2038. 

  2038. 

  2039.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    2040. 

  2040. 					       CONST_BITS+PASS1_BITS+3)
    2041. 

  2041. 			     & RANGE_MASK];
    2042. 

  2042.     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    2043. 

  2043. 					       CONST_BITS+PASS1_BITS+3)
    2044. 

  2044. 			     & RANGE_MASK];
    2045. 

  2045.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    2046. 

  2046. 					       CONST_BITS+PASS1_BITS+3)
    2047. 

  2047. 			     & RANGE_MASK];
    2048. 

  2048.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    2049. 

  2049. 					       CONST_BITS+PASS1_BITS+3)
    2050. 

  2050. 			     & RANGE_MASK];
    2051. 

  2051.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    2052. 

  2052. 					       CONST_BITS+PASS1_BITS+3)
    2053. 

  2053. 			     & RANGE_MASK];
    2054. 

  2054.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    2055. 

  2055. 					       CONST_BITS+PASS1_BITS+3)
    2056. 

  2056. 			     & RANGE_MASK];
    2057. 

  2057.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    2058. 

  2058. 					       CONST_BITS+PASS1_BITS+3)
    2059. 

  2059. 			     & RANGE_MASK];
    2060. 

  2060.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    2061. 

  2061. 					       CONST_BITS+PASS1_BITS+3)
    2062. 

  2062. 			     & RANGE_MASK];
    2063. 

  2063.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    2064. 

  2064. 					       CONST_BITS+PASS1_BITS+3)
    2065. 

  2065. 			     & RANGE_MASK];
    2066. 

  2066.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    2067. 

  2067. 					       CONST_BITS+PASS1_BITS+3)
    2068. 

  2068. 			     & RANGE_MASK];
    2069. 

  2069.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
    2070. 

  2070. 					       CONST_BITS+PASS1_BITS+3)
    2071. 

  2071. 			     & RANGE_MASK];
    2072. 

  2072.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
    2073. 

  2073. 					       CONST_BITS+PASS1_BITS+3)
    2074. 

  2074. 			     & RANGE_MASK];
    2075. 

  2075.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26,
    2076. 

  2076. 					       CONST_BITS+PASS1_BITS+3)
    2077. 

  2077. 			     & RANGE_MASK];
    2078. 

  2078. 

  2079.     wsptr += 8;		/* advance pointer to next row */
    2080. 

  2080.   }
    2081. 

  2081. }
    2082. 

  2082. 

  2083. 

  2084. /*
    2085. 

  2085.  * Perform dequantization and inverse DCT on one block of coefficients,
    2086. 

  2086.  * producing a 14x14 output block.
    2087. 

  2087.  *
    2088. 

  2088.  * Optimized algorithm with 20 multiplications in the 1-D kernel.
    2089. 

  2089.  * cK represents sqrt(2) * cos(K*pi/28).
    2090. 

  2090.  */
    2091. 

  2091. 

  2092. GLOBAL(void)
    2093. 

  2093. jpeg_idct_14x14 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    2094. 

  2094. 		 JCOEFPTR coef_block,
    2095. 

  2095. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    2096. 

  2096. {
    2097. 

  2097.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
    2098. 

  2098.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
    2099. 

  2099.   INT32 z1, z2, z3, z4;
    2100. 

  2100.   JCOEFPTR inptr;
    2101. 

  2101.   ISLOW_MULT_TYPE * quantptr;
    2102. 

  2102.   int * wsptr;
    2103. 

  2103.   JSAMPROW outptr;
    2104. 

  2104.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    2105. 

  2105.   int ctr;
    2106. 

  2106.   int workspace[8*14];	/* buffers data between passes */
    2107. 

  2107.   SHIFT_TEMPS
    2108. 

  2108. 

  2109.   /* Pass 1: process columns from input, store into work array. */
    2110. 

  2110. 

  2111.   inptr = coef_block;
    2112. 

  2112.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    2113. 

  2113.   wsptr = workspace;
    2114. 

  2114.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    2115. 

  2115.     /* Even part */
    2116. 

  2116. 

  2117.     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    2118. 

  2118.     z1 <<= CONST_BITS;
    2119. 

  2119.     /* Add fudge factor here for final descale. */
    2120. 

  2120.     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
    2121. 

  2121.     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    2122. 

  2122.     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
    2123. 

  2123.     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
    2124. 

  2124.     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
    2125. 

  2125. 

  2126.     tmp10 = z1 + z2;
    2127. 

  2127.     tmp11 = z1 + z3;
    2128. 

  2128.     tmp12 = z1 - z4;
    2129. 

  2129. 

  2130.     tmp23 = RIGHT_SHIFT(z1 - ((z2 + z3 - z4) << 1), /* c0 = (c4+c12-c8)*2 */
    2131. 

  2131. 			CONST_BITS-PASS1_BITS);
    2132. 

  2132. 

  2133.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    2134. 

  2134.     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    2135. 

  2135. 

  2136.     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
    2137. 

  2137. 

  2138.     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
    2139. 

  2139.     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
    2140. 

  2140.     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
    2141. 

  2141. 	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
    2142. 

  2142. 

  2143.     tmp20 = tmp10 + tmp13;
    2144. 

  2144.     tmp26 = tmp10 - tmp13;
    2145. 

  2145.     tmp21 = tmp11 + tmp14;
    2146. 

  2146.     tmp25 = tmp11 - tmp14;
    2147. 

  2147.     tmp22 = tmp12 + tmp15;
    2148. 

  2148.     tmp24 = tmp12 - tmp15;
    2149. 

  2149. 

  2150.     /* Odd part */
    2151. 

  2151. 

  2152.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    2153. 

  2153.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    2154. 

  2154.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    2155. 

  2155.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    2156. 

  2156.     tmp13 = z4 << CONST_BITS;
    2157. 

  2157. 

  2158.     tmp14 = z1 + z3;
    2159. 

  2159.     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
    2160. 

  2160.     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
    2161. 

  2161.     tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
    2162. 

  2162.     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
    2163. 

  2163.     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
    2164. 

  2164.     z1    -= z2;
    2165. 

  2165.     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13;        /* c11 */
    2166. 

  2166.     tmp16 += tmp15;
    2167. 

  2167.     z1    += z4;
    2168. 

  2168.     z4    = MULTIPLY(z2 + z3, - FIX(0.158341681)) - tmp13; /* -c13 */
    2169. 

  2169.     tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948));          /* c3-c9-c13 */
    2170. 

  2170.     tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773));          /* c3+c5-c13 */
    2171. 

  2171.     z4    = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
    2172. 

  2172.     tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
    2173. 

  2173.     tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567));          /* c1+c11-c5 */
    2174. 

  2174. 

  2175.     tmp13 = (z1 - z3) << PASS1_BITS;
    2176. 

  2176. 

  2177.     /* Final output stage */
    2178. 

  2178. 

  2179.     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    2180. 

  2180.     wsptr[8*13] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    2181. 

  2181.     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    2182. 

  2182.     wsptr[8*12] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    2183. 

  2183.     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    2184. 

  2184.     wsptr[8*11] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    2185. 

  2185.     wsptr[8*3]  = (int) (tmp23 + tmp13);
    2186. 

  2186.     wsptr[8*10] = (int) (tmp23 - tmp13);
    2187. 

  2187.     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    2188. 

  2188.     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    2189. 

  2189.     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
    2190. 

  2190.     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
    2191. 

  2191.     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
    2192. 

  2192.     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
    2193. 

  2193.   }
    2194. 

  2194. 

  2195.   /* Pass 2: process 14 rows from work array, store into output array. */
    2196. 

  2196. 

  2197.   wsptr = workspace;
    2198. 

  2198.   for (ctr = 0; ctr < 14; ctr++) {
    2199. 

  2199.     outptr = output_buf[ctr] + output_col;
    2200. 

  2200. 

  2201.     /* Even part */
    2202. 

  2202. 

  2203.     /* Add fudge factor here for final descale. */
    2204. 

  2204.     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    2205. 

  2205.     z1 <<= CONST_BITS;
    2206. 

  2206.     z4 = (INT32) wsptr[4];
    2207. 

  2207.     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
    2208. 

  2208.     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
    2209. 

  2209.     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
    2210. 

  2210. 

  2211.     tmp10 = z1 + z2;
    2212. 

  2212.     tmp11 = z1 + z3;
    2213. 

  2213.     tmp12 = z1 - z4;
    2214. 

  2214. 

  2215.     tmp23 = z1 - ((z2 + z3 - z4) << 1);          /* c0 = (c4+c12-c8)*2 */
    2216. 

  2216. 

  2217.     z1 = (INT32) wsptr[2];
    2218. 

  2218.     z2 = (INT32) wsptr[6];
    2219. 

  2219. 

  2220.     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
    2221. 

  2221. 

  2222.     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
    2223. 

  2223.     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
    2224. 

  2224.     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
    2225. 

  2225. 	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
    2226. 

  2226. 

  2227.     tmp20 = tmp10 + tmp13;
    2228. 

  2228.     tmp26 = tmp10 - tmp13;
    2229. 

  2229.     tmp21 = tmp11 + tmp14;
    2230. 

  2230.     tmp25 = tmp11 - tmp14;
    2231. 

  2231.     tmp22 = tmp12 + tmp15;
    2232. 

  2232.     tmp24 = tmp12 - tmp15;
    2233. 

  2233. 

  2234.     /* Odd part */
    2235. 

  2235. 

  2236.     z1 = (INT32) wsptr[1];
    2237. 

  2237.     z2 = (INT32) wsptr[3];
    2238. 

  2238.     z3 = (INT32) wsptr[5];
    2239. 

  2239.     z4 = (INT32) wsptr[7];
    2240. 

  2240.     z4 <<= CONST_BITS;
    2241. 

  2241. 

  2242.     tmp14 = z1 + z3;
    2243. 

  2243.     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
    2244. 

  2244.     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
    2245. 

  2245.     tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
    2246. 

  2246.     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
    2247. 

  2247.     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
    2248. 

  2248.     z1    -= z2;
    2249. 

  2249.     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4;           /* c11 */
    2250. 

  2250.     tmp16 += tmp15;
    2251. 

  2251.     tmp13 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - z4;    /* -c13 */
    2252. 

  2252.     tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948));       /* c3-c9-c13 */
    2253. 

  2253.     tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773));       /* c3+c5-c13 */
    2254. 

  2254.     tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
    2255. 

  2255.     tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
    2256. 

  2256.     tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567));       /* c1+c11-c5 */
    2257. 

  2257. 

  2258.     tmp13 = ((z1 - z3) << CONST_BITS) + z4;
    2259. 

  2259. 

  2260.     /* Final output stage */
    2261. 

  2261. 

  2262.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    2263. 

  2263. 					       CONST_BITS+PASS1_BITS+3)
    2264. 

  2264. 			     & RANGE_MASK];
    2265. 

  2265.     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    2266. 

  2266. 					       CONST_BITS+PASS1_BITS+3)
    2267. 

  2267. 			     & RANGE_MASK];
    2268. 

  2268.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    2269. 

  2269. 					       CONST_BITS+PASS1_BITS+3)
    2270. 

  2270. 			     & RANGE_MASK];
    2271. 

  2271.     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    2272. 

  2272. 					       CONST_BITS+PASS1_BITS+3)
    2273. 

  2273. 			     & RANGE_MASK];
    2274. 

  2274.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    2275. 

  2275. 					       CONST_BITS+PASS1_BITS+3)
    2276. 

  2276. 			     & RANGE_MASK];
    2277. 

  2277.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    2278. 

  2278. 					       CONST_BITS+PASS1_BITS+3)
    2279. 

  2279. 			     & RANGE_MASK];
    2280. 

  2280.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    2281. 

  2281. 					       CONST_BITS+PASS1_BITS+3)
    2282. 

  2282. 			     & RANGE_MASK];
    2283. 

  2283.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    2284. 

  2284. 					       CONST_BITS+PASS1_BITS+3)
    2285. 

  2285. 			     & RANGE_MASK];
    2286. 

  2286.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    2287. 

  2287. 					       CONST_BITS+PASS1_BITS+3)
    2288. 

  2288. 			     & RANGE_MASK];
    2289. 

  2289.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    2290. 

  2290. 					       CONST_BITS+PASS1_BITS+3)
    2291. 

  2291. 			     & RANGE_MASK];
    2292. 

  2292.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
    2293. 

  2293. 					       CONST_BITS+PASS1_BITS+3)
    2294. 

  2294. 			     & RANGE_MASK];
    2295. 

  2295.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
    2296. 

  2296. 					       CONST_BITS+PASS1_BITS+3)
    2297. 

  2297. 			     & RANGE_MASK];
    2298. 

  2298.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
    2299. 

  2299. 					       CONST_BITS+PASS1_BITS+3)
    2300. 

  2300. 			     & RANGE_MASK];
    2301. 

  2301.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
    2302. 

  2302. 					       CONST_BITS+PASS1_BITS+3)
    2303. 

  2303. 			     & RANGE_MASK];
    2304. 

  2304. 

  2305.     wsptr += 8;		/* advance pointer to next row */
    2306. 

  2306.   }
    2307. 

  2307. }
    2308. 

  2308. 

  2309. 

  2310. /*
    2311. 

  2311.  * Perform dequantization and inverse DCT on one block of coefficients,
    2312. 

  2312.  * producing a 15x15 output block.
    2313. 

  2313.  *
    2314. 

  2314.  * Optimized algorithm with 22 multiplications in the 1-D kernel.
    2315. 

  2315.  * cK represents sqrt(2) * cos(K*pi/30).
    2316. 

  2316.  */
    2317. 

  2317. 

  2318. GLOBAL(void)
    2319. 

  2319. jpeg_idct_15x15 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    2320. 

  2320. 		 JCOEFPTR coef_block,
    2321. 

  2321. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    2322. 

  2322. {
    2323. 

  2323.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
    2324. 

  2324.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
    2325. 

  2325.   INT32 z1, z2, z3, z4;
    2326. 

  2326.   JCOEFPTR inptr;
    2327. 

  2327.   ISLOW_MULT_TYPE * quantptr;
    2328. 

  2328.   int * wsptr;
    2329. 

  2329.   JSAMPROW outptr;
    2330. 

  2330.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    2331. 

  2331.   int ctr;
    2332. 

  2332.   int workspace[8*15];	/* buffers data between passes */
    2333. 

  2333.   SHIFT_TEMPS
    2334. 

  2334. 

  2335.   /* Pass 1: process columns from input, store into work array. */
    2336. 

  2336. 

  2337.   inptr = coef_block;
    2338. 

  2338.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    2339. 

  2339.   wsptr = workspace;
    2340. 

  2340.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    2341. 

  2341.     /* Even part */
    2342. 

  2342. 

  2343.     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    2344. 

  2344.     z1 <<= CONST_BITS;
    2345. 

  2345.     /* Add fudge factor here for final descale. */
    2346. 

  2346.     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
    2347. 

  2347. 

  2348.     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    2349. 

  2349.     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    2350. 

  2350.     z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    2351. 

  2351. 

  2352.     tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
    2353. 

  2353.     tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
    2354. 

  2354. 

  2355.     tmp12 = z1 - tmp10;
    2356. 

  2356.     tmp13 = z1 + tmp11;
    2357. 

  2357.     z1 -= (tmp11 - tmp10) << 1;             /* c0 = (c6-c12)*2 */
    2358. 

  2358. 

  2359.     z4 = z2 - z3;
    2360. 

  2360.     z3 += z2;
    2361. 

  2361.     tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
    2362. 

  2362.     tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
    2363. 

  2363.     z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
    2364. 

  2364. 

  2365.     tmp20 = tmp13 + tmp10 + tmp11;
    2366. 

  2366.     tmp23 = tmp12 - tmp10 + tmp11 + z2;
    2367. 

  2367. 

  2368.     tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
    2369. 

  2369.     tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
    2370. 

  2370. 

  2371.     tmp25 = tmp13 - tmp10 - tmp11;
    2372. 

  2372.     tmp26 = tmp12 + tmp10 - tmp11 - z2;
    2373. 

  2373. 

  2374.     tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
    2375. 

  2375.     tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
    2376. 

  2376. 

  2377.     tmp21 = tmp12 + tmp10 + tmp11;
    2378. 

  2378.     tmp24 = tmp13 - tmp10 + tmp11;
    2379. 

  2379.     tmp11 += tmp11;
    2380. 

  2380.     tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
    2381. 

  2381.     tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
    2382. 

  2382. 

  2383.     /* Odd part */
    2384. 

  2384. 

  2385.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    2386. 

  2386.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    2387. 

  2387.     z4 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    2388. 

  2388.     z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
    2389. 

  2389.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    2390. 

  2390. 

  2391.     tmp13 = z2 - z4;
    2392. 

  2392.     tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
    2393. 

  2393.     tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
    2394. 

  2394.     tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
    2395. 

  2395. 

  2396.     tmp13 = MULTIPLY(z2, - FIX(0.831253876));               /* -c9 */
    2397. 

  2397.     tmp15 = MULTIPLY(z2, - FIX(1.344997024));               /* -c3 */
    2398. 

  2398.     z2 = z1 - z4;
    2399. 

  2399.     tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
    2400. 

  2400. 

  2401.     tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
    2402. 

  2402.     tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
    2403. 

  2403.     tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
    2404. 

  2404.     z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
    2405. 

  2405.     tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
    2406. 

  2406.     tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
    2407. 

  2407. 

  2408.     /* Final output stage */
    2409. 

  2409. 

  2410.     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    2411. 

  2411.     wsptr[8*14] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    2412. 

  2412.     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    2413. 

  2413.     wsptr[8*13] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    2414. 

  2414.     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    2415. 

  2415.     wsptr[8*12] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    2416. 

  2416.     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
    2417. 

  2417.     wsptr[8*11] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
    2418. 

  2418.     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    2419. 

  2419.     wsptr[8*10] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    2420. 

  2420.     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
    2421. 

  2421.     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
    2422. 

  2422.     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
    2423. 

  2423.     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
    2424. 

  2424.     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27, CONST_BITS-PASS1_BITS);
    2425. 

  2425.   }
    2426. 

  2426. 

  2427.   /* Pass 2: process 15 rows from work array, store into output array. */
    2428. 

  2428. 

  2429.   wsptr = workspace;
    2430. 

  2430.   for (ctr = 0; ctr < 15; ctr++) {
    2431. 

  2431.     outptr = output_buf[ctr] + output_col;
    2432. 

  2432. 

  2433.     /* Even part */
    2434. 

  2434. 

  2435.     /* Add fudge factor here for final descale. */
    2436. 

  2436.     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    2437. 

  2437.     z1 <<= CONST_BITS;
    2438. 

  2438. 

  2439.     z2 = (INT32) wsptr[2];
    2440. 

  2440.     z3 = (INT32) wsptr[4];
    2441. 

  2441.     z4 = (INT32) wsptr[6];
    2442. 

  2442. 

  2443.     tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
    2444. 

  2444.     tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
    2445. 

  2445. 

  2446.     tmp12 = z1 - tmp10;
    2447. 

  2447.     tmp13 = z1 + tmp11;
    2448. 

  2448.     z1 -= (tmp11 - tmp10) << 1;             /* c0 = (c6-c12)*2 */
    2449. 

  2449. 

  2450.     z4 = z2 - z3;
    2451. 

  2451.     z3 += z2;
    2452. 

  2452.     tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
    2453. 

  2453.     tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
    2454. 

  2454.     z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
    2455. 

  2455. 

  2456.     tmp20 = tmp13 + tmp10 + tmp11;
    2457. 

  2457.     tmp23 = tmp12 - tmp10 + tmp11 + z2;
    2458. 

  2458. 

  2459.     tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
    2460. 

  2460.     tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
    2461. 

  2461. 

  2462.     tmp25 = tmp13 - tmp10 - tmp11;
    2463. 

  2463.     tmp26 = tmp12 + tmp10 - tmp11 - z2;
    2464. 

  2464. 

  2465.     tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
    2466. 

  2466.     tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
    2467. 

  2467. 

  2468.     tmp21 = tmp12 + tmp10 + tmp11;
    2469. 

  2469.     tmp24 = tmp13 - tmp10 + tmp11;
    2470. 

  2470.     tmp11 += tmp11;
    2471. 

  2471.     tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
    2472. 

  2472.     tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
    2473. 

  2473. 

  2474.     /* Odd part */
    2475. 

  2475. 

  2476.     z1 = (INT32) wsptr[1];
    2477. 

  2477.     z2 = (INT32) wsptr[3];
    2478. 

  2478.     z4 = (INT32) wsptr[5];
    2479. 

  2479.     z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
    2480. 

  2480.     z4 = (INT32) wsptr[7];
    2481. 

  2481. 

  2482.     tmp13 = z2 - z4;
    2483. 

  2483.     tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
    2484. 

  2484.     tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
    2485. 

  2485.     tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
    2486. 

  2486. 

  2487.     tmp13 = MULTIPLY(z2, - FIX(0.831253876));               /* -c9 */
    2488. 

  2488.     tmp15 = MULTIPLY(z2, - FIX(1.344997024));               /* -c3 */
    2489. 

  2489.     z2 = z1 - z4;
    2490. 

  2490.     tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
    2491. 

  2491. 

  2492.     tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
    2493. 

  2493.     tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
    2494. 

  2494.     tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
    2495. 

  2495.     z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
    2496. 

  2496.     tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
    2497. 

  2497.     tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
    2498. 

  2498. 

  2499.     /* Final output stage */
    2500. 

  2500. 

  2501.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    2502. 

  2502. 					       CONST_BITS+PASS1_BITS+3)
    2503. 

  2503. 			     & RANGE_MASK];
    2504. 

  2504.     outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    2505. 

  2505. 					       CONST_BITS+PASS1_BITS+3)
    2506. 

  2506. 			     & RANGE_MASK];
    2507. 

  2507.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    2508. 

  2508. 					       CONST_BITS+PASS1_BITS+3)
    2509. 

  2509. 			     & RANGE_MASK];
    2510. 

  2510.     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    2511. 

  2511. 					       CONST_BITS+PASS1_BITS+3)
    2512. 

  2512. 			     & RANGE_MASK];
    2513. 

  2513.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    2514. 

  2514. 					       CONST_BITS+PASS1_BITS+3)
    2515. 

  2515. 			     & RANGE_MASK];
    2516. 

  2516.     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    2517. 

  2517. 					       CONST_BITS+PASS1_BITS+3)
    2518. 

  2518. 			     & RANGE_MASK];
    2519. 

  2519.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    2520. 

  2520. 					       CONST_BITS+PASS1_BITS+3)
    2521. 

  2521. 			     & RANGE_MASK];
    2522. 

  2522.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    2523. 

  2523. 					       CONST_BITS+PASS1_BITS+3)
    2524. 

  2524. 			     & RANGE_MASK];
    2525. 

  2525.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    2526. 

  2526. 					       CONST_BITS+PASS1_BITS+3)
    2527. 

  2527. 			     & RANGE_MASK];
    2528. 

  2528.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    2529. 

  2529. 					       CONST_BITS+PASS1_BITS+3)
    2530. 

  2530. 			     & RANGE_MASK];
    2531. 

  2531.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
    2532. 

  2532. 					       CONST_BITS+PASS1_BITS+3)
    2533. 

  2533. 			     & RANGE_MASK];
    2534. 

  2534.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
    2535. 

  2535. 					       CONST_BITS+PASS1_BITS+3)
    2536. 

  2536. 			     & RANGE_MASK];
    2537. 

  2537.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
    2538. 

  2538. 					       CONST_BITS+PASS1_BITS+3)
    2539. 

  2539. 			     & RANGE_MASK];
    2540. 

  2540.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
    2541. 

  2541. 					       CONST_BITS+PASS1_BITS+3)
    2542. 

  2542. 			     & RANGE_MASK];
    2543. 

  2543.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27,
    2544. 

  2544. 					       CONST_BITS+PASS1_BITS+3)
    2545. 

  2545. 			     & RANGE_MASK];
    2546. 

  2546. 

  2547.     wsptr += 8;		/* advance pointer to next row */
    2548. 

  2548.   }
    2549. 

  2549. }
    2550. 

  2550. 

  2551. 

  2552. /*
    2553. 

  2553.  * Perform dequantization and inverse DCT on one block of coefficients,
    2554. 

  2554.  * producing a 16x16 output block.
    2555. 

  2555.  *
    2556. 

  2556.  * Optimized algorithm with 28 multiplications in the 1-D kernel.
    2557. 

  2557.  * cK represents sqrt(2) * cos(K*pi/32).
    2558. 

  2558.  */
    2559. 

  2559. 

  2560. GLOBAL(void)
    2561. 

  2561. jpeg_idct_16x16 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    2562. 

  2562. 		 JCOEFPTR coef_block,
    2563. 

  2563. 		 JSAMPARRAY output_buf, JDIMENSION output_col)
    2564. 

  2564. {
    2565. 

  2565.   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
    2566. 

  2566.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
    2567. 

  2567.   INT32 z1, z2, z3, z4;
    2568. 

  2568.   JCOEFPTR inptr;
    2569. 

  2569.   ISLOW_MULT_TYPE * quantptr;
    2570. 

  2570.   int * wsptr;
    2571. 

  2571.   JSAMPROW outptr;
    2572. 

  2572.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    2573. 

  2573.   int ctr;
    2574. 

  2574.   int workspace[8*16];	/* buffers data between passes */
    2575. 

  2575.   SHIFT_TEMPS
    2576. 

  2576. 

  2577.   /* Pass 1: process columns from input, store into work array. */
    2578. 

  2578. 

  2579.   inptr = coef_block;
    2580. 

  2580.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    2581. 

  2581.   wsptr = workspace;
    2582. 

  2582.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    2583. 

  2583.     /* Even part */
    2584. 

  2584. 

  2585.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    2586. 

  2586.     tmp0 <<= CONST_BITS;
    2587. 

  2587.     /* Add fudge factor here for final descale. */
    2588. 

  2588.     tmp0 += 1 << (CONST_BITS-PASS1_BITS-1);
    2589. 

  2589. 

  2590.     z1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    2591. 

  2591.     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
    2592. 

  2592.     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
    2593. 

  2593. 

  2594.     tmp10 = tmp0 + tmp1;
    2595. 

  2595.     tmp11 = tmp0 - tmp1;
    2596. 

  2596.     tmp12 = tmp0 + tmp2;
    2597. 

  2597.     tmp13 = tmp0 - tmp2;
    2598. 

  2598. 

  2599.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    2600. 

  2600.     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    2601. 

  2601.     z3 = z1 - z2;
    2602. 

  2602.     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
    2603. 

  2603.     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
    2604. 

  2604. 

  2605.     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
    2606. 

  2606.     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
    2607. 

  2607.     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
    2608. 

  2608.     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
    2609. 

  2609. 

  2610.     tmp20 = tmp10 + tmp0;
    2611. 

  2611.     tmp27 = tmp10 - tmp0;
    2612. 

  2612.     tmp21 = tmp12 + tmp1;
    2613. 

  2613.     tmp26 = tmp12 - tmp1;
    2614. 

  2614.     tmp22 = tmp13 + tmp2;
    2615. 

  2615.     tmp25 = tmp13 - tmp2;
    2616. 

  2616.     tmp23 = tmp11 + tmp3;
    2617. 

  2617.     tmp24 = tmp11 - tmp3;
    2618. 

  2618. 

  2619.     /* Odd part */
    2620. 

  2620. 

  2621.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    2622. 

  2622.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    2623. 

  2623.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    2624. 

  2624.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    2625. 

  2625. 

  2626.     tmp11 = z1 + z3;
    2627. 

  2627. 

  2628.     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
    2629. 

  2629.     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
    2630. 

  2630.     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
    2631. 

  2631.     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
    2632. 

  2632.     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
    2633. 

  2633.     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
    2634. 

  2634.     tmp0  = tmp1 + tmp2 + tmp3 -
    2635. 

  2635. 	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
    2636. 

  2636.     tmp13 = tmp10 + tmp11 + tmp12 -
    2637. 

  2637. 	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
    2638. 

  2638.     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
    2639. 

  2639.     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
    2640. 

  2640.     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
    2641. 

  2641.     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
    2642. 

  2642.     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
    2643. 

  2643.     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
    2644. 

  2644.     z2    += z4;
    2645. 

  2645.     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
    2646. 

  2646.     tmp1  += z1;
    2647. 

  2647.     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
    2648. 

  2648.     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
    2649. 

  2649.     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
    2650. 

  2650.     tmp12 += z2;
    2651. 

  2651.     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
    2652. 

  2652.     tmp2  += z2;
    2653. 

  2653.     tmp3  += z2;
    2654. 

  2654.     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
    2655. 

  2655.     tmp10 += z2;
    2656. 

  2656.     tmp11 += z2;
    2657. 

  2657. 

  2658.     /* Final output stage */
    2659. 

  2659. 

  2660.     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp0,  CONST_BITS-PASS1_BITS);
    2661. 

  2661.     wsptr[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0,  CONST_BITS-PASS1_BITS);
    2662. 

  2662.     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp1,  CONST_BITS-PASS1_BITS);
    2663. 

  2663.     wsptr[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1,  CONST_BITS-PASS1_BITS);
    2664. 

  2664.     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp2,  CONST_BITS-PASS1_BITS);
    2665. 

  2665.     wsptr[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2,  CONST_BITS-PASS1_BITS);
    2666. 

  2666.     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp3,  CONST_BITS-PASS1_BITS);
    2667. 

  2667.     wsptr[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3,  CONST_BITS-PASS1_BITS);
    2668. 

  2668.     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
    2669. 

  2669.     wsptr[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
    2670. 

  2670.     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
    2671. 

  2671.     wsptr[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
    2672. 

  2672.     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
    2673. 

  2673.     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
    2674. 

  2674.     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
    2675. 

  2675.     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
    2676. 

  2676.   }
    2677. 

  2677. 

  2678.   /* Pass 2: process 16 rows from work array, store into output array. */
    2679. 

  2679. 

  2680.   wsptr = workspace;
    2681. 

  2681.   for (ctr = 0; ctr < 16; ctr++) {
    2682. 

  2682.     outptr = output_buf[ctr] + output_col;
    2683. 

  2683. 

  2684.     /* Even part */
    2685. 

  2685. 

  2686.     /* Add fudge factor here for final descale. */
    2687. 

  2687.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    2688. 

  2688.     tmp0 <<= CONST_BITS;
    2689. 

  2689. 

  2690.     z1 = (INT32) wsptr[4];
    2691. 

  2691.     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
    2692. 

  2692.     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
    2693. 

  2693. 

  2694.     tmp10 = tmp0 + tmp1;
    2695. 

  2695.     tmp11 = tmp0 - tmp1;
    2696. 

  2696.     tmp12 = tmp0 + tmp2;
    2697. 

  2697.     tmp13 = tmp0 - tmp2;
    2698. 

  2698. 

  2699.     z1 = (INT32) wsptr[2];
    2700. 

  2700.     z2 = (INT32) wsptr[6];
    2701. 

  2701.     z3 = z1 - z2;
    2702. 

  2702.     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
    2703. 

  2703.     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
    2704. 

  2704. 

  2705.     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
    2706. 

  2706.     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
    2707. 

  2707.     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
    2708. 

  2708.     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
    2709. 

  2709. 

  2710.     tmp20 = tmp10 + tmp0;
    2711. 

  2711.     tmp27 = tmp10 - tmp0;
    2712. 

  2712.     tmp21 = tmp12 + tmp1;
    2713. 

  2713.     tmp26 = tmp12 - tmp1;
    2714. 

  2714.     tmp22 = tmp13 + tmp2;
    2715. 

  2715.     tmp25 = tmp13 - tmp2;
    2716. 

  2716.     tmp23 = tmp11 + tmp3;
    2717. 

  2717.     tmp24 = tmp11 - tmp3;
    2718. 

  2718. 

  2719.     /* Odd part */
    2720. 

  2720. 

  2721.     z1 = (INT32) wsptr[1];
    2722. 

  2722.     z2 = (INT32) wsptr[3];
    2723. 

  2723.     z3 = (INT32) wsptr[5];
    2724. 

  2724.     z4 = (INT32) wsptr[7];
    2725. 

  2725. 

  2726.     tmp11 = z1 + z3;
    2727. 

  2727. 

  2728.     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
    2729. 

  2729.     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
    2730. 

  2730.     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
    2731. 

  2731.     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
    2732. 

  2732.     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
    2733. 

  2733.     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
    2734. 

  2734.     tmp0  = tmp1 + tmp2 + tmp3 -
    2735. 

  2735. 	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
    2736. 

  2736.     tmp13 = tmp10 + tmp11 + tmp12 -
    2737. 

  2737. 	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
    2738. 

  2738.     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
    2739. 

  2739.     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
    2740. 

  2740.     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
    2741. 

  2741.     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
    2742. 

  2742.     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
    2743. 

  2743.     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
    2744. 

  2744.     z2    += z4;
    2745. 

  2745.     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
    2746. 

  2746.     tmp1  += z1;
    2747. 

  2747.     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
    2748. 

  2748.     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
    2749. 

  2749.     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
    2750. 

  2750.     tmp12 += z2;
    2751. 

  2751.     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
    2752. 

  2752.     tmp2  += z2;
    2753. 

  2753.     tmp3  += z2;
    2754. 

  2754.     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
    2755. 

  2755.     tmp10 += z2;
    2756. 

  2756.     tmp11 += z2;
    2757. 

  2757. 

  2758.     /* Final output stage */
    2759. 

  2759. 

  2760.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp0,
    2761. 

  2761. 					       CONST_BITS+PASS1_BITS+3)
    2762. 

  2762. 			     & RANGE_MASK];
    2763. 

  2763.     outptr[15] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp0,
    2764. 

  2764. 					       CONST_BITS+PASS1_BITS+3)
    2765. 

  2765. 			     & RANGE_MASK];
    2766. 

  2766.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp1,
    2767. 

  2767. 					       CONST_BITS+PASS1_BITS+3)
    2768. 

  2768. 			     & RANGE_MASK];
    2769. 

  2769.     outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp1,
    2770. 

  2770. 					       CONST_BITS+PASS1_BITS+3)
    2771. 

  2771. 			     & RANGE_MASK];
    2772. 

  2772.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp2,
    2773. 

  2773. 					       CONST_BITS+PASS1_BITS+3)
    2774. 

  2774. 			     & RANGE_MASK];
    2775. 

  2775.     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp2,
    2776. 

  2776. 					       CONST_BITS+PASS1_BITS+3)
    2777. 

  2777. 			     & RANGE_MASK];
    2778. 

  2778.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp3,
    2779. 

  2779. 					       CONST_BITS+PASS1_BITS+3)
    2780. 

  2780. 			     & RANGE_MASK];
    2781. 

  2781.     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp3,
    2782. 

  2782. 					       CONST_BITS+PASS1_BITS+3)
    2783. 

  2783. 			     & RANGE_MASK];
    2784. 

  2784.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp10,
    2785. 

  2785. 					       CONST_BITS+PASS1_BITS+3)
    2786. 

  2786. 			     & RANGE_MASK];
    2787. 

  2787.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp10,
    2788. 

  2788. 					       CONST_BITS+PASS1_BITS+3)
    2789. 

  2789. 			     & RANGE_MASK];
    2790. 

  2790.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp11,
    2791. 

  2791. 					       CONST_BITS+PASS1_BITS+3)
    2792. 

  2792. 			     & RANGE_MASK];
    2793. 

  2793.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp11,
    2794. 

  2794. 					       CONST_BITS+PASS1_BITS+3)
    2795. 

  2795. 			     & RANGE_MASK];
    2796. 

  2796.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp12,
    2797. 

  2797. 					       CONST_BITS+PASS1_BITS+3)
    2798. 

  2798. 			     & RANGE_MASK];
    2799. 

  2799.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp12,
    2800. 

  2800. 					       CONST_BITS+PASS1_BITS+3)
    2801. 

  2801. 			     & RANGE_MASK];
    2802. 

  2802.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27 + tmp13,
    2803. 

  2803. 					       CONST_BITS+PASS1_BITS+3)
    2804. 

  2804. 			     & RANGE_MASK];
    2805. 

  2805.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp27 - tmp13,
    2806. 

  2806. 					       CONST_BITS+PASS1_BITS+3)
    2807. 

  2807. 			     & RANGE_MASK];
    2808. 

  2808. 

  2809.     wsptr += 8;		/* advance pointer to next row */
    2810. 

  2810.   }
    2811. 

  2811. }
    2812. 

  2812. 

  2813. 

  2814. /*
    2815. 

  2815.  * Perform dequantization and inverse DCT on one block of coefficients,
    2816. 

  2816.  * producing a 16x8 output block.
    2817. 

  2817.  *
    2818. 

  2818.  * 8-point IDCT in pass 1 (columns), 16-point in pass 2 (rows).
    2819. 

  2819.  */
    2820. 

  2820. 

  2821. GLOBAL(void)
    2822. 

  2822. jpeg_idct_16x8 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    2823. 

  2823. 		JCOEFPTR coef_block,
    2824. 

  2824. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    2825. 

  2825. {
    2826. 

  2826.   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
    2827. 

  2827.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
    2828. 

  2828.   INT32 z1, z2, z3, z4;
    2829. 

  2829.   JCOEFPTR inptr;
    2830. 

  2830.   ISLOW_MULT_TYPE * quantptr;
    2831. 

  2831.   int * wsptr;
    2832. 

  2832.   JSAMPROW outptr;
    2833. 

  2833.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    2834. 

  2834.   int ctr;
    2835. 

  2835.   int workspace[8*8];	/* buffers data between passes */
    2836. 

  2836.   SHIFT_TEMPS
    2837. 

  2837. 

  2838.   /* Pass 1: process columns from input, store into work array. */
    2839. 

  2839.   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
    2840. 

  2840.   /* furthermore, we scale the results by 2**PASS1_BITS. */
    2841. 

  2841. 

  2842.   inptr = coef_block;
    2843. 

  2843.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    2844. 

  2844.   wsptr = workspace;
    2845. 

  2845.   for (ctr = DCTSIZE; ctr > 0; ctr--) {
    2846. 

  2846.     /* Due to quantization, we will usually find that many of the input
    2847. 

  2847.      * coefficients are zero, especially the AC terms.  We can exploit this
    2848. 

  2848.      * by short-circuiting the IDCT calculation for any column in which all
    2849. 

  2849.      * the AC terms are zero.  In that case each output is equal to the
    2850. 

  2850.      * DC coefficient (with scale factor as needed).
    2851. 

  2851.      * With typical images and quantization tables, half or more of the
    2852. 

  2852.      * column DCT calculations can be simplified this way.
    2853. 

  2853.      */
    2854. 

  2854.     
    2855. 

  2855.     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
    2856. 

  2856. 	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
    2857. 

  2857. 	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
    2858. 

  2858. 	inptr[DCTSIZE*7] == 0) {
    2859. 

  2859.       /* AC terms all zero */
    2860. 

  2860.       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
    2861. 

  2861.       
    2862. 

  2862.       wsptr[DCTSIZE*0] = dcval;
    2863. 

  2863.       wsptr[DCTSIZE*1] = dcval;
    2864. 

  2864.       wsptr[DCTSIZE*2] = dcval;
    2865. 

  2865.       wsptr[DCTSIZE*3] = dcval;
    2866. 

  2866.       wsptr[DCTSIZE*4] = dcval;
    2867. 

  2867.       wsptr[DCTSIZE*5] = dcval;
    2868. 

  2868.       wsptr[DCTSIZE*6] = dcval;
    2869. 

  2869.       wsptr[DCTSIZE*7] = dcval;
    2870. 

  2870.       
    2871. 

  2871.       inptr++;			/* advance pointers to next column */
    2872. 

  2872.       quantptr++;
    2873. 

  2873.       wsptr++;
    2874. 

  2874.       continue;
    2875. 

  2875.     }
    2876. 

  2876.     
    2877. 

  2877.     /* Even part: reverse the even part of the forward DCT. */
    2878. 

  2878.     /* The rotator is sqrt(2)*c(-6). */
    2879. 

  2879.     
    2880. 

  2880.     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    2881. 

  2881.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    2882. 

  2882.     
    2883. 

  2883.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
    2884. 

  2884.     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);
    2885. 

  2885.     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);
    2886. 

  2886.     
    2887. 

  2887.     z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    2888. 

  2888.     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    2889. 

  2889.     z2 <<= CONST_BITS;
    2890. 

  2890.     z3 <<= CONST_BITS;
    2891. 

  2891.     /* Add fudge factor here for final descale. */
    2892. 

  2892.     z2 += ONE << (CONST_BITS-PASS1_BITS-1);
    2893. 

  2893. 

  2894.     tmp0 = z2 + z3;
    2895. 

  2895.     tmp1 = z2 - z3;
    2896. 

  2896.     
    2897. 

  2897.     tmp10 = tmp0 + tmp2;
    2898. 

  2898.     tmp13 = tmp0 - tmp2;
    2899. 

  2899.     tmp11 = tmp1 + tmp3;
    2900. 

  2900.     tmp12 = tmp1 - tmp3;
    2901. 

  2901.     
    2902. 

  2902.     /* Odd part per figure 8; the matrix is unitary and hence its
    2903. 

  2903.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
    2904. 

  2904.      */
    2905. 

  2905.     
    2906. 

  2906.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    2907. 

  2907.     tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    2908. 

  2908.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    2909. 

  2909.     tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    2910. 

  2910.     
    2911. 

  2911.     z2 = tmp0 + tmp2;
    2912. 

  2912.     z3 = tmp1 + tmp3;
    2913. 

  2913. 

  2914.     z1 = MULTIPLY(z2 + z3, FIX_1_175875602); /* sqrt(2) * c3 */
    2915. 

  2915.     z2 = MULTIPLY(z2, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
    2916. 

  2916.     z3 = MULTIPLY(z3, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
    2917. 

  2917.     z2 += z1;
    2918. 

  2918.     z3 += z1;
    2919. 

  2919. 

  2920.     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
    2921. 

  2921.     tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
    2922. 

  2922.     tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
    2923. 

  2923.     tmp0 += z1 + z2;
    2924. 

  2924.     tmp3 += z1 + z3;
    2925. 

  2925. 

  2926.     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
    2927. 

  2927.     tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    2928. 

  2928.     tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    2929. 

  2929.     tmp1 += z1 + z3;
    2930. 

  2930.     tmp2 += z1 + z2;
    2931. 

  2931.     
    2932. 

  2932.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
    2933. 

  2933.     
    2934. 

  2934.     wsptr[DCTSIZE*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
    2935. 

  2935.     wsptr[DCTSIZE*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
    2936. 

  2936.     wsptr[DCTSIZE*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
    2937. 

  2937.     wsptr[DCTSIZE*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
    2938. 

  2938.     wsptr[DCTSIZE*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
    2939. 

  2939.     wsptr[DCTSIZE*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
    2940. 

  2940.     wsptr[DCTSIZE*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
    2941. 

  2941.     wsptr[DCTSIZE*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
    2942. 

  2942.     
    2943. 

  2943.     inptr++;			/* advance pointers to next column */
    2944. 

  2944.     quantptr++;
    2945. 

  2945.     wsptr++;
    2946. 

  2946.   }
    2947. 

  2947. 

  2948.   /* Pass 2: process 8 rows from work array, store into output array.
    2949. 

  2949.    * 16-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
    2950. 

  2950.    */
    2951. 

  2951.   wsptr = workspace;
    2952. 

  2952.   for (ctr = 0; ctr < 8; ctr++) {
    2953. 

  2953.     outptr = output_buf[ctr] + output_col;
    2954. 

  2954. 

  2955.     /* Even part */
    2956. 

  2956. 

  2957.     /* Add fudge factor here for final descale. */
    2958. 

  2958.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    2959. 

  2959.     tmp0 <<= CONST_BITS;
    2960. 

  2960. 

  2961.     z1 = (INT32) wsptr[4];
    2962. 

  2962.     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
    2963. 

  2963.     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
    2964. 

  2964. 

  2965.     tmp10 = tmp0 + tmp1;
    2966. 

  2966.     tmp11 = tmp0 - tmp1;
    2967. 

  2967.     tmp12 = tmp0 + tmp2;
    2968. 

  2968.     tmp13 = tmp0 - tmp2;
    2969. 

  2969. 

  2970.     z1 = (INT32) wsptr[2];
    2971. 

  2971.     z2 = (INT32) wsptr[6];
    2972. 

  2972.     z3 = z1 - z2;
    2973. 

  2973.     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
    2974. 

  2974.     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
    2975. 

  2975. 

  2976.     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
    2977. 

  2977.     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
    2978. 

  2978.     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
    2979. 

  2979.     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
    2980. 

  2980. 

  2981.     tmp20 = tmp10 + tmp0;
    2982. 

  2982.     tmp27 = tmp10 - tmp0;
    2983. 

  2983.     tmp21 = tmp12 + tmp1;
    2984. 

  2984.     tmp26 = tmp12 - tmp1;
    2985. 

  2985.     tmp22 = tmp13 + tmp2;
    2986. 

  2986.     tmp25 = tmp13 - tmp2;
    2987. 

  2987.     tmp23 = tmp11 + tmp3;
    2988. 

  2988.     tmp24 = tmp11 - tmp3;
    2989. 

  2989. 

  2990.     /* Odd part */
    2991. 

  2991. 

  2992.     z1 = (INT32) wsptr[1];
    2993. 

  2993.     z2 = (INT32) wsptr[3];
    2994. 

  2994.     z3 = (INT32) wsptr[5];
    2995. 

  2995.     z4 = (INT32) wsptr[7];
    2996. 

  2996. 

  2997.     tmp11 = z1 + z3;
    2998. 

  2998. 

  2999.     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
    3000. 

  3000.     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
    3001. 

  3001.     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
    3002. 

  3002.     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
    3003. 

  3003.     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
    3004. 

  3004.     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
    3005. 

  3005.     tmp0  = tmp1 + tmp2 + tmp3 -
    3006. 

  3006. 	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
    3007. 

  3007.     tmp13 = tmp10 + tmp11 + tmp12 -
    3008. 

  3008. 	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
    3009. 

  3009.     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
    3010. 

  3010.     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
    3011. 

  3011.     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
    3012. 

  3012.     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
    3013. 

  3013.     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
    3014. 

  3014.     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
    3015. 

  3015.     z2    += z4;
    3016. 

  3016.     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
    3017. 

  3017.     tmp1  += z1;
    3018. 

  3018.     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
    3019. 

  3019.     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
    3020. 

  3020.     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
    3021. 

  3021.     tmp12 += z2;
    3022. 

  3022.     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
    3023. 

  3023.     tmp2  += z2;
    3024. 

  3024.     tmp3  += z2;
    3025. 

  3025.     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
    3026. 

  3026.     tmp10 += z2;
    3027. 

  3027.     tmp11 += z2;
    3028. 

  3028. 

  3029.     /* Final output stage */
    3030. 

  3030. 

  3031.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp0,
    3032. 

  3032. 					       CONST_BITS+PASS1_BITS+3)
    3033. 

  3033. 			     & RANGE_MASK];
    3034. 

  3034.     outptr[15] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp0,
    3035. 

  3035. 					       CONST_BITS+PASS1_BITS+3)
    3036. 

  3036. 			     & RANGE_MASK];
    3037. 

  3037.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp1,
    3038. 

  3038. 					       CONST_BITS+PASS1_BITS+3)
    3039. 

  3039. 			     & RANGE_MASK];
    3040. 

  3040.     outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp1,
    3041. 

  3041. 					       CONST_BITS+PASS1_BITS+3)
    3042. 

  3042. 			     & RANGE_MASK];
    3043. 

  3043.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp2,
    3044. 

  3044. 					       CONST_BITS+PASS1_BITS+3)
    3045. 

  3045. 			     & RANGE_MASK];
    3046. 

  3046.     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp2,
    3047. 

  3047. 					       CONST_BITS+PASS1_BITS+3)
    3048. 

  3048. 			     & RANGE_MASK];
    3049. 

  3049.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp3,
    3050. 

  3050. 					       CONST_BITS+PASS1_BITS+3)
    3051. 

  3051. 			     & RANGE_MASK];
    3052. 

  3052.     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp3,
    3053. 

  3053. 					       CONST_BITS+PASS1_BITS+3)
    3054. 

  3054. 			     & RANGE_MASK];
    3055. 

  3055.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp10,
    3056. 

  3056. 					       CONST_BITS+PASS1_BITS+3)
    3057. 

  3057. 			     & RANGE_MASK];
    3058. 

  3058.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp10,
    3059. 

  3059. 					       CONST_BITS+PASS1_BITS+3)
    3060. 

  3060. 			     & RANGE_MASK];
    3061. 

  3061.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp11,
    3062. 

  3062. 					       CONST_BITS+PASS1_BITS+3)
    3063. 

  3063. 			     & RANGE_MASK];
    3064. 

  3064.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp11,
    3065. 

  3065. 					       CONST_BITS+PASS1_BITS+3)
    3066. 

  3066. 			     & RANGE_MASK];
    3067. 

  3067.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp12,
    3068. 

  3068. 					       CONST_BITS+PASS1_BITS+3)
    3069. 

  3069. 			     & RANGE_MASK];
    3070. 

  3070.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp12,
    3071. 

  3071. 					       CONST_BITS+PASS1_BITS+3)
    3072. 

  3072. 			     & RANGE_MASK];
    3073. 

  3073.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27 + tmp13,
    3074. 

  3074. 					       CONST_BITS+PASS1_BITS+3)
    3075. 

  3075. 			     & RANGE_MASK];
    3076. 

  3076.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp27 - tmp13,
    3077. 

  3077. 					       CONST_BITS+PASS1_BITS+3)
    3078. 

  3078. 			     & RANGE_MASK];
    3079. 

  3079. 

  3080.     wsptr += 8;		/* advance pointer to next row */
    3081. 

  3081.   }
    3082. 

  3082. }
    3083. 

  3083. 

  3084. 

  3085. /*
    3086. 

  3086.  * Perform dequantization and inverse DCT on one block of coefficients,
    3087. 

  3087.  * producing a 14x7 output block.
    3088. 

  3088.  *
    3089. 

  3089.  * 7-point IDCT in pass 1 (columns), 14-point in pass 2 (rows).
    3090. 

  3090.  */
    3091. 

  3091. 

  3092. GLOBAL(void)
    3093. 

  3093. jpeg_idct_14x7 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    3094. 

  3094. 		JCOEFPTR coef_block,
    3095. 

  3095. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    3096. 

  3096. {
    3097. 

  3097.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
    3098. 

  3098.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
    3099. 

  3099.   INT32 z1, z2, z3, z4;
    3100. 

  3100.   JCOEFPTR inptr;
    3101. 

  3101.   ISLOW_MULT_TYPE * quantptr;
    3102. 

  3102.   int * wsptr;
    3103. 

  3103.   JSAMPROW outptr;
    3104. 

  3104.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    3105. 

  3105.   int ctr;
    3106. 

  3106.   int workspace[8*7];	/* buffers data between passes */
    3107. 

  3107.   SHIFT_TEMPS
    3108. 

  3108. 

  3109.   /* Pass 1: process columns from input, store into work array.
    3110. 

  3110.    * 7-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
    3111. 

  3111.    */
    3112. 

  3112.   inptr = coef_block;
    3113. 

  3113.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    3114. 

  3114.   wsptr = workspace;
    3115. 

  3115.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    3116. 

  3116.     /* Even part */
    3117. 

  3117. 

  3118.     tmp23 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    3119. 

  3119.     tmp23 <<= CONST_BITS;
    3120. 

  3120.     /* Add fudge factor here for final descale. */
    3121. 

  3121.     tmp23 += ONE << (CONST_BITS-PASS1_BITS-1);
    3122. 

  3122. 

  3123.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    3124. 

  3124.     z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    3125. 

  3125.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    3126. 

  3126. 

  3127.     tmp20 = MULTIPLY(z2 - z3, FIX(0.881747734));       /* c4 */
    3128. 

  3128.     tmp22 = MULTIPLY(z1 - z2, FIX(0.314692123));       /* c6 */
    3129. 

  3129.     tmp21 = tmp20 + tmp22 + tmp23 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
    3130. 

  3130.     tmp10 = z1 + z3;
    3131. 

  3131.     z2 -= tmp10;
    3132. 

  3132.     tmp10 = MULTIPLY(tmp10, FIX(1.274162392)) + tmp23; /* c2 */
    3133. 

  3133.     tmp20 += tmp10 - MULTIPLY(z3, FIX(0.077722536));   /* c2-c4-c6 */
    3134. 

  3134.     tmp22 += tmp10 - MULTIPLY(z1, FIX(2.470602249));   /* c2+c4+c6 */
    3135. 

  3135.     tmp23 += MULTIPLY(z2, FIX(1.414213562));           /* c0 */
    3136. 

  3136. 

  3137.     /* Odd part */
    3138. 

  3138. 

  3139.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    3140. 

  3140.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    3141. 

  3141.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    3142. 

  3142. 

  3143.     tmp11 = MULTIPLY(z1 + z2, FIX(0.935414347));       /* (c3+c1-c5)/2 */
    3144. 

  3144.     tmp12 = MULTIPLY(z1 - z2, FIX(0.170262339));       /* (c3+c5-c1)/2 */
    3145. 

  3145.     tmp10 = tmp11 - tmp12;
    3146. 

  3146.     tmp11 += tmp12;
    3147. 

  3147.     tmp12 = MULTIPLY(z2 + z3, - FIX(1.378756276));     /* -c1 */
    3148. 

  3148.     tmp11 += tmp12;
    3149. 

  3149.     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));          /* c5 */
    3150. 

  3150.     tmp10 += z2;
    3151. 

  3151.     tmp12 += z2 + MULTIPLY(z3, FIX(1.870828693));      /* c3+c1-c5 */
    3152. 

  3152. 

  3153.     /* Final output stage */
    3154. 

  3154. 

  3155.     wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    3156. 

  3156.     wsptr[8*6] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    3157. 

  3157.     wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    3158. 

  3158.     wsptr[8*5] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    3159. 

  3159.     wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    3160. 

  3160.     wsptr[8*4] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    3161. 

  3161.     wsptr[8*3] = (int) RIGHT_SHIFT(tmp23, CONST_BITS-PASS1_BITS);
    3162. 

  3162.   }
    3163. 

  3163. 

  3164.   /* Pass 2: process 7 rows from work array, store into output array.
    3165. 

  3165.    * 14-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/28).
    3166. 

  3166.    */
    3167. 

  3167.   wsptr = workspace;
    3168. 

  3168.   for (ctr = 0; ctr < 7; ctr++) {
    3169. 

  3169.     outptr = output_buf[ctr] + output_col;
    3170. 

  3170. 

  3171.     /* Even part */
    3172. 

  3172. 

  3173.     /* Add fudge factor here for final descale. */
    3174. 

  3174.     z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    3175. 

  3175.     z1 <<= CONST_BITS;
    3176. 

  3176.     z4 = (INT32) wsptr[4];
    3177. 

  3177.     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
    3178. 

  3178.     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
    3179. 

  3179.     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
    3180. 

  3180. 

  3181.     tmp10 = z1 + z2;
    3182. 

  3182.     tmp11 = z1 + z3;
    3183. 

  3183.     tmp12 = z1 - z4;
    3184. 

  3184. 

  3185.     tmp23 = z1 - ((z2 + z3 - z4) << 1);          /* c0 = (c4+c12-c8)*2 */
    3186. 

  3186. 

  3187.     z1 = (INT32) wsptr[2];
    3188. 

  3188.     z2 = (INT32) wsptr[6];
    3189. 

  3189. 

  3190.     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
    3191. 

  3191. 

  3192.     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
    3193. 

  3193.     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
    3194. 

  3194.     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
    3195. 

  3195. 	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
    3196. 

  3196. 

  3197.     tmp20 = tmp10 + tmp13;
    3198. 

  3198.     tmp26 = tmp10 - tmp13;
    3199. 

  3199.     tmp21 = tmp11 + tmp14;
    3200. 

  3200.     tmp25 = tmp11 - tmp14;
    3201. 

  3201.     tmp22 = tmp12 + tmp15;
    3202. 

  3202.     tmp24 = tmp12 - tmp15;
    3203. 

  3203. 

  3204.     /* Odd part */
    3205. 

  3205. 

  3206.     z1 = (INT32) wsptr[1];
    3207. 

  3207.     z2 = (INT32) wsptr[3];
    3208. 

  3208.     z3 = (INT32) wsptr[5];
    3209. 

  3209.     z4 = (INT32) wsptr[7];
    3210. 

  3210.     z4 <<= CONST_BITS;
    3211. 

  3211. 

  3212.     tmp14 = z1 + z3;
    3213. 

  3213.     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
    3214. 

  3214.     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
    3215. 

  3215.     tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
    3216. 

  3216.     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
    3217. 

  3217.     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
    3218. 

  3218.     z1    -= z2;
    3219. 

  3219.     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4;           /* c11 */
    3220. 

  3220.     tmp16 += tmp15;
    3221. 

  3221.     tmp13 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - z4;    /* -c13 */
    3222. 

  3222.     tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948));       /* c3-c9-c13 */
    3223. 

  3223.     tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773));       /* c3+c5-c13 */
    3224. 

  3224.     tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
    3225. 

  3225.     tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
    3226. 

  3226.     tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567));       /* c1+c11-c5 */
    3227. 

  3227. 

  3228.     tmp13 = ((z1 - z3) << CONST_BITS) + z4;
    3229. 

  3229. 

  3230.     /* Final output stage */
    3231. 

  3231. 

  3232.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    3233. 

  3233. 					       CONST_BITS+PASS1_BITS+3)
    3234. 

  3234. 			     & RANGE_MASK];
    3235. 

  3235.     outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    3236. 

  3236. 					       CONST_BITS+PASS1_BITS+3)
    3237. 

  3237. 			     & RANGE_MASK];
    3238. 

  3238.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    3239. 

  3239. 					       CONST_BITS+PASS1_BITS+3)
    3240. 

  3240. 			     & RANGE_MASK];
    3241. 

  3241.     outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    3242. 

  3242. 					       CONST_BITS+PASS1_BITS+3)
    3243. 

  3243. 			     & RANGE_MASK];
    3244. 

  3244.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    3245. 

  3245. 					       CONST_BITS+PASS1_BITS+3)
    3246. 

  3246. 			     & RANGE_MASK];
    3247. 

  3247.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    3248. 

  3248. 					       CONST_BITS+PASS1_BITS+3)
    3249. 

  3249. 			     & RANGE_MASK];
    3250. 

  3250.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    3251. 

  3251. 					       CONST_BITS+PASS1_BITS+3)
    3252. 

  3252. 			     & RANGE_MASK];
    3253. 

  3253.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    3254. 

  3254. 					       CONST_BITS+PASS1_BITS+3)
    3255. 

  3255. 			     & RANGE_MASK];
    3256. 

  3256.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    3257. 

  3257. 					       CONST_BITS+PASS1_BITS+3)
    3258. 

  3258. 			     & RANGE_MASK];
    3259. 

  3259.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    3260. 

  3260. 					       CONST_BITS+PASS1_BITS+3)
    3261. 

  3261. 			     & RANGE_MASK];
    3262. 

  3262.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
    3263. 

  3263. 					       CONST_BITS+PASS1_BITS+3)
    3264. 

  3264. 			     & RANGE_MASK];
    3265. 

  3265.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
    3266. 

  3266. 					       CONST_BITS+PASS1_BITS+3)
    3267. 

  3267. 			     & RANGE_MASK];
    3268. 

  3268.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
    3269. 

  3269. 					       CONST_BITS+PASS1_BITS+3)
    3270. 

  3270. 			     & RANGE_MASK];
    3271. 

  3271.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
    3272. 

  3272. 					       CONST_BITS+PASS1_BITS+3)
    3273. 

  3273. 			     & RANGE_MASK];
    3274. 

  3274. 

  3275.     wsptr += 8;		/* advance pointer to next row */
    3276. 

  3276.   }
    3277. 

  3277. }
    3278. 

  3278. 

  3279. 

  3280. /*
    3281. 

  3281.  * Perform dequantization and inverse DCT on one block of coefficients,
    3282. 

  3282.  * producing a 12x6 output block.
    3283. 

  3283.  *
    3284. 

  3284.  * 6-point IDCT in pass 1 (columns), 12-point in pass 2 (rows).
    3285. 

  3285.  */
    3286. 

  3286. 

  3287. GLOBAL(void)
    3288. 

  3288. jpeg_idct_12x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    3289. 

  3289. 		JCOEFPTR coef_block,
    3290. 

  3290. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    3291. 

  3291. {
    3292. 

  3292.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
    3293. 

  3293.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
    3294. 

  3294.   INT32 z1, z2, z3, z4;
    3295. 

  3295.   JCOEFPTR inptr;
    3296. 

  3296.   ISLOW_MULT_TYPE * quantptr;
    3297. 

  3297.   int * wsptr;
    3298. 

  3298.   JSAMPROW outptr;
    3299. 

  3299.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    3300. 

  3300.   int ctr;
    3301. 

  3301.   int workspace[8*6];	/* buffers data between passes */
    3302. 

  3302.   SHIFT_TEMPS
    3303. 

  3303. 

  3304.   /* Pass 1: process columns from input, store into work array.
    3305. 

  3305.    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
    3306. 

  3306.    */
    3307. 

  3307.   inptr = coef_block;
    3308. 

  3308.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    3309. 

  3309.   wsptr = workspace;
    3310. 

  3310.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    3311. 

  3311.     /* Even part */
    3312. 

  3312. 

  3313.     tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    3314. 

  3314.     tmp10 <<= CONST_BITS;
    3315. 

  3315.     /* Add fudge factor here for final descale. */
    3316. 

  3316.     tmp10 += ONE << (CONST_BITS-PASS1_BITS-1);
    3317. 

  3317.     tmp12 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    3318. 

  3318.     tmp20 = MULTIPLY(tmp12, FIX(0.707106781));   /* c4 */
    3319. 

  3319.     tmp11 = tmp10 + tmp20;
    3320. 

  3320.     tmp21 = RIGHT_SHIFT(tmp10 - tmp20 - tmp20, CONST_BITS-PASS1_BITS);
    3321. 

  3321.     tmp20 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    3322. 

  3322.     tmp10 = MULTIPLY(tmp20, FIX(1.224744871));   /* c2 */
    3323. 

  3323.     tmp20 = tmp11 + tmp10;
    3324. 

  3324.     tmp22 = tmp11 - tmp10;
    3325. 

  3325. 

  3326.     /* Odd part */
    3327. 

  3327. 

  3328.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    3329. 

  3329.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    3330. 

  3330.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    3331. 

  3331.     tmp11 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
    3332. 

  3332.     tmp10 = tmp11 + ((z1 + z2) << CONST_BITS);
    3333. 

  3333.     tmp12 = tmp11 + ((z3 - z2) << CONST_BITS);
    3334. 

  3334.     tmp11 = (z1 - z2 - z3) << PASS1_BITS;
    3335. 

  3335. 

  3336.     /* Final output stage */
    3337. 

  3337. 

  3338.     wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    3339. 

  3339.     wsptr[8*5] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    3340. 

  3340.     wsptr[8*1] = (int) (tmp21 + tmp11);
    3341. 

  3341.     wsptr[8*4] = (int) (tmp21 - tmp11);
    3342. 

  3342.     wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    3343. 

  3343.     wsptr[8*3] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    3344. 

  3344.   }
    3345. 

  3345. 

  3346.   /* Pass 2: process 6 rows from work array, store into output array.
    3347. 

  3347.    * 12-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/24).
    3348. 

  3348.    */
    3349. 

  3349.   wsptr = workspace;
    3350. 

  3350.   for (ctr = 0; ctr < 6; ctr++) {
    3351. 

  3351.     outptr = output_buf[ctr] + output_col;
    3352. 

  3352. 

  3353.     /* Even part */
    3354. 

  3354. 

  3355.     /* Add fudge factor here for final descale. */
    3356. 

  3356.     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    3357. 

  3357.     z3 <<= CONST_BITS;
    3358. 

  3358. 

  3359.     z4 = (INT32) wsptr[4];
    3360. 

  3360.     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
    3361. 

  3361. 

  3362.     tmp10 = z3 + z4;
    3363. 

  3363.     tmp11 = z3 - z4;
    3364. 

  3364. 

  3365.     z1 = (INT32) wsptr[2];
    3366. 

  3366.     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
    3367. 

  3367.     z1 <<= CONST_BITS;
    3368. 

  3368.     z2 = (INT32) wsptr[6];
    3369. 

  3369.     z2 <<= CONST_BITS;
    3370. 

  3370. 

  3371.     tmp12 = z1 - z2;
    3372. 

  3372. 

  3373.     tmp21 = z3 + tmp12;
    3374. 

  3374.     tmp24 = z3 - tmp12;
    3375. 

  3375. 

  3376.     tmp12 = z4 + z2;
    3377. 

  3377. 

  3378.     tmp20 = tmp10 + tmp12;
    3379. 

  3379.     tmp25 = tmp10 - tmp12;
    3380. 

  3380. 

  3381.     tmp12 = z4 - z1 - z2;
    3382. 

  3382. 

  3383.     tmp22 = tmp11 + tmp12;
    3384. 

  3384.     tmp23 = tmp11 - tmp12;
    3385. 

  3385. 

  3386.     /* Odd part */
    3387. 

  3387. 

  3388.     z1 = (INT32) wsptr[1];
    3389. 

  3389.     z2 = (INT32) wsptr[3];
    3390. 

  3390.     z3 = (INT32) wsptr[5];
    3391. 

  3391.     z4 = (INT32) wsptr[7];
    3392. 

  3392. 

  3393.     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
    3394. 

  3394.     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
    3395. 

  3395. 

  3396.     tmp10 = z1 + z3;
    3397. 

  3397.     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
    3398. 

  3398.     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
    3399. 

  3399.     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
    3400. 

  3400.     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
    3401. 

  3401.     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
    3402. 

  3402.     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
    3403. 

  3403.     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
    3404. 

  3404. 	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
    3405. 

  3405. 

  3406.     z1 -= z4;
    3407. 

  3407.     z2 -= z3;
    3408. 

  3408.     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
    3409. 

  3409.     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
    3410. 

  3410.     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
    3411. 

  3411. 

  3412.     /* Final output stage */
    3413. 

  3413. 

  3414.     outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    3415. 

  3415. 					       CONST_BITS+PASS1_BITS+3)
    3416. 

  3416. 			     & RANGE_MASK];
    3417. 

  3417.     outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    3418. 

  3418. 					       CONST_BITS+PASS1_BITS+3)
    3419. 

  3419. 			     & RANGE_MASK];
    3420. 

  3420.     outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    3421. 

  3421. 					       CONST_BITS+PASS1_BITS+3)
    3422. 

  3422. 			     & RANGE_MASK];
    3423. 

  3423.     outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    3424. 

  3424. 					       CONST_BITS+PASS1_BITS+3)
    3425. 

  3425. 			     & RANGE_MASK];
    3426. 

  3426.     outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    3427. 

  3427. 					       CONST_BITS+PASS1_BITS+3)
    3428. 

  3428. 			     & RANGE_MASK];
    3429. 

  3429.     outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    3430. 

  3430. 					       CONST_BITS+PASS1_BITS+3)
    3431. 

  3431. 			     & RANGE_MASK];
    3432. 

  3432.     outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    3433. 

  3433. 					       CONST_BITS+PASS1_BITS+3)
    3434. 

  3434. 			     & RANGE_MASK];
    3435. 

  3435.     outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    3436. 

  3436. 					       CONST_BITS+PASS1_BITS+3)
    3437. 

  3437. 			     & RANGE_MASK];
    3438. 

  3438.     outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    3439. 

  3439. 					       CONST_BITS+PASS1_BITS+3)
    3440. 

  3440. 			     & RANGE_MASK];
    3441. 

  3441.     outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    3442. 

  3442. 					       CONST_BITS+PASS1_BITS+3)
    3443. 

  3443. 			     & RANGE_MASK];
    3444. 

  3444.     outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
    3445. 

  3445. 					       CONST_BITS+PASS1_BITS+3)
    3446. 

  3446. 			     & RANGE_MASK];
    3447. 

  3447.     outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
    3448. 

  3448. 					       CONST_BITS+PASS1_BITS+3)
    3449. 

  3449. 			     & RANGE_MASK];
    3450. 

  3450. 

  3451.     wsptr += 8;		/* advance pointer to next row */
    3452. 

  3452.   }
    3453. 

  3453. }
    3454. 

  3454. 

  3455. 

  3456. /*
    3457. 

  3457.  * Perform dequantization and inverse DCT on one block of coefficients,
    3458. 

  3458.  * producing a 10x5 output block.
    3459. 

  3459.  *
    3460. 

  3460.  * 5-point IDCT in pass 1 (columns), 10-point in pass 2 (rows).
    3461. 

  3461.  */
    3462. 

  3462. 

  3463. GLOBAL(void)
    3464. 

  3464. jpeg_idct_10x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    3465. 

  3465. 		JCOEFPTR coef_block,
    3466. 

  3466. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    3467. 

  3467. {
    3468. 

  3468.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
    3469. 

  3469.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
    3470. 

  3470.   INT32 z1, z2, z3, z4;
    3471. 

  3471.   JCOEFPTR inptr;
    3472. 

  3472.   ISLOW_MULT_TYPE * quantptr;
    3473. 

  3473.   int * wsptr;
    3474. 

  3474.   JSAMPROW outptr;
    3475. 

  3475.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    3476. 

  3476.   int ctr;
    3477. 

  3477.   int workspace[8*5];	/* buffers data between passes */
    3478. 

  3478.   SHIFT_TEMPS
    3479. 

  3479. 

  3480.   /* Pass 1: process columns from input, store into work array.
    3481. 

  3481.    * 5-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
    3482. 

  3482.    */
    3483. 

  3483.   inptr = coef_block;
    3484. 

  3484.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    3485. 

  3485.   wsptr = workspace;
    3486. 

  3486.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    3487. 

  3487.     /* Even part */
    3488. 

  3488. 

  3489.     tmp12 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    3490. 

  3490.     tmp12 <<= CONST_BITS;
    3491. 

  3491.     /* Add fudge factor here for final descale. */
    3492. 

  3492.     tmp12 += ONE << (CONST_BITS-PASS1_BITS-1);
    3493. 

  3493.     tmp13 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    3494. 

  3494.     tmp14 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    3495. 

  3495.     z1 = MULTIPLY(tmp13 + tmp14, FIX(0.790569415)); /* (c2+c4)/2 */
    3496. 

  3496.     z2 = MULTIPLY(tmp13 - tmp14, FIX(0.353553391)); /* (c2-c4)/2 */
    3497. 

  3497.     z3 = tmp12 + z2;
    3498. 

  3498.     tmp10 = z3 + z1;
    3499. 

  3499.     tmp11 = z3 - z1;
    3500. 

  3500.     tmp12 -= z2 << 2;
    3501. 

  3501. 

  3502.     /* Odd part */
    3503. 

  3503. 

  3504.     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    3505. 

  3505.     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    3506. 

  3506. 

  3507.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));       /* c3 */
    3508. 

  3508.     tmp13 = z1 + MULTIPLY(z2, FIX(0.513743148));    /* c1-c3 */
    3509. 

  3509.     tmp14 = z1 - MULTIPLY(z3, FIX(2.176250899));    /* c1+c3 */
    3510. 

  3510. 

  3511.     /* Final output stage */
    3512. 

  3512. 

  3513.     wsptr[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp13, CONST_BITS-PASS1_BITS);
    3514. 

  3514.     wsptr[8*4] = (int) RIGHT_SHIFT(tmp10 - tmp13, CONST_BITS-PASS1_BITS);
    3515. 

  3515.     wsptr[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp14, CONST_BITS-PASS1_BITS);
    3516. 

  3516.     wsptr[8*3] = (int) RIGHT_SHIFT(tmp11 - tmp14, CONST_BITS-PASS1_BITS);
    3517. 

  3517.     wsptr[8*2] = (int) RIGHT_SHIFT(tmp12, CONST_BITS-PASS1_BITS);
    3518. 

  3518.   }
    3519. 

  3519. 

  3520.   /* Pass 2: process 5 rows from work array, store into output array.
    3521. 

  3521.    * 10-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/20).
    3522. 

  3522.    */
    3523. 

  3523.   wsptr = workspace;
    3524. 

  3524.   for (ctr = 0; ctr < 5; ctr++) {
    3525. 

  3525.     outptr = output_buf[ctr] + output_col;
    3526. 

  3526. 

  3527.     /* Even part */
    3528. 

  3528. 

  3529.     /* Add fudge factor here for final descale. */
    3530. 

  3530.     z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    3531. 

  3531.     z3 <<= CONST_BITS;
    3532. 

  3532.     z4 = (INT32) wsptr[4];
    3533. 

  3533.     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
    3534. 

  3534.     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
    3535. 

  3535.     tmp10 = z3 + z1;
    3536. 

  3536.     tmp11 = z3 - z2;
    3537. 

  3537. 

  3538.     tmp22 = z3 - ((z1 - z2) << 1);               /* c0 = (c4-c8)*2 */
    3539. 

  3539. 

  3540.     z2 = (INT32) wsptr[2];
    3541. 

  3541.     z3 = (INT32) wsptr[6];
    3542. 

  3542. 

  3543.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
    3544. 

  3544.     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
    3545. 

  3545.     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
    3546. 

  3546. 

  3547.     tmp20 = tmp10 + tmp12;
    3548. 

  3548.     tmp24 = tmp10 - tmp12;
    3549. 

  3549.     tmp21 = tmp11 + tmp13;
    3550. 

  3550.     tmp23 = tmp11 - tmp13;
    3551. 

  3551. 

  3552.     /* Odd part */
    3553. 

  3553. 

  3554.     z1 = (INT32) wsptr[1];
    3555. 

  3555.     z2 = (INT32) wsptr[3];
    3556. 

  3556.     z3 = (INT32) wsptr[5];
    3557. 

  3557.     z3 <<= CONST_BITS;
    3558. 

  3558.     z4 = (INT32) wsptr[7];
    3559. 

  3559. 

  3560.     tmp11 = z2 + z4;
    3561. 

  3561.     tmp13 = z2 - z4;
    3562. 

  3562. 

  3563.     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
    3564. 

  3564. 

  3565.     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
    3566. 

  3566.     z4 = z3 + tmp12;
    3567. 

  3567. 

  3568.     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
    3569. 

  3569.     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
    3570. 

  3570. 

  3571.     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
    3572. 

  3572.     z4 = z3 - tmp12 - (tmp13 << (CONST_BITS - 1));
    3573. 

  3573. 

  3574.     tmp12 = ((z1 - tmp13) << CONST_BITS) - z3;
    3575. 

  3575. 

  3576.     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
    3577. 

  3577.     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
    3578. 

  3578. 

  3579.     /* Final output stage */
    3580. 

  3580. 

  3581.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    3582. 

  3582. 					      CONST_BITS+PASS1_BITS+3)
    3583. 

  3583. 			    & RANGE_MASK];
    3584. 

  3584.     outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    3585. 

  3585. 					      CONST_BITS+PASS1_BITS+3)
    3586. 

  3586. 			    & RANGE_MASK];
    3587. 

  3587.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    3588. 

  3588. 					      CONST_BITS+PASS1_BITS+3)
    3589. 

  3589. 			    & RANGE_MASK];
    3590. 

  3590.     outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    3591. 

  3591. 					      CONST_BITS+PASS1_BITS+3)
    3592. 

  3592. 			    & RANGE_MASK];
    3593. 

  3593.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    3594. 

  3594. 					      CONST_BITS+PASS1_BITS+3)
    3595. 

  3595. 			    & RANGE_MASK];
    3596. 

  3596.     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    3597. 

  3597. 					      CONST_BITS+PASS1_BITS+3)
    3598. 

  3598. 			    & RANGE_MASK];
    3599. 

  3599.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
    3600. 

  3600. 					      CONST_BITS+PASS1_BITS+3)
    3601. 

  3601. 			    & RANGE_MASK];
    3602. 

  3602.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
    3603. 

  3603. 					      CONST_BITS+PASS1_BITS+3)
    3604. 

  3604. 			    & RANGE_MASK];
    3605. 

  3605.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
    3606. 

  3606. 					      CONST_BITS+PASS1_BITS+3)
    3607. 

  3607. 			    & RANGE_MASK];
    3608. 

  3608.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
    3609. 

  3609. 					      CONST_BITS+PASS1_BITS+3)
    3610. 

  3610. 			    & RANGE_MASK];
    3611. 

  3611. 

  3612.     wsptr += 8;		/* advance pointer to next row */
    3613. 

  3613.   }
    3614. 

  3614. }
    3615. 

  3615. 

  3616. 

  3617. /*
    3618. 

  3618.  * Perform dequantization and inverse DCT on one block of coefficients,
    3619. 

  3619.  * producing a 8x4 output block.
    3620. 

  3620.  *
    3621. 

  3621.  * 4-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
    3622. 

  3622.  */
    3623. 

  3623. 

  3624. GLOBAL(void)
    3625. 

  3625. jpeg_idct_8x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    3626. 

  3626. 	       JCOEFPTR coef_block,
    3627. 

  3627. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    3628. 

  3628. {
    3629. 

  3629.   INT32 tmp0, tmp1, tmp2, tmp3;
    3630. 

  3630.   INT32 tmp10, tmp11, tmp12, tmp13;
    3631. 

  3631.   INT32 z1, z2, z3;
    3632. 

  3632.   JCOEFPTR inptr;
    3633. 

  3633.   ISLOW_MULT_TYPE * quantptr;
    3634. 

  3634.   int * wsptr;
    3635. 

  3635.   JSAMPROW outptr;
    3636. 

  3636.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    3637. 

  3637.   int ctr;
    3638. 

  3638.   int workspace[8*4];	/* buffers data between passes */
    3639. 

  3639.   SHIFT_TEMPS
    3640. 

  3640. 

  3641.   /* Pass 1: process columns from input, store into work array.
    3642. 

  3642.    * 4-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
    3643. 

  3643.    */
    3644. 

  3644.   inptr = coef_block;
    3645. 

  3645.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    3646. 

  3646.   wsptr = workspace;
    3647. 

  3647.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    3648. 

  3648.     /* Even part */
    3649. 

  3649. 

  3650.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    3651. 

  3651.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    3652. 

  3652. 

  3653.     tmp10 = (tmp0 + tmp2) << PASS1_BITS;
    3654. 

  3654.     tmp12 = (tmp0 - tmp2) << PASS1_BITS;
    3655. 

  3655. 

  3656.     /* Odd part */
    3657. 

  3657.     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
    3658. 

  3658. 

  3659.     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    3660. 

  3660.     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    3661. 

  3661. 

  3662.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);               /* c6 */
    3663. 

  3663.     /* Add fudge factor here for final descale. */
    3664. 

  3664.     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
    3665. 

  3665.     tmp0 = RIGHT_SHIFT(z1 + MULTIPLY(z2, FIX_0_765366865), /* c2-c6 */
    3666. 

  3666. 		       CONST_BITS-PASS1_BITS);
    3667. 

  3667.     tmp2 = RIGHT_SHIFT(z1 - MULTIPLY(z3, FIX_1_847759065), /* c2+c6 */
    3668. 

  3668. 		       CONST_BITS-PASS1_BITS);
    3669. 

  3669. 

  3670.     /* Final output stage */
    3671. 

  3671. 

  3672.     wsptr[8*0] = (int) (tmp10 + tmp0);
    3673. 

  3673.     wsptr[8*3] = (int) (tmp10 - tmp0);
    3674. 

  3674.     wsptr[8*1] = (int) (tmp12 + tmp2);
    3675. 

  3675.     wsptr[8*2] = (int) (tmp12 - tmp2);
    3676. 

  3676.   }
    3677. 

  3677. 

  3678.   /* Pass 2: process rows from work array, store into output array. */
    3679. 

  3679.   /* Note that we must descale the results by a factor of 8 == 2**3, */
    3680. 

  3680.   /* and also undo the PASS1_BITS scaling. */
    3681. 

  3681. 

  3682.   wsptr = workspace;
    3683. 

  3683.   for (ctr = 0; ctr < 4; ctr++) {
    3684. 

  3684.     outptr = output_buf[ctr] + output_col;
    3685. 

  3685. 

  3686.     /* Even part: reverse the even part of the forward DCT. */
    3687. 

  3687.     /* The rotator is sqrt(2)*c(-6). */
    3688. 

  3688. 

  3689.     z2 = (INT32) wsptr[2];
    3690. 

  3690.     z3 = (INT32) wsptr[6];
    3691. 

  3691.     
    3692. 

  3692.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
    3693. 

  3693.     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);
    3694. 

  3694.     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);
    3695. 

  3695.     
    3696. 

  3696.     /* Add fudge factor here for final descale. */
    3697. 

  3697.     z2 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    3698. 

  3698.     z3 = (INT32) wsptr[4];
    3699. 

  3699.     
    3700. 

  3700.     tmp0 = (z2 + z3) << CONST_BITS;
    3701. 

  3701.     tmp1 = (z2 - z3) << CONST_BITS;
    3702. 

  3702.     
    3703. 

  3703.     tmp10 = tmp0 + tmp2;
    3704. 

  3704.     tmp13 = tmp0 - tmp2;
    3705. 

  3705.     tmp11 = tmp1 + tmp3;
    3706. 

  3706.     tmp12 = tmp1 - tmp3;
    3707. 

  3707. 

  3708.     /* Odd part per figure 8; the matrix is unitary and hence its
    3709. 

  3709.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
    3710. 

  3710.      */
    3711. 

  3711. 

  3712.     tmp0 = (INT32) wsptr[7];
    3713. 

  3713.     tmp1 = (INT32) wsptr[5];
    3714. 

  3714.     tmp2 = (INT32) wsptr[3];
    3715. 

  3715.     tmp3 = (INT32) wsptr[1];
    3716. 

  3716. 

  3717.     z2 = tmp0 + tmp2;
    3718. 

  3718.     z3 = tmp1 + tmp3;
    3719. 

  3719. 

  3720.     z1 = MULTIPLY(z2 + z3, FIX_1_175875602); /* sqrt(2) * c3 */
    3721. 

  3721.     z2 = MULTIPLY(z2, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
    3722. 

  3722.     z3 = MULTIPLY(z3, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
    3723. 

  3723.     z2 += z1;
    3724. 

  3724.     z3 += z1;
    3725. 

  3725. 

  3726.     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
    3727. 

  3727.     tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
    3728. 

  3728.     tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
    3729. 

  3729.     tmp0 += z1 + z2;
    3730. 

  3730.     tmp3 += z1 + z3;
    3731. 

  3731. 

  3732.     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
    3733. 

  3733.     tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    3734. 

  3734.     tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    3735. 

  3735.     tmp1 += z1 + z3;
    3736. 

  3736.     tmp2 += z1 + z2;
    3737. 

  3737. 

  3738.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
    3739. 

  3739. 

  3740.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
    3741. 

  3741. 					      CONST_BITS+PASS1_BITS+3)
    3742. 

  3742. 			    & RANGE_MASK];
    3743. 

  3743.     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
    3744. 

  3744. 					      CONST_BITS+PASS1_BITS+3)
    3745. 

  3745. 			    & RANGE_MASK];
    3746. 

  3746.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
    3747. 

  3747. 					      CONST_BITS+PASS1_BITS+3)
    3748. 

  3748. 			    & RANGE_MASK];
    3749. 

  3749.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
    3750. 

  3750. 					      CONST_BITS+PASS1_BITS+3)
    3751. 

  3751. 			    & RANGE_MASK];
    3752. 

  3752.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
    3753. 

  3753. 					      CONST_BITS+PASS1_BITS+3)
    3754. 

  3754. 			    & RANGE_MASK];
    3755. 

  3755.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
    3756. 

  3756. 					      CONST_BITS+PASS1_BITS+3)
    3757. 

  3757. 			    & RANGE_MASK];
    3758. 

  3758.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
    3759. 

  3759. 					      CONST_BITS+PASS1_BITS+3)
    3760. 

  3760. 			    & RANGE_MASK];
    3761. 

  3761.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
    3762. 

  3762. 					      CONST_BITS+PASS1_BITS+3)
    3763. 

  3763. 			    & RANGE_MASK];
    3764. 

  3764. 

  3765.     wsptr += DCTSIZE;		/* advance pointer to next row */
    3766. 

  3766.   }
    3767. 

  3767. }
    3768. 

  3768. 

  3769. 

  3770. /*
    3771. 

  3771.  * Perform dequantization and inverse DCT on one block of coefficients,
    3772. 

  3772.  * producing a reduced-size 6x3 output block.
    3773. 

  3773.  *
    3774. 

  3774.  * 3-point IDCT in pass 1 (columns), 6-point in pass 2 (rows).
    3775. 

  3775.  */
    3776. 

  3776. 

  3777. GLOBAL(void)
    3778. 

  3778. jpeg_idct_6x3 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    3779. 

  3779. 	       JCOEFPTR coef_block,
    3780. 

  3780. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    3781. 

  3781. {
    3782. 

  3782.   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
    3783. 

  3783.   INT32 z1, z2, z3;
    3784. 

  3784.   JCOEFPTR inptr;
    3785. 

  3785.   ISLOW_MULT_TYPE * quantptr;
    3786. 

  3786.   int * wsptr;
    3787. 

  3787.   JSAMPROW outptr;
    3788. 

  3788.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    3789. 

  3789.   int ctr;
    3790. 

  3790.   int workspace[6*3];	/* buffers data between passes */
    3791. 

  3791.   SHIFT_TEMPS
    3792. 

  3792. 

  3793.   /* Pass 1: process columns from input, store into work array.
    3794. 

  3794.    * 3-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
    3795. 

  3795.    */
    3796. 

  3796.   inptr = coef_block;
    3797. 

  3797.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    3798. 

  3798.   wsptr = workspace;
    3799. 

  3799.   for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
    3800. 

  3800.     /* Even part */
    3801. 

  3801. 

  3802.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    3803. 

  3803.     tmp0 <<= CONST_BITS;
    3804. 

  3804.     /* Add fudge factor here for final descale. */
    3805. 

  3805.     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
    3806. 

  3806.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    3807. 

  3807.     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
    3808. 

  3808.     tmp10 = tmp0 + tmp12;
    3809. 

  3809.     tmp2 = tmp0 - tmp12 - tmp12;
    3810. 

  3810. 

  3811.     /* Odd part */
    3812. 

  3812. 

  3813.     tmp12 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    3814. 

  3814.     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
    3815. 

  3815. 

  3816.     /* Final output stage */
    3817. 

  3817. 

  3818.     wsptr[6*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
    3819. 

  3819.     wsptr[6*2] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
    3820. 

  3820.     wsptr[6*1] = (int) RIGHT_SHIFT(tmp2, CONST_BITS-PASS1_BITS);
    3821. 

  3821.   }
    3822. 

  3822.   
    3823. 

  3823.   /* Pass 2: process 3 rows from work array, store into output array.
    3824. 

  3824.    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
    3825. 

  3825.    */
    3826. 

  3826.   wsptr = workspace;
    3827. 

  3827.   for (ctr = 0; ctr < 3; ctr++) {
    3828. 

  3828.     outptr = output_buf[ctr] + output_col;
    3829. 

  3829. 

  3830.     /* Even part */
    3831. 

  3831. 

  3832.     /* Add fudge factor here for final descale. */
    3833. 

  3833.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    3834. 

  3834.     tmp0 <<= CONST_BITS;
    3835. 

  3835.     tmp2 = (INT32) wsptr[4];
    3836. 

  3836.     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
    3837. 

  3837.     tmp1 = tmp0 + tmp10;
    3838. 

  3838.     tmp11 = tmp0 - tmp10 - tmp10;
    3839. 

  3839.     tmp10 = (INT32) wsptr[2];
    3840. 

  3840.     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
    3841. 

  3841.     tmp10 = tmp1 + tmp0;
    3842. 

  3842.     tmp12 = tmp1 - tmp0;
    3843. 

  3843. 

  3844.     /* Odd part */
    3845. 

  3845. 

  3846.     z1 = (INT32) wsptr[1];
    3847. 

  3847.     z2 = (INT32) wsptr[3];
    3848. 

  3848.     z3 = (INT32) wsptr[5];
    3849. 

  3849.     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
    3850. 

  3850.     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
    3851. 

  3851.     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
    3852. 

  3852.     tmp1 = (z1 - z2 - z3) << CONST_BITS;
    3853. 

  3853. 

  3854.     /* Final output stage */
    3855. 

  3855. 

  3856.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    3857. 

  3857. 					      CONST_BITS+PASS1_BITS+3)
    3858. 

  3858. 			    & RANGE_MASK];
    3859. 

  3859.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    3860. 

  3860. 					      CONST_BITS+PASS1_BITS+3)
    3861. 

  3861. 			    & RANGE_MASK];
    3862. 

  3862.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
    3863. 

  3863. 					      CONST_BITS+PASS1_BITS+3)
    3864. 

  3864. 			    & RANGE_MASK];
    3865. 

  3865.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
    3866. 

  3866. 					      CONST_BITS+PASS1_BITS+3)
    3867. 

  3867. 			    & RANGE_MASK];
    3868. 

  3868.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
    3869. 

  3869. 					      CONST_BITS+PASS1_BITS+3)
    3870. 

  3870. 			    & RANGE_MASK];
    3871. 

  3871.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
    3872. 

  3872. 					      CONST_BITS+PASS1_BITS+3)
    3873. 

  3873. 			    & RANGE_MASK];
    3874. 

  3874. 

  3875.     wsptr += 6;		/* advance pointer to next row */
    3876. 

  3876.   }
    3877. 

  3877. }
    3878. 

  3878. 

  3879. 

  3880. /*
    3881. 

  3881.  * Perform dequantization and inverse DCT on one block of coefficients,
    3882. 

  3882.  * producing a 4x2 output block.
    3883. 

  3883.  *
    3884. 

  3884.  * 2-point IDCT in pass 1 (columns), 4-point in pass 2 (rows).
    3885. 

  3885.  */
    3886. 

  3886. 

  3887. GLOBAL(void)
    3888. 

  3888. jpeg_idct_4x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    3889. 

  3889. 	       JCOEFPTR coef_block,
    3890. 

  3890. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    3891. 

  3891. {
    3892. 

  3892.   INT32 tmp0, tmp2, tmp10, tmp12;
    3893. 

  3893.   INT32 z1, z2, z3;
    3894. 

  3894.   JCOEFPTR inptr;
    3895. 

  3895.   ISLOW_MULT_TYPE * quantptr;
    3896. 

  3896.   INT32 * wsptr;
    3897. 

  3897.   JSAMPROW outptr;
    3898. 

  3898.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    3899. 

  3899.   int ctr;
    3900. 

  3900.   INT32 workspace[4*2];	/* buffers data between passes */
    3901. 

  3901.   SHIFT_TEMPS
    3902. 

  3902. 

  3903.   /* Pass 1: process columns from input, store into work array. */
    3904. 

  3904. 

  3905.   inptr = coef_block;
    3906. 

  3906.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    3907. 

  3907.   wsptr = workspace;
    3908. 

  3908.   for (ctr = 0; ctr < 4; ctr++, inptr++, quantptr++, wsptr++) {
    3909. 

  3909.     /* Even part */
    3910. 

  3910. 

  3911.     tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    3912. 

  3912. 

  3913.     /* Odd part */
    3914. 

  3914. 

  3915.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    3916. 

  3916. 

  3917.     /* Final output stage */
    3918. 

  3918. 

  3919.     wsptr[4*0] = tmp10 + tmp0;
    3920. 

  3920.     wsptr[4*1] = tmp10 - tmp0;
    3921. 

  3921.   }
    3922. 

  3922. 

  3923.   /* Pass 2: process 2 rows from work array, store into output array.
    3924. 

  3924.    * 4-point IDCT kernel,
    3925. 

  3925.    * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
    3926. 

  3926.    */
    3927. 

  3927.   wsptr = workspace;
    3928. 

  3928.   for (ctr = 0; ctr < 2; ctr++) {
    3929. 

  3929.     outptr = output_buf[ctr] + output_col;
    3930. 

  3930. 

  3931.     /* Even part */
    3932. 

  3932. 

  3933.     /* Add fudge factor here for final descale. */
    3934. 

  3934.     tmp0 = wsptr[0] + (ONE << 2);
    3935. 

  3935.     tmp2 = wsptr[2];
    3936. 

  3936. 

  3937.     tmp10 = (tmp0 + tmp2) << CONST_BITS;
    3938. 

  3938.     tmp12 = (tmp0 - tmp2) << CONST_BITS;
    3939. 

  3939. 

  3940.     /* Odd part */
    3941. 

  3941.     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
    3942. 

  3942. 

  3943.     z2 = wsptr[1];
    3944. 

  3944.     z3 = wsptr[3];
    3945. 

  3945. 

  3946.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
    3947. 

  3947.     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
    3948. 

  3948.     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
    3949. 

  3949. 

  3950.     /* Final output stage */
    3951. 

  3951. 

  3952.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    3953. 

  3953. 					      CONST_BITS+3)
    3954. 

  3954. 			    & RANGE_MASK];
    3955. 

  3955.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    3956. 

  3956. 					      CONST_BITS+3)
    3957. 

  3957. 			    & RANGE_MASK];
    3958. 

  3958.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
    3959. 

  3959. 					      CONST_BITS+3)
    3960. 

  3960. 			    & RANGE_MASK];
    3961. 

  3961.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
    3962. 

  3962. 					      CONST_BITS+3)
    3963. 

  3963. 			    & RANGE_MASK];
    3964. 

  3964. 

  3965.     wsptr += 4;		/* advance pointer to next row */
    3966. 

  3966.   }
    3967. 

  3967. }
    3968. 

  3968. 

  3969. 

  3970. /*
    3971. 

  3971.  * Perform dequantization and inverse DCT on one block of coefficients,
    3972. 

  3972.  * producing a 2x1 output block.
    3973. 

  3973.  *
    3974. 

  3974.  * 1-point IDCT in pass 1 (columns), 2-point in pass 2 (rows).
    3975. 

  3975.  */
    3976. 

  3976. 

  3977. GLOBAL(void)
    3978. 

  3978. jpeg_idct_2x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    3979. 

  3979. 	       JCOEFPTR coef_block,
    3980. 

  3980. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    3981. 

  3981. {
    3982. 

  3982.   INT32 tmp0, tmp10;
    3983. 

  3983.   ISLOW_MULT_TYPE * quantptr;
    3984. 

  3984.   JSAMPROW outptr;
    3985. 

  3985.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    3986. 

  3986.   SHIFT_TEMPS
    3987. 

  3987. 

  3988.   /* Pass 1: empty. */
    3989. 

  3989. 

  3990.   /* Pass 2: process 1 row from input, store into output array. */
    3991. 

  3991. 

  3992.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    3993. 

  3993.   outptr = output_buf[0] + output_col;
    3994. 

  3994. 

  3995.   /* Even part */
    3996. 

  3996. 

  3997.   tmp10 = DEQUANTIZE(coef_block[0], quantptr[0]);
    3998. 

  3998.   /* Add fudge factor here for final descale. */
    3999. 

  3999.   tmp10 += ONE << 2;
    4000. 

  4000. 

  4001.   /* Odd part */
    4002. 

  4002. 

  4003.   tmp0 = DEQUANTIZE(coef_block[1], quantptr[1]);
    4004. 

  4004. 

  4005.   /* Final output stage */
    4006. 

  4006. 

  4007.   outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0, 3) & RANGE_MASK];
    4008. 

  4008.   outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0, 3) & RANGE_MASK];
    4009. 

  4009. }
    4010. 

  4010. 

  4011. 

  4012. /*
    4013. 

  4013.  * Perform dequantization and inverse DCT on one block of coefficients,
    4014. 

  4014.  * producing a 8x16 output block.
    4015. 

  4015.  *
    4016. 

  4016.  * 16-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
    4017. 

  4017.  */
    4018. 

  4018. 

  4019. GLOBAL(void)
    4020. 

  4020. jpeg_idct_8x16 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    4021. 

  4021. 		JCOEFPTR coef_block,
    4022. 

  4022. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    4023. 

  4023. {
    4024. 

  4024.   INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
    4025. 

  4025.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
    4026. 

  4026.   INT32 z1, z2, z3, z4;
    4027. 

  4027.   JCOEFPTR inptr;
    4028. 

  4028.   ISLOW_MULT_TYPE * quantptr;
    4029. 

  4029.   int * wsptr;
    4030. 

  4030.   JSAMPROW outptr;
    4031. 

  4031.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    4032. 

  4032.   int ctr;
    4033. 

  4033.   int workspace[8*16];	/* buffers data between passes */
    4034. 

  4034.   SHIFT_TEMPS
    4035. 

  4035. 

  4036.   /* Pass 1: process columns from input, store into work array.
    4037. 

  4037.    * 16-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
    4038. 

  4038.    */
    4039. 

  4039.   inptr = coef_block;
    4040. 

  4040.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    4041. 

  4041.   wsptr = workspace;
    4042. 

  4042.   for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
    4043. 

  4043.     /* Even part */
    4044. 

  4044. 

  4045.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    4046. 

  4046.     tmp0 <<= CONST_BITS;
    4047. 

  4047.     /* Add fudge factor here for final descale. */
    4048. 

  4048.     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
    4049. 

  4049. 

  4050.     z1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    4051. 

  4051.     tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
    4052. 

  4052.     tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
    4053. 

  4053. 

  4054.     tmp10 = tmp0 + tmp1;
    4055. 

  4055.     tmp11 = tmp0 - tmp1;
    4056. 

  4056.     tmp12 = tmp0 + tmp2;
    4057. 

  4057.     tmp13 = tmp0 - tmp2;
    4058. 

  4058. 

  4059.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    4060. 

  4060.     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    4061. 

  4061.     z3 = z1 - z2;
    4062. 

  4062.     z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
    4063. 

  4063.     z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
    4064. 

  4064. 

  4065.     tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
    4066. 

  4066.     tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
    4067. 

  4067.     tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
    4068. 

  4068.     tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
    4069. 

  4069. 

  4070.     tmp20 = tmp10 + tmp0;
    4071. 

  4071.     tmp27 = tmp10 - tmp0;
    4072. 

  4072.     tmp21 = tmp12 + tmp1;
    4073. 

  4073.     tmp26 = tmp12 - tmp1;
    4074. 

  4074.     tmp22 = tmp13 + tmp2;
    4075. 

  4075.     tmp25 = tmp13 - tmp2;
    4076. 

  4076.     tmp23 = tmp11 + tmp3;
    4077. 

  4077.     tmp24 = tmp11 - tmp3;
    4078. 

  4078. 

  4079.     /* Odd part */
    4080. 

  4080. 

  4081.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    4082. 

  4082.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    4083. 

  4083.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    4084. 

  4084.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    4085. 

  4085. 

  4086.     tmp11 = z1 + z3;
    4087. 

  4087. 

  4088.     tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
    4089. 

  4089.     tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
    4090. 

  4090.     tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
    4091. 

  4091.     tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
    4092. 

  4092.     tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
    4093. 

  4093.     tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
    4094. 

  4094.     tmp0  = tmp1 + tmp2 + tmp3 -
    4095. 

  4095. 	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
    4096. 

  4096.     tmp13 = tmp10 + tmp11 + tmp12 -
    4097. 

  4097. 	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
    4098. 

  4098.     z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
    4099. 

  4099.     tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
    4100. 

  4100.     tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
    4101. 

  4101.     z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
    4102. 

  4102.     tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
    4103. 

  4103.     tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
    4104. 

  4104.     z2    += z4;
    4105. 

  4105.     z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
    4106. 

  4106.     tmp1  += z1;
    4107. 

  4107.     tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
    4108. 

  4108.     z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
    4109. 

  4109.     tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
    4110. 

  4110.     tmp12 += z2;
    4111. 

  4111.     z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
    4112. 

  4112.     tmp2  += z2;
    4113. 

  4113.     tmp3  += z2;
    4114. 

  4114.     z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
    4115. 

  4115.     tmp10 += z2;
    4116. 

  4116.     tmp11 += z2;
    4117. 

  4117. 

  4118.     /* Final output stage */
    4119. 

  4119. 

  4120.     wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp0,  CONST_BITS-PASS1_BITS);
    4121. 

  4121.     wsptr[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0,  CONST_BITS-PASS1_BITS);
    4122. 

  4122.     wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp1,  CONST_BITS-PASS1_BITS);
    4123. 

  4123.     wsptr[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1,  CONST_BITS-PASS1_BITS);
    4124. 

  4124.     wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp2,  CONST_BITS-PASS1_BITS);
    4125. 

  4125.     wsptr[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2,  CONST_BITS-PASS1_BITS);
    4126. 

  4126.     wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp3,  CONST_BITS-PASS1_BITS);
    4127. 

  4127.     wsptr[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3,  CONST_BITS-PASS1_BITS);
    4128. 

  4128.     wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
    4129. 

  4129.     wsptr[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
    4130. 

  4130.     wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
    4131. 

  4131.     wsptr[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
    4132. 

  4132.     wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
    4133. 

  4133.     wsptr[8*9]  = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
    4134. 

  4134.     wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
    4135. 

  4135.     wsptr[8*8]  = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
    4136. 

  4136.   }
    4137. 

  4137.   
    4138. 

  4138.   /* Pass 2: process rows from work array, store into output array. */
    4139. 

  4139.   /* Note that we must descale the results by a factor of 8 == 2**3, */
    4140. 

  4140.   /* and also undo the PASS1_BITS scaling. */
    4141. 

  4141. 

  4142.   wsptr = workspace;
    4143. 

  4143.   for (ctr = 0; ctr < 16; ctr++) {
    4144. 

  4144.     outptr = output_buf[ctr] + output_col;
    4145. 

  4145.     
    4146. 

  4146.     /* Even part: reverse the even part of the forward DCT. */
    4147. 

  4147.     /* The rotator is sqrt(2)*c(-6). */
    4148. 

  4148.     
    4149. 

  4149.     z2 = (INT32) wsptr[2];
    4150. 

  4150.     z3 = (INT32) wsptr[6];
    4151. 

  4151.     
    4152. 

  4152.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
    4153. 

  4153.     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);
    4154. 

  4154.     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);
    4155. 

  4155.     
    4156. 

  4156.     /* Add fudge factor here for final descale. */
    4157. 

  4157.     z2 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    4158. 

  4158.     z3 = (INT32) wsptr[4];
    4159. 

  4159.     
    4160. 

  4160.     tmp0 = (z2 + z3) << CONST_BITS;
    4161. 

  4161.     tmp1 = (z2 - z3) << CONST_BITS;
    4162. 

  4162.     
    4163. 

  4163.     tmp10 = tmp0 + tmp2;
    4164. 

  4164.     tmp13 = tmp0 - tmp2;
    4165. 

  4165.     tmp11 = tmp1 + tmp3;
    4166. 

  4166.     tmp12 = tmp1 - tmp3;
    4167. 

  4167.     
    4168. 

  4168.     /* Odd part per figure 8; the matrix is unitary and hence its
    4169. 

  4169.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
    4170. 

  4170.      */
    4171. 

  4171.     
    4172. 

  4172.     tmp0 = (INT32) wsptr[7];
    4173. 

  4173.     tmp1 = (INT32) wsptr[5];
    4174. 

  4174.     tmp2 = (INT32) wsptr[3];
    4175. 

  4175.     tmp3 = (INT32) wsptr[1];
    4176. 

  4176.     
    4177. 

  4177.     z2 = tmp0 + tmp2;
    4178. 

  4178.     z3 = tmp1 + tmp3;
    4179. 

  4179. 

  4180.     z1 = MULTIPLY(z2 + z3, FIX_1_175875602); /* sqrt(2) * c3 */
    4181. 

  4181.     z2 = MULTIPLY(z2, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
    4182. 

  4182.     z3 = MULTIPLY(z3, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
    4183. 

  4183.     z2 += z1;
    4184. 

  4184.     z3 += z1;
    4185. 

  4185. 

  4186.     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
    4187. 

  4187.     tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
    4188. 

  4188.     tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
    4189. 

  4189.     tmp0 += z1 + z2;
    4190. 

  4190.     tmp3 += z1 + z3;
    4191. 

  4191. 

  4192.     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
    4193. 

  4193.     tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    4194. 

  4194.     tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    4195. 

  4195.     tmp1 += z1 + z3;
    4196. 

  4196.     tmp2 += z1 + z2;
    4197. 

  4197.     
    4198. 

  4198.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
    4199. 

  4199.     
    4200. 

  4200.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
    4201. 

  4201. 					      CONST_BITS+PASS1_BITS+3)
    4202. 

  4202. 			    & RANGE_MASK];
    4203. 

  4203.     outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
    4204. 

  4204. 					      CONST_BITS+PASS1_BITS+3)
    4205. 

  4205. 			    & RANGE_MASK];
    4206. 

  4206.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
    4207. 

  4207. 					      CONST_BITS+PASS1_BITS+3)
    4208. 

  4208. 			    & RANGE_MASK];
    4209. 

  4209.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
    4210. 

  4210. 					      CONST_BITS+PASS1_BITS+3)
    4211. 

  4211. 			    & RANGE_MASK];
    4212. 

  4212.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
    4213. 

  4213. 					      CONST_BITS+PASS1_BITS+3)
    4214. 

  4214. 			    & RANGE_MASK];
    4215. 

  4215.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
    4216. 

  4216. 					      CONST_BITS+PASS1_BITS+3)
    4217. 

  4217. 			    & RANGE_MASK];
    4218. 

  4218.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
    4219. 

  4219. 					      CONST_BITS+PASS1_BITS+3)
    4220. 

  4220. 			    & RANGE_MASK];
    4221. 

  4221.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
    4222. 

  4222. 					      CONST_BITS+PASS1_BITS+3)
    4223. 

  4223. 			    & RANGE_MASK];
    4224. 

  4224.     
    4225. 

  4225.     wsptr += DCTSIZE;		/* advance pointer to next row */
    4226. 

  4226.   }
    4227. 

  4227. }
    4228. 

  4228. 

  4229. 

  4230. /*
    4231. 

  4231.  * Perform dequantization and inverse DCT on one block of coefficients,
    4232. 

  4232.  * producing a 7x14 output block.
    4233. 

  4233.  *
    4234. 

  4234.  * 14-point IDCT in pass 1 (columns), 7-point in pass 2 (rows).
    4235. 

  4235.  */
    4236. 

  4236. 

  4237. GLOBAL(void)
    4238. 

  4238. jpeg_idct_7x14 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    4239. 

  4239. 		JCOEFPTR coef_block,
    4240. 

  4240. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    4241. 

  4241. {
    4242. 

  4242.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
    4243. 

  4243.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
    4244. 

  4244.   INT32 z1, z2, z3, z4;
    4245. 

  4245.   JCOEFPTR inptr;
    4246. 

  4246.   ISLOW_MULT_TYPE * quantptr;
    4247. 

  4247.   int * wsptr;
    4248. 

  4248.   JSAMPROW outptr;
    4249. 

  4249.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    4250. 

  4250.   int ctr;
    4251. 

  4251.   int workspace[7*14];	/* buffers data between passes */
    4252. 

  4252.   SHIFT_TEMPS
    4253. 

  4253. 

  4254.   /* Pass 1: process columns from input, store into work array.
    4255. 

  4255.    * 14-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/28).
    4256. 

  4256.    */
    4257. 

  4257.   inptr = coef_block;
    4258. 

  4258.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    4259. 

  4259.   wsptr = workspace;
    4260. 

  4260.   for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
    4261. 

  4261.     /* Even part */
    4262. 

  4262. 

  4263.     z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    4264. 

  4264.     z1 <<= CONST_BITS;
    4265. 

  4265.     /* Add fudge factor here for final descale. */
    4266. 

  4266.     z1 += ONE << (CONST_BITS-PASS1_BITS-1);
    4267. 

  4267.     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    4268. 

  4268.     z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
    4269. 

  4269.     z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
    4270. 

  4270.     z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
    4271. 

  4271. 

  4272.     tmp10 = z1 + z2;
    4273. 

  4273.     tmp11 = z1 + z3;
    4274. 

  4274.     tmp12 = z1 - z4;
    4275. 

  4275. 

  4276.     tmp23 = RIGHT_SHIFT(z1 - ((z2 + z3 - z4) << 1), /* c0 = (c4+c12-c8)*2 */
    4277. 

  4277. 			CONST_BITS-PASS1_BITS);
    4278. 

  4278. 

  4279.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    4280. 

  4280.     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    4281. 

  4281. 

  4282.     z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
    4283. 

  4283. 

  4284.     tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
    4285. 

  4285.     tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
    4286. 

  4286.     tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
    4287. 

  4287. 	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
    4288. 

  4288. 

  4289.     tmp20 = tmp10 + tmp13;
    4290. 

  4290.     tmp26 = tmp10 - tmp13;
    4291. 

  4291.     tmp21 = tmp11 + tmp14;
    4292. 

  4292.     tmp25 = tmp11 - tmp14;
    4293. 

  4293.     tmp22 = tmp12 + tmp15;
    4294. 

  4294.     tmp24 = tmp12 - tmp15;
    4295. 

  4295. 

  4296.     /* Odd part */
    4297. 

  4297. 

  4298.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    4299. 

  4299.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    4300. 

  4300.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    4301. 

  4301.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    4302. 

  4302.     tmp13 = z4 << CONST_BITS;
    4303. 

  4303. 

  4304.     tmp14 = z1 + z3;
    4305. 

  4305.     tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
    4306. 

  4306.     tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
    4307. 

  4307.     tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
    4308. 

  4308.     tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
    4309. 

  4309.     tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
    4310. 

  4310.     z1    -= z2;
    4311. 

  4311.     tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13;        /* c11 */
    4312. 

  4312.     tmp16 += tmp15;
    4313. 

  4313.     z1    += z4;
    4314. 

  4314.     z4    = MULTIPLY(z2 + z3, - FIX(0.158341681)) - tmp13; /* -c13 */
    4315. 

  4315.     tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948));          /* c3-c9-c13 */
    4316. 

  4316.     tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773));          /* c3+c5-c13 */
    4317. 

  4317.     z4    = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
    4318. 

  4318.     tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
    4319. 

  4319.     tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567));          /* c1+c11-c5 */
    4320. 

  4320. 

  4321.     tmp13 = (z1 - z3) << PASS1_BITS;
    4322. 

  4322. 

  4323.     /* Final output stage */
    4324. 

  4324. 

  4325.     wsptr[7*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    4326. 

  4326.     wsptr[7*13] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    4327. 

  4327.     wsptr[7*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    4328. 

  4328.     wsptr[7*12] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    4329. 

  4329.     wsptr[7*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    4330. 

  4330.     wsptr[7*11] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    4331. 

  4331.     wsptr[7*3]  = (int) (tmp23 + tmp13);
    4332. 

  4332.     wsptr[7*10] = (int) (tmp23 - tmp13);
    4333. 

  4333.     wsptr[7*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    4334. 

  4334.     wsptr[7*9]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    4335. 

  4335.     wsptr[7*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
    4336. 

  4336.     wsptr[7*8]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
    4337. 

  4337.     wsptr[7*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
    4338. 

  4338.     wsptr[7*7]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
    4339. 

  4339.   }
    4340. 

  4340. 

  4341.   /* Pass 2: process 14 rows from work array, store into output array.
    4342. 

  4342.    * 7-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
    4343. 

  4343.    */
    4344. 

  4344.   wsptr = workspace;
    4345. 

  4345.   for (ctr = 0; ctr < 14; ctr++) {
    4346. 

  4346.     outptr = output_buf[ctr] + output_col;
    4347. 

  4347. 

  4348.     /* Even part */
    4349. 

  4349. 

  4350.     /* Add fudge factor here for final descale. */
    4351. 

  4351.     tmp23 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    4352. 

  4352.     tmp23 <<= CONST_BITS;
    4353. 

  4353. 

  4354.     z1 = (INT32) wsptr[2];
    4355. 

  4355.     z2 = (INT32) wsptr[4];
    4356. 

  4356.     z3 = (INT32) wsptr[6];
    4357. 

  4357. 

  4358.     tmp20 = MULTIPLY(z2 - z3, FIX(0.881747734));       /* c4 */
    4359. 

  4359.     tmp22 = MULTIPLY(z1 - z2, FIX(0.314692123));       /* c6 */
    4360. 

  4360.     tmp21 = tmp20 + tmp22 + tmp23 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
    4361. 

  4361.     tmp10 = z1 + z3;
    4362. 

  4362.     z2 -= tmp10;
    4363. 

  4363.     tmp10 = MULTIPLY(tmp10, FIX(1.274162392)) + tmp23; /* c2 */
    4364. 

  4364.     tmp20 += tmp10 - MULTIPLY(z3, FIX(0.077722536));   /* c2-c4-c6 */
    4365. 

  4365.     tmp22 += tmp10 - MULTIPLY(z1, FIX(2.470602249));   /* c2+c4+c6 */
    4366. 

  4366.     tmp23 += MULTIPLY(z2, FIX(1.414213562));           /* c0 */
    4367. 

  4367. 

  4368.     /* Odd part */
    4369. 

  4369. 

  4370.     z1 = (INT32) wsptr[1];
    4371. 

  4371.     z2 = (INT32) wsptr[3];
    4372. 

  4372.     z3 = (INT32) wsptr[5];
    4373. 

  4373. 

  4374.     tmp11 = MULTIPLY(z1 + z2, FIX(0.935414347));       /* (c3+c1-c5)/2 */
    4375. 

  4375.     tmp12 = MULTIPLY(z1 - z2, FIX(0.170262339));       /* (c3+c5-c1)/2 */
    4376. 

  4376.     tmp10 = tmp11 - tmp12;
    4377. 

  4377.     tmp11 += tmp12;
    4378. 

  4378.     tmp12 = MULTIPLY(z2 + z3, - FIX(1.378756276));     /* -c1 */
    4379. 

  4379.     tmp11 += tmp12;
    4380. 

  4380.     z2 = MULTIPLY(z1 + z3, FIX(0.613604268));          /* c5 */
    4381. 

  4381.     tmp10 += z2;
    4382. 

  4382.     tmp12 += z2 + MULTIPLY(z3, FIX(1.870828693));      /* c3+c1-c5 */
    4383. 

  4383. 

  4384.     /* Final output stage */
    4385. 

  4385. 

  4386.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    4387. 

  4387. 					      CONST_BITS+PASS1_BITS+3)
    4388. 

  4388. 			    & RANGE_MASK];
    4389. 

  4389.     outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    4390. 

  4390. 					      CONST_BITS+PASS1_BITS+3)
    4391. 

  4391. 			    & RANGE_MASK];
    4392. 

  4392.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    4393. 

  4393. 					      CONST_BITS+PASS1_BITS+3)
    4394. 

  4394. 			    & RANGE_MASK];
    4395. 

  4395.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    4396. 

  4396. 					      CONST_BITS+PASS1_BITS+3)
    4397. 

  4397. 			    & RANGE_MASK];
    4398. 

  4398.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    4399. 

  4399. 					      CONST_BITS+PASS1_BITS+3)
    4400. 

  4400. 			    & RANGE_MASK];
    4401. 

  4401.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    4402. 

  4402. 					      CONST_BITS+PASS1_BITS+3)
    4403. 

  4403. 			    & RANGE_MASK];
    4404. 

  4404.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23,
    4405. 

  4405. 					      CONST_BITS+PASS1_BITS+3)
    4406. 

  4406. 			    & RANGE_MASK];
    4407. 

  4407. 

  4408.     wsptr += 7;		/* advance pointer to next row */
    4409. 

  4409.   }
    4410. 

  4410. }
    4411. 

  4411. 

  4412. 

  4413. /*
    4414. 

  4414.  * Perform dequantization and inverse DCT on one block of coefficients,
    4415. 

  4415.  * producing a 6x12 output block.
    4416. 

  4416.  *
    4417. 

  4417.  * 12-point IDCT in pass 1 (columns), 6-point in pass 2 (rows).
    4418. 

  4418.  */
    4419. 

  4419. 

  4420. GLOBAL(void)
    4421. 

  4421. jpeg_idct_6x12 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    4422. 

  4422. 		JCOEFPTR coef_block,
    4423. 

  4423. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    4424. 

  4424. {
    4425. 

  4425.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
    4426. 

  4426.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
    4427. 

  4427.   INT32 z1, z2, z3, z4;
    4428. 

  4428.   JCOEFPTR inptr;
    4429. 

  4429.   ISLOW_MULT_TYPE * quantptr;
    4430. 

  4430.   int * wsptr;
    4431. 

  4431.   JSAMPROW outptr;
    4432. 

  4432.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    4433. 

  4433.   int ctr;
    4434. 

  4434.   int workspace[6*12];	/* buffers data between passes */
    4435. 

  4435.   SHIFT_TEMPS
    4436. 

  4436. 

  4437.   /* Pass 1: process columns from input, store into work array.
    4438. 

  4438.    * 12-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/24).
    4439. 

  4439.    */
    4440. 

  4440.   inptr = coef_block;
    4441. 

  4441.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    4442. 

  4442.   wsptr = workspace;
    4443. 

  4443.   for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
    4444. 

  4444.     /* Even part */
    4445. 

  4445. 

  4446.     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    4447. 

  4447.     z3 <<= CONST_BITS;
    4448. 

  4448.     /* Add fudge factor here for final descale. */
    4449. 

  4449.     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
    4450. 

  4450. 

  4451.     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    4452. 

  4452.     z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
    4453. 

  4453. 

  4454.     tmp10 = z3 + z4;
    4455. 

  4455.     tmp11 = z3 - z4;
    4456. 

  4456. 

  4457.     z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    4458. 

  4458.     z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
    4459. 

  4459.     z1 <<= CONST_BITS;
    4460. 

  4460.     z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    4461. 

  4461.     z2 <<= CONST_BITS;
    4462. 

  4462. 

  4463.     tmp12 = z1 - z2;
    4464. 

  4464. 

  4465.     tmp21 = z3 + tmp12;
    4466. 

  4466.     tmp24 = z3 - tmp12;
    4467. 

  4467. 

  4468.     tmp12 = z4 + z2;
    4469. 

  4469. 

  4470.     tmp20 = tmp10 + tmp12;
    4471. 

  4471.     tmp25 = tmp10 - tmp12;
    4472. 

  4472. 

  4473.     tmp12 = z4 - z1 - z2;
    4474. 

  4474. 

  4475.     tmp22 = tmp11 + tmp12;
    4476. 

  4476.     tmp23 = tmp11 - tmp12;
    4477. 

  4477. 

  4478.     /* Odd part */
    4479. 

  4479. 

  4480.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    4481. 

  4481.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    4482. 

  4482.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    4483. 

  4483.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    4484. 

  4484. 

  4485.     tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
    4486. 

  4486.     tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
    4487. 

  4487. 

  4488.     tmp10 = z1 + z3;
    4489. 

  4489.     tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
    4490. 

  4490.     tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
    4491. 

  4491.     tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
    4492. 

  4492.     tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
    4493. 

  4493.     tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
    4494. 

  4494.     tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
    4495. 

  4495.     tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
    4496. 

  4496. 	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
    4497. 

  4497. 

  4498.     z1 -= z4;
    4499. 

  4499.     z2 -= z3;
    4500. 

  4500.     z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
    4501. 

  4501.     tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
    4502. 

  4502.     tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
    4503. 

  4503. 

  4504.     /* Final output stage */
    4505. 

  4505. 

  4506.     wsptr[6*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    4507. 

  4507.     wsptr[6*11] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    4508. 

  4508.     wsptr[6*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    4509. 

  4509.     wsptr[6*10] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    4510. 

  4510.     wsptr[6*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
    4511. 

  4511.     wsptr[6*9]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
    4512. 

  4512.     wsptr[6*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
    4513. 

  4513.     wsptr[6*8]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
    4514. 

  4514.     wsptr[6*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    4515. 

  4515.     wsptr[6*7]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    4516. 

  4516.     wsptr[6*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
    4517. 

  4517.     wsptr[6*6]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
    4518. 

  4518.   }
    4519. 

  4519. 

  4520.   /* Pass 2: process 12 rows from work array, store into output array.
    4521. 

  4521.    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
    4522. 

  4522.    */
    4523. 

  4523.   wsptr = workspace;
    4524. 

  4524.   for (ctr = 0; ctr < 12; ctr++) {
    4525. 

  4525.     outptr = output_buf[ctr] + output_col;
    4526. 

  4526. 

  4527.     /* Even part */
    4528. 

  4528. 

  4529.     /* Add fudge factor here for final descale. */
    4530. 

  4530.     tmp10 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    4531. 

  4531.     tmp10 <<= CONST_BITS;
    4532. 

  4532.     tmp12 = (INT32) wsptr[4];
    4533. 

  4533.     tmp20 = MULTIPLY(tmp12, FIX(0.707106781));   /* c4 */
    4534. 

  4534.     tmp11 = tmp10 + tmp20;
    4535. 

  4535.     tmp21 = tmp10 - tmp20 - tmp20;
    4536. 

  4536.     tmp20 = (INT32) wsptr[2];
    4537. 

  4537.     tmp10 = MULTIPLY(tmp20, FIX(1.224744871));   /* c2 */
    4538. 

  4538.     tmp20 = tmp11 + tmp10;
    4539. 

  4539.     tmp22 = tmp11 - tmp10;
    4540. 

  4540. 

  4541.     /* Odd part */
    4542. 

  4542. 

  4543.     z1 = (INT32) wsptr[1];
    4544. 

  4544.     z2 = (INT32) wsptr[3];
    4545. 

  4545.     z3 = (INT32) wsptr[5];
    4546. 

  4546.     tmp11 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
    4547. 

  4547.     tmp10 = tmp11 + ((z1 + z2) << CONST_BITS);
    4548. 

  4548.     tmp12 = tmp11 + ((z3 - z2) << CONST_BITS);
    4549. 

  4549.     tmp11 = (z1 - z2 - z3) << CONST_BITS;
    4550. 

  4550. 

  4551.     /* Final output stage */
    4552. 

  4552. 

  4553.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
    4554. 

  4554. 					      CONST_BITS+PASS1_BITS+3)
    4555. 

  4555. 			    & RANGE_MASK];
    4556. 

  4556.     outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
    4557. 

  4557. 					      CONST_BITS+PASS1_BITS+3)
    4558. 

  4558. 			    & RANGE_MASK];
    4559. 

  4559.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
    4560. 

  4560. 					      CONST_BITS+PASS1_BITS+3)
    4561. 

  4561. 			    & RANGE_MASK];
    4562. 

  4562.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
    4563. 

  4563. 					      CONST_BITS+PASS1_BITS+3)
    4564. 

  4564. 			    & RANGE_MASK];
    4565. 

  4565.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
    4566. 

  4566. 					      CONST_BITS+PASS1_BITS+3)
    4567. 

  4567. 			    & RANGE_MASK];
    4568. 

  4568.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
    4569. 

  4569. 					      CONST_BITS+PASS1_BITS+3)
    4570. 

  4570. 			    & RANGE_MASK];
    4571. 

  4571. 

  4572.     wsptr += 6;		/* advance pointer to next row */
    4573. 

  4573.   }
    4574. 

  4574. }
    4575. 

  4575. 

  4576. 

  4577. /*
    4578. 

  4578.  * Perform dequantization and inverse DCT on one block of coefficients,
    4579. 

  4579.  * producing a 5x10 output block.
    4580. 

  4580.  *
    4581. 

  4581.  * 10-point IDCT in pass 1 (columns), 5-point in pass 2 (rows).
    4582. 

  4582.  */
    4583. 

  4583. 

  4584. GLOBAL(void)
    4585. 

  4585. jpeg_idct_5x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    4586. 

  4586. 		JCOEFPTR coef_block,
    4587. 

  4587. 		JSAMPARRAY output_buf, JDIMENSION output_col)
    4588. 

  4588. {
    4589. 

  4589.   INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
    4590. 

  4590.   INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
    4591. 

  4591.   INT32 z1, z2, z3, z4, z5;
    4592. 

  4592.   JCOEFPTR inptr;
    4593. 

  4593.   ISLOW_MULT_TYPE * quantptr;
    4594. 

  4594.   int * wsptr;
    4595. 

  4595.   JSAMPROW outptr;
    4596. 

  4596.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    4597. 

  4597.   int ctr;
    4598. 

  4598.   int workspace[5*10];	/* buffers data between passes */
    4599. 

  4599.   SHIFT_TEMPS
    4600. 

  4600. 

  4601.   /* Pass 1: process columns from input, store into work array.
    4602. 

  4602.    * 10-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/20).
    4603. 

  4603.    */
    4604. 

  4604.   inptr = coef_block;
    4605. 

  4605.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    4606. 

  4606.   wsptr = workspace;
    4607. 

  4607.   for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
    4608. 

  4608.     /* Even part */
    4609. 

  4609. 

  4610.     z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    4611. 

  4611.     z3 <<= CONST_BITS;
    4612. 

  4612.     /* Add fudge factor here for final descale. */
    4613. 

  4613.     z3 += ONE << (CONST_BITS-PASS1_BITS-1);
    4614. 

  4614.     z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    4615. 

  4615.     z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
    4616. 

  4616.     z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
    4617. 

  4617.     tmp10 = z3 + z1;
    4618. 

  4618.     tmp11 = z3 - z2;
    4619. 

  4619. 

  4620.     tmp22 = RIGHT_SHIFT(z3 - ((z1 - z2) << 1),   /* c0 = (c4-c8)*2 */
    4621. 

  4621. 			CONST_BITS-PASS1_BITS);
    4622. 

  4622. 

  4623.     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    4624. 

  4624.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    4625. 

  4625. 

  4626.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
    4627. 

  4627.     tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
    4628. 

  4628.     tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
    4629. 

  4629. 

  4630.     tmp20 = tmp10 + tmp12;
    4631. 

  4631.     tmp24 = tmp10 - tmp12;
    4632. 

  4632.     tmp21 = tmp11 + tmp13;
    4633. 

  4633.     tmp23 = tmp11 - tmp13;
    4634. 

  4634. 

  4635.     /* Odd part */
    4636. 

  4636. 

  4637.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    4638. 

  4638.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    4639. 

  4639.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    4640. 

  4640.     z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    4641. 

  4641. 

  4642.     tmp11 = z2 + z4;
    4643. 

  4643.     tmp13 = z2 - z4;
    4644. 

  4644. 

  4645.     tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
    4646. 

  4646.     z5 = z3 << CONST_BITS;
    4647. 

  4647. 

  4648.     z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
    4649. 

  4649.     z4 = z5 + tmp12;
    4650. 

  4650. 

  4651.     tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
    4652. 

  4652.     tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
    4653. 

  4653. 

  4654.     z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
    4655. 

  4655.     z4 = z5 - tmp12 - (tmp13 << (CONST_BITS - 1));
    4656. 

  4656. 

  4657.     tmp12 = (z1 - tmp13 - z3) << PASS1_BITS;
    4658. 

  4658. 

  4659.     tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
    4660. 

  4660.     tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
    4661. 

  4661. 

  4662.     /* Final output stage */
    4663. 

  4663. 

  4664.     wsptr[5*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
    4665. 

  4665.     wsptr[5*9] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
    4666. 

  4666.     wsptr[5*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
    4667. 

  4667.     wsptr[5*8] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
    4668. 

  4668.     wsptr[5*2] = (int) (tmp22 + tmp12);
    4669. 

  4669.     wsptr[5*7] = (int) (tmp22 - tmp12);
    4670. 

  4670.     wsptr[5*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
    4671. 

  4671.     wsptr[5*6] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
    4672. 

  4672.     wsptr[5*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
    4673. 

  4673.     wsptr[5*5] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
    4674. 

  4674.   }
    4675. 

  4675. 

  4676.   /* Pass 2: process 10 rows from work array, store into output array.
    4677. 

  4677.    * 5-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
    4678. 

  4678.    */
    4679. 

  4679.   wsptr = workspace;
    4680. 

  4680.   for (ctr = 0; ctr < 10; ctr++) {
    4681. 

  4681.     outptr = output_buf[ctr] + output_col;
    4682. 

  4682. 

  4683.     /* Even part */
    4684. 

  4684. 

  4685.     /* Add fudge factor here for final descale. */
    4686. 

  4686.     tmp12 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    4687. 

  4687.     tmp12 <<= CONST_BITS;
    4688. 

  4688.     tmp13 = (INT32) wsptr[2];
    4689. 

  4689.     tmp14 = (INT32) wsptr[4];
    4690. 

  4690.     z1 = MULTIPLY(tmp13 + tmp14, FIX(0.790569415)); /* (c2+c4)/2 */
    4691. 

  4691.     z2 = MULTIPLY(tmp13 - tmp14, FIX(0.353553391)); /* (c2-c4)/2 */
    4692. 

  4692.     z3 = tmp12 + z2;
    4693. 

  4693.     tmp10 = z3 + z1;
    4694. 

  4694.     tmp11 = z3 - z1;
    4695. 

  4695.     tmp12 -= z2 << 2;
    4696. 

  4696. 

  4697.     /* Odd part */
    4698. 

  4698. 

  4699.     z2 = (INT32) wsptr[1];
    4700. 

  4700.     z3 = (INT32) wsptr[3];
    4701. 

  4701. 

  4702.     z1 = MULTIPLY(z2 + z3, FIX(0.831253876));       /* c3 */
    4703. 

  4703.     tmp13 = z1 + MULTIPLY(z2, FIX(0.513743148));    /* c1-c3 */
    4704. 

  4704.     tmp14 = z1 - MULTIPLY(z3, FIX(2.176250899));    /* c1+c3 */
    4705. 

  4705. 

  4706.     /* Final output stage */
    4707. 

  4707. 

  4708.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp13,
    4709. 

  4709. 					      CONST_BITS+PASS1_BITS+3)
    4710. 

  4710. 			    & RANGE_MASK];
    4711. 

  4711.     outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp13,
    4712. 

  4712. 					      CONST_BITS+PASS1_BITS+3)
    4713. 

  4713. 			    & RANGE_MASK];
    4714. 

  4714.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp14,
    4715. 

  4715. 					      CONST_BITS+PASS1_BITS+3)
    4716. 

  4716. 			    & RANGE_MASK];
    4717. 

  4717.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp14,
    4718. 

  4718. 					      CONST_BITS+PASS1_BITS+3)
    4719. 

  4719. 			    & RANGE_MASK];
    4720. 

  4720.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12,
    4721. 

  4721. 					      CONST_BITS+PASS1_BITS+3)
    4722. 

  4722. 			    & RANGE_MASK];
    4723. 

  4723. 

  4724.     wsptr += 5;		/* advance pointer to next row */
    4725. 

  4725.   }
    4726. 

  4726. }
    4727. 

  4727. 

  4728. 

  4729. /*
    4730. 

  4730.  * Perform dequantization and inverse DCT on one block of coefficients,
    4731. 

  4731.  * producing a 4x8 output block.
    4732. 

  4732.  *
    4733. 

  4733.  * 8-point IDCT in pass 1 (columns), 4-point in pass 2 (rows).
    4734. 

  4734.  */
    4735. 

  4735. 

  4736. GLOBAL(void)
    4737. 

  4737. jpeg_idct_4x8 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    4738. 

  4738. 	       JCOEFPTR coef_block,
    4739. 

  4739. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    4740. 

  4740. {
    4741. 

  4741.   INT32 tmp0, tmp1, tmp2, tmp3;
    4742. 

  4742.   INT32 tmp10, tmp11, tmp12, tmp13;
    4743. 

  4743.   INT32 z1, z2, z3;
    4744. 

  4744.   JCOEFPTR inptr;
    4745. 

  4745.   ISLOW_MULT_TYPE * quantptr;
    4746. 

  4746.   int * wsptr;
    4747. 

  4747.   JSAMPROW outptr;
    4748. 

  4748.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    4749. 

  4749.   int ctr;
    4750. 

  4750.   int workspace[4*8];	/* buffers data between passes */
    4751. 

  4751.   SHIFT_TEMPS
    4752. 

  4752. 

  4753.   /* Pass 1: process columns from input, store into work array. */
    4754. 

  4754.   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
    4755. 

  4755.   /* furthermore, we scale the results by 2**PASS1_BITS. */
    4756. 

  4756. 

  4757.   inptr = coef_block;
    4758. 

  4758.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    4759. 

  4759.   wsptr = workspace;
    4760. 

  4760.   for (ctr = 4; ctr > 0; ctr--) {
    4761. 

  4761.     /* Due to quantization, we will usually find that many of the input
    4762. 

  4762.      * coefficients are zero, especially the AC terms.  We can exploit this
    4763. 

  4763.      * by short-circuiting the IDCT calculation for any column in which all
    4764. 

  4764.      * the AC terms are zero.  In that case each output is equal to the
    4765. 

  4765.      * DC coefficient (with scale factor as needed).
    4766. 

  4766.      * With typical images and quantization tables, half or more of the
    4767. 

  4767.      * column DCT calculations can be simplified this way.
    4768. 

  4768.      */
    4769. 

  4769. 

  4770.     if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
    4771. 

  4771. 	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
    4772. 

  4772. 	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
    4773. 

  4773. 	inptr[DCTSIZE*7] == 0) {
    4774. 

  4774.       /* AC terms all zero */
    4775. 

  4775.       int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
    4776. 

  4776. 

  4777.       wsptr[4*0] = dcval;
    4778. 

  4778.       wsptr[4*1] = dcval;
    4779. 

  4779.       wsptr[4*2] = dcval;
    4780. 

  4780.       wsptr[4*3] = dcval;
    4781. 

  4781.       wsptr[4*4] = dcval;
    4782. 

  4782.       wsptr[4*5] = dcval;
    4783. 

  4783.       wsptr[4*6] = dcval;
    4784. 

  4784.       wsptr[4*7] = dcval;
    4785. 

  4785. 

  4786.       inptr++;			/* advance pointers to next column */
    4787. 

  4787.       quantptr++;
    4788. 

  4788.       wsptr++;
    4789. 

  4789.       continue;
    4790. 

  4790.     }
    4791. 

  4791. 

  4792.     /* Even part: reverse the even part of the forward DCT. */
    4793. 

  4793.     /* The rotator is sqrt(2)*c(-6). */
    4794. 

  4794. 

  4795.     z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    4796. 

  4796.     z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
    4797. 

  4797.     
    4798. 

  4798.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
    4799. 

  4799.     tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);
    4800. 

  4800.     tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);
    4801. 

  4801.     
    4802. 

  4802.     z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    4803. 

  4803.     z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    4804. 

  4804.     z2 <<= CONST_BITS;
    4805. 

  4805.     z3 <<= CONST_BITS;
    4806. 

  4806.     /* Add fudge factor here for final descale. */
    4807. 

  4807.     z2 += ONE << (CONST_BITS-PASS1_BITS-1);
    4808. 

  4808. 

  4809.     tmp0 = z2 + z3;
    4810. 

  4810.     tmp1 = z2 - z3;
    4811. 

  4811.     
    4812. 

  4812.     tmp10 = tmp0 + tmp2;
    4813. 

  4813.     tmp13 = tmp0 - tmp2;
    4814. 

  4814.     tmp11 = tmp1 + tmp3;
    4815. 

  4815.     tmp12 = tmp1 - tmp3;
    4816. 

  4816. 

  4817.     /* Odd part per figure 8; the matrix is unitary and hence its
    4818. 

  4818.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
    4819. 

  4819.      */
    4820. 

  4820. 

  4821.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
    4822. 

  4822.     tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    4823. 

  4823.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    4824. 

  4824.     tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    4825. 

  4825. 

  4826.     z2 = tmp0 + tmp2;
    4827. 

  4827.     z3 = tmp1 + tmp3;
    4828. 

  4828. 

  4829.     z1 = MULTIPLY(z2 + z3, FIX_1_175875602); /* sqrt(2) * c3 */
    4830. 

  4830.     z2 = MULTIPLY(z2, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
    4831. 

  4831.     z3 = MULTIPLY(z3, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
    4832. 

  4832.     z2 += z1;
    4833. 

  4833.     z3 += z1;
    4834. 

  4834. 

  4835.     z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
    4836. 

  4836.     tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
    4837. 

  4837.     tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
    4838. 

  4838.     tmp0 += z1 + z2;
    4839. 

  4839.     tmp3 += z1 + z3;
    4840. 

  4840. 

  4841.     z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
    4842. 

  4842.     tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
    4843. 

  4843.     tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
    4844. 

  4844.     tmp1 += z1 + z3;
    4845. 

  4845.     tmp2 += z1 + z2;
    4846. 

  4846. 

  4847.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
    4848. 

  4848. 

  4849.     wsptr[4*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
    4850. 

  4850.     wsptr[4*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
    4851. 

  4851.     wsptr[4*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
    4852. 

  4852.     wsptr[4*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
    4853. 

  4853.     wsptr[4*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
    4854. 

  4854.     wsptr[4*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
    4855. 

  4855.     wsptr[4*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
    4856. 

  4856.     wsptr[4*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
    4857. 

  4857. 

  4858.     inptr++;			/* advance pointers to next column */
    4859. 

  4859.     quantptr++;
    4860. 

  4860.     wsptr++;
    4861. 

  4861.   }
    4862. 

  4862. 

  4863.   /* Pass 2: process 8 rows from work array, store into output array.
    4864. 

  4864.    * 4-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
    4865. 

  4865.    */
    4866. 

  4866.   wsptr = workspace;
    4867. 

  4867.   for (ctr = 0; ctr < 8; ctr++) {
    4868. 

  4868.     outptr = output_buf[ctr] + output_col;
    4869. 

  4869. 

  4870.     /* Even part */
    4871. 

  4871. 

  4872.     /* Add fudge factor here for final descale. */
    4873. 

  4873.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    4874. 

  4874.     tmp2 = (INT32) wsptr[2];
    4875. 

  4875. 

  4876.     tmp10 = (tmp0 + tmp2) << CONST_BITS;
    4877. 

  4877.     tmp12 = (tmp0 - tmp2) << CONST_BITS;
    4878. 

  4878. 

  4879.     /* Odd part */
    4880. 

  4880.     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
    4881. 

  4881. 

  4882.     z2 = (INT32) wsptr[1];
    4883. 

  4883.     z3 = (INT32) wsptr[3];
    4884. 

  4884. 

  4885.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
    4886. 

  4886.     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
    4887. 

  4887.     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
    4888. 

  4888. 

  4889.     /* Final output stage */
    4890. 

  4890. 

  4891.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    4892. 

  4892. 					      CONST_BITS+PASS1_BITS+3)
    4893. 

  4893. 			    & RANGE_MASK];
    4894. 

  4894.     outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    4895. 

  4895. 					      CONST_BITS+PASS1_BITS+3)
    4896. 

  4896. 			    & RANGE_MASK];
    4897. 

  4897.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
    4898. 

  4898. 					      CONST_BITS+PASS1_BITS+3)
    4899. 

  4899. 			    & RANGE_MASK];
    4900. 

  4900.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
    4901. 

  4901. 					      CONST_BITS+PASS1_BITS+3)
    4902. 

  4902. 			    & RANGE_MASK];
    4903. 

  4903.     
    4904. 

  4904.     wsptr += 4;		/* advance pointer to next row */
    4905. 

  4905.   }
    4906. 

  4906. }
    4907. 

  4907. 

  4908. 

  4909. /*
    4910. 

  4910.  * Perform dequantization and inverse DCT on one block of coefficients,
    4911. 

  4911.  * producing a reduced-size 3x6 output block.
    4912. 

  4912.  *
    4913. 

  4913.  * 6-point IDCT in pass 1 (columns), 3-point in pass 2 (rows).
    4914. 

  4914.  */
    4915. 

  4915. 

  4916. GLOBAL(void)
    4917. 

  4917. jpeg_idct_3x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    4918. 

  4918. 	       JCOEFPTR coef_block,
    4919. 

  4919. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    4920. 

  4920. {
    4921. 

  4921.   INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
    4922. 

  4922.   INT32 z1, z2, z3;
    4923. 

  4923.   JCOEFPTR inptr;
    4924. 

  4924.   ISLOW_MULT_TYPE * quantptr;
    4925. 

  4925.   int * wsptr;
    4926. 

  4926.   JSAMPROW outptr;
    4927. 

  4927.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    4928. 

  4928.   int ctr;
    4929. 

  4929.   int workspace[3*6];	/* buffers data between passes */
    4930. 

  4930.   SHIFT_TEMPS
    4931. 

  4931. 

  4932.   /* Pass 1: process columns from input, store into work array.
    4933. 

  4933.    * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
    4934. 

  4934.    */
    4935. 

  4935.   inptr = coef_block;
    4936. 

  4936.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    4937. 

  4937.   wsptr = workspace;
    4938. 

  4938.   for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
    4939. 

  4939.     /* Even part */
    4940. 

  4940. 

  4941.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    4942. 

  4942.     tmp0 <<= CONST_BITS;
    4943. 

  4943.     /* Add fudge factor here for final descale. */
    4944. 

  4944.     tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
    4945. 

  4945.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
    4946. 

  4946.     tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
    4947. 

  4947.     tmp1 = tmp0 + tmp10;
    4948. 

  4948.     tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS-PASS1_BITS);
    4949. 

  4949.     tmp10 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    4950. 

  4950.     tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
    4951. 

  4951.     tmp10 = tmp1 + tmp0;
    4952. 

  4952.     tmp12 = tmp1 - tmp0;
    4953. 

  4953. 

  4954.     /* Odd part */
    4955. 

  4955. 

  4956.     z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    4957. 

  4957.     z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    4958. 

  4958.     z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
    4959. 

  4959.     tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
    4960. 

  4960.     tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
    4961. 

  4961.     tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
    4962. 

  4962.     tmp1 = (z1 - z2 - z3) << PASS1_BITS;
    4963. 

  4963. 

  4964.     /* Final output stage */
    4965. 

  4965. 

  4966.     wsptr[3*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
    4967. 

  4967.     wsptr[3*5] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
    4968. 

  4968.     wsptr[3*1] = (int) (tmp11 + tmp1);
    4969. 

  4969.     wsptr[3*4] = (int) (tmp11 - tmp1);
    4970. 

  4970.     wsptr[3*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
    4971. 

  4971.     wsptr[3*3] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
    4972. 

  4972.   }
    4973. 

  4973. 

  4974.   /* Pass 2: process 6 rows from work array, store into output array.
    4975. 

  4975.    * 3-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
    4976. 

  4976.    */
    4977. 

  4977.   wsptr = workspace;
    4978. 

  4978.   for (ctr = 0; ctr < 6; ctr++) {
    4979. 

  4979.     outptr = output_buf[ctr] + output_col;
    4980. 

  4980. 

  4981.     /* Even part */
    4982. 

  4982. 

  4983.     /* Add fudge factor here for final descale. */
    4984. 

  4984.     tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
    4985. 

  4985.     tmp0 <<= CONST_BITS;
    4986. 

  4986.     tmp2 = (INT32) wsptr[2];
    4987. 

  4987.     tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
    4988. 

  4988.     tmp10 = tmp0 + tmp12;
    4989. 

  4989.     tmp2 = tmp0 - tmp12 - tmp12;
    4990. 

  4990. 

  4991.     /* Odd part */
    4992. 

  4992. 

  4993.     tmp12 = (INT32) wsptr[1];
    4994. 

  4994.     tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
    4995. 

  4995. 

  4996.     /* Final output stage */
    4997. 

  4997. 

  4998.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
    4999. 

  4999. 					      CONST_BITS+PASS1_BITS+3)
    5000. 

  5000. 			    & RANGE_MASK];
    5001. 

  5001.     outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
    5002. 

  5002. 					      CONST_BITS+PASS1_BITS+3)
    5003. 

  5003. 			    & RANGE_MASK];
    5004. 

  5004.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2,
    5005. 

  5005. 					      CONST_BITS+PASS1_BITS+3)
    5006. 

  5006. 			    & RANGE_MASK];
    5007. 

  5007. 

  5008.     wsptr += 3;		/* advance pointer to next row */
    5009. 

  5009.   }
    5010. 

  5010. }
    5011. 

  5011. 

  5012. 

  5013. /*
    5014. 

  5014.  * Perform dequantization and inverse DCT on one block of coefficients,
    5015. 

  5015.  * producing a 2x4 output block.
    5016. 

  5016.  *
    5017. 

  5017.  * 4-point IDCT in pass 1 (columns), 2-point in pass 2 (rows).
    5018. 

  5018.  */
    5019. 

  5019. 

  5020. GLOBAL(void)
    5021. 

  5021. jpeg_idct_2x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    5022. 

  5022. 	       JCOEFPTR coef_block,
    5023. 

  5023. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    5024. 

  5024. {
    5025. 

  5025.   INT32 tmp0, tmp2, tmp10, tmp12;
    5026. 

  5026.   INT32 z1, z2, z3;
    5027. 

  5027.   JCOEFPTR inptr;
    5028. 

  5028.   ISLOW_MULT_TYPE * quantptr;
    5029. 

  5029.   INT32 * wsptr;
    5030. 

  5030.   JSAMPROW outptr;
    5031. 

  5031.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    5032. 

  5032.   int ctr;
    5033. 

  5033.   INT32 workspace[2*4];	/* buffers data between passes */
    5034. 

  5034.   SHIFT_TEMPS
    5035. 

  5035. 

  5036.   /* Pass 1: process columns from input, store into work array.
    5037. 

  5037.    * 4-point IDCT kernel,
    5038. 

  5038.    * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
    5039. 

  5039.    */
    5040. 

  5040.   inptr = coef_block;
    5041. 

  5041.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    5042. 

  5042.   wsptr = workspace;
    5043. 

  5043.   for (ctr = 0; ctr < 2; ctr++, inptr++, quantptr++, wsptr++) {
    5044. 

  5044.     /* Even part */
    5045. 

  5045. 

  5046.     tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
    5047. 

  5047.     tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
    5048. 

  5048. 

  5049.     tmp10 = (tmp0 + tmp2) << CONST_BITS;
    5050. 

  5050.     tmp12 = (tmp0 - tmp2) << CONST_BITS;
    5051. 

  5051. 

  5052.     /* Odd part */
    5053. 

  5053.     /* Same rotation as in the even part of the 8x8 LL&M IDCT */
    5054. 

  5054. 

  5055.     z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
    5056. 

  5056.     z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
    5057. 

  5057. 

  5058.     z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
    5059. 

  5059.     tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
    5060. 

  5060.     tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
    5061. 

  5061. 

  5062.     /* Final output stage */
    5063. 

  5063. 

  5064.     wsptr[2*0] = tmp10 + tmp0;
    5065. 

  5065.     wsptr[2*3] = tmp10 - tmp0;
    5066. 

  5066.     wsptr[2*1] = tmp12 + tmp2;
    5067. 

  5067.     wsptr[2*2] = tmp12 - tmp2;
    5068. 

  5068.   }
    5069. 

  5069. 

  5070.   /* Pass 2: process 4 rows from work array, store into output array. */
    5071. 

  5071. 

  5072.   wsptr = workspace;
    5073. 

  5073.   for (ctr = 0; ctr < 4; ctr++) {
    5074. 

  5074.     outptr = output_buf[ctr] + output_col;
    5075. 

  5075. 

  5076.     /* Even part */
    5077. 

  5077. 

  5078.     /* Add fudge factor here for final descale. */
    5079. 

  5079.     tmp10 = wsptr[0] + (ONE << (CONST_BITS+2));
    5080. 

  5080. 

  5081.     /* Odd part */
    5082. 

  5082. 

  5083.     tmp0 = wsptr[1];
    5084. 

  5084. 

  5085.     /* Final output stage */
    5086. 

  5086. 

  5087.     outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS+3)
    5088. 

  5088. 			    & RANGE_MASK];
    5089. 

  5089.     outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS+3)
    5090. 

  5090. 			    & RANGE_MASK];
    5091. 

  5091. 

  5092.     wsptr += 2;		/* advance pointer to next row */
    5093. 

  5093.   }
    5094. 

  5094. }
    5095. 

  5095. 

  5096. 

  5097. /*
    5098. 

  5098.  * Perform dequantization and inverse DCT on one block of coefficients,
    5099. 

  5099.  * producing a 1x2 output block.
    5100. 

  5100.  *
    5101. 

  5101.  * 2-point IDCT in pass 1 (columns), 1-point in pass 2 (rows).
    5102. 

  5102.  */
    5103. 

  5103. 

  5104. GLOBAL(void)
    5105. 

  5105. jpeg_idct_1x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
    5106. 

  5106. 	       JCOEFPTR coef_block,
    5107. 

  5107. 	       JSAMPARRAY output_buf, JDIMENSION output_col)
    5108. 

  5108. {
    5109. 

  5109.   INT32 tmp0, tmp10;
    5110. 

  5110.   ISLOW_MULT_TYPE * quantptr;
    5111. 

  5111.   JSAMPLE *range_limit = IDCT_range_limit(cinfo);
    5112. 

  5112.   SHIFT_TEMPS
    5113. 

  5113. 

  5114.   /* Process 1 column from input, store into output array. */
    5115. 

  5115. 

  5116.   quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
    5117. 

  5117. 

  5118.   /* Even part */
    5119. 

  5119.     
    5120. 

  5120.   tmp10 = DEQUANTIZE(coef_block[DCTSIZE*0], quantptr[DCTSIZE*0]);
    5121. 

  5121.   /* Add fudge factor here for final descale. */
    5122. 

  5122.   tmp10 += ONE << 2;
    5123. 

  5123. 

  5124.   /* Odd part */
    5125. 

  5125. 

  5126.   tmp0 = DEQUANTIZE(coef_block[DCTSIZE*1], quantptr[DCTSIZE*1]);
    5127. 

  5127. 

  5128.   /* Final output stage */
    5129. 

  5129. 

  5130.   output_buf[0][output_col] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0, 3)
    5131. 

  5131. 					  & RANGE_MASK];
    5132. 

  5132.   output_buf[1][output_col] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0, 3)
    5133. 

  5133. 					  & RANGE_MASK];
    5134. 

  5134. }
    5135. 

  5135. 

  5136. #endif /* IDCT_SCALING_SUPPORTED */
    5137. 

  5137. #endif /* DCT_ISLOW_SUPPORTED */
    5138. 

  5138.