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

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

多媒体编程

开发平台：

Visual C++

Layer3.cpp：源码内容
  3. #include <stdlib.h>
  4. #include <windows.h>
  6. #include "mpg123.h"
  7. #include "mpglib.h"
  8. #include "huffman.h"
  10. extern struct mpstr *gmp;
  12. static real ispow[8207];
  13. static real aa_ca[8],aa_cs[8];
  14. static real COS1[12][6];
  15. static real win[4][36];
  16. static real win1[4][36];
  17. static real gainpow2[256+118+4];
  18. static real COS9[9];
  19. static real COS6_1,COS6_2;
  20. static real tfcos36[9];
  21. static real tfcos12[3];
  23. struct bandInfoStruct {
  24.   short longIdx[23];
  25.   short longDiff[22];
  26.   short shortIdx[14];
  27.   short shortDiff[13];
  28. };
  31. int longLimit[9][23];
  32. int shortLimit[9][14];
  34. struct bandInfoStruct bandInfo[9] = { 
  36.  { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},
  37.    {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},
  38.    {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},
  39.    {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,
  41.  { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},
  42.    {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},
  43.    {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},
  44.    {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,
  46.  { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,
  47.    {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,
  48.    {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} ,
  49.    {4,4,4,4,6,8,12,16,20,26,34,42,12} }  ,
  52.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  53.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,
  54.    {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} ,
  55.    {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,
  57.  { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
  58.    {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } ,
  59.    {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} ,
  60.    {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,
  62.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  63.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },
  64.    {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},
  65.    {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,
  67.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
  68.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
  69.    {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
  70.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  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,12,24,36,54,78,108,144,186,240,312,402,522,576},
  74.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  75.  { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
  76.    {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},
  77.    {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},
  78.    {8,8,8,12,16,20,24,28,36,2,2,2,26} } ,
  79. };
  81. static int mapbuf0[9][152];
  82. static int mapbuf1[9][156];
  83. static int mapbuf2[9][44];
  84. static int *map[9][3];
  85. static int *mapend[9][3];
  87. static unsigned int n_slen2[512]; 
  88. static unsigned int i_slen2[256]; 
  90. static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];
  91. static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];
  94. void init_layer3(int down_sample_sblimit)
  95. {
  96.   int i,j,k,l;
  98.   for(i=-256;i<118+4;i++)
  99.     gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) );
  101.   for(i=0;i<8207;i++)
  102.     ispow[i] = pow((double)i,(double)4.0/3.0);
  104.   for (i=0;i<8;i++)
  105.   {
  106.     static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
  107.     double sq=sqrt(1.0+Ci[i]*Ci[i]);
  108.     aa_cs[i] = 1.0/sq;
  109.     aa_ca[i] = Ci[i]/sq;
  110.   }
  112.   for(i=0;i<18;i++)
  113.   {
  114.     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 );
  115.     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 );
  116.   }
  117.   for(i=0;i<6;i++)
  118.   {
  119.     win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
  120.     win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );
  121.     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 );
  122.     win[1][i+30] = win[3][i] = 0.0;
  123.     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 );
  124.   }
  126.   for(i=0;i<9;i++)
  127.     COS9[i] = cos( M_PI / 18.0 * (double) i);
  129.   for(i=0;i<9;i++)
  130.     tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 );
  131.   for(i=0;i<3;i++)
  132.     tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 );
  134.   COS6_1 = cos( M_PI / 6.0 * (double) 1);
  135.   COS6_2 = cos( M_PI / 6.0 * (double) 2);
  137.   for(i=0;i<12;i++)
  138.   {
  139.     win[2][i]  = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );
  140.     for(j=0;j<6;j++)
  141.       COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );
  142.   }
  144.   for(j=0;j<4;j++) {
  145.     static int len[4] = { 36,36,12,36 };
  146.     for(i=0;i<len[j];i+=2)
  147.       win1[j][i] = + win[j][i];
  148.     for(i=1;i<len[j];i+=2)
  149.       win1[j][i] = - win[j][i];
  150.   }
  152.   for(i=0;i<16;i++)
  153.   {
  154.     double t = tan( (double) i * M_PI / 12.0 );
  155.     tan1_1[i] = t / (1.0+t);
  156.     tan2_1[i] = 1.0 / (1.0 + t);
  157.     tan1_2[i] = M_SQRT2 * t / (1.0+t);
  158.     tan2_2[i] = M_SQRT2 / (1.0 + t);
  160.     for(j=0;j<2;j++) {
  161.       double base = pow(2.0,-0.25*(j+1.0));
  162.       double p1=1.0,p2=1.0;
  163.       if(i > 0) {
  164.         if( i & 1 )
  165.           p1 = pow(base,(i+1.0)*0.5);
  166.         else
  167.           p2 = pow(base,i*0.5);
  168.       }
  169.       pow1_1[j][i] = p1;
  170.       pow2_1[j][i] = p2;
  171.       pow1_2[j][i] = M_SQRT2 * p1;
  172.       pow2_2[j][i] = M_SQRT2 * p2;
  173.     }
  174.   }
  176.   for(j=0;j<9;j++)
  177.   {
  178.    struct bandInfoStruct *bi = &bandInfo[j];
  179.    int *mp;
  180.    int cb,lwin;
  181.    short *bdf;
  183.    mp = map[j][0] = mapbuf0[j];
  184.    bdf = bi->longDiff;
  185.    for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {
  186.      *mp++ = (*bdf) >> 1;
  187.      *mp++ = i;
  188.      *mp++ = 3;
  189.      *mp++ = cb;
  190.    }
  191.    bdf = bi->shortDiff+3;
  192.    for(cb=3;cb<13;cb++) {
  193.      int l = (*bdf++) >> 1;
  194.      for(lwin=0;lwin<3;lwin++) {
  195.        *mp++ = l;
  196.        *mp++ = i + lwin;
  197.        *mp++ = lwin;
  198.        *mp++ = cb;
  199.      }
  200.      i += 6*l;
  201.    }
  202.    mapend[j][0] = mp;
  204.    mp = map[j][1] = mapbuf1[j];
  205.    bdf = bi->shortDiff+0;
  206.    for(i=0,cb=0;cb<13;cb++) {
  207.      int l = (*bdf++) >> 1;
  208.      for(lwin=0;lwin<3;lwin++) {
  209.        *mp++ = l;
  210.        *mp++ = i + lwin;
  211.        *mp++ = lwin;
  212.        *mp++ = cb;
  213.      }
  214.      i += 6*l;
  215.    }
  216.    mapend[j][1] = mp;
  218.    mp = map[j][2] = mapbuf2[j];
  219.    bdf = bi->longDiff;
  220.    for(cb = 0; cb < 22 ; cb++) {
  221.      *mp++ = (*bdf++) >> 1;
  222.      *mp++ = cb;
  223.    }
  224.    mapend[j][2] = mp;
  226.   }
  228.   for(j=0;j<9;j++) {
  229.     for(i=0;i<23;i++) {
  230.       longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
  231.       if(longLimit[j][i] > (down_sample_sblimit) )
  232.         longLimit[j][i] = down_sample_sblimit;
  233.     }
  234.     for(i=0;i<14;i++) {
  235.       shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
  236.       if(shortLimit[j][i] > (down_sample_sblimit) )
  237.         shortLimit[j][i] = down_sample_sblimit;
  238.     }
  239.   }
  241.   for(i=0;i<5;i++) {
  242.     for(j=0;j<6;j++) {
  243.       for(k=0;k<6;k++) {
  244.         int n = k + j * 6 + i * 36;
  245.         i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12);
  246.       }
  247.     }
  248.   }
  249.   for(i=0;i<4;i++) {
  250.     for(j=0;j<4;j++) {
  251.       for(k=0;k<4;k++) {
  252.         int n = k + j * 4 + i * 16;
  253.         i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12);
  254.       }
  255.     }
  256.   }
  257.   for(i=0;i<4;i++) {
  258.     for(j=0;j<3;j++) {
  259.       int n = j + i * 3;
  260.       i_slen2[n+244] = i|(j<<3) | (5<<12);
  261.       n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15);
  262.     }
  263.   }
  265.   for(i=0;i<5;i++) {
  266.     for(j=0;j<5;j++) {
  267.       for(k=0;k<4;k++) {
  268.         for(l=0;l<4;l++) {
  269.           int n = l + k * 4 + j * 16 + i * 80;
  270.           n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12);
  271.         }
  272.       }
  273.     }
  274.   }
  275.   for(i=0;i<5;i++) {
  276.     for(j=0;j<5;j++) {
  277.       for(k=0;k<4;k++) {
  278.         int n = k + j * 4 + i * 20;
  279.         n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12);
  280.       }
  281.     }
  282.   }
  283. }
  288. static void III_get_side_info_1(struct III_sideinfo *si,int stereo,
  289.  int ms_stereo,long sfreq,int single)
  290. {
  291.    int ch, gr;
  292.    int powdiff = (single == 3) ? 4 : 0;
  294.    si->main_data_begin = getbits(9);
  295.    if (stereo == 1)
  296.      si->private_bits = getbits_fast(5);
  297.    else 
  298.      si->private_bits = getbits_fast(3);
  300.    for (ch=0; ch<stereo; ch++) {
  301.        si->ch[ch].gr[0].scfsi = -1;
  302.        si->ch[ch].gr[1].scfsi = getbits_fast(4);
  303.    }
  305.    for (gr=0; gr<2; gr++) 
  306.    {
  307.      for (ch=0; ch<stereo; ch++) 
  308.      {
  309.        register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  311.        gr_info->part2_3_length = getbits(12);
  312.        gr_info->big_values = getbits_fast(9);
  313.        if(gr_info->big_values > 288) {
  314.           gr_info->big_values = 288;
  315.        }
  316.        gr_info->pow2gain = gainpow2+256 - getbits_fast(8) + powdiff;
  317.        if(ms_stereo)
  318.          gr_info->pow2gain += 2;
  319.        gr_info->scalefac_compress = getbits_fast(4);
  321.        if(get1bit()) 
  322.        {
  323.          int i;
  324.          gr_info->block_type = getbits_fast(2);
  325.          gr_info->mixed_block_flag = get1bit();
  326.          gr_info->table_select[0] = getbits_fast(5);
  327.          gr_info->table_select[1] = getbits_fast(5);
  329.          gr_info->table_select[2] = 0;
  330.          for(i=0;i<3;i++)
  331.            gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(3)<<3);
  333.          if(gr_info->block_type == 0) {
  334.    return;
  335.          }
  336.        
  337.          gr_info->region1start = 36>>1;
  338.          gr_info->region2start = 576>>1;
  339.        }
  340.        else 
  341.        {
  342.          int i,r0c,r1c;
  343.          for (i=0; i<3; i++)
  344.            gr_info->table_select[i] = getbits_fast(5);
  345.          r0c = getbits_fast(4);
  346.          r1c = getbits_fast(3);
  347.          gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  348.          gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  349.          gr_info->block_type = 0;
  350.          gr_info->mixed_block_flag = 0;
  351.        }
  352.        gr_info->preflag = get1bit();
  353.        gr_info->scalefac_scale = get1bit();
  354.        gr_info->count1table_select = get1bit();
  355.      }
  356.    }
  357. }
  362. static void III_get_side_info_2(struct III_sideinfo *si,int stereo,
  363.  int ms_stereo,long sfreq,int single)
  364. {
  365.    int ch;
  366.    int powdiff = (single == 3) ? 4 : 0;
  368.    si->main_data_begin = getbits(8);
  369.    if (stereo == 1)
  370.      si->private_bits = get1bit();
  371.    else 
  372.      si->private_bits = getbits_fast(2);
  374.    for (ch=0; ch<stereo; ch++) 
  375.    {
  376.        register struct gr_info_s *gr_info = &(si->ch[ch].gr[0]);
  378.        gr_info->part2_3_length = getbits(12);
  379.        gr_info->big_values = getbits_fast(9);
  380.        if(gr_info->big_values > 288) {
  381.  gr_info->big_values = 288;
  382.        }
  383.        gr_info->pow2gain = gainpow2+256 - getbits_fast(8) + powdiff;
  384.        if(ms_stereo)
  385.          gr_info->pow2gain += 2;
  386.        gr_info->scalefac_compress = getbits(9);
  388.        if(get1bit()) 
  389.        {
  390.          int i;
  391.          gr_info->block_type = getbits_fast(2);
  392.          gr_info->mixed_block_flag = get1bit();
  393.          gr_info->table_select[0] = getbits_fast(5);
  394.          gr_info->table_select[1] = getbits_fast(5);
  395.          /*
  396.           * table_select[2] not needed, because there is no region2,
  397.           * but to satisfy some verifications tools we set it either.
  398.           */
  399.          gr_info->table_select[2] = 0;
  400.          for(i=0;i<3;i++)
  401.            gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(3)<<3);
  403.          if(gr_info->block_type == 0) {
  404.            return;
  405.          }
  407.          if(gr_info->block_type == 2)
  408.            gr_info->region1start = 36>>1;
  409.          else if(sfreq == 8)
  411.            gr_info->region1start = 108>>1;
  412.          else
  413.            gr_info->region1start = 54>>1;
  414.          gr_info->region2start = 576>>1;
  415.        }
  416.        else 
  417.        {
  418.          int i,r0c,r1c;
  419.          for (i=0; i<3; i++)
  420.            gr_info->table_select[i] = getbits_fast(5);
  421.          r0c = getbits_fast(4);
  422.          r1c = getbits_fast(3);
  423.          gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  424.          gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  425.          gr_info->block_type = 0;
  426.          gr_info->mixed_block_flag = 0;
  427.        }
  428.        gr_info->scalefac_scale = get1bit();
  429.        gr_info->count1table_select = get1bit();
  430.    }
  431. }
  436. static int III_get_scale_factors_1(int *scf,struct gr_info_s *gr_info)
  437. {
  438.    static const unsigned char slen[2][16] = {
  439.      {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  440.      {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
  441.    };
  442.    int numbits;
  443.    int num0 = slen[0][gr_info->scalefac_compress];
  444.    int num1 = slen[1][gr_info->scalefac_compress];
  446.     if (gr_info->block_type == 2) {
  447.       int i=18;
  448.       numbits = (num0 + num1) * 18;
  450.       if (gr_info->mixed_block_flag) {
  451.          for (i=8;i;i--)
  452.            *scf++ = getbits_fast(num0);
  453.          i = 9;
  454.          numbits -= num0; 
  455.       }
  457.       for (;i;i--)
  458.         *scf++ = getbits_fast(num0);
  459.       for (i = 18; i; i--)
  460.         *scf++ = getbits_fast(num1);
  461.       *scf++ = 0; *scf++ = 0; *scf++ = 0; 
  462.     }
  463.     else {
  464.       int i;
  465.       int scfsi = gr_info->scfsi;
  467.       if(scfsi < 0) { 
  468.          for(i=11;i;i--)
  469.            *scf++ = getbits_fast(num0);
  470.          for(i=10;i;i--)
  471.            *scf++ = getbits_fast(num1);
  472.          numbits = (num0 + num1) * 10 + num0;
  473.          *scf++ = 0;
  474.       }
  475.       else {
  476.         numbits = 0;
  477.         if(!(scfsi & 0x8)) {
  478.           for (i=0;i<6;i++)
  479.             *scf++ = getbits_fast(num0);
  480.           numbits += num0 * 6;
  481.         }
  482.         else {
  483.           scf += 6; 
  484.         }
  486.         if(!(scfsi & 0x4)) {
  487.           for (i=0;i<5;i++)
  488.             *scf++ = getbits_fast(num0);
  489.           numbits += num0 * 5;
  490.         }
  491.         else {
  492.           scf += 5;
  493.         }
  495.         if(!(scfsi & 0x2)) {
  496.           for(i=0;i<5;i++)
  497.             *scf++ = getbits_fast(num1);
  498.           numbits += num1 * 5;
  499.         }
  500.         else {
  501.           scf += 5; 
  502.         }
  504.         if(!(scfsi & 0x1)) {
  505.           for (i=0;i<5;i++)
  506.             *scf++ = getbits_fast(num1);
  507.           numbits += num1 * 5;
  508.         }
  509.         else {
  510.            scf += 5;
  511.         }
  512.         *scf++ = 0;  
  513.       }
  514.     }
  515.     return numbits;
  516. }
  519. /**
  520.  *
  521.  **/
  523. static int III_get_scale_factors_2(int *scf,struct gr_info_s *gr_info,int i_stereo)
  524. {
  525.   unsigned char *pnt;
  526.   int i,j;
  527.   unsigned int slen;
  528.   int n = 0;
  529.   int numbits = 0;
  531.   static unsigned char stab[3][6][4] = {
  532.    { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
  533.      { 7, 7, 7,0 } , { 6, 6, 6,3 } , {  8, 8,5,0} } ,
  534.    { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
  535.      {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
  536.    { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
  537.      { 6,15,12,0 } , { 6,12, 9,6 } , {  6,18,9,0} } }; 
  539.   if(i_stereo) 
  540.     slen = i_slen2[gr_info->scalefac_compress>>1];
  541.   else
  542.     slen = n_slen2[gr_info->scalefac_compress];
  544.   gr_info->preflag = (slen>>15) & 0x1;
  546.   n = 0;  
  547.   if( gr_info->block_type == 2 ) {
  548.     n++;
  549.     if(gr_info->mixed_block_flag)
  550.       n++;
  551.   }
  553.   pnt = stab[n][(slen>>12)&0x7];
  555.   for(i=0;i<4;i++) {
  556.     int num = slen & 0x7;
  557.     slen >>= 3;
  558.     if(num) {
  559.       for(j=0;j<(int)(pnt[i]);j++)
  560.         *scf++ = getbits_fast(num);
  561.       numbits += pnt[i] * num;
  562.     }
  563.     else {
  564.       for(j=0;j<(int)(pnt[i]);j++)
  565.         *scf++ = 0;
  566.     }
  567.   }
  568.   
  569.   n = (n << 1) + 1;
  570.   for(i=0;i<n;i++)
  571.     *scf++ = 0;
  573.   return numbits;
  574. }
  576. 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};
  577. 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};
  579. /**
  580.  *
  581.  **/
  583. static int III_dequantize_sample(real xr[SBLIMIT][SSLIMIT],int *scf,
  584.    struct gr_info_s *gr_info,int sfreq,int part2bits)
  585. {
  586.   int shift = 1 + gr_info->scalefac_scale;
  587.   real *xrpnt = (real *) xr;
  588.   int l[3],l3;
  589.   int part2remain = gr_info->part2_3_length - part2bits;
  590.   int *me;
  594.   {
  595.     int bv       = gr_info->big_values;
  596.     int region1  = gr_info->region1start;
  597.     int region2  = gr_info->region2start;
  599.     l3 = ((576>>1)-bv)>>1;   
  601.     if(bv <= region1) {
  602.       l[0] = bv; l[1] = 0; l[2] = 0;
  603.     }
  604.     else {
  605.       l[0] = region1;
  606.       if(bv <= region2) {
  607.         l[1] = bv - l[0];  l[2] = 0;
  608.       }
  609.       else {
  610.         l[1] = region2 - l[0]; l[2] = bv - region2;
  611.       }
  612.     }
  613.   }
  614.  
  615.   if(gr_info->block_type == 2) {
  618.   
  619. int i,max[4];
  620.     int step=0,lwin=0,cb=0;
  621.     register real v = 0.0;
  622.     register int *m,mc;
  626.     if(gr_info->mixed_block_flag) {
  627.       max[3] = -1;
  628.       max[0] = max[1] = max[2] = 2;
  629.       m = map[sfreq][0];
  630.       me = mapend[sfreq][0];
  631.     }
  632.     else {
  633.       max[0] = max[1] = max[2] = max[3] = -1;
  635.       m = map[sfreq][1];
  636.       me = mapend[sfreq][1];
  637.     }
  641.     mc = 0;
  642.     for(i=0;i<2;i++) {
  643.       int lp = l[i];
  644.       struct newhuff *h = ht+gr_info->table_select[i];
  645.       for(;lp;lp--,mc--) {
  646.         register int x,y;
  647.         if( (!mc) ) {
  648.           mc = *m++;
  649.           xrpnt = ((real *) xr) + (*m++);
  650.           lwin = *m++;
  651.           cb = *m++;
  652.           if(lwin == 3) {
  653.             v = gr_info->pow2gain[(*scf++) << shift];
  654.             step = 1;
  655.           }
  656.           else {
  657.             v = gr_info->full_gain[lwin][(*scf++) << shift];
  658.             step = 3;
  659.           }
  660.         }
  661.         {
  662.           register short *val = h->table;
  663.           while((y=*val++)<0) {
  664.             if (get1bit())
  665.               val -= y;
  666.             part2remain--;
  667.           }
  668.           x = y >> 4;
  669.           y &= 0xf;
  670.         }
  671.         if(x == 15) {
  672.           max[lwin] = cb;
  673.           part2remain -= h->linbits+1;
  674.           x += getbits(h->linbits);
  675.           if(get1bit())
  676.             *xrpnt = -ispow[x] * v;
  677.           else
  678.             *xrpnt =  ispow[x] * v;
  679.         }
  680.         else if(x) {
  681.           max[lwin] = cb;
  682.           if(get1bit())
  683.             *xrpnt = -ispow[x] * v;
  684.           else
  685.             *xrpnt =  ispow[x] * v;
  686.           part2remain--;
  687.         }
  688.         else
  689.           *xrpnt = 0.0;
  690.         xrpnt += step;
  691.         if(y == 15) {
  692.           max[lwin] = cb;
  693.           part2remain -= h->linbits+1;
  694.           y += getbits(h->linbits);
  695.           if(get1bit())
  696.             *xrpnt = -ispow[y] * v;
  697.           else
  698.             *xrpnt =  ispow[y] * v;
  699.         }
  700.         else if(y) {
  701.           max[lwin] = cb;
  702.           if(get1bit())
  703.             *xrpnt = -ispow[y] * v;
  704.           else
  705.             *xrpnt =  ispow[y] * v;
  706.           part2remain--;
  707.         }
  708.         else
  709.           *xrpnt = 0.0;
  710.         xrpnt += step;
  711.       }
  712.     }
  717.     for(;l3 && (part2remain > 0);l3--) {
  718.       struct newhuff *h = htc+gr_info->count1table_select;
  719.       register short *val = h->table,a;
  721.       while((a=*val++)<0) {
  722.         part2remain--;
  723.         if(part2remain < 0) {
  724.           part2remain++;
  725.           a = 0;
  726.           break;
  727.         }
  728.         if (get1bit())
  729.           val -= a;
  730.       }
  732.       for(i=0;i<4;i++) {
  733.         if(!(i & 1)) {
  734.           if(!mc) {
  735.             mc = *m++;
  736.             xrpnt = ((real *) xr) + (*m++);
  737.             lwin = *m++;
  738.             cb = *m++;
  739.             if(lwin == 3) {
  740.               v = gr_info->pow2gain[(*scf++) << shift];
  741.               step = 1;
  742.             }
  743.             else {
  744.               v = gr_info->full_gain[lwin][(*scf++) << shift];
  745.               step = 3;
  746.             }
  747.           }
  748.           mc--;
  749.         }
  750.         if( (a & (0x8>>i)) ) {
  751.           max[lwin] = cb;
  752.           part2remain--;
  753.           if(part2remain < 0) {
  754.             part2remain++;
  755.             break;
  756.           }
  757.           if(get1bit()) 
  758.             *xrpnt = -v;
  759.           else
  760.             *xrpnt = v;
  761.         }
  762.         else
  763.           *xrpnt = 0.0;
  764.         xrpnt += step;
  765.       }
  766.     }
  770.     while( m < me ) {
  771.       if(!mc) {
  772.         mc = *m++;
  773.         xrpnt = ((real *) xr) + *m++;
  774.         if( (*m++) == 3)
  775.           step = 1;
  776.         else
  777.           step = 3;
  778.         m++; /* cb */
  779.       }
  780.       mc--;
  781.       *xrpnt = 0.0;
  782.       xrpnt += step;
  783.       *xrpnt = 0.0;
  784.       xrpnt += step;
  786.     }
  791.     gr_info->maxband[0] = max[0]+1;
  792.     gr_info->maxband[1] = max[1]+1;
  793.     gr_info->maxband[2] = max[2]+1;
  794.     gr_info->maxbandl = max[3]+1;
  796.     {
  797.       int rmax = max[0] > max[1] ? max[0] : max[1];
  798.       rmax = (rmax > max[2] ? rmax : max[2]) + 1;
  799.       gr_info->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];
  800.     }
  802.   }
  803.   else {
  807.     int *pretab = gr_info->preflag ? pretab1 : pretab2;
  808.     int i,max = -1;
  809.     int cb = 0;
  810.     register int *m = map[sfreq][2];
  811.     register real v = 0.0;
  812.     register int mc = 0;
  813. #if 0
  814.     me = mapend[sfreq][2];
  815. #endif
  819.     for(i=0;i<3;i++) {
  820.       int lp = l[i];
  821.       struct newhuff *h = ht+gr_info->table_select[i];
  823.       for(;lp;lp--,mc--) {
  824.         int x,y;
  826.         if(!mc) {
  827.           mc = *m++;
  828.           v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
  829.           cb = *m++;
  830.         }
  831.         {
  832.           register short *val = h->table;
  833.           while((y=*val++)<0) {
  834.             if (get1bit())
  835.               val -= y;
  836.             part2remain--;
  837.           }
  838.           x = y >> 4;
  839.           y &= 0xf;
  840.         }
  841.         if (x == 15) {
  842.           max = cb;
  843.           part2remain -= h->linbits+1;
  844.           x += getbits(h->linbits);
  845.           if(get1bit())
  846.             *xrpnt++ = -ispow[x] * v;
  847.           else
  848.             *xrpnt++ =  ispow[x] * v;
  849.         }
  850.         else if(x) {
  851.           max = cb;
  852.           if(get1bit())
  853.             *xrpnt++ = -ispow[x] * v;
  854.           else
  855.             *xrpnt++ =  ispow[x] * v;
  856.           part2remain--;
  857.         }
  858.         else
  859.           *xrpnt++ = 0.0;
  861.         if (y == 15) {
  862.           max = cb;
  863.           part2remain -= h->linbits+1;
  864.           y += getbits(h->linbits);
  865.           if(get1bit())
  866.             *xrpnt++ = -ispow[y] * v;
  867.           else
  868.             *xrpnt++ =  ispow[y] * v;
  869.         }
  870.         else if(y) {
  871.           max = cb;
  872.           if(get1bit())
  873.             *xrpnt++ = -ispow[y] * v;
  874.           else
  875.             *xrpnt++ =  ispow[y] * v;
  876.           part2remain--;
  877.         }
  878.         else
  879.           *xrpnt++ = 0.0;
  880.       }
  881.     }
  885.     for(;l3 && (part2remain > 0);l3--) {
  886.       struct newhuff *h = htc+gr_info->count1table_select;
  887.       register short *val = h->table,a;
  891.       while((a=*val++)<0) {
  892.         part2remain--;
  893.         if(part2remain < 0) {
  894.           part2remain++;
  895.           a = 0;
  896.           break;
  897.         }
  898.         if (get1bit())
  899.           val -= a;
  900.       }
  905.       for(i=0;i<4;i++) {
  906.         if(!(i & 1)) {
  907.           if(!mc) {
  908.         
  909.     
  910. mc = *m++;
  911.             cb = *m++;
  914. v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
  915.          
  916. }
  917.           mc--;
  918.         }
  922.         if ( (a & (0x8>>i)) ) {
  923.           max = cb;
  924.           part2remain--;
  925.           if(part2remain < 0) {
  926.             part2remain++;
  927.             break;
  928.           }
  929.           if(get1bit())
  930.             *xrpnt++ = -v;
  931.           else
  932.             *xrpnt++ = v;
  933.         }
  934.         else
  935.           *xrpnt++ = 0.0;
  936.       }
  937.     }
  940.     for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i;i--) {
  941.       *xrpnt++ = 0.0;
  942.       *xrpnt++ = 0.0;
  943.     }
  945.     gr_info->maxbandl = max+1;
  946.     gr_info->maxb = longLimit[sfreq][gr_info->maxbandl];
  947.   }
  949.   while( part2remain > 16 ) {
  950.     getbits(16); 
  951.     part2remain -= 16;
  952.   }
  957.   if(part2remain > 0)
  958.     getbits(part2remain);
  959.   else if(part2remain < 0) {
  960.     return 1;
  961.   }
  962.   return 0;
  963. }
  967. static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,
  968.    struct gr_info_s *gr_info,int sfreq,int ms_stereo,int lsf)
  969. {
  970.       real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;
  971.       struct bandInfoStruct *bi = &bandInfo[sfreq];
  972.       real *tab1,*tab2;
  974.       if(lsf) {
  975.         int p = gr_info->scalefac_compress & 0x1;
  976.     if(ms_stereo) {
  977.           tab1 = pow1_2[p]; tab2 = pow2_2[p];
  978.         }
  979.         else {
  980.           tab1 = pow1_1[p]; tab2 = pow2_1[p];
  981.         }
  982.       }
  983.       else {
  984.         if(ms_stereo) {
  985.           tab1 = tan1_2; tab2 = tan2_2;
  986.         }
  987.         else {
  988.           tab1 = tan1_1; tab2 = tan2_1;
  989.         }
  990.       }
  992.       if (gr_info->block_type == 2)
  993.       {
  994.          int lwin,do_l = 0;
  995.          if( gr_info->mixed_block_flag )
  996.            do_l = 1;
  998.          for (lwin=0;lwin<3;lwin++) 
  999.          {
  1000.              
  1001.            int is_p,sb,idx,sfb = gr_info->maxband[lwin];  
  1002.            if(sfb > 3)
  1003.              do_l = 0;
  1005.            for(;sfb<12;sfb++)
  1006.            {
  1007.              is_p = scalefac[sfb*3+lwin-gr_info->mixed_block_flag]; 
  1008.              if(is_p != 7) {
  1009.                real t1,t2;
  1010.                sb = bi->shortDiff[sfb];
  1011.                idx = bi->shortIdx[sfb] + lwin;
  1012.                t1 = tab1[is_p]; t2 = tab2[is_p];
  1013.                for (; sb > 0; sb--,idx+=3)
  1014.                {
  1015.                  real v = xr[0][idx];
  1016.                  xr[0][idx] = v * t1;
  1017.                  xr[1][idx] = v * t2;
  1018.                }
  1019.              }
  1020.            }
  1022. #if 1
  1024.            is_p = scalefac[11*3+lwin-gr_info->mixed_block_flag]; 
  1025.            sb = bi->shortDiff[12];
  1026.            idx = bi->shortIdx[12] + lwin;
  1027. #else
  1028.            is_p = scalefac[10*3+lwin-gr_info->mixed_block_flag]; 
  1029.            sb = bi->shortDiff[11];
  1030.            idx = bi->shortIdx[11] + lwin;
  1031. #endif
  1032.            if(is_p != 7)
  1033.            {
  1034.              real t1,t2;
  1035.              t1 = tab1[is_p]; t2 = tab2[is_p];
  1036.              for ( ; sb > 0; sb--,idx+=3 )
  1037.              {  
  1038.                real v = xr[0][idx];
  1039.                xr[0][idx] = v * t1;
  1040.                xr[1][idx] = v * t2;
  1041.              }
  1042.            }
  1043.          } 
  1045.          if (do_l)
  1046.          {
  1048.            int sfb = gr_info->maxbandl;
  1049.            int idx = bi->longIdx[sfb];
  1051.            for ( ; sfb<8; sfb++ )
  1052.            {
  1053.              int sb = bi->longDiff[sfb];
  1054.              int is_p = scalefac[sfb]; 
  1055.              if(is_p != 7) {
  1056.                real t1,t2;
  1057.                t1 = tab1[is_p]; t2 = tab2[is_p];
  1058.                for ( ; sb > 0; sb--,idx++)
  1059.                {
  1060.                  real v = xr[0][idx];
  1061.                  xr[0][idx] = v * t1;
  1062.                  xr[1][idx] = v * t2;
  1063.                }
  1064.              }
  1065.              else 
  1066.                idx += sb;
  1067.            }
  1068.          }     
  1069.       } 
  1070.       else
  1071.       {
  1072.         int sfb = gr_info->maxbandl;
  1073.         int is_p,idx = bi->longIdx[sfb];
  1074.         for ( ; sfb<21; sfb++)
  1075.         {
  1076.           int sb = bi->longDiff[sfb];
  1077.           is_p = scalefac[sfb];
  1078.           if(is_p != 7) {
  1079.             real t1,t2;
  1080.             t1 = tab1[is_p]; t2 = tab2[is_p];
  1081.             for ( ; sb > 0; sb--,idx++)
  1082.             {
  1083.                real v = xr[0][idx];
  1084.                xr[0][idx] = v * t1;
  1085.                xr[1][idx] = v * t2;
  1086.             }
  1087.           }
  1088.           else
  1089.             idx += sb;
  1090.         }
  1092.         is_p = scalefac[20]; 
  1093.         if(is_p != 7)
  1094.         {
  1095.           int sb;
  1096.           real t1 = tab1[is_p],t2 = tab2[is_p]; 
  1098.           for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ )
  1099.           {
  1100.             real v = xr[0][idx];
  1101.             xr[0][idx] = v * t1;
  1102.             xr[1][idx] = v * t2;
  1103.           }
  1104.         }
  1105.       } /* ... */
  1106. }
  1108. static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_info)
  1109. {
  1110.    int sblim;
  1112.    if(gr_info->block_type == 2)
  1113.    {
  1114.       if(!gr_info->mixed_block_flag) 
  1115.         return;
  1116.       sblim = 1; 
  1117.    }
  1118.    else {
  1119.      sblim = gr_info->maxb-1;
  1120.    }
  1123.    {
  1124.      int sb;
  1125.      real *xr1=(real *) xr[1];
  1127.      for(sb=sblim;sb;sb--,xr1+=10)
  1128.      {
  1129.        int ss;
  1130.        real *cs=aa_cs,*ca=aa_ca;
  1131.        real *xr2 = xr1;
  1133.        for(ss=7;ss>=0;ss--)
  1134.        {       
  1135.          register real bu = *--xr2,bd = *xr1;
  1136.          *xr2   = (bu * (*cs)   ) - (bd * (*ca)   );
  1137.          *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
  1138.        }
  1139.      }
  1140.   }
  1141. }
  1145. static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
  1146. {
  1147.   {
  1148.     register real *in = inbuf;
  1150.     in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];
  1151.     in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];
  1152.     in[11]+=in[10]; in[10]+=in[9];  in[9] +=in[8];
  1153.     in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
  1154.     in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];
  1155.     in[2] +=in[1];  in[1] +=in[0];
  1157.     in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
  1158.     in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
  1161.   {
  1163. #define MACRO0(v) { 
  1164.     real tmp; 
  1165.     out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; 
  1166.     out2[8-(v)] = tmp * w[26-(v)];  } 
  1167.     sum0 -= sum1; 
  1168.     ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; 
  1169.     ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; 
  1170. #define MACRO1(v) { 
  1171. real sum0,sum1; 
  1172.     sum0 = tmp1a + tmp2a; 
  1173. sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; 
  1174. MACRO0(v); }
  1175. #define MACRO2(v) { 
  1176.     real sum0,sum1; 
  1177.     sum0 = tmp2a - tmp1a; 
  1178.     sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; 
  1179. MACRO0(v); }
  1181.     register const real *c = COS9;
  1182.     register real *out2 = o2;
  1183. register real *w = wintab;
  1184. register real *out1 = o1;
  1185. register real *ts = tsbuf;
  1187.     real ta33,ta66,tb33,tb66;
  1189.     ta33 = in[2*3+0] * c[3];
  1190.     ta66 = in[2*6+0] * c[6];
  1191.     tb33 = in[2*3+1] * c[3];
  1192.     tb66 = in[2*6+1] * c[6];
  1194.     { 
  1195.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1196.       tmp1a =             in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7];
  1197.       tmp1b =             in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7];
  1198.       tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8];
  1199.       tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8];
  1201.       MACRO1(0);
  1202.       MACRO2(8);
  1203.     }
  1205.     {
  1206.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1207.       tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3];
  1208.       tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3];
  1209.       tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0];
  1210.       tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1];
  1212.       MACRO1(1);
  1213.       MACRO2(7);
  1214.     }
  1216.     {
  1217.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1218.       tmp1a =             in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1];
  1219.       tmp1b =             in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1];
  1220.       tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4];
  1221.       tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4];
  1223.       MACRO1(2);
  1224.       MACRO2(6);
  1225.     }
  1227.     {
  1228.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1229.       tmp1a =             in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5];
  1230.       tmp1b =             in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5];
  1231.       tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2];
  1232.       tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2];
  1234.       MACRO1(3);
  1235.       MACRO2(5);
  1236.     }
  1238. {
  1239. real sum0,sum1;
  1240.      sum0 =  in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0];
  1241.      sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4];
  1242. MACRO0(4);
  1243. }
  1244.   }
  1246.   }
  1247. }
  1250. static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts)
  1251. {
  1252. #define DCT12_PART1 
  1253.              in5 = in[5*3];  
  1254.      in5 += (in4 = in[4*3]); 
  1255.      in4 += (in3 = in[3*3]); 
  1256.      in3 += (in2 = in[2*3]); 
  1257.      in2 += (in1 = in[1*3]); 
  1258.      in1 += (in0 = in[0*3]); 
  1259.                              
  1260.      in5 += in3; in3 += in1; 
  1261.                              
  1262.      in2 *= COS6_1; 
  1263.      in3 *= COS6_1; 
  1265. #define DCT12_PART2 
  1266.      in0 += in4 * COS6_2; 
  1267.                           
  1268.      in4 = in0 + in2;     
  1269.      in0 -= in2;          
  1270.                           
  1271.      in1 += in5 * COS6_2; 
  1272.                           
  1273.      in5 = (in1 + in3) * tfcos12[0]; 
  1274.      in1 = (in1 - in3) * tfcos12[2]; 
  1275.                          
  1276.      in3 = in4 + in5;    
  1277.      in4 -= in5;         
  1278.                          
  1279.      in2 = in0 + in1;    
  1280.      in0 -= in1;
  1283.    {
  1284.      real in0,in1,in2,in3,in4,in5;
  1285.      register real *out1 = rawout1;
  1286.      ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];
  1287.      ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];
  1288.  
  1289.      DCT12_PART1
  1291.      {
  1292.        real tmp0,tmp1 = (in0 - in4);
  1293.        {
  1294.          real tmp2 = (in1 - in5) * tfcos12[1];
  1295.          tmp0 = tmp1 + tmp2;
  1296.          tmp1 -= tmp2;
  1297.        }
  1298.        ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1];
  1299.        ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1];
  1300.        ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1];
  1301.        ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1];
  1302.      }
  1304.      DCT12_PART2
  1306.      ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0];
  1307.      ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0];
  1308.      ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2];
  1309.      ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2];
  1311.      ts[(6+0)*SBLIMIT]  = out1[6+0] + in0 * wi[0];
  1312.      ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0];
  1313.      ts[(6+2)*SBLIMIT]  = out1[6+2] + in4 * wi[2];
  1314.      ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2];
  1315.   }
  1317.   in++;
  1319.   {
  1320.      real in0,in1,in2,in3,in4,in5;
  1321.      register real *out2 = rawout2;
  1322.  
  1323.      DCT12_PART1
  1325.      {
  1326.        real tmp0,tmp1 = (in0 - in4);
  1327.        {
  1328.          real tmp2 = (in1 - in5) * tfcos12[1];
  1329.          tmp0 = tmp1 + tmp2;
  1330.          tmp1 -= tmp2;
  1331.        }
  1332.        out2[5-1] = tmp0 * wi[11-1];
  1333.        out2[0+1] = tmp0 * wi[6+1];
  1334.        ts[(12+1)*SBLIMIT] += tmp1 * wi[1];
  1335.        ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1];
  1336.      }
  1338.      DCT12_PART2
  1340.      out2[5-0] = in2 * wi[11-0];
  1341.      out2[0+0] = in2 * wi[6+0];
  1342.      out2[0+2] = in3 * wi[6+2];
  1343.      out2[5-2] = in3 * wi[11-2];
  1345.      ts[(12+0)*SBLIMIT] += in0 * wi[0];
  1346.      ts[(17-0)*SBLIMIT] += in0 * wi[5-0];
  1347.      ts[(12+2)*SBLIMIT] += in4 * wi[2];
  1348.      ts[(17-2)*SBLIMIT] += in4 * wi[5-2];
  1349.   }
  1351.   in++; 
  1353.   {
  1354.      real in0,in1,in2,in3,in4,in5;
  1355.      register real *out2 = rawout2;
  1356.      out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;
  1358.      DCT12_PART1
  1360.      {
  1361.        real tmp0,tmp1 = (in0 - in4);
  1362.        {
  1363.          real tmp2 = (in1 - in5) * tfcos12[1];
  1364.          tmp0 = tmp1 + tmp2;
  1365.          tmp1 -= tmp2;
  1366.        }
  1367.        out2[11-1] = tmp0 * wi[11-1];
  1368.        out2[6 +1] = tmp0 * wi[6+1];
  1369.        out2[0+1] += tmp1 * wi[1];
  1370.        out2[5-1] += tmp1 * wi[5-1];
  1371.      }
  1373.      DCT12_PART2
  1375.      out2[11-0] = in2 * wi[11-0];
  1376.      out2[6 +0] = in2 * wi[6+0];
  1377.      out2[6 +2] = in3 * wi[6+2];
  1378.      out2[11-2] = in3 * wi[11-2];
  1380.      out2[0+0] += in0 * wi[0];
  1381.      out2[5-0] += in0 * wi[5-0];
  1382.      out2[0+2] += in4 * wi[2];
  1383.      out2[5-2] += in4 * wi[5-2];
  1384.   }
  1385. }
  1387. static void III_hybrid(real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],
  1388.    int ch,struct gr_info_s *gr_info)
  1389. {
  1390.    real *tspnt = (real *) tsOut;
  1391.    real (*block)[2][SBLIMIT*SSLIMIT] = gmp->hybrid_block;
  1392.    int *blc = gmp->hybrid_blc;
  1393.    real *rawout1,*rawout2;
  1394.    int bt;
  1395.    int sb = 0;
  1397.    {
  1398.      int b = blc[ch];
  1399.      rawout1=block[b][ch];
  1400.      b=-b+1;
  1401.      rawout2=block[b][ch];
  1402.      blc[ch] = b;
  1403.    }
  1405.   
  1406.    if(gr_info->mixed_block_flag) {
  1407.      sb = 2;
  1408.      dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);
  1409.      dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
  1410.      rawout1 += 36; rawout2 += 36; tspnt += 2;
  1411.    }
  1412.  
  1413.    bt = gr_info->block_type;
  1414.    if(bt == 2) {
  1415.      for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1416.        dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt);
  1417.        dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);
  1418.      }
  1419.    }
  1420.    else {
  1421.      for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1422.        dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
  1423.        dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
  1424.      }
  1425.    }
  1427.    for(;sb<SBLIMIT;sb++,tspnt++) {
  1428.      int i;
  1429.      for(i=0;i<SSLIMIT;i++) {
  1430.        tspnt[i*SBLIMIT] = *rawout1++;
  1431.        *rawout2++ = 0.0;
  1432.      }
  1433.    }
  1434. }
  1437. int do_layer3(struct frame *fr,unsigned char *pcm_sample,int *pcm_point)
  1438. {
  1439.   int gr, ch, ss,clip=0;
  1440.   int scalefacs[2][39]; 
  1441.   struct III_sideinfo sideinfo;
  1442.   int stereo = fr->stereo;
  1443.   int single = fr->single;
  1444.   int ms_stereo,i_stereo;
  1445.   int sfreq = fr->sampling_frequency;
  1446.   int stereo1,granules;
  1448.   
  1450.   if(stereo == 1) { 
  1451.     stereo1 = 1;
  1452.     single = 0;
  1453.   }
  1454.   else if(single >= 0) 
  1455.     stereo1 = 1;
  1456.   else
  1457.     stereo1 = 2;
  1459.   if(fr->mode == MPG_MD_JOINT_STEREO) {
  1460.     ms_stereo = fr->mode_ext & 0x2;
  1461.     i_stereo  = fr->mode_ext & 0x1;
  1462.   }
  1463.   else
  1464.     ms_stereo = i_stereo = 0;
  1468.   if(fr->lsf) {
  1469.     granules = 1;
  1470.     III_get_side_info_2(&sideinfo,stereo,ms_stereo,sfreq,single);
  1471.   }
  1472.   else {
  1473.     granules = 2;
  1474.     III_get_side_info_1(&sideinfo,stereo,ms_stereo,sfreq,single);
  1475.   }
  1479.   if(set_pointer(sideinfo.main_data_begin) == MP3_ERR)
  1480.     return 0;
  1482.   for (gr=0;gr<granules;gr++) 
  1483.   {
  1484.     real hybridIn[2][SBLIMIT][SSLIMIT];
  1485.     real hybridOut[2][SSLIMIT][SBLIMIT];
  1487.     {
  1488.       struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]);
  1489.       long part2bits;
  1492.   if(fr->lsf)
  1493.         part2bits = III_get_scale_factors_2(scalefacs[0],gr_info,0);
  1494.       else {
  1495.         part2bits = III_get_scale_factors_1(scalefacs[0],gr_info);
  1496.       }
  1500.       if(III_dequantize_sample(hybridIn[0], scalefacs[0],gr_info,sfreq,part2bits))
  1501.         return clip;
  1504.     }
  1505.     if(stereo == 2) {
  1506.       struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]);
  1507.       long part2bits;
  1511.       if(fr->lsf) 
  1512.         part2bits = III_get_scale_factors_2(scalefacs[1],gr_info,i_stereo);
  1513.       else {
  1514.         part2bits = III_get_scale_factors_1(scalefacs[1],gr_info);
  1515.       }
  1520.       if(III_dequantize_sample(hybridIn[1],scalefacs[1],gr_info,sfreq,part2bits))
  1521.           return clip;
  1524.       if(ms_stereo) {
  1525.         int i;
  1526.         for(i=0;i<SBLIMIT*SSLIMIT;i++) {
  1527.           real tmp0,tmp1;
  1528.           tmp0 = ((real *) hybridIn[0])[i];
  1529.           tmp1 = ((real *) hybridIn[1])[i];
  1530.           ((real *) hybridIn[0])[i] = tmp0 + tmp1;
  1531.           ((real *) hybridIn[1])[i] = tmp0 - tmp1;  
  1532.         }
  1533.       }
  1537. if(i_stereo)
  1538. III_i_stereo(hybridIn,scalefacs[1],gr_info,sfreq,ms_stereo,fr->lsf);
  1540. if(ms_stereo || i_stereo || (single == 3) ) {
  1541. if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb) 
  1542. sideinfo.ch[0].gr[gr].maxb = gr_info->maxb;
  1543. else
  1544. gr_info->maxb = sideinfo.ch[0].gr[gr].maxb;
  1545. }
  1548. switch(single) {
  1549. case 3: {
  1550. register int i;
  1551. register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1552. for(i=0;i<SSLIMIT*gr_info->maxb;i++,in0++)
  1553. *in0 = (*in0 + *in1++);  
  1554.            break;
  1555. }
  1556. case 1: {
  1557. register int i;
  1558. register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1559. for(i=0;i<SSLIMIT*gr_info->maxb;i++)
  1560. *in0++ = *in1++;
  1561. break;
  1562. }
  1563. }
  1564. }
  1568. for(ch=0;ch<stereo1;ch++) {
  1569. struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]);
  1570. III_antialias(hybridIn[ch],gr_info);
  1571. III_hybrid(hybridIn[ch], hybridOut[ch], ch,gr_info);
  1572. }
  1576. if (single >= 0) {
  1577.      for(ss=0;ss<SSLIMIT;ss++)
  1578.          clip += synth_1to1_mono(hybridOut[0][ss],pcm_sample,pcm_point);
  1579.        } else {
  1580.      for(ss=0;ss<SSLIMIT;ss++) {
  1581.          int p1 = *pcm_point;
  1582.          clip += synth_1to1(hybridOut[0][ss],0,pcm_sample,&p1);
  1583.          clip += synth_1to1(hybridOut[1][ss],1,pcm_sample,pcm_point);
  1584. }
  1585. }
  1586. }
  1589. return clip;
  1590. }