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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
jrevdct.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：33k
源码类别：

Audio

开发平台：

Visual C++

jrevdct.c：源码内容
  1. /*
  2.  * jrevdct.c
  3.  *
  4.  * Copyright (C) 1991, 1992, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file contains the basic inverse-DCT transformation subroutine.
  9.  *
  10.  * This implementation is based on an algorithm described in
  11.  *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
  12.  *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
  13.  *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
  14.  * The primary algorithm described there uses 11 multiplies and 29 adds.
  15.  * We use their alternate method with 12 multiplies and 32 adds.
  16.  * The advantage of this method is that no data path contains more than one
  17.  * multiplication; this allows a very simple and accurate implementation in
  18.  * scaled fixed-point arithmetic, with a minimal number of shifts.
  19.  * 
  20.  * I've made lots of modifications to attempt to take advantage of the
  21.  * sparse nature of the DCT matrices we're getting.  Although the logic
  22.  * is cumbersome, it's straightforward and the resulting code is much
  23.  * faster.
  24.  *
  25.  * A better way to do this would be to pass in the DCT block as a sparse
  26.  * matrix, perhaps with the difference cases encoded.
  27.  */
  28.  
  29. /**
  30.  * @file jrevdct.c
  31.  * Independent JPEG Group's LLM idct.
  32.  */
  33.  
  34. #include "common.h"
  35. #include "dsputil.h"
  37. #define EIGHT_BIT_SAMPLES
  39. #define DCTSIZE 8
  40. #define DCTSIZE2 64
  42. #define GLOBAL
  44. #define RIGHT_SHIFT(x, n) ((x) >> (n))
  46. typedef DCTELEM DCTBLOCK[DCTSIZE2];
  48. #define CONST_BITS 13
  50. /*
  51.  * This routine is specialized to the case DCTSIZE = 8.
  52.  */
  54. #if DCTSIZE != 8
  55.   Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
  56. #endif
  59. /*
  60.  * A 2-D IDCT can be done by 1-D IDCT on each row followed by 1-D IDCT
  61.  * on each column.  Direct algorithms are also available, but they are
  62.  * much more complex and seem not to be any faster when reduced to code.
  63.  *
  64.  * The poop on this scaling stuff is as follows:
  65.  *
  66.  * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
  67.  * larger than the true IDCT outputs.  The final outputs are therefore
  68.  * a factor of N larger than desired; since N=8 this can be cured by
  69.  * a simple right shift at the end of the algorithm.  The advantage of
  70.  * this arrangement is that we save two multiplications per 1-D IDCT,
  71.  * because the y0 and y4 inputs need not be divided by sqrt(N).
  72.  *
  73.  * We have to do addition and subtraction of the integer inputs, which
  74.  * is no problem, and multiplication by fractional constants, which is
  75.  * a problem to do in integer arithmetic.  We multiply all the constants
  76.  * by CONST_SCALE and convert them to integer constants (thus retaining
  77.  * CONST_BITS bits of precision in the constants).  After doing a
  78.  * multiplication we have to divide the product by CONST_SCALE, with proper
  79.  * rounding, to produce the correct output.  This division can be done
  80.  * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
  81.  * as long as possible so that partial sums can be added together with
  82.  * full fractional precision.
  83.  *
  84.  * The outputs of the first pass are scaled up by PASS1_BITS bits so that
  85.  * they are represented to better-than-integral precision.  These outputs
  86.  * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
  87.  * with the recommended scaling.  (To scale up 12-bit sample data further, an
  88.  * intermediate int32 array would be needed.)
  89.  *
  90.  * To avoid overflow of the 32-bit intermediate results in pass 2, we must
  91.  * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
  92.  * shows that the values given below are the most effective.
  93.  */
  95. #ifdef EIGHT_BIT_SAMPLES
  96. #define PASS1_BITS  2
  97. #else
  98. #define PASS1_BITS  1 /* lose a little precision to avoid overflow */
  99. #endif
  101. #define ONE ((int32_t) 1)
  103. #define CONST_SCALE (ONE << CONST_BITS)
  105. /* Convert a positive real constant to an integer scaled by CONST_SCALE.
  106.  * IMPORTANT: if your compiler doesn't do this arithmetic at compile time,
  107.  * you will pay a significant penalty in run time.  In that case, figure
  108.  * the correct integer constant values and insert them by hand.
  109.  */
  111. /* Actually FIX is no longer used, we precomputed them all */
  112. #define FIX(x) ((int32_t) ((x) * CONST_SCALE + 0.5)) 
  114. /* Descale and correctly round an int32_t value that's scaled by N bits.
  115.  * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
  116.  * the fudge factor is correct for either sign of X.
  117.  */
  119. #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
  121. /* Multiply an int32_t variable by an int32_t constant to yield an int32_t result.
  122.  * For 8-bit samples with the recommended scaling, all the variable
  123.  * and constant values involved are no more than 16 bits wide, so a
  124.  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply;
  125.  * this provides a useful speedup on many machines.
  126.  * There is no way to specify a 16x16->32 multiply in portable C, but
  127.  * some C compilers will do the right thing if you provide the correct
  128.  * combination of casts.
  129.  * NB: for 12-bit samples, a full 32-bit multiplication will be needed.
  130.  */
  132. #ifdef EIGHT_BIT_SAMPLES
  133. #ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */
  134. #define MULTIPLY(var,const)  (((int16_t) (var)) * ((int16_t) (const)))
  135. #endif
  136. #ifdef SHORTxLCONST_32 /* known to work with Microsoft C 6.0 */
  137. #define MULTIPLY(var,const)  (((int16_t) (var)) * ((int32_t) (const)))
  138. #endif
  139. #endif
  141. #ifndef MULTIPLY /* default definition */
  142. #define MULTIPLY(var,const)  ((var) * (const))
  143. #endif
  146. /* 
  147.   Unlike our decoder where we approximate the FIXes, we need to use exact
  148. ones here or successive P-frames will drift too much with Reference frame coding 
  149. */
  150. #define FIX_0_211164243 1730
  151. #define FIX_0_275899380 2260
  152. #define FIX_0_298631336 2446
  153. #define FIX_0_390180644 3196
  154. #define FIX_0_509795579 4176
  155. #define FIX_0_541196100 4433
  156. #define FIX_0_601344887 4926
  157. #define FIX_0_765366865 6270
  158. #define FIX_0_785694958 6436
  159. #define FIX_0_899976223 7373
  160. #define FIX_1_061594337 8697
  161. #define FIX_1_111140466 9102
  162. #define FIX_1_175875602 9633
  163. #define FIX_1_306562965 10703
  164. #define FIX_1_387039845 11363
  165. #define FIX_1_451774981 11893
  166. #define FIX_1_501321110 12299
  167. #define FIX_1_662939225 13623
  168. #define FIX_1_847759065 15137
  169. #define FIX_1_961570560 16069
  170. #define FIX_2_053119869 16819
  171. #define FIX_2_172734803 17799
  172. #define FIX_2_562915447 20995
  173. #define FIX_3_072711026 25172
  175. /*
  176.  * Perform the inverse DCT on one block of coefficients.
  177.  */
  179. void j_rev_dct(DCTBLOCK data)
  180. {
  181.   int32_t tmp0, tmp1, tmp2, tmp3;
  182.   int32_t tmp10, tmp11, tmp12, tmp13;
  183.   int32_t z1, z2, z3, z4, z5;
  184.   int32_t d0, d1, d2, d3, d4, d5, d6, d7;
  185.   register DCTELEM *dataptr;
  186.   int rowctr;
  187.    
  188.   /* Pass 1: process rows. */
  189.   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
  190.   /* furthermore, we scale the results by 2**PASS1_BITS. */
  192.   dataptr = data;
  194.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
  195.     /* Due to quantization, we will usually find that many of the input
  196.      * coefficients are zero, especially the AC terms.  We can exploit this
  197.      * by short-circuiting the IDCT calculation for any row in which all
  198.      * the AC terms are zero.  In that case each output is equal to the
  199.      * DC coefficient (with scale factor as needed).
  200.      * With typical images and quantization tables, half or more of the
  201.      * row DCT calculations can be simplified this way.
  202.      */
  204.     register int *idataptr = (int*)dataptr;
  206.     /* WARNING: we do the same permutation as MMX idct to simplify the
  207.        video core */
  208.     d0 = dataptr[0];
  209.     d2 = dataptr[1];
  210.     d4 = dataptr[2];
  211.     d6 = dataptr[3];
  212.     d1 = dataptr[4];
  213.     d3 = dataptr[5];
  214.     d5 = dataptr[6];
  215.     d7 = dataptr[7];
  217.     if ((d1 | d2 | d3 | d4 | d5 | d6 | d7) == 0) {
  218.       /* AC terms all zero */
  219.       if (d0) {
  220.   /* Compute a 32 bit value to assign. */
  221.   DCTELEM dcval = (DCTELEM) (d0 << PASS1_BITS);
  222.   register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
  223.   
  224.   idataptr[0] = v;
  225.   idataptr[1] = v;
  226.   idataptr[2] = v;
  227.   idataptr[3] = v;
  228.       }
  229.       
  230.       dataptr += DCTSIZE; /* advance pointer to next row */
  231.       continue;
  232.     }
  234.     /* Even part: reverse the even part of the forward DCT. */
  235.     /* The rotator is sqrt(2)*c(-6). */
  236. {
  237.     if (d6) {
  238. if (d4) {
  239.     if (d2) {
  240. if (d0) {
  241.     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  242.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  243.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  244.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  246.     tmp0 = (d0 + d4) << CONST_BITS;
  247.     tmp1 = (d0 - d4) << CONST_BITS;
  249.     tmp10 = tmp0 + tmp3;
  250.     tmp13 = tmp0 - tmp3;
  251.     tmp11 = tmp1 + tmp2;
  252.     tmp12 = tmp1 - tmp2;
  253. } else {
  254.     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  255.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  256.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  257.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  259.     tmp0 = d4 << CONST_BITS;
  261.     tmp10 = tmp0 + tmp3;
  262.     tmp13 = tmp0 - tmp3;
  263.     tmp11 = tmp2 - tmp0;
  264.     tmp12 = -(tmp0 + tmp2);
  265. }
  266.     } else {
  267. if (d0) {
  268.     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  269.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  270.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  272.     tmp0 = (d0 + d4) << CONST_BITS;
  273.     tmp1 = (d0 - d4) << CONST_BITS;
  275.     tmp10 = tmp0 + tmp3;
  276.     tmp13 = tmp0 - tmp3;
  277.     tmp11 = tmp1 + tmp2;
  278.     tmp12 = tmp1 - tmp2;
  279. } else {
  280.     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  281.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  282.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  284.     tmp0 = d4 << CONST_BITS;
  286.     tmp10 = tmp0 + tmp3;
  287.     tmp13 = tmp0 - tmp3;
  288.     tmp11 = tmp2 - tmp0;
  289.     tmp12 = -(tmp0 + tmp2);
  290. }
  291.     }
  292. } else {
  293.     if (d2) {
  294. if (d0) {
  295.     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  296.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  297.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  298.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  300.     tmp0 = d0 << CONST_BITS;
  302.     tmp10 = tmp0 + tmp3;
  303.     tmp13 = tmp0 - tmp3;
  304.     tmp11 = tmp0 + tmp2;
  305.     tmp12 = tmp0 - tmp2;
  306. } else {
  307.     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  308.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  309.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  310.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  312.     tmp10 = tmp3;
  313.     tmp13 = -tmp3;
  314.     tmp11 = tmp2;
  315.     tmp12 = -tmp2;
  316. }
  317.     } else {
  318. if (d0) {
  319.     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  320.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  321.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  323.     tmp0 = d0 << CONST_BITS;
  325.     tmp10 = tmp0 + tmp3;
  326.     tmp13 = tmp0 - tmp3;
  327.     tmp11 = tmp0 + tmp2;
  328.     tmp12 = tmp0 - tmp2;
  329. } else {
  330.     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  331.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  332.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  334.     tmp10 = tmp3;
  335.     tmp13 = -tmp3;
  336.     tmp11 = tmp2;
  337.     tmp12 = -tmp2;
  338. }
  339.     }
  340. }
  341.     } else {
  342. if (d4) {
  343.     if (d2) {
  344. if (d0) {
  345.     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  346.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  347.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  349.     tmp0 = (d0 + d4) << CONST_BITS;
  350.     tmp1 = (d0 - d4) << CONST_BITS;
  352.     tmp10 = tmp0 + tmp3;
  353.     tmp13 = tmp0 - tmp3;
  354.     tmp11 = tmp1 + tmp2;
  355.     tmp12 = tmp1 - tmp2;
  356. } else {
  357.     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  358.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  359.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  361.     tmp0 = d4 << CONST_BITS;
  363.     tmp10 = tmp0 + tmp3;
  364.     tmp13 = tmp0 - tmp3;
  365.     tmp11 = tmp2 - tmp0;
  366.     tmp12 = -(tmp0 + tmp2);
  367. }
  368.     } else {
  369. if (d0) {
  370.     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  371.     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  372.     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  373. } else {
  374.     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  375.     tmp10 = tmp13 = d4 << CONST_BITS;
  376.     tmp11 = tmp12 = -tmp10;
  377. }
  378.     }
  379. } else {
  380.     if (d2) {
  381. if (d0) {
  382.     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  383.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  384.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  386.     tmp0 = d0 << CONST_BITS;
  388.     tmp10 = tmp0 + tmp3;
  389.     tmp13 = tmp0 - tmp3;
  390.     tmp11 = tmp0 + tmp2;
  391.     tmp12 = tmp0 - tmp2;
  392. } else {
  393.     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  394.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  395.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  397.     tmp10 = tmp3;
  398.     tmp13 = -tmp3;
  399.     tmp11 = tmp2;
  400.     tmp12 = -tmp2;
  401. }
  402.     } else {
  403. if (d0) {
  404.     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  405.     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  406. } else {
  407.     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  408.     tmp10 = tmp13 = tmp11 = tmp12 = 0;
  409. }
  410.     }
  411. }
  412.       }
  414.     /* Odd part per figure 8; the matrix is unitary and hence its
  415.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  416.      */
  418.     if (d7) {
  419. if (d5) {
  420.     if (d3) {
  421. if (d1) {
  422.     /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  423.     z1 = d7 + d1;
  424.     z2 = d5 + d3;
  425.     z3 = d7 + d3;
  426.     z4 = d5 + d1;
  427.     z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
  428.     
  429.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  430.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  431.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  432.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  433.     z1 = MULTIPLY(-z1, FIX_0_899976223);
  434.     z2 = MULTIPLY(-z2, FIX_2_562915447);
  435.     z3 = MULTIPLY(-z3, FIX_1_961570560);
  436.     z4 = MULTIPLY(-z4, FIX_0_390180644);
  437.     
  438.     z3 += z5;
  439.     z4 += z5;
  440.     
  441.     tmp0 += z1 + z3;
  442.     tmp1 += z2 + z4;
  443.     tmp2 += z2 + z3;
  444.     tmp3 += z1 + z4;
  445. } else {
  446.     /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  447.     z2 = d5 + d3;
  448.     z3 = d7 + d3;
  449.     z5 = MULTIPLY(z3 + d5, FIX_1_175875602);
  450.     
  451.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  452.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  453.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  454.     z1 = MULTIPLY(-d7, FIX_0_899976223);
  455.     z2 = MULTIPLY(-z2, FIX_2_562915447);
  456.     z3 = MULTIPLY(-z3, FIX_1_961570560);
  457.     z4 = MULTIPLY(-d5, FIX_0_390180644);
  458.     
  459.     z3 += z5;
  460.     z4 += z5;
  461.     
  462.     tmp0 += z1 + z3;
  463.     tmp1 += z2 + z4;
  464.     tmp2 += z2 + z3;
  465.     tmp3 = z1 + z4;
  466. }
  467.     } else {
  468. if (d1) {
  469.     /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  470.     z1 = d7 + d1;
  471.     z4 = d5 + d1;
  472.     z5 = MULTIPLY(d7 + z4, FIX_1_175875602);
  473.     
  474.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  475.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  476.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  477.     z1 = MULTIPLY(-z1, FIX_0_899976223);
  478.     z2 = MULTIPLY(-d5, FIX_2_562915447);
  479.     z3 = MULTIPLY(-d7, FIX_1_961570560);
  480.     z4 = MULTIPLY(-z4, FIX_0_390180644);
  481.     
  482.     z3 += z5;
  483.     z4 += z5;
  484.     
  485.     tmp0 += z1 + z3;
  486.     tmp1 += z2 + z4;
  487.     tmp2 = z2 + z3;
  488.     tmp3 += z1 + z4;
  489. } else {
  490.     /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  491.     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
  492.     z1 = MULTIPLY(-d7, FIX_0_899976223);
  493.     z3 = MULTIPLY(-d7, FIX_1_961570560);
  494.     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
  495.     z2 = MULTIPLY(-d5, FIX_2_562915447);
  496.     z4 = MULTIPLY(-d5, FIX_0_390180644);
  497.     z5 = MULTIPLY(d5 + d7, FIX_1_175875602);
  498.     
  499.     z3 += z5;
  500.     z4 += z5;
  501.     
  502.     tmp0 += z3;
  503.     tmp1 += z4;
  504.     tmp2 = z2 + z3;
  505.     tmp3 = z1 + z4;
  506. }
  507.     }
  508. } else {
  509.     if (d3) {
  510. if (d1) {
  511.     /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
  512.     z1 = d7 + d1;
  513.     z3 = d7 + d3;
  514.     z5 = MULTIPLY(z3 + d1, FIX_1_175875602);
  515.     
  516.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  517.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  518.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  519.     z1 = MULTIPLY(-z1, FIX_0_899976223);
  520.     z2 = MULTIPLY(-d3, FIX_2_562915447);
  521.     z3 = MULTIPLY(-z3, FIX_1_961570560);
  522.     z4 = MULTIPLY(-d1, FIX_0_390180644);
  523.     
  524.     z3 += z5;
  525.     z4 += z5;
  526.     
  527.     tmp0 += z1 + z3;
  528.     tmp1 = z2 + z4;
  529.     tmp2 += z2 + z3;
  530.     tmp3 += z1 + z4;
  531. } else {
  532.     /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  533.     z3 = d7 + d3;
  534.     
  535.     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
  536.     z1 = MULTIPLY(-d7, FIX_0_899976223);
  537.     tmp2 = MULTIPLY(d3, FIX_0_509795579);
  538.     z2 = MULTIPLY(-d3, FIX_2_562915447);
  539.     z5 = MULTIPLY(z3, FIX_1_175875602);
  540.     z3 = MULTIPLY(-z3, FIX_0_785694958);
  541.     
  542.     tmp0 += z3;
  543.     tmp1 = z2 + z5;
  544.     tmp2 += z3;
  545.     tmp3 = z1 + z5;
  546. }
  547.     } else {
  548. if (d1) {
  549.     /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  550.     z1 = d7 + d1;
  551.     z5 = MULTIPLY(z1, FIX_1_175875602);
  553.     z1 = MULTIPLY(z1, FIX_0_275899380);
  554.     z3 = MULTIPLY(-d7, FIX_1_961570560);
  555.     tmp0 = MULTIPLY(-d7, FIX_1_662939225); 
  556.     z4 = MULTIPLY(-d1, FIX_0_390180644);
  557.     tmp3 = MULTIPLY(d1, FIX_1_111140466);
  559.     tmp0 += z1;
  560.     tmp1 = z4 + z5;
  561.     tmp2 = z3 + z5;
  562.     tmp3 += z1;
  563. } else {
  564.     /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  565.     tmp0 = MULTIPLY(-d7, FIX_1_387039845);
  566.     tmp1 = MULTIPLY(d7, FIX_1_175875602);
  567.     tmp2 = MULTIPLY(-d7, FIX_0_785694958);
  568.     tmp3 = MULTIPLY(d7, FIX_0_275899380);
  569. }
  570.     }
  571. }
  572.     } else {
  573. if (d5) {
  574.     if (d3) {
  575. if (d1) {
  576.     /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  577.     z2 = d5 + d3;
  578.     z4 = d5 + d1;
  579.     z5 = MULTIPLY(d3 + z4, FIX_1_175875602);
  580.     
  581.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  582.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  583.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  584.     z1 = MULTIPLY(-d1, FIX_0_899976223);
  585.     z2 = MULTIPLY(-z2, FIX_2_562915447);
  586.     z3 = MULTIPLY(-d3, FIX_1_961570560);
  587.     z4 = MULTIPLY(-z4, FIX_0_390180644);
  588.     
  589.     z3 += z5;
  590.     z4 += z5;
  591.     
  592.     tmp0 = z1 + z3;
  593.     tmp1 += z2 + z4;
  594.     tmp2 += z2 + z3;
  595.     tmp3 += z1 + z4;
  596. } else {
  597.     /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  598.     z2 = d5 + d3;
  599.     
  600.     z5 = MULTIPLY(z2, FIX_1_175875602);
  601.     tmp1 = MULTIPLY(d5, FIX_1_662939225);
  602.     z4 = MULTIPLY(-d5, FIX_0_390180644);
  603.     z2 = MULTIPLY(-z2, FIX_1_387039845);
  604.     tmp2 = MULTIPLY(d3, FIX_1_111140466);
  605.     z3 = MULTIPLY(-d3, FIX_1_961570560);
  606.     
  607.     tmp0 = z3 + z5;
  608.     tmp1 += z2;
  609.     tmp2 += z2;
  610.     tmp3 = z4 + z5;
  611. }
  612.     } else {
  613. if (d1) {
  614.     /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  615.     z4 = d5 + d1;
  616.     
  617.     z5 = MULTIPLY(z4, FIX_1_175875602);
  618.     z1 = MULTIPLY(-d1, FIX_0_899976223);
  619.     tmp3 = MULTIPLY(d1, FIX_0_601344887);
  620.     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
  621.     z2 = MULTIPLY(-d5, FIX_2_562915447);
  622.     z4 = MULTIPLY(z4, FIX_0_785694958);
  623.     
  624.     tmp0 = z1 + z5;
  625.     tmp1 += z4;
  626.     tmp2 = z2 + z5;
  627.     tmp3 += z4;
  628. } else {
  629.     /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  630.     tmp0 = MULTIPLY(d5, FIX_1_175875602);
  631.     tmp1 = MULTIPLY(d5, FIX_0_275899380);
  632.     tmp2 = MULTIPLY(-d5, FIX_1_387039845);
  633.     tmp3 = MULTIPLY(d5, FIX_0_785694958);
  634. }
  635.     }
  636. } else {
  637.     if (d3) {
  638. if (d1) {
  639.     /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  640.     z5 = d1 + d3;
  641.     tmp3 = MULTIPLY(d1, FIX_0_211164243);
  642.     tmp2 = MULTIPLY(-d3, FIX_1_451774981);
  643.     z1 = MULTIPLY(d1, FIX_1_061594337);
  644.     z2 = MULTIPLY(-d3, FIX_2_172734803);
  645.     z4 = MULTIPLY(z5, FIX_0_785694958);
  646.     z5 = MULTIPLY(z5, FIX_1_175875602);
  647.     
  648.     tmp0 = z1 - z4;
  649.     tmp1 = z2 + z4;
  650.     tmp2 += z5;
  651.     tmp3 += z5;
  652. } else {
  653.     /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  654.     tmp0 = MULTIPLY(-d3, FIX_0_785694958);
  655.     tmp1 = MULTIPLY(-d3, FIX_1_387039845);
  656.     tmp2 = MULTIPLY(-d3, FIX_0_275899380);
  657.     tmp3 = MULTIPLY(d3, FIX_1_175875602);
  658. }
  659.     } else {
  660. if (d1) {
  661.     /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  662.     tmp0 = MULTIPLY(d1, FIX_0_275899380);
  663.     tmp1 = MULTIPLY(d1, FIX_0_785694958);
  664.     tmp2 = MULTIPLY(d1, FIX_1_175875602);
  665.     tmp3 = MULTIPLY(d1, FIX_1_387039845);
  666. } else {
  667.     /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  668.     tmp0 = tmp1 = tmp2 = tmp3 = 0;
  669. }
  670.     }
  671. }
  672.     }
  673. }
  674.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  676.     dataptr[0] = (DCTELEM) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
  677.     dataptr[7] = (DCTELEM) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
  678.     dataptr[1] = (DCTELEM) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
  679.     dataptr[6] = (DCTELEM) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
  680.     dataptr[2] = (DCTELEM) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
  681.     dataptr[5] = (DCTELEM) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
  682.     dataptr[3] = (DCTELEM) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
  683.     dataptr[4] = (DCTELEM) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
  685.     dataptr += DCTSIZE; /* advance pointer to next row */
  686.   }
  688.   /* Pass 2: process columns. */
  689.   /* Note that we must descale the results by a factor of 8 == 2**3, */
  690.   /* and also undo the PASS1_BITS scaling. */
  692.   dataptr = data;
  693.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
  694.     /* Columns of zeroes can be exploited in the same way as we did with rows.
  695.      * However, the row calculation has created many nonzero AC terms, so the
  696.      * simplification applies less often (typically 5% to 10% of the time).
  697.      * On machines with very fast multiplication, it's possible that the
  698.      * test takes more time than it's worth.  In that case this section
  699.      * may be commented out.
  700.      */
  702.     d0 = dataptr[DCTSIZE*0];
  703.     d1 = dataptr[DCTSIZE*1];
  704.     d2 = dataptr[DCTSIZE*2];
  705.     d3 = dataptr[DCTSIZE*3];
  706.     d4 = dataptr[DCTSIZE*4];
  707.     d5 = dataptr[DCTSIZE*5];
  708.     d6 = dataptr[DCTSIZE*6];
  709.     d7 = dataptr[DCTSIZE*7];
  711.     /* Even part: reverse the even part of the forward DCT. */
  712.     /* The rotator is sqrt(2)*c(-6). */
  713.     if (d6) {
  714. if (d4) {
  715.     if (d2) {
  716. if (d0) {
  717.     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  718.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  719.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  720.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  722.     tmp0 = (d0 + d4) << CONST_BITS;
  723.     tmp1 = (d0 - d4) << CONST_BITS;
  725.     tmp10 = tmp0 + tmp3;
  726.     tmp13 = tmp0 - tmp3;
  727.     tmp11 = tmp1 + tmp2;
  728.     tmp12 = tmp1 - tmp2;
  729. } else {
  730.     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  731.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  732.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  733.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  735.     tmp0 = d4 << CONST_BITS;
  737.     tmp10 = tmp0 + tmp3;
  738.     tmp13 = tmp0 - tmp3;
  739.     tmp11 = tmp2 - tmp0;
  740.     tmp12 = -(tmp0 + tmp2);
  741. }
  742.     } else {
  743. if (d0) {
  744.     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  745.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  746.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  748.     tmp0 = (d0 + d4) << CONST_BITS;
  749.     tmp1 = (d0 - d4) << CONST_BITS;
  751.     tmp10 = tmp0 + tmp3;
  752.     tmp13 = tmp0 - tmp3;
  753.     tmp11 = tmp1 + tmp2;
  754.     tmp12 = tmp1 - tmp2;
  755. } else {
  756.     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  757.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  758.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  760.     tmp0 = d4 << CONST_BITS;
  762.     tmp10 = tmp0 + tmp3;
  763.     tmp13 = tmp0 - tmp3;
  764.     tmp11 = tmp2 - tmp0;
  765.     tmp12 = -(tmp0 + tmp2);
  766. }
  767.     }
  768. } else {
  769.     if (d2) {
  770. if (d0) {
  771.     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  772.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  773.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  774.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  776.     tmp0 = d0 << CONST_BITS;
  778.     tmp10 = tmp0 + tmp3;
  779.     tmp13 = tmp0 - tmp3;
  780.     tmp11 = tmp0 + tmp2;
  781.     tmp12 = tmp0 - tmp2;
  782. } else {
  783.     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  784.     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
  785.     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
  786.     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
  788.     tmp10 = tmp3;
  789.     tmp13 = -tmp3;
  790.     tmp11 = tmp2;
  791.     tmp12 = -tmp2;
  792. }
  793.     } else {
  794. if (d0) {
  795.     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  796.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  797.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  799.     tmp0 = d0 << CONST_BITS;
  801.     tmp10 = tmp0 + tmp3;
  802.     tmp13 = tmp0 - tmp3;
  803.     tmp11 = tmp0 + tmp2;
  804.     tmp12 = tmp0 - tmp2;
  805. } else {
  806.     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  807.     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
  808.     tmp3 = MULTIPLY(d6, FIX_0_541196100);
  810.     tmp10 = tmp3;
  811.     tmp13 = -tmp3;
  812.     tmp11 = tmp2;
  813.     tmp12 = -tmp2;
  814. }
  815.     }
  816. }
  817.     } else {
  818. if (d4) {
  819.     if (d2) {
  820. if (d0) {
  821.     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  822.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  823.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  825.     tmp0 = (d0 + d4) << CONST_BITS;
  826.     tmp1 = (d0 - d4) << CONST_BITS;
  828.     tmp10 = tmp0 + tmp3;
  829.     tmp13 = tmp0 - tmp3;
  830.     tmp11 = tmp1 + tmp2;
  831.     tmp12 = tmp1 - tmp2;
  832. } else {
  833.     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  834.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  835.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  837.     tmp0 = d4 << CONST_BITS;
  839.     tmp10 = tmp0 + tmp3;
  840.     tmp13 = tmp0 - tmp3;
  841.     tmp11 = tmp2 - tmp0;
  842.     tmp12 = -(tmp0 + tmp2);
  843. }
  844.     } else {
  845. if (d0) {
  846.     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  847.     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  848.     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  849. } else {
  850.     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  851.     tmp10 = tmp13 = d4 << CONST_BITS;
  852.     tmp11 = tmp12 = -tmp10;
  853. }
  854.     }
  855. } else {
  856.     if (d2) {
  857. if (d0) {
  858.     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  859.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  860.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  862.     tmp0 = d0 << CONST_BITS;
  864.     tmp10 = tmp0 + tmp3;
  865.     tmp13 = tmp0 - tmp3;
  866.     tmp11 = tmp0 + tmp2;
  867.     tmp12 = tmp0 - tmp2;
  868. } else {
  869.     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  870.     tmp2 = MULTIPLY(d2, FIX_0_541196100);
  871.     tmp3 = MULTIPLY(d2, FIX_1_306562965);
  873.     tmp10 = tmp3;
  874.     tmp13 = -tmp3;
  875.     tmp11 = tmp2;
  876.     tmp12 = -tmp2;
  877. }
  878.     } else {
  879. if (d0) {
  880.     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  881.     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  882. } else {
  883.     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  884.     tmp10 = tmp13 = tmp11 = tmp12 = 0;
  885. }
  886.     }
  887. }
  888.     }
  890.     /* Odd part per figure 8; the matrix is unitary and hence its
  891.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  892.      */
  893.     if (d7) {
  894. if (d5) {
  895.     if (d3) {
  896. if (d1) {
  897.     /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  898.     z1 = d7 + d1;
  899.     z2 = d5 + d3;
  900.     z3 = d7 + d3;
  901.     z4 = d5 + d1;
  902.     z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
  903.     
  904.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  905.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  906.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  907.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  908.     z1 = MULTIPLY(-z1, FIX_0_899976223);
  909.     z2 = MULTIPLY(-z2, FIX_2_562915447);
  910.     z3 = MULTIPLY(-z3, FIX_1_961570560);
  911.     z4 = MULTIPLY(-z4, FIX_0_390180644);
  912.     
  913.     z3 += z5;
  914.     z4 += z5;
  915.     
  916.     tmp0 += z1 + z3;
  917.     tmp1 += z2 + z4;
  918.     tmp2 += z2 + z3;
  919.     tmp3 += z1 + z4;
  920. } else {
  921.     /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  922.     z1 = d7;
  923.     z2 = d5 + d3;
  924.     z3 = d7 + d3;
  925.     z5 = MULTIPLY(z3 + d5, FIX_1_175875602);
  926.     
  927.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  928.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  929.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  930.     z1 = MULTIPLY(-d7, FIX_0_899976223);
  931.     z2 = MULTIPLY(-z2, FIX_2_562915447);
  932.     z3 = MULTIPLY(-z3, FIX_1_961570560);
  933.     z4 = MULTIPLY(-d5, FIX_0_390180644);
  934.     
  935.     z3 += z5;
  936.     z4 += z5;
  937.     
  938.     tmp0 += z1 + z3;
  939.     tmp1 += z2 + z4;
  940.     tmp2 += z2 + z3;
  941.     tmp3 = z1 + z4;
  942. }
  943.     } else {
  944. if (d1) {
  945.     /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  946.     z1 = d7 + d1;
  947.     z2 = d5;
  948.     z3 = d7;
  949.     z4 = d5 + d1;
  950.     z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
  951.     
  952.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  953.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  954.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  955.     z1 = MULTIPLY(-z1, FIX_0_899976223);
  956.     z2 = MULTIPLY(-d5, FIX_2_562915447);
  957.     z3 = MULTIPLY(-d7, FIX_1_961570560);
  958.     z4 = MULTIPLY(-z4, FIX_0_390180644);
  959.     
  960.     z3 += z5;
  961.     z4 += z5;
  962.     
  963.     tmp0 += z1 + z3;
  964.     tmp1 += z2 + z4;
  965.     tmp2 = z2 + z3;
  966.     tmp3 += z1 + z4;
  967. } else {
  968.     /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  969.     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
  970.     z1 = MULTIPLY(-d7, FIX_0_899976223);
  971.     z3 = MULTIPLY(-d7, FIX_1_961570560);
  972.     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
  973.     z2 = MULTIPLY(-d5, FIX_2_562915447);
  974.     z4 = MULTIPLY(-d5, FIX_0_390180644);
  975.     z5 = MULTIPLY(d5 + d7, FIX_1_175875602);
  976.     
  977.     z3 += z5;
  978.     z4 += z5;
  979.     
  980.     tmp0 += z3;
  981.     tmp1 += z4;
  982.     tmp2 = z2 + z3;
  983.     tmp3 = z1 + z4;
  984. }
  985.     }
  986. } else {
  987.     if (d3) {
  988. if (d1) {
  989.     /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
  990.     z1 = d7 + d1;
  991.     z3 = d7 + d3;
  992.     z5 = MULTIPLY(z3 + d1, FIX_1_175875602);
  993.     
  994.     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
  995.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  996.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  997.     z1 = MULTIPLY(-z1, FIX_0_899976223);
  998.     z2 = MULTIPLY(-d3, FIX_2_562915447);
  999.     z3 = MULTIPLY(-z3, FIX_1_961570560);
  1000.     z4 = MULTIPLY(-d1, FIX_0_390180644);
  1001.     
  1002.     z3 += z5;
  1003.     z4 += z5;
  1004.     
  1005.     tmp0 += z1 + z3;
  1006.     tmp1 = z2 + z4;
  1007.     tmp2 += z2 + z3;
  1008.     tmp3 += z1 + z4;
  1009. } else {
  1010.     /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  1011.     z3 = d7 + d3;
  1012.     
  1013.     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
  1014.     z1 = MULTIPLY(-d7, FIX_0_899976223);
  1015.     tmp2 = MULTIPLY(d3, FIX_0_509795579);
  1016.     z2 = MULTIPLY(-d3, FIX_2_562915447);
  1017.     z5 = MULTIPLY(z3, FIX_1_175875602);
  1018.     z3 = MULTIPLY(-z3, FIX_0_785694958);
  1019.     
  1020.     tmp0 += z3;
  1021.     tmp1 = z2 + z5;
  1022.     tmp2 += z3;
  1023.     tmp3 = z1 + z5;
  1024. }
  1025.     } else {
  1026. if (d1) {
  1027.     /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  1028.     z1 = d7 + d1;
  1029.     z5 = MULTIPLY(z1, FIX_1_175875602);
  1031.     z1 = MULTIPLY(z1, FIX_0_275899380);
  1032.     z3 = MULTIPLY(-d7, FIX_1_961570560);
  1033.     tmp0 = MULTIPLY(-d7, FIX_1_662939225); 
  1034.     z4 = MULTIPLY(-d1, FIX_0_390180644);
  1035.     tmp3 = MULTIPLY(d1, FIX_1_111140466);
  1037.     tmp0 += z1;
  1038.     tmp1 = z4 + z5;
  1039.     tmp2 = z3 + z5;
  1040.     tmp3 += z1;
  1041. } else {
  1042.     /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  1043.     tmp0 = MULTIPLY(-d7, FIX_1_387039845);
  1044.     tmp1 = MULTIPLY(d7, FIX_1_175875602);
  1045.     tmp2 = MULTIPLY(-d7, FIX_0_785694958);
  1046.     tmp3 = MULTIPLY(d7, FIX_0_275899380);
  1047. }
  1048.     }
  1049. }
  1050.     } else {
  1051. if (d5) {
  1052.     if (d3) {
  1053. if (d1) {
  1054.     /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  1055.     z2 = d5 + d3;
  1056.     z4 = d5 + d1;
  1057.     z5 = MULTIPLY(d3 + z4, FIX_1_175875602);
  1058.     
  1059.     tmp1 = MULTIPLY(d5, FIX_2_053119869);
  1060.     tmp2 = MULTIPLY(d3, FIX_3_072711026);
  1061.     tmp3 = MULTIPLY(d1, FIX_1_501321110);
  1062.     z1 = MULTIPLY(-d1, FIX_0_899976223);
  1063.     z2 = MULTIPLY(-z2, FIX_2_562915447);
  1064.     z3 = MULTIPLY(-d3, FIX_1_961570560);
  1065.     z4 = MULTIPLY(-z4, FIX_0_390180644);
  1066.     
  1067.     z3 += z5;
  1068.     z4 += z5;
  1069.     
  1070.     tmp0 = z1 + z3;
  1071.     tmp1 += z2 + z4;
  1072.     tmp2 += z2 + z3;
  1073.     tmp3 += z1 + z4;
  1074. } else {
  1075.     /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  1076.     z2 = d5 + d3;
  1077.     
  1078.     z5 = MULTIPLY(z2, FIX_1_175875602);
  1079.     tmp1 = MULTIPLY(d5, FIX_1_662939225);
  1080.     z4 = MULTIPLY(-d5, FIX_0_390180644);
  1081.     z2 = MULTIPLY(-z2, FIX_1_387039845);
  1082.     tmp2 = MULTIPLY(d3, FIX_1_111140466);
  1083.     z3 = MULTIPLY(-d3, FIX_1_961570560);
  1084.     
  1085.     tmp0 = z3 + z5;
  1086.     tmp1 += z2;
  1087.     tmp2 += z2;
  1088.     tmp3 = z4 + z5;
  1089. }
  1090.     } else {
  1091. if (d1) {
  1092.     /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  1093.     z4 = d5 + d1;
  1094.     
  1095.     z5 = MULTIPLY(z4, FIX_1_175875602);
  1096.     z1 = MULTIPLY(-d1, FIX_0_899976223);
  1097.     tmp3 = MULTIPLY(d1, FIX_0_601344887);
  1098.     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
  1099.     z2 = MULTIPLY(-d5, FIX_2_562915447);
  1100.     z4 = MULTIPLY(z4, FIX_0_785694958);
  1101.     
  1102.     tmp0 = z1 + z5;
  1103.     tmp1 += z4;
  1104.     tmp2 = z2 + z5;
  1105.     tmp3 += z4;
  1106. } else {
  1107.     /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  1108.     tmp0 = MULTIPLY(d5, FIX_1_175875602);
  1109.     tmp1 = MULTIPLY(d5, FIX_0_275899380);
  1110.     tmp2 = MULTIPLY(-d5, FIX_1_387039845);
  1111.     tmp3 = MULTIPLY(d5, FIX_0_785694958);
  1112. }
  1113.     }
  1114. } else {
  1115.     if (d3) {
  1116. if (d1) {
  1117.     /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  1118.     z5 = d1 + d3;
  1119.     tmp3 = MULTIPLY(d1, FIX_0_211164243);
  1120.     tmp2 = MULTIPLY(-d3, FIX_1_451774981);
  1121.     z1 = MULTIPLY(d1, FIX_1_061594337);
  1122.     z2 = MULTIPLY(-d3, FIX_2_172734803);
  1123.     z4 = MULTIPLY(z5, FIX_0_785694958);
  1124.     z5 = MULTIPLY(z5, FIX_1_175875602);
  1125.     
  1126.     tmp0 = z1 - z4;
  1127.     tmp1 = z2 + z4;
  1128.     tmp2 += z5;
  1129.     tmp3 += z5;
  1130. } else {
  1131.     /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  1132.     tmp0 = MULTIPLY(-d3, FIX_0_785694958);
  1133.     tmp1 = MULTIPLY(-d3, FIX_1_387039845);
  1134.     tmp2 = MULTIPLY(-d3, FIX_0_275899380);
  1135.     tmp3 = MULTIPLY(d3, FIX_1_175875602);
  1136. }
  1137.     } else {
  1138. if (d1) {
  1139.     /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  1140.     tmp0 = MULTIPLY(d1, FIX_0_275899380);
  1141.     tmp1 = MULTIPLY(d1, FIX_0_785694958);
  1142.     tmp2 = MULTIPLY(d1, FIX_1_175875602);
  1143.     tmp3 = MULTIPLY(d1, FIX_1_387039845);
  1144. } else {
  1145.     /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  1146.     tmp0 = tmp1 = tmp2 = tmp3 = 0;
  1147. }
  1148.     }
  1149. }
  1150.     }
  1152.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  1154.     dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp3,
  1155.    CONST_BITS+PASS1_BITS+3);
  1156.     dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp10 - tmp3,
  1157.    CONST_BITS+PASS1_BITS+3);
  1158.     dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp11 + tmp2,
  1159.    CONST_BITS+PASS1_BITS+3);
  1160.     dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(tmp11 - tmp2,
  1161.    CONST_BITS+PASS1_BITS+3);
  1162.     dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(tmp12 + tmp1,
  1163.    CONST_BITS+PASS1_BITS+3);
  1164.     dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12 - tmp1,
  1165.    CONST_BITS+PASS1_BITS+3);
  1166.     dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp13 + tmp0,
  1167.    CONST_BITS+PASS1_BITS+3);
  1168.     dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp13 - tmp0,
  1169.    CONST_BITS+PASS1_BITS+3);
  1170.     
  1171.     dataptr++; /* advance pointer to next column */
  1172.   }
  1173. }
  1175. #undef FIX
  1176. #undef CONST_BITS