home *** CD-ROM | disk | FTP | other *** search
/ Geek 6 / Geek-006.iso / linux / video / xmovie-1.5.3.tar.gz / xmovie-1.5.3.tar / xmovie-1.5.3 / quicktime / revdct.c < prev    next >
C/C++ Source or Header  |  2000-11-29  |  31KB  |  1,198 lines
  1. #include "sizes.h"
  2.  
  3. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  4. #define SHIFT_TEMPS    long shift_temp;
  5. #define RIGHT_SHIFT(x, shft) \
  6.     ((shift_temp = (x)) < 0 ? \
  7.      (shift_temp >> (shft)) | ((~((long) 0)) << (32-(shft))) : \
  8.      (shift_temp >> (shft)))
  9. #else
  10. #define SHIFT_TEMPS
  11. #define RIGHT_SHIFT(x, shft) ((x) >> (shft))
  12. #endif
  13.  
  14. #define MAXJSAMPLE 255
  15. #define RANGE_MASK  (MAXJSAMPLE * 4 + 3)
  16. #define CONST_SCALE (ONE << CONST_BITS)
  17. #define ONE    ((long)1)
  18. #define CONST_BITS 13
  19. #define PASS1_BITS  2
  20. #define DCTSIZE1 8
  21. #define DCTSIZE2 64
  22. #define MULTIPLY(var, const) ((var) * (const))
  23. #define FIX(x)    ((long)((x) * CONST_SCALE + 0.5))
  24. #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n) - 1)), n)
  25.  
  26. int quicktime_rev_dct(QUICKTIME_INT16 *data, unsigned char *outptr, unsigned char *rnglimit)
  27. {
  28.     long tmp0, tmp1, tmp2, tmp3;
  29.     long tmp10, tmp11, tmp12, tmp13;
  30.     long z1, z2, z3, z4, z5;
  31.     long d0, d1, d2, d3, d4, d5, d6, d7;
  32.     register QUICKTIME_INT16 *dataptr;
  33.     int rowctr;
  34.     SHIFT_TEMPS
  35.  
  36. /* Pass 1: process rows. */
  37. /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
  38. /* furthermore, we scale the results by 2**PASS1_BITS. */
  39.  
  40.     dataptr = data;
  41.  
  42.     for(rowctr = DCTSIZE1 - 1; rowctr >= 0; rowctr--) 
  43.     {
  44. /* Due to quantization, we will usually find that many of the input
  45.  * coefficients are zero, especially the AC terms.  We can exploit this
  46.  * by short-circuiting the IDCT calculation for any row in which all
  47.  * the AC terms are zero.  In that case each output is equal to the
  48.  * DC coefficient (with scale factor as needed).
  49.  * With typical images and quantization tables, half or more of the
  50.  * row DCT calculations can be simplified this way.
  51.  */
  52.  
  53.         register int *idataptr = (int*)dataptr;
  54.         d0 = dataptr[0];
  55.         d1 = dataptr[1];
  56.         if((d1 == 0) && (idataptr[1] | idataptr[2] | idataptr[3]) == 0) 
  57.         {
  58. /* AC terms all zero */
  59.             if(d0) 
  60.             {
  61. /* Compute a 32 bit value to assign. */
  62.                 QUICKTIME_INT16 dcval = (QUICKTIME_INT16) (d0 << PASS1_BITS);
  63.                 register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
  64.  
  65.                 idataptr[0] = v;
  66.                 idataptr[1] = v;
  67.                 idataptr[2] = v;
  68.                 idataptr[3] = v;
  69.             }
  70.  
  71. /* advance pointer to next row */
  72.             dataptr += DCTSIZE1;    
  73.             continue;
  74.         }
  75.         d2 = dataptr[2];
  76.         d3 = dataptr[3];
  77.         d4 = dataptr[4];
  78.         d5 = dataptr[5];
  79.         d6 = dataptr[6];
  80.         d7 = dataptr[7];
  81.  
  82.         /* Even part: reverse the even part of the forward DCT. */
  83.         /* The rotator is sqrt(2)*c(-6). */
  84.         if(d6)
  85.         {
  86.             if(d4) 
  87.             {
  88.                 if(d2)
  89.                 {
  90.                     if(d0)
  91.                     {
  92. /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  93.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  94.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  95.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  96.  
  97.                         tmp0 = (d0 + d4) << CONST_BITS;
  98.                         tmp1 = (d0 - d4) << CONST_BITS;
  99.  
  100.                         tmp10 = tmp0 + tmp3;
  101.                         tmp13 = tmp0 - tmp3;
  102.                         tmp11 = tmp1 + tmp2;
  103.                         tmp12 = tmp1 - tmp2;
  104.                     } 
  105.                     else 
  106.                     {
  107. /* d*0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  108.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  109.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  110.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  111.  
  112.                         tmp0 = d4 << CONST_BITS;
  113.  
  114.                         tmp10 = tmp0 + tmp3;
  115.                         tmp13 = tmp0 - tmp3;
  116.                         tmp11 = tmp2 - tmp0;
  117.                         tmp12 = -(tmp0 + tmp2);
  118.                     }
  119.                 } 
  120.                 else 
  121.                 {
  122.                     if(d0) 
  123.                     {
  124. /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  125.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  126.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  127.  
  128.                         tmp0 = (d0 + d4) << CONST_BITS;
  129.                         tmp1 = (d0 - d4) << CONST_BITS;
  130.  
  131.                         tmp10 = tmp0 + tmp3;
  132.                         tmp13 = tmp0 - tmp3;
  133.                         tmp11 = tmp1 + tmp2;
  134.                         tmp12 = tmp1 - tmp2;
  135.                     } 
  136.                     else 
  137.                     {
  138. /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  139.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  140.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  141.  
  142.                         tmp0 = d4 << CONST_BITS;
  143.  
  144.                         tmp10 = tmp0 + tmp3;
  145.                         tmp13 = tmp0 - tmp3;
  146.                         tmp11 = tmp2 - tmp0;
  147.                         tmp12 = -(tmp0 + tmp2);
  148.                     }
  149.                 }
  150.             } 
  151.             else 
  152.             {
  153.                 if (d2) 
  154.                 {
  155.                     if (d0) 
  156.                     {
  157. /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  158.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  159.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  160.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  161.  
  162.                         tmp0 = d0 << CONST_BITS;
  163.  
  164.                         tmp10 = tmp0 + tmp3;
  165.                         tmp13 = tmp0 - tmp3;
  166.                         tmp11 = tmp0 + tmp2;
  167.                         tmp12 = tmp0 - tmp2;
  168.                     } 
  169.                     else 
  170.                     {
  171. /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  172.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  173.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  174.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  175.  
  176.                         tmp10 = tmp3;
  177.                         tmp13 = -tmp3;
  178.                         tmp11 = tmp2;
  179.                         tmp12 = -tmp2;
  180.                     }
  181.                 } 
  182.                 else 
  183.                 {
  184.                     if(d0) 
  185.                     {
  186. /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  187.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  188.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  189.  
  190.                         tmp0 = d0 << CONST_BITS;
  191.  
  192.                         tmp10 = tmp0 + tmp3;
  193.                         tmp13 = tmp0 - tmp3;
  194.                         tmp11 = tmp0 + tmp2;
  195.                         tmp12 = tmp0 - tmp2;
  196.                     } 
  197.                     else 
  198.                     {
  199. /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  200.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  201.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  202.  
  203.                         tmp10 = tmp3;
  204.                         tmp13 = -tmp3;
  205.                         tmp11 = tmp2;
  206.                         tmp12 = -tmp2;
  207.                     }
  208.                 }
  209.             }
  210.         } 
  211.         else 
  212.         {
  213.             if(d4) 
  214.             {
  215.                 if(d2) 
  216.                 {
  217.                     if(d0) 
  218.                     {
  219. /* d*0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  220.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  221.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  222.  
  223.                         tmp0 = (d0 + d4) << CONST_BITS;
  224.                         tmp1 = (d0 - d4) << CONST_BITS;
  225.  
  226.                         tmp10 = tmp0 + tmp3;
  227.                         tmp13 = tmp0 - tmp3;
  228.                         tmp11 = tmp1 + tmp2;
  229.                         tmp12 = tmp1 - tmp2;
  230.                     } 
  231.                     else 
  232.                     {
  233. /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  234.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  235.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  236.  
  237.                         tmp0 = d4 << CONST_BITS;
  238.  
  239.                         tmp10 = tmp0 + tmp3;
  240.                         tmp13 = tmp0 - tmp3;
  241.                         tmp11 = tmp2 - tmp0;
  242.                         tmp12 = -(tmp0 + tmp2);
  243.                     }
  244.                 } 
  245.                 else 
  246.                 {
  247.                     if(d0) 
  248.                     {
  249. /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  250.                         tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  251.                         tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  252.                     } 
  253.                     else 
  254.                     {
  255. /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  256.                         tmp10 = tmp13 = d4 << CONST_BITS;
  257.                         tmp11 = tmp12 = -tmp10;
  258.                     }
  259.                 }
  260.             } 
  261.             else 
  262.             {
  263.                 if(d2) 
  264.                 {
  265.                     if(d0) 
  266.                     {
  267. /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  268.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  269.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  270.  
  271.                         tmp0 = d0 << CONST_BITS;
  272.  
  273.                         tmp10 = tmp0 + tmp3;
  274.                         tmp13 = tmp0 - tmp3;
  275.                         tmp11 = tmp0 + tmp2;
  276.                         tmp12 = tmp0 - tmp2;
  277.                     } 
  278.                     else 
  279.                     {
  280. /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  281.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  282.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  283.  
  284.                         tmp10 = tmp3;
  285.                         tmp13 = -tmp3;
  286.                         tmp11 = tmp2;
  287.                         tmp12 = -tmp2;
  288.                     }
  289.                 } 
  290.                 else 
  291.                 {
  292.                     if(d0) 
  293.                     {
  294. /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  295.                         tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  296.                     } 
  297.                     else 
  298.                     {
  299. /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  300.                         tmp10 = tmp13 = tmp11 = tmp12 = 0;
  301.                     }
  302.                 }
  303.             }
  304.         }
  305.  
  306.  
  307. /* Odd part per figure 8; the matrix is unitary and hence its
  308.  * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  309.  */
  310.  
  311.         if(d7) 
  312.         {
  313.             if(d5) 
  314.             {
  315.                 if(d3) 
  316.                 {
  317.                     if(d1) 
  318.                     {
  319. /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  320.                         z1 = d7 + d1;
  321.                         z2 = d5 + d3;
  322.                         z3 = d7 + d3;
  323.                         z4 = d5 + d1;
  324.                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  325.  
  326.                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  327.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  328.                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
  329.                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
  330.                         z1 = MULTIPLY(z1, -FIX(0.899976223));
  331.                         z2 = MULTIPLY(z2, -FIX(2.562915447));
  332.                         z3 = MULTIPLY(z3, -FIX(1.961570560));
  333.                         z4 = MULTIPLY(z4, -FIX(0.390180644));
  334.  
  335.                         z3 += z5;
  336.                         z4 += z5;
  337.  
  338.                         tmp0 += z1 + z3;
  339.                         tmp1 += z2 + z4;
  340.                         tmp2 += z2 + z3;
  341.                         tmp3 += z1 + z4;
  342.                     }
  343.                     else 
  344.                     {
  345. /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  346.                         z1 = d7;
  347.                         z2 = d5 + d3;
  348.                         z3 = d7 + d3;
  349.                         z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
  350.  
  351.                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  352.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  353.                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
  354.                         z1 = MULTIPLY(d7, -FIX(0.899976223));
  355.                         z2 = MULTIPLY(z2, -FIX(2.562915447));
  356.                         z3 = MULTIPLY(z3, -FIX(1.961570560));
  357.                         z4 = MULTIPLY(d5, -FIX(0.390180644));
  358.  
  359.                         z3 += z5;
  360.                         z4 += z5;
  361.  
  362.                         tmp0 += z1 + z3;
  363.                         tmp1 += z2 + z4;
  364.                         tmp2 += z2 + z3;
  365.                         tmp3 = z1 + z4;
  366.                     }
  367.                 } 
  368.                 else 
  369.                 {
  370.                     if(d1) 
  371.                     {
  372. /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  373.                         z1 = d7 + d1;
  374.                         z2 = d5;
  375.                         z3 = d7;
  376.                         z4 = d5 + d1;
  377.                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  378.  
  379.                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  380.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  381.                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
  382.                         z1 = MULTIPLY(z1, -FIX(0.899976223));
  383.                         z2 = MULTIPLY(d5, -FIX(2.562915447));
  384.                         z3 = MULTIPLY(d7, -FIX(1.961570560));
  385.                         z4 = MULTIPLY(z4, -FIX(0.390180644));
  386.  
  387.                         z3 += z5;
  388.                         z4 += z5;
  389.  
  390.                         tmp0 += z1 + z3;
  391.                         tmp1 += z2 + z4;
  392.                         tmp2 = z2 + z3;
  393.                         tmp3 += z1 + z4;
  394.                     } 
  395.                     else 
  396.                     {
  397. /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  398.                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
  399.                         z1 = MULTIPLY(d7, -FIX(0.899976223));
  400.                         z3 = MULTIPLY(d7, -FIX(1.961570560));
  401.                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
  402.                         z2 = MULTIPLY(d5, -FIX(2.562915447));
  403.                         z4 = MULTIPLY(d5, -FIX(0.390180644));
  404.                         z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
  405.  
  406.                         z3 += z5;
  407.                         z4 += z5;
  408.  
  409.                         tmp0 += z3;
  410.                         tmp1 += z4;
  411.                         tmp2 = z2 + z3;
  412.                         tmp3 = z1 + z4;
  413.                     }
  414.                 }
  415.             } 
  416.             else 
  417.             {
  418.                 if(d3) 
  419.                 {
  420.                     if(d1) 
  421.                     {
  422. /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
  423.                         z1 = d7 + d1;
  424.                         z3 = d7 + d3;
  425.                         z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
  426.  
  427.                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  428.                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
  429.                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
  430.                         z1 = MULTIPLY(z1, -FIX(0.899976223));
  431.                         z2 = MULTIPLY(d3, -FIX(2.562915447));
  432.                         z3 = MULTIPLY(z3, -FIX(1.961570560));
  433.                         z4 = MULTIPLY(d1, -FIX(0.390180644));
  434.  
  435.                         z3 += z5;
  436.                         z4 += z5;
  437.  
  438.                         tmp0 += z1 + z3;
  439.                         tmp1 = z2 + z4;
  440.                         tmp2 += z2 + z3;
  441.                         tmp3 += z1 + z4;
  442.                     } 
  443.                     else 
  444.                     {
  445. /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  446.                         z3 = d7 + d3;
  447.  
  448.                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
  449.                         z1 = MULTIPLY(d7, -FIX(0.899976223));
  450.                         tmp2 = MULTIPLY(d3, FIX(0.509795579));
  451.                         z2 = MULTIPLY(d3, -FIX(2.562915447));
  452.                         z5 = MULTIPLY(z3, FIX(1.175875602));
  453.                         z3 = MULTIPLY(z3, -FIX(0.785694958));
  454.  
  455.                         tmp0 += z3;
  456.                         tmp1 = z2 + z5;
  457.                         tmp2 += z3;
  458.                         tmp3 = z1 + z5;
  459.                     }
  460.                    } 
  461.                 else 
  462.                 {
  463.                     if(d1) 
  464.                     {
  465. /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  466.                         z1 = d7 + d1;
  467.                         z5 = MULTIPLY(z1, FIX(1.175875602));
  468.  
  469.                         z1 = MULTIPLY(z1, FIX(0.275899379));
  470.                         z3 = MULTIPLY(d7, -FIX(1.961570560));
  471.                         tmp0 = MULTIPLY(d7, -FIX(1.662939224)); 
  472.                         z4 = MULTIPLY(d1, -FIX(0.390180644));
  473.                         tmp3 = MULTIPLY(d1, FIX(1.111140466));
  474.  
  475.                         tmp0 += z1;
  476.                         tmp1 = z4 + z5;
  477.                         tmp2 = z3 + z5;
  478.                         tmp3 += z1;
  479.                     } 
  480.                     else 
  481.                     {
  482. /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  483.                         tmp0 = MULTIPLY(d7, -FIX(1.387039845));
  484.                         tmp1 = MULTIPLY(d7, FIX(1.175875602));
  485.                         tmp2 = MULTIPLY(d7, -FIX(0.785694958));
  486.                         tmp3 = MULTIPLY(d7, FIX(0.275899379));
  487.                     }
  488.                 }
  489.             }
  490.         } 
  491.         else 
  492.         {
  493.             if(d5) 
  494.             {
  495.                 if(d3) 
  496.                 {
  497.                     if(d1) 
  498.                     {
  499. /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  500.                         z2 = d5 + d3;
  501.                         z4 = d5 + d1;
  502.                         z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
  503.  
  504.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  505.                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
  506.                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
  507.                         z1 = MULTIPLY(d1, -FIX(0.899976223));
  508.                         z2 = MULTIPLY(z2, -FIX(2.562915447));
  509.                         z3 = MULTIPLY(d3, -FIX(1.961570560));
  510.                         z4 = MULTIPLY(z4, -FIX(0.390180644));
  511.  
  512.                         z3 += z5;
  513.                         z4 += z5;
  514.  
  515.                         tmp0 = z1 + z3;
  516.                         tmp1 += z2 + z4;
  517.                         tmp2 += z2 + z3;
  518.                         tmp3 += z1 + z4;
  519.                     } 
  520.                     else 
  521.                     {
  522. /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  523.                         z2 = d5 + d3;
  524.  
  525.                         z5 = MULTIPLY(z2, FIX(1.175875602));
  526.                         tmp1 = MULTIPLY(d5, FIX(1.662939225));
  527.                         z4 = MULTIPLY(d5, -FIX(0.390180644));
  528.                         z2 = MULTIPLY(z2, -FIX(1.387039845));
  529.                         tmp2 = MULTIPLY(d3, FIX(1.111140466));
  530.                         z3 = MULTIPLY(d3, -FIX(1.961570560));
  531.  
  532.                         tmp0 = z3 + z5;
  533.                         tmp1 += z2;
  534.                         tmp2 += z2;
  535.                         tmp3 = z4 + z5;
  536.                     }
  537.                 } 
  538.                 else 
  539.                 {
  540.                     if(d1) 
  541.                     {
  542. /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  543.                         z4 = d5 + d1;
  544.  
  545.                         z5 = MULTIPLY(z4, FIX(1.175875602));
  546.                         z1 = MULTIPLY(d1, -FIX(0.899976223));
  547.                         tmp3 = MULTIPLY(d1, FIX(0.601344887));
  548.                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
  549.                         z2 = MULTIPLY(d5, -FIX(2.562915447));
  550.                         z4 = MULTIPLY(z4, FIX(0.785694958));
  551.  
  552.                         tmp0 = z1 + z5;
  553.                         tmp1 += z4;
  554.                         tmp2 = z2 + z5;
  555.                         tmp3 += z4;
  556.                     } 
  557.                     else 
  558.                     {
  559. /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  560.                         tmp0 = MULTIPLY(d5, FIX(1.175875602));
  561.                         tmp1 = MULTIPLY(d5, FIX(0.275899380));
  562.                         tmp2 = MULTIPLY(d5, -FIX(1.387039845));
  563.                         tmp3 = MULTIPLY(d5, FIX(0.785694958));
  564.                     }
  565.                 }
  566.             } 
  567.             else 
  568.             {
  569.                 if(d3) 
  570.                 {
  571.                     if(d1) 
  572.                     {
  573. /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  574.                         z5 = d1 + d3;
  575.                         tmp3 = MULTIPLY(d1, FIX(0.211164243));
  576.                         tmp2 = MULTIPLY(d3, -FIX(1.451774981));
  577.                         z1 = MULTIPLY(d1, FIX(1.061594337));
  578.                         z2 = MULTIPLY(d3, -FIX(2.172734803));
  579.                         z4 = MULTIPLY(z5, FIX(0.785694958));
  580.                         z5 = MULTIPLY(z5, FIX(1.175875602));
  581.  
  582.                         tmp0 = z1 - z4;
  583.                         tmp1 = z2 + z4;
  584.                         tmp2 += z5;
  585.                         tmp3 += z5;
  586.                     } 
  587.                     else 
  588.                     {
  589. /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  590.                         tmp0 = MULTIPLY(d3, -FIX(0.785694958));
  591.                         tmp1 = MULTIPLY(d3, -FIX(1.387039845));
  592.                         tmp2 = MULTIPLY(d3, -FIX(0.275899379));
  593.                         tmp3 = MULTIPLY(d3, FIX(1.175875602));
  594.                     }
  595.                 } 
  596.                 else 
  597.                 {
  598.                     if(d1) 
  599.                     {
  600. /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  601.                         tmp0 = MULTIPLY(d1, FIX(0.275899379));
  602.                         tmp1 = MULTIPLY(d1, FIX(0.785694958));
  603.                         tmp2 = MULTIPLY(d1, FIX(1.175875602));
  604.                         tmp3 = MULTIPLY(d1, FIX(1.387039845));
  605.                     } 
  606.                     else 
  607.                     {
  608. /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  609.                         tmp0 = tmp1 = tmp2 = tmp3 = 0;
  610.                     }
  611.                 }
  612.             }
  613.         }
  614.  
  615. /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  616.  
  617.         dataptr[0] = (QUICKTIME_INT16) DESCALE(tmp10 + tmp3, CONST_BITS - PASS1_BITS);
  618.         dataptr[7] = (QUICKTIME_INT16) DESCALE(tmp10 - tmp3, CONST_BITS - PASS1_BITS);
  619.         dataptr[1] = (QUICKTIME_INT16) DESCALE(tmp11 + tmp2, CONST_BITS - PASS1_BITS);
  620.         dataptr[6] = (QUICKTIME_INT16) DESCALE(tmp11 - tmp2, CONST_BITS - PASS1_BITS);
  621.         dataptr[2] = (QUICKTIME_INT16) DESCALE(tmp12 + tmp1, CONST_BITS - PASS1_BITS);
  622.         dataptr[5] = (QUICKTIME_INT16) DESCALE(tmp12 - tmp1, CONST_BITS - PASS1_BITS);
  623.         dataptr[3] = (QUICKTIME_INT16) DESCALE(tmp13 + tmp0, CONST_BITS - PASS1_BITS);
  624.         dataptr[4] = (QUICKTIME_INT16) DESCALE(tmp13 - tmp0, CONST_BITS - PASS1_BITS);
  625.  
  626.         dataptr += DCTSIZE1;        /* advance pointer to next row */
  627.     }
  628.  
  629. /* Pass 2: process columns. */
  630. /* Note that we must descale the results by a factor of 8 == 2**3, */
  631. /* and also undo the PASS1_BITS scaling. */
  632.  
  633.     dataptr = data;
  634.     for(rowctr = DCTSIZE1 - 1; rowctr >= 0; rowctr--) 
  635.     {
  636. /* Columns of zeroes can be exploited in the same way as we did with rows.
  637.  * However, the row calculation has created many nonzero AC terms, so the
  638.  * simplification applies less often (typically 5% to 10% of the time).
  639.  * On machines with very fast multiplication, it's possible that the
  640.  * test takes more time than it's worth.  In that case this section
  641.  * may be commented out.
  642.  */
  643.  
  644.         d0 = dataptr[DCTSIZE1 * 0];
  645.         d1 = dataptr[DCTSIZE1 * 1];
  646.         d2 = dataptr[DCTSIZE1 * 2];
  647.         d3 = dataptr[DCTSIZE1 * 3];
  648.         d4 = dataptr[DCTSIZE1 * 4];
  649.         d5 = dataptr[DCTSIZE1 * 5];
  650.         d6 = dataptr[DCTSIZE1 * 6];
  651.         d7 = dataptr[DCTSIZE1 * 7];
  652.  
  653. /* Even part: reverse the even part of the forward DCT. */
  654. /* The rotator is sqrt(2)*c(-6). */
  655.         if(d6) 
  656.         {
  657.             if(d4) 
  658.             {
  659.                 if(d2) 
  660.                 {
  661.                     if(d0) 
  662.                     {
  663. /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  664.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  665.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  666.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  667.  
  668.                         tmp0 = (d0 + d4) << CONST_BITS;
  669.                         tmp1 = (d0 - d4) << CONST_BITS;
  670.  
  671.                         tmp10 = tmp0 + tmp3;
  672.                         tmp13 = tmp0 - tmp3;
  673.                         tmp11 = tmp1 + tmp2;
  674.                         tmp12 = tmp1 - tmp2;
  675.                     } else {
  676. /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  677.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  678.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  679.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  680.  
  681.                         tmp0 = d4 << CONST_BITS;
  682.  
  683.                         tmp10 = tmp0 + tmp3;
  684.                         tmp13 = tmp0 - tmp3;
  685.                         tmp11 = tmp2 - tmp0;
  686.                         tmp12 = -(tmp0 + tmp2);
  687.                     }
  688.                 } 
  689.                 else 
  690.                 {
  691.                     if(d0) 
  692.                     {
  693. /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  694.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  695.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  696.  
  697.                         tmp0 = (d0 + d4) << CONST_BITS;
  698.                         tmp1 = (d0 - d4) << CONST_BITS;
  699.  
  700.                         tmp10 = tmp0 + tmp3;
  701.                         tmp13 = tmp0 - tmp3;
  702.                         tmp11 = tmp1 + tmp2;
  703.                         tmp12 = tmp1 - tmp2;
  704.                     } 
  705.                     else 
  706.                     {
  707. /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  708.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  709.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  710.  
  711.                         tmp0 = d4 << CONST_BITS;
  712.  
  713.                         tmp10 = tmp0 + tmp3;
  714.                         tmp13 = tmp0 - tmp3;
  715.                         tmp11 = tmp2 - tmp0;
  716.                         tmp12 = -(tmp0 + tmp2);
  717.                     }
  718.                 }
  719.             } 
  720.             else 
  721.             {
  722.                 if(d2) 
  723.                 {
  724.                     if(d0) 
  725.                     {
  726. /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  727.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  728.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  729.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  730.  
  731.                         tmp0 = d0 << CONST_BITS;
  732.  
  733.                         tmp10 = tmp0 + tmp3;
  734.                         tmp13 = tmp0 - tmp3;
  735.                         tmp11 = tmp0 + tmp2;
  736.                         tmp12 = tmp0 - tmp2;
  737.                     } 
  738.                     else 
  739.                     {
  740. /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  741.                         z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  742.                         tmp2 = z1 + MULTIPLY(d6, -FIX(1.847759065));
  743.                         tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  744.  
  745.                         tmp10 = tmp3;
  746.                         tmp13 = -tmp3;
  747.                         tmp11 = tmp2;
  748.                         tmp12 = -tmp2;
  749.                     }
  750.                 } 
  751.                 else 
  752.                 {
  753.                     if(d0) 
  754.                     {
  755. /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  756.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  757.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  758.  
  759.                         tmp0 = d0 << CONST_BITS;
  760.  
  761.                         tmp10 = tmp0 + tmp3;
  762.                         tmp13 = tmp0 - tmp3;
  763.                         tmp11 = tmp0 + tmp2;
  764.                         tmp12 = tmp0 - tmp2;
  765.                     } 
  766.                     else 
  767.                     {
  768. /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  769.                         tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  770.                         tmp3 = MULTIPLY(d6, FIX(0.541196100));
  771.  
  772.                         tmp10 = tmp3;
  773.                         tmp13 = -tmp3;
  774.                         tmp11 = tmp2;
  775.                         tmp12 = -tmp2;
  776.                     }
  777.                 }
  778.             }
  779.         } 
  780.         else 
  781.         {
  782.             if(d4) 
  783.             {
  784.                 if(d2) 
  785.                 {
  786.                     if(d0) 
  787.                     {
  788. /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  789.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  790.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  791.  
  792.                         tmp0 = (d0 + d4) << CONST_BITS;
  793.                         tmp1 = (d0 - d4) << CONST_BITS;
  794.  
  795.                         tmp10 = tmp0 + tmp3;
  796.                         tmp13 = tmp0 - tmp3;
  797.                         tmp11 = tmp1 + tmp2;
  798.                         tmp12 = tmp1 - tmp2;
  799.                     } 
  800.                     else 
  801.                     {
  802. /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  803.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  804.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  805.  
  806.                         tmp0 = d4 << CONST_BITS;
  807.  
  808.                         tmp10 = tmp0 + tmp3;
  809.                         tmp13 = tmp0 - tmp3;
  810.                         tmp11 = tmp2 - tmp0;
  811.                         tmp12 = -(tmp0 + tmp2);
  812.                     }
  813.                 } 
  814.                 else 
  815.                 {
  816.                     if(d0) 
  817.                     {
  818. /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  819.                         tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  820.                         tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  821.                     }
  822.                     else 
  823.                     {
  824. /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  825.                         tmp10 = tmp13 = d4 << CONST_BITS;
  826.                         tmp11 = tmp12 = -tmp10;
  827.                     }
  828.                 }
  829.             } 
  830.             else 
  831.             {
  832.                 if(d2) 
  833.                 {
  834.                     if(d0) 
  835.                     {
  836. /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  837.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  838.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  839.  
  840.                         tmp0 = d0 << CONST_BITS;
  841.  
  842.                         tmp10 = tmp0 + tmp3;
  843.                         tmp13 = tmp0 - tmp3;
  844.                         tmp11 = tmp0 + tmp2;
  845.                         tmp12 = tmp0 - tmp2;
  846.                     } 
  847.                     else 
  848.                     {
  849. /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  850.                         tmp2 = MULTIPLY(d2, FIX(0.541196100));
  851.                         tmp3 = MULTIPLY(d2, FIX(1.306562965));
  852.  
  853.                         tmp10 = tmp3;
  854.                         tmp13 = -tmp3;
  855.                         tmp11 = tmp2;
  856.                         tmp12 = -tmp2;
  857.                     }
  858.                 } 
  859.                 else 
  860.                 {
  861.                     if(d0) 
  862.                     {
  863. /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  864.                         tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  865.                     } 
  866.                     else 
  867.                     {
  868. /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  869.                         tmp10 = tmp13 = tmp11 = tmp12 = 0;
  870.                     }
  871.                 }
  872.             }
  873.         }
  874.  
  875. /* Odd part per figure 8; the matrix is unitary and hence its
  876.  * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  877.  */
  878.         if(d7) 
  879.         {
  880.             if(d5) 
  881.             {
  882.                 if(d3) 
  883.                 {
  884.                     if(d1) 
  885.                     {
  886. /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  887.                         z1 = d7 + d1;
  888.                         z2 = d5 + d3;
  889.                         z3 = d7 + d3;
  890.                         z4 = d5 + d1;
  891.                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  892.  
  893.                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  894.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  895.                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
  896.                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
  897.                         z1 = MULTIPLY(z1, -FIX(0.899976223));
  898.                         z2 = MULTIPLY(z2, -FIX(2.562915447));
  899.                         z3 = MULTIPLY(z3, -FIX(1.961570560));
  900.                         z4 = MULTIPLY(z4, -FIX(0.390180644));
  901.  
  902.                         z3 += z5;
  903.                         z4 += z5;
  904.  
  905.                         tmp0 += z1 + z3;
  906.                         tmp1 += z2 + z4;
  907.                         tmp2 += z2 + z3;
  908.                         tmp3 += z1 + z4;
  909.                     } 
  910.                     else 
  911.                     {
  912. /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  913.                         z1 = d7;
  914.                         z2 = d5 + d3;
  915.                         z3 = d7 + d3;
  916.                         z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
  917.  
  918.                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  919.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  920.                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
  921.                         z1 = MULTIPLY(d7, -FIX(0.899976223));
  922.                         z2 = MULTIPLY(z2, -FIX(2.562915447));
  923.                         z3 = MULTIPLY(z3, -FIX(1.961570560));
  924.                         z4 = MULTIPLY(d5, -FIX(0.390180644));
  925.  
  926.                         z3 += z5;
  927.                         z4 += z5;
  928.  
  929.                         tmp0 += z1 + z3;
  930.                         tmp1 += z2 + z4;
  931.                         tmp2 += z2 + z3;
  932.                         tmp3 = z1 + z4;
  933.                     }
  934.                 } 
  935.                 else 
  936.                 {
  937.                     if(d1) 
  938.                     {
  939. /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  940.                         z1 = d7 + d1;
  941.                         z2 = d5;
  942.                         z3 = d7;
  943.                         z4 = d5 + d1;
  944.                         z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  945.  
  946.                         tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  947.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  948.                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
  949.                         z1 = MULTIPLY(z1, -FIX(0.899976223));
  950.                         z2 = MULTIPLY(d5, -FIX(2.562915447));
  951.                         z3 = MULTIPLY(d7, -FIX(1.961570560));
  952.                         z4 = MULTIPLY(z4, -FIX(0.390180644));
  953.  
  954.                         z3 += z5;
  955.                         z4 += z5;
  956.  
  957.                         tmp0 += z1 + z3;
  958.                         tmp1 += z2 + z4;
  959.                         tmp2 = z2 + z3;
  960.                         tmp3 += z1 + z4;
  961.                     } 
  962.                     else 
  963.                     {
  964. /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  965.                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
  966.                         z1 = MULTIPLY(d7, -FIX(0.899976223));
  967.                         z3 = MULTIPLY(d7, -FIX(1.961570560));
  968.                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
  969.                         z2 = MULTIPLY(d5, -FIX(2.562915447));
  970.                         z4 = MULTIPLY(d5, -FIX(0.390180644));
  971.                         z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
  972.  
  973.                         z3 += z5;
  974.                         z4 += z5;
  975.  
  976.                         tmp0 += z3;
  977.                         tmp1 += z4;
  978.                         tmp2 = z2 + z3;
  979.                         tmp3 = z1 + z4;
  980.                     }
  981.                 }
  982.             } 
  983.             else 
  984.             {
  985.                 if(d3) 
  986.                 {
  987.                     if(d1) 
  988.                     {
  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.                     }
  1010.                     else 
  1011.                     {
  1012. /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  1013.                         z3 = d7 + d3;
  1014.  
  1015.                         tmp0 = MULTIPLY(d7, -FIX(0.601344887)); 
  1016.                         z1 = MULTIPLY(d7, -FIX(0.899976223));
  1017.                         tmp2 = MULTIPLY(d3, FIX(0.509795579));
  1018.                         z2 = MULTIPLY(d3, -FIX(2.562915447));
  1019.                         z5 = MULTIPLY(z3, FIX(1.175875602));
  1020.                         z3 = MULTIPLY(z3, -FIX(0.785694958));
  1021.  
  1022.                         tmp0 += z3;
  1023.                         tmp1 = z2 + z5;
  1024.                         tmp2 += z3;
  1025.                         tmp3 = z1 + z5;
  1026.                     }
  1027.                 } 
  1028.                 else 
  1029.                 {
  1030.                     if(d1) 
  1031.                     {
  1032. /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  1033.                         z1 = d7 + d1;
  1034.                         z5 = MULTIPLY(z1, FIX(1.175875602));
  1035.  
  1036.                         z1 = MULTIPLY(z1, FIX(0.275899379));
  1037.                         z3 = MULTIPLY(d7, -FIX(1.961570560));
  1038.                         tmp0 = MULTIPLY(d7, -FIX(1.662939224)); 
  1039.                         z4 = MULTIPLY(d1, -FIX(0.390180644));
  1040.                         tmp3 = MULTIPLY(d1, FIX(1.111140466));
  1041.  
  1042.                         tmp0 += z1;
  1043.                         tmp1 = z4 + z5;
  1044.                         tmp2 = z3 + z5;
  1045.                         tmp3 += z1;
  1046.                     } 
  1047.                     else 
  1048.                     {
  1049. /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  1050.                         tmp0 = MULTIPLY(d7, -FIX(1.387039845));
  1051.                         tmp1 = MULTIPLY(d7, FIX(1.175875602));
  1052.                         tmp2 = MULTIPLY(d7, -FIX(0.785694958));
  1053.                         tmp3 = MULTIPLY(d7, FIX(0.275899379));
  1054.                     }
  1055.                 }
  1056.             }
  1057.         } 
  1058.         else 
  1059.         {
  1060.             if(d5)
  1061.             {
  1062.                 if(d3) 
  1063.                 {
  1064.                     if(d1) 
  1065.                     {
  1066. /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  1067.                         z2 = d5 + d3;
  1068.                         z4 = d5 + d1;
  1069.                         z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
  1070.  
  1071.                         tmp1 = MULTIPLY(d5, FIX(2.053119869));
  1072.                         tmp2 = MULTIPLY(d3, FIX(3.072711026));
  1073.                         tmp3 = MULTIPLY(d1, FIX(1.501321110));
  1074.                         z1 = MULTIPLY(d1, -FIX(0.899976223));
  1075.                         z2 = MULTIPLY(z2, -FIX(2.562915447));
  1076.                         z3 = MULTIPLY(d3, -FIX(1.961570560));
  1077.                         z4 = MULTIPLY(z4, -FIX(0.390180644));
  1078.  
  1079.                         z3 += z5;
  1080.                         z4 += z5;
  1081.  
  1082.                         tmp0 = z1 + z3;
  1083.                         tmp1 += z2 + z4;
  1084.                         tmp2 += z2 + z3;
  1085.                         tmp3 += z1 + z4;
  1086.                     } 
  1087.                     else 
  1088.                     {
  1089. /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  1090.                         z2 = d5 + d3;
  1091.  
  1092.                         z5 = MULTIPLY(z2, FIX(1.175875602));
  1093.                         tmp1 = MULTIPLY(d5, FIX(1.662939225));
  1094.                         z4 = MULTIPLY(d5, -FIX(0.390180644));
  1095.                         z2 = MULTIPLY(z2, -FIX(1.387039845));
  1096.                         tmp2 = MULTIPLY(d3, FIX(1.111140466));
  1097.                         z3 = MULTIPLY(d3, -FIX(1.961570560));
  1098.  
  1099.                         tmp0 = z3 + z5;
  1100.                         tmp1 += z2;
  1101.                         tmp2 += z2;
  1102.                         tmp3 = z4 + z5;
  1103.                     }
  1104.                 } 
  1105.                 else 
  1106.                 {
  1107.                     if(d1) 
  1108.                     {
  1109. /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  1110.                         z4 = d5 + d1;
  1111.  
  1112.                         z5 = MULTIPLY(z4, FIX(1.175875602));
  1113.                         z1 = MULTIPLY(d1, -FIX(0.899976223));
  1114.                         tmp3 = MULTIPLY(d1, FIX(0.601344887));
  1115.                         tmp1 = MULTIPLY(d5, -FIX(0.509795578));
  1116.                         z2 = MULTIPLY(d5, -FIX(2.562915447));
  1117.                         z4 = MULTIPLY(z4, FIX(0.785694958));
  1118.  
  1119.                         tmp0 = z1 + z5;
  1120.                         tmp1 += z4;
  1121.                         tmp2 = z2 + z5;
  1122.                         tmp3 += z4;
  1123.                     } 
  1124.                     else 
  1125.                     {
  1126. /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  1127.                         tmp0 = MULTIPLY(d5, FIX(1.175875602));
  1128.                         tmp1 = MULTIPLY(d5, FIX(0.275899380));
  1129.                         tmp2 = MULTIPLY(d5, -FIX(1.387039845));
  1130.                         tmp3 = MULTIPLY(d5, FIX(0.785694958));
  1131.                     }
  1132.                 }
  1133.             } 
  1134.             else 
  1135.             {
  1136.                 if(d3) 
  1137.                 {
  1138.                     if(d1) 
  1139.                     {
  1140. /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  1141.                         z5 = d1 + d3;
  1142.                         tmp3 = MULTIPLY(d1, FIX(0.211164243));
  1143.                         tmp2 = MULTIPLY(d3, -FIX(1.451774981));
  1144.                         z1 = MULTIPLY(d1, FIX(1.061594337));
  1145.                         z2 = MULTIPLY(d3, -FIX(2.172734803));
  1146.                         z4 = MULTIPLY(z5, FIX(0.785694958));
  1147.                         z5 = MULTIPLY(z5, FIX(1.175875602));
  1148.  
  1149.                         tmp0 = z1 - z4;
  1150.                         tmp1 = z2 + z4;
  1151.                         tmp2 += z5;
  1152.                         tmp3 += z5;
  1153.                     } 
  1154.                     else 
  1155.                     {
  1156. /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  1157.                         tmp0 = MULTIPLY(d3, -FIX(0.785694958));
  1158.                         tmp1 = MULTIPLY(d3, -FIX(1.387039845));
  1159.                         tmp2 = MULTIPLY(d3, -FIX(0.275899379));
  1160.                         tmp3 = MULTIPLY(d3, FIX(1.175875602));
  1161.                     }
  1162.                 } 
  1163.                 else 
  1164.                 {
  1165.                     if(d1) 
  1166.                     {
  1167. /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  1168.                         tmp0 = MULTIPLY(d1, FIX(0.275899379));
  1169.                         tmp1 = MULTIPLY(d1, FIX(0.785694958));
  1170.                         tmp2 = MULTIPLY(d1, FIX(1.175875602));
  1171.                         tmp3 = MULTIPLY(d1, FIX(1.387039845));
  1172.                     } 
  1173.                     else 
  1174.                     {
  1175. /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  1176.                         tmp0 = tmp1 = tmp2 = tmp3 = 0;
  1177.                     }
  1178.                 }
  1179.             }
  1180.         }
  1181.  
  1182. /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  1183.  
  1184.  
  1185.         outptr[DCTSIZE1 * 0] = rnglimit[(int)DESCALE(tmp10 + tmp3, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1186.         outptr[DCTSIZE1 * 7] = rnglimit[(int)DESCALE(tmp10 - tmp3, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1187.         outptr[DCTSIZE1 * 1] = rnglimit[(int)DESCALE(tmp11 + tmp2, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1188.         outptr[DCTSIZE1 * 6] = rnglimit[(int)DESCALE(tmp11 - tmp2, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1189.         outptr[DCTSIZE1 * 2] = rnglimit[(int)DESCALE(tmp12 + tmp1, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1190.         outptr[DCTSIZE1 * 5] = rnglimit[(int)DESCALE(tmp12 - tmp1, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1191.         outptr[DCTSIZE1 * 3] = rnglimit[(int)DESCALE(tmp13 + tmp0, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1192.         outptr[DCTSIZE1 * 4] = rnglimit[(int)DESCALE(tmp13 - tmp0, CONST_BITS + PASS1_BITS + 3) & RANGE_MASK];
  1193.  
  1194.         dataptr++;            /* advance pointer to next column */
  1195.         outptr++;
  1196.     }
  1197. }
  1198.