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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
newmdct.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：18k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

newmdct.c：源码内容
  1. /*
  2.  * MP3 window subband -> subband filtering -> mdct routine
  3.  *
  4.  * Copyright (c) 1999 Takehiro TOMINAGA
  5.  *
  6.  *
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Library General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Library General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Library General Public
  18.  * License along with this library; if not, write to the
  19.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20.  * Boston, MA 02111-1307, USA.
  21.  */
  23. /*
  24.  *         Special Thanks to Patrick De Smet for your advices.
  25.  */
  28. #include "util.h"
  29. #include "l3side.h"
  30. #include "newmdct.h"
  32. #define SCALE 32768
  34. static FLOAT8 enwindow[] = 
  35. {
  36.   3.5780907e-02,1.7876148e-02,3.134727e-03,2.457142e-03,
  37.     9.71317e-04,  2.18868e-04, 1.01566e-04,  1.3828e-05,
  39.   3.5758972e-02, 3.401756e-03,  9.83715e-04,   9.9182e-05,
  40.       -4.77e-07,  1.03951e-04,  9.53674e-04, 2.841473e-03,
  41.      1.2398e-05,  1.91212e-04, 2.283096e-03,1.6994476e-02,
  42.   1.8756866e-02, 2.630711e-03,  2.47478e-04,   1.4782e-05,
  44.   3.5694122e-02, 3.643036e-03,  9.91821e-04,   9.6321e-05,
  45.       -4.77e-07,  1.05858e-04,  9.30786e-04, 2.521515e-03,
  46.      1.1444e-05,  1.65462e-04, 2.110004e-03,1.6112804e-02,
  47.   1.9634247e-02, 2.803326e-03,  2.77042e-04,   1.6689e-05,
  49.   3.5586357e-02, 3.858566e-03,  9.95159e-04,   9.3460e-05,
  50.       -4.77e-07,  1.07288e-04,  9.02653e-04, 2.174854e-03,
  51.      1.0014e-05,  1.40190e-04, 1.937389e-03,1.5233517e-02,
  52.   2.0506859e-02, 2.974033e-03,  3.07560e-04,   1.8120e-05,
  54.   3.5435200e-02, 4.049301e-03,  9.94205e-04,   9.0599e-05,
  55.       -4.77e-07,  1.08242e-04,  8.68797e-04, 1.800537e-03,
  56.       9.060e-06,  1.16348e-04, 1.766682e-03,1.4358521e-02,
  57.   2.1372318e-02,  3.14188e-03,  3.39031e-04,   1.9550e-05,
  59.   3.5242081e-02, 4.215240e-03,  9.89437e-04,   8.7261e-05,
  60.       -4.77e-07,  1.08719e-04,  8.29220e-04, 1.399517e-03,
  61.       8.106e-06,   9.3937e-05, 1.597881e-03,1.3489246e-02,
  62.   2.2228718e-02, 3.306866e-03,  3.71456e-04,   2.1458e-05,
  64.   3.5007000e-02, 4.357815e-03,  9.80854e-04,   8.3923e-05,
  65.       -4.77e-07,  1.08719e-04,   7.8392e-04,  9.71317e-04,
  66.       7.629e-06,   7.2956e-05, 1.432419e-03,1.2627602e-02,
  67.   2.3074150e-02, 3.467083e-03,  4.04358e-04,   2.3365e-05,
  69.   3.4730434e-02, 4.477024e-03,  9.68933e-04,   8.0585e-05,
  70.       -9.54e-07,  1.08242e-04,  7.31945e-04,  5.15938e-04,
  71.       6.676e-06,   5.2929e-05, 1.269817e-03,1.1775017e-02,
  72.   2.3907185e-02, 3.622532e-03,  4.38213e-04,   2.5272e-05,
  74.   3.4412861e-02, 4.573822e-03,  9.54151e-04,   7.6771e-05,
  75.       -9.54e-07,  1.06812e-04,  6.74248e-04,   3.3379e-05,
  76.       6.199e-06,   3.4332e-05, 1.111031e-03,1.0933399e-02,
  77.   2.4725437e-02, 3.771782e-03,  4.72546e-04,   2.7657e-05,
  79.   3.4055710e-02, 4.649162e-03,  9.35555e-04,   7.3433e-05,
  80.       -9.54e-07,  1.05381e-04,  6.10352e-04, -4.75883e-04,
  81.       5.245e-06,   1.7166e-05,  9.56535e-04,1.0103703e-02,
  82.   2.5527000e-02, 3.914356e-03,  5.07355e-04,   3.0041e-05,
  84.   3.3659935e-02, 4.703045e-03,  9.15051e-04,   7.0095e-05,
  85.       -9.54e-07,  1.02520e-04,  5.39303e-04,-1.011848e-03,
  86.       4.768e-06,     9.54e-07,  8.06808e-04, 9.287834e-03,
  87.   2.6310921e-02, 4.048824e-03,  5.42164e-04,   3.2425e-05,
  89.   3.3225536e-02, 4.737377e-03,  8.91685e-04,   6.6280e-05,
  90.      -1.431e-06,   9.9182e-05,  4.62532e-04,-1.573563e-03,
  91.       4.292e-06,  -1.3828e-05,  6.61850e-04, 8.487225e-03,
  92.   2.7073860e-02, 4.174709e-03,  5.76973e-04,   3.4809e-05,
  94.   3.2754898e-02, 4.752159e-03,  8.66413e-04,   6.2943e-05,
  95.      -1.431e-06,   9.5367e-05,  3.78609e-04,-2.161503e-03,
  96.       3.815e-06,   -2.718e-05,  5.22137e-04, 7.703304e-03,
  97.   2.7815342e-02, 4.290581e-03,  6.11782e-04,   3.7670e-05,
  99.   3.2248020e-02, 4.748821e-03,  8.38757e-04,   5.9605e-05,
  100.      -1.907e-06,   9.0122e-05,  2.88486e-04,-2.774239e-03,
  101.       3.338e-06,  -3.9577e-05,  3.88145e-04, 6.937027e-03,
  102.   2.8532982e-02, 4.395962e-03,  6.46591e-04,   4.0531e-05,
  104.   3.1706810e-02, 4.728317e-03,  8.09669e-04,    5.579e-05,
  105.      -1.907e-06,   8.4400e-05,  1.91689e-04,-3.411293e-03,
  106.       3.338e-06,  -5.0545e-05,  2.59876e-04, 6.189346e-03,
  107.   2.9224873e-02, 4.489899e-03,  6.80923e-04,   4.3392e-05,
  109.   3.1132698e-02, 4.691124e-03,  7.79152e-04,   5.2929e-05,
  110.      -2.384e-06,   7.7724e-05,   8.8215e-05,-4.072189e-03,
  111.       2.861e-06,  -6.0558e-05,  1.37329e-04, 5.462170e-03,
  112.   2.9890060e-02, 4.570484e-03,  7.14302e-04,   4.6253e-05,
  114.   3.0526638e-02, 4.638195e-03,  7.47204e-04,   4.9591e-05,
  115.    4.756451e-03,   2.1458e-05,  -6.9618e-05,    2.384e-06
  116. };
  118. static FLOAT8 sb_sample[2][2][18][SBLIMIT];
  119. static FLOAT8 mm[16][SBLIMIT - 1];
  121. #define NS 12
  122. #define NL 36
  124. static const int all[] = {0,2,3,5,6,8,9,11,12,14,15,17};
  125. static FLOAT8 ca[8], cs[8];
  126. static FLOAT8 cos_s[NS / 2][NS / 2];
  127. static FLOAT8 cos_l[(NL / 2) * 12 + (NL / 6) * 4 + (NL / 18) * 2];
  128. static FLOAT8 win[4][36];
  130. #define work (&win[2][4])
  132. /************************************************************************
  133. *
  134. * window_subband()
  135. *
  136. * PURPOSE:  Overlapping window on PCM samples
  137. *
  138. * SEMANTICS:
  139. * 32 16-bit pcm samples are scaled to fractional 2's complement and
  140. * concatenated to the end of the window buffer #x#. The updated window
  141. * buffer #x# is then windowed by the analysis window #c# to produce the
  142. * windowed sample #z#
  143. *
  144. ************************************************************************/
  146. static void window_subband(short *xk, FLOAT8 d[SBLIMIT], FLOAT8 *in)
  147. {
  148.     int i;
  149.     FLOAT8 s, t, *wp;
  150.     wp = enwindow;
  151.     {
  152. t  =  xk[255];
  153. t += (xk[223] - xk[287]) * *wp++;
  154. t += (xk[191] + xk[319]) * *wp++;
  155. t += (xk[159] - xk[351]) * *wp++;
  156. t += (xk[127] + xk[383]) * *wp++;
  157. t += (xk[ 95] - xk[415]) * *wp++;
  158. t += (xk[ 63] + xk[447]) * *wp++;
  159. t += (xk[ 31] - xk[479]) * *wp++;
  160. in[15] = t;
  161.     }
  163.     for (i = 14; i >= 0; --i) {
  164. short *x1 = &xk[i];
  165. short *x2 = &xk[-i];
  166. FLOAT8 w;
  168. s = x2[270]; t = x1[240];
  169. w = *wp++; s += x2[334] * w; t += x1[176] * w;
  170. w = *wp++; s += x2[398] * w; t += x1[112] * w;
  171. w = *wp++; s += x2[462] * w; t += x1[ 48] * w;
  172. w = *wp++; s += x2[ 14] * w; t += x1[496] * w;
  173. w = *wp++; s += x2[ 78] * w; t += x1[432] * w;
  174. w = *wp++; s += x2[142] * w; t += x1[368] * w;
  175. w = *wp++; s += x2[206] * w; t += x1[304] * w;
  177. w = *wp++; s += x1[ 16] * w; t -= x2[494] * w;
  178. w = *wp++; s += x1[ 80] * w; t -= x2[430] * w;
  179. w = *wp++; s += x1[144] * w; t -= x2[366] * w;
  180. w = *wp++; s += x1[208] * w; t -= x2[302] * w;
  181. w = *wp++; s -= x1[272] * w; t += x2[238] * w;
  182. w = *wp++; s -= x1[336] * w; t += x2[174] * w;
  183. w = *wp++; s -= x1[400] * w; t += x2[110] * w;
  184. w = *wp++; s -= x1[464] * w; t += x2[ 46] * w;
  186. in[30 - i] = s;
  187. in[i] = t;
  188.     }
  190.     {
  191. s  = xk[239];
  192. s += xk[175] * *wp++;
  193. s += xk[111] * *wp++;
  194. s += xk[ 47] * *wp++;
  195. s -= xk[303] * *wp++;
  196. s -= xk[367] * *wp++;
  197. s -= xk[431] * *wp++;
  198. s -= xk[495] * *wp++;
  199. /* in[-1] = s;  */
  200.     }
  202.     in++;
  203.     wp = &mm[0][0];
  204.     for (i = 15; i >= 0; --i) {
  205. int j;
  206. FLOAT8 s0 = s; /* mm[i][0] is always 1 */
  207. FLOAT8 s1 = t * *wp++;
  208. for (j = 14; j >= 0; j--) {
  209.     s0 += *wp++ * *in++;
  210.     s1 += *wp++ * *in++;
  211. }
  212. in -= 30;
  213. d[i     ] = s0 + s1;
  214. d[31 - i] = s0 - s1;
  215.     }
  216. }
  219. /*-------------------------------------------------------------------*/
  220. /*                                                                   */
  221. /*   Function: Calculation of the MDCT                               */
  222. /*   In the case of long blocks (type 0,1,3) there are               */
  223. /*   36 coefficents in the time domain and 18 in the frequency       */
  224. /*   domain.                                                         */
  225. /*   In the case of short blocks (type 2) there are 3                */
  226. /*   transformations with short length. This leads to 12 coefficents */
  227. /*   in the time and 6 in the frequency domain. In this case the     */
  228. /*   results are stored side by side in the vector out[].            */
  229. /*                                                                   */
  230. /*   New layer3                                                      */
  231. /*                                                                   */
  232. /*-------------------------------------------------------------------*/
  234. static void mdct_short(FLOAT8 *out, FLOAT8 *in)
  235. {
  236.     int m;
  237.     for (m = NS / 2 - 1; m >= 0; --m) {
  238. int l;
  239. FLOAT8 a0, a1, a2, a3, a4, a5;
  240. a0 = cos_s[m][0];
  241. a1 = cos_s[m][1];
  242. a2 = cos_s[m][2];
  243. a3 = cos_s[m][3];
  244. a4 = cos_s[m][4];
  245. a5 = cos_s[m][5];
  246. for (l = 2; l >= 0; l--) {
  247.     out[3 * m + l] =
  248. a0 * in[6 * l    ] +
  249. a1 * in[6 * l + 1] +
  250. a2 * in[6 * l + 2] +
  251. a3 * in[6 * l + 3] +
  252. a4 * in[6 * l + 4] +
  253. a5 * in[6 * l + 5];
  254. }
  255.     }
  256. }
  258. static void mdct_long(FLOAT8 *out, FLOAT8 *in)
  259. {
  260.     FLOAT8 s0, s1, s2, s3, s4, s5;
  261.     int j = sizeof(all) / sizeof(int) - 1;
  262.     FLOAT8 *cos_l0 = cos_l;
  263.     do {
  264. out[all[j]] =
  265.     in[ 0] * cos_l0[ 0] +
  266.     in[ 1] * cos_l0[ 1] +
  267.     in[ 2] * cos_l0[ 2] +
  268.     in[ 3] * cos_l0[ 3] +
  269.     in[ 4] * cos_l0[ 4] +
  270.     in[ 5] * cos_l0[ 5] +
  271.     in[ 6] * cos_l0[ 6] +
  272.     in[ 7] * cos_l0[ 7] +
  273.     in[ 8] * cos_l0[ 8] +
  274.     in[ 9] * cos_l0[ 9] +
  275.     in[10] * cos_l0[10] +
  276.     in[11] * cos_l0[11] +
  277.     in[12] * cos_l0[12] +
  278.     in[13] * cos_l0[13] +
  279.     in[14] * cos_l0[14] +
  280.     in[15] * cos_l0[15] +
  281.     in[16] * cos_l0[16] +
  282.     in[17] * cos_l0[17];
  283. cos_l0 += 18;
  284.     } while (--j >= 0);
  286.     s0 = in[0] + in[ 5] + in[15];
  287.     s1 = in[1] + in[ 4] + in[16];
  288.     s2 = in[2] + in[ 3] + in[17];
  289.     s3 = in[6] - in[ 9] + in[14];
  290.     s4 = in[7] - in[10] + in[13];
  291.     s5 = in[8] - in[11] + in[12];
  293.     /* 16 */
  294.     out[16] =
  295. s0 * cos_l0[0] + s1 * cos_l0[1] + s2 * cos_l0[2] +
  296. s3 * cos_l0[3] + s4 * cos_l0[4] + s5 * cos_l0[5];
  297.     cos_l0 += 6;
  299.     /* 10 */
  300.     out[10] =
  301. s0 * cos_l0[0] + s1 * cos_l0[1] + s2 * cos_l0[2] +
  302. s3 * cos_l0[3] + s4 * cos_l0[4] + s5 * cos_l0[5];
  303.     cos_l0 += 6;
  305.     /* 7 */
  306.     out[7] =
  307. s0 * cos_l0[0] + s1 * cos_l0[1] + s2 * cos_l0[2] +
  308. s3 * cos_l0[3] + s4 * cos_l0[4] + s5 * cos_l0[5];
  309.     cos_l0 += 6;
  311.     /* 1 */
  312.     out[1] =
  313. s0 * cos_l0[0] + s1 * cos_l0[1] + s2 * cos_l0[2] +
  314. s3 * cos_l0[3] + s4 * cos_l0[4] + s5 * cos_l0[5];
  315.     cos_l0 += 6;
  317.     s0 = s0 - s1 + s5;
  318.     s2 = s2 - s3 - s4;
  319.     /* 13 */
  320.     out[13] = s0 * cos_l0[0] + s2 * cos_l0[1];
  322.     /* 4 */
  323.     out[4] = s0 * cos_l0[2] + s2 * cos_l0[3];
  324. }
  327. void mdct_sub48(lame_global_flags *gfp,
  328.     short *w0, short *w1,
  329.     FLOAT8 mdct_freq[2][2][576],
  330.     III_side_info_t *l3_side)
  331. {
  332.     int gr, k, ch;
  333.     short *wk;
  334.     static int init = 0;
  336.     if ( init == 0 ) {
  337.         void mdct_init48(void);
  338. mdct_init48();
  339. init++;
  340.     }
  342.     wk = w0;
  343.     /* thinking cache performance, ch->gr loop is better than gr->ch loop */
  344.     for (ch = 0; ch < gfp->stereo; ch++) {
  345. for (gr = 0; gr < gfp->mode_gr; gr++) {
  346.     int band;
  347.     FLOAT8 *mdct_enc = mdct_freq[gr][ch];
  348.     gr_info *gi = &(l3_side->gr[gr].ch[ch].tt);
  349.     FLOAT8 *samp = sb_sample[ch][1 - gr][0];
  351.     for (k = 0; k < 18 / 2; k++) {
  352. window_subband(wk, samp, work);
  353. window_subband(wk + 32, samp + 32, work);
  354. /*
  355.  * Compensate for inversion in the analysis filter
  356.  */
  357. for (band = 1; band < 32; band += 2)
  358.     samp[band + 32] *= -1.0;
  359. samp += 64;
  360. wk += 64;
  361.     }
  364.     /* apply filters on the polyphase filterbank outputs */
  365.     /* bands <= gfp->highpass_band will be zeroed out below */
  366.     /* bands >= gfp->lowpass_band  will be zeroed out below */
  367.     if (gfp->filter_type==0) {
  368.       FLOAT8 amp,freq;
  369.       for (band=gfp->highpass_band+1;  band < gfp->lowpass_band ; band++) { 
  370. freq = band/31.0;
  371. if (gfp->lowpass1 < freq && freq < gfp->lowpass2) {
  372.   amp = cos((PI/2)*(gfp->lowpass1-freq)/(gfp->lowpass2-gfp->lowpass1));
  373.   for (k=0; k<18; k++) 
  374.     sb_sample[ch][1-gr][k][band]*=amp;
  375. }
  376. if (gfp->highpass1 < freq && freq < gfp->highpass2) {
  377.   amp = cos((PI/2)*(gfp->highpass2-freq)/(gfp->highpass2-gfp->highpass1));
  378.   for (k=0; k<18; k++) 
  379.     sb_sample[ch][1-gr][k][band]*=amp;
  380. }
  381.       }
  382.     }
  383.     
  386.     /*
  387.      * Perform imdct of 18 previous subband samples
  388.      * + 18 current subband samples
  389.      */
  390.     for (band = 0; band < 32; band++, mdct_enc += 18) 
  391.               {
  392. int type = gi->block_type;
  393. #ifdef ALLOW_MIXED
  394. if (gi->mixed_block_flag && band < 2)
  395.     type = 0;
  396. #endif
  397. if (band >= gfp->lowpass_band || band <= gfp->highpass_band) {
  398.     memset((char *)mdct_enc,0,18*sizeof(FLOAT8));
  399. }else {
  400.   if (type == SHORT_TYPE) {
  401.     for (k = 2; k >= 0; --k) {
  402.       FLOAT8 w1 = win[SHORT_TYPE][k];
  403.       work[k] =
  404. sb_sample[ch][gr][k+6][band] * w1 -
  405. sb_sample[ch][gr][11-k][band];
  406.       work[k+3] =
  407. sb_sample[ch][gr][k+12][band] +
  408. sb_sample[ch][gr][17-k][band] * w1;
  409.       
  410.       work[k+6] =
  411. sb_sample[ch][gr][k+12][band] * w1 -
  412. sb_sample[ch][gr][17-k][band];
  413.       work[k+9] =
  414. sb_sample[ch][1-gr][k][band] +
  415. sb_sample[ch][1-gr][5-k][band] * w1;
  416.       
  417.       work[k+12] =
  418. sb_sample[ch][1-gr][k][band] * w1 -
  419. sb_sample[ch][1-gr][5-k][band];
  420.       work[k+15] =
  421. sb_sample[ch][1-gr][k+6][band] +
  422. sb_sample[ch][1-gr][11-k][band] * w1;
  423.     }
  424.     mdct_short(mdct_enc, work);
  425.   } else {
  426.     for (k = 8; k >= 0; --k) {
  427.       work[k] =
  428. win[type][k  ] * sb_sample[ch][gr][k   ][band]
  429. - win[type][k+9] * sb_sample[ch][gr][17-k][band];
  430.       
  431.       work[9+k] =
  432. win[type][k+18] * sb_sample[ch][1-gr][k   ][band]
  433. + win[type][k+27] * sb_sample[ch][1-gr][17-k][band];
  434.     }
  435.     mdct_long(mdct_enc, work);
  436.   }
  437. }
  440. /*
  441.   Perform aliasing reduction butterfly
  442. */
  443. if (type != SHORT_TYPE) {
  444.   if (band == 0)
  445.     continue;
  446.   for (k = 7; k >= 0; --k) {
  447.     FLOAT8 bu,bd;
  448.     bu = mdct_enc[k] * ca[k] + mdct_enc[-1-k] * cs[k];
  449.     bd = mdct_enc[k] * cs[k] - mdct_enc[-1-k] * ca[k];
  450.     
  451.     mdct_enc[-1-k] = bu;
  452.     mdct_enc[k]    = bd;
  453.   }
  454. }
  455.       }
  456. }
  457. wk = w1;
  458. if (gfp->mode_gr == 1) {
  459.     memcpy(sb_sample[ch][0], sb_sample[ch][1], 576 * sizeof(FLOAT8));
  460. }
  461.     }
  462. }
  466. void mdct_init48(void)
  467. {
  468.     int i, k, m;
  469.     FLOAT8 sq;
  470.     FLOAT8 max;
  472.     /* prepare the aliasing reduction butterflies */
  473.     for (k = 0; k < 8; k++) {
  474. /*
  475.   This is table B.9: coefficients for aliasing reduction
  476.   */
  477. static const FLOAT8 c[8] = {
  478.     -0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142, -0.0037
  479. };
  480. sq = 1.0 + c[k] * c[k];
  481. sq = sqrt(sq);
  482. ca[k] = c[k] / sq;
  483. cs[k] = 1.0 / sq;
  484.     }
  486.     /* type 0*/
  487.     for (i = 0; i < 36; i++)
  488. win[0][i] = sin(PI/36 * (i + 0.5));
  489.     /* type 1*/
  490.     for (i = 0; i < 18; i++) 
  491. win[1][i] = win[0][i];
  492.     for (; i < 24; i++)
  493. win[1][i] = 1.0;
  494.     for (; i < 30; i++)
  495. win[1][i] = cos(PI/12 * (i + 0.5));
  496.     for (; i < 36; i++)
  497. win[1][i] = 0.0;
  498.     /* type 3*/
  499.     for (i = 0; i < 36; i++)
  500. win[3][i] = win[1][35 - i];
  502.     sq = 4.0 / NL;
  503.     {
  504. FLOAT8 *cos_l0 = cos_l;
  505. static const int d3[] = {1,7,10,16};
  506. static const int d9[] = {4,13};
  508. int j = sizeof(all) / sizeof(int) - 1;
  509. do {
  510.     m = all[j];
  511.     for (k = 0; k < NL / 4; k++) {
  512. *cos_l0++ = sq *
  513.     cos((PI / (4 * NL)) * (2 * m + 1) * (4 * k + 2 + NL));
  514.     }
  515.     for (k = 0; k < NL / 4; k++) {
  516. *cos_l0++ = sq *
  517.     cos((PI / (4 * NL)) * (2 * m + 1) * (4 * k + 2 + NL * 3));
  518.     }
  519. } while (--j >= 0);
  521. j = sizeof(d3) / sizeof(int) - 1;
  522. do {
  523.     m = d3[j];
  524.     for (k = 0; k < 3; k++) {
  525. *cos_l0++ = sq *
  526.     cos((PI / (4 * NL)) * (2 * m + 1) * (4 * k + 2 + NL));
  527.     }
  528.     for (k = 6; k < 9; k++) {
  529. *cos_l0++ = sq *
  530.     cos((PI / (4 * NL)) * (2 * m + 1) * (4 * k + 2 + NL));
  531.     }
  532. } while (--j >= 0);
  534. j = sizeof(d9) / sizeof(int) - 1;
  535. do {
  536.     m = d9[j];
  537.     *cos_l0++ = sq *
  538. cos((PI / (4 * NL)) * (2 * m + 1) * (2 + NL));
  539.     *cos_l0++ = sq *
  540. cos((PI / (4 * NL)) * (2 * m + 1) * (4 * 2 + 2 + NL));
  541. } while (--j >= 0);
  542.     }
  544.     max = enwindow[256 - 8];
  545.     {
  546. FLOAT8 *wp = enwindow;
  547. FLOAT8 *wr = enwindow;
  548. FLOAT8 mmax[32 - 1];
  550. {
  551.     FLOAT8 w = *wp++;
  552.     mmax[15] = w / max;
  554.     for (k = 0; k < 7; k++) {
  555. *wr++ = *wp++ / w;
  556.     }
  557. }
  559. for (i = 14; i >= 0; --i) {
  560.     FLOAT8 w = *wp++;
  561.     mmax[i] = mmax[30 - i] = w / max;
  563.     for (k = 0; k < 15; k++) {
  564. *wr++ = *wp++ / w;
  565.     }
  566. }
  568. {
  569.     wp++;
  570.     for (k = 0; k < 7; k++) {
  571. *wr++ = *wp++ / max;
  572.     }
  573. }
  575. wp = &mm[0][0];
  576. for (i = 15; i >= 0; --i) {
  577.     for (k = 1; k < 32; k++) {
  578. *wp++ = cos((2 * i + 1) * k * PI/64) * mmax[k - 1];
  579.     }
  580. }
  581.     }
  583.     /* swap window data*/
  584.     for (k = 0; k < 4; k++) {
  585. FLOAT8 a;
  587. a = win[0][17-k];
  588. win[0][17-k] = win[0][9+k];
  589. win[0][9+k] = a;
  591. a = win[0][35-k];
  592. win[0][35-k] = win[0][27+k];
  593. win[0][27+k] = a;
  595. a = win[1][17-k];
  596. win[1][17-k] = win[1][9+k];
  597. win[1][9+k] = a;
  599. a = win[1][35-k];
  600. win[1][35-k] = win[1][27+k];
  601. win[1][27+k] = a;
  603. a = win[3][17-k];
  604. win[3][17-k] = win[3][9+k];
  605. win[3][9+k] = a;
  607. a = win[3][35-k];
  608. win[3][35-k] = win[3][27+k];
  609. win[3][27+k] = a;
  610.     }
  612.     for (i = 0; i < 36; i++) {
  613. win[0][i] *= max / SCALE;
  614. win[1][i] *= max / SCALE;
  615. win[3][i] *= max / SCALE;
  616.     }
  618.     /* type 2(short)*/
  619.     sq = 4.0 / NS;
  620.     for (i = 0; i < NS / 4; i++) {
  621. FLOAT8 w2 = cos(PI/12 * (i + 0.5)) * max / SCALE * sq;
  622. win[SHORT_TYPE][i] = tan(PI/12 * (i + 0.5));
  624. for (m = 0; m < NS / 2; m++) {
  625.     cos_s[m][i] = w2 *
  626. cos((PI / (4 * NS)) * (2 * m + 1) * (4 * i + 2 + NS));
  627.     cos_s[m][i + NS / 4] = w2 *
  628. cos((PI / (4 * NS)) * (2 * m + 1) * (4 * i + 2 + NS * 3));
  629. }
  630.     }
  631. }