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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
decode.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：29k
源码类别：

多媒体编程

开发平台：

Visual C++

decode.c：源码内容
  1. #include <math.h>
  2. #include <stdlib.h>
  3. #include "common.h"
  4. #include "decode.h"
  5. #include "huffman.h"
  7. void decode_info(Bit_stream_struc *bs, frame_params *fr_ps)
  8. {
  9.     layer *hdr = fr_ps->header;
  11.     hdr->version = get1bit(bs);
  12.     hdr->lay = 4-getbits(bs,2);
  13.     hdr->error_protection = !get1bit(bs); /* 错误保护. TRUE/FALSE */
  14.     hdr->bitrate_index = getbits(bs,4);
  15.     hdr->sampling_frequency = getbits(bs,2);
  16.     hdr->padding = get1bit(bs);
  17.     hdr->extension = get1bit(bs);
  18.     hdr->mode = getbits(bs,2);
  19.     hdr->mode_ext = getbits(bs,2);
  20.     hdr->copyright = get1bit(bs);
  21.     hdr->original = get1bit(bs);
  22.     hdr->emphasis = getbits(bs,2);
  23. }
  25. void III_get_side_info(Bit_stream_struc *bs, III_side_info_t *si, frame_params *fr_ps)
  26. {
  27. int ch, gr, i;
  28. int stereo = fr_ps->stereo;
  30. si->main_data_begin = getbits(bs, 9);
  31. if (stereo == 1)
  32. si->private_bits = getbits(bs,5);
  33. else
  34. si->private_bits = getbits(bs,3);
  36. for (ch=0; ch<stereo; ch++)
  37. for (i=0; i<4; i++)
  38. si->ch[ch].scfsi[i] = get1bit(bs);
  40. for (gr=0; gr<2; gr++) {
  41. for (ch=0; ch<stereo; ch++) {
  42. si->ch[ch].gr[gr].part2_3_length = getbits(bs, 12);
  43. si->ch[ch].gr[gr].big_values = getbits(bs, 9);
  44. si->ch[ch].gr[gr].global_gain = getbits(bs, 8);
  45. si->ch[ch].gr[gr].scalefac_compress = getbits(bs, 4);
  46. si->ch[ch].gr[gr].window_switching_flag = get1bit(bs);
  47. if (si->ch[ch].gr[gr].window_switching_flag) {
  48. si->ch[ch].gr[gr].block_type = getbits(bs, 2);
  49. si->ch[ch].gr[gr].mixed_block_flag = get1bit(bs);
  50. for (i=0; i<2; i++)
  51. si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
  52. for (i=0; i<3; i++)
  53. si->ch[ch].gr[gr].subblock_gain[i] = getbits(bs, 3);
  55. /* Set region_count parameters since they are implicit in this case. */
  57. if (si->ch[ch].gr[gr].block_type == 0) {
  58. printf("Side info bad: block_type == 0 in split block.n");
  59. exit(0);
  60. }
  61. else if (si->ch[ch].gr[gr].block_type == 2
  62. && si->ch[ch].gr[gr].mixed_block_flag == 0)
  63. si->ch[ch].gr[gr].region0_count = 8; /* MI 9; */
  64. else si->ch[ch].gr[gr].region0_count = 7; /* MI 8; */
  65. si->ch[ch].gr[gr].region1_count = 20 - si->ch[ch].gr[gr].region0_count;
  66. }
  67. else {
  68. for (i=0; i<3; i++)
  69. si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
  70. si->ch[ch].gr[gr].region0_count = getbits(bs, 4);
  71. si->ch[ch].gr[gr].region1_count = getbits(bs, 3);
  72. si->ch[ch].gr[gr].block_type = 0;
  73. }
  74. si->ch[ch].gr[gr].preflag = get1bit(bs);
  75. si->ch[ch].gr[gr].scalefac_scale = get1bit(bs);
  76. si->ch[ch].gr[gr].count1table_select = get1bit(bs);
  77.          }
  78. }
  79. }
  82. struct {
  83. int l[5];
  84. int s[3];
  85. } sfbtable = {
  86. {0, 6, 11, 16, 21},
  87. {0, 6, 12}
  88. };
  89. int slen[2][16]={
  90. {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  91. {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
  92. };
  93. struct {
  94. int l[23];
  95. int s[14];
  96. } sfBandIndex[3]= {
  97. {{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  98. {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
  99. {{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  100. {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
  101. {{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  102. {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}
  103. };
  105. void III_get_scale_factors(III_scalefac_t *scalefac, III_side_info_t *si, int gr, int ch, frame_params *fr_ps)
  106. {
  107. int sfb, i, window;
  108. struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  110. if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  111. if (gr_info->mixed_block_flag) { /* MIXED */ /* NEW - ag 11/25 */
  112. for (sfb = 0; sfb < 8; sfb++)
  113. (*scalefac)[ch].l[sfb] = hgetbits(
  114. slen[0][gr_info->scalefac_compress]);
  115. for (sfb = 3; sfb < 6; sfb++)
  116. for (window=0; window<3; window++)
  117. (*scalefac)[ch].s[window][sfb] = hgetbits(
  118. slen[0][gr_info->scalefac_compress]);
  119. for (sfb = 6; sfb < 12; sfb++)
  120. for (window=0; window<3; window++)
  121. (*scalefac)[ch].s[window][sfb] = hgetbits(
  122. slen[1][gr_info->scalefac_compress]);
  123. for (sfb=12,window=0; window<3; window++)
  124. (*scalefac)[ch].s[window][sfb] = 0;
  125. }
  126. else {  /* SHORT*/
  127. for (i=0; i<2; i++)
  128. for (sfb = sfbtable.s[i]; sfb < sfbtable.s[i+1]; sfb++)
  129. for (window=0; window<3; window++)
  130. (*scalefac)[ch].s[window][sfb] = hgetbits(
  131. slen[i][gr_info->scalefac_compress]);
  132. for (sfb=12,window=0; window<3; window++)
  133. (*scalefac)[ch].s[window][sfb] = 0;
  134. }
  135. }
  136. else {   /* LONG types 0,1,3 */
  137. for (i=0; i<4; i++) {
  138. if ((si->ch[ch].scfsi[i] == 0) || (gr == 0))
  139. for (sfb = sfbtable.l[i]; sfb < sfbtable.l[i+1]; sfb++)
  140. (*scalefac)[ch].l[sfb] = hgetbits(
  141. slen[(i<2)?0:1][gr_info->scalefac_compress]);
  142. }
  143. (*scalefac)[ch].l[22] = 0;
  144. }
  145. }
  147. /* 已经在 huffman.c中声明
  148. struct huffcodetab ht[HTN];
  149. */
  150. int huffman_initialized = FALSE;
  152. void initialize_huffman()
  153. {
  154. FILE *fi;
  156. if (huffman_initialized) return;
  157. if (!(fi = OpenTableFile("huffdec.txt") )) {
  158. printf("Please check huffman table 'huffdec.txt'n");
  159. exit(1);
  160. }
  162. if (fi==NULL) {
  163. fprintf(stderr,"decoder table open errorn");
  164. exit(3);
  165. }
  167. if (read_decoder_table(fi) != HTN) {
  168. fprintf(stderr,"decoder table read errorn");
  169. exit(4);
  170. }
  171. huffman_initialized = TRUE;
  172. }
  175. void III_hufman_decode(long int is[SBLIMIT][SSLIMIT], III_side_info_t *si, int ch, int gr, int part2_start, frame_params *fr_ps)
  176. {
  177.    int i, x, y;
  178.    int v, w;
  179.    struct huffcodetab *h;
  180.    int region1Start;
  181.    int region2Start;
  182.    int bt = (*si).ch[ch].gr[gr].window_switching_flag && ((*si).ch[ch].gr[gr].block_type == 2);
  184.    initialize_huffman();
  186.    /* 查找区域边界 */
  188.    if ( ((*si).ch[ch].gr[gr].window_switching_flag) &&
  189.         ((*si).ch[ch].gr[gr].block_type == 2) ) {
  191.       /* Region2. */
  193.       region1Start = 36;  /* sfb[9/3]*3=36 */
  194.       region2Start = 576; /* No Region2 for short block case. */
  195.    }
  198.    else {          /* 查找长块情况下的区域边界. */
  200.       region1Start = sfBandIndex[fr_ps->header->sampling_frequency]
  201.                            .l[(*si).ch[ch].gr[gr].region0_count + 1]; /* MI */
  202.       region2Start = sfBandIndex[fr_ps->header->sampling_frequency]
  203.                               .l[(*si).ch[ch].gr[gr].region0_count +
  204.                               (*si).ch[ch].gr[gr].region1_count + 2]; /* MI */
  205.       }
  208.    /* 读取大值区域Read bigvalues area. */
  209.    for (i=0; i<(*si).ch[ch].gr[gr].big_values*2; i+=2) {
  210.       if      (i<region1Start) h = &ht[(*si).ch[ch].gr[gr].table_select[0]];
  211.       else if (i<region2Start) h = &ht[(*si).ch[ch].gr[gr].table_select[1]];
  212.            else                h = &ht[(*si).ch[ch].gr[gr].table_select[2]];
  213.       huffman_decoder(h, &x, &y, &v, &w);
  214.       is[i/SSLIMIT][i%SSLIMIT] = x;
  215.       is[(i+1)/SSLIMIT][(i+1)%SSLIMIT] = y;
  216.       }
  218.    /* Read count1 area. */
  219.    h = &ht[(*si).ch[ch].gr[gr].count1table_select+32];
  220.    while ((hsstell() < part2_start + (*si).ch[ch].gr[gr].part2_3_length ) &&
  221.      ( i < SSLIMIT*SBLIMIT )) {
  222.       huffman_decoder(h, &x, &y, &v, &w);
  223.       is[i/SSLIMIT][i%SSLIMIT] = v;
  224.       is[(i+1)/SSLIMIT][(i+1)%SSLIMIT] = w;
  225.       is[(i+2)/SSLIMIT][(i+2)%SSLIMIT] = x;
  226.       is[(i+3)/SSLIMIT][(i+3)%SSLIMIT] = y;
  227.       i += 4;
  228.       }
  230.    if (hsstell() > part2_start + (*si).ch[ch].gr[gr].part2_3_length)
  231.    {  i -=4;
  232.       rewindNbits(hsstell()-part2_start - (*si).ch[ch].gr[gr].part2_3_length);
  233.    }
  235.    /* Dismiss stuffing Bits */
  236.    if ( hsstell() < part2_start + (*si).ch[ch].gr[gr].part2_3_length )
  237.       hgetbits( part2_start + (*si).ch[ch].gr[gr].part2_3_length - hsstell());
  239.    /* Zero out rest. */
  240.    for (; i<SSLIMIT*SBLIMIT; i++)
  241.       is[i/SSLIMIT][i%SSLIMIT] = 0;
  242. }
  245. int pretab[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
  247. void III_dequantize_sample(long int is[SBLIMIT][SSLIMIT], double xr[SBLIMIT][SSLIMIT], III_scalefac_t *scalefac, struct gr_info_s *gr_info, int ch, frame_params *fr_ps)
  248. {
  249. int ss,sb,cb=0,sfreq=fr_ps->header->sampling_frequency;
  250. int stereo = fr_ps->stereo;
  251. int next_cb_boundary, cb_begin, cb_width, sign;
  253. /* choose correct scalefactor band per block type, initalize boundary */
  255. if (gr_info->window_switching_flag && (gr_info->block_type == 2) )
  256. if (gr_info->mixed_block_flag)
  257. next_cb_boundary=sfBandIndex[sfreq].l[1];  /* LONG blocks: 0,1,3 */
  258. else {
  259. next_cb_boundary=sfBandIndex[sfreq].s[1]*3; /* pure SHORT block */
  260. cb_width = sfBandIndex[sfreq].s[1];
  261. cb_begin = 0;
  262. }
  263. else
  264. next_cb_boundary=sfBandIndex[sfreq].l[1];  /* LONG blocks: 0,1,3 */
  266. /* apply formula per block type */
  267. for (sb=0 ; sb < SBLIMIT ; sb++) {
  268. for (ss=0 ; ss < SSLIMIT ; ss++) {
  269. if ( (sb*18)+ss == next_cb_boundary) { /* Adjust critical band boundary */
  270. if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  271. if (gr_info->mixed_block_flag) {
  272. if (((sb*18)+ss) == sfBandIndex[sfreq].l[8])  {
  273. next_cb_boundary=sfBandIndex[sfreq].s[4]*3;
  274. cb = 3;
  275. cb_width = sfBandIndex[sfreq].s[cb+1] -
  276. sfBandIndex[sfreq].s[cb];
  277. cb_begin = sfBandIndex[sfreq].s[cb]*3;
  278. }
  279. else if (((sb*18)+ss) < sfBandIndex[sfreq].l[8])
  280. next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  281. else {
  282. next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1]*3;
  283. cb_width = sfBandIndex[sfreq].s[cb+1] -
  284. sfBandIndex[sfreq].s[cb];
  285. cb_begin = sfBandIndex[sfreq].s[cb]*3;
  286. }
  287. }
  288. else {
  289. next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1]*3;
  290. cb_width = sfBandIndex[sfreq].s[cb+1] -
  291. sfBandIndex[sfreq].s[cb];
  292. cb_begin = sfBandIndex[sfreq].s[cb]*3;
  293. }
  294. }
  295.             else /* long blocks */
  296.            next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  297. }
  299. /* Compute overall (global) scaling. */
  300. xr[sb][ss] = pow( 2.0 , (0.25 * (gr_info->global_gain - 210.0)));
  302. /* Do long/short dependent scaling operations. */
  304. if (gr_info->window_switching_flag && (
  305. ((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0)) ||
  306. ((gr_info->block_type == 2) && gr_info->mixed_block_flag && (sb >= 2)) )) {
  308. xr[sb][ss] *= pow(2.0, 0.25 * -8.0 *
  309. gr_info->subblock_gain[(((sb*18)+ss) - cb_begin)/cb_width]);
  310. xr[sb][ss] *= pow(2.0, 0.25 * -2.0 * (1.0+gr_info->scalefac_scale)
  311. * (*scalefac)[ch].s[(((sb*18)+ss) - cb_begin)/cb_width][cb]);
  312. }
  313. else {   /* LONG block types 0,1,3 & 1st 2 subbands of switched blocks */
  314. xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info->scalefac_scale)
  315. * ((*scalefac)[ch].l[cb]
  316. + gr_info->preflag * pretab[cb]));
  317. }
  319. /* Scale quantized value. */
  321. sign = (is[sb][ss]<0) ? 1 : 0;
  322. xr[sb][ss] *= pow( (double) abs(is[sb][ss]), ((double)4.0/3.0) );
  323. if (sign) xr[sb][ss] = -xr[sb][ss];
  324. }
  325. }
  326. }
  329. void III_reorder(double xr[SBLIMIT][SSLIMIT], double ro[SBLIMIT][SSLIMIT], struct gr_info_s *gr_info, frame_params *fr_ps)
  330. {
  331.    int sfreq=fr_ps->header->sampling_frequency;
  332.    int sfb, sfb_start, sfb_lines;
  333.    int sb, ss, window, freq, src_line, des_line;
  335.    for(sb=0;sb<SBLIMIT;sb++)
  336.       for(ss=0;ss<SSLIMIT;ss++)
  337.          ro[sb][ss] = 0;
  339.    if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  340.       if (gr_info->mixed_block_flag) {
  341.          /* NO REORDER FOR LOW 2 SUBBANDS */
  342.          for (sb=0 ; sb < 2 ; sb++)
  343.             for (ss=0 ; ss < SSLIMIT ; ss++) {
  344.                ro[sb][ss] = xr[sb][ss];
  345.             }
  346.          /* REORDERING FOR REST SWITCHED SHORT */
  347.          for(sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
  348.             sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
  349.             sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  350.             (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  351.                for(window=0; window<3; window++)
  352.                   for(freq=0;freq<sfb_lines;freq++) {
  353.                      src_line = sfb_start*3 + window*sfb_lines + freq;
  354.                      des_line = (sfb_start*3) + window + (freq*3);
  355.                      ro[des_line/SSLIMIT][des_line%SSLIMIT] =
  356.                                     xr[src_line/SSLIMIT][src_line%SSLIMIT];
  357.                }
  358.       }
  359.       else {  /* pure short */
  360.          for(sfb=0,sfb_start=0,sfb_lines=sfBandIndex[sfreq].s[1];
  361.             sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  362.             (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  363.                for(window=0; window<3; window++)
  364.                   for(freq=0;freq<sfb_lines;freq++) {
  365.                      src_line = sfb_start*3 + window*sfb_lines + freq;
  366.                      des_line = (sfb_start*3) + window + (freq*3);
  367.                      ro[des_line/SSLIMIT][des_line%SSLIMIT] =
  368.                                     xr[src_line/SSLIMIT][src_line%SSLIMIT];
  369.                }
  370.       }
  371.    }
  372.    else {   /*long blocks */
  373.       for (sb=0 ; sb < SBLIMIT ; sb++)
  374.          for (ss=0 ; ss < SSLIMIT ; ss++)
  375.             ro[sb][ss] = xr[sb][ss];
  376.    }
  377. }
  380. void III_stereo(double xr[2][SBLIMIT][SSLIMIT], double lr[2][SBLIMIT][SSLIMIT], III_scalefac_t *scalefac, struct gr_info_s *gr_info, frame_params *fr_ps)
  381. {
  382.    int sfreq = fr_ps->header->sampling_frequency;
  383.    int stereo = fr_ps->stereo;
  384.    int ms_stereo = (fr_ps->header->mode == MPG_MD_JOINT_STEREO) &&
  385.                    (fr_ps->header->mode_ext & 0x2);
  386.    int i_stereo = (fr_ps->header->mode == MPG_MD_JOINT_STEREO) &&
  387.                   (fr_ps->header->mode_ext & 0x1);
  388.    int sfb;
  389.    int i,j,sb,ss,ch,is_pos[576];
  390.    double is_ratio[576];
  392.    /* intialization */
  393.    for ( i=0; i<576; i++ )
  394.       is_pos[i] = 7;
  396.    if ((stereo == 2) && i_stereo )
  397.    {  if (gr_info->window_switching_flag && (gr_info->block_type == 2))
  398.       {  if( gr_info->mixed_block_flag )
  399.          {  int max_sfb = 0;
  401.             for ( j=0; j<3; j++ )
  402.             {  int sfbcnt;
  403.                sfbcnt = 2;
  404.                for( sfb=12; sfb >=3; sfb-- )
  405.                {  int lines;
  406.                   lines = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  407.                   i = 3*sfBandIndex[sfreq].s[sfb] + (j+1) * lines - 1;
  408.                   while ( lines > 0 )
  409.                   {  if ( xr[1][i/SSLIMIT][i%SSLIMIT] != 0.0 )
  410.                      {  sfbcnt = sfb;
  411.                         sfb = -10;
  412.                         lines = -10;
  413.                      }
  414.                      lines--;
  415.                      i--;
  416.                   }
  417.                }
  418.                sfb = sfbcnt + 1;
  420.                if ( sfb > max_sfb )
  421.                   max_sfb = sfb;
  423.                while( sfb<12 )
  424.                {  sb = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  425.                   i = 3*sfBandIndex[sfreq].s[sfb] + j * sb;
  426.                   for ( ; sb > 0; sb--)
  427.                   {  is_pos[i] = (*scalefac)[1].s[j][sfb];
  428.                      if ( is_pos[i] != 7 )
  429.                         is_ratio[i] = tan( is_pos[i] * (PI / 12));
  430.                      i++;
  431.                   }
  432.                   sfb++;
  433.                }
  434.                sb = sfBandIndex[sfreq].s[11]-sfBandIndex[sfreq].s[10];
  435.                sfb = 3*sfBandIndex[sfreq].s[10] + j * sb;
  436.                sb = sfBandIndex[sfreq].s[12]-sfBandIndex[sfreq].s[11];
  437.                i = 3*sfBandIndex[sfreq].s[11] + j * sb;
  438.                for ( ; sb > 0; sb-- )
  439.                {  is_pos[i] = is_pos[sfb];
  440.                   is_ratio[i] = is_ratio[sfb];
  441.                   i++;
  442.                }
  443.              }
  444.              if ( max_sfb <= 3 )
  445.              {  i = 2;
  446.                 ss = 17;
  447.                 sb = -1;
  448.                 while ( i >= 0 )
  449.                 {  if ( xr[1][i][ss] != 0.0 )
  450.                    {  sb = i*18+ss;
  451.                       i = -1;
  452.                    } else
  453.                    {  ss--;
  454.                       if ( ss < 0 )
  455.                       {  i--;
  456.                          ss = 17;
  457.                       }
  458.                    }
  459.                 }
  460.                 i = 0;
  461.                 while ( sfBandIndex[sfreq].l[i] <= sb )
  462.                    i++;
  463.                 sfb = i;
  464.                 i = sfBandIndex[sfreq].l[i];
  465.                 for ( ; sfb<8; sfb++ )
  466.                 {  sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
  467.                    for ( ; sb > 0; sb--)
  468.                    {  is_pos[i] = (*scalefac)[1].l[sfb];
  469.                       if ( is_pos[i] != 7 )
  470.                          is_ratio[i] = tan( is_pos[i] * (PI / 12));
  471.                       i++;
  472.                    }
  473.                 }
  474.             }
  475.          } else
  476.          {  for ( j=0; j<3; j++ )
  477.             {  int sfbcnt;
  478.                sfbcnt = -1;
  479.                for( sfb=12; sfb >=0; sfb-- )
  480.                {  int lines;
  481.                   lines = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  482.                   i = 3*sfBandIndex[sfreq].s[sfb] + (j+1) * lines - 1;
  483.                   while ( lines > 0 )
  484.                   {  if ( xr[1][i/SSLIMIT][i%SSLIMIT] != 0.0 )
  485.                      {  sfbcnt = sfb;
  486.                         sfb = -10;
  487.                         lines = -10;
  488.                      }
  489.                      lines--;
  490.                      i--;
  491.                   }
  492.                }
  493.                sfb = sfbcnt + 1;
  494.                while( sfb<12 )
  495.                {  sb = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  496.                   i = 3*sfBandIndex[sfreq].s[sfb] + j * sb;
  497.                   for ( ; sb > 0; sb--)
  498.                   {  is_pos[i] = (*scalefac)[1].s[j][sfb];
  499.                      if ( is_pos[i] != 7 )
  500.                         is_ratio[i] = tan( is_pos[i] * (PI / 12));
  501.                      i++;
  502.                   }
  503.                   sfb++;
  504.                }
  506.                sb = sfBandIndex[sfreq].s[11]-sfBandIndex[sfreq].s[10];
  507.                sfb = 3*sfBandIndex[sfreq].s[10] + j * sb;
  508.                sb = sfBandIndex[sfreq].s[12]-sfBandIndex[sfreq].s[11];
  509.                i = 3*sfBandIndex[sfreq].s[11] + j * sb;
  510.                for ( ; sb > 0; sb-- )
  511.                {  is_pos[i] = is_pos[sfb];
  512.                   is_ratio[i] = is_ratio[sfb];
  513.                   i++;
  514.                }
  515.             }
  516.          }
  517.       } else
  518.       {  i = 31;
  519.          ss = 17;
  520.          sb = 0;
  521.          while ( i >= 0 )
  522.          {  if ( xr[1][i][ss] != 0.0 )
  523.             {  sb = i*18+ss;
  524.                i = -1;
  525.             } else
  526.             {  ss--;
  527.                if ( ss < 0 )
  528.                {  i--;
  529.                   ss = 17;
  530.                }
  531.             }
  532.          }
  533.          i = 0;
  534.          while ( sfBandIndex[sfreq].l[i] <= sb )
  535.             i++;
  536.          sfb = i;
  537.          i = sfBandIndex[sfreq].l[i];
  538.          for ( ; sfb<21; sfb++ )
  539.          {  sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
  540.             for ( ; sb > 0; sb--)
  541.             {  is_pos[i] = (*scalefac)[1].l[sfb];
  542.                if ( is_pos[i] != 7 )
  543.                   is_ratio[i] = tan( is_pos[i] * (PI / 12));
  544.                i++;
  545.             }
  546.          }
  547.          sfb = sfBandIndex[sfreq].l[20];
  548.          for ( sb = 576 - sfBandIndex[sfreq].l[21]; sb > 0; sb-- )
  549.          {  is_pos[i] = is_pos[sfb];
  550.             is_ratio[i] = is_ratio[sfb];
  551.             i++;
  552.          }
  553.       }
  554.    }
  556.    for(ch=0;ch<2;ch++)
  557.       for(sb=0;sb<SBLIMIT;sb++)
  558.          for(ss=0;ss<SSLIMIT;ss++)
  559.             lr[ch][sb][ss] = 0;
  561.    if (stereo==2)
  562.       for(sb=0;sb<SBLIMIT;sb++)
  563.          for(ss=0;ss<SSLIMIT;ss++) {
  564.             i = (sb*18)+ss;
  565.             if ( is_pos[i] == 7 ) {
  566.                if ( ms_stereo ) {
  567.                   lr[0][sb][ss] = (xr[0][sb][ss]+xr[1][sb][ss])/1.41421356;
  568.                   lr[1][sb][ss] = (xr[0][sb][ss]-xr[1][sb][ss])/1.41421356;
  569.                }
  570.                else {
  571.                   lr[0][sb][ss] = xr[0][sb][ss];
  572.                   lr[1][sb][ss] = xr[1][sb][ss];
  573.                }
  574.             }
  575.             else if (i_stereo ) {
  576.                lr[0][sb][ss] = xr[0][sb][ss] * (is_ratio[i]/(1+is_ratio[i]));
  577.                lr[1][sb][ss] = xr[0][sb][ss] * (1/(1+is_ratio[i]));
  578.             }
  579.             else {
  580.                printf("Error in streo processingn");
  581.             }
  582.          }
  583.    else  /* mono , bypass xr[0][][] to lr[0][][]*/
  584.       for(sb=0;sb<SBLIMIT;sb++)
  585.          for(ss=0;ss<SSLIMIT;ss++)
  586.             lr[0][sb][ss] = xr[0][sb][ss];
  588. }
  591. double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
  592. void III_antialias(double xr[SBLIMIT][SSLIMIT], double hybridIn[SBLIMIT][SSLIMIT], struct gr_info_s *gr_info, frame_params *fr_ps)
  593. {
  594.    static int    init = 1;
  595.    static double ca[8],cs[8];
  596.    double        bu,bd;  /* upper and lower butterfly inputs */
  597.    int           ss,sb,sblim;
  599.    if (init) {
  600.       int i;
  601.       double    sq;
  602.       for (i=0;i<8;i++) {
  603.          sq=sqrt(1.0+Ci[i]*Ci[i]);
  604.          cs[i] = 1.0/sq;
  605.          ca[i] = Ci[i]/sq;
  606.       }
  607.       init = 0;
  608.    }
  610.    /* clear all inputs */
  612.     for(sb=0;sb<SBLIMIT;sb++)
  613.        for(ss=0;ss<SSLIMIT;ss++)
  614.           hybridIn[sb][ss] = xr[sb][ss];
  616.    if  (gr_info->window_switching_flag && (gr_info->block_type == 2) &&
  617.        !gr_info->mixed_block_flag ) return;
  619.    if ( gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  620.      (gr_info->block_type == 2))
  621.       sblim = 1;
  622.    else
  623.       sblim = SBLIMIT-1;
  625.    /* 31 alias-reduction operations between each pair of sub-bands */
  626.    /* with 8 butterflies between each pair                         */
  628.    for(sb=0;sb<sblim;sb++)
  629.       for(ss=0;ss<8;ss++) {
  630.          bu = xr[sb][17-ss];
  631.          bd = xr[sb+1][ss];
  632.          hybridIn[sb][17-ss] = (bu * cs[ss]) - (bd * ca[ss]);
  633.          hybridIn[sb+1][ss] = (bd * cs[ss]) + (bu * ca[ss]);
  634.          }
  635. }
  638. /*------------------------------------------------------------------*/
  639. /*                                                                  */
  640. /*    Function: Calculation of the inverse MDCT                     */
  641. /*    In the case of short blocks the 3 output vectors are already  */
  642. /*    overlapped and added in this modul.                           */
  643. /*                                                                  */
  644. /*    New layer3                                                    */
  645. /*                                                                  */
  646. /*------------------------------------------------------------------*/
  647. void inv_mdct(double in[18], double out[36], int block_type)
  648. {
  649. int     i,m,N,p;
  650. double  tmp[12],sum;
  651. static  double  win[4][36];
  652. static  int init=0;
  653. static  double COS[4*36];
  655.     if(init==0){
  657.     /* type 0 */
  658.       for(i=0;i<36;i++)
  659.          win[0][i] = sin( PI/36 *(i+0.5) );
  661.     /* type 1*/
  662.       for(i=0;i<18;i++)
  663.          win[1][i] = sin( PI/36 *(i+0.5) );
  664.       for(i=18;i<24;i++)
  665.          win[1][i] = 1.0;
  666.       for(i=24;i<30;i++)
  667.          win[1][i] = sin( PI/12 *(i+0.5-18) );
  668.       for(i=30;i<36;i++)
  669.          win[1][i] = 0.0;
  671.     /* type 3*/
  672.       for(i=0;i<6;i++)
  673.          win[3][i] = 0.0;
  674.       for(i=6;i<12;i++)
  675.          win[3][i] = sin( PI/12 *(i+0.5-6) );
  676.       for(i=12;i<18;i++)
  677.          win[3][i] =1.0;
  678.       for(i=18;i<36;i++)
  679.          win[3][i] = sin( PI/36*(i+0.5) );
  681.     /* type 2*/
  682.       for(i=0;i<12;i++)
  683.          win[2][i] = sin( PI/12*(i+0.5) ) ;
  684.       for(i=12;i<36;i++)
  685.          win[2][i] = 0.0 ;
  687.       for (i=0; i<4*36; i++)
  688.          COS[i] = cos(PI/(2*36) * i);
  690.       init++;
  691.     }
  693.     for(i=0;i<36;i++)
  694.        out[i]=0;
  696.     if(block_type == 2){
  697.        N=12;
  698.        for(i=0;i<3;i++){
  699.           for(p= 0;p<N;p++){
  700.              sum = 0.0;
  701.              for(m=0;m<N/2;m++)
  702.                 sum += in[i+3*m] * cos( PI/(2*N)*(2*p+1+N/2)*(2*m+1) );
  703.              tmp[p] = sum * win[block_type][p] ;
  704.           }
  705.           for(p=0;p<N;p++)
  706.              out[6*i+p+6] += tmp[p];
  707.        }
  708.     }
  709.     else{
  710.       N=36;
  711.       for(p= 0;p<N;p++){
  712.          sum = 0.0;
  713.          for(m=0;m<N/2;m++)
  714.            sum += in[m] * COS[((2*p+1+N/2)*(2*m+1))%(4*36)];
  715.          out[p] = sum * win[block_type][p];
  716.       }
  717.     }
  718. }
  721. void III_hybrid(double fsIn[SSLIMIT], double tsOut[SSLIMIT], int sb, int ch, struct gr_info_s *gr_info, frame_params *fr_ps)
  722. /* fsIn:freq samples per subband in */
  723. /* tsOut:time samples per subband out */
  724. {
  725.    int ss;
  726.    double rawout[36];
  727.    static double prevblck[2][SBLIMIT][SSLIMIT];
  728.    static int init = 1;
  729.    int bt;
  731.    if (init) {
  732.       int i,j,k;
  734.       for(i=0;i<2;i++)
  735.          for(j=0;j<SBLIMIT;j++)
  736.             for(k=0;k<SSLIMIT;k++)
  737.                prevblck[i][j][k]=0.0;
  738.       init = 0;
  739.    }
  741.    bt = (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  742.           (sb < 2)) ? 0 : gr_info->block_type;
  744.    inv_mdct( fsIn, rawout, bt);
  746.    /* overlap addition */
  747.    for(ss=0; ss<SSLIMIT; ss++) {
  748.       tsOut[ss] = rawout[ss] + prevblck[ch][sb][ss];
  749.       prevblck[ch][sb][ss] = rawout[ss+18];
  750.    }
  751. }
  754. /*************************************************************
  755. /*
  756. /*   Pass the subband sample through the synthesis window
  757. /*
  758. /**************************************************************/
  759. /* create in synthesis filter */
  760. void create_syn_filter(double filter[64][SBLIMIT])
  761. {
  762. register int i,k;
  764. for (i=0; i<64; i++)
  765. for (k=0; k<32; k++) {
  766. if ((filter[i][k] = 1e9*cos((double)((PI64*i+PI4)*(2*k+1)))) >= 0)
  767. modf(filter[i][k]+0.5, &filter[i][k]);
  768. else
  769. modf(filter[i][k]-0.5, &filter[i][k]);
  770. filter[i][k] *= 1e-9;
  771. }
  772. }
  775. /***************************************************************
  776. /*
  777. /*   Window the restored sample
  778. /*
  779. /***************************************************************/
  780. /* read in synthesis window */
  781. void read_syn_window(double window[HAN_SIZE])
  782. {
  783.     int i,j[4];
  784.     FILE *fp;
  785.     double f[4];
  786.     char t[150];
  788.     if (!(fp = OpenTableFile("dewindow.txt") )) {
  789.         printf("Please check synthesis window table 'dewindow.txt'n");
  790.         exit(1);
  791.     }
  792.     for (i=0;i<512;i+=4) {
  793.         fgets(t, 150, fp);
  794.         sscanf(t,"D[%d] = %lf D[%d] = %lf D[%d] = %lf D[%d] = %lfn",
  795.                j, f,j+1,f+1,j+2,f+2,j+3,f+3);
  796.         if (i==j[0]) {
  797.             window[i] = f[0];
  798.             window[i+1] = f[1];
  799.             window[i+2] = f[2];
  800.             window[i+3] = f[3];
  801.         }
  802.         else {
  803.             printf("Check index in synthesis window tablen");
  804.             exit(1);
  805.         }
  806.         fgets(t,150,fp);
  807.     }
  808.     fclose(fp);
  809. }
  811. int SubBandSynthesis (double *bandPtr, int channel, short *samples)
  812. {
  813. register int i,j,k;
  814. register double *bufOffsetPtr, sum;
  815. static int init = 1;
  816. typedef double NN[64][32];
  817. static NN *filter;
  818. typedef double BB[2][2*HAN_SIZE];
  819. static BB *buf;
  820. static int bufOffset[2] = {64,64};
  821. static double *window;
  822. int clip = 0;               /* count & return how many samples clipped */
  824. if (init) {
  825. buf = (BB *) mem_alloc(sizeof(BB),"BB");
  826. filter = (NN *) mem_alloc(sizeof(NN), "NN");
  827. create_syn_filter(*filter);
  828. window = (double *) mem_alloc(sizeof(double) * HAN_SIZE, "WIN");
  829. read_syn_window(window);
  830. init = 0;
  831. }
  832. /*    if (channel == 0) */
  833. bufOffset[channel] = (bufOffset[channel] - 64) & 0x3ff;
  834. bufOffsetPtr = &((*buf)[channel][bufOffset[channel]]);
  836. for (i=0; i<64; i++) {
  837. sum = 0;
  838. for (k=0; k<32; k++)
  839. sum += bandPtr[k] * (*filter)[i][k];
  840. bufOffsetPtr[i] = sum;
  841. }
  842. /*  S(i,j) = D(j+32i) * U(j+32i+((i+1)>>1)*64)  */
  843. /*  samples(i,j) = MWindow(j+32i) * bufPtr(j+32i+((i+1)>>1)*64)  */
  844. for (j=0; j<32; j++) {
  845. sum = 0;
  846. for (i=0; i<16; i++) {
  847. k = j + (i<<5);
  848. sum += window[k] * (*buf) [channel] [( (k + ( ((i+1)>>1) <<6) ) +
  849. bufOffset[channel]) & 0x3ff];
  850. }
  851. {
  852. /*long foo = (sum > 0) ? sum * SCALE + 0.5 : sum * SCALE - 0.5; */
  853. long foo = sum * SCALE;
  854. if (foo >= (long) SCALE)      {samples[j] = SCALE-1; ++clip;}
  855. else if (foo < (long) -SCALE) {samples[j] = -SCALE;  ++clip;}
  856. else                           samples[j] = foo;
  857. }
  858. }
  859.     return(clip);
  860. }
  862. void out_fifo(short pcm_sample[2][SSLIMIT][SBLIMIT], int num, frame_params *fr_ps, int done, FILE *outFile, unsigned long *psampFrames)
  863. {
  864. int i,j,l;
  865. int stereo = fr_ps->stereo;
  866. int sblimit = fr_ps->sblimit;
  867. static short int outsamp[1600];
  868. static long k = 0;
  870.     if (!done)
  871.         for (i=0;i<num;i++) for (j=0;j<SBLIMIT;j++) {
  872.             (*psampFrames)++;
  873.             for (l=0;l<stereo;l++) {
  874.                 if (!(k%1600) && k) {
  875.                     fwrite(outsamp,2,1600,outFile);
  876.                     k = 0;
  877.                 }
  878.                 outsamp[k++] = pcm_sample[l][i][j];
  879.             }
  880.         }
  881.     else {
  882.         fwrite(outsamp,2,(int)k,outFile);
  883.         k = 0;
  884.     }
  885. }
  888. void  buffer_CRC(Bit_stream_struc *bs, unsigned int *old_crc)
  889. {
  890.     *old_crc = getbits(bs, 16);
  891. }
  894. extern int bitrate[3][15];
  895. extern double s_freq[4];
  896. /* Return the number of slots for main data of current frame, */
  897. int main_data_slots(frame_params fr_ps)
  898. {
  899. int nSlots;
  901. nSlots = (144 * bitrate[2][fr_ps.header->bitrate_index])
  902. / s_freq[fr_ps.header->sampling_frequency];
  903. if (fr_ps.header->padding) nSlots++;
  904. nSlots -= 4;
  905. if (fr_ps.header->error_protection)
  906. nSlots -= 2;
  907. if (fr_ps.stereo == 1)
  908. nSlots -= 17;
  909. else
  910. nSlots -=32;
  911. return(nSlots);
  912. }