home *** CD-ROM | disk | FTP | other *** search
/ Windows 95 Secrets / Secrets2.iso / Audio / WAV / MaplayP / _SETUP.1 / inv_mdct.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-02  |  17.6 KB  |  571 lines
  1. /* inv_mdct.cpp
  2.  
  3.     Inverse Discrete Cosine Transform for hybrid
  4.    synthesis in MPEG Audio Layer III. Based on the public_c source,
  5.    but almost completely redone by Jeff Tsay and Mikko Tommila.
  6.  
  7.    Last modified : 04/14/97 */
  8.  
  9. #include <math.h>
  10.  
  11. #include "all.h"
  12. #include "inv_mdct.h"
  13.  
  14. #define PI12      0.261799387f
  15. #define PI36      0.087266462f
  16. #define COSPI3    0.500000000f
  17. #define COSPI6    0.866025403f
  18. #define DCTODD1   0.984807753f
  19. #define DCTODD2  -0.342020143f
  20. #define DCTODD3  -0.642787609f
  21. #define DCTEVEN1  0.939692620f
  22. #define DCTEVEN2 -0.173648177f
  23. #define DCTEVEN3 -0.766044443f
  24.  
  25. /*
  26. This uses Byeong Gi Lee's Fast Cosine Transform algorithm to
  27. decompose the 36 point and 12 point IDCT's into 9 point and 3
  28. point IDCT's, respectively. Then the 9 point IDCT is computed
  29. by a modified version of Mikko Tommila's IDCT algorithm, based on
  30. the WFTA. See his comments before the first 9 point IDCT. The 3
  31. point IDCT is already efficient to implement. -- Jeff Tsay. */
  32.  
  33. void inv_mdct(real *in, real *out, int32 block_type)
  34. {
  35. /*------------------------------------------------------------------*/
  36. /*                                                                  */
  37. /*    Function: Calculation of the inverse MDCT                     */
  38. /*    In the case of short blocks the 3 output vectors are already  */
  39. /*    overlapped and added in this modul.                           */
  40. /*                                                                  */
  41. /*    New layer3                                                    */
  42. /*                                                                  */
  43. /*------------------------------------------------------------------*/
  44.  
  45.      real    tmp[18];
  46.      real    *win_bt;
  47.     int32   i;
  48.      static  real win[4][36];
  49.     static  bool MDCT_init = FALSE;
  50.  
  51.      if(!MDCT_init){
  52.  
  53.      // type 0
  54.         for(i=0;i<36;i++)
  55.             win[0][i] = (real) sin(PI36 *(i+0.5));
  56.  
  57.      // type 1
  58.         for(i=0;i<18;i++)
  59.             win[1][i] = (real) sin(PI36 *(i+0.5));
  60.         for(i=18;i<24;i++)
  61.             win[1][i] = 1.0f;
  62.         for(i=24;i<30;i++)
  63.             win[1][i] = (real) sin(PI12 *(i+0.5-18));
  64.         for(i=30;i<36;i++)
  65.             win[1][i] = 0.0f;
  66.  
  67.      // type 2 (not needed anymore)
  68.         for(i=0;i<12;i++)
  69.             win[2][i] = (real) sin(PI12*(i+0.5)) ;
  70.         for(i=12;i<36;i++)
  71.             win[2][i] = 0.0f;
  72.  
  73.      // type 3
  74.         for(i=0;i<6;i++)
  75.             win[3][i] = 0.0f;
  76.         for(i=6;i<12;i++)
  77.             win[3][i] = (real) sin(PI12 * (i+ 0.5 - 6.0));
  78.         for(i=12;i<18;i++)
  79.             win[3][i] = 1.0f;
  80.         for(i=18;i<36;i++)
  81.             win[3][i] = (real) sin(PI36 * (i + 0.5));
  82.  
  83.       for (i=0; i<4; i++) {
  84.  
  85.           real *win_bt = win[i];
  86.  
  87.             win_bt[26] *=  -0.500476342f;
  88.            win_bt[25] *=  -0.504314480f;
  89.            win_bt[24] *=  -0.512139757f;
  90.            win_bt[23] *=  -0.524264562f;
  91.            win_bt[22] *=  -0.541196100f;
  92.            win_bt[21] *=  -0.563690973f;
  93.             win_bt[20] *=  -0.592844523f;
  94.            win_bt[19] *=  -0.630236207f;
  95.            win_bt[18] *=  -0.678170852f;
  96.  
  97.           win_bt[27] *=  -0.500476342f;
  98.            win_bt[28] *=  -0.504314480f;
  99.            win_bt[29] *=  -0.512139757f;
  100.            win_bt[30] *=  -0.524264562f;
  101.            win_bt[31] *=  -0.541196100f;
  102.            win_bt[32] *=  -0.563690973f;
  103.             win_bt[33] *=  -0.592844523f;
  104.            win_bt[34] *=  -0.630236207f;
  105.            win_bt[35] *=  -0.678170852f;
  106.  
  107.            win_bt[0]  *=  -0.740093616f;
  108.            win_bt[1]  *=  -0.821339815f;
  109.            win_bt[2]  *=  -0.930579498f;
  110.            win_bt[3]  *=  -1.082840285f;
  111.            win_bt[4]  *=  -1.306562965f;
  112.            win_bt[5]  *=  -1.662754762f;
  113.            win_bt[6]  *=  -2.310113158f;
  114.            win_bt[7]  *=  -3.830648788f;
  115.            win_bt[8]  *= -11.46279281f;
  116.  
  117.            win_bt[17] *=  -0.740093616f;
  118.            win_bt[16] *=  -0.821339815f;
  119.            win_bt[15] *=  -0.930579498f;
  120.            win_bt[14] *=  -1.082840285f;
  121.            win_bt[13] *=  -1.306562965f;
  122.            win_bt[12] *=  -1.662754762f;
  123.            win_bt[11] *=  -2.310113158f;
  124.            win_bt[10] *=  -3.830648788f;
  125.            win_bt[9]  *= -11.46279281f;
  126.  
  127.       }
  128.  
  129.         MDCT_init = TRUE;
  130.      }
  131.  
  132.      if(block_type == 2){
  133.  
  134.        for(int32 p=0;p<36;p+=9) {
  135.            out[p]   = out[p+1] = out[p+2] = out[p+3] =
  136.           out[p+4] = out[p+5] = out[p+6] = out[p+7] =
  137.           out[p+8] = 0.0f;
  138.        }
  139.  
  140.         int32 six_i = 0;
  141.  
  142.        for(i=0;i<3;i++)
  143.        {
  144.  
  145.           // 12 point IMDCT
  146.  
  147.          // Begin 12 point IDCT
  148.  
  149.            // Input aliasing for 12 pt IDCT
  150.            in[15+i] += in[12+i]; in[12+i] += in[9+i]; in[9+i]  +=  in[6+i];
  151.            in[6+i]  += in[3+i];  in[3+i]  += in[0+i];
  152.  
  153.            // Input aliasing on odd indices (for 6 point IDCT)
  154.            in[15+i] += in[9+i];  in[9+i]  += in[3+i];
  155.  
  156.            // 3 point IDCT on even indices
  157.  
  158.          {
  159.              real     pp1, pp2, sum;
  160.             pp2 = in[12+i] * 0.500000000f;
  161.            pp1 = in[ 6+i] * 0.866025403f;
  162.            sum = in[0+i] + pp2;
  163.            tmp[1] = in[0+i] - in[12+i];
  164.            tmp[0] = sum + pp1;
  165.            tmp[2] = sum - pp1;
  166.  
  167.           // End 3 point IDCT on even indices
  168.  
  169.            // 3 point IDCT on odd indices (for 6 point IDCT)
  170.  
  171.             pp2 = in[15+i] * 0.500000000f;
  172.            pp1 = in[ 9+i] * 0.866025403f;
  173.            sum = in[ 3+i] + pp2;
  174.            tmp[4] = in[3+i] - in[15+i];
  175.            tmp[5] = sum + pp1;
  176.            tmp[3] = sum - pp1;
  177.          }
  178.  
  179.           // End 3 point IDCT on odd indices
  180.  
  181.            // Twiddle factors on odd indices (for 6 point IDCT)
  182.  
  183.            tmp[3] *= 1.931851653f;
  184.            tmp[4] *= 0.707106781f;
  185.            tmp[5] *= 0.517638090f;
  186.  
  187.            // Output butterflies on 2 3 point IDCT's (for 6 point IDCT)
  188.  
  189.          {
  190.            real save = tmp[0];
  191.            tmp[0] += tmp[5];
  192.            tmp[5] = save - tmp[5];
  193.            save = tmp[1];
  194.            tmp[1] += tmp[4];
  195.            tmp[4] = save - tmp[4];
  196.            save = tmp[2];
  197.            tmp[2] += tmp[3];
  198.            tmp[3] = save - tmp[3];
  199.          }
  200.  
  201.            // End 6 point IDCT
  202.  
  203.            // Twiddle factors on indices (for 12 point IDCT)
  204.  
  205.            tmp[0]  *=  0.504314480f;
  206.            tmp[1]  *=  0.541196100f;
  207.            tmp[2]  *=  0.630236207f;
  208.            tmp[3]  *=  0.821339815f;
  209.            tmp[4]  *=  1.306562965f;
  210.            tmp[5]  *=  3.830648788f;
  211.  
  212.           // End 12 point IDCT
  213.  
  214.            // Shift to 12 point modified IDCT, multiply by window type 2
  215.            tmp[8]  = -tmp[0] * 0.793353340f;
  216.            tmp[9]  = -tmp[0] * 0.608761429f;
  217.            tmp[7]  = -tmp[1] * 0.923879532f;
  218.            tmp[10] = -tmp[1] * 0.382683432f;
  219.            tmp[6]  = -tmp[2] * 0.991444861f;
  220.            tmp[11] = -tmp[2] * 0.130526192f;
  221.  
  222.            tmp[0]  =  tmp[3];
  223.            tmp[1]  =  tmp[4] * 0.382683432f;
  224.            tmp[2]  =  tmp[5] * 0.608761429f;
  225.  
  226.            tmp[3]  = -tmp[5] * 0.793353340f;
  227.            tmp[4]  = -tmp[4] * 0.923879532f;
  228.            tmp[5]  = -tmp[0] * 0.991444861f;
  229.  
  230.            tmp[0] *= 0.130526192f;
  231.  
  232.            out[six_i + 6]  += tmp[0];
  233.             out[six_i + 7]  += tmp[1];
  234.            out[six_i + 8]  += tmp[2];
  235.             out[six_i + 9]  += tmp[3];
  236.            out[six_i + 10] += tmp[4];
  237.             out[six_i + 11] += tmp[5];
  238.            out[six_i + 12] += tmp[6];
  239.             out[six_i + 13] += tmp[7];
  240.            out[six_i + 14] += tmp[8];
  241.             out[six_i + 15] += tmp[9];
  242.            out[six_i + 16] += tmp[10];
  243.             out[six_i + 17] += tmp[11];
  244.  
  245.            six_i += 6;
  246.        }
  247.  
  248.      } else {
  249.  
  250. /*
  251.    // 36 point IDCT
  252.  
  253.    // input aliasing for 36 point IDCT
  254.    in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14]; in[14]+=in[13];
  255.    in[13]+=in[12]; in[12]+=in[11]; in[11]+=in[10]; in[10]+=in[9];
  256.    in[9] +=in[8];  in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
  257.    in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];  in[2] +=in[1];
  258.    in[1] +=in[0];
  259.  
  260.    // 18 point IDCT for odd indices
  261.  
  262.    // input aliasing for 18 point IDCT
  263.    in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
  264.    in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
  265.  
  266. {
  267.    real tmp0,tmp1,tmp2,tmp3,tmp4,tmp0_,tmp1_,tmp2_,tmp3_;
  268.    real tmp0o,tmp1o,tmp2o,tmp3o,tmp4o,tmp0_o,tmp1_o,tmp2_o,tmp3_o;
  269.  
  270. // Fast 9 Point Inverse Discrete Cosine Transform
  271. //
  272. // By  Francois-Raymond Boyer
  273. //         mailto:boyerf@iro.umontreal.ca
  274. //         http://www.iro.umontreal.ca/~boyerf
  275. //
  276. // The code has been optimized for Intel processors
  277. //  (takes a lot of time to convert float to and from iternal FPU representation)
  278. //
  279. // It is a simple "factorization" of the IDCT matrix.
  280.  
  281.    // 9 point IDCT on even indices
  282.    {
  283. // 5 points on odd indices (not realy an IDCT)
  284.    real i0 = in[0]+in[0];
  285.    real i0p12 = i0 + in[12];
  286.  
  287.    tmp0 = i0p12 + in[4]*1.8793852415718f  + in[8]*1.532088886238f   + in[16]*0.34729635533386f;
  288.    tmp1 = i0    + in[4]                   - in[8] - in[12] - in[12] - in[16];
  289.    tmp2 = i0p12 - in[4]*0.34729635533386f - in[8]*1.8793852415718f  + in[16]*1.532088886238f;
  290.    tmp3 = i0p12 - in[4]*1.532088886238f   + in[8]*0.34729635533386f - in[16]*1.8793852415718f;
  291.    tmp4 = in[0] - in[4]                   + in[8] - in[12]          + in[16];
  292.  
  293. // 4 points on even indices
  294.    real i6_ = in[6]*1.732050808f;        // Sqrt[3]
  295.  
  296.    tmp0_ = in[2]*1.9696155060244f  + i6_ + in[10]*1.2855752193731f  + in[14]*0.68404028665134f;
  297.    tmp1_ = (in[2]                        - in[10]                   - in[14])*1.732050808f;
  298.    tmp2_ = in[2]*1.2855752193731f  - i6_ - in[10]*0.68404028665134f + in[14]*1.9696155060244f;
  299.    tmp3_ = in[2]*0.68404028665134f - i6_ + in[10]*1.9696155060244f  - in[14]*1.2855752193731f;
  300.    }
  301.  
  302.    // 9 point IDCT on odd indices
  303.    {
  304. // 5 points on odd indices (not realy an IDCT)
  305.    real i0 = in[0+1]+in[0+1];
  306.    real i0p12 = i0 + in[12+1];
  307.  
  308.    tmp0o = i0p12   + in[4+1]*1.8793852415718f  + in[8+1]*1.532088886238f       + in[16+1]*0.34729635533386f;
  309.    tmp1o = i0      + in[4+1]                   - in[8+1] - in[12+1] - in[12+1] - in[16+1];
  310.    tmp2o = i0p12   - in[4+1]*0.34729635533386f - in[8+1]*1.8793852415718f      + in[16+1]*1.532088886238f;
  311.    tmp3o = i0p12   - in[4+1]*1.532088886238f   + in[8+1]*0.34729635533386f     - in[16+1]*1.8793852415718f;
  312.    tmp4o = (in[0+1] - in[4+1]                   + in[8+1] - in[12+1]            + in[16+1])*0.707106781f; // Twiddled
  313.  
  314. // 4 points on even indices
  315.    real i6_ = in[6+1]*1.732050808f;        // Sqrt[3]
  316.  
  317.    tmp0_o = in[2+1]*1.9696155060244f  + i6_ + in[10+1]*1.2855752193731f  + in[14+1]*0.68404028665134f;
  318.    tmp1_o = (in[2+1]                        - in[10+1]                   - in[14+1])*1.732050808f;
  319.    tmp2_o = in[2+1]*1.2855752193731f  - i6_ - in[10+1]*0.68404028665134f + in[14+1]*1.9696155060244f;
  320.    tmp3_o = in[2+1]*0.68404028665134f - i6_ + in[10+1]*1.9696155060244f  - in[14+1]*1.2855752193731f;
  321.    }
  322.  
  323.    // Twiddle factors on odd indices
  324.    // and
  325.    // Butterflies on 9 point IDCT's
  326.    // and
  327.    // twiddle factors for 36 point IDCT
  328.  
  329.    real e, o;
  330.    e = tmp0 + tmp0_; o = (tmp0o + tmp0_o)*0.501909918f; tmp[0] = (e + o)*(-0.500476342f*.5f);    tmp[17] = (e - o)*(-11.46279281f*.5f);
  331.    e = tmp1 + tmp1_; o = (tmp1o + tmp1_o)*0.517638090f; tmp[1] = (e + o)*(-0.504314480f*.5f);    tmp[16] = (e - o)*(-3.830648788f*.5f);
  332.    e = tmp2 + tmp2_; o = (tmp2o + tmp2_o)*0.551688959f; tmp[2] = (e + o)*(-0.512139757f*.5f);    tmp[15] = (e - o)*(-2.310113158f*.5f);
  333.    e = tmp3 + tmp3_; o = (tmp3o + tmp3_o)*0.610387294f; tmp[3] = (e + o)*(-0.524264562f*.5f);    tmp[14] = (e - o)*(-1.662754762f*.5f);
  334.                                                         tmp[4] = (tmp4 + tmp4o)*(-0.541196100f); tmp[13] = (tmp4 - tmp4o)*(-1.306562965f);
  335.    e = tmp3 - tmp3_; o = (tmp3o - tmp3_o)*0.871723397f; tmp[5] = (e + o)*(-0.563690973f*.5f);    tmp[12] = (e - o)*(-1.082840285f*.5f);
  336.    e = tmp2 - tmp2_; o = (tmp2o - tmp2_o)*1.183100792f; tmp[6] = (e + o)*(-0.592844523f*.5f);    tmp[11] = (e - o)*(-0.930579498f*.5f);
  337.    e = tmp1 - tmp1_; o = (tmp1o - tmp1_o)*1.931851653f; tmp[7] = (e + o)*(-0.630236207f*.5f);    tmp[10] = (e - o)*(-0.821339815f*.5f);
  338.    e = tmp0 - tmp0_; o = (tmp0o - tmp0_o)*5.736856623f; tmp[8] = (e + o)*(-0.678170852f*.5f);    tmp[9] =  (e - o)*(-0.740093616f*.5f);
  339.    }
  340.        // end 36 point IDCT */
  341.  
  342.       // 36 point IDCT
  343.  
  344.       // input aliasing for 36 point IDCT
  345.       in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14]; in[14]+=in[13];
  346.        in[13]+=in[12]; in[12]+=in[11]; in[11]+=in[10]; in[10]+=in[9];
  347.        in[9] +=in[8];  in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
  348.        in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];  in[2] +=in[1];
  349.        in[1] +=in[0];
  350.  
  351.        // 18 point IDCT for odd indices
  352.  
  353.        // input aliasing for 18 point IDCT
  354.        in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
  355.        in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
  356.  
  357.        // 9 point IDCT on even indices
  358.  
  359.         // original:
  360.  
  361. /*   for(i=0; i<9; i++) {
  362.        sum = 0.0;
  363.  
  364.       for(j=0;j<18;j+=2)
  365.           sum += in[j] * cos(PI36 * (2*i + 1) * j);
  366.  
  367.       tmp[i] = sum;
  368.      } */
  369.  
  370. // 9 Point Inverse Discrete Cosine Transform
  371. //
  372. // This piece of code is Copyright 1997 Mikko Tommila and is freely usable
  373. // by anybody. The algorithm itself is of course in the public domain.
  374. //
  375. // Again derived heuristically from the 9-point WFTA.
  376. //
  377. // The algorithm is optimized (?) for speed, not for small rounding errors or
  378. // good readability.
  379. //
  380. // 36 additions, 11 multiplications
  381. //
  382. // Again this is very likely sub-optimal.
  383. //
  384. // The code is optimized to use a minimum number of temporary variables,
  385. // so it should compile quite well even on 8-register Intel x86 processors.
  386. // This makes the code quite obfuscated and very difficult to understand.
  387. //
  388. // References:
  389. // [1] S. Winograd: "On Computing the Discrete Fourier Transform",
  390. //     Mathematics of Computation, Volume 32, Number 141, January 1978,
  391. //     Pages 175-199
  392.  
  393. // Some modifications for maplay by Jeff Tsay
  394.       {
  395.       real t0, t1, t2, t3, t4, t5, t6, t7;
  396.  
  397.       t1 = COSPI3 * in[12];
  398.       t2 = COSPI3 * (in[8] + in[16] - in[4]);
  399.  
  400.          t3 = in[0] + t1;
  401.          t4 = in[0] - t1 - t1;
  402.         t5 = t4 - t2;
  403.  
  404.         t0 = DCTEVEN1 * (in[4] + in[8]);
  405.         t1 = DCTEVEN2 * (in[8] - in[16]);
  406.  
  407.         tmp[4] = t4 + t2 + t2;
  408.         t2 = DCTEVEN3 * (in[4] + in[16]);
  409.  
  410.         t6 = t3 - t0 - t2;
  411.         t0 += t3 + t1;
  412.         t3 += t2 - t1;
  413.  
  414.         t2 = DCTODD1 * (in[2]  + in[10]);
  415.         t4 = DCTODD2 * (in[10] - in[14]);
  416.         t7 = COSPI6 * in[6];
  417.  
  418.         t1 = t2 + t4 + t7;
  419.         tmp[0] = t0 + t1;
  420.         tmp[8] = t0 - t1;
  421.         t1 = DCTODD3 * (in[2] + in[14]);
  422.         t2 += t1 - t7;
  423.  
  424.         tmp[3] = t3 + t2;
  425.         t0 = COSPI6 * (in[10] + in[14] - in[2]);
  426.         tmp[5] = t3 - t2;
  427.  
  428.         t4 -= t1 + t7;
  429.  
  430.         tmp[1] = t5 - t0;
  431.         tmp[7] = t5 + t0;
  432.         tmp[2] = t6 + t4;
  433.         tmp[6] = t6 - t4;
  434.         }
  435.  
  436.        // End 9 point IDCT on even indices
  437.  
  438.    // 9 point IDCT on odd indices
  439.  
  440.     // original:
  441. /*   for(i=0; i<9; i++) {
  442.        sum = 0.0;
  443.  
  444.       for(j=0;j<18;j+=2)
  445.           sum += in[j+1] * cos(PI36 * (2*i + 1) * j);
  446.  
  447.       tmp[17-i] = sum;
  448.      } */
  449.  
  450.        // This includes multiplication by the twiddle factors
  451.       // at the end -- Jeff.
  452.       {
  453.         real t0, t1, t2, t3, t4, t5, t6, t7;
  454.  
  455.         t1 = COSPI3 * in[13];
  456.         t2 = COSPI3 * (in[9] + in[17] - in[5]);
  457.  
  458.          t3 = in[1] + t1;
  459.          t4 = in[1] - t1 - t1;
  460.         t5 = t4 - t2;
  461.  
  462.         t0 = DCTEVEN1 * (in[5] + in[9]);
  463.         t1 = DCTEVEN2 * (in[9] - in[17]);
  464.  
  465.         tmp[13] = (t4 + t2 + t2) * 0.707106781f;
  466.         t2 = DCTEVEN3 * (in[5] + in[17]);
  467.  
  468.         t6 = t3 - t0 - t2;
  469.         t0 += t3 + t1;
  470.         t3 += t2 - t1;
  471.  
  472.         t2 = DCTODD1 * (in[3]  + in[11]);
  473.         t4 = DCTODD2 * (in[11] - in[15]);
  474.         t7 = COSPI6  * in[7];
  475.  
  476.         t1 = t2 + t4 + t7;
  477.         tmp[17] = (t0 + t1) * 0.501909918f;
  478.         tmp[9]  = (t0 - t1) * 5.736856623f;
  479.         t1 = DCTODD3 * (in[3] + in[15]);
  480.         t2 += t1 - t7;
  481.  
  482.         tmp[14] = (t3 + t2) * 0.610387294f;
  483.         t0 = COSPI6 * (in[11] + in[15] - in[3]);
  484.         tmp[12] = (t3 - t2) * 0.871723397f;
  485.  
  486.         t4 -= t1 + t7;
  487.  
  488.         tmp[16] = (t5 - t0) * 0.517638090f;
  489.         tmp[10] = (t5 + t0) * 1.931851653f;
  490.         tmp[15] = (t6 + t4) * 0.551688959f;
  491.         tmp[11] = (t6 - t4) * 1.183100792f;
  492.         }
  493.  
  494.        // End 9 point IDCT on odd indices
  495.  
  496.        // Butterflies on 9 point IDCT's
  497.        for (int32 i=0;i<9;i++) {
  498.            real save = tmp[i];
  499.           tmp[i] += tmp[17-i];
  500.           tmp[17-i] = save - tmp[17-i];
  501.        }
  502.        // end 18 point IDCT
  503.  
  504.        // twiddle factors for 36 point IDCT
  505.       // (already taken care of in window)
  506.  
  507. //       tmp[0] *=  -0.500476342f;
  508. //       tmp[1] *=  -0.504314480f;
  509. //       tmp[2] *=  -0.512139757f;
  510. //       tmp[3] *=  -0.524264562f;
  511. //       tmp[4] *=  -0.541196100f;
  512. //       tmp[5] *=  -0.563690973f;
  513. //        tmp[6] *=  -0.592844523f;
  514. //       tmp[7] *=  -0.630236207f;
  515. //       tmp[8] *=  -0.678170852f;
  516. //       tmp[9] *=  -0.740093616f;
  517. //       tmp[10]*=  -0.821339815f;
  518. //       tmp[11]*=  -0.930579498f;
  519. //       tmp[12]*=  -1.082840285f;
  520. //       tmp[13]*=  -1.306562965f;
  521. //       tmp[14]*=  -1.662754762f;
  522. //       tmp[15]*=  -2.310113158f;
  523. //       tmp[16]*=  -3.830648788f;
  524. //       tmp[17]*= -11.46279281f;
  525.  
  526.        // end 36 point IDCT
  527.  
  528.        // shift to modified IDCT
  529.        win_bt = win[block_type];
  530.  
  531.        out[0] =-tmp[9]  * win_bt[0];
  532.        out[1] =-tmp[10] * win_bt[1];
  533.        out[2] =-tmp[11] * win_bt[2];
  534.        out[3] =-tmp[12] * win_bt[3];
  535.        out[4] =-tmp[13] * win_bt[4];
  536.        out[5] =-tmp[14] * win_bt[5];
  537.        out[6] =-tmp[15] * win_bt[6];
  538.        out[7] =-tmp[16] * win_bt[7];
  539.        out[8] =-tmp[17] * win_bt[8];
  540.  
  541.        out[9] = tmp[17] * win_bt[9];
  542.        out[10]= tmp[16] * win_bt[10];
  543.        out[11]= tmp[15] * win_bt[11];
  544.        out[12]= tmp[14] * win_bt[12];
  545.        out[13]= tmp[13] * win_bt[13];
  546.        out[14]= tmp[12] * win_bt[14];
  547.        out[15]= tmp[11] * win_bt[15];
  548.        out[16]= tmp[10] * win_bt[16];
  549.        out[17]= tmp[9]  * win_bt[17];
  550.        out[18]= tmp[8]  * win_bt[18];
  551.        out[19]= tmp[7]  * win_bt[19];
  552.        out[20]= tmp[6]  * win_bt[20];
  553.        out[21]= tmp[5]  * win_bt[21];
  554.        out[22]= tmp[4]  * win_bt[22];
  555.        out[23]= tmp[3]  * win_bt[23];
  556.         out[24]= tmp[2]  * win_bt[24];
  557.        out[25]= tmp[1]  * win_bt[25];
  558.        out[26]= tmp[0]  * win_bt[26];
  559.  
  560.        out[27]= tmp[0]  * win_bt[27];
  561.        out[28]= tmp[1]  * win_bt[28];
  562.        out[29]= tmp[2]  * win_bt[29];
  563.        out[30]= tmp[3]  * win_bt[30];
  564.        out[31]= tmp[4]  * win_bt[31];
  565.        out[32]= tmp[5]  * win_bt[32];
  566.        out[33]= tmp[6]  * win_bt[33];
  567.        out[34]= tmp[7]  * win_bt[34];
  568.        out[35]= tmp[8]  * win_bt[35];
  569.    }
  570. }
  571.