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

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

mpeg/mp3

开发平台：

C/C++

DECODE.C：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Multichannel Decoder
  4.  *
  5.  * $Id: decode.c 1.12 1997/01/17 04:26:01 rowlands Exp $
  6.  *
  7.  * $Log: decode.c $
  8.  * Revision 1.12  1997/01/17 04:26:01  rowlands
  9.  * Fixed base bitstream joint stereo bugs.
  10.  * Fixed PCM output file cleanup bugs.
  11.  *
  12.  * Revision 1.11  1996/04/18 05:37:23  rowlands
  13.  * Release following Florence meeting
  14.  *
  15.  * Revision 1.10  1996/02/12 07:13:06  rowlands
  16.  * Release following Munich meeting
  17.  *
  18.  * Revision 1.9.1.4  1996/01/29  03:36:47  rowlands
  19.  * Fixed problem with dynamic crosstalk in 2/2 configuration
  20.  * Fixed bug in dynamic crosstalk for 3/1 configuration.
  21.  *
  22.  * Revision 1.9.1.1  1996/01/20  17:28:45  rowlands
  23.  * Received from Ralf Schwalbe (Telekom FTZ) - includes prediction
  24.  *
  25.  * Revision 1.7.1.3  1995/08/14  08:12:10  tenkate
  26.  * ML-LSF added Warner ten Kate 7/8/95 (Philips)
  27.  * change "alloc" and "sblimit" into "alloc_ml" and
  28.  * "sblimit_ml" where appropriate.
  29.  *
  30.  * Revision 1.7.1.1  1995/07/14  06:12:46  rowlands
  31.  * Updated dynamic crosstalk from FTZ: revision FTZ_03
  32.  *
  33.  * Revision 1.3.3.1  1995/06/16  08:00:46  rowlands
  34.  * Input from Sang Wook Kim (Samsung AIT)
  35.  *
  36.  * Revision 1.3.2.1  1995/06/16  03:27:20  rowlands
  37.  * Corrected prediction select syntax according to IS
  38.  * Added dematrixing procedure 2. Corrected dematrix weighting values.
  39.  *
  40.  **********************************************************************/
  42. /**********************************************************************
  43.  *   date   programmers                comment                        *
  44.  * 2/25/91  Douglas Wong        start of version 1.0 records          *
  45.  * 3/06/91  Douglas Wong        rename setup.h to dedef.h             *
  46.  *                              removed extraneous variables          *
  47.  *                              removed window_samples (now part of   *
  48.  *                              filter_samples)                       *
  49.  * 3/07/91  Davis Pan           changed output file to "codmusic"     *
  50.  * 5/10/91  Vish (PRISM)        Ported to Macintosh and Unix.         *
  51.  *                              Incorporated new "out_fifo()" which   *
  52.  *                              writes out last incomplete buffer.    *
  53.  *                              Incorporated all AIFF routines which  *
  54.  *                              are also compatible with SUN.         *
  55.  *                              Incorporated user interface for       *
  56.  *                              specifying sound file names.          *
  57.  *                              Also incorporated user interface for  *
  58.  *                              writing AIFF compatible sound files.  *
  59.  * 27jun91  dpwe (Aware)        Added musicout and &sample_frames as  *
  60.  *                              args to out_fifo (were glob refs).    *
  61.  *                              Used new 'frame_params' struct.       *
  62.  *                              Clean,simplify, track clipped output  *
  63.  *                              and total bits/frame received.        *
  64.  * 7/10/91  Earle Jennings      changed to floats to FLOAT            *
  65.  *10/ 1/91  S.I. Sudharsanan,   Ported to IBM AIX platform.           *
  66.  *          Don H. Lee,                                               *
  67.  *          Peter W. Farrett                                          *
  68.  *10/ 3/91  Don H. Lee          implemented CRC-16 error protection   *
  69.  *                              newly introduced functions are        *
  70.  *                              buffer_CRC and recover_CRC_error      *
  71.  *                              Additions and revisions are marked    *
  72.  *                              with "dhl" for clarity                *
  73.  * 2/11/92  W. Joseph Carter    Ported new code to Macintosh.  Most   *
  74.  *                              important fixes involved changing     *
  75.  *                              16-bit ints to long or unsigned in    *
  76.  *                              bit alloc routines for quant of 65535 *
  77.  *                              and passing proper function args.     *
  78.  *                              Removed "Other Joint Stereo" option   *
  79.  *                              and made bitrate be total channel     *
  80.  *                              bitrate, irrespective of the mode.    *
  81.  *                              Fixed many small bugs & reorganized.  *
  82.  **********************************************************************
  83.  *                                                                    *
  84.  *                                                                    *
  85.  *  MPEG/audio Phase 2 coding/decoding multichannel                   *
  86.  *                                                                    *
  87.  *  Version 1.0                                                       *
  88.  *                                                                    *
  89.  *  7/27/93        Susanne Ritscher,  IRT Munich                      *
  90.  *                                                                    *
  91.  *                  thanks to                                         *
  92.  *                  Ralf Schwalbe,    Telekom FTZ Berlin              *
  93.  *                  Heiko Purnhagen,  Uni Hannover                    *
  94.  *                                                                    *
  95.  *  Version 2.0                                                       *
  96.  *                                                                    *
  97.  *  8/27/93        Susanne Ritscher, IRT Munich                       *
  98.  *                 Channel-Switching is working                       *
  99.  *                                                                    *
  100.  *  Version 2.1                                                       *
  101.  *                                                                    *
  102.  *  9/1/93         Susanne Ritscher,  IRT Munich                      *
  103.  *                 all channels normalized                            *
  104.  *                                                                    *
  105.  *  Version 3.0                                                       *
  106.  *                                                                    *
  107.  *  06/16/94       Ralf Schwalbe, Telekom FTZ Berlin                  *
  108.  *                 all sources and variables adapted due to MPEG-2 -  *
  109.  *                 DIS from March 1994                                *
  110.  *                  - dematrix and denormalize procedure              *
  111.  *                  - new tc - allocation (0-7)                       *
  112.  *                  - some new structures and variables as a basis    *
  113.  *                    for further decoding modes                      *
  114.  **********************************************************************
  115.  *       *
  116.  *  Version 1.0                                                       *
  117.  *                                                                    *
  118.  *  11/04/94       Ralf Schwalbe,  Telekom FTZ Berlin                 *
  119.  *                  - decoding tc-allocation                          *
  120.  *                  - some new subroutines, globale variables and     *
  121.  *                    structures (important to handle the ext. bitst.)*
  122.  *                  - changed all functions to ANSI-C funktion header *
  123.  *     - corrected some bugs to decode bitstreams > 512kB*
  124.  *       *
  125.  *  Version 1.1                                                       *
  126.  *                                                                    *
  127.  *  12/07/94       Ralf Schwalbe,  Telekom FTZ Berlin                 *
  128.  *                  - decoding extension bitstream                    *
  129.  *                                                                    *
  130.  *  Version 1.1.1                                                     *
  131.  *                 Ralf Schwalbe, Telekom FTZ Berlin                  *
  132.  *                  - fixed some bugs                                 *
  133.  *                                                                    *
  134.  *  Version 1.2                                                       *
  135.  *                                                                    *
  136.  *  6/21/95       Ralf Schwalbe, Deutsche Telekom FTZ Berlin          *
  137.  *                 - decoding dynamic crosstalk                      *
  138.  *                  - decoding phantom center                         * 
  139.  *                  - decoding MPEG1 compatible part only (stereo)    *
  140.  *                  - corrected some settings and bugs                *
  141.  *                                                                    * 
  142.  *  7/12/95   Ralf Schwalbe, Deutsche Telekom FTZ Berlin          *
  143.  *     - corrected dynamic crosstalk        *
  144.  *     - 3/2,3/1,3/0,2/1, channel configurations         *
  145.  *                    are working                                     *
  146.  *          *
  147.  * 10/31/95   Ralf Schwalbe, Deutsche Telekom FTZ Berlin       *
  148.  *     - decoding of LFE-channel is working         *
  149.  *     - corrected any settings and bugs       *
  150.  *     - corrected table-switch for channel mode < 3/2   *
  151.  *       and tc-allocation / dyn-crosstalk       *
  152.  *     - still a problem with compl. bitstream 18/19     *
  153.  *       *
  154.  * 01/12/96   Ralf Schwalbe, Deutsche Telekom TZ Darmstadt       *
  155.  *     - decoder prediction installed       *
  156.  *     - problem with compl. bitstream 19 solved,        *
  157.  *                                                                    *         
  158.  *  Version 2.0                                                       *
  159.  *                                                                    *
  160.  * 01/28/97       Frans de Bont, Philips Sound & Vision, Eindhoven    *
  161.  *     - simultaneous use of tc allocation and dynamic   *
  162.  *       crosstalk working for all configurations       *
  163.  *     - prediction working for all configurations       *
  164.  *     - layer 1 MC working       *
  165.  *     - variable bit rate and extension bitstreams      *
  166.  *     - fully compliant to 13818-3.2                    *
  167.  *                                                                    *       *     
  168.  **********************************************************************/
  170. /**********************************************************************
  171.  *                                                                    *
  172.  *  06/06/95       Yeon Bae Thomas Kim,  Samsung AIT                  *
  173.  *                 ancillary data is working                          *
  174.  *       *
  175.  **********************************************************************/
  176.  /*********************************************************************/
  178. #include        "common.h"
  179. #include        "decoder.h"
  181. /***************************************************************
  182. /*
  183. /* This module contains the core of the decoder ie all the
  184. /* computational routines. (Layer I and II only)
  185. /* Functions are common to both layer unless
  186. /* otherwise specified.
  187. /*
  188. /***************************************************************/
  190. /*****************************************************************
  191. /*
  192. /* The following routines decode the system information
  193. /*
  194. /****************************************************************/
  196. /************************* Layer II  ****************************/
  198. void decode_info(Bit_stream *bs,
  199.  frame_params *fr_ps)
  200. {
  201.    layer *hdr = fr_ps->header;
  203.    hdr->version = get1bit (bs);
  204.    hdr->lay = 4 - getbits (bs, 2);
  205.    hdr->error_protection = !get1bit (bs); /* error protect. TRUE/FALSE */
  206.    hdr->bitrate_index = getbits (bs, 4);
  207.    hdr->sampling_frequency = getbits (bs, 2);
  208.    hdr->padding = get1bit (bs);
  209.    hdr->extension = get1bit (bs);
  210.    hdr->mode = getbits (bs, 2);
  211.    hdr->mode_ext = getbits (bs, 2);
  212.    hdr->copyright = get1bit (bs);
  213.    hdr->original = get1bit (bs);
  214.    hdr->emphasis = getbits (bs, 2);
  215. }
  219. /**********************************************************************/
  220. /*   */
  221. /*  7.7.93 Susanne Ritscher Systeminformation for multi-channel       */
  222. /* 27.5.94 Ralf Schwalbe    Systeminformation and names due to   */
  223. /* MPEG 2 DIS from March 1994  */                         
  224. /* */
  225. /**********************************************************************/
  227. void mc_header(Bit_stream *bs,
  228.        frame_params *fr_ps)
  229. {
  230.    layer *hdr = fr_ps->header;
  231.    hdr->ext_bit_stream_present = get1bit (bs);
  232.    if( hdr->ext_bit_stream_present == 1)
  233. hdr->n_ad_bytes =  getbits (bs, 8);
  234.    hdr->center = getbits (bs, 2);
  235.    hdr->surround = getbits (bs, 2);
  236.    hdr->lfe = get1bit (bs);
  237.    hdr->audio_mix = get1bit (bs);     /* large or small room  R.S. */
  238.    hdr->dematrix_procedure = getbits (bs, 2);
  239.    hdr->no_of_multi_lingual_ch = getbits (bs, 3);
  240.    hdr->multi_lingual_fs = get1bit (bs);
  241.    hdr->multi_lingual_layer = get1bit (bs);
  242.    hdr->copyright_ident_bit = get1bit (bs);
  243.    hdr->copyright_ident_start = get1bit (bs);
  244. }
  246. /* R.S. prediction table MPEG-2 IS November, 1995 */
  247. /* FdB  prediction table MPEG-2 CD 13818-3.2 March, 1996 */
  248. int pred_coef_table[6][16] = {{6,4,4,4,2,2,2,0,2,2,2,0,0,0,0,0},
  249.       {4,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0},
  250.       {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  251.       {4,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0},
  252.       {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  253.       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  256. void mc_composite_status_info(Bit_stream *bs,
  257.       frame_params *fr_ps, int tca_log, int dynx_log)
  258. {
  259.    layer *hdr = fr_ps->header;
  260.    int sbgr, j, pci;
  263.    hdr->tc_sbgr_select = get1bit (bs);
  264.    hdr->dyn_cross_on = get1bit (bs);
  265.    hdr->mc_prediction_on = get1bit (bs);
  267.    if(hdr->tc_sbgr_select == 1)
  268.    {
  269. hdr->tc_allocation = getbits (bs, fr_ps->alloc_bits);
  270. /* tc_allocation is valid for all sbgr R.S. */
  271. for(sbgr = 0; sbgr < 12; sbgr++)   
  272. hdr->tc_alloc[sbgr] = hdr->tc_allocation;
  273.    }
  274.    else
  275.    {
  276. hdr->tc_allocation = 0;
  277. for(sbgr = 0; sbgr < 12; sbgr++)
  278. hdr->tc_alloc[sbgr] = getbits (bs, fr_ps->alloc_bits);
  279.    }
  281.    if (tca_log)
  282.       for (sbgr = 0; sbgr < 12; sbgr++)
  283.  printf ("tc_alloc[ %2d ] = %2dn", sbgr, hdr->tc_alloc[sbgr]);
  285.    if( hdr->dyn_cross_on == 1)
  286.    {
  287. hdr->dyn_cross_LR = get1bit (bs);
  288. for(sbgr = 0; sbgr < 12; sbgr++)
  289. {
  290. hdr->dyn_cross_mode[sbgr] = getbits (bs, fr_ps->dyn_cross_bits);
  291. /* 960816 FdB dyn_second_stereo added */
  292. if (hdr->surround == 3)
  293. hdr->dyn_second_stereo[sbgr] = get1bit (bs);
  294. }
  295.    }
  296.    else
  297.    {
  298. hdr->dyn_cross_LR = 0;
  299. for(sbgr = 0; sbgr < 12; sbgr++)
  300. hdr->dyn_cross_mode[sbgr] = 0;
  301.    }
  303.    if (dynx_log)
  304.       for (sbgr = 0; sbgr < 12; sbgr++)
  305.  printf ("dynx_mod[ %2d ] = %2dn", sbgr, hdr->dyn_cross_mode[sbgr]);
  307.    if( hdr->mc_prediction_on == 1)
  308.    {
  309.   for(sbgr = 0; sbgr < 8; sbgr++) 
  310.   {  
  311. if( (hdr->mc_prediction[sbgr] = get1bit (bs)) == 1 )
  312. {
  313. /* R.S. read from npredcoef-table max number of coef. for 3/2 configuration */
  314. /* and then the predsi info -> 0    : no prediction    */
  315. /*     -> 1..3 : 1..3 coefficient */
  316.     for(pci=0; pci< pred_coef_table[fr_ps->pred_mode][hdr->dyn_cross_mode[sbgr]] ; pci++)
  317. hdr->mc_predsi[sbgr][pci] = getbits (bs, 2);
  318. }
  319.   }
  320.    }
  321. }
  325. #ifdef Augmentation_7ch
  326. void mc_aug_composite_status_info (Bit_stream *bs, frame_params *fr_ps, int tca_log, int dynx_log)
  327. {
  328.    layer *hdr = fr_ps->header;
  329.    int sbgr, j, pci;
  331.    hdr->aug_mtx_proc = getbits (bs, 2);
  332.    hdr->aug_dyn_cross_on = get1bit (bs);
  333.    hdr->aug_future_ext = get1bit (bs);
  335.    if(hdr->aug_mtx_proc == 0)
  336.    {
  337. for(sbgr = 0; sbgr < 12; sbgr++)   
  338. hdr->tc_aug_alloc[sbgr] = getbits (bs, 3);
  339.    }
  340.    else if(hdr->aug_mtx_proc == 1)
  341.    {
  342. for(sbgr = 0; sbgr < 12; sbgr++)
  343. hdr->tc_aug_alloc[sbgr] = getbits (bs, 2);
  344.    }
  345.    else
  346. for(sbgr = 0; sbgr < 12; sbgr++)
  347. hdr->tc_aug_alloc[sbgr] = 0;
  349.    if (tca_log)
  350.       for (sbgr = 0; sbgr < 12; sbgr++)
  351.  printf ("tc_aug_alloc[ %2d ] = %2dn", sbgr, hdr->tc_aug_alloc[sbgr]);
  353.    if( hdr->aug_dyn_cross_on == 1)
  354.    {
  355. for(sbgr = 0; sbgr < 12; sbgr++)
  356. hdr->dyn_cross_aug_mode[sbgr] = getbits (bs, 5);
  357.    }
  358.    else
  359. for(sbgr = 0; sbgr < 12; sbgr++)
  360. hdr->dyn_cross_aug_mode[sbgr] = 0;
  362.    if (dynx_log)
  363.       for (sbgr = 0; sbgr < 12; sbgr++)
  364.  printf ("dynx_aug_mod[ %2d ] = %2dn", sbgr, hdr->dyn_cross_aug_mode[sbgr]);
  365. }
  366. #endif
  368. /*******************************************************************
  369. /*
  370. /* The bit allocation information is decoded. Layer I
  371. /* has 4 bit per subband whereas Layer II is Ws and bit rate
  372. /* dependent.
  373. /*
  374. /********************************************************************/
  376. void I_decode_bitalloc (Bit_stream   *bs,
  377. frame_params *fr_ps,
  378. unsigned int bit_alloc[7][SBLIMIT],
  379. int      bits_log)
  380. {
  381.    int i,j;
  382.    int stereo  = fr_ps->stereo;
  383.    int sblimit = fr_ps->sblimit;
  384.    int jsbound = fr_ps->jsbound;
  385.    int b;
  387.    for (i=0;i<jsbound;i++)
  388.       for (j=0;j<stereo;j++)
  389.  bit_alloc[j][i] = getbits (bs, 4);
  391.    for (i=jsbound; i<SBLIMIT; i++)
  392.    {
  393.       b = getbits (bs, 4);
  394.       for (j=0; j<stereo; j++)
  395.  bit_alloc[j][i] = b;
  396.    }
  398.    if (bits_log)
  399.    {
  400.       for (j= 0; j < stereo; j++)
  401.          for (i = 0; i < SBLIMIT; i++)
  402.  {
  403.     int alloc_bits = 0, alloc_id = bit_alloc[j][i];
  405.     if ((j == 0 || i < jsbound) && bit_alloc[j][i] > 0)
  406.        alloc_bits = 12 * (alloc_id + 1);
  408.     printf ("alloc_bi[ %d ][ %2d ]= %3dn", j, i, alloc_bits);
  409.  }
  410.    }
  411. }
  414. void II_decode_bitalloc (Bit_stream *bs,
  415.  frame_params *fr_ps,
  416.  unsigned int bit_alloc[7][SBLIMIT],
  417.  int bits_log)
  418. {
  419.    int i,j,c,sbgr;
  420.    int stereo = fr_ps->stereo;
  421.    int sblimit = fr_ps->sblimit;
  422.    int jsbound = fr_ps->jsbound;
  423.    al_table *alloc = fr_ps->alloc;
  424.    unsigned int actual_alloc[7][SBLIMIT];
  426.    for (i = 0; i < SBLIMIT; i++)
  427.       for (j = 0; j < stereo; j++)
  428.  actual_alloc[j][i] = 0;
  430.    for (i=0; i<jsbound; i++)
  431.       for (j=0;j<stereo;j++)
  432.  actual_alloc[j][i] = bit_alloc[j][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  434.    for (i=jsbound; i<sblimit; i++)   /* expand to 2 channels */
  435.       actual_alloc[0][i] = bit_alloc[0][i] = bit_alloc[1][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  437.    for (i=sblimit; i<SBLIMIT; i++)
  438.       for (j=0; j<stereo; j++)
  439.   bit_alloc[j][i] = 0;
  441.    if (bits_log)
  442.    {
  443.       for (j= 0; j < stereo; j++)
  444.          for (i = 0; i < SBLIMIT; i++)
  445.  {
  446.     int alloc_bits = 0, alloc_id = bit_alloc[j][i];
  448.     if (actual_alloc[j][i] > 0)
  449.        alloc_bits = 12 * (*alloc)[i][alloc_id].bits * (*alloc)[i][alloc_id].group;
  451.     printf ("alloc_bi[ %d ][ %2d ]= %3dn", j, i, alloc_bits);
  452.  }
  453.    }
  454. }
  457. void II_decode_bitalloc_mc (Bit_stream *bs,
  458.     frame_params *fr_ps,
  459.     unsigned int bit_alloc[7][SBLIMIT],
  460.     int *l, int *m, int bits_log)
  461. {
  462.    layer *info = fr_ps->header;
  463.    int i,j,c,sbgr;
  464.    int sblimit = fr_ps->sblimit_mc;
  465.    al_table *alloc = fr_ps->alloc_mc;
  466.    unsigned int actual_alloc[7][SBLIMIT];
  468.    for (i = 0; i < SBLIMIT; i++)
  469.       for (j = *l; j < *m; j++)
  470.  actual_alloc[j][i] = 0;
  472.    /* 10/31/95 Ralf Schwalbe LFE */
  473.    if (info->lfe)
  474.       info->lfe_alloc = (char) getbits (bs, (*alloc)[0][0].bits);
  476.    for (i=0; i<sblimit; i++)
  477.       if (info->dyn_cross_on == 0)
  478.  for (j=*l;j<*m;j++)
  479.  {
  480.     if ((fr_ps->header->center != 3) || (i < 12) || (j !=2))
  481.        actual_alloc[j][i] = bit_alloc[j][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  482.     else
  483.        bit_alloc[j][i] = 0;
  484.  }
  485.       else  /* dyn. cross mode */
  486.       {
  487.  if (i == 0) sbgr = 0;
  488.  else
  489.     for (c = 1; c < 12; c++)
  490.     {
  491.        if ((sb_groups[c-1] < i) && (i <= sb_groups[c]))
  492.        {
  493.   sbgr = c;  /* search the valid subband group */
  494.   break;
  495.        }
  496.     }
  497.  
  498.  /* 960816 FdB new setup for dyn. crosstalk modes */
  499.  if (info->dyn_cross_mode[sbgr] == 0)
  500.  {
  501.     for (j = *l; j < *m; j++)
  502.        if (fr_ps->header->center == 3 && i >= 12 && j == 2)
  503.   bit_alloc[j][i] = 0;
  504.        else if (info->surround == 3 && info->dyn_second_stereo[sbgr] == 1)
  505.        {
  506.   if (info->center != 0 && j == 4)
  507.      bit_alloc[j][i] = bit_alloc[3][i];
  508.   else if (info->center == 0 && j == 3)
  509.      bit_alloc[j][i] = bit_alloc[2][i];
  510.   else
  511.      actual_alloc[j][i] = bit_alloc[j][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  512.        }
  513.        else
  514.   actual_alloc[j][i] = bit_alloc[j][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  515.  }
  516.  else if (fr_ps->dyn_cross_bits == 1)   /* for channel mode 3/0 and 2/1 */
  517.  {
  518.     /* DynX mode has to be 1 */
  519.     if ((info->center == 3) && (i >= 12))    /* 3/0 + phantom center */
  520.        bit_alloc[2][i] = 0;
  521.     else if (info->tc_alloc[sbgr] == 1)
  522.        bit_alloc[2][i] = bit_alloc[0][i];
  523.     else if (info->tc_alloc[sbgr] == 2)
  524.        bit_alloc[2][i] = bit_alloc[1][i];
  525.     else
  526.        if (info->dyn_cross_LR)
  527.   bit_alloc[2][i] = bit_alloc[1][i];
  528.        else
  529.   bit_alloc[2][i] = bit_alloc[0][i];
  530.  
  531.     if (info->surround == 3) /* 3/0 + 2/0 */
  532.     {
  533.        actual_alloc[3][i] = bit_alloc[3][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  534.        if (info->dyn_second_stereo[sbgr] == 1)
  535.   bit_alloc[4][i] = bit_alloc[3][i];
  536.        else
  537.   actual_alloc[4][i] = bit_alloc[4][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  538.     }
  539.  }
  540.  else if (fr_ps->dyn_cross_bits == 3)   /* for channel mode 3/1 and 2/2 */
  541.  {
  542.     if ((info->center == 3) && (i >= 12))    /* 3/1 + phantom center */
  543.        bit_alloc[2][i] = 0;
  544.     else if ((info->dyn_cross_mode[sbgr] == 1) || (info->dyn_cross_mode[sbgr] == 4))
  545.        actual_alloc[2][i] = bit_alloc[2][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  546.     else
  547.     {
  548.        /* T2 not transmitted */
  549.        if (fr_ps->header->surround == 2 || /* 2/2 mode */
  550.    fr_ps->header->tc_alloc[sbgr] == 1 || /* 3/1 mode */
  551.    fr_ps->header->tc_alloc[sbgr] == 5 || /* 3/1 mode (matrix mode 2 only) */
  552.    fr_ps->header->tc_alloc[sbgr] != 2 && !fr_ps->header->dyn_cross_LR)
  553.   bit_alloc[2][i] = bit_alloc[0][i]; /* C, L or Ls from L0 */
  554.        else
  555.   bit_alloc[2][i] = bit_alloc[1][i]; /* C, R or Rs from RO */
  556.     }
  557.  
  558.     if (info->dyn_cross_mode[sbgr] == 2)
  559.        actual_alloc[3][i] = bit_alloc[3][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  560.     else if (info->dyn_cross_mode[sbgr] == 4)
  561.        bit_alloc[3][i] = bit_alloc[2][i];
  562.     else
  563.     {
  564.        /* T3 not transmitted */
  565.        if (fr_ps->header->surround == 2 || /* 2/2 mode */
  566.    fr_ps->header->tc_alloc[sbgr] == 4 || /* 3/1 mode */
  567.    fr_ps->header->tc_alloc[sbgr] == 5 || /* 3/1 mode (matrix mode 2 only) */
  568.    fr_ps->header->tc_alloc[sbgr] < 3 && fr_ps->header->dyn_cross_LR)
  569.   bit_alloc[3][i] = bit_alloc[1][i]; /* S, R or Rs from R0 */
  570.        else
  571.   bit_alloc[3][i] = bit_alloc[0][i]; /* S, L or Ls from LO */
  572.     }
  573.  } 
  574.  else if (fr_ps->dyn_cross_bits == 4)   /* for channel mode 3/2 */
  575.  {
  576.     /* T2 */
  577.     if ((info->center == 3) && (i >= 12))    /* 3/2 + phantom center */
  578.        bit_alloc[2][i] = 0;
  579.     else switch (info->dyn_cross_mode[sbgr])
  580.     {
  581.     case 1 :   /* T2 contains bitalloc info */
  582.     case 2 :
  583.     case 4 :
  584.     case 8 :
  585.     case 9 :
  586.     case 10: 
  587.     case 11: 
  588.     case 12: 
  589.     case 14: 
  590.        actual_alloc[2][i] = bit_alloc[2][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  591.        break;
  592.     case 3 :   /* T2 contains no bitalloc info */
  593.     case 5 :
  594.     case 6 :
  595.     case 7 :
  596.     case 13: 
  597.        if ((info->tc_alloc[sbgr] == 1) || (info->tc_alloc[sbgr] == 7))
  598.   bit_alloc[2][i] = bit_alloc[0][i];
  599.        else if ((info->tc_alloc[sbgr] == 2) || (info->tc_alloc[sbgr] == 6))
  600.   bit_alloc[2][i] = bit_alloc[1][i];
  601.        else
  602.   if (info->dyn_cross_LR)
  603.      bit_alloc[2][i] = bit_alloc[1][i];
  604.   else
  605.      bit_alloc[2][i] = bit_alloc[0][i];
  606.        break;
  607.     }
  608.  
  609.     /* T3 */
  610.     switch (info->dyn_cross_mode[sbgr])
  611.     {
  612.     case 1 :   /* T3 contains bitalloc info */
  613.     case 3 :
  614.     case 5 :
  615.     case 8 :
  616.     case 10: 
  617.     case 13: 
  618.        actual_alloc[3][i] = bit_alloc[3][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  619.        break;
  620.     case 2 :   /* T3 has to copy its bitalloc from T0 */
  621.     case 4 :
  622.     case 6 :
  623.     case 7 :
  624.     case 12: 
  625.        bit_alloc[3][i] = bit_alloc[0][i];
  626.        break;
  627.     case 9 :   /* T3 has to copy its bitalloc from T2 */
  628.     case 11:
  629.     case 14: 
  630.        bit_alloc[3][i] = bit_alloc[2][i];
  631.        break;
  632.     }
  633.  
  634.     /* T4 */
  635.     switch (info->dyn_cross_mode[sbgr])
  636.     {
  637.     case 2 :   /* T4 contains bitalloc info */
  638.     case 3 :
  639.     case 6 :
  640.     case 9 : 
  641.        actual_alloc[4][i] = bit_alloc[4][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  642.        break;
  643.     case 1 :   /* T4 has to copy its bitalloc from T1 */
  644.     case 4 :
  645.     case 5 :
  646.     case 7 :
  647.     case 11: 
  648.        bit_alloc[4][i] = bit_alloc[1][i];
  649.        break;
  650.     case 10:   /* T4 has to copy its bitalloc from T2 */
  651.     case 12:
  652.     case 14: 
  653.        bit_alloc[4][i] = bit_alloc[2][i];
  654.        break;
  655.     case 8 :   /* T4 has to copy its bitalloc from T3 */
  656.     case 13: 
  657.        bit_alloc[4][i] = bit_alloc[3][i];
  658.        break;
  659.     }
  660.  }
  661.       }
  663.    for (i=sblimit; i<SBLIMIT; i++)
  664.       for (j=*l; j<*m; j++)
  665.   bit_alloc[j][i] = 0;
  667.    if (bits_log)
  668.    {
  669.       for (j= *l; j < *m; j++)
  670.          for (i = 0; i < SBLIMIT; i++)
  671.  {
  672.     int alloc_bits = 0, alloc_id = bit_alloc[j][i];
  674.     if (actual_alloc[j][i] > 0)
  675.        alloc_bits = 12 * (*alloc)[i][alloc_id].bits * (*alloc)[i][alloc_id].group;
  677.     printf ("alloc_bi[ %d ][ %2d ]= %3dn", j, i, alloc_bits);
  678.  }
  679.    }
  680. }
  682. #ifdef Augmentation_7ch
  683. void II_decode_bitalloc_aug (Bit_stream *bs,
  684.      frame_params *fr_ps,
  685.      unsigned int bit_alloc[7][SBLIMIT],
  686.      int *l, int *m, int bits_log)
  687. {
  688.    layer *info = fr_ps->header;
  689.    int i,j,c,sbgr;
  690.    /* int stereo = fr_ps->stereo; */ /* not used for mc - decoding */
  691.    int sblimit = fr_ps->sblimit_mc;
  692.    al_table *alloc = fr_ps->alloc_mc;
  693.    unsigned int actual_alloc[7][SBLIMIT];
  695.    for (i = 0; i < SBLIMIT; i++)
  696.       for (j = *l; j < *m; j++)
  697.  actual_alloc[j][i] = 0;
  699.    for (i=0; i<sblimit; i++)
  700.       if (info->aug_dyn_cross_on == 0)
  701.  for (j=*l;j<*m;j++)
  702.     actual_alloc[j][i] = bit_alloc[j][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  703.       else  /* dyn. cross mode */
  704.       {
  705.         int T5T0 = 0, T6T0 = 0, T6T1 = 1;
  706.     
  707.  if(i == 0) sbgr = 0;
  708.  else
  709.     for(c = 1; c < 12; c++)
  710.     {
  711.        if((sb_groups[c-1] < i) && (i <= sb_groups[c]))
  712.        {
  713.  sbgr = c;  /* search the valid subband group */
  714.  break;
  715. }
  716.      }
  717.  
  718.         if (info->tc_aug_alloc[sbgr] == 4 || info->tc_aug_alloc[sbgr] == 5)
  719.        if (info->dyn_cross_LR == 0)
  720.     T6T1 = 0;
  721.   else
  722.     T6T0 = 1;
  723.         else if (info->tc_aug_alloc[sbgr] == 6 || info->tc_aug_alloc[sbgr] == 7)
  724.           if (info->dyn_cross_LR)
  725.     T5T0 = 1;
  727.  /* read bitalloc info from bitstream */
  728.  switch (info->dyn_cross_aug_mode[sbgr])
  729.  {
  730.  case  0:   /* T5 and T6 contains bitalloc info */
  731.     actual_alloc[5][i] = bit_alloc[5][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  732.     actual_alloc[6][i] = bit_alloc[6][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  733.     break;
  734.  case  1:   /* T5 contains bitalloc info */
  735.  case  2:
  736.  case  3:
  737.  case  4:
  738.     actual_alloc[5][i] = bit_alloc[5][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  739.     break;
  740.  
  741.  case  5:   /* T6 contains bitalloc info */
  742.  case 10:
  743.  case 14:
  744.     actual_alloc[6][i] = bit_alloc[6][i] = (char) getbits (bs, (*alloc)[i][0].bits);
  745.     break;
  746.  }
  747.  
  748.  /* copy bitalloc info from other channels */
  749.  switch (info->dyn_cross_aug_mode[sbgr])
  750.  {
  751.  case  1:   /* copy T6 from T1 */
  752.     bit_alloc[6][i] = bit_alloc[T6T1][i];
  753.     break;
  754.  case  2:   /* copy T6 from T2 */
  755.     bit_alloc[6][i] = bit_alloc[2][i];
  756.     break;
  757.  case  3:   /* copy T6 from T4 */
  758.     bit_alloc[6][i] = bit_alloc[4][i];
  759.     break;
  760.  case  4:   /* copy T6 from T5 */
  761.     bit_alloc[6][i] = bit_alloc[5][i];
  762.     break;
  763.  case  5:   /* copy T5 from T0 */
  764.     bit_alloc[5][i] = bit_alloc[T5T0][i];
  765.     break;
  766.  case  6:   /* copy T5 from T0 and T6 from T1 */
  767.     bit_alloc[5][i] = bit_alloc[T5T0][i];
  768.     bit_alloc[6][i] = bit_alloc[T6T1][i];
  769.     break;
  770.  case  7:   /* copy T5 from T0 and T6 from T2 */
  771.     bit_alloc[5][i] = bit_alloc[T5T0][i];
  772.     bit_alloc[6][i] = bit_alloc[2][i];
  773.     break;
  774.  case  8:   /* copy T5 from T0 and T6 from T4 */
  775.     bit_alloc[5][i] = bit_alloc[T5T0][i];
  776.     bit_alloc[6][i] = bit_alloc[4][i];
  777.     break;
  778.  case  9:   /* copy T5 and T6 from T0 */
  779.     bit_alloc[5][i] = bit_alloc[T5T0][i];
  780.     bit_alloc[6][i] = bit_alloc[T6T0][i];
  781.     break;
  782.  case 10:   /* copy T5 from T2 */
  783.     bit_alloc[5][i] = bit_alloc[2][i];
  784.     break;
  785.  case 11:   /* copy T5 from T2 and T6 from T1 */
  786.     bit_alloc[5][i] = bit_alloc[2][i];
  787.     bit_alloc[6][i] = bit_alloc[T6T1][i];
  788.     break;
  789.  case 12:   /* copy T5 and T6 from T2 */
  790.     bit_alloc[5][i] = bit_alloc[6][i] = bit_alloc[2][i];
  791.     break;
  792.  case 13:   /* copy T5 from T2 and T6 from T4 */
  793.     bit_alloc[5][i] = bit_alloc[2][i];
  794.     bit_alloc[6][i] = bit_alloc[4][i];
  795.     break;
  796.  case 14:   /* copy T5 from T3 */
  797.     bit_alloc[5][i] = bit_alloc[3][i];
  798.     break;
  799.  case 15:   /* copy T5 from T3 and T6 from T1 */
  800.     bit_alloc[5][i] = bit_alloc[3][i];
  801.     bit_alloc[6][i] = bit_alloc[T6T1][i];
  802.     break;
  803.  case 16:   /* copy T5 from T3 and T6 from T2 */
  804.     bit_alloc[5][i] = bit_alloc[3][i];
  805.     bit_alloc[6][i] = bit_alloc[2][i];
  806.     break;
  807.  case 17:   /* copy T5 from T3 and T6 from T4 */
  808.     bit_alloc[5][i] = bit_alloc[3][i];
  809.     bit_alloc[6][i] = bit_alloc[4][i];
  810.     break;
  811.  case 18:   /* copy T5 and T6 from T3 */
  812.     bit_alloc[5][i] = bit_alloc[6][i] = bit_alloc[3][i];
  813.     break;
  814.  }
  815.       }
  817.    for (i=sblimit; i<SBLIMIT; i++)
  818.       for (j=*l; j<*m; j++)
  819.  bit_alloc[j][i] = 0;
  821.    if (bits_log)
  822.    {
  823.       for (j= *l; j < *m; j++)
  824.          for (i = 0; i < SBLIMIT; i++)
  825.  {
  826.     int alloc_bits = 0, alloc_id = bit_alloc[j][i];
  828.     if (actual_alloc[j][i] > 0)
  829.        alloc_bits = 12 * (*alloc)[i][alloc_id].bits * (*alloc)[i][alloc_id].group;
  831.     printf ("alloc_bi[ %d ][ %2d ]= %3dn", j, i, alloc_bits);
  832.  }
  833.    }
  834. }
  835. #endif
  837. void II_decode_bitalloc_ml(Bit_stream *bs,
  838.    frame_params *fr_ps,
  839.    unsigned int bit_alloc_ml[7][SBLIMIT],
  840.    int *m)
  841. {
  842.    int i,j;
  843.    int sblimit_ml = fr_ps->sblimit_ml;
  844.    al_table *alloc_ml = fr_ps->alloc_ml;
  846.    /* JR: no dynamic crosstalk for multilingual channels */
  847.    /* JR: no phantom center coding for multilingual channels */
  848.    /* JR: no joint coding for multilingual channels */
  849.    /* JR: they're really simple, aren't they? */
  851.    for (i=0;i<sblimit_ml;i++)
  852.     for (j=0;j<*m;j++) 
  853.      bit_alloc_ml[j][i] = (char) getbits (bs, (*alloc_ml)[i][0].bits);
  854.    for (i=sblimit_ml;i<SBLIMIT;i++) 
  855.     for (j=0;j<*m;j++) 
  856.      bit_alloc_ml[j][i] = 0;
  857. }
  859. /*****************************************************************
  860. /*
  861. /* The following two functions implement the layer II
  862. /* format of scale factor extraction. Layer I involves reading
  863. /* 6 bit per subband as scale factor. Layer II requires reading
  864. /* first the scfsi which in turn indicate the number of scale factors
  865. /* transmitted.
  866. /*   Layer II : II_decode_scale
  867. /*
  868. /*************************** Layer II stuff ***************************/
  869. /* 28.9.93 R.S. reading of the prediction coefficients */
  870. /* 03.6.94 R.S. read pred-coef. due to MPEG 2 - DIS    */
  871. /**********************************************************************/
  872. /* JMZ 09/03/1995 Multilingual adaptations , WtK 7/8/95               */
  873. /**********************************************************************/
  875. void I_decode_scale (Bit_stream   *bs,
  876.      frame_params *fr_ps,
  877.      unsigned int bit_alloc[7][SBLIMIT],
  878.      unsigned int scale_index[7][3][SBLIMIT],
  879.      int   part,
  880.      int   scf_log)
  881. {
  882.    int i,j;
  883.    int stereo = fr_ps->stereo;
  884.    int sblimit = fr_ps->sblimit;
  886.    for (i=0; i<SBLIMIT; i++)
  887.       for (j=0;j<stereo;j++)
  888.  if (!bit_alloc[j][i])
  889.     scale_index[j][part][i] = SCALE_RANGE-1;
  890.  else                    /* 6 bit per scale factor */
  891.     scale_index[j][part][i] = getbits (bs, 6);
  892. }
  894. void II_decode_scale (Bit_stream *bs,
  895.       frame_params *fr_ps,
  896.       unsigned int scfsi[7][SBLIMIT], 
  897.       unsigned int bit_alloc[7][SBLIMIT],
  898.       unsigned int scale_index[7][3][SBLIMIT],
  899.       int *l, int *m, int scfsi_log)
  900. {
  901.     layer *info = fr_ps->header;
  902.     int stereo = fr_ps->stereo;
  903.     int i,j;
  904.     int px,pci;
  905.     int sblimit = fr_ps->sblimit;
  907.     if (*m == stereo)
  908. sblimit = fr_ps->sblimit;
  909.     else
  910.      sblimit = fr_ps->sblimit_mc;
  912.     for (i = 0; i < sblimit; i++) 
  913.     {
  914. for (j = *l; j < *m; j++)   /* 2 bit scfsi */
  915.     if (bit_alloc[j][i]) 
  916.   scfsi[j][i] = (char) getbits (bs, 2);
  917.     else
  918. scfsi[j][i] = 4;
  919.     }
  921.     for (i = sblimit; i < SBLIMIT; i++) 
  922. for (j = *l; j < *m; j++)
  923.     scfsi[j][i] = 4;
  925.     if (scfsi_log)
  926.     {
  927. for (j= *l; j < *m; j++)
  928.     for (i = 0; i < SBLIMIT; i++)
  929.     {
  930. int scf_bits;
  931.     
  932. switch (scfsi[j][i])
  933. {
  934.     /* all three scale factors transmitted */
  935.     case 0 : scf_bits = 20;
  936.      break;
  937.     /* two scale factors transmitted */
  938.     case 1 :
  939.     case 3 : scf_bits = 14;
  940.      break;
  941.     /* only one scale factor transmitted */
  942.     case 2 : scf_bits = 8;
  943.      break;
  944.     /* no scale factors transmitted */
  945.     default : scf_bits = 0;
  946. }
  947. printf ("scf_bits[ %d ][ %2d ]= %3dn", j, i, scf_bits);
  948.     }
  949.     }
  951.     /* 3.6.94 R.S. read the prediction coefficients in the mc - part */
  952.     if (*m > stereo && *m < 7)
  953. if (fr_ps->header->mc_prediction_on == 1)
  954.     for (i = 0; i < 8; i++)
  955. if (fr_ps->header->mc_prediction[i] == 1)
  956.     for (px = 0; px < pred_coef_table[fr_ps->pred_mode][fr_ps->header->dyn_cross_mode[i]]; px++)
  957. if (fr_ps->header->mc_predsi[i][px] != 0)
  958. {
  959.     /* predictors are transfered */
  960.     fr_ps->header->mc_delay_comp[i][px] = getbits (bs, 3);
  961.     for (pci = 0; pci < fr_ps->header->mc_predsi[i][px]; pci++)
  962. fr_ps->header->mc_pred_coeff[i][px][pci] = getbits (bs, 8);
  963. }
  964. else
  965. {
  966.     /* no prediction coef. */
  967.     fr_ps->header->mc_pred_coeff[i][px][0] = 127;     /* Index 127 -> 0.0 */
  968.     fr_ps->header->mc_delay_comp[i][px] = 0;
  969. }
  971.     /* 31/10/95 Ralf Schwalbe LFE */
  972.     if (*l == stereo)
  973. if (info->lfe)
  974.     if (info->lfe_alloc)
  975. info->lfe_scf = getbits (bs, 6);
  977.     for (i = 0; i < sblimit; i++) 
  978. for (j = *l; j < *m; j++)
  979.     if (bit_alloc[j][i])
  980. switch (scfsi[j][i])
  981. {
  982.     /* all three scale factors transmitted */
  983.     case 0 : scale_index[j][0][i] = getbits (bs, 6);
  984.      scale_index[j][1][i] = getbits (bs, 6);
  985.      scale_index[j][2][i] = getbits (bs, 6);
  986.      break;
  987.     /* scale factor 1 & 3 transmitted */
  988.     case 1 : scale_index[j][0][i] =
  989.      scale_index[j][1][i] = getbits (bs, 6);
  990.      scale_index[j][2][i] = getbits (bs, 6);
  991.      break;
  992.     /* scale factor 1 & 2 transmitted */
  993.     case 3 : scale_index[j][0][i] = getbits (bs, 6);
  994.      scale_index[j][1][i] =
  995.      scale_index[j][2][i] = getbits (bs, 6);
  996.      break;
  997.     /* only one scale factor transmitted */
  998.     case 2 : scale_index[j][0][i] =
  999.      scale_index[j][1][i] =
  1000.      scale_index[j][2][i] = getbits (bs, 6);
  1001.      break;
  1002.     default : scale_index[j][0][i] =
  1003.       scale_index[j][1][i] =
  1004.       scale_index[j][2][i] = SCALE_RANGE-1;
  1005.       break;
  1006. }
  1007.     else
  1008. scale_index[j][0][i] = scale_index[j][1][i] = scale_index[j][2][i] = SCALE_RANGE-1;
  1010.     for (i = sblimit; i < SBLIMIT; i++)
  1011. for (j = *l; j < *m; j++)
  1012.     scale_index[j][0][i] = scale_index[j][1][i] = scale_index[j][2][i] = SCALE_RANGE-1;
  1013. }
  1015. /**********************************************************************/
  1016. /* JMZ 15/03/1995 Multilingual                                        */
  1017. /**********************************************************************/
  1019. void II_decode_scale_ml(Bit_stream *bs,
  1020.         frame_params *fr_ps,
  1021.         unsigned int scfsi[7][SBLIMIT], 
  1022.         unsigned int bit_alloc[7][SBLIMIT],
  1023.         unsigned int scale_index[7][3][SBLIMIT],
  1024.         int *m)
  1025. {
  1026.    int i,j;
  1027.    int px,pci;
  1028.    int sblimit_ml = fr_ps->sblimit_ml;
  1031.    for (i=0;i<sblimit_ml;i++) for (j=0;j<*m;j++)   /* 2 bit scfsi */
  1032. if (bit_alloc[j][i]) 
  1033. {
  1034.    scfsi[j][i] = (char) getbits (bs, 2);
  1035.    }
  1036. else scfsi[j][i] = 4;
  1037.    for (i=sblimit_ml;i<SBLIMIT;i++) for (j=0;j<*m;j++)
  1038. scfsi[j][i] = 4;
  1040.    for (i = 0; i < sblimit_ml; i++) for (j = 0; j < *m; j++) {
  1041.   if (bit_alloc[j][i])
  1042.     switch (scfsi[j][i]) {
  1043.  /* all three scale factors transmitted */
  1044.  case 0 : scale_index[j][0][i] = getbits (bs, 6);
  1045.   scale_index[j][1][i] = getbits (bs, 6);
  1046.   scale_index[j][2][i] = getbits (bs, 6);
  1047.   break;
  1048.  /* scale factor 1 & 3 transmitted */
  1049.  case 1 : scale_index[j][0][i] =
  1050.   scale_index[j][1][i] = getbits (bs, 6);
  1051.   scale_index[j][2][i] = getbits (bs, 6);
  1052.   break;
  1053.          /* scale factor 1 & 2 transmitted */
  1054.  case 3 : scale_index[j][0][i] = getbits (bs, 6);
  1055.   scale_index[j][1][i] =
  1056.   scale_index[j][2][i] = getbits (bs, 6);
  1057.             break;
  1058.  /* only one scale factor transmitted */
  1059.          case 2 : scale_index[j][0][i] =
  1060.           scale_index[j][1][i] =
  1061.           scale_index[j][2][i] = getbits (bs, 6);
  1062.             break;
  1063.  default : scale_index[j][0][i] =
  1064.            scale_index[j][1][i] =
  1065.            scale_index[j][2][i] = SCALE_RANGE-1;
  1066.              break;
  1067.           }
  1068.           else {
  1069.                           scale_index[j][0][i] = scale_index[j][1][i] =
  1070.                   scale_index[j][2][i] = SCALE_RANGE-1;
  1071.   }
  1072.    }
  1074.    for (i=sblimit_ml;i<SBLIMIT;i++) for (j=0;j<*m;j++) {
  1075.           scale_index[j][0][i] = scale_index[j][1][i] =
  1076.           scale_index[j][2][i] = SCALE_RANGE-1;
  1077.    }
  1078. }
  1080. /**************************************************************
  1081. /*
  1082. /* The following two routines take care of reading the
  1083. /* compressed sample from the bit stream for layer 2.
  1084. /* For layer 1, read the number of bits as indicated
  1085. /* by the bit_alloc information. For layer 2, if grouping is
  1086. /* indicated for a particular subband, then the sample size has
  1087. /* to be read from the bits_group and the merged samples has
  1088. /* to be decompose into the three distinct samples. Otherwise,
  1089. /* it is the same for as layer one.
  1090. /*
  1091. /*************************** Layer II stuff ************************/
  1093. void I_buffer_sample (Bit_stream *bs,
  1094.       frame_params *fr_ps,
  1095.       unsigned int sample[7][3][SBLIMIT],
  1096.       unsigned int bit_alloc[7][SBLIMIT])
  1097. {
  1098.    int i,j,k;
  1099.    int stereo = fr_ps->stereo;
  1100.    int sblimit = fr_ps->sblimit;
  1101.    int jsbound = fr_ps->jsbound;
  1102.    unsigned int s;
  1104.    for (i=0; i<jsbound; i++)
  1105.       for (j=0; j<stereo; j++)
  1106.  if ((k = bit_alloc[j][i]) == 0)
  1107.     sample[j][0][i] = 0;
  1108.  else 
  1109.     sample[j][0][i] = (unsigned int) getbits (bs, k+1);
  1111.    for (i=jsbound; i<SBLIMIT; i++)
  1112.    {
  1113.       if ((k = bit_alloc[0][i]) == 0)
  1114.  s = 0;
  1115.       else 
  1116.  s = (unsigned int) getbits (bs, k+1);
  1118.       for (j=0; j<stereo; j++)
  1119.  sample[j][0][i] = s;
  1120.    }
  1121. }
  1123. void II_buffer_sample (Bit_stream *bs,
  1124.        frame_params *fr_ps,
  1125.        unsigned int sample[7][3][SBLIMIT],
  1126.        unsigned int bit_alloc[7][SBLIMIT])
  1127. {
  1128.    int i,j,k,m;
  1129.    int stereo = fr_ps->stereo;
  1130.    int sblimit = fr_ps->sblimit;
  1131.    int jsbound = fr_ps->jsbound;
  1132.    al_table *alloc = fr_ps->alloc;
  1134.    for (i=0;i<sblimit;i++)
  1135.       for (j= 0;j<((i<jsbound)? stereo:1);j++)
  1136.       {
  1137.    if (bit_alloc[j][i])
  1138.    {
  1139.  /* check for grouping in subband */
  1140.  if ((*alloc)[i][bit_alloc[j][i]].group==3)
  1141.    {
  1142. for (m=0;m<3;m++)
  1143. {
  1144.   k = (*alloc)[i][bit_alloc[j][i]].bits;
  1145.   sample[j][m][i] = (unsigned int) getbits (bs, k);
  1146.  }
  1147.  }
  1148.  else
  1149.  {    /* bit_alloc = 3, 5, 9 */
  1150.    unsigned int nlevels, c=0;
  1152.    nlevels = (*alloc)[i][bit_alloc[j][i]].steps;
  1153.    k=(*alloc)[i][bit_alloc[j][i]].bits;
  1154.    c = (unsigned int) getbits (bs, k);
  1156.    for (k=0;k<3;k++)
  1157.    {
  1158.  sample[j][k][i] = c % nlevels;
  1159.  c /= nlevels;
  1160.    }
  1161.  }
  1162.    }
  1163.    else
  1164.    {      /* for no sample transmitted */
  1165.  for (k=0;k<3;k++) sample[j][k][i] = 0;
  1166.    }
  1167.    if(stereo == 2 && i>= jsbound)  /* joint stereo : copy L to R */
  1168.   for (k=0;k<3;k++) sample[1][k][i] = sample[0][k][i];
  1169.       }
  1170.    for (i = sblimit; i < SBLIMIT; i++)
  1171.  for (j = 0; j < stereo; j++)
  1172. for (k = 0; k < 3; k++)
  1173.    sample[j][k][i] = 0;
  1174. }
  1176. /******************** mc - layer2 stuff ******************************/
  1177. /* 19.10.93 R.S. */
  1179. void II_buffer_sample_mc (Bit_stream *bs,
  1180.   frame_params *fr_ps,
  1181.   unsigned int sample[7][3][SBLIMIT],
  1182.   unsigned int bit_alloc[7][SBLIMIT],
  1183.   int ch_start, int channels, int gr)
  1184. {
  1185.    layer *info = fr_ps->header;
  1186.    int i,j,k,m,sbgr,l;
  1187.    unsigned int nlevels, c=0;
  1188.    int sblimit = fr_ps->sblimit_mc;
  1189.    int transmitted;
  1190.    al_table *alloc = fr_ps->alloc_mc;
  1192.    /* 31/10/95 Ralf Schwalbe LFE */
  1193.    /* 961003 FdB LFE number of bits corrected */
  1194.    if(info->lfe && info->lfe_alloc > 0)
  1195. info->lfe_spl[gr] = (unsigned int) getbits (bs, info->lfe_alloc+1);
  1197.    for (i = 0; i < sblimit; i++)
  1198.    {
  1199.   if( i == 0) sbgr = 0 ;
  1200.   else
  1201.      for(l = 1; l < 12; l++)
  1202. if((sb_groups[l-1] < i) && (i <= sb_groups[l]))
  1203. {
  1204.    sbgr = l; break;
  1205. }
  1207.  for (j = ch_start; j < channels; j++)
  1208.  {
  1209.    if (bit_alloc[j][i])
  1210.    {
  1211.      transmitted = 1;
  1212.      if (fr_ps->header->dyn_cross_on == 1)
  1213.      {
  1214. if (fr_ps->dyn_cross_bits == 4 && (
  1215. (fr_ps->header->dyn_cross_mode[sbgr]==1  && j==4) ||
  1216. (fr_ps->header->dyn_cross_mode[sbgr]==2  && j==3) ||
  1217. (fr_ps->header->dyn_cross_mode[sbgr]==3  && j==2) ||
  1218. (fr_ps->header->dyn_cross_mode[sbgr]==4  && j!=2) ||
  1219. (fr_ps->header->dyn_cross_mode[sbgr]==5  && j!=3) ||
  1220. (fr_ps->header->dyn_cross_mode[sbgr]==6  && j!=4) ||
  1221. (fr_ps->header->dyn_cross_mode[sbgr]==7) ||
  1222. (fr_ps->header->dyn_cross_mode[sbgr]==8  && j==4) ||
  1223. (fr_ps->header->dyn_cross_mode[sbgr]==9  && j==3) ||
  1224. (fr_ps->header->dyn_cross_mode[sbgr]==10 && j==4) ||
  1225. (fr_ps->header->dyn_cross_mode[sbgr]==11 && j!=2) ||
  1226. (fr_ps->header->dyn_cross_mode[sbgr]==12 && j!=2) ||
  1227. (fr_ps->header->dyn_cross_mode[sbgr]==13 && j!=3) ||
  1228. (fr_ps->header->dyn_cross_mode[sbgr]==14 && j!=2)
  1229.           ))
  1230.    transmitted = 0; /* 3/2 */
  1231. if (fr_ps->dyn_cross_bits == 3 && (
  1232. (fr_ps->header->dyn_cross_mode[sbgr]==1  && j==3) ||
  1233. (fr_ps->header->dyn_cross_mode[sbgr]==2  && j==2) ||
  1234. (fr_ps->header->dyn_cross_mode[sbgr]==3) ||
  1235. (fr_ps->header->dyn_cross_mode[sbgr]==4  && j==3)
  1236.   ))
  1237.    transmitted = 0; /* 3/1 and 2/2 */
  1238. if (fr_ps->dyn_cross_bits == 1 && fr_ps->header->dyn_cross_mode[sbgr]==1 && j==2)
  1239.    transmitted = 0; /* 3/0 (+2/0) and 2/1 */
  1240. if (fr_ps->header->surround == 3 && fr_ps->header->dyn_second_stereo[sbgr] == 1)
  1241. {
  1242.    if ((fr_ps->header->center == 1 || fr_ps->header->center == 3) && j == 4)
  1243.               transmitted = 0;
  1244.            else if (fr_ps->header->center == 0 && j == 3)
  1245.               transmitted = 0;
  1246. }
  1247.      }
  1248.    }
  1249.    else
  1250.       transmitted = 0;
  1252.    if (transmitted == 1)
  1253.    {
  1254. /* check for grouping in subband */
  1255. if ((*alloc)[i][bit_alloc[j][i]].group==3)
  1256. {
  1257. for (m=0;m<3;m++)
  1258. {
  1259. k = (*alloc)[i][bit_alloc[j][i]].bits;
  1260. sample[j][m][i] = (unsigned int) getbits (bs, k);
  1261. }
  1262. }
  1263. else
  1264. { /* bit_alloc = 3, 5, 9 */
  1265. nlevels = (*alloc)[i][bit_alloc[j][i]].steps;
  1266. k=(*alloc)[i][bit_alloc[j][i]].bits;
  1267. c = (unsigned int) getbits (bs, k);
  1268. for (k=0;k<3;k++)
  1269. {
  1270. sample[j][k][i] = c % nlevels;
  1271. c /= nlevels;
  1272. }
  1273. }
  1274.    }
  1275.    else   /* no samples transmitted */
  1276.       for (k=0; k<3; k++)
  1277.  sample[j][k][i] = 0;
  1278.  }  /* for channel loop */
  1279.    }  /* for sblimit loop */
  1281.    for (i = sblimit; i < SBLIMIT; i++)
  1282.  for (j = ch_start; j < channels; j++)
  1283. for (k = 0; k < 3; k++)  sample[j][k][i] = 0;
  1284. }
  1286. #ifdef Augmentation_7ch
  1287. void II_buffer_sample_aug(Bit_stream *bs,
  1288. frame_params *fr_ps,
  1289. unsigned int sample[7][3][SBLIMIT],
  1290. unsigned int bit_alloc[7][SBLIMIT],
  1291. int gr)
  1292. {
  1293.    int i,j,k,m,sbgr,l;
  1294.    unsigned int nlevels, c=0;
  1295.    int sblimit = fr_ps->sblimit_mc;
  1296.    int transmitted;
  1297.    al_table *alloc = fr_ps->alloc_mc;
  1299.    for (i = 0; i < sblimit; i++)
  1300.    {
  1301.       if( i == 0) sbgr = 0;
  1302.       else
  1303.  for(l = 1; l < 12; l++)
  1304.     if((sb_groups[l-1] < i) && (i <= sb_groups[l]))
  1305.     {
  1306.        sbgr = l; break;
  1307.     }
  1309.       for (j = 5; j < 7; j++)
  1310.       {
  1311.  if (bit_alloc[j][i])
  1312.  {
  1313.     transmitted = 1;
  1314.     if (fr_ps->header->aug_dyn_cross_on == 1)
  1315.     {
  1316.        if (j == 5)
  1317.        {
  1318.   if (fr_ps->header->dyn_cross_aug_mode[sbgr] > 4)
  1319.      transmitted = 0;
  1320.        }
  1321.        else
  1322.        {
  1323.   transmitted = 0;
  1324.   switch (fr_ps->header->dyn_cross_aug_mode[sbgr])
  1325.   {
  1326.   case  0:
  1327.   case  5:
  1328.   case 10:
  1329.   case 14:
  1330.    transmitted = 1;
  1331.    break;
  1332.   }
  1333.        }
  1334.     }
  1335.  }
  1336.  else
  1337.     transmitted = 0;
  1339.  if (transmitted == 1)
  1340.  {
  1341.       /* check for grouping in subband */
  1342.       if ((*alloc)[i][bit_alloc[j][i]].group==3)
  1343.       {
  1344.       for (m=0;m<3;m++)
  1345.       {
  1346.       k = (*alloc)[i][bit_alloc[j][i]].bits;
  1347.       sample[j][m][i] = (unsigned int) getbits (bs, k);
  1348.       }
  1349.       }
  1350.       else
  1351.       { /* bit_alloc = 3, 5, 9 */
  1352.       nlevels = (*alloc)[i][bit_alloc[j][i]].steps;
  1353.       k=(*alloc)[i][bit_alloc[j][i]].bits;
  1354.       c = (unsigned int) getbits (bs, k);
  1355.       for (k=0;k<3;k++)
  1356.       {
  1357.       sample[j][k][i] = c % nlevels;
  1358.       c /= nlevels;
  1359.       }
  1360.       }
  1361.  }
  1362.  else   /* no samples transmitted */
  1363.     for (k=0; k<3; k++)
  1364.        sample[j][k][i] = 0;
  1365.       }  /* for channel loop */
  1366.    }  /* for sblimit loop */
  1368.    for (i = sblimit; i < SBLIMIT; i++)
  1369.  for (j = 5; j < 7; j++)
  1370. for (k = 0; k < 3; k++)  sample[j][k][i] = 0;
  1371. }
  1372. #endif
  1374. /***************************************************************/
  1375. /* 09/03/1995 JMZ Multilingual */
  1377. /***************************************************************/
  1378. /* 15/03/1995 JMZ */
  1380. void II_buffer_sample_ml(Bit_stream *bs,
  1381.  frame_params *fr_ps,
  1382.  unsigned int sample_ml[7][3][SBLIMIT],
  1383.  unsigned int bit_alloc_ml[7][SBLIMIT],
  1384.  int *n_ml_ch)
  1385. {
  1386.    int i,j,k,m,sbgr,l;
  1387.    unsigned int nlevels, c=0;
  1388.    int sblimit_ml = fr_ps->sblimit_ml;
  1389.    al_table *alloc_ml = fr_ps->alloc_ml;
  1391.    for (i = 0; i < sblimit_ml; i++)
  1392.    {
  1393.  for (j = 0; j < *n_ml_ch; j++)
  1394.  {
  1395.    if (bit_alloc_ml[j][i])
  1396.    {
  1397. /* JR: no dynamic crosstalk for multilingual channels */
  1398. /* check for grouping in subband */
  1399. if ((*alloc_ml)[i][bit_alloc_ml[j][i]].group==3)
  1400. {
  1402. for (m=0;m<3;m++)
  1403. {
  1404. k = (*alloc_ml)[i][bit_alloc_ml[j][i]].bits;
  1405. sample_ml[j][m][i] = (unsigned int) getbits (bs, k);
  1406. }
  1408. }
  1409. else
  1410. {    /* bit_alloc = 3, 5, 9 */
  1411.   nlevels = (*alloc_ml)[i][bit_alloc_ml[j][i]].steps;
  1412.   k=(*alloc_ml)[i][bit_alloc_ml[j][i]].bits;
  1413.   c = (unsigned int) getbits (bs, k);
  1414.   for (k=0;k<3;k++)
  1415.   {
  1416. sample_ml[j][k][i] = c % nlevels;
  1417. c /= nlevels;
  1418.   }
  1419. }
  1420.    }
  1421.    else
  1422.    {      /* for no sample transmitted */
  1423.  for (k=0;k<3;k++) sample_ml[j][k][i] = 0;
  1424.    }
  1425.  }
  1426.    }
  1428.    for (i = sblimit_ml; i < SBLIMIT; i++)
  1429.  for (j = 0; j < *n_ml_ch; j++)
  1430. for (k = 0; k < 3; k++)
  1431.    sample_ml[j][k][i] = 0;
  1432. }
  1434. /**************************************************************
  1435. /*
  1436. /*   Restore the compressed sample to a factional number.
  1437. /*   first complement the MSB of the sample
  1438. /*    for layer I :
  1439. /*    Use s = (s' + 2^(-nb+1) ) * 2^nb / (2^nb-1)
  1440. /*   for Layer II :
  1441. /*   Use the formula s = s' * c + d
  1442. /*
  1443. /**************************************************************/
  1445. static double c[17] = { 1.33333333333, 1.60000000000, 1.14285714286,
  1446. 1.77777777777, 1.06666666666, 1.03225806452,
  1447. 1.01587301587, 1.00787401575, 1.00392156863,
  1448. 1.00195694716, 1.00097751711, 1.00048851979,
  1449. 1.00024420024, 1.00012208522, 1.00006103888,
  1450. 1.00003051851, 1.00001525902 };
  1452. static double d[17] = { 0.500000000, 0.500000000, 0.250000000, 0.500000000,
  1453. 0.125000000, 0.062500000, 0.031250000, 0.015625000,
  1454. 0.007812500, 0.003906250, 0.001953125, 0.0009765625,
  1455. 0.00048828125, 0.00024414063, 0.00012207031,
  1456. 0.00006103516, 0.00003051758 };
  1458. /************************** Layer II stuff ************************/
  1460. void I_dequantize_sample (unsigned int sample[7][3][SBLIMIT],
  1461.   int part,
  1462.   unsigned int bit_alloc[7][SBLIMIT],
  1463.   double fraction[7][SBLIMIT][3][12],
  1464.   frame_params *fr_ps, int *z)
  1465. {
  1466.    int i, nb, k, gr_id, gr_sam;
  1467.    int stereo = fr_ps->stereo;
  1468.    int sblimit = fr_ps->sblimit;
  1470.    gr_id = 4*part + (*z / 3);
  1471.    gr_sam = *z % 3;
  1473.    for (i=0; i<SBLIMIT; i++)
  1474.       for (k=0; k<stereo; k++)
  1475.  if (bit_alloc[k][i])
  1476.  {
  1477.     nb = bit_alloc[k][i] + 1;
  1478.     if (((sample[k][0][i] >> nb-1) & 1) == 1)
  1479.        fraction[k][i][gr_sam][gr_id] = 0.0;
  1480.     else
  1481.        fraction[k][i][gr_sam][gr_id] = -1.0;
  1483.     fraction[k][i][gr_sam][gr_id] += (double) (sample[k][0][i] & ((1<<nb-1)-1)) /
  1484.  (double) (1L<<nb-1);
  1486.     fraction[k][i][gr_sam][gr_id] =
  1487.  (double) (fraction[k][i][gr_sam][gr_id] + 1.0 / (double)(1L<<nb-1)) *
  1488.      (double) (1L<<nb) / (double) ((1L<<nb)-1);
  1489.  }
  1490.  else
  1491.     fraction[k][i][gr_sam][gr_id] = 0.0;
  1492. }
  1493. void II_dequantize_sample (unsigned int sample[7][3][SBLIMIT],
  1494.    unsigned int bit_alloc[7][SBLIMIT],
  1495.    double fraction[7][SBLIMIT][3][12],
  1496.    frame_params *fr_ps, int *z)
  1497. {
  1498.    int i, j, k, x;
  1499.    int stereo = fr_ps->stereo;
  1500.    int sblimit = fr_ps->sblimit;
  1501.    al_table *alloc = fr_ps->alloc;
  1503.    for (i=0;i<sblimit;i++)  for (j=0;j<3;j++) for (k = 0; k < stereo ; k++)
  1504.  if (bit_alloc[k][i])
  1505.  {
  1506.    /* locate MSB in the sample */
  1507.    x = 0;
  1508. #ifndef MSDOS
  1509.    while ((1L<<x) < (*alloc)[i][bit_alloc[k][i]].steps) x++;
  1510. #else
  1511.    /* microsoft C thinks an int is a short */
  1512.    while (( (unsigned long) (1L<<(long)x) <
  1513. (unsigned long)( (*alloc)[i][bit_alloc[k][i]].steps)
  1514.   ) && ( x < 16) ) x++;
  1515. #endif
  1517.    /* MSB inversion */
  1518.    if (((sample[k][j][i] >> (x-1)) & 1) == 1)
  1519.   fraction[k][i][j][*z] = 0.0;
  1520.    else  fraction[k][i][j][*z] = -1.0;
  1522.    /* Form a 2's complement sample */
  1523.    fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
  1524. (double) (1L<<(x-1));
  1526.    /* Dequantize the sample */
  1527.    fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
  1528.    fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
  1529.  }
  1530.  else fraction[k][i][j][*z] = 0.0;
  1532.    for (i=sblimit;i<SBLIMIT;i++)
  1533.   for (j=0;j<3;j++)
  1534.  for(k = 0; k < stereo; k++)
  1535.  fraction[k][i][j][*z] = 0.0;
  1536. }
  1539. /************************** MC Layer II stuff ************************/
  1541. void II_dequantize_sample_mc (unsigned int sample[7][3][SBLIMIT],
  1542.       unsigned int bit_alloc[7][SBLIMIT],
  1543.       double fraction[7][SBLIMIT][3][12],
  1544.       frame_params *fr_ps, int ch_start, int channels, int *z)
  1545. {
  1546.    int i, j, k, x,sbgr,l;
  1547.    int sblimit = fr_ps->sblimit_mc;
  1548.    al_table *alloc = fr_ps->alloc_mc;
  1550.    for (i = 0; i < sblimit; i++)
  1551.    {
  1552. if (i == 0) sbgr = 0;
  1553. else
  1554.    for (l = 1; l < 12; l++)
  1555. if ((sb_groups[l-1] < i) && (i <= sb_groups[l]))
  1556. {
  1557.     sbgr = l; break;
  1558. }
  1560. for (j = 0; j < 3; j++)
  1561.     for (k = ch_start; k < channels; k++)
  1562. if (bit_alloc[k][i])
  1563. {
  1564.     if (fr_ps->header->dyn_cross_on == 0)
  1565.     {
  1566. /* locate MSB in the sample */
  1567. x = 0;
  1568. #ifndef MSDOS
  1569. while ((1L << x) < (*alloc)[i][bit_alloc[k][i]].steps)
  1570.     x++;
  1571. #else
  1572. /* microsoft C thinks an int is a short */
  1573. while (((unsigned long) (1L << (long) x) <
  1574.         (unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)) &&
  1575.        (x < 16))
  1576.     x++;
  1577. #endif
  1578. /* MSB inversion */
  1579. if (((sample[k][j][i] >> (x-1)) & 1) == 1)
  1580.     fraction[k][i][j][*z] = 0.0;
  1581. else 
  1582.     fraction[k][i][j][*z] = -1.0;
  1584. /* Form a 2's complement sample */
  1585. fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
  1586.      (double) (1L<<(x-1));
  1588. /* Dequantize the sample */
  1589. fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
  1590. fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
  1591.     }
  1592.     else   /* 21.07.94 Ralf Schwalbe dyn. cross mode */
  1593.     {
  1594. if (fr_ps->dyn_cross_bits == 4  &&
  1595.     ((fr_ps->header->dyn_cross_mode[sbgr]==0) ||
  1596.      (fr_ps->header->dyn_cross_mode[sbgr]==1  && k!=4) ||
  1597.      (fr_ps->header->dyn_cross_mode[sbgr]==2  && k!=3) ||
  1598.      (fr_ps->header->dyn_cross_mode[sbgr]==3  && k!=2) ||
  1599.      (fr_ps->header->dyn_cross_mode[sbgr]==8  && k!=4) ||
  1600.      (fr_ps->header->dyn_cross_mode[sbgr]==9  && k!=3) ||
  1601.      (fr_ps->header->dyn_cross_mode[sbgr]==10 && k!=4)))
  1602. {
  1603.     x = 0;
  1604. #ifndef MSDOS
  1605.     while ((1L << x) < (*alloc)[i][bit_alloc[k][i]].steps)
  1606. x++;
  1607. #else
  1608.     /* microsoft C thinks an int is a short */
  1609.     while (((unsigned long) (1L << (long) x) <
  1610.     (unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)) &&
  1611.    (x < 16))
  1612. x++;
  1613. #endif
  1614.     /* MSB inversion */
  1615.     if (((sample[k][j][i] >> (x-1)) & 1) == 1)
  1616. fraction[k][i][j][*z] = 0.0;
  1617.     else
  1618. fraction[k][i][j][*z] = -1.0;
  1620.     /* Form a 2's complement sample */
  1621.     fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
  1622.     (double) (1L<<(x-1));
  1624.     /* Dequantize the sample */
  1625.     fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
  1626.     fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
  1627. }  /* end if 2-channel dyn-cross mode */
  1629. if (fr_ps->dyn_cross_bits != 4 ||
  1630.     ((fr_ps->header->dyn_cross_mode[sbgr]==4  && k==2) ||
  1631.      (fr_ps->header->dyn_cross_mode[sbgr]==5  && k==3) ||
  1632.      (fr_ps->header->dyn_cross_mode[sbgr]==6  && k==4) ||
  1633.      (fr_ps->header->dyn_cross_mode[sbgr]==11 && k==2) ||
  1634.      (fr_ps->header->dyn_cross_mode[sbgr]==12 && k==2) ||
  1635.      (fr_ps->header->dyn_cross_mode[sbgr]==13 && k==3) ||
  1636.      (fr_ps->header->dyn_cross_mode[sbgr]==14 && k==2))) 
  1637. {
  1638.      if ((fr_ps->dyn_cross_bits == 3 && ((fr_ps->header->dyn_cross_mode[sbgr] == 1 && k==3) ||
  1639.  (fr_ps->header->dyn_cross_mode[sbgr] == 2 && k==2) ||
  1640.  fr_ps->header->dyn_cross_mode[sbgr] == 3 ||
  1641.  (fr_ps->header->dyn_cross_mode[sbgr] == 4 && k==3)
  1642. )) ||
  1643.  (fr_ps->dyn_cross_bits == 1 && fr_ps->header->dyn_cross_mode[sbgr] == 1 && k == 2) ||
  1644.  (fr_ps->header->surround == 3 && fr_ps->header->dyn_second_stereo[sbgr] == 1 &&
  1645.   ((fr_ps->header->center != 0 && j == 4) || (fr_ps->header->center == 0 && j == 3))))
  1646.      {
  1647.      /* no samples to dequantize */
  1648.      }
  1649.      else
  1650.      {
  1651. x = 0;
  1652. #ifndef MSDOS
  1653. while ((1L << x) < (*alloc)[i][bit_alloc[k][i]].steps)
  1654.     x++;
  1655. #else
  1656. /* microsoft C thinks an int is a short */
  1657. while (((unsigned long) (1L << (long) x) <
  1658. (unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)) &&
  1659.        (x < 16))
  1660.     x++;
  1661. #endif
  1662. /* MSB inversion */
  1663. if (((sample[k][j][i] >> (x-1)) & 1) == 1)
  1664.     fraction[k][i][j][*z] = 0.0;
  1665. else
  1666.     fraction[k][i][j][*z] = -1.0;
  1668. /* Form a 2's complement sample */
  1669. fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
  1670. (double) (1L<<(x-1));
  1672. /* Dequantize the sample */
  1673. fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
  1674. fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
  1675.     } /* end if ..bits */
  1676. }   /* end if 1-channel dyn-cross mode */
  1677.     } /* end if dyn-cross on */
  1678. } /* if bit_alloc */
  1679.    else
  1680.     fraction[k][i][j][*z] = 0.0;
  1681.     }
  1682.     for (i = sblimit; i < SBLIMIT; i++)
  1683. for (j = 0; j < 3; j++)
  1684.     for (k = ch_start; k < channels; k++)
  1685. fraction[k][i][j][*z] = 0.0;
  1686. }
  1688. #ifdef Augmentation_7ch
  1689. void II_dequantize_sample_aug (unsigned int sample[7][3][SBLIMIT],
  1690.        unsigned int bit_alloc[7][SBLIMIT],
  1691.        double fraction[7][SBLIMIT][3][12],
  1692.        frame_params *fr_ps, int *z)
  1693. {
  1694.    int i, j, k, x,sbgr,l;
  1695.    int sblimit = fr_ps->sblimit_mc;
  1696.    al_table *alloc = fr_ps->alloc_mc;
  1698.    for (i = 0; i < sblimit; i++)
  1699.    {
  1700. if( i == 0) sbgr = 0 ;
  1701. else
  1702.    for(l = 1; l < 12; l++)
  1703. if((sb_groups[l-1] < i) && (i <= sb_groups[l]))
  1704. {
  1705.     sbgr = l; break;
  1706. }
  1707. for (j = 0; j < 3; j++)
  1708.    for ( k = 5; k < 7; k++)
  1709. if (bit_alloc[k][i])
  1710. {
  1711.    if ((fr_ps->header->dyn_cross_aug_mode[sbgr]== 0) ||
  1712.        (fr_ps->header->dyn_cross_aug_mode[sbgr]== 1 && k==5) ||
  1713.        (fr_ps->header->dyn_cross_aug_mode[sbgr]== 2 && k==5) ||
  1714.        (fr_ps->header->dyn_cross_aug_mode[sbgr]== 3 && k==5) ||
  1715.        (fr_ps->header->dyn_cross_aug_mode[sbgr]== 4 && k==5) ||
  1716.        (fr_ps->header->dyn_cross_aug_mode[sbgr]== 5 && k==6) ||
  1717.        (fr_ps->header->dyn_cross_aug_mode[sbgr]==10 && k==6) ||
  1718.        (fr_ps->header->dyn_cross_aug_mode[sbgr]==14 && k==6))
  1719.    {
  1720. x = 0;
  1721. #ifndef MSDOS
  1722. while ((1L<<x) < (*alloc)[i][bit_alloc[k][i]].steps) x++;
  1723. #else
  1724. /* microsoft C thinks an int is a short */
  1725. while (( (unsigned long) (1L<<(long)x) <
  1726. (unsigned long)( (*alloc)[i][bit_alloc[k][i]].steps)) && ( x < 16) ) x++;
  1727. #endif
  1728. /* MSB inversion */
  1729. if (((sample[k][j][i] >> (x-1)) & 1) == 1)
  1730.       fraction[k][i][j][*z] = 0.0;
  1731. else  fraction[k][i][j][*z] = -1.0;
  1733. /* Form a 2's complement sample */
  1734. fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
  1735. (double) (1L<<(x-1));
  1737. /* Dequantize the sample */
  1738. fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
  1739. fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
  1740.    }  /* end if 2-channel dyn-cross mode */
  1741. } /* if bit_alloc */
  1742. else
  1743.    fraction[k][i][j][*z] = 0.0;
  1744.    }
  1745.    for (i = sblimit; i < SBLIMIT; i++)
  1746.   for (j = 0; j < 3; j++)
  1747.  for(k = 5; k < 7; k++)
  1748.  fraction[k][i][j][*z] = 0.0;
  1749. }
  1750. #endif
  1752. /*************************************************************************/
  1753. /* JMZ 09/03/1995 Multilingual */
  1755. void II_dequantize_sample_ml(unsigned int sample_ml[7][3][SBLIMIT],
  1756.      unsigned int bit_alloc_ml[7][SBLIMIT],
  1757.      double fraction_ml[7][SBLIMIT][3][12],
  1758.      frame_params *fr_ps,
  1759.      int *n_ml_ch,
  1760.      int *z)
  1761. {
  1762.    int i, j, k, x,sbgr,l;
  1763.    int sblimit_ml = fr_ps->sblimit_ml;
  1764.    al_table *alloc_ml = fr_ps->alloc_ml;
  1766.    for (i = 0; i < sblimit_ml; i++)
  1767.    {
  1768.   for (j = 0; j < 3; j++)
  1769.  for ( k = 0; k < *n_ml_ch; k++)
  1770. if (bit_alloc_ml[k][i])
  1771. {
  1772.   /* JR: ditto */
  1773.   /* locate MSB in the sample */
  1774.    x = 0;
  1775. #ifndef MSDOS
  1776.    while ((1L<<x) < (*alloc_ml)[i][bit_alloc_ml[k][i]].steps) x++;
  1777. #else
  1778.    /* microsoft C thinks an int is a short */
  1779.    while (( (unsigned long) (1L<<(long)x) <
  1780. (unsigned long)( (*alloc_ml)[i][bit_alloc_ml[k][i]].steps)
  1781.    ) && ( x < 16) ) x++;
  1782. #endif
  1783.    /* MSB inversion */
  1784.    if (((sample_ml[k][j][i] >> (x-1)) & 1) == 1)
  1785. fraction_ml[k][i][j][*z] = 0.0;
  1786.    else  fraction_ml[k][i][j][*z] = -1.0;
  1788.    /* Form a 2's complement sample */
  1789.    fraction_ml[k][i][j][*z] += (double) (sample_ml[k][j][i] & ((1<<(x-1))-1)) /
  1790. (double) (1L<<(x-1));
  1792.    /* Dequantize the sample */
  1793.    fraction_ml[k][i][j][*z] += d[(*alloc_ml)[i][bit_alloc_ml[k][i]].quant];
  1794.    fraction_ml[k][i][j][*z] *= c[(*alloc_ml)[i][bit_alloc_ml[k][i]].quant];
  1795. } /* if bit_alloc */
  1796. else fraction_ml[k][i][j][*z] = 0.0;
  1797.    }
  1798.    for (i = sblimit_ml; i < SBLIMIT; i++)
  1799.   for (j = 0; j < 3; j++)
  1800.  for(k = 0; k < *n_ml_ch; k++)
  1801.  fraction_ml[k][i][j][*z] = 0.0;
  1802. }
  1804. /**************************************************************************
  1805. II_lfe_calc();  R.Schwalbe 
  1806. **************************************************************************/
  1807. void II_lfe_calc(frame_params *fr_ps)
  1808. {
  1809.    layer *info = fr_ps->header;
  1810.    int x,i;
  1811.    al_table *alloc = fr_ps->alloc_mc;
  1813.    for(i = 0; i < 12; i++)
  1814.    {
  1815. x = 0;
  1816. #ifndef MSDOS
  1817.     while ((1L<<x) < (*alloc)[0][info->lfe_alloc].steps) x++;
  1818. #else
  1819.     /* microsoft C thinks an int is a short */
  1820.     while (( (unsigned long) (1L<<(long)x) <
  1821.     (unsigned long)( (*alloc)[0][info->lfe_alloc].steps)) && ( x < 16) ) x++;
  1822. #endif
  1823.     /* MSB inversion */
  1824.     if (((info->lfe_spl[i] >> (x-1)) & 1) == 1)
  1825.       info->lfe_spl_fraction[i] = 0.0;
  1826.     else  info->lfe_spl_fraction[i] = -1.0;
  1828.     /* Form a 2's complement sample */
  1829.     info->lfe_spl_fraction[i] += (double) (info->lfe_spl[i] & ((1<<(x-1))-1)) /
  1830.   (double) (1L<<(x-1));
  1832.     /* Dequantize the sample */
  1833.     info->lfe_spl_fraction[i] += d[(*alloc)[0][info->lfe_alloc].quant];
  1834.     info->lfe_spl_fraction[i] *= c[(*alloc)[0][info->lfe_alloc].quant];
  1836.     /* Denormalize the sample */
  1837.     info->lfe_spl_fraction[i] *= multiple[info->lfe_scf];
  1838.     }
  1839. }
  1841. /************************************************************
  1842. /*
  1843. /*   Restore the original value of the sample ie multiply
  1844. /*    the fraction value by its scalefactor.
  1845. /*
  1846. /************************* Layer II Stuff **********************/
  1848. void I_denormalize_sample (double fraction[7][SBLIMIT][3][12],
  1849.    unsigned int scale_index[7][3][SBLIMIT],
  1850.    int part,
  1851.    frame_params *fr_ps,
  1852.    int *z)
  1853. {
  1854.    int i, j, k, gr_id, gr_sam;
  1855.    int stereo = fr_ps->stereo;
  1856.    int sblimit = fr_ps->sblimit;
  1858.    gr_id = 4*part + (*z / 3);
  1859.    gr_sam = *z % 3;
  1861.    for (i=0; i<SBLIMIT; i++)
  1862.       for (j=0; j<stereo; j++)
  1863.  fraction[j][i][gr_sam][gr_id] *= multiple[scale_index[j][part][i]];
  1864. }
  1866. void II_denormalize_sample(double fraction[7][SBLIMIT][3][12],
  1867.    unsigned int scale_index[7][3][SBLIMIT],
  1868.    frame_params *fr_ps,
  1869.    int x,
  1870.    int *z)
  1871. {
  1872.    int i,j,k;
  1873.    int stereo = fr_ps->stereo;
  1874.    int sblimit = fr_ps->sblimit;
  1876.    for (i=0;i<sblimit;i++)
  1877. for (j = 0;j < stereo; j++)
  1878. {
  1879.   fraction[j][i][0][*z] *= multiple[scale_index[j][x][i]];
  1880.   fraction[j][i][1][*z] *= multiple[scale_index[j][x][i]];
  1881.   fraction[j][i][2][*z] *= multiple[scale_index[j][x][i]];
  1882. }
  1883. }
  1885. /************************* MC Layer II Stuff **********************/
  1887. void II_denormalize_sample_mc(double fraction[7][SBLIMIT][3][12],
  1888.      unsigned int scale_index[7][3][SBLIMIT],
  1889.      frame_params *fr_ps,
  1890.      int x, int ch_start, int channels, int *z)
  1891. {
  1892.    int i,j,k,sbgr,l,bl=0;
  1893.    int sblimit = fr_ps->sblimit_mc;
  1895.    for (i = 0; i < sblimit; i++)
  1896.    {
  1897.       if (i == 0) sbgr = 0 ;
  1898.       else
  1899. for (l = 1; l < 12; l++)
  1900. if ((sb_groups[l-1] < i) && (i <= sb_groups[l]))
  1901. {
  1902. sbgr = l; break;
  1903. }
  1905.       /* 960821 FdB new setup for dyn. crosstalk modes */
  1906.       for (bl = 0; bl < 3; bl++)   
  1907. if (fr_ps->header->dyn_cross_on == 0)
  1908. for (j = ch_start; j < channels; j++)
  1909. fraction[j][i][bl][*z] *= multiple[scale_index[j][x][i]];
  1910. else if (fr_ps->dyn_cross_bits == 0)   /* for channel mode 2/0 (+2/0) */
  1911. {
  1912. if (fr_ps->header->surround == 3) /* 2/0 + 2/0 and 1/0 + 2/0 */
  1913. {
  1914. fraction[ch_start][i][bl][*z] *= multiple[scale_index[ch_start][x][i]];
  1915. if (fr_ps->header->dyn_second_stereo[sbgr] == 0)
  1916. fraction[ch_start+1][i][bl][*z] *= multiple[scale_index[ch_start+1][x][i]];
  1917. else
  1918. fraction[ch_start+1][i][bl][*z] = (fraction[ch_start][i][bl][*z] / multiple[scale_index[ch_start][x][i]])
  1919.  * multiple[scale_index[ch_start+1][x][i]];
  1920. }
  1921. }
  1922. else if (fr_ps->dyn_cross_bits == 1)   /* for channel mode 3/0 (+2/0) and 2/1 */
  1923. {
  1924. switch (fr_ps->header->dyn_cross_mode[sbgr])
  1925. {
  1926.   case 0 : fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  1927. if (fr_ps->header->surround == 3) /* 3/0 + 2/0 */
  1928. {
  1929. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  1930. if (fr_ps->header->dyn_second_stereo[sbgr] == 0)
  1931. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  1932. else
  1933. fraction[4][i][bl][*z] = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  1934.  * multiple[scale_index[4][x][i]];
  1935. }
  1936.    break;
  1937.   case 1 : if (fr_ps->header->tc_alloc[sbgr] == 0)
  1938. if (fr_ps->header->dyn_cross_LR) /* C,S from R0 */ 
  1939. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  1940.    * multiple[scale_index[2][x][i]];
  1941.      else /* C,S from L0 */
  1942. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  1943.  * multiple[scale_index[2][x][i]];
  1944. if (fr_ps->header->tc_alloc[sbgr] == 1)
  1945. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  1946.  * multiple[scale_index[2][x][i]];
  1947. if (fr_ps->header->tc_alloc[sbgr] == 2)
  1948. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  1949.  * multiple[scale_index[2][x][i]];
  1950. if (fr_ps->header->surround == 3) /* 3/0 + 2/0 */
  1951. {
  1952. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  1953. if (fr_ps->header->dyn_second_stereo[sbgr] == 0)
  1954. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  1955. else
  1956. fraction[4][i][bl][*z] = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  1957.  * multiple[scale_index[4][x][i]];
  1958. }
  1959.    break;
  1960. }
  1961. }
  1962. else if (fr_ps->dyn_cross_bits == 3)   /* for channel mode 3/1 and 2/2 */
  1963. {
  1964. switch (fr_ps->header->dyn_cross_mode[sbgr])
  1965. {
  1966.   case 0 : for (j = ch_start; j < channels; j++)
  1967. fraction[j][i][bl][*z] *= multiple[scale_index[j][x][i]];
  1968.    break;
  1969.   case 1 : fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  1970. if (fr_ps->header->surround == 2 || /* 2/2 mode */
  1971.     fr_ps->header->tc_alloc[sbgr] == 4 || /* 3/1 mode */
  1972.     fr_ps->header->tc_alloc[sbgr] == 5 || /* 3/1 mode, matrix mode 2 */
  1973.     (fr_ps->header->tc_alloc[sbgr] != 3 && fr_ps->header->dyn_cross_LR))
  1974. /* S, R or Rs from R0 */
  1975. fraction[3][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  1976.   * multiple[scale_index[3][x][i]];
  1977. else
  1978. /* S, L or Ls from L0 */
  1979. fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  1980.   * multiple[scale_index[3][x][i]];
  1981.    break;
  1982.   case 2 : fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  1983. if (fr_ps->header->surround == 2 || /* 2/2 mode */
  1984.     fr_ps->header->tc_alloc[sbgr] == 1 || /* 3/1 mode */
  1985.     fr_ps->header->tc_alloc[sbgr] == 5 || /* 3/1 mode, matrix mode 2 */
  1986.     (fr_ps->header->tc_alloc[sbgr] != 2 && !fr_ps->header->dyn_cross_LR))
  1987. /* C, L or Ls from L0 */
  1988. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  1989.  * multiple[scale_index[2][x][i]];
  1990. else
  1991. /* C, R or Rs from RO */
  1992. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  1993.  * multiple[scale_index[2][x][i]];
  1994.    break;
  1995.   case 3 : if (fr_ps->header->surround == 2 || /* 2/2 mode */
  1996.     fr_ps->header->tc_alloc[sbgr] == 1 || /* 3/1 mode */
  1997.     fr_ps->header->tc_alloc[sbgr] == 5 || /* 3/1 mode, matrix mode 2 */
  1998.     (fr_ps->header->tc_alloc[sbgr] != 2 && !fr_ps->header->dyn_cross_LR))
  1999. /* C, L or Ls from L0 */
  2000. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2001.  * multiple[scale_index[2][x][i]];
  2002. else
  2003. /* C, R or Rs from RO */
  2004. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2005.  * multiple[scale_index[2][x][i]];
  2006. if (fr_ps->header->surround == 2 || /* 2/2 mode */
  2007.     fr_ps->header->tc_alloc[sbgr] == 4 || /* 3/1 mode */
  2008.     fr_ps->header->tc_alloc[sbgr] == 5 || /* 3/1 mode, matrix mode 2 */
  2009.     (fr_ps->header->tc_alloc[sbgr] != 3 && fr_ps->header->dyn_cross_LR))
  2010. /* S, R or Rs from R0 */
  2011. fraction[3][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2012.   * multiple[scale_index[3][x][i]];
  2013. else
  2014. /* S, L or Ls from L0 */
  2015. fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2016.   * multiple[scale_index[3][x][i]];
  2017.    break;
  2018.   case 4 : fraction[3][i][bl][*z] = fraction[2][i][bl][*z];
  2019. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2020. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2021.    break;
  2022. }
  2023. }
  2024. else if (fr_ps->dyn_cross_bits == 4)   /* for channel mode 3/2 */
  2025. {
  2026. switch (fr_ps->header->dyn_cross_mode[sbgr])
  2027. {
  2028.   case 0 : for (j = ch_start; j < channels; j++)
  2029. fraction[j][i][bl][*z] *= multiple[scale_index[j][x][i]];
  2030.    break;
  2031.   case 1 : /* C from T2 */
  2032. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2033. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2034. fraction[4][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2035.   * multiple[scale_index[4][x][i]];
  2036.    break;
  2037.   case 2 : /* C from T2 */
  2038. fraction[2][i][bl][*z] = fraction[2][i][bl][*z] * multiple[scale_index[2][x][i]];
  2039. fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2040.   * multiple[scale_index[3][x][i]];
  2041. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2042.    break;
  2043.   case 3 : if ((fr_ps->header->tc_alloc[sbgr] == 1) || (fr_ps->header->tc_alloc[sbgr] == 7))
  2044. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2045.  * multiple[scale_index[2][x][i]];
  2046. else if ((fr_ps->header->tc_alloc[sbgr] == 2) || (fr_ps->header->tc_alloc[sbgr] == 6))
  2047. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2048.  * multiple[scale_index[2][x][i]];
  2049. else if (fr_ps->header->dyn_cross_LR) /* C from RO */
  2050. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2051.  * multiple[scale_index[2][x][i]];
  2052. else /* C from LO */
  2053. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2054.  * multiple[scale_index[2][x][i]];
  2056. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]]; 
  2057. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2058.    break;
  2059.   case 4 : /* C from T2 */
  2060. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2061. fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2062.   * multiple[scale_index[3][x][i]];
  2063. fraction[4][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2064.   * multiple[scale_index[4][x][i]];
  2065.    break;
  2066.   case 5 : if ((fr_ps->header->tc_alloc[sbgr] == 1) || (fr_ps->header->tc_alloc[sbgr] == 7))
  2067. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2068.  * multiple[scale_index[2][x][i]];
  2069. else if ((fr_ps->header->tc_alloc[sbgr] == 2) || (fr_ps->header->tc_alloc[sbgr] == 6))
  2070. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2071.  * multiple[scale_index[2][x][i]];
  2072. else if (fr_ps->header->dyn_cross_LR)  /* C from RO */
  2073. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2074.  * multiple[scale_index[2][x][i]];
  2075. else /* C from LO */
  2076. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2077.  * multiple[scale_index[2][x][i]];
  2079. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2080. fraction[4][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2081.   * multiple[scale_index[4][x][i]];
  2082.    break;
  2083.   case 6 : if ((fr_ps->header->tc_alloc[sbgr] == 1) || (fr_ps->header->tc_alloc[sbgr] == 7))
  2084. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2085.  * multiple[scale_index[2][x][i]];
  2086. else if ((fr_ps->header->tc_alloc[sbgr] == 2) || (fr_ps->header->tc_alloc[sbgr] == 6))
  2087. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2088.  * multiple[scale_index[2][x][i]];
  2089. else if (fr_ps->header->dyn_cross_LR) /* C from RO */
  2090. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2091.  * multiple[scale_index[2][x][i]];
  2092. else /* C from LO */
  2093. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2094.  * multiple[scale_index[2][x][i]];
  2096. fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2097.   * multiple[scale_index[3][x][i]];
  2098. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2099.    break;
  2100.   case 7 : if ((fr_ps->header->tc_alloc[sbgr] == 1) || (fr_ps->header->tc_alloc[sbgr] == 7))
  2101. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2102.  * multiple[scale_index[2][x][i]];
  2103. else if ((fr_ps->header->tc_alloc[sbgr] == 2) || (fr_ps->header->tc_alloc[sbgr] == 6))
  2104. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2105.  * multiple[scale_index[2][x][i]];
  2106. else if (fr_ps->header->dyn_cross_LR) /* C from RO */
  2107. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2108.  * multiple[scale_index[2][x][i]];
  2109. else /* C from LO */
  2110. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2111.  * multiple[scale_index[2][x][i]];
  2112. fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2113.   * multiple[scale_index[3][x][i]];
  2114. fraction[4][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2115.   * multiple[scale_index[4][x][i]];
  2116.    break;
  2117.   case 8 : /* C from T2 */
  2118. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2119. fraction[4][i][bl][*z]  = fraction[3][i][bl][*z];
  2120. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2121. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2122.    break;
  2123.   case 9 : /* C from T2 */
  2124. fraction[3][i][bl][*z] = fraction[2][i][bl][*z];
  2125. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2126. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2127. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2128.    break;
  2129.   case 10 : /* C from T2 */
  2130. fraction[4][i][bl][*z]  = fraction[2][i][bl][*z];
  2131. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2132. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2133. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2134.    break;
  2135.   case 11 : fraction[3][i][bl][*z]  = fraction[2][i][bl][*z];
  2136. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2137. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2138. fraction[4][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2139.   * multiple[scale_index[4][x][i]];
  2140.    break;
  2141.   case 12 : fraction[4][i][bl][*z]  = fraction[2][i][bl][*z];
  2142. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2143. fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2144.   * multiple[scale_index[3][x][i]];
  2145. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2146.    break;
  2147.   case 13: if ((fr_ps->header->tc_alloc[sbgr] == 1) || (fr_ps->header->tc_alloc[sbgr] == 7))
  2148. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2149.  * multiple[scale_index[2][x][i]];
  2150. else if ((fr_ps->header->tc_alloc[sbgr] == 2) || (fr_ps->header->tc_alloc[sbgr] == 6))
  2151. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2152.  * multiple[scale_index[2][x][i]];
  2153. else if (fr_ps->header->dyn_cross_LR) /* C from RO */
  2154. fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
  2155.  * multiple[scale_index[2][x][i]];
  2156. else /* C from LO */
  2157. fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
  2158.  * multiple[scale_index[2][x][i]];
  2159. fraction[4][i][bl][*z]  = fraction[3][i][bl][*z];
  2160. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2161. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2162.    break;
  2163.   case 14 : fraction[4][i][bl][*z]  = fraction[2][i][bl][*z];
  2164. fraction[3][i][bl][*z]  = fraction[2][i][bl][*z];
  2165. /* C from T2 */
  2166. fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
  2167. fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
  2168. fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
  2169. break;
  2170. }
  2171. }
  2172.    } /* for sblimit */
  2173. }
  2175. #ifdef Augmentation_7ch
  2176. void II_denormalize_sample_aug(double fraction[7][SBLIMIT][3][12],
  2177.      unsigned int scale_index[7][3][SBLIMIT],
  2178.      frame_params *fr_ps,
  2179.      int x,
  2180.      int *z)
  2181. {
  2182.    layer *info = fr_ps->header;
  2183.    int i,j,k,sbgr,l,bl=0;
  2184.    int sblimit = fr_ps->sblimit_mc;
  2185.     
  2186.    for (i = 0; i < sblimit; i++)
  2187.    {
  2188.       int T5T0 = 0, T6T0 = 0, T6T1 = 1;
  2190.       if (i == 0) sbgr = 0 ;
  2191.       else
  2192.  for (l = 1; l < 12; l++)
  2193.     if ((sb_groups[l-1] < i) && (i <= sb_groups[l]))
  2194.     {
  2195.        sbgr = l; break;
  2196.     }
  2198.       if (info->tc_aug_alloc[sbgr] == 4 || info->tc_aug_alloc[sbgr] == 5)
  2199.      if (info->dyn_cross_LR == 0)
  2200.   T6T1 = 0;
  2201. else
  2202.   T6T0 = 1;
  2203.       else if (info->tc_aug_alloc[sbgr] == 6 || info->tc_aug_alloc[sbgr] == 7)
  2204.         if (info->dyn_cross_LR)
  2205.   T5T0 = 1;
  2208.       /* 960821 FdB new setup for dyn. crosstalk modes */
  2209.       for (bl = 0; bl < 3; bl++)
  2210.       {
  2211.  switch (fr_ps->header->dyn_cross_aug_mode[sbgr])
  2212.  {
  2213.    case  0 : /* T5 and T6 present */
  2214.  for (j = 5; j < 7; j++)
  2215.     fraction[j][i][bl][*z] *= multiple[scale_index[j][x][i]];
  2216.  break;
  2217.    case  1 : /* T6 from T1 */
  2218.  fraction[5][i][bl][*z] *= multiple[scale_index[5][x][i]];
  2219.  fraction[6][i][bl][*z]  = (fraction[T6T1][i][bl][*z] / multiple[scale_index[T6T1][x][i]])
  2220.       * multiple[scale_index[6][x][i]];
  2221.  break;
  2222.    case  2 : /* T6 from T2 */
  2223.  fraction[5][i][bl][*z] *= multiple[scale_index[5][x][i]];
  2224.  fraction[6][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2225.    * multiple[scale_index[6][x][i]];
  2226.  break;
  2227.    case  3 : /* T6 from T4 */
  2228.  fraction[5][i][bl][*z] *= multiple[scale_index[5][x][i]];
  2229.  fraction[6][i][bl][*z]  = (fraction[4][i][bl][*z] / multiple[scale_index[4][x][i]])
  2230.    * multiple[scale_index[6][x][i]];
  2231.  break;
  2232.    case  4 : /* T6 from T5 */
  2233.  fraction[5][i][bl][*z] *= multiple[scale_index[5][x][i]];
  2234.  fraction[6][i][bl][*z]  = (fraction[5][i][bl][*z] / multiple[scale_index[5][x][i]])
  2235.    * multiple[scale_index[6][x][i]];
  2236.  break;
  2237.    case  5 : /* T5 from T0 */
  2238.  fraction[5][i][bl][*z]  = (fraction[T5T0][i][bl][*z] / multiple[scale_index[T5T0][x][i]])
  2239.       * multiple[scale_index[5][x][i]];
  2240.  fraction[6][i][bl][*z] *= multiple[scale_index[6][x][i]];
  2241.  break;
  2242.    case  6 : /* T5 from T0 and T6 from T1 */
  2243.  fraction[5][i][bl][*z]  = (fraction[T5T0][i][bl][*z] / multiple[scale_index[T5T0][x][i]])
  2244.       * multiple[scale_index[5][x][i]];
  2245.  fraction[6][i][bl][*z]  = (fraction[T6T1][i][bl][*z] / multiple[scale_index[T6T1][x][i]])
  2246.       * multiple[scale_index[6][x][i]];
  2247.  break;
  2248.    case  7 : /* T5 from T0 and T6 from T2 */
  2249.  fraction[5][i][bl][*z]  = (fraction[T5T0][i][bl][*z] / multiple[scale_index[T5T0][x][i]])
  2250.       * multiple[scale_index[5][x][i]];
  2251.  fraction[6][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2252.    * multiple[scale_index[6][x][i]];
  2253.  break;
  2254.    case  8 : /* T5 from T0 and T6 from T4 */
  2255.  fraction[5][i][bl][*z]  = (fraction[T5T0][i][bl][*z] / multiple[scale_index[T5T0][x][i]])
  2256.       * multiple[scale_index[5][x][i]];
  2257.  fraction[6][i][bl][*z]  = (fraction[4][i][bl][*z] / multiple[scale_index[4][x][i]])
  2258.    * multiple[scale_index[6][x][i]];
  2259.  break;
  2260.    case  9 : /* T5 and T6 from T0 */
  2261.  fraction[5][i][bl][*z]  = (fraction[T5T0][i][bl][*z] / multiple[scale_index[T5T0][x][i]])
  2262.       * multiple[scale_index[5][x][i]];
  2263.  fraction[6][i][bl][*z]  = (fraction[T6T0][i][bl][*z] / multiple[scale_index[T6T0][x][i]])
  2264.       * multiple[scale_index[6][x][i]];
  2265.  break;
  2266.    case 10 : /* T5 from T2 */
  2267.  fraction[5][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2268.    * multiple[scale_index[5][x][i]];
  2269.  fraction[6][i][bl][*z] *= multiple[scale_index[6][x][i]];
  2270.  break;
  2271.    case 11 : /* T5 from T2 and T6 from T1 */
  2272.  fraction[5][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2273.    * multiple[scale_index[5][x][i]];
  2274.  fraction[6][i][bl][*z]  = (fraction[T6T1][i][bl][*z] / multiple[scale_index[T6T1][x][i]])
  2275.    * multiple[scale_index[6][x][i]];
  2276.  break;
  2277.    case 12 : /* T5 and T6 from T2 */
  2278.  fraction[5][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2279.    * multiple[scale_index[5][x][i]];
  2280.  fraction[6][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2281.    * multiple[scale_index[6][x][i]];
  2282.  break;
  2283.    case 13 : /* T5 from T2 and T6 from T4 */
  2284.  fraction[5][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2285.    * multiple[scale_index[5][x][i]];
  2286.  fraction[6][i][bl][*z]  = (fraction[4][i][bl][*z] / multiple[scale_index[4][x][i]])
  2287.    * multiple[scale_index[6][x][i]];
  2288.  break;
  2289.    case 14 : /* T5 from T3 */
  2290.  fraction[5][i][bl][*z]  = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  2291.    * multiple[scale_index[5][x][i]];
  2292.  fraction[6][i][bl][*z] *= multiple[scale_index[6][x][i]];
  2293.  break;
  2294.    case 15 : /* T5 from T3 and T6 from T1 */
  2295.  fraction[5][i][bl][*z]  = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  2296.    * multiple[scale_index[5][x][i]];
  2297.  fraction[6][i][bl][*z]  = (fraction[T6T1][i][bl][*z] / multiple[scale_index[T6T1][x][i]])
  2298.       * multiple[scale_index[6][x][i]];
  2299.  break;
  2300.    case 16 : /* T5 from T3 and T6 from T2 */
  2301.  fraction[5][i][bl][*z]  = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  2302.    * multiple[scale_index[5][x][i]];
  2303.  fraction[6][i][bl][*z]  = (fraction[2][i][bl][*z] / multiple[scale_index[2][x][i]])
  2304.    * multiple[scale_index[6][x][i]];
  2305.  break;
  2306.    case 17 : /* T5 from T3 and T6 from T4 */
  2307.  fraction[5][i][bl][*z]  = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  2308.    * multiple[scale_index[5][x][i]];
  2309.  fraction[6][i][bl][*z]  = (fraction[4][i][bl][*z] / multiple[scale_index[4][x][i]])
  2310.    * multiple[scale_index[6][x][i]];
  2311.  break;
  2312.    case 18 : /* T5 and T6 from T3 */
  2313.  fraction[5][i][bl][*z]  = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  2314.    * multiple[scale_index[5][x][i]];
  2315.  fraction[6][i][bl][*z]  = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
  2316.    * multiple[scale_index[6][x][i]];
  2317.  break;
  2318.  }
  2319.       }   
  2320.    } /* for sblimit */
  2321. }
  2322. #endif
  2324. /*************************************************************/
  2325. /* JMZ 09/03/1995 Multilingual */
  2327. void II_denormalize_sample_ml(double fraction_ml[7][SBLIMIT][3][12],
  2328.       unsigned int scale_index_ml[7][3][SBLIMIT],
  2329.       frame_params *fr_ps,
  2330.       int x,
  2331.       int *n_ml_ch,
  2332.       int *z)
  2333. {
  2334.    int i,j;
  2335.    int sblimit_ml = fr_ps->sblimit_ml;
  2337.    for (i = 0; i < sblimit_ml; i++)
  2338.     for (j = 0; j < *n_ml_ch; j++)
  2339.      {
  2340.        fraction_ml[j][i][0][*z] *= multiple[scale_index_ml[j][x][i]];
  2341.        fraction_ml[j][i][1][*z] *= multiple[scale_index_ml[j][x][i]];
  2342.        fraction_ml[j][i][2][*z] *= multiple[scale_index_ml[j][x][i]];
  2343.      }
  2344. }
  2346. /*****************************************************************
  2347. /*
  2348. /* The following are the subband synthesis routines. They apply
  2349. /* to both layer I and layer II stereo or mono. The user has to
  2350. /* decide what parameters are to be passed to the routines.
  2351. /*
  2352. /***************************************************************/
  2354. /*************************************************************
  2355. /*
  2356. /*   Pass the subband sample through the synthesis window
  2357. /*
  2358. /**************************************************************/
  2360. /* create in synthesis filter */
  2362. static void create_syn_filter(double filter[64][SBLIMIT])
  2363. {
  2364.    register int i,k;
  2366.    for (i=0; i<64; i++)
  2367.       for (k=0; k<32; k++) {
  2368.  if ((filter[i][k] = 1e9*cos((double)((PI64*i+PI4)*(2*k+1)))) >= 0)
  2369. modf(filter[i][k]+0.5, &filter[i][k]);
  2370.          else
  2371.             modf(filter[i][k]-0.5, &filter[i][k]);
  2372.  filter[i][k] *= 1e-9;
  2373.   }
  2374. }
  2376. /***************************************************************
  2377. /*
  2378. /*   Window the restored sample
  2379. /*
  2380. /***************************************************************/
  2382. /* read in synthesis window */
  2384. static void read_syn_window(double window[HAN_SIZE])
  2385. {
  2386.    int i,j[4];
  2387.    FILE *fp;
  2388.    double f[4];
  2389.    char t[150];
  2391.    if (!(fp = OpenTableFile("dewindow") )) {
  2392.   fprintf (stderr, "Please check synthesis window table 'dewindow'n");
  2393.   exit (1);
  2394.    }
  2395.    for (i=0;i<512;i+=4) {
  2396. fgets(t,150, fp);
  2397.   sscanf(t,"D[%d] = %lf D[%d] = %lf D[%d] = %lf D[%d] = %lfn",
  2398.  j, f,j+1,f+1,j+2,f+2,j+3,f+3);
  2399.   if (i==j[0]) {
  2400.  window[i] = f[0];
  2401.  window[i+1] = f[1];
  2402.  window[i+2] = f[2];
  2403.  window[i+3] = f[3];
  2404.   }
  2405.   else {
  2406.  fprintf (stderr, "Check index in synthesis window tablen");
  2407. exit (1);
  2408.   }
  2409.   fgets(t,80,fp);
  2410.    }
  2411.    fclose(fp);
  2412. }
  2415. int SubBandSynthesis (double *bandPtr,
  2416.       int channel,
  2417.       long *samples)
  2418. {
  2419.     long foo;
  2420.     register int i,j,k;
  2421.     register double *bufOffsetPtr, sum;
  2422.     static int init = 1;
  2423.     typedef double NN[64][32];
  2424.     static NN *filter;
  2425.     typedef double BB[7][2*HAN_SIZE]; 
  2426.     static BB *buf;
  2427.     static int bufOffset = 64;
  2428.     static double *window;
  2429.     int clip = 0;               /* count & return how many samples clipped */
  2431.     if (init) {
  2432. buf = (BB *) mem_alloc(sizeof(BB),"BB");
  2433. filter = (NN *) mem_alloc(sizeof(NN), "NN");
  2434. create_syn_filter(*filter);
  2435. window = (double *) mem_alloc(sizeof(double) * HAN_SIZE, "WIN");
  2436. read_syn_window(window);
  2437. bufOffset = 64;
  2438. init = 0;
  2439. }
  2440. if (channel == 0) bufOffset = (bufOffset - 64) & 0x3ff;
  2441. bufOffsetPtr = &((*buf)[channel][bufOffset]);
  2443. for (i=0; i<64; i++)
  2444. {
  2445. sum = 0;
  2446. for (k=0; k<32; k++)
  2447. sum += bandPtr[k] * (*filter)[i][k];
  2448. bufOffsetPtr[i] = sum;
  2449. }
  2451. /*  S(i,j) = D(j+32i) * U(j+32i+((i+1)>>1)*64)  */
  2452. /*  samples(i,j) = MWindow(j+32i) * bufPtr(j+32i+((i+1)>>1)*64)  */
  2453. for (j=0; j<32; j++)
  2454. {
  2455.         sum = 0;
  2456. for (i=0; i<16; i++)
  2457. {
  2458. k = j + (i<<5);
  2459.             sum += window[k] * (*buf) [channel] [( (k + ( ((i+1)>>1) <<6) ) +
  2460.                                                   bufOffset) & 0x3ff];
  2461.         }
  2463. /*   {long foo = (sum > 0) ? sum * SCALE + 0.5 : sum * SCALE - 0.5; */
  2464. /*   {long foo = sum * SCALE;  */
  2465.      
  2466. #ifdef SB_OUTPUT
  2467.  sum = bandPtr[j]; /* 960814 FdB for subband sample generation */
  2468. #endif
  2470.  foo = floor(sum * SCALE + 0.5);
  2471.  if (foo >= (long) SCALE)      {samples[j] = SCALE-1; ++clip;}
  2472.  else if (foo < (long) -SCALE) {samples[j] =-SCALE;  ++clip;}
  2473.  else                           samples[j] = foo;
  2474.  
  2475.     }
  2476.     return(clip);
  2477. }
  2479. int SubBandSynthesis_ml (double *bandPtr,
  2480.          int channel,
  2481.          long *samples)
  2482. {
  2483.     long foo;
  2484.     register int i,j,k;
  2485.     register double *bufOffsetPtr, sum;
  2486.     static int init = 1;
  2487.     typedef double NN[64][32];
  2488.     static NN *filter;
  2489.     typedef double BB[7][2*HAN_SIZE]; 
  2490.     static BB *buf;
  2491.     static int bufOffset = 64;
  2492.     static double *window;
  2493.     int clip = 0;               /* count & return how many samples clipped */
  2495.     if (init) {
  2496. buf = (BB *) mem_alloc(sizeof(BB),"BB");
  2497. filter = (NN *) mem_alloc(sizeof(NN), "NN");
  2498. create_syn_filter(*filter);
  2499. window = (double *) mem_alloc(sizeof(double) * HAN_SIZE, "WIN");
  2500. read_syn_window(window);
  2501. bufOffset = 64;
  2502. init = 0;
  2503. }
  2504. if (channel == 0) bufOffset = (bufOffset - 64) & 0x3ff;
  2505. bufOffsetPtr = &((*buf)[channel][bufOffset]);
  2507. for (i=0; i<64; i++)
  2508. {
  2509. sum = 0;
  2510. for (k=0; k<32; k++)
  2511. sum += bandPtr[k] * (*filter)[i][k];
  2512. bufOffsetPtr[i] = sum;
  2513. }
  2515. /*  S(i,j) = D(j+32i) * U(j+32i+((i+1)>>1)*64)  */
  2516. /*  samples(i,j) = MWindow(j+32i) * bufPtr(j+32i+((i+1)>>1)*64)  */
  2517. for (j=0; j<32; j++)
  2518. {
  2519.         sum = 0;
  2520. for (i=0; i<16; i++)
  2521. {
  2522. k = j + (i<<5);
  2523.             sum += window[k] * (*buf) [channel] [( (k + ( ((i+1)>>1) <<6) ) +
  2524.                                                   bufOffset) & 0x3ff];
  2525.         }
  2527. /*   {long foo = (sum > 0) ? sum * SCALE + 0.5 : sum * SCALE - 0.5; */
  2528. /*   {long foo = sum * SCALE;  */
  2529.      
  2530. #ifdef SB_OUTPUT
  2531.  sum = bandPtr[j]; /* 960814 FdB for subband sample generation */
  2532. #endif
  2534.  foo = floor(sum * SCALE + 0.5);
  2535.  if (foo >= (long) SCALE)      {samples[j] = SCALE-1; ++clip;}
  2536.  else if (foo < (long) -SCALE) {samples[j] =-SCALE;  ++clip;}
  2537.  else                           samples[j] = foo;
  2538.  
  2539.     }
  2540.     return (clip);
  2541. }
  2544. void out_fifo (long pcm_sample[7][3][SBLIMIT],
  2545.        int num,
  2546.        frame_params *fr_ps,
  2547.        int done,
  2548.        FILE *outFile,
  2549.        unsigned long *psampFrames,
  2550.        int ch)
  2551. {
  2552.    int i,j,l;
  2553. static short int outsamp[1600];
  2554. static long k = 0;
  2556.     if (!done)
  2557. for (i = 0; i < num; i++)
  2558.     for (j = 0; j < SBLIMIT; j++) 
  2559.     {
  2560. (*psampFrames)++;
  2561. for (l = 0; l < ch; l++)
  2562. {
  2563.     if (!(k % 1600) && k) 
  2564.     {
  2565. fwrite (outsamp, 2, 1600, outFile);
  2566. k = 0;
  2567.     }
  2568.     outsamp[k++] = pcm_sample[l][i][j];
  2569. }
  2570.     }
  2571.     else if (k > 0)
  2572.     {
  2573. fwrite (outsamp, 2, (int) k, outFile);
  2574. k = 0;
  2575.     }
  2576. }
  2578. void out_fifo_ml(long pcm_sample[7][3][SBLIMIT],
  2579.          int num,
  2580.          frame_params *fr_ps,
  2581.          int done,
  2582.          FILE *outFile,
  2583.          unsigned long *psampFrames)
  2584. {
  2585.    int i,j,l;
  2586.    int n_ml_ch = fr_ps->header->no_of_multi_lingual_ch;
  2587.    static short int outsamp[1600];
  2588.    static long k = 0;
  2590.    if (!done)
  2591.       for (i=0; i<num; i++)
  2592.  for (j=0; j<SBLIMIT; j++)
  2593.  {
  2594.     (*psampFrames)++;
  2595.     for (l=0; l<n_ml_ch; l++)
  2596.     {
  2597.        if (!(k%1600) && k)
  2598.        {
  2599.   fwrite (outsamp, 2, 1600, outFile);
  2600.   k = 0;
  2601.        }
  2602.        outsamp[k++] = pcm_sample[l][i][j];
  2603.     }
  2604.  }
  2605.    else if (k > 0)
  2606.    {
  2607.       fwrite (outsamp, 2, (int) k, outFile);
  2608.       k = 0;
  2609.    }
  2610. }
  2612. /*************************************************/
  2613. /* JMZ 10/03/1995 Multilingual */
  2615. /* JMZ 10/03/1995 Multilingual */
  2616. /*************************************************/
  2618. void  buffer_CRC(Bit_stream  *bs,
  2619.  unsigned int  *old_crc)
  2620. {
  2621.    *old_crc = getbits (bs, 16);
  2622. }
  2624. void  recover_CRC_error(long pcm_sample[7][3][SBLIMIT],
  2625. int error_count,
  2626. frame_params *fr_ps,
  2627. FILE *outFile,
  2628. unsigned long *psampFrames,
  2629. int ch)
  2630. {
  2631.    int  stereo = fr_ps->stereo;
  2632.    int  num, done, i;
  2633.    int  samplesPerFrame, samplesPerSlot;
  2634.    layer  *hdr = fr_ps->header;
  2635.    long  offset;
  2636.    short  *temp;
  2638.    num = 3;
  2639.    if (hdr->lay == 1) num = 1;
  2641.    samplesPerSlot = SBLIMIT * num * stereo;
  2642.    samplesPerFrame = samplesPerSlot * 32;
  2644.    if (error_count == 1) {   /* replicate previous error_free frame */
  2645.       done = 1;
  2646.   /* flush out fifo */
  2647.   out_fifo(pcm_sample, num, fr_ps, done, outFile, psampFrames, ch);
  2648.   /* go back to the beginning of the previous frame */
  2649.   offset = sizeof(short int) * samplesPerFrame;
  2650.       fseek(outFile, -offset, SEEK_CUR);
  2651.       done = 0;
  2652.       for (i = 0; i < 12; i++) {
  2653.  fread(pcm_sample, 2, samplesPerSlot, outFile);
  2654.  out_fifo(pcm_sample, num, fr_ps, done, outFile, psampFrames, ch);
  2655.       }
  2656.    }
  2657.    else{   /* mute the frame */
  2658.       temp = (short*) pcm_sample;
  2659.       done = 0;
  2660.       for (i = 0; i < 2*3*SBLIMIT; i++)
  2661.          *temp++ = MUTE;   /* MUTE value is in decoder.h */
  2662.       for (i = 0; i < 12; i++)
  2663.          out_fifo(pcm_sample, num, fr_ps, done, outFile, psampFrames, ch);
  2664.    }
  2665. }
  2668. /*******************************************************/
  2669. /* prediction corrected, Heiko Purnhagen 08-nov-94 */
  2670. /*******************************************************/
  2672. /* this is only a local function */
  2673. static double predict (double pred_buf[2][8][36+PREDDEL], 
  2674. frame_params *fr_ps,
  2675. int sb, 
  2676. int jj, 
  2677. int j,
  2678. int ch,
  2679. int idx) 
  2680. {
  2681.   int i;
  2682.   double t;
  2684.   t = 0;
  2685.   for (i=0; i<fr_ps->header->mc_predsi[sb][idx]; i++)
  2686.     t += pred_buf[ch][sb][PREDDEL+3*jj+j-i-fr_ps->header->mc_delay_comp[sb][idx]]
  2687.       * (fr_ps->header->mc_pred_coeff[sb][idx][i] - 127) * STEP;
  2688.   return t;
  2689. }
  2692. /**************************************************************/
  2693. /* JMZ 09/03/1995 Multilingual modifications */
  2695. void dematricing_mc (double pcm_sample[7][SBLIMIT][3][12], 
  2696.      frame_params *fr_ps,
  2697.      double pred_buf[2][8][36+PREDDEL])
  2698. {
  2699.   int i, j, jj, k, tc_alloc, l, sbgr = 0 ;
  2700.   layer *info = fr_ps->header;
  2701.   double tmp_sample, tmp_sample1, surround_sample;
  2702.   
  2703.   for (jj=0; jj<12; jj++)
  2704.   for( j = 0; j < 3; ++j)
  2705.    {
  2706. for(k = 0; k < SBLIMIT; k ++)
  2707. {
  2708.     if(fr_ps->header->tc_sbgr_select == 1)
  2709. tc_alloc = fr_ps->header->tc_allocation; /* one tc_alloc is valid for all sbgr */
  2710.     else
  2711.     {
  2712. if(k == 0) sbgr = 0;
  2713. else
  2714. for(l = 1; l < 12; l++)
  2715. {
  2716. if((sb_groups[l-1] < k) && (k <= sb_groups[l]))
  2717. {
  2718. sbgr = l;  /* search the valid subband group */
  2719. break;
  2720. }
  2721. }
  2722. tc_alloc = fr_ps->header->tc_alloc[sbgr]; /* no prediction, but different tc_alloc's
  2723. per subband*/
  2724.     }  /* else tc_sbgr_select == 0 */
  2726.     if (fr_ps->header->mc_prediction_on && k < 8 && fr_ps->header->mc_prediction[k])
  2727.     {
  2728. /* prediction on in sbgr */
  2729.     if ((fr_ps->header->surround == 2) && (fr_ps->header->center != 0))
  2730. {    
  2731.     /* FdB channel mode 3/2 */
  2732.     switch (fr_ps->header->dyn_cross_mode[k])   /* if prediction on in sb */
  2733.     {
  2734. case 0: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2735.                                  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2736.      pcm_sample[3][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,2)
  2737.            + predict(pred_buf,fr_ps,k,jj,j,1,3);
  2738.      pcm_sample[4][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,4)
  2739.          + predict(pred_buf,fr_ps,k,jj,j,1,5);
  2740. break;
  2742. case 1: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2743.                                  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2744.      pcm_sample[3][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,2)
  2745.            + predict(pred_buf,fr_ps,k,jj,j,1,3);
  2746.      break;
  2748. case 2: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2749.                                  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2750.      pcm_sample[4][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,2)
  2751.          + predict(pred_buf,fr_ps,k,jj,j,1,3);
  2752. break;
  2754. case 3: pcm_sample[3][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2755.            + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2756.      pcm_sample[4][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,2)
  2757.          + predict(pred_buf,fr_ps,k,jj,j,1,3);
  2758. break;
  2760. case 4: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2761.                                  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2762.      break;
  2764. case 5: pcm_sample[3][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2765.            + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2766.      break;
  2768. case 6: pcm_sample[4][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2769.          + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2770. break;
  2772. case 8: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2773.                                  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2774.      break;
  2776. case 9: pcm_sample[4][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2777.          + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2778. break;
  2780.        case 10: pcm_sample[3][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2781.          + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2782.      break;
  2784.      }
  2785. } /* 3/2 mode */
  2786. else if ((fr_ps->header->surround == 1 && fr_ps->header->center != 0) ||
  2787.  (fr_ps->header->surround == 2 && fr_ps->header->center == 0))
  2788. {
  2789.     /* FdB channel modes 3/1 and 2/2 */
  2790.     switch(fr_ps->header->dyn_cross_mode[k])   /* if prediction on in sb */
  2791.     {
  2792. case 0: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2793.  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2794. pcm_sample[3][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,2)
  2795.  + predict(pred_buf,fr_ps,k,jj,j,1,3);
  2796. break;
  2798. case 1: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2799.  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2800. break;
  2802. case 2: pcm_sample[3][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2803.  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2804. break;
  2806.     }
  2807. } /* 3/1 and 2/2 modes */
  2808. else if (((fr_ps->header->surround == 0 || fr_ps->header->surround == 3) && fr_ps->header->center != 0) ||
  2809.  (fr_ps->header->surround == 1 && fr_ps->header->center == 0))
  2810. {
  2811.     /* FdB channel modes 3/0 (+ 2/0) and 2/1 */
  2812.     switch(fr_ps->header->dyn_cross_mode[k])   /* if prediction on in sb */
  2813.     {
  2814. case 0: pcm_sample[2][k][j][jj] += predict(pred_buf,fr_ps,k,jj,j,0,0)
  2815.  + predict(pred_buf,fr_ps,k,jj,j,1,1);
  2816. break;
  2818.     }
  2819. }
  2820.     }    
  2822.     if (fr_ps->header->dematrix_procedure != 3)
  2823.     if ((fr_ps->header->surround == 2) && (fr_ps->header->center != 0))
  2824. {    
  2825.     /* FdB channel mode 3/2 */
  2826.     switch(tc_alloc)
  2827.     {
  2828.      case 0:
  2829.     if (fr_ps->header->dematrix_procedure == 2) {
  2830. surround_sample = (pcm_sample[3][k][j][jj] + pcm_sample[4][k][j][jj]) / 2.0;
  2831. pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + surround_sample;
  2832. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - surround_sample;
  2833.     }
  2834.     else {
  2835. pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2836. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[4][k][j][jj];
  2837.     }
  2838.     break;
  2839.     
  2840.      case 1:
  2841.     if (fr_ps->header->dematrix_procedure == 2) {
  2842.     surround_sample = (pcm_sample[3][k][j][jj] + pcm_sample[4][k][j][jj]) / 2.0;
  2843.     tmp_sample = pcm_sample[2][k][j][jj]; /* L */
  2844.     pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + surround_sample;
  2845.     pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - surround_sample;
  2846.     pcm_sample[0][k][j][jj] = tmp_sample;
  2847.     }
  2848.     else {
  2849.     tmp_sample = pcm_sample[2][k][j][jj]; /* L */
  2850.     pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2851.     pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[4][k][j][jj];
  2852.     pcm_sample[0][k][j][jj] = tmp_sample;
  2853.     }
  2854.     break;
  2855.     
  2856.      case 2:
  2857.     if (fr_ps->header->dematrix_procedure == 2) {
  2858.     surround_sample = (pcm_sample[3][k][j][jj] + pcm_sample[4][k][j][jj]) / 2.0;
  2859.     tmp_sample = pcm_sample[2][k][j][jj]; /* R */
  2860.     pcm_sample[2][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - surround_sample;
  2861.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + surround_sample;
  2862.     pcm_sample[1][k][j][jj] = tmp_sample;
  2863.     }
  2864.     else {
  2865.     tmp_sample = pcm_sample[2][k][j][jj]; /* R */
  2866.     pcm_sample[2][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[4][k][j][jj];
  2867.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2868.     pcm_sample[1][k][j][jj] = tmp_sample;
  2869.     }
  2870.     break;
  2871.     
  2872.      case 3:
  2873.     if (fr_ps->header->dematrix_procedure == 2) {
  2874.     tmp_sample = pcm_sample[3][k][j][jj];  /* L in T3 */
  2875.     pcm_sample[3][k][j][jj] = -2.0 * (pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] -  pcm_sample[3][k][j][jj]) - pcm_sample[4][k][j][jj];
  2876.     pcm_sample[1][k][j][jj] = pcm_sample[0][k][j][jj] + pcm_sample[1][k][j][jj] - 2.0 * pcm_sample[2][k][j][jj] - tmp_sample;
  2877.     pcm_sample[0][k][j][jj] = tmp_sample;
  2878.     }
  2879.     else {
  2880.     tmp_sample = pcm_sample[3][k][j][jj];  /* L in T3 */
  2881.     pcm_sample[3][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[3][k][j][jj] - pcm_sample[2][k][j][jj];
  2882.     pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[4][k][j][jj];
  2883.     pcm_sample[0][k][j][jj] = tmp_sample;
  2884.     }
  2885.     break;
  2886.     
  2887.      case 4:
  2888.     if (fr_ps->header->dematrix_procedure == 2) {
  2889.     tmp_sample = pcm_sample[4][k][j][jj];  /* R in T4 */
  2890.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] + pcm_sample[1][k][j][jj] - 2.0 * pcm_sample[2][k][j][jj] - pcm_sample[4][k][j][jj];
  2891.     pcm_sample[4][k][j][jj] = 2.0 * pcm_sample[1][k][j][jj] - 2.0 * (pcm_sample[2][k][j][jj] + pcm_sample[4][k][j][jj]) - pcm_sample[3][k][j][jj];
  2892.     pcm_sample[1][k][j][jj] = tmp_sample;
  2893.     }
  2894.     else {
  2895.     tmp_sample = pcm_sample[4][k][j][jj];  /* R in T4 */
  2896.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2897.     pcm_sample[4][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[4][k][j][jj] - pcm_sample[2][k][j][jj];
  2898.     pcm_sample[1][k][j][jj] = tmp_sample;
  2899.     }
  2900.     break;
  2901.     
  2902.      case 5:
  2903.     if (fr_ps->header->dematrix_procedure == 2) {
  2904.     tmp_sample = pcm_sample[3][k][j][jj];  /* L in T3 */
  2905.     pcm_sample[3][k][j][jj] = 0.5 * (pcm_sample[1][k][j][jj] - pcm_sample[0][k][j][jj] + pcm_sample[3][k][j][jj] - pcm_sample[4][k][j][jj]);
  2906.     pcm_sample[0][k][j][jj] = tmp_sample;
  2907.     pcm_sample[1][k][j][jj] = pcm_sample[4][k][j][jj]; /* R in T4 */
  2908.     pcm_sample[4][k][j][jj] = pcm_sample[3][k][j][jj]; /* RS = LS */
  2909.     }
  2910.     else {
  2911.     tmp_sample = pcm_sample[3][k][j][jj];
  2912.     pcm_sample[3][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[3][k][j][jj] - pcm_sample[2][k][j][jj];
  2913.     pcm_sample[0][k][j][jj] = tmp_sample;
  2914.     tmp_sample = pcm_sample[4][k][j][jj];
  2915.     pcm_sample[4][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[4][k][j][jj] - pcm_sample[2][k][j][jj];
  2916.     pcm_sample[1][k][j][jj] = tmp_sample;
  2917.     }
  2918.     break;
  2919.     
  2920.      case 6:
  2921.     if (fr_ps->header->dematrix_procedure == 2) {
  2922.     tmp_sample = pcm_sample[2][k][j][jj];  /* R in T2 */
  2923.     tmp_sample1 = pcm_sample[3][k][j][jj];  /* L in T3 */
  2924.     pcm_sample[3][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + pcm_sample[3][k][j][jj] - pcm_sample[4][k][j][jj];
  2925.     pcm_sample[2][k][j][jj] = 0.5 * (pcm_sample[0][k][j][jj] + pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - tmp_sample1);
  2926.     pcm_sample[1][k][j][jj] = tmp_sample;
  2927.     pcm_sample[0][k][j][jj] = tmp_sample1;
  2928.     }
  2929.     else {
  2930.     tmp_sample = pcm_sample[2][k][j][jj];  /* R in T2 */
  2931.     pcm_sample[2][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[4][k][j][jj];
  2932.     pcm_sample[1][k][j][jj] = tmp_sample;
  2933.     tmp_sample = pcm_sample[3][k][j][jj];  /* L in T3 */
  2934.     pcm_sample[3][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[3][k][j][jj] - pcm_sample[2][k][j][jj];
  2935.     pcm_sample[0][k][j][jj] = tmp_sample;
  2936.     }
  2937.     break;
  2938.     
  2939.      case 7:
  2940.     if (fr_ps->header->dematrix_procedure == 2) {
  2941.     tmp_sample = pcm_sample[2][k][j][jj];  /* L in T2 */
  2942.     tmp_sample1 = pcm_sample[4][k][j][jj];  /* R in T4 */
  2943.     pcm_sample[4][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[0][k][j][jj] + pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj] - pcm_sample[4][k][j][jj];
  2944.     pcm_sample[2][k][j][jj] = 0.5 * (pcm_sample[0][k][j][jj] + pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - tmp_sample1);
  2945.     pcm_sample[0][k][j][jj] = tmp_sample;
  2946.     pcm_sample[1][k][j][jj] = tmp_sample1;
  2947.     }
  2948.     else {
  2949.     tmp_sample = pcm_sample[2][k][j][jj];
  2950.     pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2951.     pcm_sample[0][k][j][jj] = tmp_sample;
  2952.     tmp_sample = pcm_sample[4][k][j][jj];
  2953.     pcm_sample[4][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[4][k][j][jj] - pcm_sample[2][k][j][jj];
  2954.     pcm_sample[1][k][j][jj] = tmp_sample;
  2955.     }
  2956.     break;
  2957.     
  2958.     } /* switch end loop*/
  2959. }
  2960. else if (fr_ps->header->surround == 1 && fr_ps->header->center != 0)  
  2961. {    
  2962.     /* FdB channel mode 3/1 */
  2963.     switch(tc_alloc)
  2964.     {
  2965.  case 0: 
  2966. if (fr_ps->header->dematrix_procedure == 2)
  2967.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + pcm_sample[3][k][j][jj];
  2968. else
  2969.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2970. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2971. break;
  2973.  case 1:
  2974. tmp_sample = pcm_sample[2][k][j][jj]; /* L */
  2975. if (fr_ps->header->dematrix_procedure == 2)
  2976.     pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + pcm_sample[3][k][j][jj];
  2977. else
  2978.     pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2979. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2980. pcm_sample[0][k][j][jj] = tmp_sample;
  2981. break;
  2983.  case 2: 
  2984. tmp_sample = pcm_sample[2][k][j][jj]; /* R */
  2985. pcm_sample[2][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2986. if (fr_ps->header->dematrix_procedure == 2)
  2987.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + pcm_sample[3][k][j][jj];
  2988. else
  2989.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2990. pcm_sample[1][k][j][jj] = tmp_sample;
  2991. break;
  2993.  case 3: 
  2994. tmp_sample = pcm_sample[3][k][j][jj];  /* L in T3 */
  2995. if (fr_ps->header->dematrix_procedure == 2)
  2996.     pcm_sample[3][k][j][jj] = -pcm_sample[0][k][j][jj] + pcm_sample[2][k][j][jj] + pcm_sample[3][k][j][jj];
  2997. else
  2998.     pcm_sample[3][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  2999. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  3000. pcm_sample[0][k][j][jj] = tmp_sample;
  3001. break;
  3003.  case 4:
  3004. tmp_sample = pcm_sample[3][k][j][jj];  /* R in T3 */
  3005. pcm_sample[3][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  3006. if (fr_ps->header->dematrix_procedure == 2)
  3007.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] + pcm_sample[3][k][j][jj];
  3008. else
  3009.     pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj] - pcm_sample[3][k][j][jj];
  3010. pcm_sample[1][k][j][jj] = tmp_sample;
  3011. break;
  3013.  case 5:
  3014. tmp_sample = pcm_sample[2][k][j][jj];  /* L in T2 */
  3015. tmp_sample1 = pcm_sample[3][k][j][jj];  /* R in T3 */
  3016. pcm_sample[2][k][j][jj] = 0.5 * (pcm_sample[0][k][j][jj] + pcm_sample[1][k][j][jj] - tmp_sample - tmp_sample1);
  3017. pcm_sample[3][k][j][jj] = 0.5 * (pcm_sample[1][k][j][jj] - pcm_sample[0][k][j][jj] + tmp_sample - tmp_sample1);
  3018. pcm_sample[0][k][j][jj] = tmp_sample;
  3019. pcm_sample[1][k][j][jj] = tmp_sample1;
  3020. break;
  3021.     }   /* switch end */
  3022. }
  3023. else if (fr_ps->header->surround == 1 || fr_ps->header->center != 0)
  3024. {
  3025.     /* FdB channel modes 3/0 (+ 2/0) and 2/1 */
  3026.     switch(tc_alloc)
  3027.     {
  3028.  case 0: 
  3029. pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj]; 
  3030. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj];
  3031. break;
  3033.  case 1:
  3034. tmp_sample = pcm_sample[2][k][j][jj]; /* L */
  3035. pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj];
  3036. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj];
  3037. pcm_sample[0][k][j][jj] = tmp_sample;
  3038. break;
  3040.  case 2: 
  3041. tmp_sample = pcm_sample[2][k][j][jj]; /* R */
  3042. pcm_sample[2][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[2][k][j][jj];
  3043. pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj];
  3044. pcm_sample[1][k][j][jj] = tmp_sample;
  3045. break;
  3046.     }   /* switch end */
  3047. }
  3048. else if (fr_ps->header->surround == 2)  
  3049. {
  3050.     /* FdB channel mode 2/2 */
  3051.     switch(tc_alloc)
  3052.     {
  3053.  case 0: 
  3054. pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj];
  3055.      pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[3][k][j][jj];
  3056. break;
  3058.  case 1:
  3059. tmp_sample = pcm_sample[2][k][j][jj]; /* L */
  3060. pcm_sample[1][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[3][k][j][jj];
  3061. pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj];
  3062. pcm_sample[0][k][j][jj] = tmp_sample;
  3063. break;
  3065.  case 2: 
  3066. tmp_sample = pcm_sample[3][k][j][jj]; /* R */
  3067. pcm_sample[0][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj];
  3068. pcm_sample[3][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[3][k][j][jj];
  3069. pcm_sample[1][k][j][jj] = tmp_sample;
  3070. break;
  3072.  case 3: 
  3073. tmp_sample = pcm_sample[2][k][j][jj]; /* L */
  3074. pcm_sample[2][k][j][jj] = pcm_sample[0][k][j][jj] - pcm_sample[2][k][j][jj];
  3075. pcm_sample[0][k][j][jj] = tmp_sample;
  3076. tmp_sample = pcm_sample[3][k][j][jj]; /* R */
  3077. pcm_sample[3][k][j][jj] = pcm_sample[1][k][j][jj] - pcm_sample[3][k][j][jj];
  3078. pcm_sample[1][k][j][jj] = tmp_sample;
  3079. break;
  3080.     }   /* switch end */
  3081. }
  3082. }     /* for k < sblimit loop */
  3083.       }     /* for j < 3 loop */
  3084. }
  3086. void denormalizing_mc (double pcm_sample[7][SBLIMIT][3][12], frame_params *fr_ps, int channels)
  3087. {
  3088.   double matr1;   /* normalizing factor */
  3089.   double matr2;   /* matricing factor   */
  3090.   double matr3;   /* matricing factor   */
  3091.   int i, j, jj, k, l;
  3092.   layer *info = fr_ps->header;
  3093.   int  stereo = fr_ps->stereo;
  3094.   
  3095.   switch (info->dematrix_procedure)
  3096.   {
  3097.     /* factors according to International Standard */
  3098.     case 0:
  3099.     case 2: matr1 = 1 + sqrt(2.0); /* factor for L and R   */
  3100.     matr2 = sqrt(2.0) * matr1; /* factor for C */
  3101.     matr3 = sqrt(2.0) * matr1; /* factor for Ls, Rs */
  3102.     break;
  3103.     case 1: matr1 = (1.5 + 0.5*sqrt(2.0));/* factor for L, R      */
  3104.     matr2 = sqrt(2.0) * matr1; /* factor for C         */
  3105.     matr3 = 2 * matr1; /* factor for Ls, Rs  */
  3106.     break;
  3107.     case 3: matr1 = 1.0;
  3108.     matr2 = 1.0;
  3109.     matr3 = 1.0;
  3110.     break;
  3111.   }
  3113.   /* denormalized signals */
  3114.   if (fr_ps->header->dematrix_procedure != 3 )  /* dematrixing */
  3115.     for (jj=0; jj<12; jj++)
  3116.       for( j = 0; j < 3; ++j)
  3117. for (k = 0; k < SBLIMIT; k ++)
  3118. {   /* Lo / Ro */
  3119.     for (i = 0; i < stereo; i++)
  3120. pcm_sample[i][k][j][jj] = pcm_sample[i][k][j][jj] * matr1;
  3122.     if (fr_ps->header->dematrix_procedure != 1)  /* matrix 0 and 2, since C, Ls, Rs, and S all use the same value */
  3123.     {
  3124. /* second stereo channels */
  3125. if (fr_ps->header->surround == 3)
  3126. {
  3127.     if (fr_ps->header->center != 0)
  3128. pcm_sample[2][k][j][jj] = pcm_sample[2][k][j][jj] * matr2;
  3129. }
  3130. else   
  3131. {
  3132.     for (l = 2; l < channels; l++)
  3133.        pcm_sample[l][k][j][jj] = pcm_sample[l][k][j][jj] * matr2;
  3134. }
  3135.     }
  3136.     else   /* matrix 1 */
  3137.     {
  3138. if (fr_ps->header->surround == 3)
  3139. {
  3140.     if (fr_ps->header->center != 0)
  3141. pcm_sample[2][k][j][jj] = pcm_sample[2][k][j][jj] * matr2;
  3142. }
  3143. else if (fr_ps->mc_channel == 3)   /* R.S. matr2 = C */
  3144. {
  3145.     pcm_sample[2][k][j][jj] = pcm_sample[2][k][j][jj] * matr2;
  3146.     pcm_sample[3][k][j][jj] = pcm_sample[3][k][j][jj] * matr3;
  3147.     pcm_sample[4][k][j][jj] = pcm_sample[4][k][j][jj] * matr3;
  3148. }
  3149. else if (fr_ps->mc_channel == 2)
  3150. {
  3151.     if (fr_ps->header->surround == 2) /* 2/2 */
  3152.     {
  3153. pcm_sample[2][k][j][jj] = pcm_sample[2][k][j][jj] * matr3;  
  3154. pcm_sample[3][k][j][jj] = pcm_sample[3][k][j][jj] * matr3;
  3155.     }
  3156.     else /* 3/1 */
  3157.     {
  3158. pcm_sample[2][k][j][jj] = pcm_sample[2][k][j][jj] * matr2;
  3159. pcm_sample[3][k][j][jj] = pcm_sample[3][k][j][jj] * matr3;
  3160.     }
  3161. }
  3162. else /* mc_channel == 1 */
  3163. {
  3164.     if (fr_ps->header->center == 0) /* 2/1 */
  3165. pcm_sample[2][k][j][jj] = pcm_sample[2][k][j][jj] * matr3; 
  3166.     else /* 3/0 */
  3167. pcm_sample[2][k][j][jj] = pcm_sample[2][k][j][jj] * matr2;
  3168. }
  3169.     }
  3170. }
  3171. }
  3173. #ifdef Augmentation_7ch
  3174. void dematricing_aug (double pcm_sample[7][SBLIMIT][3][12], frame_params *fr_ps)
  3175. {
  3176.   double c0, c1;   /* denormalization factors */
  3177.   int i, j, jj, k, tc_aug_alloc, l, sbgr = 0 ;
  3178.   layer *info = fr_ps->header;
  3179.   double tmp_sample1, tmp_sample2;
  3180.   
  3181.   c0 = 1.0 / 3.0;
  3182.   if (info->dematrix_procedure != 3)
  3183.     c0 *= sqrt (0.5);
  3184.   c1 = 1.0 / c0;
  3186.   for (jj=0; jj<12; jj++)
  3187.     for( j = 0; j < 3; ++j)
  3188.     {
  3189.       for(k = 0; k < SBLIMIT; k ++)
  3190.       {
  3191. if (k == 0) sbgr = 0;
  3192. else
  3193. {
  3194.   for(l = 1; l < 12; l++)
  3195.   {
  3196.     if((sb_groups[l-1] < k) && (k <= sb_groups[l]))
  3197.     {
  3198.       sbgr = l;  /* search the valid subband group */
  3199.       break;
  3200.     }
  3201.   }
  3202. }
  3203. tc_aug_alloc = fr_ps->header->tc_aug_alloc[sbgr];
  3205. if (info->aug_mtx_proc == 0)
  3206.   switch (tc_aug_alloc)
  3207.   {
  3208.   case 0:  pcm_sample[0][k][j][jj] -= pcm_sample[5][k][j][jj];
  3209.    pcm_sample[1][k][j][jj] -= pcm_sample[6][k][j][jj];
  3210.    pcm_sample[2][k][j][jj] -= c0 * (pcm_sample[5][k][j][jj] + pcm_sample[6][k][j][jj]);
  3211.    break;
  3212.   case 1:  tmp_sample1 = pcm_sample[0][k][j][jj];
  3213.    pcm_sample[0][k][j][jj] = pcm_sample[5][k][j][jj];
  3214.    pcm_sample[5][k][j][jj] = tmp_sample1 - pcm_sample[5][k][j][jj];
  3215.    pcm_sample[1][k][j][jj] -= pcm_sample[6][k][j][jj];
  3216.    pcm_sample[2][k][j][jj] -= c0 * (pcm_sample[5][k][j][jj] + pcm_sample[6][k][j][jj]);
  3217.    break;
  3218.   case 2:  pcm_sample[0][k][j][jj] -= pcm_sample[5][k][j][jj];
  3219.    tmp_sample2 = pcm_sample[1][k][j][jj];
  3220.    pcm_sample[1][k][j][jj] = pcm_sample[6][k][j][jj];
  3221.    pcm_sample[6][k][j][jj] = tmp_sample2 - pcm_sample[6][k][j][jj];
  3222.    pcm_sample[2][k][j][jj] -= c0 * (pcm_sample[5][k][j][jj] + pcm_sample[6][k][j][jj]);
  3223.    break;
  3224.   case 3:  tmp_sample1 = pcm_sample[0][k][j][jj];
  3225.    pcm_sample[0][k][j][jj] = pcm_sample[5][k][j][jj];
  3226.    pcm_sample[5][k][j][jj] = tmp_sample1 - pcm_sample[5][k][j][jj];
  3227.    tmp_sample2 = pcm_sample[1][k][j][jj];
  3228.    pcm_sample[1][k][j][jj] = pcm_sample[6][k][j][jj];
  3229.    pcm_sample[6][k][j][jj] = tmp_sample2 - pcm_sample[6][k][j][jj];
  3230.    pcm_sample[2][k][j][jj] -= c0 * (pcm_sample[5][k][j][jj] + pcm_sample[6][k][j][jj]);
  3231.    break;
  3232.   case 4:  pcm_sample[0][k][j][jj] -= pcm_sample[5][k][j][jj];
  3233.    tmp_sample1 = pcm_sample[2][k][j][jj];
  3234.    tmp_sample2 = pcm_sample[6][k][j][jj];
  3235.    pcm_sample[2][k][j][jj] = tmp_sample2;
  3236.    pcm_sample[6][k][j][jj] = c1 * (tmp_sample1 - tmp_sample2) - pcm_sample[5][k][j][jj];
  3237.    pcm_sample[1][k][j][jj] -= pcm_sample[6][k][j][jj];
  3238.    break;
  3239.   case 5:  tmp_sample1 = pcm_sample[0][k][j][jj];
  3240.    pcm_sample[0][k][j][jj] = pcm_sample[5][k][j][jj];
  3241.    pcm_sample[5][k][j][jj] = tmp_sample1 - pcm_sample[5][k][j][jj];
  3242.    tmp_sample1 = pcm_sample[2][k][j][jj];
  3243.    tmp_sample2 = pcm_sample[6][k][j][jj];
  3244.    pcm_sample[2][k][j][jj] = tmp_sample2;
  3245.    pcm_sample[6][k][j][jj] = c1 * (tmp_sample1 - tmp_sample2) - pcm_sample[5][k][j][jj];
  3246.    pcm_sample[1][k][j][jj] -= pcm_sample[6][k][j][jj];
  3247.    break;
  3248.   case 6:  pcm_sample[1][k][j][jj] -= pcm_sample[6][k][j][jj];
  3249.    tmp_sample1 = pcm_sample[2][k][j][jj];
  3250.    tmp_sample2 = pcm_sample[5][k][j][jj];
  3251.    pcm_sample[2][k][j][jj] = tmp_sample2;
  3252.    pcm_sample[5][k][j][jj] = c1 * (tmp_sample1 - tmp_sample2) - pcm_sample[6][k][j][jj];
  3253.    pcm_sample[0][k][j][jj] -= pcm_sample[5][k][j][jj];
  3254.    break;
  3255.   case 7:  tmp_sample1 = pcm_sample[1][k][j][jj];
  3256.    pcm_sample[1][k][j][jj] = pcm_sample[6][k][j][jj];
  3257.    pcm_sample[6][k][j][jj] = tmp_sample1 - pcm_sample[6][k][j][jj];
  3258.    tmp_sample1 = pcm_sample[2][k][j][jj];
  3259.    tmp_sample2 = pcm_sample[5][k][j][jj];
  3260.    pcm_sample[2][k][j][jj] = tmp_sample2;
  3261.    pcm_sample[5][k][j][jj] = c1 * (tmp_sample1 - tmp_sample2) - pcm_sample[6][k][j][jj];
  3262.    pcm_sample[0][k][j][jj] -= pcm_sample[5][k][j][jj];
  3263.    break;
  3264.   }
  3265. else if (info->aug_mtx_proc == 1)
  3266.   switch (tc_aug_alloc)
  3267.   {
  3268.   case 0:  pcm_sample[0][k][j][jj] -= pcm_sample[5][k][j][jj];
  3269.    pcm_sample[1][k][j][jj] -= pcm_sample[6][k][j][jj];
  3270.    break;
  3271.   case 1:  tmp_sample1 = pcm_sample[0][k][j][jj];
  3272.    pcm_sample[0][k][j][jj] = pcm_sample[5][k][j][jj];
  3273.    pcm_sample[5][k][j][jj] = tmp_sample1 - pcm_sample[5][k][j][jj];
  3274.    pcm_sample[1][k][j][jj] -= pcm_sample[6][k][j][jj];
  3275.    break;
  3276.   case 2:  pcm_sample[0][k][j][jj] -= pcm_sample[5][k][j][jj];
  3277.    tmp_sample2 = pcm_sample[1][k][j][jj];
  3278.    pcm_sample[1][k][j][jj] = pcm_sample[6][k][j][jj];
  3279.    pcm_sample[6][k][j][jj] = tmp_sample2 - pcm_sample[6][k][j][jj];
  3280.    break;
  3281.   case 3:  tmp_sample1 = pcm_sample[0][k][j][jj];
  3282.    pcm_sample[0][k][j][jj] = pcm_sample[5][k][j][jj];
  3283.    pcm_sample[5][k][j][jj] = tmp_sample1 - pcm_sample[5][k][j][jj];
  3284.    tmp_sample2 = pcm_sample[1][k][j][jj];
  3285.    pcm_sample[1][k][j][jj] = pcm_sample[6][k][j][jj];
  3286.    pcm_sample[6][k][j][jj] = tmp_sample2 - pcm_sample[6][k][j][jj];
  3287.    break;
  3288.   }
  3289.       }     /* for k < sblimit loop */
  3290.     }     /* for j < 3 loop */
  3291. }
  3294. void denormalizing_aug (double pcm_sample[7][SBLIMIT][3][12], frame_params *fr_ps)
  3295. {
  3296.   double c[7], d, denorm;   /* denormalization factors */
  3297.   int j, jj, k, l;
  3298.   layer *info = fr_ps->header;
  3300.   for (l = 0; l < 7; l++)
  3301.     c[l] = 1.0;
  3303.   switch(info->dematrix_procedure)
  3304.   {
  3305.     /* factors according to International Standard */
  3306.     case 0:
  3307.     case 2: c[2] = c[3] = c[4] = sqrt (2.0); /* unweigh factor for C, Ls and Rs */
  3308.     break;
  3309.     case 1: c[2] = sqrt (2.0); /* unweigh factor for C            */
  3310.     c[3] = c[4] = 2.0; /* unweigh factor for Ls, Rs       */
  3311.     break;
  3312.   }
  3314.   if (info->aug_mtx_proc == 0)
  3315.     /* factors according to 7-ch augmentation */
  3316.     c[5] = c[6] = 4.0 / 3; /* unweigh factor for LC, RC */
  3318.   /* denormalization factor */
  3319.   switch (info->dematrix_procedure * 10 + info->aug_mtx_proc)
  3320.   {
  3321.     case 00:
  3322.     case 20: denorm = 1.75 + 1.25 * sqrt (2.0);
  3323.      break;
  3324.     case 10: denorm = 2.25 + 0.75 * sqrt (2.0);
  3325.      break;
  3326.     case 30: denorm = 1.75;
  3327.      break;
  3328.     case 01:
  3329.     case 21: denorm = 2.0 + sqrt (2.0);
  3330.      break;
  3331.     case 11: denorm = 2.5 + 0.5 * sqrt (2.0);
  3332.      break;
  3333.     case 31: denorm = 2.0;
  3334.      break;
  3335.     case 03:
  3336.     case 23: denorm = 1.0 + sqrt (2.0);
  3337.      break;
  3338.     case 13: denorm = 1.5 + 0.5 * sqrt (2.0);
  3339.      break;
  3340.     case 33: denorm = 1.0;
  3341.      break;
  3342.   }
  3344.   for (l = 0; l < 7; l++)
  3345.     c[l] *= denorm;
  3347.   /* denormalizing */
  3348.   if (fr_ps->header->dematrix_procedure != 3 || fr_ps->header->aug_mtx_proc != 3)
  3349.     for (jj=0; jj<12; jj++)
  3350.       for( j = 0; j < 3; ++j)
  3351. for (k = 0; k < SBLIMIT; k ++)
  3352.   for (l = 0; l < 7; l++)
  3353.     pcm_sample[l][k][j][jj] *= c[l];
  3354. }
  3355. #endif