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

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

mpeg/mp3

开发平台：

C/C++

PREDISTO.C：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Multichannel Encoder
  4.  *
  5.  * $Id: predisto.c 1.6 1996/02/12 07:13:35 rowlands Exp $
  6.  *
  7.  * $Log: predisto.c $
  8.  * Revision 1.6  1996/02/12 07:13:35  rowlands
  9.  * Release following Munich meeting
  10.  *
  11.  * Revision 1.5  1996/02/12 05:51:17  rowlands
  12.  * Added verbosity switch to control text output.
  13.  * Fixed uninitialized variable d in subband_quantization_pre.
  14.  *
  15.  * Revision 1.3.2.1  1995/11/06  04:19:12  rowlands
  16.  * Received from Uwe Felderhoff (IRT)
  17.  *
  18.  * Revision 1.4  1995/08/14  08:06:01  tenkate
  19.  * ML-LSF added Warner ten Kate 7/8/95 (Philips)
  20.  * change alloc and sblimit into alloc_ml and sblimit_ml where appropriate
  21.  *
  22.  **********************************************************************/
  24.  /*********************************************************************
  25.  *                                                                    *
  26.  *                                                                    *
  27.  *  MPEG/audio Phase 2 coding/decoding multichannel                   *
  28.  *                                                                    *
  29.  *                                                                    *
  30.  *                                                                    *
  31.  *  Version 4.0    Susanne Ritscher, IRT Munich                       *
  32.  *                                                                    *
  33.  *  9/20/93        Implemented Prediction written by                  *
  34.  *                 Heiko Purnhagen,  Uni Hannover in                  *
  35.  *                 new source-file called prediction.c                *
  36.  *                                                                    *
  37.  *                                                                    *
  38.  *                                                                    *
  39.  *  version 4.1    Susanne Ritscher, IRT Munich                       *
  40.  *                                                                    *
  41.  *  9/20/93        channel-switching is only performed at a           *
  42.  *                 certain limit of TC_ALLOC dB, which is included    *
  43.  *                 in encoder.h                                       *
  44.  *                                                                    *
  45.  * 01/16/94        prediction will not work with trans._pat._errsig   *
  46.  *    Have to do a new strategy with a new bal for       *
  47.  *    the add. channels                                  *
  48.  *                                                                    *
  49.  * 04/08/94    started with predistortion                         *
  50.  *                                                                    *
  51.  * 06/28/94        started with predistortion according to the DIS    *
  52.  *    and the tc_table                                   *
  53.  *                                                                    *
  54.  *                                                                    *
  55.  *  version 5.0    Susanne Ritscher,  IRT Munich                      *
  56.  *                                                                    *
  57.  *  7/12/94        bitstream according to DIS                         *
  58.  *                 extension bitstream is working                     *
  59.  *                 predistortion is working                           *
  60.  *                                                                    *
  61.  *  Version 1.1                                                       *
  62.  *                                                                    *
  63.  *  02/23/95    Susanne Ritscher,  IRT Munich                      *
  64.  *                 corrected some bugs                                *
  65.  *                 extension bitstream is working                     *
  66.  *                                                                    *
  67.  *  Version 2.0                                                       *
  68.  *                                                                    *
  69.  *  01/28/97       Frans de Bont, Philips Sound & Vision, Eindhoven   *
  70.  *     - dynamic crosstalk working for all configurations*
  71.  *     - prediction working for all configurations       *
  72.  *     - extension bitstream fixed       *
  73.  *     - fully compliant to DIS 13818-3.2                *
  74.  *                                                                    *       *     
  75.  *********************************************************************/ 
  77. /**********************************************************************
  78.  * 
  79.  *  This program computes the predistortion.
  80.  *  The three additional channels are AFTER THE BITALLOCATION
  81.  *  quantized and dequantized. With these dequantized samples
  82.  *  the frontchannels are matriced again in order to dematrice them in a
  83.  *  more exact way. This should improve the quality of matriced signals.
  84.  * 
  85.  *  In case of prediction the whole process of decoding predicted signals
  86.  *  is worked off????
  87.  * 
  88.  **************************************************************************/
  89. #include "common.h"
  90. #include "encoder.h"
  93. void predistortion(double (*sb_sample)[3][12][32], unsigned int (*scalar)[3][32], 
  94.     unsigned int (*bit_alloc)[32], unsigned int (*subband)[3][12][32], 
  95.     frame_params *fr_ps, double (*perm_smr)[32], unsigned int (*scfsi)[32], 
  96.     int *adb, unsigned int (*scfsi_dyn)[32])
  97. {
  98.     double sbs_sample[7][3][12][SBLIMIT];  /*predistortion*/
  99.     int l, m, i, n, k;
  100.     int sblimit;
  101.     int ch, gr, sb;
  102.     int ad;
  103.     sblimit = fr_ps->sblimit;
  104.     l = 2; m = 7;
  105.     
  106.     pre_quant(sbs_sample, l, m, sb_sample, scalar, bit_alloc, subband, fr_ps);
  107.     
  108.     matri(sbs_sample, fr_ps, sb_sample, scalar, sblimit, scfsi, scfsi_dyn,
  109.           bit_alloc, subband);
  111.     l = 0; m = 2;
  112.     
  113.     /*II_scale_factor_calc(sb_sample,scalar,sblimit, l, m);*/
  114.     trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  115.       
  116.     bit_all(perm_smr, scfsi, bit_alloc, adb, fr_ps);
  117. }
  127. static double snr[18] = { 0.00,  6.03, 11.80, 15.81, /* 0, 3, 5, 7 */
  128.  19.03, 23.50, 29.82, 35.99, /* 9,15,31,63 */
  129.  42.08, 48.13, 54.17, 60.20, /* 127, ...   */
  130.  66.22, 72.25, 78.27, 84.29, /* 2047, ...  */
  131.  90.31, 96.33};              /* 16383, ... */
  134. /* Multilingual TEST 17/03/1995 JMZ */
  135. int bit_all(double (*perm_smr)[32], unsigned int (*scfsi)[32], unsigned int (*bit_alloc)[32], int *adb, frame_params *fr_ps)
  136.                               /* minimum masking level */
  138. /* bit_all() recalculates allocation for compatible signals Lo and Ro */
  139. /* which are channels k==0 and k==1. This recalculation is performed  */
  140. /* because of signal modifications by predistortion.                  */
  141. /* WtK 7/8/95. Information from SR.                                   */
  142.          
  143.                     
  144. {
  145.     int n_ml_ch = fr_ps->header->multiling_ch;  /*JMZ 17/03/95 Multilingual */
  146.     int i, min_ch, min_sb, oth_ch, k, increment, scale, seli, ba, j, l;
  147.     int adb_hlp, adb_hlp1, adb_hlp2;
  148.     int bspl, bscf, bsel, ad, noisy_sbs;
  149.     int bspl_mpg1, bscf_mpg1, bsel_mpg1;
  150.     double mnr[14][SBLIMIT], small; /*JMZ 17/03/95 Multilingual */
  151.     char used[14][SBLIMIT]; /*JMZ 17/03/95 Multilingual */
  152.     int stereo = fr_ps->stereo;
  153.     int stereomc = fr_ps->stereomc;
  154.     int stereoaug = fr_ps->stereoaug;
  155.     int sblimit = fr_ps->sblimit;
  156.     int sblimit_mc = fr_ps->sblimit_mc;
  157.     int sblimit_ml = fr_ps->sblimit_ml;
  159.     int jsbound = fr_ps->jsbound;
  160.     al_table *alloc = fr_ps->alloc;
  161.     al_table *alloc_mc = fr_ps->alloc_mc;
  162.     al_table *alloc_ml = fr_ps->alloc_ml;
  164.     double dynsmr = 0.0;  /* border of SMR for dynamic datarate */
  165.     static char init= 0;
  166.     static int banc, berr;
  167.     int bbal, bancmc, pred, bancext, bbal_mpg1;
  168.     int ll, pci, adb_mpg1;
  169.     int bits = 0; /*bits already used for the front-channels*/
  170.     static int sfsPerScfsi[] = { 3,2,1,2 };    /* lookup # sfs per scfsi */
  171.     
  172.     banc = 32; /* banc: bits for header */;
  173.     /* 960627 FdB reserve extra bits wrt bugs */
  174.     banc += 200;
  176.     if (fr_ps->header->error_protection)
  177. berr = 16;
  178.     else
  179. berr = 0; /* added 92-08-11 shn */
  181.     pred = 0;
  182.     bancmc = 0;
  183.     bancext = 0;
  184.     bbal = 0;
  185.     bbal_mpg1 = 0;
  186.     adb_mpg1 = bitrate[fr_ps->header->lay-1][fr_ps->header->bitrate_index] * 24;
  188. #ifdef DEBUG
  189. if (verbosity >= 3) printf("stereo+stereomc+stereoaug+n_ml_ch=%dn", stereo+stereomc+stereoaug+n_ml_ch);
  190. #endif 
  192.     if (fr_ps->header->mode == MPG_MD_STEREO)
  193.     {
  194. for (i = 0; i < sblimit; ++i)
  195.     bbal += (stereo) * (*alloc)[i][0].bits;
  196. for (i = 0; i < sblimit_mc; ++i)
  197.     bbal += (stereomc+stereoaug) * (*alloc)[i][0].bits;
  198. for (i = 0; i < sblimit_ml; ++i)
  199.     bbal += (n_ml_ch) * (*alloc_ml)[i][0].bits;
  200.     }  
  201.     if (fr_ps->header->mode == MPG_MD_JOINT_STEREO)
  202.     {
  203. for (i = 0; i < jsbound; ++i)
  204.     bbal += (stereo) * (*alloc)[i][0].bits;
  205. for (i = jsbound; i < sblimit; ++i)
  206.     bbal += (stereo-1) * (*alloc)[i][0].bits;
  207. for (i = 0; i < sblimit_mc; ++i)
  208.     bbal += (stereomc+stereoaug) * (*alloc)[i][0].bits;
  209. for (i = 0; i < sblimit_ml; ++i)
  210.     bbal += (n_ml_ch) * (*alloc_ml)[i][0].bits;
  211.     }
  213.     if (fr_ps->header->center == 3) bbal -= 41; 
  215.     if (fr_ps->header->ext_bit_stream_present == 0)
  216. bancmc += 35;      /* mc_header + crc + tc_sbgr_select+ dyn_cross_on + 
  217.       mc_prediction_on  01/05/94,  SR  new! 05/04/94,  SR*/
  218.     else
  219.     {
  220. bancmc += 43;     
  221. bancext = 40;
  222.     }
  223.            
  224.     if (fr_ps->header->tc_sbgr_select == 0)
  225. bancmc += 36;
  226.     else
  227. bancmc += 3;
  229.     if (fr_ps->header->dyn_cross_on == 1)
  230. bancmc += 49;      /* now with dyn_cross_LR,  505/04/94,  SR*/
  232.     if (fr_ps->header->mc_prediction_on == 1)
  233.     {
  234. for (i = 0; i < 8; i++)   /*now only 8 sb_groups, 05/04/94, SR*/
  235. {
  236.     bancmc += 1;
  237.     if (fr_ps->header->mc_pred[i] == 1)
  238. bancmc += n_pred_coef[fr_ps->header->dyn_cross[i]] * 2;
  239. }
  241. for (i = 0; i < 8; i++) 
  242.     if (fr_ps->header->mc_pred[i] == 1)
  243. for (j = 0; j < n_pred_coef[fr_ps->header->dyn_cross[i]]; j++)
  244.     if (fr_ps->header->predsi[i][j] != 0)
  245.     {
  246. pred += 3;
  247. for (pci = 0; pci < fr_ps->header->predsi[i][j]; pci++)
  248.     pred += 8;
  249.     }
  250.     }  
  253.     for (l = 0; l < sblimit; l++)
  254. for (k = 0; k < 2; k++)
  255.     used[k][l] = 0;
  256.     
  257.     for (l = 0; l < SBLIMIT; l++)   /* searching for the sb min SMR */
  258.     {
  259. i = sbgrp[l];
  261. for (j = stereo; j < stereo+stereomc+stereoaug; j++)
  262.     if ((j < stereo && l < sblimit) ||
  263. (j >= stereo && l < sblimit_mc))
  264.     {
  265. /* k = transmission_channel5[fr_ps->header->tc_alloc[i]][j]; */
  266.    k = transmission_channel (fr_ps, i, j);
  268. if (j < stereo)
  269.     bits += 12 * ((*alloc)[l][bit_alloc[k][l]].group *
  270.   (*alloc)[l][bit_alloc[k][l]].bits);
  271. else if (j < 7 || n_ml_ch == 0) /* Multichannel */ 
  272.     bits += 12 * ((*alloc_mc)[l][bit_alloc[k][l]].group *
  273.   (*alloc_mc)[l][bit_alloc[k][l]].bits);
  274. else /* MultiLingual */ 
  275.     bits += 12 * ((*alloc_ml)[l][bit_alloc[k][l]].group *
  276.   (*alloc_ml)[l][bit_alloc[k][l]].bits);
  278. if (bit_alloc[k][l] != 0)
  279. {
  280.     bits += 2;
  281.     switch (scfsi[k][l])
  282.     {
  283. case 0: bits += 18; break;
  284. case 1: bits += 12; break;
  285. case 2: bits += 6; break;
  286. case 3: bits += 12; break;
  287.     }   
  288. }
  289.     }
  290.     }
  292.     for (i = 0; i < 12; i++)
  293.     {
  294. if ((fr_ps->header->tc_alloc[i] == 1) || (fr_ps->header->tc_alloc[i] == 7))
  295. {
  296.     bits += 12 * ((*alloc)[l][bit_alloc[0][l]].group *
  297.   (*alloc)[l][bit_alloc[0][l]].bits);
  298.     if (bit_alloc[0][l] != 0)
  299.     {
  300. bits += 2;
  301. switch(scfsi[0][l])
  302. {
  303.     case 0: bits += 18; break;
  304.     case 1: bits += 12; break;
  305.     case 2: bits += 6; break;
  306.     case 3: bits += 12; break;
  307. }   
  308.     }
  309.     used[0][l] = 2;
  310. }
  312. if ((fr_ps->header->tc_alloc[i] == 2) || (fr_ps->header->tc_alloc[i] == 6))
  313. {
  314.     bits += 12 * ((*alloc)[l][bit_alloc[1][l]].group *
  315.   (*alloc)[l][bit_alloc[1][l]].bits);
  316.     if (bit_alloc[1][l] != 0)
  317.     {
  318. bits += 2;
  319. switch(scfsi[1][l])
  320. {
  321.     case 0: bits += 18; break;
  322.     case 1: bits += 12; break;
  323.     case 2: bits += 6; break;
  324.     case 3: bits += 12; break;
  325. }   
  326.     }
  327.     used[1][l] = 2;
  328. }
  329.     }   
  331.      if(fr_ps->header->ext_bit_stream_present == 0)    
  332.     *adb -= bbal + berr + banc + bancmc + pred + bits;
  333. else
  334. {
  335.     *adb = *adb - bbal - berr - banc - bancmc - pred - bits - 
  336.     bancext - (fr_ps->header->n_ad_bytes * 8);
  337.     for(i = 0; i < sblimit; ++i)
  338.  bbal_mpg1 += 2 * (*alloc)[i][0].bits;
  339.     adb_mpg1 -= bbal_mpg1 + berr + banc + bancmc +
  340.      (fr_ps->header->n_ad_bytes * 8);
  341.  }   
  342.         ad = *adb;
  343.  
  344.     for(l = 0;l < sblimit; l++)
  345.     {
  346. for( k = 0; k < 2; k++)
  347. {
  348. mnr[k][l]=snr[0]-perm_smr[k][l];
  349. if(used[k][l] == 0)
  350.         bit_alloc[k][l] = 0;
  351. }
  352.     }
  353.    
  354. /********************************************************************/
  355. /* JMZ 08/03/1995 Multilingual */  
  357. for (i = 0; i < sblimit_ml; i++) 
  358. for (k = 7; k < 7+n_ml_ch; k++) 
  359. {
  360. mnr[k][i]=snr[0]-perm_smr[k][i];
  361.  /* mask-to-noise-level = signal-to-noise-level - minimum-masking-*/
  362.  /* threshold*/
  364. bit_alloc[k][i] = 0;
  365. used[k][i] = 0;
  366. }
  368. /* JMZ 08/03/1995 Multilingual */   
  369. /********************************************************************/
  370.    
  371.    
  372.    
  373. bspl = bscf = bsel = bspl_mpg1 = bscf_mpg1 = bsel_mpg1 = 0;
  374.  
  375.     do  {
  376. small = 999999.0;
  377. min_sb = -1;
  378. min_ch = -1;
  381.         for(i = 0; i < sblimit; i++)
  382. {
  383.      for( k = 0; k < 2; k++)
  384. {
  385.     if ((used[k][i] != 2) && (small > mnr[k][i])) 
  386.     {
  387. small = mnr[k][i];
  388. min_sb = i;  min_ch = k;
  389.     }
  390. }  
  391.  }
  392.  
  393. /******************************************************************/
  394. /* Multilingual JMZ 08/03/1995 */
  396. if(n_ml_ch >0)
  397. {
  398. for (i = 0; i < sblimit_ml; i++)
  399.   for(j = 7; j < (n_ml_ch+7); ++j)
  400.   {
  401.      k=j;
  402.      if ((used[k][i] != 2) && (small > mnr[k][i])) 
  403.      {
  404.                   small = mnr[k][i];
  405.                   min_sb = i;  min_ch = k;
  406.      }
  407. }
  408. }
  410. /* Multilingual JMZ 08/03/1995 */
  411. /******************************************************************/
  413.  
  414.      if(min_sb > -1) 
  415.      { 
  416.        if (min_ch < stereo) 
  417.        {
  418.  increment = 12 * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb]+1].group * 
  419.              (*alloc)[min_sb][bit_alloc[min_ch][min_sb]+1].bits);
  420.      /* how many bits are needed */
  421.          if (used[min_ch][min_sb])
  422.           increment -= 12 * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb]].group * 
  423.                             (*alloc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
  424.        } 
  425.        else if (min_ch < 7 || n_ml_ch == 0) /* Multichannel */ 
  426.        {
  427.  increment = 12 * ((*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]+1].group * 
  428.              (*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]+1].bits);
  429.      /* how many bits are needed */
  430.          if (used[min_ch][min_sb])
  431.           increment -= 12 * ((*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]].group * 
  432.                             (*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
  433.        } 
  434.        else /* MultiLingual 7/8/95 WtK */ 
  435.        {
  436.   increment   = ((*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]+1].group * 
  437.  (*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]+1].bits);
  438.   if (used[min_ch][min_sb])
  439.    increment -= ((*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]].group * 
  440.  (*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]].bits);
  441.   if (fr_ps->header->multiling_fs==1) increment *=  6;
  442.   else                                increment *= 12;
  443.        }
  445.        /* scale factor bits required for subband [min] */
  446.        if (used[min_ch][min_sb]) scale = seli = 0;
  447.        else 
  448.        {   /* this channel had no bits or scfs before */
  449.          seli = 2;
  450.          scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
  451. }
  453.        if(fr_ps->header->ext_bit_stream_present == 1)
  454.        {
  455. if (adb_mpg1 > bspl_mpg1 + bscf_mpg1 + bsel_mpg1 + seli + scale + increment) 
  456. {
  457.    bspl_mpg1 += increment;  /* bits for subband sample */
  458.    bscf_mpg1 += scale;      /* bits for scale factor */
  459.    bsel_mpg1 += seli;       /* bits for scfsi code */
  460. }
  461. else
  462.    used[min_ch][min_sb] = 2;  /* can't increase this alloc */
  463.        }
  465.        
  466.        if ((ad > bspl + bscf + bsel + seli + scale + increment) && (used[min_ch][min_sb] != 2)) 
  467.        {
  468.     ba = ++bit_alloc[min_ch][min_sb]; /* next up alloc */
  469.     bspl += increment;     /* bits for subband sample */
  470.     bscf += scale;     /* bits for scale factor */
  471.     bsel += seli;     /* bits for scfsi code */
  472.     used[min_ch][min_sb] = 1;     /* subband has bits */
  473.     if (min_ch<7)
  474.       mnr[min_ch][min_sb] = -perm_smr[min_ch][min_sb] +
  475.     snr[(*alloc)[min_sb][ba].quant+1];
  476.     else
  477.       mnr[min_ch][min_sb] = -perm_smr[min_ch][min_sb] +
  478.     snr[(*alloc_ml)[min_sb][ba].quant+1];
  479.     
  480.     /* Check if subband has been fully allocated max bits */
  481.     if (min_ch < stereo) 
  482.     {
  483.      if (ba >= (1<<(*alloc)[min_sb][0].bits)-1) used[min_ch][min_sb] = 2;
  484.     } 
  485.     else if (min_ch < 7 || n_ml_ch == 0) /* Multichannel */ 
  486.     {
  487.      if (ba >= (1<<(*alloc_mc)[min_sb][0].bits)-1) used[min_ch][min_sb] = 2;
  488.     } 
  489.     else 
  490.     {
  491.      if (ba >= (1<<(*alloc_ml)[min_sb][0].bits)-1) used[min_ch][min_sb] = 2;
  492.     }
  493. }
  494. else used[min_ch][min_sb] = 2;  /* can't increase this alloc */
  496.       }   /* end of if-loop if min_sb >-1 */
  497.    } while(min_sb > -1);   /* until could find no channel */
  498.    /* Calculate the number of bits left */
  500.    ad -= bspl+bscf+bsel; 
  501.    *adb = ad;
  502.    for (i=sblimit;i<SBLIMIT;i++) for (k = 0; k < 2; k++) 
  503.       bit_alloc[k][i]=0;
  504.    for (i=sblimit_ml;i<SBLIMIT;i++) for (k = 7; k < 7+n_ml_ch; k++) 
  505.       bit_alloc[k][i]=0;
  506. }
  507.  
  509. void matri(double (*sbs_sample)[3][12][32], frame_params *fr_ps, double (*sb_sample)[3][12][32],
  510.  unsigned int (*scalar)[3][32], int sblimit, unsigned int (*scfsi)[32], 
  511.  unsigned int (*scfsi_dyn)[32], unsigned int (*bit_alloc)[32], 
  512.  unsigned int (*subband)[3][12][32])
  513. {
  514.   int i, j, k, l, ch1, ch2, m, n;
  515.   
  516.   layer *info = fr_ps->header;
  518. for(k = 0; k < 8; k++)
  519. {
  520.           if(fr_ps->header->mc_pred[k] == 0)
  521.   {
  522.     switch(fr_ps->header->tc_alloc[k])
  523.     {
  524. case 0: 
  525.       for( j = 0; j < 3; ++j)
  526. for(l = 0; l < 12; l ++)
  527. {
  528. sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  529. sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  530. }
  531. m = 0; n = 2;
  532. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  533.      break;
  534. case 1:
  535.       for( j = 0; j < 3; ++j)
  536. for(l = 0; l < 12; l ++)
  537. {
  538. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  539. }
  541. m = 0; n = 1;
  542. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  543. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  544. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  546.       for( j = 0; j < 3; ++j)
  547. for(l = 0; l < 12; l ++)
  548. {
  549. sbs_sample[2][j][l][k] = sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] - sbs_sample[3][j][l][k];
  550. sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  551. }
  552. m = 1; n = 2;
  553. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  555.      break;
  556. case 2:
  557.       for( j = 0; j < 3; ++j)
  558. for(l = 0; l < 12; l ++)
  559. {
  560. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  561. }
  563. m = 1; n = 2;
  564. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  565. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  566. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  568.       for( j = 0; j < 3; ++j)
  569. for(l = 0; l < 12; l ++)
  570. {
  571. sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
  572. sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  573. }
  574. m = 0; n = 1;
  575. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  577.      break;
  578. case 3: 
  579.       for( j = 0; j < 3; ++j)
  580. for(l = 0; l < 12; l ++)
  581. {
  582. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
  583. sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  584. }
  585. m = 0; n = 2;
  586. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  587.      break;
  588. case 4: 
  589.       for( j = 0; j < 3; ++j)
  590. for(l = 0; l < 12; l ++)
  591. {
  592. sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  593. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
  594. }
  595. m = 0; n = 2;
  596. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  597.      break;
  598. case 5: 
  599.       for( j = 0; j < 3; ++j)
  600. for(l = 0; l < 12; l ++)
  601. {
  602. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
  603. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
  604. }
  605. m = 0; n = 2;
  606. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  607.      break;
  608. case 6:
  609.       for( j = 0; j < 3; ++j)
  610. for(l = 0; l < 12; l ++)
  611. {
  612. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  613. }
  615. m = 1; n = 2;
  616. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  617. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  618. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  620.       for( j = 0; j < 3; ++j)
  621. for(l = 0; l < 12; l ++)
  622. {
  623. sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
  624. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
  625. }
  626. m = 0; n = 1;
  627. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  629.      break;
  630. case 7:
  631.       for( j = 0; j < 3; ++j)
  632. for(l = 0; l < 12; l ++)
  633. {
  634. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  635. }
  637. m = 0; n = 1;
  638. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  639. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  640. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  642.       for( j = 0; j < 3; ++j)
  643. for(l = 0; l < 12; l ++)
  644. {
  645. sbs_sample[2][j][l][k] = sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] - sbs_sample[3][j][l][k];
  646. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
  647. }
  648. m = 1; n = 2;
  649. scale_factor_calc(scalar,sblimit, m, n, k, sb_sample);
  651.      break;
  652.     }
  653.   }
  654. } 
  656. for(i = 8; i < 12; i++)
  657. {
  658.           if(fr_ps->header->mc_pred[k] == 0)
  659.   {
  660.     switch(fr_ps->header->tc_alloc[i])
  661.     {
  662. case 0: 
  663.       for( j = 0; j < 3; ++j)
  664. for(l = 0; l < 12; l ++)
  665.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  666.     {
  667. sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  668. sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  669.     }
  670.  m = 0; n = 2;    
  671.  scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  672.      break;
  673. case 1:
  674.       for( j = 0; j < 3; ++j)
  675. for(l = 0; l < 12; l ++)
  676.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  677.     {
  678. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  679.     }
  681. m = 0; n = 1;
  682. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  683. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  684. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  686.       for( j = 0; j < 3; ++j)
  687. for(l = 0; l < 12; l ++)
  688.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  689.     {
  690. sbs_sample[2][j][l][k] = sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] - sbs_sample[3][j][l][k];
  691. sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  692.     }
  693. m = 1; n = 2;
  694. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  695.      break;
  696. case 2:
  697.       for( j = 0; j < 3; ++j)
  698. for(l = 0; l < 12; l ++)
  699.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  700.     {
  701. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  702.     }
  704. m = 1; n = 2;
  705. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  706. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  707. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  709.       for( j = 0; j < 3; ++j)
  710. for(l = 0; l < 12; l ++)
  711.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  712.     {
  713. sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
  714. sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  715.     }
  716. m = 0; n = 1;
  717. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  718.     
  719.      break;
  720. case 3: 
  721.       for( j = 0; j < 3; ++j)
  722. for(l = 0; l < 12; l ++)
  723.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  724.     {
  725. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
  726. sb_sample[1][j][l][k] = sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  727.     }
  728. m = 0; n = 2;
  729. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  730.      break;
  731. case 4: 
  732.       for( j = 0; j < 3; ++j)
  733. for(l = 0; l < 12; l ++)
  734.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  735.     {
  736. sb_sample[0][j][l][k] = sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  737. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
  738.     }
  739. m = 0; n = 2;
  740. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  741.      break;
  742. case 5: 
  743.       for( j = 0; j < 3; ++j)
  744. for(l = 0; l < 12; l ++)
  745.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  746.     {
  747. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
  748. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
  749.     }
  750. m = 0; n = 2;
  751. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  752.      break;
  753. case 6:
  754.       for( j = 0; j < 3; ++j)
  755. for(l = 0; l < 12; l ++)
  756.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  757.     {
  758. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[4][j][l][k];
  759.     }
  761. m = 1; n = 2;
  762. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  763. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  764. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  766.       for( j = 0; j < 3; ++j)
  767. for(l = 0; l < 12; l ++)
  768.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  769.     {
  770. sbs_sample[2][j][l][k] = sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] - sbs_sample[4][j][l][k];
  771. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[3][j][l][k];
  772.     }
  773. m = 0; n = 1;
  774. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  776.      break;
  777. case 7:
  778.       for( j = 0; j < 3; ++j)
  779. for(l = 0; l < 12; l ++)
  780.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  781.     {
  782. sb_sample[0][j][l][k] = sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] + sbs_sample[3][j][l][k];
  783.     }
  785. m = 0; n = 1;
  786. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  787. trans_pattern(scalar, scfsi, fr_ps,scfsi_dyn);
  788. pre_quant(sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband, fr_ps);
  790.       for( j = 0; j < 3; ++j)
  791. for(l = 0; l < 12; l ++)
  792.     for( k = sb_groups[i-1] + 1; k <= sb_groups[i]; k++)
  793.     {
  794. sbs_sample[2][j][l][k] = sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] - sbs_sample[3][j][l][k];
  795. sb_sample[1][j][l][k] = sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] + sb_sample[4][j][l][k];
  796.     }
  797. m = 1; n = 2;
  798. scale_factor_calc(scalar,sblimit, m, n, i, sb_sample);
  800.      break;
  801.     }
  802.   }
  803. }
  804.  }
  809. buffer_sample(unsigned int (*keep_it)[36][32], unsigned int (*sample)[3][32], unsigned int (*bit_alloc)[32], frame_params *fr_ps, int l, int z, int q)
  810. {
  811.    int i,j,k,m;
  812.    int stereo = fr_ps->stereo;
  813.    int sblimit = fr_ps->sblimit;
  814.    int jsbound = fr_ps->jsbound;
  815.    al_table *alloc = fr_ps->alloc;
  816.    unsigned int x;
  818.    for (i=0;i<sblimit;i++) for (j= l;j<((i<jsbound)?z:l+1);j++) 
  819.    {
  820.        if (bit_alloc[j][i]) 
  821.        {
  822.          /* check for grouping in subband */
  823.  /* if ((*alloc)[i][bit_alloc[j][i]].group==3)*/
  824.            for (m=0;m<3;m++) 
  825.    {
  826.               sample[j][m][i] = keep_it[j][q*3+m][i];
  827.            }         
  828.        }
  829.        else 
  830.        {      /* for no sample transmitted */
  831.          for (k=0;k<3;k++) sample[j][k][i] = 0;
  832.        }
  833.        if(stereo == 2 && i>= jsbound)  /* joint stereo : copy L to R */
  834.           for (k=0;k<3;k++) sample[1][k][i] = sample[0][k][i];
  835.    }
  836.    for (i=sblimit;i<SBLIMIT;i++) for (j= l;j< z;j++) for (k=0;k<3;k++)
  837.       sample[j][k][i] = 0;
  838. }      
  842. static double a[17] = {
  843.   0.750000000, 0.625000000, 0.875000000, 0.562500000, 0.937500000,
  844.   0.968750000, 0.984375000, 0.992187500, 0.996093750, 0.998046875,
  845.   0.999023438, 0.999511719, 0.999755859, 0.999877930, 0.999938965,
  846.   0.999969482, 0.999984741 };
  847.  
  848. static double b[17] = {
  849.   -0.250000000, -0.375000000, -0.125000000, -0.437500000, -0.062500000,
  850.   -0.031250000, -0.015625000, -0.007812500, -0.003906250, -0.001953125,
  851.   -0.000976563, -0.000488281, -0.000244141, -0.000122070, -0.000061035,
  852.   -0.000030518, -0.000015259 };
  853.  
  856. void subband_quantization_pre(unsigned int (*scalar)[3][32], double (*sb_samples)[3][12][32], unsigned int (*bit_alloc)[32], unsigned int (*sbband)[3][12][32], frame_params *fr_ps, int ch1, int ch2)
  857. {
  858.    int i, j, k, s, n, qnt, sig, m, l, ll, z;
  859.    int stereo = fr_ps->stereo;
  860.    int stereomc = fr_ps->stereomc;
  861.    int sblimit = fr_ps->sblimit;
  862.    unsigned int stps, y;
  863.    double d;
  864.    al_table *alloc = fr_ps->alloc;
  866.  
  868.    for (s=0;s<3;s++)
  869.      for (j=0;j<12;j= j+3)
  870. for (i=0;i<sblimit;i++)
  871.   for(k = ch1; k < ch2; k++)
  872.   {
  873.     for(z = 0; z < 3; z ++)
  874.     {
  875.     if(bit_alloc[k][i])
  876.                d = sb_samples[k][s][j+z][i] / multiple[scalar[k][s][i]];
  877.     else
  878.        d = 0;
  879.    
  880.    
  881.     if (mod(d) >= 1.0) /* > changed to >=, 1992-11-06 shn */
  882.     {
  883. printf("In predistortion, not scaled properly, %d %d %d %dn",k,s,j+z,i);
  884. printf("Value %1.10fn",sb_samples[k][s][j+z][i]);
  885.     }
  886.     qnt = (*alloc)[i][bit_alloc[k][i]].quant;
  887.             d = d * a[qnt] + b[qnt];
  888.              /* extract MSB N-1 bits from the floating point sample */
  889.              if (d >= 0) sig = 1;
  890.              else { sig = 0; d += 1.0; }
  891.              n = 0;
  892. #ifndef MS_DOS
  893.              stps = (*alloc)[i][bit_alloc[k][i]].steps;
  894.              while ((1L<<n) < stps) n++;
  895. #else
  896.              while  ( ( (unsigned long)(1L<<(long)n) <
  897.                  ((unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)
  898.                           & 0xffff
  899.                          )
  900.                       ) && ( n <16)
  901.                     ) n++;
  902. #endif
  903.              n--;
  904.              sbband[k][s][j+z][i] = (unsigned int) (d * (double) (1L<<n));
  905.              /* tag the inverted sign bit to sbband at position N */
  906.              /* The bit inversion is a must for grouping with 3,5,9 steps
  907.                 so it is done for all subbands */
  908.              if (sig) sbband[k][s][j+z][i] |= 1<<n;
  909.      
  910.      if(!bit_alloc[k][i]) sbband[k][s][j+z][i] = 0;
  911.     }
  913. /*try try try ! 7/7/94 */
  915. /*             if ((*alloc)[i][bit_alloc[k][i]].group != 3) 
  916.      {
  917.                y =(*alloc)[i][bit_alloc[k][i]].steps;
  918.                sbband[k][s][j][i] = sbband[k][s][j][i] +
  919.                            sbband[k][s][j+1][i] * y +
  920.                                     sbband[k][s][j+2][i] * y * y;
  921.                sbband[k][s][j+1][i] = sbband[k][s][j][i];
  922.                sbband[k][s][j+2][i] = sbband[k][s][j][i];
  923.       }*/
  925.      
  926.      
  927.  }
  928.            for (s=0;s<3;s++)
  929.              for (j=sblimit;j<SBLIMIT;j++)
  930. for (i=0;i<12;i++) for (k = 0; k < 7; k++) sbband[k][s][i][j] = 0;
  931. }
  938. void trans_pattern(unsigned int (*scalar)[3][32], unsigned int (*scfsi)[32], frame_params *fr_ps, unsigned int (*scfsi_dyn)[32])
  939. {
  940.    int stereo  = fr_ps->stereo;
  941.    int stereomc = fr_ps->stereomc;
  942.    int sblimit = fr_ps->sblimit;
  943. int dscf[2];
  944. int class[2],i,j,k;
  945. static int pattern[5][5] = {0x123, 0x122, 0x122, 0x133, 0x123,
  946.                             0x113, 0x111, 0x111, 0x444, 0x113,
  947.                             0x111, 0x111, 0x111, 0x333, 0x113,
  948.                             0x222, 0x222, 0x222, 0x333, 0x123,
  949.                             0x123, 0x122, 0x122, 0x133, 0x123};
  950.  
  951.   for (k = 0; k < 2; k++)
  952.      for (i=0;i<sblimit;i++) 
  953.      {
  954.        dscf[0] =  (scalar[k][0][i]-scalar[k][1][i]);
  955.        dscf[1] =  (scalar[k][1][i]-scalar[k][2][i]);
  956.        for (j=0;j<2;j++)
  957.        {
  958.          if (dscf[j]<=-3) class[j] = 0;
  959.          else if (dscf[j] > -3 && dscf[j] <0) class[j] = 1;
  960.               else if (dscf[j] == 0) class[j] = 2;
  961.                    else if (dscf[j] > 0 && dscf[j] < 3) class[j] = 3;
  962.                         else class[j] = 4;
  963.        }
  964.        switch (pattern[class[0]][class[1]]) 
  965.        {
  966.          case 0x123 :    scfsi[k][i] = 0;
  967.                          break;
  968.          case 0x122 :    scfsi[k][i] = 3;
  969.                          scalar[k][2][i] = scalar[k][1][i];
  970.                          break;
  971.          case 0x133 :    scfsi[k][i] = 3;
  972.                          scalar[k][1][i] = scalar[k][2][i];
  973.                          break;
  974.          case 0x113 :    scfsi[k][i] = 1;
  975.                          scalar[k][1][i] = scalar[k][0][i];
  976.                          break;
  977.          case 0x111 :    scfsi[k][i] = 2;
  978.                          scalar[k][1][i] = scalar[k][2][i] = scalar[k][0][i];
  979.                          break;
  980.          case 0x222 :    scfsi[k][i] = 2;
  981.                          scalar[k][0][i] = scalar[k][2][i] = scalar[k][1][i];
  982.                          break;
  983.          case 0x333 :    scfsi[k][i] = 2;
  984.                          scalar[k][0][i] = scalar[k][1][i] = scalar[k][2][i];
  985.                          break;
  986.          case 0x444 :    scfsi[k][i] = 2;
  987.                          if (scalar[k][0][i] > scalar[k][2][i])
  988.                               scalar[k][0][i] = scalar[k][2][i];
  989.                          scalar[k][1][i] = scalar[k][2][i] = scalar[k][0][i];
  990.    
  991. }
  992.     }
  993. }        
  999. void pre_quant(double (*sbs_sample)[3][12][32], int l, int m, double (*sb_sample)[3][12][32], 
  1000. unsigned int (*scalar)[3][32], unsigned int (*bit_alloc)[32], 
  1001. unsigned int (*subband)[3][12][32], frame_params *fr_ps)
  1002. {
  1003.     double sb_pre_sample[7][3][12][SBLIMIT];  /*predistortion*/
  1004.     unsigned int sample[7][3][SBLIMIT];
  1005.     unsigned int keep_it[7][36][SBLIMIT];
  1006.     int ch, sb, gr, i;
  1007.     int hi,  hu;
  1009.     subband_quantization_pre(scalar, sb_sample, bit_alloc, subband, fr_ps, l, m);
  1012.     for (ch = l; ch < m; ch++)
  1013.       for (sb = 0; sb < SBLIMIT; sb++)
  1014. for (gr = 0; gr < 3; gr++)
  1015.     for (i = 0; i < 12; i++)
  1016. keep_it[ch][i+gr*12][sb] = subband[ch][gr][i][sb];
  1018. for(i = 0; i < 12; i++) 
  1019. {      
  1020.     buffer_sample(keep_it,sample,bit_alloc,fr_ps, l, m, i);
  1022.     II_dequantize_sample(sample, bit_alloc, sb_pre_sample, fr_ps, l, m, i);
  1023.     II_denormalize_sample(sb_pre_sample, scalar, fr_ps, i>>2, l, m, i);
  1024.         }           
  1026.     for (ch = l; ch < m; ch++)
  1027.       for (sb=0;sb<SBLIMIT;sb++)
  1028. for (i = 0; i < 4; i++)
  1029.     for (gr=0;gr<3;gr++)
  1030. sbs_sample[ch][0][i*3 + gr][sb] = sb_pre_sample[ch][gr][i][sb];
  1032.     for (ch = l; ch < m; ch++)
  1033.       for (sb=0;sb<SBLIMIT;sb++)
  1034. for (i = 4; i < 8; i++)
  1035.     for (gr=0;gr<3;gr++)
  1036. sbs_sample[ch][1][(i-4)*3 + gr][sb] = sb_pre_sample[ch][gr][i][sb];
  1038.     for (ch = l; ch < m; ch++)
  1039.       for (sb=0;sb<SBLIMIT;sb++)
  1040. for (i = 8; i < 12; i++)
  1041.     for (gr=0;gr<3;gr++)
  1042. sbs_sample[ch][2][(i-8)*3 + gr][sb] = sb_pre_sample[ch][gr][i][sb];
  1045. }
  1047. /**************************************************************
  1048. /*
  1049. /*   Restore the compressed sample to a factional number.
  1050. /*   first complement the MSB of the sample
  1051. /*   for Layer II :
  1052. /*   Use the formula s = s' * c + d
  1053. /*
  1054. /*  taken out of decoder,modified for prediction 9/16/93,SR
  1055. /*
  1056. /**************************************************************/
  1058. static double c[17] = { 1.33333333333, 1.60000000000, 1.14285714286,
  1059.                         1.77777777777, 1.06666666666, 1.03225806452,
  1060.                         1.01587301587, 1.00787401575, 1.00392156863,
  1061.                         1.00195694716, 1.00097751711, 1.00048851979,
  1062.                         1.00024420024, 1.00012208522, 1.00006103888,
  1063.                         1.00003051851, 1.00001525902 };
  1065. static double d[17] = { 0.500000000, 0.500000000, 0.250000000, 0.500000000,
  1066.                         0.125000000, 0.062500000, 0.031250000, 0.015625000,
  1067.                         0.007812500, 0.003906250, 0.001953125, 0.0009765625,
  1068.                         0.00048828125, 0.00024414063, 0.00012207031,
  1069.                         0.00006103516, 0.00003051758 };
  1071. /************************** Layer II stuff ************************/
  1073. void II_dequantize_sample(unsigned int (*sample)[3][32], unsigned int (*bit_alloc)[32], double (*fraction)[3][12][32], frame_params *fr_ps, int l, int m, int z)
  1074. {
  1075.    int i, j, k, x;
  1076.    int stereo = fr_ps->stereo;
  1077.    int sblimit = fr_ps->sblimit;
  1078.    al_table *alloc = fr_ps->alloc;
  1080.    for (i=0;i<sblimit;i++)  for (j=0;j<3;j++) for (k = l;k < m ;k++)
  1081.      if (bit_alloc[k][i]) {
  1083.        /* locate MSB in the sample */
  1084.        x = 0;
  1085. #ifndef MSDOS
  1086.        while ((1L<<x) < (*alloc)[i][bit_alloc[k][i]].steps) x++;
  1087. #else
  1088.        /* microsoft C thinks an int is a short */
  1089.        while (( (unsigned long) (1L<<(long)x) <
  1090.                 (unsigned long)( (*alloc)[i][bit_alloc[k][i]].steps)
  1091.               ) && ( x < 16) ) x++;
  1092. #endif
  1094.        /* MSB inversion */
  1095.        if (((sample[k][j][i] >> x-1) & 1) == 1)
  1096.           fraction[k][j][z][i] = 0.0;
  1097.        else  fraction[k][j][z][i] = -1.0;
  1099.        /* Form a 2's complement sample */
  1100.        fraction[k][j][z][i] += (double) (sample[k][j][i] & ((1<<x-1)-1)) /
  1101.                             (double) (1L<<x-1);
  1103.        /* Dequantize the sample */
  1104.        fraction[k][j][z][i] += d[(*alloc)[i][bit_alloc[k][i]].quant];
  1105.        fraction[k][j][z][i] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
  1106.      }
  1107.      else fraction[k][j][z][i] = 0.0;   
  1108.    
  1109.    for (i=sblimit;i<SBLIMIT;i++) for (j=0;j<3;j++) for(k = l; k < m; k++)
  1110.      fraction[k][j][z][i] = 0.0;
  1111. }
  1124. void II_denormalize_sample(double (*fraction)[3][12][32], unsigned int (*scale_index)[3][32], frame_params *fr_ps, int x, int l, int m, int z)
  1125.        /*far*/                             
  1126.                                         
  1127.                     
  1128.       
  1129.             
  1130. {
  1131.    int i,j,k;
  1132.    int stereo = fr_ps->stereo;
  1133.    int sblimit = fr_ps->sblimit;
  1135.    for (i=0;i<sblimit;i++) for (j= l;j < m; j++) {
  1136.       fraction[j][0][z][i] *= multiple[scale_index[j][x][i]];
  1137.       fraction[j][1][z][i] *= multiple[scale_index[j][x][i]];
  1138.       fraction[j][2][z][i] *= multiple[scale_index[j][x][i]];
  1139.    }
  1140. }
  1144. void scale_factor_calc(unsigned int (*scalar)[3][32], int sblimit, int l, int m, int z, double (*sb_sample)[3][12][32])
  1145.                                    
  1146.             
  1147.             
  1148.                                           /* (see above) */
  1149. {
  1150.   int i,j, k,t;
  1151.   double s[SBLIMIT];
  1152.  
  1153.   for (k = l; k< m; k++) for (t=0;t<3;t++) 
  1154.   {
  1155.    for (i=((z == 0) ? 0:(sb_groups[z-1]+1));i<=sb_groups[z];i++) 
  1156.    {
  1157. for (j=1, s[i] = mod(sb_sample[k][t][0][i]);j<SCALE_BLOCK;j++)
  1158.   if (mod(sb_sample[k][t][j][i]) > s[i])
  1159.  s[i] = mod(sb_sample[k][t][j][i]);
  1160.    } 
  1161.     for (i=((z == 0) ? 0:(sb_groups[z-1]+1));i<=sb_groups[z];i++)
  1162.     { 
  1163.         for (j=SCALE_RANGE-1,scalar[k][t][i]=0;j>=0;j--)
  1164. if (s[i] < multiple[j]) 
  1165. {                       /* <= changed to <, 1992-11-06 shn*/
  1166.                    scalar[k][t][i] = j;
  1167.                    break;
  1168.                 }
  1169.      }
  1170.    }
  1171. }