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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
Layer3.cpp
资源名称：playa-0.3.3src.zip　[点击查看]
上传用户：lusi_8715
上传日期：2007-01-08
资源大小：199k
文件大小：45k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

Layer3.cpp：源码内容
  1. /**************************************************************************************
  2.  *                                                                                    *
  3.  * This application contains code from OpenDivX and is released as a "Larger Work"    *
  4.  * under that license. Consistant with that license, this application is released     *
  5.  * under the GNU General Public License.                                              *
  6.  *                                                                                    *
  7.  * The OpenDivX license can be found at: http://www.projectmayo.com/opendivx/docs.php *
  8.  * The GPL can be found at: http://www.gnu.org/copyleft/gpl.html                      *
  9.  *                                                                                    *
  10.  * Authors: Damien Chavarria <roy204 at projectmayo.com>                              *
  11.  *                                                                                    *
  12.  **************************************************************************************/
  14. /* 
  15.  * Mpeg Layer-3 audio decoder 
  16.  * --------------------------
  17.  * copyright (c) 1995,1996,1997 by Michael Hipp.
  18.  * All rights reserved. See also 'README'
  19.  */ 
  21. #include <stdlib.h>
  22. #include <windows.h>
  24. #include "mpg123.h"
  25. #include "mpglib.h"
  26. #include "huffman.h"
  28. extern struct mpstr *gmp;
  30. static real ispow[8207];
  31. static real aa_ca[8],aa_cs[8];
  32. static real COS1[12][6];
  33. static real win[4][36];
  34. static real win1[4][36];
  35. static real gainpow2[256+118+4];
  36. static real COS9[9];
  37. static real COS6_1,COS6_2;
  38. static real tfcos36[9];
  39. static real tfcos12[3];
  41. struct bandInfoStruct {
  42.   short longIdx[23];
  43.   short longDiff[22];
  44.   short shortIdx[14];
  45.   short shortDiff[13];
  46. };
  49. int longLimit[9][23];
  50. int shortLimit[9][14];
  52. struct bandInfoStruct bandInfo[9] = { 
  54. /* MPEG 1.0 */
  55.  { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},
  56.    {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},
  57.    {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3},
  58.    {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,
  60.  { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},
  61.    {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},
  62.    {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3},
  63.    {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,
  65.  { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,
  66.    {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,
  67.    {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} ,
  68.    {4,4,4,4,6,8,12,16,20,26,34,42,12} }  ,
  70. /* MPEG 2.0 */
  71.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  72.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,
  73.    {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,
  74.    {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,
  76.  { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
  77.    {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } ,
  78.    {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} ,
  79.    {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,
  81.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  82.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },
  83.    {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3},
  84.    {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,
  85. /* MPEG 2.5 */
  86.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
  87.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
  88.    {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
  89.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  90.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
  91.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
  92.    {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
  93.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  94.  { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
  95.    {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},
  96.    {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},
  97.    {8,8,8,12,16,20,24,28,36,2,2,2,26} } ,
  98. };
  100. static int mapbuf0[9][152];
  101. static int mapbuf1[9][156];
  102. static int mapbuf2[9][44];
  103. static int *map[9][3];
  104. static int *mapend[9][3];
  106. static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */
  107. static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */
  109. static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];
  110. static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];
  112. /* 
  113.  * init tables for layer-3 
  114.  */
  115. void init_layer3(int down_sample_sblimit)
  116. {
  117.   int i,j,k,l;
  119.   for(i=-256;i<118+4;i++)
  120.     gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) );
  122.   for(i=0;i<8207;i++)
  123.     ispow[i] = pow((double)i,(double)4.0/3.0);
  125.   for (i=0;i<8;i++)
  126.   {
  127.     static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
  128.     double sq=sqrt(1.0+Ci[i]*Ci[i]);
  129.     aa_cs[i] = 1.0/sq;
  130.     aa_ca[i] = Ci[i]/sq;
  131.   }
  133.   for(i=0;i<18;i++)
  134.   {
  135.     win[0][i]    = win[1][i]    = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 );
  136.     win[0][i+18] = win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
  137.   }
  138.   for(i=0;i<6;i++)
  139.   {
  140.     win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
  141.     win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );
  142.     win[1][i+24] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 );
  143.     win[1][i+30] = win[3][i] = 0.0;
  144.     win[3][i+6 ] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) )  / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 );
  145.   }
  147.   for(i=0;i<9;i++)
  148.     COS9[i] = cos( M_PI / 18.0 * (double) i);
  150.   for(i=0;i<9;i++)
  151.     tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 );
  152.   for(i=0;i<3;i++)
  153.     tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 );
  155.   COS6_1 = cos( M_PI / 6.0 * (double) 1);
  156.   COS6_2 = cos( M_PI / 6.0 * (double) 2);
  158.   for(i=0;i<12;i++)
  159.   {
  160.     win[2][i]  = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );
  161.     for(j=0;j<6;j++)
  162.       COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );
  163.   }
  165.   for(j=0;j<4;j++) {
  166.     static int len[4] = { 36,36,12,36 };
  167.     for(i=0;i<len[j];i+=2)
  168.       win1[j][i] = + win[j][i];
  169.     for(i=1;i<len[j];i+=2)
  170.       win1[j][i] = - win[j][i];
  171.   }
  173.   for(i=0;i<16;i++)
  174.   {
  175.     double t = tan( (double) i * M_PI / 12.0 );
  176.     tan1_1[i] = t / (1.0+t);
  177.     tan2_1[i] = 1.0 / (1.0 + t);
  178.     tan1_2[i] = M_SQRT2 * t / (1.0+t);
  179.     tan2_2[i] = M_SQRT2 / (1.0 + t);
  181.     for(j=0;j<2;j++) {
  182.       double base = pow(2.0,-0.25*(j+1.0));
  183.       double p1=1.0,p2=1.0;
  184.       if(i > 0) {
  185.         if( i & 1 )
  186.           p1 = pow(base,(i+1.0)*0.5);
  187.         else
  188.           p2 = pow(base,i*0.5);
  189.       }
  190.       pow1_1[j][i] = p1;
  191.       pow2_1[j][i] = p2;
  192.       pow1_2[j][i] = M_SQRT2 * p1;
  193.       pow2_2[j][i] = M_SQRT2 * p2;
  194.     }
  195.   }
  197.   for(j=0;j<9;j++)
  198.   {
  199.    struct bandInfoStruct *bi = &bandInfo[j];
  200.    int *mp;
  201.    int cb,lwin;
  202.    short *bdf;
  204.    mp = map[j][0] = mapbuf0[j];
  205.    bdf = bi->longDiff;
  206.    for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {
  207.      *mp++ = (*bdf) >> 1;
  208.      *mp++ = i;
  209.      *mp++ = 3;
  210.      *mp++ = cb;
  211.    }
  212.    bdf = bi->shortDiff+3;
  213.    for(cb=3;cb<13;cb++) {
  214.      int l = (*bdf++) >> 1;
  215.      for(lwin=0;lwin<3;lwin++) {
  216.        *mp++ = l;
  217.        *mp++ = i + lwin;
  218.        *mp++ = lwin;
  219.        *mp++ = cb;
  220.      }
  221.      i += 6*l;
  222.    }
  223.    mapend[j][0] = mp;
  225.    mp = map[j][1] = mapbuf1[j];
  226.    bdf = bi->shortDiff+0;
  227.    for(i=0,cb=0;cb<13;cb++) {
  228.      int l = (*bdf++) >> 1;
  229.      for(lwin=0;lwin<3;lwin++) {
  230.        *mp++ = l;
  231.        *mp++ = i + lwin;
  232.        *mp++ = lwin;
  233.        *mp++ = cb;
  234.      }
  235.      i += 6*l;
  236.    }
  237.    mapend[j][1] = mp;
  239.    mp = map[j][2] = mapbuf2[j];
  240.    bdf = bi->longDiff;
  241.    for(cb = 0; cb < 22 ; cb++) {
  242.      *mp++ = (*bdf++) >> 1;
  243.      *mp++ = cb;
  244.    }
  245.    mapend[j][2] = mp;
  247.   }
  249.   for(j=0;j<9;j++) {
  250.     for(i=0;i<23;i++) {
  251.       longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
  252.       if(longLimit[j][i] > (down_sample_sblimit) )
  253.         longLimit[j][i] = down_sample_sblimit;
  254.     }
  255.     for(i=0;i<14;i++) {
  256.       shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
  257.       if(shortLimit[j][i] > (down_sample_sblimit) )
  258.         shortLimit[j][i] = down_sample_sblimit;
  259.     }
  260.   }
  262.   for(i=0;i<5;i++) {
  263.     for(j=0;j<6;j++) {
  264.       for(k=0;k<6;k++) {
  265.         int n = k + j * 6 + i * 36;
  266.         i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12);
  267.       }
  268.     }
  269.   }
  270.   for(i=0;i<4;i++) {
  271.     for(j=0;j<4;j++) {
  272.       for(k=0;k<4;k++) {
  273.         int n = k + j * 4 + i * 16;
  274.         i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12);
  275.       }
  276.     }
  277.   }
  278.   for(i=0;i<4;i++) {
  279.     for(j=0;j<3;j++) {
  280.       int n = j + i * 3;
  281.       i_slen2[n+244] = i|(j<<3) | (5<<12);
  282.       n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15);
  283.     }
  284.   }
  286.   for(i=0;i<5;i++) {
  287.     for(j=0;j<5;j++) {
  288.       for(k=0;k<4;k++) {
  289.         for(l=0;l<4;l++) {
  290.           int n = l + k * 4 + j * 16 + i * 80;
  291.           n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12);
  292.         }
  293.       }
  294.     }
  295.   }
  296.   for(i=0;i<5;i++) {
  297.     for(j=0;j<5;j++) {
  298.       for(k=0;k<4;k++) {
  299.         int n = k + j * 4 + i * 20;
  300.         n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12);
  301.       }
  302.     }
  303.   }
  304. }
  307. /**
  308.  * read additional side information
  309.  **/
  311. static void III_get_side_info_1(struct III_sideinfo *si,int stereo,
  312.  int ms_stereo,long sfreq,int single)
  313. {
  314.    int ch, gr;
  315.    int powdiff = (single == 3) ? 4 : 0;
  317.    si->main_data_begin = getbits(9);
  318.    if (stereo == 1)
  319.      si->private_bits = getbits_fast(5);
  320.    else 
  321.      si->private_bits = getbits_fast(3);
  323.    for (ch=0; ch<stereo; ch++) {
  324.        si->ch[ch].gr[0].scfsi = -1;
  325.        si->ch[ch].gr[1].scfsi = getbits_fast(4);
  326.    }
  328.    for (gr=0; gr<2; gr++) 
  329.    {
  330.      for (ch=0; ch<stereo; ch++) 
  331.      {
  332.        register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  334.        gr_info->part2_3_length = getbits(12);
  335.        gr_info->big_values = getbits_fast(9);
  336.        if(gr_info->big_values > 288) {
  337.           gr_info->big_values = 288;
  338.        }
  339.        gr_info->pow2gain = gainpow2+256 - getbits_fast(8) + powdiff;
  340.        if(ms_stereo)
  341.          gr_info->pow2gain += 2;
  342.        gr_info->scalefac_compress = getbits_fast(4);
  343. /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
  344.        if(get1bit()) 
  345.        {
  346.          int i;
  347.          gr_info->block_type = getbits_fast(2);
  348.          gr_info->mixed_block_flag = get1bit();
  349.          gr_info->table_select[0] = getbits_fast(5);
  350.          gr_info->table_select[1] = getbits_fast(5);
  351.          /*
  352.           * table_select[2] not needed, because there is no region2,
  353.           * but to satisfy some verifications tools we set it either.
  354.           */
  355.          gr_info->table_select[2] = 0;
  356.          for(i=0;i<3;i++)
  357.            gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(3)<<3);
  359.          if(gr_info->block_type == 0) {
  360.    return;
  361.          }
  362.          /* region_count/start parameters are implicit in this case. */       
  363.          gr_info->region1start = 36>>1;
  364.          gr_info->region2start = 576>>1;
  365.        }
  366.        else 
  367.        {
  368.          int i,r0c,r1c;
  369.          for (i=0; i<3; i++)
  370.            gr_info->table_select[i] = getbits_fast(5);
  371.          r0c = getbits_fast(4);
  372.          r1c = getbits_fast(3);
  373.          gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  374.          gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  375.          gr_info->block_type = 0;
  376.          gr_info->mixed_block_flag = 0;
  377.        }
  378.        gr_info->preflag = get1bit();
  379.        gr_info->scalefac_scale = get1bit();
  380.        gr_info->count1table_select = get1bit();
  381.      }
  382.    }
  383. }
  386. /**
  387.  * Side Info for MPEG 2.0 / LSF
  388.  **/
  390. static void III_get_side_info_2(struct III_sideinfo *si,int stereo,
  391.  int ms_stereo,long sfreq,int single)
  392. {
  393.    int ch;
  394.    int powdiff = (single == 3) ? 4 : 0;
  396.    si->main_data_begin = getbits(8);
  397.    if (stereo == 1)
  398.      si->private_bits = get1bit();
  399.    else 
  400.      si->private_bits = getbits_fast(2);
  402.    for (ch=0; ch<stereo; ch++) 
  403.    {
  404.        register struct gr_info_s *gr_info = &(si->ch[ch].gr[0]);
  406.        gr_info->part2_3_length = getbits(12);
  407.        gr_info->big_values = getbits_fast(9);
  408.        if(gr_info->big_values > 288) {
  409.  gr_info->big_values = 288;
  410.        }
  411.        gr_info->pow2gain = gainpow2+256 - getbits_fast(8) + powdiff;
  412.        if(ms_stereo)
  413.          gr_info->pow2gain += 2;
  414.        gr_info->scalefac_compress = getbits(9);
  415. /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
  416.        if(get1bit()) 
  417.        {
  418.          int i;
  419.          gr_info->block_type = getbits_fast(2);
  420.          gr_info->mixed_block_flag = get1bit();
  421.          gr_info->table_select[0] = getbits_fast(5);
  422.          gr_info->table_select[1] = getbits_fast(5);
  423.          /*
  424.           * table_select[2] not needed, because there is no region2,
  425.           * but to satisfy some verifications tools we set it either.
  426.           */
  427.          gr_info->table_select[2] = 0;
  428.          for(i=0;i<3;i++)
  429.            gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(3)<<3);
  431.          if(gr_info->block_type == 0) {
  432.            return;
  433.          }
  434.          /* region_count/start parameters are implicit in this case. */       
  435. /* check this again! */
  436.          if(gr_info->block_type == 2)
  437.            gr_info->region1start = 36>>1;
  438.          else if(sfreq == 8)
  439. /* check this for 2.5 and sfreq=8 */
  440.            gr_info->region1start = 108>>1;
  441.          else
  442.            gr_info->region1start = 54>>1;
  443.          gr_info->region2start = 576>>1;
  444.        }
  445.        else 
  446.        {
  447.          int i,r0c,r1c;
  448.          for (i=0; i<3; i++)
  449.            gr_info->table_select[i] = getbits_fast(5);
  450.          r0c = getbits_fast(4);
  451.          r1c = getbits_fast(3);
  452.          gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  453.          gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  454.          gr_info->block_type = 0;
  455.          gr_info->mixed_block_flag = 0;
  456.        }
  457.        gr_info->scalefac_scale = get1bit();
  458.        gr_info->count1table_select = get1bit();
  459.    }
  460. }
  463. /**
  464.  * read scalefactors
  465.  **/
  467. static int III_get_scale_factors_1(int *scf,struct gr_info_s *gr_info)
  468. {
  469.    static const unsigned char slen[2][16] = {
  470.      {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  471.      {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
  472.    };
  473.    int numbits;
  474.    int num0 = slen[0][gr_info->scalefac_compress];
  475.    int num1 = slen[1][gr_info->scalefac_compress];
  477.     if (gr_info->block_type == 2) {
  478.       int i=18;
  479.       numbits = (num0 + num1) * 18;
  481.       if (gr_info->mixed_block_flag) {
  482.          for (i=8;i;i--)
  483.            *scf++ = getbits_fast(num0);
  484.          i = 9;
  485.          numbits -= num0; /* num0 * 17 + num1 * 18 */
  486.       }
  488.       for (;i;i--)
  489.         *scf++ = getbits_fast(num0);
  490.       for (i = 18; i; i--)
  491.         *scf++ = getbits_fast(num1);
  492.       *scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */
  493.     }
  494.     else {
  495.       int i;
  496.       int scfsi = gr_info->scfsi;
  498.       if(scfsi < 0) { /* scfsi < 0 => granule == 0 */
  499.          for(i=11;i;i--)
  500.            *scf++ = getbits_fast(num0);
  501.          for(i=10;i;i--)
  502.            *scf++ = getbits_fast(num1);
  503.          numbits = (num0 + num1) * 10 + num0;
  504.          *scf++ = 0;
  505.       }
  506.       else {
  507.         numbits = 0;
  508.         if(!(scfsi & 0x8)) {
  509.           for (i=0;i<6;i++)
  510.             *scf++ = getbits_fast(num0);
  511.           numbits += num0 * 6;
  512.         }
  513.         else {
  514.           scf += 6; 
  515.         }
  517.         if(!(scfsi & 0x4)) {
  518.           for (i=0;i<5;i++)
  519.             *scf++ = getbits_fast(num0);
  520.           numbits += num0 * 5;
  521.         }
  522.         else {
  523.           scf += 5;
  524.         }
  526.         if(!(scfsi & 0x2)) {
  527.           for(i=0;i<5;i++)
  528.             *scf++ = getbits_fast(num1);
  529.           numbits += num1 * 5;
  530.         }
  531.         else {
  532.           scf += 5; 
  533.         }
  535.         if(!(scfsi & 0x1)) {
  536.           for (i=0;i<5;i++)
  537.             *scf++ = getbits_fast(num1);
  538.           numbits += num1 * 5;
  539.         }
  540.         else {
  541.            scf += 5;
  542.         }
  543.         *scf++ = 0;  /* no l[21] in original sources */
  544.       }
  545.     }
  546.     return numbits;
  547. }
  550. /**
  551.  *
  552.  **/
  554. static int III_get_scale_factors_2(int *scf,struct gr_info_s *gr_info,int i_stereo)
  555. {
  556.   unsigned char *pnt;
  557.   int i,j;
  558.   unsigned int slen;
  559.   int n = 0;
  560.   int numbits = 0;
  562.   static unsigned char stab[3][6][4] = {
  563.    { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
  564.      { 7, 7, 7,0 } , { 6, 6, 6,3 } , {  8, 8,5,0} } ,
  565.    { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
  566.      {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
  567.    { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
  568.      { 6,15,12,0 } , { 6,12, 9,6 } , {  6,18,9,0} } }; 
  570.   if(i_stereo) /* i_stereo AND second channel -> do_layer3() checks this */
  571.     slen = i_slen2[gr_info->scalefac_compress>>1];
  572.   else
  573.     slen = n_slen2[gr_info->scalefac_compress];
  575.   gr_info->preflag = (slen>>15) & 0x1;
  577.   n = 0;  
  578.   if( gr_info->block_type == 2 ) {
  579.     n++;
  580.     if(gr_info->mixed_block_flag)
  581.       n++;
  582.   }
  584.   pnt = stab[n][(slen>>12)&0x7];
  586.   for(i=0;i<4;i++) {
  587.     int num = slen & 0x7;
  588.     slen >>= 3;
  589.     if(num) {
  590.       for(j=0;j<(int)(pnt[i]);j++)
  591.         *scf++ = getbits_fast(num);
  592.       numbits += pnt[i] * num;
  593.     }
  594.     else {
  595.       for(j=0;j<(int)(pnt[i]);j++)
  596.         *scf++ = 0;
  597.     }
  598.   }
  599.   
  600.   n = (n << 1) + 1;
  601.   for(i=0;i<n;i++)
  602.     *scf++ = 0;
  604.   return numbits;
  605. }
  607. static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
  608. static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  610. /**
  611.  *
  612.  **/
  614. static int III_dequantize_sample(real xr[SBLIMIT][SSLIMIT],int *scf,
  615.    struct gr_info_s *gr_info,int sfreq,int part2bits)
  616. {
  617.   int shift = 1 + gr_info->scalefac_scale;
  618.   real *xrpnt = (real *) xr;
  619.   int l[3],l3;
  620.   int part2remain = gr_info->part2_3_length - part2bits;
  621.   int *me;
  623.   //MessageBox(NULL, "DEQUANTIZE", "", MB_OK);
  625.   {
  626.     int bv       = gr_info->big_values;
  627.     int region1  = gr_info->region1start;
  628.     int region2  = gr_info->region2start;
  630.     l3 = ((576>>1)-bv)>>1;   
  631. /*
  632.  * we may lose the 'odd' bit here !! 
  633.  * check this later again 
  634.  */
  635.     if(bv <= region1) {
  636.       l[0] = bv; l[1] = 0; l[2] = 0;
  637.     }
  638.     else {
  639.       l[0] = region1;
  640.       if(bv <= region2) {
  641.         l[1] = bv - l[0];  l[2] = 0;
  642.       }
  643.       else {
  644.         l[1] = region2 - l[0]; l[2] = bv - region2;
  645.       }
  646.     }
  647.   }
  648.  
  649.   if(gr_info->block_type == 2) {
  651.     /*
  652.      * decoding with short or mixed mode BandIndex table 
  653.      */
  654.   
  655. int i,max[4];
  656.     int step=0,lwin=0,cb=0;
  657.     register real v = 0.0;
  658.     register int *m,mc;
  660.   //MessageBox(NULL, "DEQUANTIZE1", "", MB_OK);
  663.     if(gr_info->mixed_block_flag) {
  664.       max[3] = -1;
  665.       max[0] = max[1] = max[2] = 2;
  666.       m = map[sfreq][0];
  667.       me = mapend[sfreq][0];
  668.     }
  669.     else {
  670.       max[0] = max[1] = max[2] = max[3] = -1;
  671.       /* max[3] not really needed in this case */
  672.       m = map[sfreq][1];
  673.       me = mapend[sfreq][1];
  674.     }
  676.   //MessageBox(NULL, "DEQUANTIZE3", "", MB_OK);
  678.     mc = 0;
  679.     for(i=0;i<2;i++) {
  680.       int lp = l[i];
  681.       struct newhuff *h = ht+gr_info->table_select[i];
  682.       for(;lp;lp--,mc--) {
  683.         register int x,y;
  684.         if( (!mc) ) {
  685.           mc = *m++;
  686.           xrpnt = ((real *) xr) + (*m++);
  687.           lwin = *m++;
  688.           cb = *m++;
  689.           if(lwin == 3) {
  690.             v = gr_info->pow2gain[(*scf++) << shift];
  691.             step = 1;
  692.           }
  693.           else {
  694.             v = gr_info->full_gain[lwin][(*scf++) << shift];
  695.             step = 3;
  696.           }
  697.         }
  698.         {
  699.           register short *val = h->table;
  700.           while((y=*val++)<0) {
  701.             if (get1bit())
  702.               val -= y;
  703.             part2remain--;
  704.           }
  705.           x = y >> 4;
  706.           y &= 0xf;
  707.         }
  708.         if(x == 15) {
  709.           max[lwin] = cb;
  710.           part2remain -= h->linbits+1;
  711.           x += getbits(h->linbits);
  712.           if(get1bit())
  713.             *xrpnt = -ispow[x] * v;
  714.           else
  715.             *xrpnt =  ispow[x] * v;
  716.         }
  717.         else if(x) {
  718.           max[lwin] = cb;
  719.           if(get1bit())
  720.             *xrpnt = -ispow[x] * v;
  721.           else
  722.             *xrpnt =  ispow[x] * v;
  723.           part2remain--;
  724.         }
  725.         else
  726.           *xrpnt = 0.0;
  727.         xrpnt += step;
  728.         if(y == 15) {
  729.           max[lwin] = cb;
  730.           part2remain -= h->linbits+1;
  731.           y += getbits(h->linbits);
  732.           if(get1bit())
  733.             *xrpnt = -ispow[y] * v;
  734.           else
  735.             *xrpnt =  ispow[y] * v;
  736.         }
  737.         else if(y) {
  738.           max[lwin] = cb;
  739.           if(get1bit())
  740.             *xrpnt = -ispow[y] * v;
  741.           else
  742.             *xrpnt =  ispow[y] * v;
  743.           part2remain--;
  744.         }
  745.         else
  746.           *xrpnt = 0.0;
  747.         xrpnt += step;
  748.       }
  749.     }
  751.   //MessageBox(NULL, "DEQUANTIZE4", "", MB_OK);
  754.     for(;l3 && (part2remain > 0);l3--) {
  755.       struct newhuff *h = htc+gr_info->count1table_select;
  756.       register short *val = h->table,a;
  758.       while((a=*val++)<0) {
  759.         part2remain--;
  760.         if(part2remain < 0) {
  761.           part2remain++;
  762.           a = 0;
  763.           break;
  764.         }
  765.         if (get1bit())
  766.           val -= a;
  767.       }
  769.       for(i=0;i<4;i++) {
  770.         if(!(i & 1)) {
  771.           if(!mc) {
  772.             mc = *m++;
  773.             xrpnt = ((real *) xr) + (*m++);
  774.             lwin = *m++;
  775.             cb = *m++;
  776.             if(lwin == 3) {
  777.               v = gr_info->pow2gain[(*scf++) << shift];
  778.               step = 1;
  779.             }
  780.             else {
  781.               v = gr_info->full_gain[lwin][(*scf++) << shift];
  782.               step = 3;
  783.             }
  784.           }
  785.           mc--;
  786.         }
  787.         if( (a & (0x8>>i)) ) {
  788.           max[lwin] = cb;
  789.           part2remain--;
  790.           if(part2remain < 0) {
  791.             part2remain++;
  792.             break;
  793.           }
  794.           if(get1bit()) 
  795.             *xrpnt = -v;
  796.           else
  797.             *xrpnt = v;
  798.         }
  799.         else
  800.           *xrpnt = 0.0;
  801.         xrpnt += step;
  802.       }
  803.     }
  804.  
  805.   //MessageBox(NULL, "DEQUANTIZE5", "", MB_OK);
  808.     while( m < me ) {
  809.       if(!mc) {
  810.         mc = *m++;
  811.         xrpnt = ((real *) xr) + *m++;
  812.         if( (*m++) == 3)
  813.           step = 1;
  814.         else
  815.           step = 3;
  816.         m++; /* cb */
  817.       }
  818.       mc--;
  819.       *xrpnt = 0.0;
  820.       xrpnt += step;
  821.       *xrpnt = 0.0;
  822.       xrpnt += step;
  823. /* we could add a little opt. here:
  824.  * if we finished a band for window 3 or a long band
  825.  * further bands could copied in a simple loop without a
  826.  * special 'map' decoding
  827.  */
  828.     }
  830.   //MessageBox(NULL, "DEQUANTIZE6", "", MB_OK);
  833.     gr_info->maxband[0] = max[0]+1;
  834.     gr_info->maxband[1] = max[1]+1;
  835.     gr_info->maxband[2] = max[2]+1;
  836.     gr_info->maxbandl = max[3]+1;
  838.     {
  839.       int rmax = max[0] > max[1] ? max[0] : max[1];
  840.       rmax = (rmax > max[2] ? rmax : max[2]) + 1;
  841.       gr_info->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];
  842.     }
  844.   }
  845.   else {
  846. /*
  847.      * decoding with 'long' BandIndex table (block_type != 2)
  848.      */
  850.   //MessageBox(NULL, "DEQUANTIZE7", "", MB_OK);
  853.     int *pretab = gr_info->preflag ? pretab1 : pretab2;
  854.     int i,max = -1;
  855.     int cb = 0;
  856.     register int *m = map[sfreq][2];
  857.     register real v = 0.0;
  858.     register int mc = 0;
  859. #if 0
  860.     me = mapend[sfreq][2];
  861. #endif
  863. /*
  864.      * long hash table values
  865.      */
  867. //MessageBox(NULL, "DEQUANTIZE8", "", MB_OK);
  869.     for(i=0;i<3;i++) {
  870.       int lp = l[i];
  871.       struct newhuff *h = ht+gr_info->table_select[i];
  873.       for(;lp;lp--,mc--) {
  874.         int x,y;
  876.         if(!mc) {
  877.           mc = *m++;
  878.           v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
  879.           cb = *m++;
  880.         }
  881.         {
  882.           register short *val = h->table;
  883.           while((y=*val++)<0) {
  884.             if (get1bit())
  885.               val -= y;
  886.             part2remain--;
  887.           }
  888.           x = y >> 4;
  889.           y &= 0xf;
  890.         }
  891.         if (x == 15) {
  892.           max = cb;
  893.           part2remain -= h->linbits+1;
  894.           x += getbits(h->linbits);
  895.           if(get1bit())
  896.             *xrpnt++ = -ispow[x] * v;
  897.           else
  898.             *xrpnt++ =  ispow[x] * v;
  899.         }
  900.         else if(x) {
  901.           max = cb;
  902.           if(get1bit())
  903.             *xrpnt++ = -ispow[x] * v;
  904.           else
  905.             *xrpnt++ =  ispow[x] * v;
  906.           part2remain--;
  907.         }
  908.         else
  909.           *xrpnt++ = 0.0;
  911.         if (y == 15) {
  912.           max = cb;
  913.           part2remain -= h->linbits+1;
  914.           y += getbits(h->linbits);
  915.           if(get1bit())
  916.             *xrpnt++ = -ispow[y] * v;
  917.           else
  918.             *xrpnt++ =  ispow[y] * v;
  919.         }
  920.         else if(y) {
  921.           max = cb;
  922.           if(get1bit())
  923.             *xrpnt++ = -ispow[y] * v;
  924.           else
  925.             *xrpnt++ =  ispow[y] * v;
  926.           part2remain--;
  927.         }
  928.         else
  929.           *xrpnt++ = 0.0;
  930.       }
  931.     }
  933.   //MessageBox(NULL, "DEQUANTIZE9", "", MB_OK);
  936. /*
  937.      * short (count1table) values
  938.      */
  940.     for(;l3 && (part2remain > 0);l3--) {
  941.       struct newhuff *h = htc+gr_info->count1table_select;
  942.       register short *val = h->table,a;
  944.   //MessageBox(NULL, "DEQUANTIZE91", "", MB_OK);
  946.       while((a=*val++)<0) {
  947.         part2remain--;
  948.         if(part2remain < 0) {
  949.           part2remain++;
  950.           a = 0;
  951.           break;
  952.         }
  953.         if (get1bit())
  954.           val -= a;
  955.       }
  957.     //MessageBox(NULL, "DEQUANTIZE92", "", MB_OK);
  960.       for(i=0;i<4;i++) {
  961.         if(!(i & 1)) {
  962.           if(!mc) {
  963.         
  964.   //MessageBox(NULL, "DEQUANTIZE BEFORE BEFORE", "", MB_OK);
  965.     
  966. mc = *m++;
  967.             cb = *m++;
  969.   //MessageBox(NULL, "DEQUANTIZE BEFORE", "", MB_OK);
  970. v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
  971.             //MessageBox(NULL, "DEQUANTIZE AFTER", "", MB_OK);
  972. }
  973.           mc--;
  974.         }
  976. //MessageBox(NULL, "DEQUANTIZE93", "", MB_OK);
  978.         if ( (a & (0x8>>i)) ) {
  979.           max = cb;
  980.           part2remain--;
  981.           if(part2remain < 0) {
  982.             part2remain++;
  983.             break;
  984.           }
  985.           if(get1bit())
  986.             *xrpnt++ = -v;
  987.           else
  988.             *xrpnt++ = v;
  989.         }
  990.         else
  991.           *xrpnt++ = 0.0;
  992.       }
  993.     }
  995.   //MessageBox(NULL, "DEQUANTIZE10", "", MB_OK);
  998. /* 
  999.      * zero part
  1000.      */
  1001.     for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i;i--) {
  1002.       *xrpnt++ = 0.0;
  1003.       *xrpnt++ = 0.0;
  1004.     }
  1006.     gr_info->maxbandl = max+1;
  1007.     gr_info->maxb = longLimit[sfreq][gr_info->maxbandl];
  1008.   }
  1010.   while( part2remain > 16 ) {
  1011.     getbits(16); /* Dismiss stuffing Bits */
  1012.     part2remain -= 16;
  1013.   }
  1015.     ///MessageBox(NULL, "DEQUANTIZE11", "", MB_OK);
  1018.   if(part2remain > 0)
  1019.     getbits(part2remain);
  1020.   else if(part2remain < 0) {
  1021.     return 1;
  1022.   }
  1023.   return 0;
  1024. }
  1027. /* 
  1028.  * III_stereo: calculate real channel values for Joint-I-Stereo-mode
  1029.  */
  1030. static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,
  1031.    struct gr_info_s *gr_info,int sfreq,int ms_stereo,int lsf)
  1032. {
  1033.       real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;
  1034.       struct bandInfoStruct *bi = &bandInfo[sfreq];
  1035.       real *tab1,*tab2;
  1037.       if(lsf) {
  1038.         int p = gr_info->scalefac_compress & 0x1;
  1039.     if(ms_stereo) {
  1040.           tab1 = pow1_2[p]; tab2 = pow2_2[p];
  1041.         }
  1042.         else {
  1043.           tab1 = pow1_1[p]; tab2 = pow2_1[p];
  1044.         }
  1045.       }
  1046.       else {
  1047.         if(ms_stereo) {
  1048.           tab1 = tan1_2; tab2 = tan2_2;
  1049.         }
  1050.         else {
  1051.           tab1 = tan1_1; tab2 = tan2_1;
  1052.         }
  1053.       }
  1055.       if (gr_info->block_type == 2)
  1056.       {
  1057.          int lwin,do_l = 0;
  1058.          if( gr_info->mixed_block_flag )
  1059.            do_l = 1;
  1061.          for (lwin=0;lwin<3;lwin++) /* process each window */
  1062.          {
  1063.              /* get first band with zero values */
  1064.            int is_p,sb,idx,sfb = gr_info->maxband[lwin];  /* sfb is minimal 3 for mixed mode */
  1065.            if(sfb > 3)
  1066.              do_l = 0;
  1068.            for(;sfb<12;sfb++)
  1069.            {
  1070.              is_p = scalefac[sfb*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ 
  1071.              if(is_p != 7) {
  1072.                real t1,t2;
  1073.                sb = bi->shortDiff[sfb];
  1074.                idx = bi->shortIdx[sfb] + lwin;
  1075.                t1 = tab1[is_p]; t2 = tab2[is_p];
  1076.                for (; sb > 0; sb--,idx+=3)
  1077.                {
  1078.                  real v = xr[0][idx];
  1079.                  xr[0][idx] = v * t1;
  1080.                  xr[1][idx] = v * t2;
  1081.                }
  1082.              }
  1083.            }
  1085. #if 1
  1086. /* in the original: copy 10 to 11 , here: copy 11 to 12 
  1087. maybe still wrong??? (copy 12 to 13?) */
  1088.            is_p = scalefac[11*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */
  1089.            sb = bi->shortDiff[12];
  1090.            idx = bi->shortIdx[12] + lwin;
  1091. #else
  1092.            is_p = scalefac[10*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */
  1093.            sb = bi->shortDiff[11];
  1094.            idx = bi->shortIdx[11] + lwin;
  1095. #endif
  1096.            if(is_p != 7)
  1097.            {
  1098.              real t1,t2;
  1099.              t1 = tab1[is_p]; t2 = tab2[is_p];
  1100.              for ( ; sb > 0; sb--,idx+=3 )
  1101.              {  
  1102.                real v = xr[0][idx];
  1103.                xr[0][idx] = v * t1;
  1104.                xr[1][idx] = v * t2;
  1105.              }
  1106.            }
  1107.          } /* end for(lwin; .. ; . ) */
  1109.          if (do_l)
  1110.          {
  1111. /* also check l-part, if ALL bands in the three windows are 'empty'
  1112.  * and mode = mixed_mode 
  1113.  */
  1114.            int sfb = gr_info->maxbandl;
  1115.            int idx = bi->longIdx[sfb];
  1117.            for ( ; sfb<8; sfb++ )
  1118.            {
  1119.              int sb = bi->longDiff[sfb];
  1120.              int is_p = scalefac[sfb]; /* scale: 0-15 */
  1121.              if(is_p != 7) {
  1122.                real t1,t2;
  1123.                t1 = tab1[is_p]; t2 = tab2[is_p];
  1124.                for ( ; sb > 0; sb--,idx++)
  1125.                {
  1126.                  real v = xr[0][idx];
  1127.                  xr[0][idx] = v * t1;
  1128.                  xr[1][idx] = v * t2;
  1129.                }
  1130.              }
  1131.              else 
  1132.                idx += sb;
  1133.            }
  1134.          }     
  1135.       } 
  1136.       else /* ((gr_info->block_type != 2)) */
  1137.       {
  1138.         int sfb = gr_info->maxbandl;
  1139.         int is_p,idx = bi->longIdx[sfb];
  1140.         for ( ; sfb<21; sfb++)
  1141.         {
  1142.           int sb = bi->longDiff[sfb];
  1143.           is_p = scalefac[sfb]; /* scale: 0-15 */
  1144.           if(is_p != 7) {
  1145.             real t1,t2;
  1146.             t1 = tab1[is_p]; t2 = tab2[is_p];
  1147.             for ( ; sb > 0; sb--,idx++)
  1148.             {
  1149.                real v = xr[0][idx];
  1150.                xr[0][idx] = v * t1;
  1151.                xr[1][idx] = v * t2;
  1152.             }
  1153.           }
  1154.           else
  1155.             idx += sb;
  1156.         }
  1158.         is_p = scalefac[20]; /* copy l-band 20 to l-band 21 */
  1159.         if(is_p != 7)
  1160.         {
  1161.           int sb;
  1162.           real t1 = tab1[is_p],t2 = tab2[is_p]; 
  1164.           for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ )
  1165.           {
  1166.             real v = xr[0][idx];
  1167.             xr[0][idx] = v * t1;
  1168.             xr[1][idx] = v * t2;
  1169.           }
  1170.         }
  1171.       } /* ... */
  1172. }
  1174. static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_info)
  1175. {
  1176.    int sblim;
  1178.    if(gr_info->block_type == 2)
  1179.    {
  1180.       if(!gr_info->mixed_block_flag) 
  1181.         return;
  1182.       sblim = 1; 
  1183.    }
  1184.    else {
  1185.      sblim = gr_info->maxb-1;
  1186.    }
  1188.    /* 31 alias-reduction operations between each pair of sub-bands */
  1189.    /* with 8 butterflies between each pair                         */
  1191.    {
  1192.      int sb;
  1193.      real *xr1=(real *) xr[1];
  1195.      for(sb=sblim;sb;sb--,xr1+=10)
  1196.      {
  1197.        int ss;
  1198.        real *cs=aa_cs,*ca=aa_ca;
  1199.        real *xr2 = xr1;
  1201.        for(ss=7;ss>=0;ss--)
  1202.        {       /* upper and lower butterfly inputs */
  1203.          register real bu = *--xr2,bd = *xr1;
  1204.          *xr2   = (bu * (*cs)   ) - (bd * (*ca)   );
  1205.          *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
  1206.        }
  1207.      }
  1208.   }
  1209. }
  1211. /*
  1212.  DCT insipired by Jeff Tsay's DCT from the maplay package
  1213.  this is an optimized version with manual unroll.
  1215.  References:
  1216.  [1] S. Winograd: "On Computing the Discrete Fourier Transform",
  1217.      Mathematics of Computation, Volume 32, Number 141, January 1978,
  1218.      Pages 175-199
  1219. */
  1221. static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
  1222. {
  1223.   {
  1224.     register real *in = inbuf;
  1226.     in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];
  1227.     in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];
  1228.     in[11]+=in[10]; in[10]+=in[9];  in[9] +=in[8];
  1229.     in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
  1230.     in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];
  1231.     in[2] +=in[1];  in[1] +=in[0];
  1233.     in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
  1234.     in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
  1237.   {
  1239. #define MACRO0(v) { 
  1240.     real tmp; 
  1241.     out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; 
  1242.     out2[8-(v)] = tmp * w[26-(v)];  } 
  1243.     sum0 -= sum1; 
  1244.     ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; 
  1245.     ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; 
  1246. #define MACRO1(v) { 
  1247. real sum0,sum1; 
  1248.     sum0 = tmp1a + tmp2a; 
  1249. sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; 
  1250. MACRO0(v); }
  1251. #define MACRO2(v) { 
  1252.     real sum0,sum1; 
  1253.     sum0 = tmp2a - tmp1a; 
  1254.     sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; 
  1255. MACRO0(v); }
  1257.     register const real *c = COS9;
  1258.     register real *out2 = o2;
  1259. register real *w = wintab;
  1260. register real *out1 = o1;
  1261. register real *ts = tsbuf;
  1263.     real ta33,ta66,tb33,tb66;
  1265.     ta33 = in[2*3+0] * c[3];
  1266.     ta66 = in[2*6+0] * c[6];
  1267.     tb33 = in[2*3+1] * c[3];
  1268.     tb66 = in[2*6+1] * c[6];
  1270.     { 
  1271.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1272.       tmp1a =             in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7];
  1273.       tmp1b =             in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7];
  1274.       tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8];
  1275.       tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8];
  1277.       MACRO1(0);
  1278.       MACRO2(8);
  1279.     }
  1281.     {
  1282.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1283.       tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3];
  1284.       tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3];
  1285.       tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0];
  1286.       tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1];
  1288.       MACRO1(1);
  1289.       MACRO2(7);
  1290.     }
  1292.     {
  1293.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1294.       tmp1a =             in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1];
  1295.       tmp1b =             in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1];
  1296.       tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4];
  1297.       tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4];
  1299.       MACRO1(2);
  1300.       MACRO2(6);
  1301.     }
  1303.     {
  1304.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1305.       tmp1a =             in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5];
  1306.       tmp1b =             in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5];
  1307.       tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2];
  1308.       tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2];
  1310.       MACRO1(3);
  1311.       MACRO2(5);
  1312.     }
  1314. {
  1315. real sum0,sum1;
  1316.      sum0 =  in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0];
  1317.      sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4];
  1318. MACRO0(4);
  1319. }
  1320.   }
  1322.   }
  1323. }
  1325. /*
  1326.  * new DCT12
  1327.  */
  1328. static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts)
  1329. {
  1330. #define DCT12_PART1 
  1331.              in5 = in[5*3];  
  1332.      in5 += (in4 = in[4*3]); 
  1333.      in4 += (in3 = in[3*3]); 
  1334.      in3 += (in2 = in[2*3]); 
  1335.      in2 += (in1 = in[1*3]); 
  1336.      in1 += (in0 = in[0*3]); 
  1337.                              
  1338.      in5 += in3; in3 += in1; 
  1339.                              
  1340.      in2 *= COS6_1; 
  1341.      in3 *= COS6_1; 
  1343. #define DCT12_PART2 
  1344.      in0 += in4 * COS6_2; 
  1345.                           
  1346.      in4 = in0 + in2;     
  1347.      in0 -= in2;          
  1348.                           
  1349.      in1 += in5 * COS6_2; 
  1350.                           
  1351.      in5 = (in1 + in3) * tfcos12[0]; 
  1352.      in1 = (in1 - in3) * tfcos12[2]; 
  1353.                          
  1354.      in3 = in4 + in5;    
  1355.      in4 -= in5;         
  1356.                          
  1357.      in2 = in0 + in1;    
  1358.      in0 -= in1;
  1361.    {
  1362.      real in0,in1,in2,in3,in4,in5;
  1363.      register real *out1 = rawout1;
  1364.      ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];
  1365.      ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];
  1366.  
  1367.      DCT12_PART1
  1369.      {
  1370.        real tmp0,tmp1 = (in0 - in4);
  1371.        {
  1372.          real tmp2 = (in1 - in5) * tfcos12[1];
  1373.          tmp0 = tmp1 + tmp2;
  1374.          tmp1 -= tmp2;
  1375.        }
  1376.        ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1];
  1377.        ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1];
  1378.        ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1];
  1379.        ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1];
  1380.      }
  1382.      DCT12_PART2
  1384.      ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0];
  1385.      ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0];
  1386.      ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2];
  1387.      ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2];
  1389.      ts[(6+0)*SBLIMIT]  = out1[6+0] + in0 * wi[0];
  1390.      ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0];
  1391.      ts[(6+2)*SBLIMIT]  = out1[6+2] + in4 * wi[2];
  1392.      ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2];
  1393.   }
  1395.   in++;
  1397.   {
  1398.      real in0,in1,in2,in3,in4,in5;
  1399.      register real *out2 = rawout2;
  1400.  
  1401.      DCT12_PART1
  1403.      {
  1404.        real tmp0,tmp1 = (in0 - in4);
  1405.        {
  1406.          real tmp2 = (in1 - in5) * tfcos12[1];
  1407.          tmp0 = tmp1 + tmp2;
  1408.          tmp1 -= tmp2;
  1409.        }
  1410.        out2[5-1] = tmp0 * wi[11-1];
  1411.        out2[0+1] = tmp0 * wi[6+1];
  1412.        ts[(12+1)*SBLIMIT] += tmp1 * wi[1];
  1413.        ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1];
  1414.      }
  1416.      DCT12_PART2
  1418.      out2[5-0] = in2 * wi[11-0];
  1419.      out2[0+0] = in2 * wi[6+0];
  1420.      out2[0+2] = in3 * wi[6+2];
  1421.      out2[5-2] = in3 * wi[11-2];
  1423.      ts[(12+0)*SBLIMIT] += in0 * wi[0];
  1424.      ts[(17-0)*SBLIMIT] += in0 * wi[5-0];
  1425.      ts[(12+2)*SBLIMIT] += in4 * wi[2];
  1426.      ts[(17-2)*SBLIMIT] += in4 * wi[5-2];
  1427.   }
  1429.   in++; 
  1431.   {
  1432.      real in0,in1,in2,in3,in4,in5;
  1433.      register real *out2 = rawout2;
  1434.      out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;
  1436.      DCT12_PART1
  1438.      {
  1439.        real tmp0,tmp1 = (in0 - in4);
  1440.        {
  1441.          real tmp2 = (in1 - in5) * tfcos12[1];
  1442.          tmp0 = tmp1 + tmp2;
  1443.          tmp1 -= tmp2;
  1444.        }
  1445.        out2[11-1] = tmp0 * wi[11-1];
  1446.        out2[6 +1] = tmp0 * wi[6+1];
  1447.        out2[0+1] += tmp1 * wi[1];
  1448.        out2[5-1] += tmp1 * wi[5-1];
  1449.      }
  1451.      DCT12_PART2
  1453.      out2[11-0] = in2 * wi[11-0];
  1454.      out2[6 +0] = in2 * wi[6+0];
  1455.      out2[6 +2] = in3 * wi[6+2];
  1456.      out2[11-2] = in3 * wi[11-2];
  1458.      out2[0+0] += in0 * wi[0];
  1459.      out2[5-0] += in0 * wi[5-0];
  1460.      out2[0+2] += in4 * wi[2];
  1461.      out2[5-2] += in4 * wi[5-2];
  1462.   }
  1463. }
  1465. /*
  1466.  * III_hybrid
  1467.  */
  1468. static void III_hybrid(real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],
  1469.    int ch,struct gr_info_s *gr_info)
  1470. {
  1471.    real *tspnt = (real *) tsOut;
  1472.    real (*block)[2][SBLIMIT*SSLIMIT] = gmp->hybrid_block;
  1473.    int *blc = gmp->hybrid_blc;
  1474.    real *rawout1,*rawout2;
  1475.    int bt;
  1476.    int sb = 0;
  1478.    {
  1479.      int b = blc[ch];
  1480.      rawout1=block[b][ch];
  1481.      b=-b+1;
  1482.      rawout2=block[b][ch];
  1483.      blc[ch] = b;
  1484.    }
  1486.   
  1487.    if(gr_info->mixed_block_flag) {
  1488.      sb = 2;
  1489.      dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);
  1490.      dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
  1491.      rawout1 += 36; rawout2 += 36; tspnt += 2;
  1492.    }
  1493.  
  1494.    bt = gr_info->block_type;
  1495.    if(bt == 2) {
  1496.      for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1497.        dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt);
  1498.        dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);
  1499.      }
  1500.    }
  1501.    else {
  1502.      for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1503.        dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
  1504.        dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
  1505.      }
  1506.    }
  1508.    for(;sb<SBLIMIT;sb++,tspnt++) {
  1509.      int i;
  1510.      for(i=0;i<SSLIMIT;i++) {
  1511.        tspnt[i*SBLIMIT] = *rawout1++;
  1512.        *rawout2++ = 0.0;
  1513.      }
  1514.    }
  1515. }
  1517. /*
  1518.  * main layer3 handler
  1519.  */
  1520. int do_layer3(struct frame *fr,unsigned char *pcm_sample,int *pcm_point)
  1521. {
  1522.   int gr, ch, ss,clip=0;
  1523.   int scalefacs[2][39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
  1524.   struct III_sideinfo sideinfo;
  1525.   int stereo = fr->stereo;
  1526.   int single = fr->single;
  1527.   int ms_stereo,i_stereo;
  1528.   int sfreq = fr->sampling_frequency;
  1529.   int stereo1,granules;
  1531.   //MessageBox(NULL, "entering layer 3", "", MB_OK);
  1533.   if(stereo == 1) { /* stream is mono */
  1534.     stereo1 = 1;
  1535.     single = 0;
  1536.   }
  1537.   else if(single >= 0) /* stream is stereo, but force to mono */
  1538.     stereo1 = 1;
  1539.   else
  1540.     stereo1 = 2;
  1542.   if(fr->mode == MPG_MD_JOINT_STEREO) {
  1543.     ms_stereo = fr->mode_ext & 0x2;
  1544.     i_stereo  = fr->mode_ext & 0x1;
  1545.   }
  1546.   else
  1547.     ms_stereo = i_stereo = 0;
  1549.   //MessageBox(NULL, "entering layer 3-1", "", MB_OK);
  1551.   if(fr->lsf) {
  1552.     granules = 1;
  1553.     III_get_side_info_2(&sideinfo,stereo,ms_stereo,sfreq,single);
  1554.   }
  1555.   else {
  1556.     granules = 2;
  1557.     III_get_side_info_1(&sideinfo,stereo,ms_stereo,sfreq,single);
  1558.   }
  1560.   //MessageBox(NULL, "entering layer 3-2", "", MB_OK);
  1562.   if(set_pointer(sideinfo.main_data_begin) == MP3_ERR)
  1563.     return 0;
  1565.   for (gr=0;gr<granules;gr++) 
  1566.   {
  1567.     real hybridIn[2][SBLIMIT][SSLIMIT];
  1568.     real hybridOut[2][SSLIMIT][SBLIMIT];
  1570.     {
  1571.       struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]);
  1572.       long part2bits;
  1573.       
  1574.   //MessageBox(NULL, "entering layer 3-21", "", MB_OK);
  1576.   if(fr->lsf)
  1577.         part2bits = III_get_scale_factors_2(scalefacs[0],gr_info,0);
  1578.       else {
  1579.         part2bits = III_get_scale_factors_1(scalefacs[0],gr_info);
  1580.       }
  1582.   //MessageBox(NULL, "entering layer 3-22", "", MB_OK);
  1584.       if(III_dequantize_sample(hybridIn[0], scalefacs[0],gr_info,sfreq,part2bits))
  1585.         return clip;
  1587.     //MessageBox(NULL, "DEQAUNTIZE END", "", MB_OK);
  1589.     }
  1590.     if(stereo == 2) {
  1591.       struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]);
  1592.       long part2bits;
  1594.      //MessageBox(NULL, "entering layer 3-23", "", MB_OK);
  1596.       if(fr->lsf) 
  1597.         part2bits = III_get_scale_factors_2(scalefacs[1],gr_info,i_stereo);
  1598.       else {
  1599.         part2bits = III_get_scale_factors_1(scalefacs[1],gr_info);
  1600.       }
  1602.      //MessageBox(NULL, "entering layer 3-24", "", MB_OK);
  1605.       if(III_dequantize_sample(hybridIn[1],scalefacs[1],gr_info,sfreq,part2bits))
  1606.           return clip;
  1608.      //MessageBox(NULL, "entering layer 3-25", "", MB_OK);
  1610.       if(ms_stereo) {
  1611.         int i;
  1612.         for(i=0;i<SBLIMIT*SSLIMIT;i++) {
  1613.           real tmp0,tmp1;
  1614.           tmp0 = ((real *) hybridIn[0])[i];
  1615.           tmp1 = ((real *) hybridIn[1])[i];
  1616.           ((real *) hybridIn[0])[i] = tmp0 + tmp1;
  1617.           ((real *) hybridIn[1])[i] = tmp0 - tmp1;  
  1618.         }
  1619.       }
  1621.      //MessageBox(NULL, "entering layer 3-26", "", MB_OK);
  1624. if(i_stereo)
  1625. III_i_stereo(hybridIn,scalefacs[1],gr_info,sfreq,ms_stereo,fr->lsf);
  1627. if(ms_stereo || i_stereo || (single == 3) ) {
  1628. if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb) 
  1629. sideinfo.ch[0].gr[gr].maxb = gr_info->maxb;
  1630. else
  1631. gr_info->maxb = sideinfo.ch[0].gr[gr].maxb;
  1632. }
  1634. //MessageBox(NULL, "entering layer 3-27", "", MB_OK);
  1636. switch(single) {
  1637. case 3: {
  1638. register int i;
  1639. register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1640. for(i=0;i<SSLIMIT*gr_info->maxb;i++,in0++)
  1641. *in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */ 
  1642.            break;
  1643. }
  1644. case 1: {
  1645. register int i;
  1646. register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1647. for(i=0;i<SSLIMIT*gr_info->maxb;i++)
  1648. *in0++ = *in1++;
  1649. break;
  1650. }
  1651. }
  1652. }
  1654.      //MessageBox(NULL, "entering layer 3-28", "", MB_OK);
  1657. for(ch=0;ch<stereo1;ch++) {
  1658. struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]);
  1659. III_antialias(hybridIn[ch],gr_info);
  1660. III_hybrid(hybridIn[ch], hybridOut[ch], ch,gr_info);
  1661. }
  1663.      //MessageBox(NULL, "entering layer 3-29", "", MB_OK);
  1666. if (single >= 0) {
  1667.      for(ss=0;ss<SSLIMIT;ss++)
  1668.          clip += synth_1to1_mono(hybridOut[0][ss],pcm_sample,pcm_point);
  1669.        } else {
  1670.      for(ss=0;ss<SSLIMIT;ss++) {
  1671.          int p1 = *pcm_point;
  1672.          clip += synth_1to1(hybridOut[0][ss],0,pcm_sample,&p1);
  1673.          clip += synth_1to1(hybridOut[1][ss],1,pcm_sample,pcm_point);
  1674. }
  1675. }
  1676. }
  1678.     //MessageBox(NULL, "entering layer 3-3", "", MB_OK);
  1680. return clip;
  1681. }