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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
DECODE.C
资源名称：mpeg.zip　[点击查看]
上传用户：njqiyou
上传日期：2007-01-08
资源大小：574k
文件大小：68k
源码类别：

mpeg/mp3

开发平台：

C/C++

DECODE.C：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Decoder - Lower Sampling Frequency Extension
  4.  *
  5.  * $Id: decode.c,v 1.2 1996/03/28 03:13:37 rowlands Exp $
  6.  *
  7.  * $Log: decode.c,v $
  8.  * Revision 1.2  1996/03/28 03:13:37  rowlands
  9.  * Merged layers 1-2 and layer 3 revisions
  10.  *
  11.  * Revision 1.1  1996/02/14 03:45:52  rowlands
  12.  * Initial revision
  13.  *
  14.  * Received from FhG
  15.  **********************************************************************/
  16. /**********************************************************************
  17.  *   date   programmers         comment                               *
  18.  * 2/25/91  Douglas Wong,       start of version 1.0 records          *
  19.  *          Davis Pan                                                 *
  20.  * 3/06/91  Douglas Wong        rename: setup.h to dedef.h            *
  21.  *                                      dfilter to defilter           *
  22.  *                                      dwindow to dewindow           *
  23.  *                              integrated "quantizer", "scalefactor" *
  24.  *                              combined window_samples routine into  *
  25.  *                              filter samples                        *
  26.  * 3/31/91  Bill Aspromonte     replaced read_filter by               *
  27.  *                              create_syn_filter and introduced a    *
  28.  *                              new Sub-Band Synthesis routine called *
  29.  *                              SubBandSynthesis()                    *
  30.  * 5/10/91  Vish (PRISM)        Ported to Macintosh and Unix.         *
  31.  *                              Changed "out_fifo()" so that last     *
  32.  *                              unfilled block is also written out.   *
  33.  *                              "create_syn_filter()" was modified so *
  34.  *                              that calculation precision is same as *
  35.  *                              in specification tables.              *
  36.  *                              Changed "decode_scale()" to reflect   *
  37.  *                              specifications.                       *
  38.  *                              Removed all routines used by          *
  39.  *                              "synchronize_buffer()".  This is now  *
  40.  *                              replaced by "seek_sync()".            *
  41.  *                              Incorporated Jean-Georges Fritsch's   *
  42.  *                              "bitstream.c" package.                *
  43.  *                              Deleted "reconstruct_sample()".       *
  44.  * 27jun91  dpwe (Aware)        Passed outFile and &sampFrames as     *
  45.  *                              args to out_fifo() - were global.     *
  46.  *                              Moved "alloc_*" reader to common.c.   *
  47.  *                              alloc, sblimit, stereo passed via new *
  48.  *                              'frame_params struct (were globals).  *
  49.  *                              Added JOINT STEREO decoding, lyrs I&II*
  50.  *                              Affects: decode_bitalloc,buffer_samps *
  51.  *                              Plus a few other cleanups.            *
  52.  * 6/10/91   Earle Jennings     conditional expansion added in        *
  53.  *                              II_dequantize_sample to handle range  *
  54.  *                              problems in MSDOS version             *
  55.  * 8/8/91    Jens Spille        Change for MS-C6.00                   *
  56.  *10/1/91    S.I. Sudharsanan,  Ported to IBM AIX platform.           *
  57.  *           Don H. Lee,                                              *
  58.  *           Peter W. Farrett                                         *
  59.  *10/3/91    Don H. Lee         implemented CRC-16 error protection   *
  60.  *                              newly introduced functions are        *
  61.  *                              buffer_CRC and recover_CRC_error.     *
  62.  * 2/11/92  W. Joseph Carter    Ported new code to Macintosh.  Most   *
  63.  *                              important fixes involved changing     *
  64.  *                              16-bit ints to long or unsigned in    *
  65.  *                              bit alloc routines for quant of 65535 *
  66.  *                              and passing proper function args.     *
  67.  *                              Removed "Other Joint Stereo" option   *
  68.  *                              and made bitrate be total channel     *
  69.  *                              bitrate, irrespective of the mode.    *
  70.  *                              Fixed many small bugs & reorganized.  *
  71.  * 7/27/92  Juan Pineda         Bug fix in SubBandSynthesis()         *
  72.  *--------------------------------------------------------------------*
  73.  * 6/14/92  Juan Pineda         Layer III decoding routines added.    *
  74.  *          Amit Gulati         Follows CD 3-11172 rev2.  Contains    *
  75.  *                              hacks deal with evolving available    *
  76.  *                              layerIII bitstreams.  Some (minor)    *
  77.  *                              modification of prior LI&II code.     *
  78.  * 10/25/92 Amit Gulati         Updated layerIII routines. Added code *
  79.  *                              for subblock_gain, switched block     *
  80.  *                              modes, stereo pre-processing.         *
  81.  *                              Corrected sign bits for huffman       *
  82.  *                              decoding of quadruples region and     *
  83.  *                              adjusted gain factor in III_dequant.  *
  84.  * 11/21/92 Amit Gulati         Several layerIII bugs fixed.          *
  85.  * 12/15/92 Amit Gulati         Corrected reordering (indexing)       *
  86.  *          Stan Searing        within IMDCT routine.                 *
  87.  *  8/24/93 Masahiro Iwadare    Included IS modification in Layer III.*
  88.  *                              Changed for 1 pass decoding.          *
  89.  *  9/07/93 Toshiyuki Ishino    Integrated Layer III with Ver 3.9.    *
  90.  *--------------------------------------------------------------------*
  91.  * 11/20/93 Masahiro Iwadare    Integrated Layer III with Ver 4.0.    *
  92.  *--------------------------------------------------------------------*
  93.  *  7/14/94 Juergen Koller      Bug fixes in Layer III code           *
  94.  *--------------------------------------------------------------------*
  95.  * 08/11/94 IIS                 Bug fixes in Layer III code           *
  96.  *--------------------------------------------------------------------*
  97.  * 9/20/94  Davis Pan           Modification to avoid premature       *
  98.  *                              synchword detection                   *
  99.  *--------------------------------------------------------------------*
  100.  * 11/09/94 Jon Rowlands        Merged premature synchword detection  *
  101.  *                              fix into layer III code version       *
  102.  *--------------------------------------------------------------------*
  103.  * 07/12/95 Soeren H. Nielsen   Changes for LSF Layer I and II        *
  104.  *--------------------------------------------------------------------*
  105.  *    8/95  Roland Bitto Adapted to MPEG2                      *
  106.  *  9/8/95  Roalnd Bitto        Bugfix in Function III_stereo         * 
  107.  **********************************************************************/
  109. #include        "common.h"
  110. #include        "decoder.h"
  111. #include        "huffman.h"
  113. /***************************************************************
  114. /*
  115. /* This module contains the core of the decoder ie all the
  116. /* computational routines. (Layer I and II only)
  117. /* Functions are common to both layer unless
  118. /* otherwise specified.
  119. /*
  120. /***************************************************************/
  122. /*****************************************************************
  123. /*
  124. /* The following routines decode the system information
  125. /*
  126. /****************************************************************/
  128. /************ Layer I, Layer II & Layer III ******************/
  130. void decode_info(bs, fr_ps)
  131. Bit_stream_struc *bs;
  132. frame_params *fr_ps;
  133. {
  134.     layer *hdr = fr_ps->header;
  136.     hdr->version = get1bit(bs);
  137.     hdr->lay = 4-getbits(bs,2);
  138.     hdr->error_protection = !get1bit(bs); /* error protect. TRUE/FALSE */
  139.     hdr->bitrate_index = getbits(bs,4);
  140.     hdr->sampling_frequency = getbits(bs,2);
  141.     hdr->padding = get1bit(bs);
  142.     hdr->extension = get1bit(bs);
  143.     hdr->mode = getbits(bs,2);
  144.     hdr->mode_ext = getbits(bs,2);
  145.     hdr->copyright = get1bit(bs);
  146.     hdr->original = get1bit(bs);
  147.     hdr->emphasis = getbits(bs,2);
  148. }
  150. /*******************************************************************
  151. /*
  152. /* The bit allocation information is decoded. Layer I
  153. /* has 4 bit per subband whereas Layer II is Ws and bit rate
  154. /* dependent.
  155. /*
  156. /********************************************************************/
  158. /**************************** Layer II *************/
  160. void II_decode_bitalloc(bs, bit_alloc, fr_ps)
  161. Bit_stream_struc *bs;
  162. unsigned int bit_alloc[2][SBLIMIT];
  163. frame_params *fr_ps;
  164. {
  165.     int i,j;
  166.     int stereo = fr_ps->stereo;
  167.     int sblimit = fr_ps->sblimit;
  168.     int jsbound = fr_ps->jsbound;
  169.     al_table *alloc = fr_ps->alloc;
  171.     for (i=0;i<jsbound;i++) for (j=0;j<stereo;j++)
  172.         bit_alloc[j][i] = (char) getbits(bs,(*alloc)[i][0].bits);
  174.     for (i=jsbound;i<sblimit;i++) /* expand to 2 channels */
  175.         bit_alloc[0][i] = bit_alloc[1][i] =
  176.             (char) getbits(bs,(*alloc)[i][0].bits);
  178.     for (i=sblimit;i<SBLIMIT;i++) for (j=0;j<stereo;j++)
  179.         bit_alloc[j][i] = 0;
  180. }
  182. /**************************** Layer I *************/
  184. void I_decode_bitalloc(bs, bit_alloc, fr_ps)
  185. Bit_stream_struc *bs;
  186. unsigned int bit_alloc[2][SBLIMIT];
  187. frame_params *fr_ps;
  188. {
  189.     int i,j;
  190.     int stereo  = fr_ps->stereo;
  191.     int sblimit = fr_ps->sblimit;
  192.     int jsbound = fr_ps->jsbound;
  193.     int b;
  195.     for (i=0;i<jsbound;i++) for (j=0;j<stereo;j++)
  196.         bit_alloc[j][i] = getbits(bs,4);
  197.     for (i=jsbound;i<SBLIMIT;i++) {
  198.         b = getbits(bs,4);
  199.         for (j=0;j<stereo;j++)
  200.             bit_alloc[j][i] = b;
  201.     }
  202. }
  204. /*****************************************************************
  205. /*
  206. /* The following two functions implement the layer I and II
  207. /* format of scale factor extraction. Layer I involves reading
  208. /* 6 bit per subband as scale factor. Layer II requires reading
  209. /* first the scfsi which in turn indicate the number of scale factors
  210. /* transmitted.
  211. /*    Layer I : I_decode_scale
  212. /*   Layer II : II_decode_scale
  213. /*
  214. /****************************************************************/
  216. /************************** Layer I stuff ************************/
  218. void I_decode_scale(bs, bit_alloc, scale_index, fr_ps)
  219. Bit_stream_struc *bs;
  220. unsigned int bit_alloc[2][SBLIMIT], scale_index[2][3][SBLIMIT];
  221. frame_params *fr_ps;
  222. {
  223.     int i,j;
  224.     int stereo = fr_ps->stereo;
  225.     int sblimit = fr_ps->sblimit;
  227.     for (i=0;i<SBLIMIT;i++) for (j=0;j<stereo;j++)
  228.         if (!bit_alloc[j][i])
  229.             scale_index[j][0][i] = SCALE_RANGE-1;
  230.         else                    /* 6 bit per scale factor */
  231.             scale_index[j][0][i] =  getbits(bs,6);
  233. }
  235. /*************************** Layer II stuff ***************************/
  237. void II_decode_scale(bs,scfsi, bit_alloc,scale_index, fr_ps)
  238. Bit_stream_struc *bs;
  239. unsigned int scfsi[2][SBLIMIT], bit_alloc[2][SBLIMIT],
  240.              scale_index[2][3][SBLIMIT];
  241. frame_params *fr_ps;
  242. {
  243.     int i,j;
  244.     int stereo = fr_ps->stereo;
  245.     int sblimit = fr_ps->sblimit;
  246.    
  247.     for (i=0;i<sblimit;i++) for (j=0;j<stereo;j++) /* 2 bit scfsi */
  248.         if (bit_alloc[j][i]) scfsi[j][i] = (char) getbits(bs,2);
  249.     for (i=sblimit;i<SBLIMIT;i++) for (j=0;j<stereo;j++)   
  250.         scfsi[j][i] = 0;
  252.     for (i=0;i<sblimit;i++) for (j=0;j<stereo;j++) {
  253.         if (bit_alloc[j][i])   
  254.             switch (scfsi[j][i]) {
  255.                 /* all three scale factors transmitted */
  256.              case 0 : scale_index[j][0][i] = getbits(bs,6);
  257.                 scale_index[j][1][i] = getbits(bs,6);
  258.                 scale_index[j][2][i] = getbits(bs,6);
  259.                 break;
  260.                 /* scale factor 1 & 3 transmitted */
  261.              case 1 : scale_index[j][0][i] =
  262.                  scale_index[j][1][i] = getbits(bs,6);
  263.                 scale_index[j][2][i] = getbits(bs,6);
  264.                 break;
  265.                 /* scale factor 1 & 2 transmitted */
  266.              case 3 : scale_index[j][0][i] = getbits(bs,6);
  267.                 scale_index[j][1][i] =
  268.                     scale_index[j][2][i] =  getbits(bs,6);
  269.                 break;
  270.                 /* only one scale factor transmitted */
  271.              case 2 : scale_index[j][0][i] =
  272.                  scale_index[j][1][i] =
  273.                      scale_index[j][2][i] = getbits(bs,6);
  274.                 break;
  275.                 default : break;
  276.             }
  277.         else {
  278.             scale_index[j][0][i] = scale_index[j][1][i] =
  279.                 scale_index[j][2][i] = SCALE_RANGE-1;
  280.         }
  281.     }
  282.     for (i=sblimit;i<SBLIMIT;i++) for (j=0;j<stereo;j++) {
  283.         scale_index[j][0][i] = scale_index[j][1][i] =
  284.             scale_index[j][2][i] = SCALE_RANGE-1;
  285.     }
  286. }
  288. /**************************************************************
  289. /*
  290. /*   The following two routines take care of reading the
  291. /* compressed sample from the bit stream for both layer 1 and
  292. /* layer 2. For layer 1, read the number of bits as indicated
  293. /* by the bit_alloc information. For layer 2, if grouping is
  294. /* indicated for a particular subband, then the sample size has
  295. /* to be read from the bits_group and the merged samples has
  296. /* to be decompose into the three distinct samples. Otherwise,
  297. /* it is the same for as layer one.
  298. /*
  299. /**************************************************************/
  301. /******************************* Layer I stuff ******************/
  303. void I_buffer_sample(bs, sample, bit_alloc, fr_ps)
  304. unsigned int FAR sample[2][3][SBLIMIT];
  305. unsigned int bit_alloc[2][SBLIMIT];
  306. Bit_stream_struc *bs;
  307. frame_params *fr_ps;
  308. {
  309.     int i,j,k;
  310.     int stereo = fr_ps->stereo;
  311.     int sblimit = fr_ps->sblimit;
  312.     int jsbound = fr_ps->jsbound;
  313.     unsigned int s;
  315.     for (i=0;i<jsbound;i++) for (j=0;j<stereo;j++)
  316.         if ( (k = bit_alloc[j][i]) == 0)
  317.             sample[j][0][i] = 0;
  318.         else 
  319.             sample[j][0][i] = (unsigned int) getbits(bs,k+1);
  320.     for (i=jsbound;i<SBLIMIT;i++) {
  321.         if ( (k = bit_alloc[0][i]) == 0)
  322.             s = 0;
  323.         else 
  324.             s = (unsigned int)getbits(bs,k+1);
  325.         for (j=0;j<stereo;j++)
  326.             sample[j][0][i]    = s;
  327.     }
  328. }
  330. /*************************** Layer II stuff ************************/
  332. void II_buffer_sample(bs,sample,bit_alloc,fr_ps)
  333. unsigned int FAR sample[2][3][SBLIMIT];
  334. unsigned int bit_alloc[2][SBLIMIT];
  335. Bit_stream_struc *bs;
  336. frame_params *fr_ps;
  337. {
  338.     int i,j,k,m;
  339.     int stereo = fr_ps->stereo;
  340.     int sblimit = fr_ps->sblimit;
  341.     int jsbound = fr_ps->jsbound;
  342.     al_table *alloc = fr_ps->alloc;
  344.     for (i=0;i<sblimit;i++) for (j=0;j<((i<jsbound)?stereo:1);j++) {
  345.         if (bit_alloc[j][i]) {
  346.             /* check for grouping in subband */
  347.             if ((*alloc)[i][bit_alloc[j][i]].group==3)
  348.                 for (m=0;m<3;m++) {
  349.                     k = (*alloc)[i][bit_alloc[j][i]].bits;
  350.                     sample[j][m][i] = (unsigned int) getbits(bs,k);
  351.                 }         
  352.             else {              /* bit_alloc = 3, 5, 9 */
  353.                 unsigned int nlevels, c=0;
  355.                 nlevels = (*alloc)[i][bit_alloc[j][i]].steps;
  356.                 k=(*alloc)[i][bit_alloc[j][i]].bits;
  357.                 c = (unsigned int) getbits(bs, k);
  358.                 for (k=0;k<3;k++) {
  359.                     sample[j][k][i] = c % nlevels;
  360.                     c /= nlevels;
  361.                 }
  362.             }
  363.         }
  364.         else {                  /* for no sample transmitted */
  365.             for (k=0;k<3;k++) sample[j][k][i] = 0;
  366.         }
  367.         if(stereo == 2 && i>= jsbound) /* joint stereo : copy L to R */
  368.             for (k=0;k<3;k++) sample[1][k][i] = sample[0][k][i];
  369.     }
  370.     for (i=sblimit;i<SBLIMIT;i++) for (j=0;j<stereo;j++) for (k=0;k<3;k++)
  371.         sample[j][k][i] = 0;
  372. }      
  374. /**************************************************************
  375. /*
  376. /*   Restore the compressed sample to a factional number.
  377. /*   first complement the MSB of the sample
  378. /*    for layer I :
  379. /*    Use s = (s' + 2^(-nb+1) ) * 2^nb / (2^nb-1)
  380. /*   for Layer II :
  381. /*   Use the formula s = s' * c + d
  382. /*
  383. /**************************************************************/
  385. static double c[17] = { 1.33333333333, 1.60000000000, 1.14285714286,
  386.                         1.77777777777, 1.06666666666, 1.03225806452,
  387.                         1.01587301587, 1.00787401575, 1.00392156863,
  388.                         1.00195694716, 1.00097751711, 1.00048851979,
  389.                         1.00024420024, 1.00012208522, 1.00006103888,
  390.                         1.00003051851, 1.00001525902 };
  392. static double d[17] = { 0.500000000, 0.500000000, 0.250000000, 0.500000000,
  393.                         0.125000000, 0.062500000, 0.031250000, 0.015625000,
  394.                         0.007812500, 0.003906250, 0.001953125, 0.0009765625,
  395.                         0.00048828125, 0.00024414063, 0.00012207031,
  396.                         0.00006103516, 0.00003051758 };
  398. /************************** Layer II stuff ************************/
  400. void II_dequantize_sample(sample, bit_alloc, fraction, fr_ps)
  401. unsigned int FAR sample[2][3][SBLIMIT];
  402. unsigned int bit_alloc[2][SBLIMIT];
  403. double FAR fraction[2][3][SBLIMIT];
  404. frame_params *fr_ps;
  405. {
  406.     int i, j, k, x;
  407.     int stereo = fr_ps->stereo;
  408.     int sblimit = fr_ps->sblimit;
  409.     al_table *alloc = fr_ps->alloc;
  411.     for (i=0;i<sblimit;i++)  for (j=0;j<3;j++) for (k=0;k<stereo;k++)
  412.         if (bit_alloc[k][i]) {
  414.             /* locate MSB in the sample */
  415.             x = 0;
  416. #ifndef MS_DOS
  417.             while ((1L<<x) < (*alloc)[i][bit_alloc[k][i]].steps) x++;
  418. #else
  419.             /* microsoft C thinks an int is a short */
  420.             while (( (unsigned long) (1L<<(long)x) <
  421.                     (unsigned long)( (*alloc)[i][bit_alloc[k][i]].steps)
  422.                     ) && ( x < 16) ) x++;
  423. #endif
  425.             /* MSB inversion */
  426.             if (((sample[k][j][i] >> x-1) & 1) == 1)
  427.                 fraction[k][j][i] = 0.0;
  428.             else  fraction[k][j][i] = -1.0;
  430.             /* Form a 2's complement sample */
  431.             fraction[k][j][i] += (double) (sample[k][j][i] & ((1<<x-1)-1)) /
  432.                 (double) (1L<<x-1);
  434.             /* Dequantize the sample */
  435.             fraction[k][j][i] += d[(*alloc)[i][bit_alloc[k][i]].quant];
  436.             fraction[k][j][i] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
  437.         }
  438.         else fraction[k][j][i] = 0.0;   
  439.    
  440.     for (i=sblimit;i<SBLIMIT;i++) for (j=0;j<3;j++) for(k=0;k<stereo;k++)
  441.         fraction[k][j][i] = 0.0;
  442. }
  444. /***************************** Layer I stuff ***********************/
  446. void I_dequantize_sample(sample, fraction, bit_alloc, fr_ps)
  447. unsigned int FAR sample[2][3][SBLIMIT];
  448. unsigned int bit_alloc[2][SBLIMIT];
  449. double FAR fraction[2][3][SBLIMIT];
  450. frame_params *fr_ps;
  451. {
  452.     int i, nb, k;
  453.     int stereo = fr_ps->stereo;
  454.     int sblimit = fr_ps->sblimit;
  456.     for (i=0;i<SBLIMIT;i++)
  457.         for (k=0;k<stereo;k++)
  458.             if (bit_alloc[k][i]) {
  459.                 nb = bit_alloc[k][i] + 1;
  460.                 if (((sample[k][0][i] >> nb-1) & 1) == 1) fraction[k][0][i] = 0.0;
  461.                 else fraction[k][0][i] = -1.0;
  462.                 fraction[k][0][i] += (double) (sample[k][0][i] & ((1<<nb-1)-1)) /
  463.                     (double) (1L<<nb-1);
  465.                 fraction[k][0][i] =
  466.                     (double) (fraction[k][0][i]+1.0/(double)(1L<<nb-1)) *
  467.                         (double) (1L<<nb) / (double) ((1L<<nb)-1);
  468.             }
  469.             else fraction[k][0][i] = 0.0;
  470. }
  472. /************************************************************
  473. /*
  474. /*   Restore the original value of the sample ie multiply
  475. /*    the fraction value by its scalefactor.
  476. /*
  477. /************************************************************/
  479. /************************* Layer II Stuff **********************/
  481. void II_denormalize_sample(fraction, scale_index,fr_ps,x)
  482. double FAR fraction[2][3][SBLIMIT];
  483. unsigned int scale_index[2][3][SBLIMIT];
  484. frame_params *fr_ps;
  485. int x;
  486. {
  487.     int i,j,k;
  488.     int stereo = fr_ps->stereo;
  489.     int sblimit = fr_ps->sblimit;
  491.     for (i=0;i<sblimit;i++) for (j=0;j<stereo;j++) {
  492.         fraction[j][0][i] *= multiple[scale_index[j][x][i]];
  493.         fraction[j][1][i] *= multiple[scale_index[j][x][i]];
  494.         fraction[j][2][i] *= multiple[scale_index[j][x][i]];
  495.     }
  496. }
  498. /**************************** Layer I stuff ******************************/
  500. void I_denormalize_sample(fraction,scale_index,fr_ps)
  501. double FAR fraction[2][3][SBLIMIT];
  502. unsigned int scale_index[2][3][SBLIMIT];
  503. frame_params *fr_ps;
  504. {
  505.     int i,j,k;
  506.     int stereo = fr_ps->stereo;
  507.     int sblimit = fr_ps->sblimit;
  509.     for (i=0;i<SBLIMIT;i++) for (j=0;j<stereo;j++)
  510.         fraction[j][0][i] *= multiple[scale_index[j][0][i]];
  511. }
  513. /*****************************************************************
  514. /*
  515. /* The following are the subband synthesis routines. They apply
  516. /* to both layer I and layer II stereo or mono. The user has to
  517. /* decide what parameters are to be passed to the routines.
  518. /*
  519. /***************************************************************/
  521. /*************************************************************
  522. /*
  523. /*   Pass the subband sample through the synthesis window
  524. /*
  525. /**************************************************************/
  527. /* create in synthesis filter */
  529. void create_syn_filter(filter)
  530. double FAR filter[64][SBLIMIT];
  531. {
  532.     register int i,k;
  534.     for (i=0; i<64; i++)
  535.         for (k=0; k<32; k++) {
  536.             if ((filter[i][k] = 1e9*cos((double)((PI64*i+PI4)*(2*k+1)))) >= 0)
  537.                 modf(filter[i][k]+0.5, &filter[i][k]);
  538.             else
  539.                 modf(filter[i][k]-0.5, &filter[i][k]);
  540.             filter[i][k] *= 1e-9;
  541.         }
  542. }
  544. /***************************************************************
  545. /*
  546. /*   Window the restored sample
  547. /*
  548. /***************************************************************/
  550. /* read in synthesis window */
  552. void read_syn_window(window)
  553. double FAR window[HAN_SIZE];
  554. {
  555.     int i,j[4];
  556.     FILE *fp;
  557.     double f[4];
  558.     char t[150];
  560.     if (!(fp = OpenTableFile("dewindow") )) {
  561.         printf("Please check synthesis window table 'dewindow'n");
  562.         exit(1);
  563.     }
  564.     for (i=0;i<512;i+=4) {
  565.         fgets(t, 150, fp);
  566.         sscanf(t,"D[%d] = %lf D[%d] = %lf D[%d] = %lf D[%d] = %lfn",
  567.                j, f,j+1,f+1,j+2,f+2,j+3,f+3);
  568.         if (i==j[0]) {
  569.             window[i] = f[0];
  570.             window[i+1] = f[1];
  571.             window[i+2] = f[2];
  572.             window[i+3] = f[3];
  573.         }
  574.         else {
  575.             printf("Check index in synthesis window tablen");
  576.             exit(1);
  577.         }
  578.         fgets(t,150,fp);
  579.     }
  580.     fclose(fp);
  581. }
  583. int SubBandSynthesis (bandPtr, channel, samples)
  584. double *bandPtr;
  585. int channel;
  586. short *samples;
  587. {
  588.     register int i,j,k;
  589.     register double *bufOffsetPtr, sum;
  590.     register long foo;
  591.     static int init = 1;
  592.     typedef double NN[64][32];
  593.     static NN FAR *filter;
  594.     typedef double BB[2][2*HAN_SIZE];
  595.     static BB FAR *buf;
  596.     static int bufOffset[2] = {64,64};
  597.     static double FAR *window;
  598.     int clip = 0;               /* count & return how many samples clipped */
  600.     if (init) {
  601.         buf = (BB FAR *) mem_alloc(sizeof(BB),"BB");
  602.         filter = (NN FAR *) mem_alloc(sizeof(NN), "NN");
  603.         create_syn_filter(*filter);
  604.         window = (double FAR *) mem_alloc(sizeof(double) * HAN_SIZE, "WIN");
  605.         read_syn_window(window);
  606.         init = 0;
  607.     }
  608. /*    if (channel == 0) */
  609.     bufOffset[channel] = (bufOffset[channel] - 64) & 0x3ff;
  610.     bufOffsetPtr = &((*buf)[channel][bufOffset[channel]]);
  612.     for (i=0; i<64; i++) {
  613.         sum = 0;
  614.         for (k=0; k<32; k++)
  615.             sum += bandPtr[k] * (*filter)[i][k];
  616.         bufOffsetPtr[i] = sum;
  617.     }
  618.     /*  S(i,j) = D(j+32i) * U(j+32i+((i+1)>>1)*64)  */
  619.     /*  samples(i,j) = MWindow(j+32i) * bufPtr(j+32i+((i+1)>>1)*64)  */
  620.     for (j=0; j<32; j++) {
  621.         sum = 0;
  622.         for (i=0; i<16; i++) {
  623.             k = j + (i<<5);
  624.             sum += window[k] * (*buf) [channel] [( (k + ( ((i+1)>>1) <<6) ) +
  625.                                                   bufOffset[channel]) & 0x3ff];
  626.         }
  628. /*      Casting truncates towards zero for both positive and negative numbers,
  629. the result is cross-over distortion,  1995-07-12 shn */
  631.         if(sum > 0)
  632.         {
  633.           foo = (long)(sum * (double) SCALE + (double)0.5);
  634.         }
  635.         else
  636.         {
  637.            foo = (long)(sum * (double)SCALE -(double)0.5);
  638.         } 
  640.      if (foo >= (long) SCALE)      {samples[j] = (short)(SCALE-1); ++clip;}
  641.      else if (foo < (long) -SCALE) {samples[j] = (short)(-SCALE);  ++clip;}
  642.      else                           samples[j] =(short)foo;
  643.     }
  644.     return(clip);
  645. }
  647. void out_fifo(pcm_sample, num, fr_ps, done, outFile, psampFrames)
  648. short FAR pcm_sample[2][SSLIMIT][SBLIMIT];
  649. int num;
  650. frame_params *fr_ps;
  651. int done;
  652. FILE *outFile;
  653. unsigned long *psampFrames;
  654. {
  655.     int i,j,l;
  656.     int stereo = fr_ps->stereo;
  657.     int sblimit = fr_ps->sblimit;
  658.     static short int outsamp[1600];
  659.     static long k = 0;
  661.     if (!done)
  662.         for (i=0;i<num;i++) for (j=0;j<SBLIMIT;j++) {
  663.             (*psampFrames)++;
  664.             for (l=0;l<stereo;l++) {
  665.                 if (!(k%1600) && k) {
  666.     /*
  667.       Samples are big-endian. If this is a little-endian machine
  668.       we must swap
  669.       */
  670.     if ( NativeByteOrder == order_unknown )
  671.     {
  672. NativeByteOrder = DetermineByteOrder();
  673. if ( NativeByteOrder == order_unknown )
  674. {
  675.     fprintf( stderr, "byte order not determinedn" );
  676.     exit( 1 );
  677. }
  678.     }
  679.     if ( NativeByteOrder == order_littleEndian )
  680. SwapBytesInWords( outsamp, 1600 );
  681.     
  682.                     fwrite(outsamp,2,1600,outFile);
  683.                     k = 0;
  684.                 }
  685.                 outsamp[k++] = pcm_sample[l][i][j];
  686.             }
  687.         }
  688.     else {
  689.         fwrite(outsamp,2,(int)k,outFile);
  690.         k = 0;
  691.     }
  692. }
  694. void  buffer_CRC(bs, old_crc)
  695. Bit_stream_struc  *bs;
  696. unsigned int  *old_crc;
  697. {
  698.     *old_crc = getbits(bs, 16);
  699. }
  701. void  recover_CRC_error(pcm_sample, error_count, fr_ps, outFile, psampFrames)
  702. short FAR pcm_sample[2][SSLIMIT][SBLIMIT];
  703. int error_count;
  704. frame_params *fr_ps;
  705. FILE *outFile;
  706. unsigned long *psampFrames;
  707. {
  708.     int  stereo = fr_ps->stereo;
  709.     int  num, done, i;
  710.     int  samplesPerFrame, samplesPerSlot;
  711.     layer  *hdr = fr_ps->header;
  712.     long  offset;
  713.     short  *temp;
  715.     num = 3;
  716.     if (hdr->lay == 1) num = 1;
  718.     samplesPerSlot = SBLIMIT * num * stereo;
  719.     samplesPerFrame = samplesPerSlot * 32;
  721.     if (error_count == 1) {     /* replicate previous error_free frame */
  722.         done = 1;
  723.         /* flush out fifo */
  724.         out_fifo(pcm_sample, num, fr_ps, done, outFile, psampFrames);
  725.         /* go back to the beginning of the previous frame */
  726.         offset = sizeof(short int) * samplesPerFrame;
  727.         fseek(outFile, -offset, SEEK_CUR);
  728.         done = 0;
  729.         for (i = 0; i < SCALE_BLOCK; i++) {
  730.             fread(pcm_sample, 2, samplesPerSlot, outFile);
  731.             out_fifo(pcm_sample, num, fr_ps, done, outFile, psampFrames);
  732.         }
  733.     }
  734.     else{                       /* mute the frame */
  735.         temp = (short*) pcm_sample;
  736.         done = 0;
  737.         for (i = 0; i < 2*3*SBLIMIT; i++)
  738.             *temp++ = MUTE;     /* MUTE value is in decoder.h */
  739.         for (i = 0; i < SCALE_BLOCK; i++)
  740.             out_fifo(pcm_sample, num, fr_ps, done, outFile, psampFrames);
  741.     }
  742. }
  744. /************************* Layer III routines **********************/
  746. void III_get_side_info(bs, si, fr_ps)
  747. Bit_stream_struc *bs;
  748. III_side_info_t *si;
  749. frame_params *fr_ps;
  750. {
  751.    int ch, gr, i;
  752.    int stereo = fr_ps->stereo;
  753.    
  754.    if(fr_ps->header->version != MPEG_PHASE2_LSF)
  755.    {
  756.       si->main_data_begin = getbits(bs, 9);
  757.       if (stereo == 1)
  758.          si->private_bits = getbits(bs,5);
  759.          else si->private_bits = getbits(bs,3);
  761.        for (ch=0; ch<stereo; ch++)
  762.            for (i=0; i<4; i++)
  763.            si->ch[ch].scfsi[i] = get1bit(bs);
  764.  
  765.   
  766.         for (gr=0; gr< 2 ; gr++) {
  767.            for (ch=0; ch<stereo; ch++) {
  768.               si->ch[ch].gr[gr].part2_3_length = getbits(bs, 12);
  769.               si->ch[ch].gr[gr].big_values = getbits(bs, 9);
  770.               si->ch[ch].gr[gr].global_gain = getbits(bs, 8);
  771.               si->ch[ch].gr[gr].scalefac_compress = getbits(bs, 4);
  772.               si->ch[ch].gr[gr].window_switching_flag = get1bit(bs);
  773.               if (si->ch[ch].gr[gr].window_switching_flag) {
  774.                  si->ch[ch].gr[gr].block_type = getbits(bs, 2);
  775.                  si->ch[ch].gr[gr].mixed_block_flag = get1bit(bs);
  776.                  for (i=0; i<2; i++)
  777.                     si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
  778.                  for (i=0; i<3; i++)
  779.                     si->ch[ch].gr[gr].subblock_gain[i] = getbits(bs, 3);
  780.                
  781.             /* Set region_count parameters since they are implicit in this case. */
  782.             
  783.                  if (si->ch[ch].gr[gr].block_type == 0) {
  784.                    printf("Side info bad: block_type == 0 in split block.n");
  785.                    exit(0);
  786.                  }
  787.                  else if (si->ch[ch].gr[gr].block_type == 2
  788.                       && si->ch[ch].gr[gr].mixed_block_flag == 0)
  789.                              si->ch[ch].gr[gr].region0_count = 8; /* MI 9; */
  790.                  else si->ch[ch].gr[gr].region0_count = 7; /* MI 8; */
  791.                       si->ch[ch].gr[gr].region1_count = 20 -
  792. si->ch[ch].gr[gr].region0_count;
  793.              }
  794.             else {
  795.                for (i=0; i<3; i++)
  796.                    si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
  797.                si->ch[ch].gr[gr].region0_count = getbits(bs, 4);
  798.                si->ch[ch].gr[gr].region1_count = getbits(bs, 3);
  799.                si->ch[ch].gr[gr].block_type = 0;
  800.             }      
  801.          si->ch[ch].gr[gr].preflag = get1bit(bs);
  802.          si->ch[ch].gr[gr].scalefac_scale = get1bit(bs);
  803.          si->ch[ch].gr[gr].count1table_select = get1bit(bs);
  804.          }
  805.       }
  806.     }     
  807.     else /* Layer 3 LSF */
  808.     {     
  809.         si->main_data_begin = getbits(bs, 8);
  810.         if (stereo == 1)
  811.                  si->private_bits = getbits(bs,1);
  812.          else si->private_bits = getbits(bs,2);
  814.         for (gr=0; gr< 1 ; gr++) {
  815.            for (ch=0; ch<stereo; ch++) {
  816.               si->ch[ch].gr[gr].part2_3_length = getbits(bs, 12);
  817.               si->ch[ch].gr[gr].big_values = getbits(bs, 9);
  818.               si->ch[ch].gr[gr].global_gain = getbits(bs, 8);
  819.               si->ch[ch].gr[gr].scalefac_compress = getbits(bs, 9);
  820.               si->ch[ch].gr[gr].window_switching_flag = get1bit(bs);
  821.               if (si->ch[ch].gr[gr].window_switching_flag) {
  822.                  si->ch[ch].gr[gr].block_type = getbits(bs, 2);
  823.                  si->ch[ch].gr[gr].mixed_block_flag = get1bit(bs);
  824.                  for (i=0; i<2; i++)
  825.                     si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
  826.                  for (i=0; i<3; i++)
  827.                     si->ch[ch].gr[gr].subblock_gain[i] = getbits(bs, 3);
  828.                
  829.             /* Set region_count parameters since they are implicit in this case. */
  830.             
  831.                  if (si->ch[ch].gr[gr].block_type == 0) {
  832.                    printf("Side info bad: block_type == 0 in split block.n");
  833.                    exit(0);
  834.                  }
  835.                  else if (si->ch[ch].gr[gr].block_type == 2
  836.                       && si->ch[ch].gr[gr].mixed_block_flag == 0)
  837.                              si->ch[ch].gr[gr].region0_count = 8; /* MI 9; */
  838.                  else si->ch[ch].gr[gr].region0_count = 7; /* MI 8; */
  839.                       si->ch[ch].gr[gr].region1_count = 20 - si->ch[ch].gr[gr].region0_count;
  841.               }
  842.               else {
  843.                 for (i=0; i<3; i++)
  844.                    si->ch[ch].gr[gr].table_select[i] = getbits(bs, 5);
  845.                si->ch[ch].gr[gr].region0_count = getbits(bs, 4);
  846.                si->ch[ch].gr[gr].region1_count = getbits(bs, 3);
  847.                si->ch[ch].gr[gr].block_type = 0;
  848.               }      
  850.          si->ch[ch].gr[gr].scalefac_scale = get1bit(bs);
  851.          si->ch[ch].gr[gr].count1table_select = get1bit(bs);
  852.          }
  853.      }
  854.   }
  855. }
  857. void III_put_side_info(bs, si, fr_ps)
  858. frame_params *fr_ps;
  859. Bit_stream_struc *bs;
  860. III_side_info_t *si;
  861. {
  862.    int ch, gr, i;
  863.    int stereo = fr_ps->stereo;
  865.  if(fr_ps->header->version != MPEG_PHASE2_LSF)
  866.  {
  867.    putbits(bs, si->main_data_begin,9);
  868.    if (stereo == 1)
  869.       putbits(bs, si->private_bits, 5);
  870.       else putbits(bs, si->private_bits, 3);
  872.    for (ch=0; ch<stereo; ch++)
  873.       for (i=0; i<4; i++)
  874.          put1bit(bs, si->ch[ch].scfsi[i]);
  876.    for (gr=0; gr<2; gr++) {
  877.       for (ch=0; ch<stereo; ch++) {
  878.          putbits(bs, si->ch[ch].gr[gr].part2_3_length, 12);
  879.          putbits(bs, si->ch[ch].gr[gr].big_values, 9);
  880.          putbits(bs, si->ch[ch].gr[gr].global_gain, 8);
  881.          putbits(bs, si->ch[ch].gr[gr].scalefac_compress, 4);
  882.          put1bit(bs, si->ch[ch].gr[gr].window_switching_flag);
  883.          if (si->ch[ch].gr[gr].window_switching_flag) {
  884.             putbits(bs, si->ch[ch].gr[gr].block_type, 2);
  885.             put1bit(bs, si->ch[ch].gr[gr].mixed_block_flag);
  886.             for (i=0; i<2; i++)
  887.                putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
  888.             for (i=0; i<3; i++)
  889.                putbits(bs, si->ch[ch].gr[gr].subblock_gain[i], 3);
  890.             }
  891.          else {
  892.             for (i=0; i<3; i++)
  893.             putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
  894.             putbits(bs, si->ch[ch].gr[gr].region0_count, 4);
  895.             putbits(bs, si->ch[ch].gr[gr].region1_count, 3);
  896.             }      
  898.          put1bit(bs, si->ch[ch].gr[gr].preflag);
  899.          put1bit(bs, si->ch[ch].gr[gr].scalefac_scale);
  900.          put1bit(bs, si->ch[ch].gr[gr].count1table_select);
  901.          }
  902.       }
  903.  }
  904.  else /* Layer 3 LSF */
  905.  {
  906.     putbits(bs, si->main_data_begin,8);
  907.     if (stereo == 1)
  908.       putbits(bs, si->private_bits, 1);
  909.       else putbits(bs, si->private_bits, 2);
  911.    
  912.      for (gr=0; gr<1; gr++) {
  913.        for (ch=0; ch<stereo; ch++) {
  914.          putbits(bs, si->ch[ch].gr[gr].part2_3_length, 12);
  915.          putbits(bs, si->ch[ch].gr[gr].big_values, 9);
  916.          putbits(bs, si->ch[ch].gr[gr].global_gain, 8);
  917.          putbits(bs, si->ch[ch].gr[gr].scalefac_compress, 9);
  918.          put1bit(bs, si->ch[ch].gr[gr].window_switching_flag);
  919.          if (si->ch[ch].gr[gr].window_switching_flag) {
  920.             putbits(bs, si->ch[ch].gr[gr].block_type, 2);
  921.             put1bit(bs, si->ch[ch].gr[gr].mixed_block_flag);
  922.             for (i=0; i<2; i++)
  923.                putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
  924.             for (i=0; i<3; i++)
  925.                putbits(bs, si->ch[ch].gr[gr].subblock_gain[i], 3);
  926.             }
  927.          else 
  928.            {  
  929.             for (i=0; i<3; i++)
  930.             putbits(bs, si->ch[ch].gr[gr].table_select[i], 5);
  931.             putbits(bs, si->ch[ch].gr[gr].region0_count, 4);
  932.             putbits(bs, si->ch[ch].gr[gr].region1_count, 3);
  933.            }      
  935.          put1bit(bs, si->ch[ch].gr[gr].scalefac_scale);
  936.          put1bit(bs, si->ch[ch].gr[gr].count1table_select);
  937.        }
  938.      }
  939.   }
  940. }
  942. struct {
  943.    int l[5];
  944.    int s[3];} sfbtable = {{0, 6, 11, 16, 21},
  945.                           {0, 6, 12}};
  946.                          
  947. int slen[2][16] = {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  948.                    {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}};
  949. struct  {
  950.    int l[23];
  951.    int s[14];} sfBandIndex[6] =
  952.     {{{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  953.      {0,4,8,12,18,24,32,42,56,74,100,132,174,192}},
  954.     {{0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
  955.      {0,4,8,12,18,26,36,48,62,80,104,136,180,192}},
  956.     {{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  957.      {0,4,8,12,18,26,36,48,62,80,104,134,174,192}},
  959.     {{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  960.      {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
  961.     {{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  962.      {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
  963.     {{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  964.      {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
  968. void III_get_scale_factors(scalefac, si, gr, ch, fr_ps)
  969. III_scalefac_t *scalefac;
  970. III_side_info_t *si;
  971. int gr, ch;
  972. frame_params *fr_ps;
  973. {
  974. int sfb, i, window;
  975. struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  977.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) { 
  978.       if (gr_info->mixed_block_flag) { /* MIXED */ /* NEW - ag 11/25 */
  979.          for (sfb = 0; sfb < 8; sfb++)
  980.             (*scalefac)[ch].l[sfb] = hgetbits( 
  981.                  slen[0][gr_info->scalefac_compress]);
  982.          for (sfb = 3; sfb < 6; sfb++)
  983.             for (window=0; window<3; window++)
  984.                (*scalefac)[ch].s[window][sfb] = hgetbits(
  985.                  slen[0][gr_info->scalefac_compress]);
  986.          for (sfb = 6; sfb < 12; sfb++)
  987.             for (window=0; window<3; window++)
  988.                (*scalefac)[ch].s[window][sfb] = hgetbits(
  989.                  slen[1][gr_info->scalefac_compress]);
  990.          for (sfb=12,window=0; window<3; window++)
  991.             (*scalefac)[ch].s[window][sfb] = 0;
  992.       }
  993.       else {  /* SHORT*/
  994.          for (i=0; i<2; i++) 
  995.             for (sfb = sfbtable.s[i]; sfb < sfbtable.s[i+1]; sfb++)
  996.                for (window=0; window<3; window++)
  997.                   (*scalefac)[ch].s[window][sfb] = hgetbits( 
  998.                     slen[i][gr_info->scalefac_compress]);
  999.          for (sfb=12,window=0; window<3; window++)
  1000.             (*scalefac)[ch].s[window][sfb] = 0;
  1001.       }
  1002.     }          
  1003.     else {   /* LONG types 0,1,3 */
  1004.         for (i=0; i<4; i++) {
  1005.            if ((si->ch[ch].scfsi[i] == 0) || (gr == 0))
  1006.               for (sfb = sfbtable.l[i]; sfb < sfbtable.l[i+1]; sfb++)
  1007.                   (*scalefac)[ch].l[sfb] = hgetbits(
  1008.                  slen[(i<2)?0:1][gr_info->scalefac_compress]);
  1009.         }
  1010.         (*scalefac)[ch].l[22] = 0; 
  1011.     }
  1012. }
  1014. /****************** new MPEG2 stuf  ***********/
  1016. static unsigned nr_of_sfb_block[6][3][4] = {{{6, 5, 5, 5},{ 9, 9, 9, 9 },{6, 9, 9, 9}},
  1017.                                          {{6, 5, 7, 3},{ 9, 9, 12, 6},{6, 9, 12, 6}},
  1018.                                          {{11, 10, 0, 0},{ 18, 18, 0, 0},{15,18,0,0 }},
  1019.                                          {{7, 7, 7, 0},{ 12, 12, 12, 0},{6, 15, 12, 0}},
  1020.                                          {{6, 6, 6, 3},{12, 9, 9, 6},{6, 12, 9, 6}},
  1021.                                          {{8, 8, 5, 0},{15,12,9,0},{6,18,9,0}}};
  1022. static unsigned scalefac_buffer[54];
  1024. void III_get_LSF_scale_data(scalefac, si, gr, ch, fr_ps)
  1025. III_scalefac_t *scalefac;
  1026. III_side_info_t *si;
  1027. int gr, ch;
  1028. frame_params *fr_ps;
  1029. {
  1030. short sfb, i,j,k, window;
  1031. short blocktypenumber, blocknumber;
  1033. struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1034. unsigned scalefac_comp, int_scalefac_comp, new_slen[4];
  1035.    
  1036. layer *hdr = fr_ps->header;
  1037. scalefac_comp =  gr_info->scalefac_compress;
  1039.     blocktypenumber = 0;
  1040.     if ((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0))
  1041.                                                         blocktypenumber = 1;
  1043.    if ((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 1))
  1044.                                                         blocktypenumber = 2;
  1046.     if(!((( hdr->mode_ext == 1) || (hdr->mode_ext == 3)) && (ch == 1)))
  1047.     {
  1048. if(scalefac_comp < 400)
  1049.         {
  1050. new_slen[0] = (scalefac_comp >> 4) / 5 ;
  1051. new_slen[1] = (scalefac_comp >> 4) % 5 ;
  1052. new_slen[2] = (scalefac_comp % 16) >> 2 ;
  1053. new_slen[3] = (scalefac_comp % 4);
  1054.                 si->ch[ch].gr[gr].preflag = 0;
  1056.                 blocknumber = 0;
  1057.          }
  1059. else if( scalefac_comp  < 500)
  1060.         {
  1061. new_slen[0] = ((scalefac_comp - 400 )  >> 2) / 5 ;
  1062. new_slen[1] = ((scalefac_comp - 400) >> 2) % 5 ;
  1063. new_slen[2] = (scalefac_comp - 400 ) % 4 ;
  1064. new_slen[3] = 0;
  1065.                 si->ch[ch].gr[gr].preflag = 0;
  1066.                 blocknumber = 1;
  1068.         }
  1070. else if( scalefac_comp  < 512)
  1071.         {
  1072. new_slen[0] = (scalefac_comp - 500 ) / 3 ;
  1073. new_slen[1] = (scalefac_comp - 500)  % 3 ;
  1074. new_slen[2] = 0 ;
  1075. new_slen[3] = 0;
  1076.                 si->ch[ch].gr[gr].preflag = 1;
  1077.                 blocknumber = 2;
  1079.         }
  1080.      }
  1082.     if((((hdr->mode_ext == 1) || (hdr->mode_ext == 3)) && (ch == 1)))
  1083.     {
  1084.       /*   intensity_scale = scalefac_comp %2; */
  1085.          int_scalefac_comp = scalefac_comp >> 1;
  1087.         if(int_scalefac_comp  < 180)
  1088.         {
  1089. new_slen[0] = int_scalefac_comp  / 36 ;
  1090. new_slen[1] = (int_scalefac_comp % 36 ) / 6 ;
  1091. new_slen[2] = (int_scalefac_comp % 36) % 6;
  1092. new_slen[3] = 0;
  1093.                 si->ch[ch].gr[gr].preflag = 0;
  1094.                 blocknumber = 3;
  1096.          }
  1098. else if( int_scalefac_comp  < 244)
  1099.         {
  1100. new_slen[0] = ((int_scalefac_comp - 180 )  % 64 ) >> 4 ;
  1101. new_slen[1] = ((int_scalefac_comp - 180) % 16) >> 2 ;
  1102. new_slen[2] = (int_scalefac_comp - 180 ) % 4 ;
  1103. new_slen[3] = 0;
  1104.                 si->ch[ch].gr[gr].preflag = 0;
  1105.                 blocknumber = 4;
  1107.         }
  1109. else if( int_scalefac_comp  < 255)
  1110.         {
  1111. new_slen[0] = (int_scalefac_comp - 244 ) / 3 ;
  1112. new_slen[1] = (int_scalefac_comp - 244 )  % 3 ;
  1113. new_slen[2] = 0 ;
  1114. new_slen[3] = 0;
  1115.                 si->ch[ch].gr[gr].preflag = 0;
  1116.                 blocknumber = 5;
  1118.         }
  1119.      }
  1120.      
  1121.      for(i=0;i< 45;i++) scalefac_buffer[i] = 0;
  1123.      k = 0;
  1124.      for(i = 0;i < 4;i++)
  1125.      { 
  1126.        for(j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i]; j++)
  1127.         {
  1128.            if(new_slen[i] == 0)
  1129.            {
  1130.         scalefac_buffer[k] = 0;
  1131.            }
  1132.            else
  1133.            {   
  1134.              scalefac_buffer[k] =  hgetbits(new_slen[i]);
  1135.            }
  1136.            k++;
  1137.  
  1138.         }
  1139.      }
  1141. }
  1145. void III_get_LSF_scale_factors(scalefac, si, gr, ch, fr_ps)
  1146. III_scalefac_t *scalefac;
  1147. III_side_info_t *si;
  1148. int gr, ch;
  1149. frame_params *fr_ps;
  1150. {
  1151. int sfb, i,k = 0, window;
  1152. struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1153.  
  1154.      III_get_LSF_scale_data(scalefac, si, gr, ch, fr_ps);
  1157.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) { 
  1158.       if (gr_info->mixed_block_flag) 
  1159.       {                                       /* MIXED */ /* NEW - ag 11/25 */
  1160.          for (sfb = 0; sfb < 8; sfb++)
  1161.          {
  1162.               (*scalefac)[ch].l[sfb] = scalefac_buffer[k];
  1163.               k++;
  1164.          } 
  1165.          for (sfb = 3; sfb < 12; sfb++)
  1166.             for (window=0; window<3; window++)
  1167.             {
  1168.                (*scalefac)[ch].s[window][sfb] = scalefac_buffer[k];
  1169.                k++;
  1170.             }
  1171.             for (sfb=12,window=0; window<3; window++)
  1172.                      (*scalefac)[ch].s[window][sfb] = 0;
  1174.        }
  1175.        else {  /* SHORT*/
  1176.            for (sfb = 0; sfb < 12; sfb++)
  1177.                for (window=0; window<3; window++)
  1178.                {
  1179.                   (*scalefac)[ch].s[window][sfb] = scalefac_buffer[k];
  1180.                   k++;
  1181.                }
  1182.                for (sfb=12,window=0; window<3; window++)
  1183.                                    (*scalefac)[ch].s[window][sfb] = 0;
  1184.       }
  1185.     }          
  1186.     else {   /* LONG types 0,1,3 */
  1188.            for (sfb = 0; sfb < 21; sfb++)
  1189.             {
  1190.                   (*scalefac)[ch].l[sfb] = scalefac_buffer[k];
  1191.                    k++;
  1192.             }
  1193.             (*scalefac)[ch].l[22] = 0; 
  1195.      
  1196.     }
  1197. }
  1201. /* Already declared in huffman.c
  1202. struct huffcodetab ht[HTN];
  1203. */
  1204. int huffman_initialized = FALSE;
  1206. void initialize_huffman() {
  1207.    FILE *fi;
  1208.   
  1209.    if (huffman_initialized) return;
  1210.    if (!(fi = OpenTableFile("huffdec") )) {
  1211.       printf("Please check huffman table 'huffdec'n");
  1212.       exit(1);
  1213.    }
  1215.    if (fi==NULL) {
  1217.       fprintf(stderr,"decoder table open errorn");
  1219.       exit(3);
  1221.       }
  1223.    if (read_decoder_table(fi) != HTN) {
  1224.       fprintf(stderr,"decoder table read errorn");
  1225.       exit(4);
  1226.       }
  1227. huffman_initialized = TRUE;
  1228. }
  1230. III_hufman_decode(is, si, ch, gr, part2_start, fr_ps)
  1231. long int is[SBLIMIT][SSLIMIT];
  1232. III_side_info_t *si;
  1233. int gr, ch, part2_start;
  1234. frame_params *fr_ps;
  1235. {
  1236.    int i, x, y;
  1237.    int v, w;
  1238.    struct huffcodetab *h;
  1239.    int region1Start;
  1240.    int region2Start;
  1241.    int sfreq;
  1242.    int currentBit, grBits;
  1243.    my_gr_info *gi;
  1244.    int bt = (*si).ch[ch].gr[gr].window_switching_flag && ((*si).ch[ch].gr[gr].block_type == 2);
  1246.    gi = (my_gr_info *) &(*si).ch[ch].gr[gr];
  1247.    sfreq = fr_ps->header->sampling_frequency + (fr_ps->header->version * 3);
  1248.    initialize_huffman();
  1250.    /* Find region boundary for short block case. */
  1251.    
  1252.    if ( ((*si).ch[ch].gr[gr].window_switching_flag) && 
  1253.         ((*si).ch[ch].gr[gr].block_type == 2) ) { 
  1254.    
  1255.       /* Region2. */
  1256.         region1Start = 36;  /* sfb[9/3]*3=36 */
  1257.         region2Start = 576; /* No Region2 for short block case. */
  1258.    }
  1259.    else {          /* Find region boundary for long block case. */
  1261.       region1Start = sfBandIndex[sfreq]
  1262.                            .l[(*si).ch[ch].gr[gr].region0_count + 1]; /* MI */
  1263.       region2Start = sfBandIndex[sfreq]
  1264.                               .l[(*si).ch[ch].gr[gr].region0_count +
  1265.                               (*si).ch[ch].gr[gr].region1_count + 2]; /* MI */
  1266.       }
  1269.    grBits     = part2_start + (*si).ch[ch].gr[gr].part2_3_length;
  1270.    currentBit = hsstell();
  1272.    /* Read bigvalues area. */
  1273.    for (i=0; i<(*si).ch[ch].gr[gr].big_values*2; i+=2) {
  1274.       if      (i<region1Start) h = &ht[(*si).ch[ch].gr[gr].table_select[0]];
  1275.       else if (i<region2Start) h = &ht[(*si).ch[ch].gr[gr].table_select[1]];
  1276.            else                h = &ht[(*si).ch[ch].gr[gr].table_select[2]];
  1277.       huffman_decoder(h, &x, &y, &v, &w);
  1278.       is[i/SSLIMIT][i%SSLIMIT] = x;
  1279.       is[(i+1)/SSLIMIT][(i+1)%SSLIMIT] = y;
  1280.       }
  1282.    grBits     = part2_start + (*si).ch[ch].gr[gr].part2_3_length;
  1283.    currentBit = hsstell();
  1285.    /* Read count1 area. */
  1286.    h = &ht[(*si).ch[ch].gr[gr].count1table_select+32];
  1287.    while ((hsstell() < part2_start + (*si).ch[ch].gr[gr].part2_3_length ) &&
  1288.      ( i < SSLIMIT*SBLIMIT )) {
  1289.       huffman_decoder(h, &x, &y, &v, &w);
  1290.       is[i/SSLIMIT][i%SSLIMIT] = v;
  1291.       is[(i+1)/SSLIMIT][(i+1)%SSLIMIT] = w;
  1292.       is[(i+2)/SSLIMIT][(i+2)%SSLIMIT] = x;
  1293.       is[(i+3)/SSLIMIT][(i+3)%SSLIMIT] = y;
  1294.       i += 4;
  1295.       }
  1297.    grBits     = part2_start + (*si).ch[ch].gr[gr].part2_3_length;
  1298.    currentBit = hsstell();
  1300.    if (hsstell() > part2_start + (*si).ch[ch].gr[gr].part2_3_length)
  1301.    {  i -=4;
  1302.       rewindNbits(hsstell()-part2_start - (*si).ch[ch].gr[gr].part2_3_length);
  1303.    }
  1305.    /* Dismiss stuffing Bits */
  1306.    grBits     = part2_start + (*si).ch[ch].gr[gr].part2_3_length;
  1307.    currentBit = hsstell();
  1308.    if ( currentBit < grBits )
  1309.       hgetbits( grBits - currentBit );
  1311.    /* Zero out rest. */
  1312.    for (; i<SSLIMIT*SBLIMIT; i++)
  1313.       is[i/SSLIMIT][i%SSLIMIT] = 0;
  1314. }
  1317. int pretab[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
  1319. void III_dequantize_sample(is,xr,scalefac,gr_info, ch,fr_ps)
  1320. long int is[SBLIMIT][SSLIMIT];
  1321. double xr[SBLIMIT][SSLIMIT];
  1322. struct gr_info_s *gr_info;
  1323. III_scalefac_t *scalefac;
  1324. frame_params *fr_ps;
  1325. int ch;
  1326. {
  1327.    int ss,sb,cb=0,sfreq;
  1328.    int stereo = fr_ps->stereo;
  1329.    int next_cb_boundary, cb_begin, cb_width, sign;
  1331.    sfreq=fr_ps->header->sampling_frequency + (fr_ps->header->version * 3);
  1333.    /* choose correct scalefactor band per block type, initalize boundary */
  1335.    if (gr_info->window_switching_flag && (gr_info->block_type == 2) )
  1336.       if (gr_info->mixed_block_flag) 
  1337.          next_cb_boundary=sfBandIndex[sfreq].l[1];  /* LONG blocks: 0,1,3 */
  1338.       else {
  1339.          next_cb_boundary=sfBandIndex[sfreq].s[1]*3; /* pure SHORT block */
  1340.     cb_width = sfBandIndex[sfreq].s[1];
  1341.     cb_begin = 0;
  1342.       }  
  1343.    else 
  1344.       next_cb_boundary=sfBandIndex[sfreq].l[1];  /* LONG blocks: 0,1,3 */
  1346.    /* apply formula per block type */
  1348.    for (sb=0 ; sb < SBLIMIT ; sb++)
  1349.       for (ss=0 ; ss < SSLIMIT ; ss++) {
  1351.          if ( (sb*18)+ss == next_cb_boundary)  { /* Adjust critical band boundary */
  1352.             if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  1353.                if (gr_info->mixed_block_flag)  {
  1354.                   if (((sb*18)+ss) == sfBandIndex[sfreq].l[8])  {
  1355.                      next_cb_boundary=sfBandIndex[sfreq].s[4]*3; 
  1356.                      cb = 3;
  1357.                      cb_width = sfBandIndex[sfreq].s[cb+1] - 
  1358.                                 sfBandIndex[sfreq].s[cb];
  1359.                      cb_begin = sfBandIndex[sfreq].s[cb]*3;      
  1360.                   }
  1361.                   else if (((sb*18)+ss) < sfBandIndex[sfreq].l[8]) 
  1362.                      next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  1363.                   else {
  1364.                      next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1]*3;
  1365.                      cb_width = sfBandIndex[sfreq].s[cb+1] - 
  1366.                                     sfBandIndex[sfreq].s[cb];
  1367.                      cb_begin = sfBandIndex[sfreq].s[cb]*3;      
  1368.                   }   
  1369.                }
  1370.                else  {
  1371.                   next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1]*3;
  1372.                   cb_width = sfBandIndex[sfreq].s[cb+1] - 
  1373.                                sfBandIndex[sfreq].s[cb];
  1374.                 cb_begin = sfBandIndex[sfreq].s[cb]*3;      
  1375.                } 
  1376.             }
  1377.             else /* long blocks */
  1378.                next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  1379.          }
  1381.          /* Compute overall (global) scaling. */
  1383.          xr[sb][ss] = pow( 2.0 , (0.25 * (gr_info->global_gain - 210.0)));
  1385.          /* Do long/short dependent scaling operations. */
  1386.         
  1387.          if (gr_info->window_switching_flag && (
  1388.             ((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0)) ||
  1389.             ((gr_info->block_type == 2) && gr_info->mixed_block_flag && (sb >= 2)) )) {
  1391.             xr[sb][ss] *= pow(2.0, 0.25 * -8.0 * 
  1392.                     gr_info->subblock_gain[(((sb*18)+ss) - cb_begin)/cb_width]);
  1393.             xr[sb][ss] *= pow(2.0, 0.25 * -2.0 * (1.0+gr_info->scalefac_scale)
  1394.               * (*scalefac)[ch].s[(((sb*18)+ss) - cb_begin)/cb_width][cb]);
  1395.          }
  1396.          else {   /* LONG block types 0,1,3 & 1st 2 subbands of switched blocks */
  1397.             xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info->scalefac_scale)
  1398.                                         * ((*scalefac)[ch].l[cb]
  1399.                                         + gr_info->preflag * pretab[cb]));
  1400.          }
  1402.          /* Scale quantized value. */
  1403.         
  1404.          sign = (is[sb][ss]<0) ? 1 : 0; 
  1405.          xr[sb][ss] *= pow( (double) abs(is[sb][ss]), ((double)4.0/3.0) );
  1406.          if (sign) xr[sb][ss] = -xr[sb][ss];
  1407.       }
  1408. }
  1410. III_reorder (xr, ro, gr_info, fr_ps) 
  1411. double xr[SBLIMIT][SSLIMIT]; 
  1412. double ro[SBLIMIT][SSLIMIT]; 
  1413. struct gr_info_s *gr_info;
  1414. frame_params *fr_ps;
  1415. {
  1416.    int sfreq;
  1417.    int sfb, sfb_start, sfb_lines;
  1418.    int sb, ss, window, freq, src_line, des_line;
  1420.    sfreq=fr_ps->header->sampling_frequency + (fr_ps->header->version * 3);
  1422.    for(sb=0;sb<SBLIMIT;sb++)
  1423.       for(ss=0;ss<SSLIMIT;ss++) 
  1424.          ro[sb][ss] = 0;
  1426.    if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  1427.       if (gr_info->mixed_block_flag) {
  1428.          /* NO REORDER FOR LOW 2 SUBBANDS */
  1429.          for (sb=0 ; sb < 2 ; sb++)
  1430.             for (ss=0 ; ss < SSLIMIT ; ss++) {
  1431.                ro[sb][ss] = xr[sb][ss];
  1432.             }
  1433.          /* REORDERING FOR REST SWITCHED SHORT */
  1434.          for(sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
  1435.             sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start; 
  1436.             sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  1437.             (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  1438.                for(window=0; window<3; window++)
  1439.                   for(freq=0;freq<sfb_lines;freq++) {
  1440.                      src_line = sfb_start*3 + window*sfb_lines + freq; 
  1441.                      des_line = (sfb_start*3) + window + (freq*3);
  1442.                      ro[des_line/SSLIMIT][des_line%SSLIMIT] = 
  1443.                                     xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1444.                }
  1445.       } 
  1446.       else {  /* pure short */
  1447.          for(sfb=0,sfb_start=0,sfb_lines=sfBandIndex[sfreq].s[1]; 
  1448.             sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  1449.             (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  1450.                for(window=0; window<3; window++)
  1451.                   for(freq=0;freq<sfb_lines;freq++) {
  1452.                      src_line = sfb_start*3 + window*sfb_lines + freq; 
  1453.                      des_line = (sfb_start*3) + window + (freq*3);
  1454.                      ro[des_line/SSLIMIT][des_line%SSLIMIT] = 
  1455.                                     xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1456.                }
  1457.       }
  1458.    }
  1459.    else {   /*long blocks */
  1460.       for (sb=0 ; sb < SBLIMIT ; sb++)
  1461.          for (ss=0 ; ss < SSLIMIT ; ss++) 
  1462.             ro[sb][ss] = xr[sb][ss];
  1463.    }
  1464. }
  1466. static void III_i_stereo_k_values(is_pos,io,i,k)
  1467. double io;
  1468. int is_pos,i;
  1469. double FAR k[2][576];
  1470.           
  1471. {
  1472.    if(is_pos == 0)
  1473.    { 
  1474.       k[0][i] = 1;
  1475.       k[1][i] = 1;
  1476.    }
  1477.    else if ((is_pos % 2) == 1)
  1478.    {
  1479.       k[0][i] = pow(io,(double)((is_pos + 1)/2));
  1480.       k[1][i] = 1;
  1481.    }
  1482.    else
  1483.    {
  1484.       k[0][i] = 1;
  1485.       k[1][i] = pow(io,(double)(is_pos/2));
  1486.    }
  1487. }
  1490. void III_stereo(xr, lr, scalefac, gr_info, fr_ps)
  1491. double xr[2][SBLIMIT][SSLIMIT];
  1492. double lr[2][SBLIMIT][SSLIMIT];
  1493. III_scalefac_t *scalefac;
  1494. struct gr_info_s *gr_info;
  1495. frame_params *fr_ps;
  1496. {
  1497.    int sfreq;
  1498.    int stereo = fr_ps->stereo;
  1499.    int ms_stereo = (fr_ps->header->mode == MPG_MD_JOINT_STEREO) &&
  1500.                    (fr_ps->header->mode_ext & 0x2); 
  1501.    int i_stereo = (fr_ps->header->mode == MPG_MD_JOINT_STEREO) &&
  1502.                   (fr_ps->header->mode_ext & 0x1);
  1503.    int js_bound;  /* frequency line that marks the beggining of the zero part */  
  1504.    int sfb,next_sfb_boundary;
  1505.    int i,j,sb,ss,ch;
  1506.    short is_pos[SBLIMIT*SSLIMIT]; 
  1507.    double is_ratio[SBLIMIT*SSLIMIT];
  1508.    double io;
  1509.    double FAR k[2][SBLIMIT*SSLIMIT];
  1511.    int lsf = (fr_ps->header->version == MPEG_PHASE2_LSF);
  1513.     if(  (gr_info->scalefac_compress % 2) == 1)
  1514.      {
  1515.        io = (double)0.707106781188;
  1516.      }
  1517.      else
  1518.      {
  1519.        io = (double)0.840896415256;
  1520.      }
  1523.    sfreq=fr_ps->header->sampling_frequency + (fr_ps->header->version * 3);
  1525.   
  1526.    /* intialization */
  1527.    for ( i=0; i<SBLIMIT*SSLIMIT; i++ )
  1528.       is_pos[i] = 7;
  1530.    if ((stereo == 2) && i_stereo )
  1531.    {  if (gr_info->window_switching_flag && (gr_info->block_type == 2))
  1532.       {  if( gr_info->mixed_block_flag )
  1533.          {  int max_sfb = 0;
  1535.             for ( j=0; j<3; j++ )
  1536.             {  int sfbcnt;
  1537.                sfbcnt = 2;
  1538.                for( sfb=12; sfb >=3; sfb-- )
  1539.                {  int lines;
  1540.                   lines = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  1541.                   i = 3*sfBandIndex[sfreq].s[sfb] + (j+1) * lines - 1;
  1542.                   while ( lines > 0 )
  1543.                   {  if ( xr[1][i/SSLIMIT][i%SSLIMIT] != 0.0 )
  1544.                      {  sfbcnt = sfb;
  1545.                         sfb = -10;
  1546.                         lines = -10;
  1547.                      }
  1548.                      lines--;
  1549.                      i--;
  1550.                   }
  1551.                }
  1552.                sfb = sfbcnt + 1;
  1554.                if ( sfb > max_sfb )
  1555.                   max_sfb = sfb;
  1557.                while( sfb<12 )
  1558.                {  sb = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  1559.                   i = 3*sfBandIndex[sfreq].s[sfb] + j * sb;
  1560.                   for ( ; sb > 0; sb--)
  1561.                   {  is_pos[i] = (*scalefac)[1].s[j][sfb];
  1562.                      if ( is_pos[i] != 7 )
  1563.                          if( lsf )
  1564.                          {
  1565.                               III_i_stereo_k_values(is_pos[i],io,i,k);
  1566.                          }
  1567.                          else
  1568.                          {
  1569.                              is_ratio[i] = tan((double)is_pos[i] * (PI / 12));
  1570.                          }
  1571.                      i++;
  1572.                   }
  1573.                   sfb++;
  1574.                }
  1576.                sb = sfBandIndex[sfreq].s[12]-sfBandIndex[sfreq].s[11];
  1577.                sfb = 3*sfBandIndex[sfreq].s[11] + j * sb;
  1578.                sb = sfBandIndex[sfreq].s[13]-sfBandIndex[sfreq].s[12];
  1580.                i = 3*sfBandIndex[sfreq].s[11] + j * sb;
  1581.                for ( ; sb > 0; sb-- )
  1582.                {  is_pos[i] = is_pos[sfb];
  1583.                   is_ratio[i] = is_ratio[sfb];
  1584.                   k[0][i] = k[0][sfb];
  1585.                   k[1][i] = k[1][sfb];
  1586.                   i++;
  1587.                }
  1588.              }
  1589.              if ( max_sfb <= 3 )
  1590.              {  i = 2;
  1591.                 ss = 17;
  1592.                 sb = -1;
  1593.                 while ( i >= 0 )
  1594.                 {  if ( xr[1][i][ss] != 0.0 )
  1595.                    {  sb = i*18+ss;
  1596.                       i = -1;
  1597.                    } else
  1598.                    {  ss--;
  1599.                       if ( ss < 0 )
  1600.                       {  i--;
  1601.                          ss = 17;
  1602.                       }
  1603.                    }
  1604.                 }
  1605.                 i = 0;
  1606.                 while ( sfBandIndex[sfreq].l[i] <= sb )
  1607.                    i++;
  1608.                 sfb = i;
  1609.                 i = sfBandIndex[sfreq].l[i];
  1610.                 for ( ; sfb<8; sfb++ )
  1611.                 {  sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
  1612.                    for ( ; sb > 0; sb--)
  1613.                    {  is_pos[i] = (*scalefac)[1].l[sfb];
  1614.                       if ( is_pos[i] != 7 )
  1615.                          if ( lsf )
  1616.                          {
  1617.                               III_i_stereo_k_values(is_pos[i],io,i,k);
  1618.                          }
  1619.                          else
  1620.                          {
  1621.                              is_ratio[i] = tan((double)is_pos[i] * (PI / 12));
  1622.                          }
  1623.                       i++;
  1624.                    }
  1625.                 }
  1626.             }
  1627.          } else
  1628.          {  for ( j=0; j<3; j++ )
  1629.             {  int sfbcnt;
  1630.                sfbcnt = -1;
  1631.                for( sfb=12; sfb >=0; sfb-- )
  1632.                {  int lines;
  1633.                   lines = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  1634.                   i = 3*sfBandIndex[sfreq].s[sfb] + (j+1) * lines - 1;
  1635.                   while ( lines > 0 )
  1636.                   {  if ( xr[1][i/SSLIMIT][i%SSLIMIT] != 0.0 )
  1637.                      {  sfbcnt = sfb;
  1638.                         sfb = -10;
  1639.                         lines = -10;
  1640.                      }
  1641.                      lines--;
  1642.                      i--;
  1643.                   }
  1644.                }
  1645.                sfb = sfbcnt + 1;
  1646.                while( sfb<12 )
  1647.                {  sb = sfBandIndex[sfreq].s[sfb+1]-sfBandIndex[sfreq].s[sfb];
  1648.                   i = 3*sfBandIndex[sfreq].s[sfb] + j * sb;
  1649.                   for ( ; sb > 0; sb--)
  1650.                   {  is_pos[i] = (*scalefac)[1].s[j][sfb];
  1651.                      if ( is_pos[i] != 7 )
  1652.                          if( lsf )
  1653.                          {
  1654.                               III_i_stereo_k_values(is_pos[i],io,i,k);
  1655.                          }
  1656.                          else
  1657.                          {
  1658.                              is_ratio[i] = tan( (double)is_pos[i] * (PI / 12));
  1659.                          }
  1660.                      i++;
  1661.                   }
  1662.                   sfb++;
  1663.                }
  1665.                sb = sfBandIndex[sfreq].s[12]-sfBandIndex[sfreq].s[11];
  1666.                sfb = 3*sfBandIndex[sfreq].s[11] + j * sb;
  1667.                sb = sfBandIndex[sfreq].s[13]-sfBandIndex[sfreq].s[12];
  1669.                i = 3*sfBandIndex[sfreq].s[11] + j * sb;
  1670.                for ( ; sb > 0; sb-- )
  1671.                {  is_pos[i] = is_pos[sfb];
  1672.                   is_ratio[i] = is_ratio[sfb];
  1673.                   k[0][i] = k[0][sfb];
  1674.                   k[1][i] = k[1][sfb];
  1675.                   i++;
  1676.                }
  1677.             }
  1678.          }
  1679.       } else
  1680.       {  i = 31;
  1681.          ss = 17;
  1682.          sb = 0;
  1683.          while ( i >= 0 )
  1684.          {  if ( xr[1][i][ss] != 0.0 )
  1685.             {  sb = i*18+ss;
  1686.                i = -1;
  1687.             } else
  1688.             {  ss--;
  1689.                if ( ss < 0 )
  1690.                {  i--;
  1691.                   ss = 17;
  1692.                }
  1693.             }
  1694.          }
  1695.          i = 0;
  1696.          while ( sfBandIndex[sfreq].l[i] <= sb )
  1697.             i++;
  1698.          sfb = i;
  1699.          i = sfBandIndex[sfreq].l[i];
  1700.          for ( ; sfb<21; sfb++ )
  1701.          {  sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
  1702.             for ( ; sb > 0; sb--)
  1703.             {  is_pos[i] = (*scalefac)[1].l[sfb];
  1704.                if ( is_pos[i] != 7 )
  1705.                      if( lsf )
  1706.                      {
  1707.                            III_i_stereo_k_values(is_pos[i],io,i,k);
  1708.                      }
  1709.                      else
  1710.                      {
  1711.                           is_ratio[i] = tan((double)is_pos[i] * (PI / 12));
  1712.                      }
  1713.                i++;
  1714.             }
  1715.          }
  1716.          sfb = sfBandIndex[sfreq].l[20];
  1717.          for ( sb = 576 - sfBandIndex[sfreq].l[21]; sb > 0; sb-- )
  1718.          {  is_pos[i] = is_pos[sfb];
  1719.             is_ratio[i] = is_ratio[sfb];
  1720.             k[0][i] = k[0][sfb];
  1721.             k[1][i] = k[1][sfb];
  1722.             i++;
  1723.          }
  1724.       }
  1725.    }
  1727.    for(ch=0;ch<2;ch++)
  1728.       for(sb=0;sb<SBLIMIT;sb++)
  1729.          for(ss=0;ss<SSLIMIT;ss++) 
  1730.             lr[ch][sb][ss] = 0;
  1732.    if (stereo==2) 
  1733.       for(sb=0;sb<SBLIMIT;sb++)
  1734.          for(ss=0;ss<SSLIMIT;ss++) {
  1735.             i = (sb*18)+ss;
  1736.             if ( is_pos[i] == 7 ) {
  1737.                if ( ms_stereo ) {
  1738.                   lr[0][sb][ss] = (xr[0][sb][ss]+xr[1][sb][ss])/(double)1.41421356;
  1739.                   lr[1][sb][ss] = (xr[0][sb][ss]-xr[1][sb][ss])/(double)1.41421356;
  1740.                }
  1741.                else {
  1742.                   lr[0][sb][ss] = xr[0][sb][ss];
  1743.                   lr[1][sb][ss] = xr[1][sb][ss];
  1744.                }
  1745.             }
  1746.             else if (i_stereo ) {
  1747.                 if ( lsf )
  1748.                 {
  1749.                   lr[0][sb][ss] = xr[0][sb][ss] * k[0][i];
  1750.                   lr[1][sb][ss] = xr[0][sb][ss] * k[1][i]; 
  1751.                 }
  1752.                else
  1753.                 {
  1754.                   lr[0][sb][ss] = xr[0][sb][ss] * (is_ratio[i]/(1+is_ratio[i]));
  1755.                   lr[1][sb][ss] = xr[0][sb][ss] * (1/(1+is_ratio[i])); 
  1756.                 }
  1757.             }
  1758.             else {
  1759.                printf("Error in streo processingn");
  1760.             }
  1761.          }
  1762.    else  /* mono , bypass xr[0][][] to lr[0][][]*/
  1763.       for(sb=0;sb<SBLIMIT;sb++)
  1764.          for(ss=0;ss<SSLIMIT;ss++)
  1765.             lr[0][sb][ss] = xr[0][sb][ss];
  1767. }
  1769. double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
  1772. void III_antialias(xr, hybridIn, gr_info, fr_ps)
  1773. double xr[SBLIMIT][SSLIMIT];    
  1774. double hybridIn[SBLIMIT][SSLIMIT];
  1775. struct gr_info_s *gr_info;             
  1776. frame_params *fr_ps;            
  1777. {
  1778.    static int    init = 1;
  1779.    static double ca[8],cs[8];
  1780.    double        bu,bd;  /* upper and lower butterfly inputs */
  1781.    int           ss,sb,sblim;
  1783.    if (init) {
  1784.       int i;
  1785.       double    sq;
  1786.       for (i=0;i<8;i++) {
  1787.          sq=sqrt(1.0+Ci[i]*Ci[i]);
  1788.          cs[i] = 1.0/sq;
  1789.          ca[i] = Ci[i]/sq;
  1790.       }
  1791.       init = 0;
  1792.    }
  1793.    
  1794.    /* clear all inputs */  
  1795.       
  1796.     for(sb=0;sb<SBLIMIT;sb++)
  1797.        for(ss=0;ss<SSLIMIT;ss++)
  1798.           hybridIn[sb][ss] = xr[sb][ss];
  1800.    if  (gr_info->window_switching_flag && (gr_info->block_type == 2) &&
  1801.        !gr_info->mixed_block_flag ) return;
  1803.    if ( gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1804.      (gr_info->block_type == 2))
  1805.       sblim = 1;
  1806.    else
  1807.       sblim = SBLIMIT-1;
  1809.    /* 31 alias-reduction operations between each pair of sub-bands */
  1810.    /* with 8 butterflies between each pair                         */
  1812.    for(sb=0;sb<sblim;sb++)   
  1813.       for(ss=0;ss<8;ss++) {      
  1814.          bu = xr[sb][17-ss];
  1815.          bd = xr[sb+1][ss];
  1816.          hybridIn[sb][17-ss] = (bu * cs[ss]) - (bd * ca[ss]);
  1817.          hybridIn[sb+1][ss] = (bd * cs[ss]) + (bu * ca[ss]);
  1818.          }  
  1819. }
  1821. void inv_mdct(in, out, block_type)
  1822. double in[18];
  1823. double out[36];
  1824. int block_type;
  1825. {
  1826. /*------------------------------------------------------------------*/
  1827. /*                                                                  */
  1828. /*    Function: Calculation of the inverse MDCT                     */
  1829. /*    In the case of short blocks the 3 output vectors are already  */
  1830. /*    overlapped and added in this modul.                           */
  1831. /*                                                                  */
  1832. /*    New layer3                                                    */
  1833. /*                                                                  */
  1834. /*------------------------------------------------------------------*/
  1836. int     k,i,m,N,p;
  1837. double  tmp[12],sum;
  1838. static  double  win[4][36];
  1839. static  int init=0;
  1840. static  double COS[4*36];
  1842.     if(init==0){
  1844.     /* type 0 */
  1845.       for(i=0;i<36;i++)
  1846.          win[0][i] = sin( PI/36 *(i+0.5) );
  1848.     /* type 1*/
  1849.       for(i=0;i<18;i++)
  1850.          win[1][i] = sin( PI/36 *(i+0.5) );
  1851.       for(i=18;i<24;i++)
  1852.          win[1][i] = 1.0;
  1853.       for(i=24;i<30;i++)
  1854.          win[1][i] = sin( PI/12 *(i+0.5-18) );
  1855.       for(i=30;i<36;i++)
  1856.          win[1][i] = 0.0;
  1858.     /* type 3*/
  1859.       for(i=0;i<6;i++)
  1860.          win[3][i] = 0.0;
  1861.       for(i=6;i<12;i++)
  1862.          win[3][i] = sin( PI/12 *(i+0.5-6) );
  1863.       for(i=12;i<18;i++)
  1864.          win[3][i] =1.0;
  1865.       for(i=18;i<36;i++)
  1866.          win[3][i] = sin( PI/36*(i+0.5) );
  1868.     /* type 2*/
  1869.       for(i=0;i<12;i++)
  1870.          win[2][i] = sin( PI/12*(i+0.5) ) ;
  1871.       for(i=12;i<36;i++)
  1872.          win[2][i] = 0.0 ;
  1874.       for (i=0; i<4*36; i++)
  1875.          COS[i] = cos(PI/(2*36) * i);
  1877.       init++;
  1878.     }
  1880.     for(i=0;i<36;i++)
  1881.        out[i]=0;
  1883.     if(block_type == 2){
  1884.        N=12;
  1885.        for(i=0;i<3;i++){
  1886.           for(p= 0;p<N;p++){
  1887.              sum = 0.0;
  1888.              for(m=0;m<N/2;m++)
  1889.                 sum += in[i+3*m] * cos( PI/(2*N)*(2*p+1+N/2)*(2*m+1) );
  1890.              tmp[p] = sum * win[block_type][p] ;
  1891.           }
  1892.           for(p=0;p<N;p++)
  1893.              out[6*i+p+6] += tmp[p];
  1894.        }
  1895.     }
  1896.     else{
  1897.       N=36;
  1898.       for(p= 0;p<N;p++){
  1899.          sum = 0.0;
  1900.          for(m=0;m<N/2;m++)
  1901.            sum += in[m] * COS[((2*p+1+N/2)*(2*m+1))%(4*36)];
  1902.          out[p] = sum * win[block_type][p];
  1903.       }
  1904.     }
  1905. }
  1907. void III_hybrid(fsIn, tsOut ,sb, ch, gr_info, fr_ps)
  1908. double fsIn[SSLIMIT];   /* freq samples per subband in */
  1909. double tsOut[SSLIMIT];  /* time samples per subband out */
  1910. int sb, ch;
  1911. struct gr_info_s *gr_info;             
  1912. frame_params *fr_ps;            
  1913. {
  1914.    int ss;
  1915.    double rawout[36];
  1916.    static double prevblck[2][SBLIMIT][SSLIMIT];
  1917.    static int init = 1;
  1918.    int bt;
  1920.    if (init) {
  1921.       int i,j,k;
  1922.       
  1923.       for(i=0;i<2;i++)
  1924.          for(j=0;j<SBLIMIT;j++)
  1925.             for(k=0;k<SSLIMIT;k++)
  1926.                prevblck[i][j][k]=0.0;
  1927.       init = 0;
  1928.    }
  1930.    bt = (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1931.           (sb < 2)) ? 0 : gr_info->block_type; 
  1933.    inv_mdct( fsIn, rawout, bt);
  1935.    /* overlap addition */
  1936.    for(ss=0; ss<SSLIMIT; ss++) {
  1937.       tsOut[ss] = rawout[ss] + prevblck[ch][sb][ss];
  1938.       prevblck[ch][sb][ss] = rawout[ss+18];
  1939.    }
  1940. }
  1942. /* Return the number of slots for main data of current frame, */
  1944. int main_data_slots(fr_ps)
  1945. frame_params fr_ps;
  1946. {int nSlots;
  1948.    nSlots = (144 * bitrate[fr_ps.header->version][2][fr_ps.header->bitrate_index])
  1949.     / s_freq[fr_ps.header->version][fr_ps.header->sampling_frequency];
  1950.   if ( fr_ps.header->version != MPEG_PHASE2_LSF ) {
  1951.        if (fr_ps.stereo == 1) nSlots -= 17; else nSlots -=32;
  1952.   }
  1953.   else
  1954.   {
  1955.       nSlots = nSlots / 2;
  1956.       if (fr_ps.stereo == 1) nSlots -= 9; else nSlots -=17;
  1957.   }
  1959.   if (fr_ps.header->padding) nSlots++;
  1960.       nSlots -= 4;
  1961.   if (fr_ps.header->error_protection) nSlots -= 2;
  1963.   return(nSlots);
  1964. }