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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
l3psy.c
资源名称：bladeenc-0.90.0-src.zip　[点击查看]
上传用户：bjsgzm
上传日期：2007-01-08
资源大小：256k
文件大小：25k
源码类别：

mpeg/mp3

开发平台：

Visual C++

l3psy.c：源码内容
  1. /*
  2. (c) Copyright 1998, 1999 - Tord Jansson
  3. =======================================
  5. This file is part of the BladeEnc MP3 Encoder, based on
  6. ISO's reference code for MPEG Layer 3 compression, and might
  7. contain smaller or larger sections that are directly taken
  8. from ISO's reference code.
  10. All changes to the ISO reference code herein are either
  11. copyrighted by Tord Jansson (tord.jansson@swipnet.se)
  12. or sublicensed to Tord Jansson by a third party.
  14. BladeEnc is free software; you can redistribute this file
  15. and/or modify it under the terms of the GNU Lesser General Public
  16. License as published by the Free Software Foundation; either
  17. version 2.1 of the License, or (at your option) any later version.
  19. */
  21. #include <stdlib.h>
  22. #include "common.h"
  23. #include "encoder.h"
  24. #include "l3psy.h"
  25. #include "l3side.h"
  28. #define maximum(x,y) ( (x>y) ? x : y )
  29. #define minimum(x,y) ( (x<y) ? x : y )
  31. /*____ Global Static Variables ______________________________________________*/
  33. static double ratio[2][21];
  34. static double ratio_s[2][12][3];
  36. /* The static variables "r", "phi_sav", "new_", "old" and "oldest" have    */
  37. /* to be remembered for the unpredictability measure.  For "r" and        */
  38. /* "phi_sav", the first index from the left is the channel select and     */
  39. /* the second index is the "age" of the data.                             */
  42.    static FLOAT window_s[BLKSIZE_s] ;
  43. static int     new_ = 0, old = 1, oldest = 0;
  44. static int     flush, sync_flush, syncsize, sfreq_idx;
  45. static double  cw[HBLKSIZE], eb[CBANDS];
  46. static double  ctb[CBANDS];
  47. static double SNR_l[CBANDS], SNR_s[CBANDS_s];
  48. static double minval[CBANDS],qthr_l[CBANDS],norm_l[CBANDS];
  49. static double qthr_s[CBANDS_s],norm_s[CBANDS_s];
  50. static double nb_1[2][CBANDS], nb_2[2][CBANDS];
  51. static double s3_l[CBANDS][CBANDS]; /* s3_s[CBANDS_s][CBANDS_s]; */
  53. /* Scale Factor Bands */
  54. static int cbw_l[SBMAX_l],bu_l[SBMAX_l],bo_l[SBMAX_l] ;
  55. static int cbw_s[SBMAX_s],bu_s[SBMAX_s],bo_s[SBMAX_s] ;
  56. static double w1_l[SBMAX_l], w2_l[SBMAX_l];
  57. static double w1_s[SBMAX_s], w2_s[SBMAX_s];
  58. static double en[SBMAX_l],   thm[SBMAX_l] ;
  59. static int blocktype_old[2] ;
  60. static int partition_l[HBLKSIZE],partition_s[HBLKSIZE_s];
  63. /* The following static variables are constants.                           */
  66. static float  crit_band[27] = {0,  100,  200, 300, 400, 510, 630,  770,
  67.                                920, 1080, 1270,1480,1720,2000,2320, 2700,
  68.                               3150, 3700, 4400,5300,6400,7700,9500,12000,
  69.                              15500,25000,30000};
  72. /* The following pointer variables point to large areas of memory         */
  73. /* dynamically allocated by the mem_alloc() function.  Dynamic memory     */
  74. /* allocation is used in order to avoid stack frame or data area          */
  75. /* overflow errors that otherwise would have occurred at compile time     */
  76. /* on the Macintosh computer.                                             */
  78. static FLOAT energy_s[3][256];
  79. static FLOAT phi_s[3][256] ; /* 256 samples not 129 */
  81. static int *numlines ;
  82. static int     *partition;
  83. static FLOAT   *cbval, *rnorm;
  84. static FLOAT   *window;
  85. static FLOAT   *absthr;
  86. static double  *tmn;
  87. static FCB     *s;
  88. static FHBLK   *lthr;
  89. static F2HBLK  *r, *phi_sav;
  92. /*____ read_absthr() ________________________________________________________*/
  94. void read_absthr(float * absthr, int table)
  95. {
  96. float * pSource;
  97. int j;
  99. switch(table)
  100. {
  101.      case 0 :
  102. pSource = absthr_0;
  103.        break;
  104.      case 1 :
  105. pSource = absthr_1;
  106.      break;
  107.      case 2 :
  108. pSource = absthr_2;
  109.        break;
  110.      default :
  111. printf("absthr table: Not valid table numbern");
  112. return;
  113. }
  115.   for(j=0; j<HBLKSIZE; j++)
  116.      absthr[j] =  pSource[j];
  117. }
  121. void L3para_read( int sfreq, int numlines[CBANDS], int partition_l[HBLKSIZE],
  122.   double minval[CBANDS], double qthr_l[CBANDS], double norm_l[CBANDS],
  123.   double s3_l[CBANDS][CBANDS], int partition_s[HBLKSIZE_s], double qthr_s[CBANDS_s],
  124.   double norm_s[CBANDS_s], double SNR_s[CBANDS_s],
  125.   int cbw_l[SBMAX_l], int bu_l[SBMAX_l], int bo_l[SBMAX_l],
  126.   double w1_l[SBMAX_l], double w2_l[SBMAX_l],
  127.   int cbw_s[SBMAX_s], int bu_s[SBMAX_s], int bo_s[SBMAX_s],
  128.   double w1_s[SBMAX_s], double w2_s[SBMAX_s] );
  133. /*____ psycho_anal_init() ___________________________________________________*/
  135. void psycho_anal_init( double sfreq )
  136. {
  137. unsigned int   i, j;
  138. float           freq_mult, bval_lo;
  139. double          temp1,temp2,temp3;
  141.    float  fthr[sizeof(FHBLK)/4];
  144. new_ = 0;
  145. old = 1;
  146. oldest = 0;
  148. for( i = 0 ; i < 21 ; i++ )
  149. {
  150. ratio[0][i] = 0.0;
  151. ratio[1][i] = 0.0;
  152. }
  154. for( i = 0 ; i < 2 ; i++ )
  155. for( j = 0 ; j < 12 ; j++ )
  156. {
  157. ratio_s[i][j][0] = 0.0;
  158. ratio_s[i][j][0] = 0.0;
  159. ratio_s[i][j][0] = 0.0;
  160. }
  163. /* These dynamic memory allocations simulate "static" variables placed    */
  164. /* in the data space.  Each mem_alloc() call here occurs only once at     */
  165. /* initialization time.  The mem_free() function must not be called.      */
  167.     numlines = (int *) mem_alloc(sizeof(ICB), "numlines");
  168.     partition  = (int *) mem_alloc(sizeof(IHBLK), "partition");
  169.     cbval  = (FLOAT *) mem_alloc(sizeof(FCB), "cbval");
  170.     rnorm  = (FLOAT *) mem_alloc(sizeof(FCB), "rnorm");
  171.     window  = (FLOAT *) mem_alloc(sizeof(FBLK), "window");
  172.     absthr  = (FLOAT *) mem_alloc(sizeof(FHBLK), "absthr");
  173.     tmn  = (double *) mem_alloc(sizeof(DCB), "tmn");
  174.     s  = (FCB *) mem_alloc(sizeof(FCBCB), "s");
  175.     lthr  = (FHBLK *) mem_alloc(sizeof(F2HBLK), "lthr");
  176.     r  = (F2HBLK *) mem_alloc(sizeof(F22HBLK), "r");
  177.     phi_sav  = (F2HBLK *) mem_alloc(sizeof(F22HBLK), "phi_sav");
  179. /*#if 0 */
  180.     i = sfreq + 0.5;
  181.     switch(i)
  182. {
  183.      case 32000:
  184. sfreq_idx = 0;
  185. break;
  186.         case 44100:
  187. sfreq_idx = 1;
  188. break;
  189.         case 48000:
  190. sfreq_idx = 2;
  191. break;
  192. /*      default:    printf("error, invalid sampling frequency: %d Hzn",i);
  193.          exit(-1); */
  194.     }
  195.     read_absthr(absthr, sfreq_idx);
  197. sync_flush=768;
  198. flush=576;
  199. syncsize=1344;
  202. /* calculate HANN window coefficients */
  203.     for(i=0;i<BLKSIZE;i++)
  204. window[i]  =0.5*(1-cos(2.0*PI*(i-0.5)/BLKSIZE));
  205.     for(i=0;i<BLKSIZE_s;i++)
  206. window_s[i]=0.5*(1-cos(2.0*PI*(i-0.5)/BLKSIZE_s));
  208. /* reset states used in unpredictability measure */
  209. for(i=0;i<HBLKSIZE;i++)
  210. {
  211.      r[0][0][i]=r[1][0][i]=r[0][1][i]=r[1][1][i]=0;
  212.         phi_sav[0][0][i]=phi_sav[1][0][i]=0;
  213.         phi_sav[0][1][i]=phi_sav[1][1][i]=0;
  214.         lthr[0][i] = 60802371420160.0;
  215.         lthr[1][i] = 60802371420160.0;
  216. }
  218. /*****************************************************************************
  219.  * Initialization: Compute the following constants for use later             *
  220.  *    partition[HBLKSIZE] = the partition number associated with each        *
  221.  *                          frequency line                                   *
  222.  *    cbval[CBANDS]       = the center (average) bark value of each          *
  223.  *                          partition                                        *
  224.  *    numlines[CBANDS]    = the number of frequency lines in each partition  *
  225.  *    tmn[CBANDS]         = tone masking noise                               *
  226.  *****************************************************************************/
  227. /* compute fft frequency multiplicand */
  228. freq_mult = sfreq/BLKSIZE;
  230. /* calculate fft frequency, then bval of each line (use fthr[] as tmp storage)*/
  231.     for(i=0;i<HBLKSIZE;i++)
  232. {
  233.         temp1 = i*freq_mult;
  234.         j = 1;
  235.         while(temp1>crit_band[j])
  236. j++;
  237.      fthr[i]=j-1+(temp1-crit_band[j-1])/(crit_band[j]-crit_band[j-1]);
  238.     }
  239.     partition[0] = 0;
  241. /* temp2 is the counter of the number of frequency lines in each partition */
  243. temp2 = 1;
  244.     cbval[0]=fthr[0];
  245.     bval_lo=fthr[0];
  246.     for(i=1;i<HBLKSIZE;i++)
  247. {
  248.         if((fthr[i]-bval_lo)>0.33)
  249. {
  250.          partition[i]=partition[i-1]+1;
  251.          cbval[partition[i-1]] = cbval[partition[i-1]]/temp2;
  252.          cbval[partition[i]] = fthr[i];
  253.          bval_lo = fthr[i];
  254.          numlines[partition[i-1]] = temp2;
  255.          temp2 = 1;
  256.         }
  257.         else
  258. {
  259.          partition[i]=partition[i-1];
  260.          cbval[partition[i]] += fthr[i];
  262.          temp2++;
  263. }
  264.     }
  265.     numlines[partition[i-1]] = temp2;
  266.     cbval[partition[i-1]] = cbval[partition[i-1]]/temp2;
  268. /************************************************************************
  269.  * Now compute the spreading function, s[j][i], the value of the spread-*
  270.  * ing function, centered at band j, for band i, store for later use    *
  271.  ************************************************************************/
  272. for(j=0;j<CBANDS;j++)
  273. {
  274.      for(i=0;i<CBANDS;i++)
  275. {
  276.          temp1 = (cbval[i] - cbval[j])*1.05;
  277. if(temp1>=0.5 && temp1<=2.5)
  278. {
  279.              temp2 = temp1 - 0.5;
  280.              temp2 = 8.0 * (temp2*temp2 - 2.0 * temp2);
  281. }
  282. else
  283. temp2 = 0;
  284. temp1 += 0.474;
  285. temp3 = 15.811389+7.5*temp1-17.5*sqrt((double) (1.0+temp1*temp1));
  286. if(temp3 <= -100)
  287. s[i][j] = 0;
  288. else
  289. {
  290.              temp3 = (temp2 + temp3)*LN_TO_LOG10;
  291.              s[i][j] = exp(temp3);
  292. }
  293. }
  294.     }
  296. /* Calculate Tone Masking Noise values */
  297.     for(j=0;j<CBANDS;j++)
  298. {
  299.         temp1 = 15.5 + cbval[j];
  300.         tmn[j] = (temp1>24.5) ? temp1 : 24.5;
  302.    /* Calculate normalization factors for the net spreading functions */
  303.         rnorm[j] = 0;
  304.         for(i=0;i<CBANDS;i++)
  305. {
  306.            rnorm[j] += s[j][i];
  307.         }
  308. }
  310.     L3para_read( (int)sfreq,numlines,partition_l,minval,qthr_l,norm_l,s3_l,
  311.    partition_s,qthr_s,norm_s,SNR_s,
  312.    cbw_l,bu_l,bo_l,w1_l,w2_l, cbw_s,bu_s,bo_s,w1_s,w2_s );
  315. }
  317. /*____ psycho_anal_exit() ___________________________________________________*/
  319. void psycho_anal_exit( void )
  320. {
  321.     free( numlines );
  322.     free( partition );
  323.     free( cbval );
  324.     free( rnorm );
  325.     free( window );
  326.     free( absthr );
  327.     free( tmn );
  328.     free( s );
  329.     free( lthr );
  330.     free( r );
  331.     free( phi_sav );
  332. }
  335. /*____ psycho_anal() ________________________________________________________*/
  337. void psycho_anal( short int *buffer, short int savebuf[1344], int chn, int lay, float snr32[32],
  338.        double ratio_d[21], double ratio_ds[12][3],
  339.        double *pe, gr_info *cod_info )
  340. {
  341. int  blocktype;
  342. unsigned int   b, i, j, k;
  343. double          r_prime, phi_prime; /* not FLOAT */
  344. double          temp1,temp2,temp3;
  346. double    thr[CBANDS];
  348. int sb,sblock;
  351. float nb[sizeof(FCB)/4];
  352. float  cb[sizeof(FCB)/4];
  353.    float  ecb[sizeof(FCB)/4];
  354.    float  bc[sizeof(FCB)/4];
  356.    float wsamp_r[sizeof(FBLK)/4];
  357.    float  wsamp_i[sizeof(FBLK)/4];
  358.    float  phi[sizeof(FBLK)/4];
  359.    float  energy[sizeof(FBLK)/4];
  360.    float  c[sizeof(FHBLK)/4];
  361.    float  fthr[sizeof(FHBLK)/4];
  362.    F32    snrtmp[2];
  364.    memset(nb, 0, sizeof(FCB));
  365.    memset(cb, 0, sizeof(FCB));
  366.    memset(ecb, 0, sizeof(FCB));
  367.    memset(bc, 0, sizeof(FCB));
  369.    memset(wsamp_r, 0, sizeof(FBLK));
  370.    memset(wsamp_i, 0, sizeof(FBLK));
  371.    memset(phi, 0, sizeof(FBLK));
  372.    memset(energy, 0, sizeof(FBLK));
  373.    memset(c, 0, sizeof(FHBLK));
  374.    memset(fthr, 0, sizeof(FHBLK));
  375.    memset(snrtmp, 0, sizeof(F32)*2);
  379. for ( j = 0; j < 21; j++ )
  380.     ratio_d[j] = ratio[chn][j];
  382. for ( j = 0; j < 12; j++ )
  383. for ( i = 0; i < 3; i++ )
  384. ratio_ds[j][i] = ratio_s[chn][j][i];
  386. if ( chn == 0 )
  387. {
  388. if ( new_ == 0 )
  389.     {
  390. new_ = 1;
  391. old = 0;
  392. oldest = 1;
  393.     }
  394.     else
  395.     {
  396. new_ = 0;
  397. old = 1;
  398. oldest = 0;
  399.     }
  400. }
  402. /**********************************************************************
  403. *  Delay signal by sync_flush=768 samples                             *
  404. **********************************************************************/
  406. for ( j = 0; j < sync_flush; j++ ) /* for long window samples */
  407.     savebuf[j] = savebuf[j+flush];
  409. for ( j = sync_flush; j < syncsize; j++ )
  410.     savebuf[j] = *buffer++;
  412. for ( j = 0; j < BLKSIZE; j++ )
  413. { /**window data with HANN window**/
  414.     wsamp_r[j] = window[j] * savebuf[j];  
  415.     wsamp_i[j] = 0.0;
  416. }
  419. /**********************************************************************
  420. *    compute unpredicatability of first six spectral lines            * 
  421. **********************************************************************/
  423. fft( wsamp_r, wsamp_i, energy, phi, 1024 ); /**long FFT**/
  425. for ( j = 0; j < 6; j++ )
  426. {  /* calculate unpredictability measure cw */
  427.     r_prime = 2.0 * r[chn][old][j] - r[chn][oldest][j];
  428.     phi_prime = 2.0 * phi_sav[chn][old][j]-phi_sav[chn][oldest][j];
  429.     r[chn][new_][j] = sqrt((double) energy[j]);
  430.     phi_sav[chn][new_][j] = phi[j];
  431.     temp1 = r[chn][new_][j] * cos((double) phi[j]) - r_prime * cos(phi_prime);
  432.     temp2 = r[chn][new_][j] * sin((double) phi[j]) - r_prime * sin(phi_prime);
  433.     temp3=r[chn][new_][j] + fabs(r_prime);
  434.     
  435.     if ( temp3 != 0.0 )
  436. cw[j] = sqrt( temp1*temp1+temp2*temp2 ) / temp3;
  437.     else
  438. cw[j] = 0;
  439. }
  442. /**********************************************************************
  443. *     compute unpredicatibility of next 200 spectral lines            *
  444. **********************************************************************/ 
  445. for ( sblock = 0; sblock < 3; sblock++ )
  446. { /**window data with HANN window**/
  447.     for ( j = 0, k = 128 * (2 + sblock); j < 256; j++, k++ )
  448.     {
  449. wsamp_r[j] = window_s[j]* savebuf[k];
  450. wsamp_i[j] = 0.0;
  451.     } /* short FFT*/
  452.     
  453.     fft( wsamp_r, wsamp_i, &energy_s[sblock][0], &phi_s[sblock][0], 256 );
  454. }
  455.  
  456.     sblock = 1;
  458. for ( j = 6; j < 206; j += 4 )
  459. {/* calculate unpredictability measure cw */
  460.     double r2, phi2, temp1, temp2, temp3;
  461.     
  462.     k = (j+2) / 4; 
  463.     r_prime = 2.0 * sqrt((double) energy_s[0][k]) - sqrt((double) energy_s[2][k]);
  464.     phi_prime = 2.0 * phi_s[0][k] - phi_s[2][k];
  465.     r2 = sqrt((double) energy_s[1][k]);
  466.     phi2 = phi_s[1][k];
  467.     temp1 = r2 * cos( phi2 ) - r_prime * cos( phi_prime );
  468.     temp2 = r2 * sin( phi2 ) - r_prime * sin( phi_prime );
  469.     temp3 = r2 + fabs( r_prime );
  471.     if ( temp3 != 0.0 )
  472. cw[j] = sqrt( temp1 * temp1 + temp2 * temp2 ) / temp3;
  473.     else
  474. cw[j] = 0.0;
  476.     cw[j+1] = cw[j+2] = cw[j+3] = cw[j];
  477. }
  480. /**********************************************************************
  481. *    Set unpredicatiblility of remaining spectral lines to 0.4        *
  482. **********************************************************************/
  483. for ( j = 206; j < HBLKSIZE; j++ )
  484.     cw[j] = 0.4;
  488. /**********************************************************************
  489. *    Calculate the energy and the unpredictability in the threshold   *
  490. *    calculation partitions                                           *
  491. **********************************************************************/
  493. for ( b = 0; b < CBANDS; b++ )
  494. {
  495.     eb[b] = 0.0;
  496.     cb[b] = 0.0;
  497. }
  498. for ( j = 0; j < HBLKSIZE; j++ )
  499. {
  500.     int tp = partition_l[j];
  501.     if ( tp >= 0 )
  502.     {
  503. eb[tp] += energy[j];
  504. cb[tp] += cw[j] * energy[j];
  505.     }
  506. }
  509. /**********************************************************************
  510. *      convolve the partitioned energy and unpredictability           *
  511. *      with the spreading function, s3_l[b][k]                        *
  512. ******************************************************************** */
  514. for ( b = 0; b < CBANDS; b++ )
  515. {
  516.     ecb[b] = 0.0;
  517.     ctb[b] = 0.0;
  518. }
  519. for ( b = 0;b < CBANDS; b++ )
  520. {
  521.     for ( k = 0; k < CBANDS; k++ )
  522.     {
  523. ecb[b] += s3_l[b][k] * eb[k]; /* sprdngf for Layer III */
  524. ctb[b] += s3_l[b][k] * cb[k];
  525.     }
  526. }
  528. /* calculate the tonality of each threshold calculation partition */
  529. /* calculate the SNR in each threshhold calculation partition */
  531. for ( b = 0; b < CBANDS; b++ )
  532. {
  533.     double cbb,tbb;
  534.     if (ecb[b] != 0.0 )
  535.         {
  536. cbb = ctb[b]/ecb[b];
  537.          if (cbb <0.01) cbb = 0.01;
  538. cbb = log( cbb);
  539.         }
  540.     else
  541. cbb = 0.0 ;
  543.     tbb = -0.299 - 0.43*cbb;  /* conv1=-0.299, conv2=-0.43 */
  544.     tbb = minimum( 1.0, maximum( 0.0, tbb) ) ;  /* 0<tbb<1 */
  545.     SNR_l[b] = maximum( minval[b], 29.0*tbb+6.0*(1.0-tbb) );
  546. } /* TMN=29.0,NMT=6.0 for all calculation partitions */
  548. for ( b = 0; b < CBANDS; b++ ) /* calculate the threshold for each partition */
  549.     nb[b] = ecb[b] * norm_l[b] * exp( -SNR_l[b] * LN_TO_LOG10 );
  551. for ( b = 0; b < CBANDS; b++ )
  552. { /* pre-echo control */
  553.     double temp_1; /* BUG of IS */
  554.     temp_1 = minimum( nb[b], minimum(2.0*nb_1[chn][b],16.0*nb_2[chn][b]) );
  555.     thr[b] = maximum( qthr_l[b], temp_1 );/* rpelev=2.0, rpelev2=16.0 */
  556.     nb_2[chn][b] = nb_1[chn][b];
  557.     nb_1[chn][b] = nb[b];
  558. }
  561. *pe = 0.0; /*  calculate percetual entropy */
  562. for ( b = 0; b < CBANDS; b++ )
  563. {
  564.     double tp ;
  565.     tp = minimum( 0.0, log((thr[b]+1.0) / (eb[b]+1.0) ) ) ; /*not log*/
  566.     *pe -= numlines[b] * tp ;
  567. } /* thr[b] -> thr[b]+1.0 : for non sound portition */
  569. #define switch_pe  1800
  570.         blocktype = NORM_TYPE;
  573. if ( *pe < switch_pe )
  574. { /* no attack : use long blocks */
  575. switch( blocktype_old[chn] )
  576.     {
  577.      case NORM_TYPE:
  578.      case STOP_TYPE:
  579. blocktype = NORM_TYPE;
  580. break;
  581.     
  582.        case SHORT_TYPE:
  583. blocktype = STOP_TYPE;
  584. break;
  585.     
  586. /*        case START_TYPE:
  587. fprintf( stderr, "Error in block selectingn" );
  588. abort();
  589. break; problem */
  590.     }
  592.     /* threshold calculation (part 2) */
  593.     for ( sb = 0; sb < SBMAX_l; sb++ )
  594.     {
  595. en[sb] = w1_l[sb] * eb[bu_l[sb]] + w2_l[sb] * eb[bo_l[sb]];
  596. thm[sb] = w1_l[sb] *thr[bu_l[sb]] + w2_l[sb] * thr[bo_l[sb]];
  598. for ( b = bu_l[sb]+1; b < bo_l[sb]; b++ )
  599. {
  600.     en[sb]  += eb[b];
  601.     thm[sb] += thr[b];
  602. }
  604. if ( en[sb] != 0.0 )
  605. ratio[chn][sb] = thm[sb]/en[sb];
  606. else
  607.     ratio[chn][sb] = 0.0;
  608.     }
  609. }
  610. else 
  611. {
  612.     /* attack : use short blocks */
  613.     blocktype = SHORT_TYPE;
  614.     
  615.     if ( blocktype_old[chn] == NORM_TYPE ) 
  616. blocktype_old[chn] = START_TYPE;
  617.     if ( blocktype_old[chn] == STOP_TYPE )
  618. blocktype_old[chn] = SHORT_TYPE ;
  619.     
  620.     /* threshold calculation for short blocks */
  621.     
  622.     for ( sblock = 0; sblock < 3; sblock++ )
  623.     {
  624. for ( b = 0; b < CBANDS_s; b++ )
  625. {
  626.     eb[b] = 0.0;
  627.     ecb[b] = 0.0;
  628. }
  630. for ( j = 0; j < HBLKSIZE_s; j++ )
  631.     eb[partition_s[j]] += energy_s[sblock][j];
  633. for ( b = 0; b < CBANDS_s; b++ )
  634.     for ( k = 0; k < CBANDS_s; k++ )
  635. ecb[b] += s3_l[b][k] * eb[k];
  637. for ( b = 0; b < CBANDS_s; b++ )
  638. {
  639.     nb[b] = ecb[b] * norm_l[b] * exp( (double) SNR_s[b] * LN_TO_LOG10 );
  640.     thr[b] = maximum (qthr_s[b],nb[b]);
  641. }
  643. for ( sb = 0; sb < SBMAX_s; sb++ )
  644. {
  645.     en[sb] = w1_s[sb] * eb[bu_s[sb]] + w2_s[sb] * eb[bo_s[sb]];
  646.     thm[sb] = w1_s[sb] *thr[bu_s[sb]] + w2_s[sb] * thr[bo_s[sb]];
  648.     for ( b = bu_s[sb]+1; b < bo_s[sb]; b++ )
  649.     {
  650. en[sb] += eb[b];
  651. thm[sb] += thr[b];
  652.     }
  654.     if ( en[sb] != 0.0 )
  655. ratio_s[chn][sb][sblock] = thm[sb]/en[sb];
  656.     else
  657. ratio_s[chn][sb][sblock] = 0.0;
  658. }
  659.     }
  660. } 
  662. cod_info->block_type = blocktype_old[chn];
  663. blocktype_old[chn] = blocktype;
  665. if ( cod_info->block_type == NORM_TYPE )
  666.     cod_info->window_switching_flag = 0;
  667. else
  668.     cod_info->window_switching_flag = 1;
  670. cod_info->mixed_block_flag = 0;
  671. }
  674. /*____ L3para_read() __________________________________________________________*/
  676. void L3para_read( int sfreq, int *numlines, int *partition_l, double *minval,
  677.   double *qthr_l, double *norm_l, double (*s3_l)[63], int *partition_s,
  678.   double *qthr_s, double *norm_s, double *SNR, int *cbw_l, int *bu_l,
  679.   int *bo_l, double *w1_l, double *w2_l, int *cbw_s, int *bu_s,
  680.   int *bo_s, double *w1_s, double *w2_s )
  681. {
  682.    static double bval_l[CBANDS], bval_s[CBANDS];
  683.    int   cbmax, cbmax_tp;
  684.    static double s3_s[CBANDS][CBANDS];
  686.    int  sbmax ;
  687.    int  i,j,k,k2, part_max ;
  690.  psyDataElem * rpa1;
  691.  psyDataElem2 * rpa2;
  692.  psyDataElem3 * rpa3;
  695.  /* Read long block data */
  698. switch( sfreq )
  699. {
  700. case 32000:
  701. rpa1 = psy_longBlock__32000_58;
  702. cbmax_tp = 59;
  703. break;
  704. case 44100:
  705. rpa1 = psy_longBlock_44100_62;
  706. cbmax_tp = 63;
  707. break;
  708. case 48000:
  709. rpa1 = psy_longBlock_48000_61;
  710. cbmax_tp = 62;
  711. break;
  712. default:
  713. return; /* Just to avoid compiler warnings */
  714. }
  716. cbmax = cbmax_tp;
  717. for(i=0,k2=0;i<cbmax_tp;i++)
  718. {
  719. numlines[i] = rpa1->lines;
  720. minval[i] = rpa1->minVal;
  721. qthr_l[i] = rpa1->qthr;
  722. norm_l[i] = rpa1->norm;
  723. bval_l[i] = rpa1->bVal;
  724. rpa1++;
  726. for(k=0;k<numlines[i];k++)
  727. partition_l[k2++] = i ;
  728. }
  732. /************************************************************************
  733.  * Now compute the spreading function, s[j][i], the value of the spread-*
  734.  * ing function, centered at band j, for band i, store for later use    *
  735.  ************************************************************************/
  736.   part_max = cbmax ;
  737.       for(i=0;i<part_max;i++)
  738.   {
  739. double tempx,x,tempy,temp;
  740.         for(j=0;j<part_max;j++)
  741.     {
  742. /*            tempx = (bval_l[i] - bval_l[j])*1.05; */
  743. if (j>=i)
  744. tempx = (bval_l[i] - bval_l[j])*3.0;
  745.             else
  746. tempx = (bval_l[i] - bval_l[j])*1.5;
  747. /*             if (j>=i) tempx = (bval_l[j] - bval_l[i])*3.0;
  748.                else    tempx = (bval_l[j] - bval_l[i])*1.5; */
  749.              if(tempx>=0.5 && tempx<=2.5)
  750.      {
  751.                temp = tempx - 0.5;
  752.                x = 8.0 * (temp*temp - 2.0 * temp);
  753.              }
  754.              else x = 0.0;
  755.              tempx += 0.474;
  756.              tempy = 15.811389 + 7.5*tempx - 17.5*sqrt(1.0+tempx*tempx);
  757.              if (tempy <= -60.0) s3_l[i][j] = 0.0;
  758.              else                s3_l[i][j] = exp( (x + tempy)*LN_TO_LOG10 );
  760.             }
  761.           }
  764. /* Read short block data */
  766. switch( sfreq )
  767. {
  768. case 32000:
  769. rpa2 = psy_shortBlock_32000_41;
  770. cbmax_tp = 42;
  771. break;
  772. case 44100:
  773. rpa2 = psy_shortBlock_44100_38;
  774. cbmax_tp = 39;
  775. break;
  776. case 48000:
  777. rpa2 = psy_shortBlock_48000_37;
  778. cbmax_tp = 38;
  779. break;
  780. default:
  781. return; /* Just to avoid compiler warnings */
  782. }
  786. cbmax = cbmax_tp;
  787. for(i=0,k2=0;i<cbmax_tp;i++)
  788. {
  789. numlines[i] = rpa2->lines;
  790. qthr_s[i] = rpa2->qthr;
  791. norm_s[i] = rpa2->norm;
  792. SNR[i] = rpa2->snr;
  793. bval_s[i] = rpa2->bVal;
  794. rpa2++;
  796. for(k=0;k<numlines[i];k++)
  797. partition_s[k2++] = i ;
  798. }
  801. /************************************************************************
  802.  * Now compute the spreading function, s[j][i], the value of the spread-*
  803.  * ing function, centered at band j, for band i, store for later use    *
  804.  ************************************************************************/
  805.   part_max = cbmax ;
  806.           for(i=0;i<part_max;i++)
  807.   {
  808.   double tempx,x,tempy,temp;
  809.             for(j=0;j<part_max;j++)
  810.     {
  811.              tempx = (bval_s[i] - bval_s[j])*1.05;
  812.              if (j>=i) tempx = (bval_s[i] - bval_s[j])*3.0;
  813.                else    tempx = (bval_s[i] - bval_s[j])*1.5;
  814.              if(tempx>=0.5 && tempx<=2.5)
  815.      {
  816.                temp = tempx - 0.5;
  817.                x = 8.0 * (temp*temp - 2.0 * temp);
  818.              }
  819.              else x = 0.0;
  820.              tempx += 0.474;
  821.              tempy = 15.811389 + 7.5*tempx - 17.5*sqrt(1.0+tempx*tempx);
  822.              if (tempy <= -60.0) s3_s[i][j] = 0.0;
  823.              else                s3_s[i][j] = exp( (x + tempy)*LN_TO_LOG10 );
  824.             }
  825.           }
  826. /* Read long block data for converting threshold calculation
  827.    partitions to scale factor bands */
  829. switch( sfreq )
  830. {
  831. case 32000:
  832. rpa3 = psy_data3_32000_20;
  833. sbmax = 21;
  834. break;
  835. case 44100:
  836. rpa3 = psy_data3_44100_20;
  837. sbmax = 21;
  838. break;
  839. case 48000:
  840. rpa3 = psy_data3_48000_20;
  841. sbmax = 21;
  842. break;
  843. default:
  844. return; /* Just to avoid compiler warnings */
  845. }
  847.   for(i=0;i<sbmax;i++)
  848.   {
  849. cbw_l[i] = rpa3->cbw;
  850. bu_l[i] = rpa3->bu;
  851. bo_l[i] = rpa3->bo;
  852. w1_l[i] = rpa3->w1;
  853. w2_l[i] = rpa3->w2;
  854. rpa3++;
  855. }
  857. /* Read short block data for converting threshold calculation
  858.    partitions to scale factor bands */
  860. switch( sfreq )
  861. {
  862. case 32000:
  863. rpa3 = psy_data4_32000_11;
  864. sbmax = 12;
  865. break;
  866. case 44100:
  867. rpa3 = psy_data4_44100_11;
  868. sbmax = 12;
  869. break;
  870. case 48000:
  871. rpa3 = psy_data4_48000_11;
  872. sbmax = 12;
  873. break;
  874. }
  876.   for(i=0;i<sbmax;i++)
  877.   {
  878. cbw_s[i] = rpa3->cbw;
  879. bu_s[i] = rpa3->bu;
  880. bo_s[i] = rpa3->bo;
  881. w1_s[i] = rpa3->w1;
  882. w2_s[i] = rpa3->w2;
  883. rpa3++;
  884. }
  886. }