MP3_Fastimdct.c
上传用户:kingbiz
上传日期:2022-06-24
资源大小:2524k
文件大小:8k
源码类别:

mpeg/mp3

开发平台:

C/C++

  1. #include "math.h"
  2. #include "mp3_common.h" 
  3. /*============================================================================*/
  4. static float Granule_twiddles_short[23] = {
  5.     0.866025403f, 0.5f,
  6.     1.931851653f, 0.707106781f, 0.517638090f,
  7.     0.504314480f, 0.541196100f, 0.630236207f,
  8.     0.821339815f, 1.306562965f, 3.830648788f,
  9.     0.793353340f, 0.608761429f, 0.923879532f,
  10.     0.382683432f, 0.991444861f, 0.130526192f, 
  11.     0.382683432f, 0.608761429f, 0.793353340f,
  12.     0.923879532f, 0.991444861f, 0.130526192f
  13. };
  14. /*============================================================================*/
  15. static float Granule_twiddles_normal[] = {
  16.     5.736856623f, 1.931851653f, 1.183100792f,
  17.     0.871723397f, 0.707106781f, 0.610387294f, 
  18.     0.551688959f, 0.517638090f, 0.501909918f,
  19.     -0.500476342f, -0.504314480f, -0.512139757f,
  20.     -0.524264562f, -0.541196100f, -0.563690973f, 
  21.     -0.592844523f, -0.630236207f, -0.678170852f, 
  22.     -0.740093616f, -0.821339815f, -0.930579498f,
  23.     -1.082840285f, -1.306562965f, -1.662754762f, 
  24.     -2.310113158f, -3.830648788f, -11.46279281f
  25. };
  26. /*============================================================================*/
  27. //IMDCT 加窗 叠加 
  28. static float Granule_imdct_previous[2][576];  /* used for overlapping */
  29. static float Granule_9x9_idct[72];
  30. static float Granule_imdct_win[4][36];
  31. void Granule_imdct(struct Granule *gr, int ch, SS XX )
  32. {
  33.     int sb, i, j, k, l, window;
  34.     float save, sum, sum2, pp1;
  35.     float s;
  36.     float x[36], t[18];
  37.     float  *prev, *z, *twid,*X;
  38.     int odd_i, two_odd_i, four_odd_i, eight_odd_i;
  39. static int init=1;
  40. ////
  41. X=&XX[0][0];
  42.     if(init)
  43. {
  44. /* block_type 0 (normal window) */
  45.       for(i = 0; i < 36; i++)
  46.     Granule_imdct_win[0][i] = sin(PI/36 * (i + 0.5));
  47.     
  48.     /* block_type 1 (start block) */
  49.       for(i = 0; i < 18; i++)
  50.     Granule_imdct_win[1][i] = sin(PI/36 * (i + 0.5));
  51.       for(i = 18; i < 24; i++)
  52.     Granule_imdct_win[1][i] = 1.0f;
  53.       for(i = 24; i < 30; i++)
  54.     Granule_imdct_win[1][i] =  sin(PI/12 * (i - 18 + 0.5));
  55.       for(i = 30; i < 36; i++)
  56.     Granule_imdct_win[1][i] =  0.0f;
  57.     
  58.     /* block_type 3 (stop block) */
  59.       for(i = 0; i < 6; i++)
  60.     Granule_imdct_win[3][i] =  0.0f;
  61.       for(i = 6; i < 12; i++)
  62.     Granule_imdct_win[3][i] =  sin(PI/12 * (i - 6 + 0.5));
  63.       for(i = 12; i < 18; i++)
  64.     Granule_imdct_win[3][i] =  1.0f;
  65.       for(i = 18; i < 36; i++)
  66.     Granule_imdct_win[3][i] =  sin(PI/36 * (i + 0.5));
  67.     
  68.     /* block_type 2 (short block) */
  69.       for(i = 0; i < 12; i++)
  70.     Granule_imdct_win[2][i] =  sin(PI/12 * (i + 0.5));
  71.       for(i = 12; i < 36; i++)
  72.     Granule_imdct_win[2][i] =  0.0 ;
  73.       
  74.       j = 0;
  75.       for(i = 0; i < 9; i++) 
  76.   {
  77.        odd_i = (i << 1) + 1;
  78.     two_odd_i = odd_i << 1;
  79.     four_odd_i = odd_i << 2;
  80.     Granule_9x9_idct[j++] =  cos(PI/18 * odd_i);
  81.     Granule_9x9_idct[j++] =  cos(PI/18 * two_odd_i);
  82.     eight_odd_i = two_odd_i << 2;
  83.     Granule_9x9_idct[j++] =  cos(PI/18 * (four_odd_i - odd_i));
  84.     Granule_9x9_idct[j++] =  cos(PI/18 * four_odd_i);
  85.     Granule_9x9_idct[j++] =  cos(PI/18 * (four_odd_i + odd_i));
  86.     Granule_9x9_idct[j++] =  cos(PI/18 * (four_odd_i + two_odd_i));
  87.     Granule_9x9_idct[j++] =  cos(PI/18 * (eight_odd_i - odd_i));
  88.     Granule_9x9_idct[j++] =  cos(PI/18 * eight_odd_i);
  89.   }
  90.      for(j = 0;  j< 2; j++)
  91.       for(i = 0; i < 576; i++)
  92.      Granule_imdct_previous[j][i] = 0.0f;
  93.   init=0;
  94. }
  95. ////////
  96. prev = Granule_imdct_previous[ch];
  97.     /* process each subband */
  98.     for(sb = 0; sb < SBLIMIT; sb++)
  99. {
  100.   for(i = 0; i < 36; i++)
  101.      x[i] =  0.0f;
  102. /* decode the block_type - it's in block_type, but we have to think
  103.    about the mixed blocks lower 2 subbands */
  104. if(gr->block_type == 2 &&
  105.    !(gr->window_switching_flag && 
  106.      gr->mixed_block_flag && sb < 2))
  107. {
  108.     /* process the 3 windows separately, each window has 12 values */
  109.       for(window = 0; window < 3; window++)
  110.   {
  111. /* 30*3=90 adds, 25*3=75 muls */
  112. X[15+window] += X[12+window];
  113. X[12+window] += X[9+window];
  114. X[9+window] += X[6+window];
  115. X[6+window] += X[3+window];
  116. X[3+window] += X[window];
  117. X[15+window] += X[9+window];
  118. X[9+window] += X[3+window];
  119. twid = Granule_twiddles_short;
  120. /* do a 3x3 IDCT on the even part */
  121. pp1 = X[6+window] * twid[0];
  122. sum = X[window] + X[12+window] * twid[1];
  123. t[1] = X[window] - X[12+window];
  124. t[0] = sum + pp1;
  125. t[2] = sum - pp1;
  126. /* 3x3 IDCT for odd part */
  127. pp1 = X[9+window] * twid[0];
  128. sum = X[3+window] + X[15+window] * twid[1];
  129. t[4] = X[3+window] - X[15+window];
  130. t[5] = sum + pp1;
  131. t[3] = sum - pp1;
  132. /* scale the odd part */
  133. t[3] *= twid[2];
  134. t[4] *= twid[3];
  135. t[5] *= twid[4];
  136. save = t[0];
  137. t[0] += t[5];
  138. t[5] = save - t[5];
  139. save = t[1];
  140. t[1] += t[4];
  141. t[4] = save - t[4];
  142. save = t[2];
  143. t[2] += t[3];
  144. t[3] = save - t[3];
  145. t[0]  *= twid[5];
  146. t[1]  *= twid[6];
  147. t[2]  *= twid[7];
  148. t[3]  *= twid[8];
  149. t[4]  *= twid[9];
  150. t[5]  *= twid[10];
  151. t[6]  = -t[2] * twid[15];
  152. t[7]  = -t[1] * twid[13];
  153. t[8]  = -t[0] * twid[11];
  154. t[9]  = -t[0] * twid[12];
  155. t[10] = -t[1] * twid[14];
  156. t[11] = -t[2] * twid[16];
  157. t[0]  =  t[3];
  158. t[1]  =  t[4] * twid[17];
  159. t[2]  =  t[5] * twid[18];
  160. t[3]  = -t[5] * twid[19];
  161. t[4]  = -t[4] * twid[20];
  162. t[5]  = -t[0] * twid[21];
  163. t[0] *= twid[22];
  164. z = &x[window * 6 + 6];
  165. z[0]  += t[0];
  166. z[1]  += t[1];
  167. z[2]  += t[2];
  168. z[3]  += t[3];
  169. z[4]  += t[4];
  170. z[5]  += t[5];
  171. z[6]  += t[6];
  172. z[7]  += t[7];
  173. z[8]  += t[8];
  174. z[9]  += t[9];
  175. z[10]  += t[10];
  176. z[11]  += t[11];
  177.   }
  178. }
  179. else
  180. {
  181.     /* uses 207 muls, 189 adds */
  182.  
  183.     X[17] += X[16];
  184.     X[16] += X[15];
  185.     X[15] += X[14];
  186.     X[14] += X[13];
  187.     X[13] += X[12];
  188.     X[12] += X[11];
  189.     X[11] += X[10];
  190.     X[10] += X[9];
  191.     X[9] += X[8];
  192.     X[8] += X[7];
  193.     X[7] += X[6];
  194.     X[6] += X[5];
  195.     X[5] += X[4];
  196.     X[4] += X[3];
  197.     X[3] += X[2];
  198.     X[2] += X[1];
  199.     X[1] += X[0];
  200.     X[17] += X[15];
  201.     X[15] += X[13];
  202.     X[13] += X[11];
  203.     X[11] += X[9];
  204.     X[9] += X[7];
  205.     X[7] += X[5];
  206.     X[5] += X[3];
  207.     X[3] += X[1];
  208.     for(i = 0, j = 0; i < 9; i++, j += 8)
  209. {
  210.             sum = X[0];
  211. sum2 = X[1];
  212. for(l = 0, k = 0; l < 16; l += 2, k++) 
  213. {
  214.     s = Granule_9x9_idct[j+k];
  215.     sum += X[2+l] * s;
  216.     sum2 += X[3+l] * s;
  217. }
  218. t[i] = sum;
  219. t[17-i] = sum2;
  220.     }
  221.     twid = Granule_twiddles_normal;
  222.     
  223.     for(i = 0; i < 9; i++)
  224.   t[9+i] *= twid[i];
  225.     for(i = 0; i < 9; i++) 
  226. {
  227.      save = t[i];
  228.   t[i] += t[17-i];
  229.   t[17-i] = save - t[17-i];
  230.     }
  231.     for(i = 0; i < 18; i++)
  232.   t[i] *= twid[9+i];
  233.     /* correct the transform into the 18x36 IMDCT we need */
  234.     /* 36 muls */
  235.     for(i = 0; i < 9; i++)
  236. {
  237.   x[i] = -t[i+9] * Granule_imdct_win[gr->block_type][i];
  238.   x[i+9] = t[17-i] * Granule_imdct_win[gr->block_type][i+9];
  239.   x[i+18] = t[8-i] * Granule_imdct_win[gr->block_type][i+18];
  240.   x[i+27] = t[i] * Granule_imdct_win[gr->block_type][i+27];
  241.     }
  242. }
  243. /* Overlap and add with previous block */
  244.        for(i = 0; i < 18; i++) 
  245. {
  246.       *(X++) = x[i] + *prev;  /* produce an output value */
  247.       *(prev++) = x[i+18]; 
  248. }
  249.     }
  250.     
  251. }
  252. /*============================================================================*/
  253. //多相频率反转
  254. void Granule_freqinverse(SS X)
  255. {
  256.     int sb, dct;
  257. float *x;
  258. ////
  259.     x = &X[0][SSLIMIT];
  260.     for(sb = 1; sb < SBLIMIT; sb += 2) 
  261. {
  262.   for(dct = 1; dct < SSLIMIT; dct += 2)
  263.   {
  264.     x[dct] = -x[dct];
  265.   }
  266.   
  267.   x = &x[2 * SSLIMIT];
  268.     }
  269. }
  270. /*============================================================================*/
  271. /*============================================================================*/