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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
aacquant.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：18k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

aacquant.c：源码内容
  1. /*
  2.  * FAAC - Freeware Advanced Audio Coder
  3.  * Copyright (C) 2001 Menno Bakker
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Lesser General Public
  7.  * License as published by the Free Software Foundation; either
  8.  * version 2.1 of the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Lesser General Public License for more details.
  15.  * You should have received a copy of the GNU Lesser General Public
  16.  * License along with this library; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  * $Id: aacquant.c,v 1.3 2001/06/04 23:02:24 wmay Exp $
  20.  */
  22. #include <math.h>
  23. #include <stdlib.h>
  25. #include "aacquant.h"
  26. #include "coder.h"
  27. #include "huffman.h"
  28. #include "psych.h"
  29. #include "util.h"
  32. #define XRPOW_FTOI(src,dest) ((dest) = (int)(src))
  33. #define QUANTFAC(rx)  adj43[rx]
  34. #define ROUNDFAC 0.4054
  37. double *pow43;
  38. double *adj43;
  39. double *adj43asm;
  42. void AACQuantizeInit(CoderInfo *coderInfo, unsigned int numChannels)
  43. {
  44. unsigned int channel, i;
  46. pow43 = (double*)AllocMemory(PRECALC_SIZE*sizeof(double));
  47. adj43 = (double*)AllocMemory(PRECALC_SIZE*sizeof(double));
  48. adj43asm = (double*)AllocMemory(PRECALC_SIZE*sizeof(double));
  50. pow43[0] = 0.0;
  51. for(i=1;i<PRECALC_SIZE;i++)
  52. pow43[i] = pow((double)i, 4.0/3.0);
  54. adj43asm[0] = 0.0;
  55. for (i = 1; i < PRECALC_SIZE; i++)
  56. adj43asm[i] = i - 0.5 - pow(0.5 * (pow43[i - 1] + pow43[i]),0.75);
  57. for (i = 0; i < PRECALC_SIZE-1; i++)
  58. adj43[i] = (i + 1) - pow(0.5 * (pow43[i] + pow43[i + 1]), 0.75);
  59. adj43[i] = 0.5;
  61. for (channel = 0; channel < numChannels; channel++) {
  62. coderInfo[channel].old_value = 0;
  63. coderInfo[channel].CurrentStep = 4;
  65. coderInfo[channel].requantFreq = (double*)AllocMemory(BLOCK_LEN_LONG*sizeof(double));
  66. }
  67. }
  69. void AACQuantizeEnd(CoderInfo *coderInfo, unsigned int numChannels)
  70. {
  71. unsigned int channel;
  73. if (pow43) FreeMemory(pow43);
  74. if (adj43) FreeMemory(adj43);
  75. if (adj43asm) FreeMemory(adj43asm);
  77. for (channel = 0; channel < numChannels; channel++) {
  78. if (coderInfo[channel].requantFreq) FreeMemory(coderInfo[channel].requantFreq);
  79. }
  80. }
  82. int AACQuantize(CoderInfo *coderInfo,
  83. PsyInfo *psyInfo,
  84. ChannelInfo *channelInfo,
  85. int *cb_width,
  86. int num_cb,
  87. double *xr,
  88. int desired_rate)
  89. {
  90. int sb, i, do_q = 0;
  91. int bits, sign;
  92. double *xr_pow, *xmin;
  93. int *xi;
  95. /* Use local copy's */
  96. int *scale_factor = coderInfo->scale_factor;
  99. xr_pow = (double*)AllocMemory(FRAME_LEN*sizeof(double));
  100. xmin = (double*)AllocMemory(MAX_SCFAC_BANDS*sizeof(double));
  101. xi = (int*)AllocMemory(FRAME_LEN*sizeof(int));
  104. if (coderInfo->block_type == ONLY_SHORT_WINDOW) {
  105. SortForGrouping(coderInfo, psyInfo, channelInfo, cb_width, xr);
  106. } else {
  107. for (sb = 0; sb < coderInfo->nr_of_sfb; sb++) {
  108. if (channelInfo->msInfo.is_present && channelInfo->msInfo.ms_used[sb]) {
  109. psyInfo->maskThr[sb] = psyInfo->maskThrMS[sb];
  110. psyInfo->maskEn[sb] = psyInfo->maskEnMS[sb];
  111. }
  112. }
  113. }
  116. /* Set all scalefactors to 0 */
  117. coderInfo->global_gain = 0;
  118. for (sb = 0; sb < coderInfo->nr_of_sfb; sb++)
  119. scale_factor[sb] = 0;
  121. /* Compute xr_pow */
  122. for (i = 0; i < FRAME_LEN; i++) {
  123.         double temp = fabs(xr[i]);
  124.         xr_pow[i] = sqrt(temp * sqrt(temp));
  125.         do_q += (temp > 1E-20);
  126.     }
  128. if (do_q) {
  129. bits = SearchStepSize(coderInfo, desired_rate, xr_pow, xi);
  130. coderInfo->old_value = coderInfo->global_gain;
  132. CalcAllowedDist(psyInfo, cb_width, num_cb, xr, xmin);
  133. OuterLoop(coderInfo, xr, xr_pow, xi, xmin, desired_rate);
  135. for ( i = 0; i < FRAME_LEN; i++ )  {
  136. sign = (xr[i] < 0) ? -1 : 1;
  137. xi[i] *= sign;
  138. }
  139. } else {
  140. coderInfo->global_gain = 0;
  141. SetMemory(xi, 0, FRAME_LEN*sizeof(int));
  142. }
  144. CountBitsLong(coderInfo, xi);
  146. /* offset the difference of common_scalefac and scalefactors by SF_OFFSET  */
  147. for (i = 0; i < coderInfo->nr_of_sfb; i++) {
  148. if ((coderInfo->book_vector[i]!=INTENSITY_HCB)&&(coderInfo->book_vector[i]!=INTENSITY_HCB2)) {
  149. scale_factor[i] = coderInfo->global_gain - scale_factor[i] + SF_OFFSET;
  150. }
  151. }
  152. coderInfo->global_gain = scale_factor[0];
  154. /* place the codewords and their respective lengths in arrays data[] and len[] respectively */
  155. /* there are 'counter' elements in each array, and these are variable length arrays depending on the input */
  156. coderInfo->spectral_count = 0;
  157. for(i = 0; i < coderInfo->nr_of_sfb; i++) {
  158. OutputBits(
  159. coderInfo,
  160. coderInfo->book_vector[i],
  161. xi,
  162. coderInfo->sfb_offset[i],
  163. coderInfo->sfb_offset[i+1]-coderInfo->sfb_offset[i]);
  164. }
  167. if (xmin) FreeMemory(xmin);
  168. if (xr_pow) FreeMemory(xr_pow);
  169. if (xi) FreeMemory(xi);
  171. return bits;
  172. }
  174. static int SearchStepSize(CoderInfo *coderInfo,
  175.   const int desired_rate,
  176.   const double *xr,
  177.   int *xi)
  178. {
  179. int flag_GoneOver = 0;
  180. int CurrentStep = coderInfo->CurrentStep;
  181. int nBits;
  182. int StepSize = coderInfo->old_value;
  183. int Direction = 0;
  185. do
  186. {
  187. coderInfo->global_gain = StepSize;
  188. nBits = CountBits(coderInfo, xi, xr);
  190. if (CurrentStep == 1 ) {
  191. break; /* nothing to adjust anymore */
  192. }
  193. if (flag_GoneOver) {
  194. CurrentStep /= 2;
  195. }
  196. if (nBits > desired_rate) { /* increase Quantize_StepSize */
  197. if (Direction == -1 && !flag_GoneOver) {
  198. flag_GoneOver = 1;
  199. CurrentStep /= 2; /* late adjust */
  200. }
  201. Direction = 1;
  202. StepSize += CurrentStep;
  203. } else if (nBits < desired_rate) {
  204. if (Direction == 1 && !flag_GoneOver) {
  205. flag_GoneOver = 1;
  206. CurrentStep /= 2; /* late adjust */
  207. }
  208. Direction = -1;
  209. StepSize -= CurrentStep;
  210. } else break;
  211. } while (1);
  213. CurrentStep = coderInfo->old_value - StepSize;
  215. coderInfo->CurrentStep = CurrentStep/4 != 0 ? 4 : 2;
  216. coderInfo->old_value = coderInfo->global_gain;
  218. return nBits;
  219. }
  221. #if 1 /* TAKEHIRO_IEEE754_HACK */
  223. #pragma warning( disable : 4244 4307 )
  225. typedef union {
  226.     float f;
  227.     int i;
  228. } fi_union;
  230. #define MAGIC_FLOAT (65536*(128))
  231. #define MAGIC_INT 0x4b000000
  233. static void Quantize(const double *xp, int *pi, double istep)
  234. {
  235. int j;
  236. fi_union *fi;
  238. fi = (fi_union *)pi;
  239. for (j = FRAME_LEN/4 - 1; j >= 0; --j) {
  240. double x0 = istep * xp[0];
  241. double x1 = istep * xp[1];
  242. double x2 = istep * xp[2];
  243. double x3 = istep * xp[3];
  245. x0 += MAGIC_FLOAT; fi[0].f = x0;
  246. x1 += MAGIC_FLOAT; fi[1].f = x1;
  247. x2 += MAGIC_FLOAT; fi[2].f = x2;
  248. x3 += MAGIC_FLOAT; fi[3].f = x3;
  250. fi[0].f = x0 + (adj43asm - MAGIC_INT)[fi[0].i];
  251. fi[1].f = x1 + (adj43asm - MAGIC_INT)[fi[1].i];
  252. fi[2].f = x2 + (adj43asm - MAGIC_INT)[fi[2].i];
  253. fi[3].f = x3 + (adj43asm - MAGIC_INT)[fi[3].i];
  255. fi[0].i -= MAGIC_INT;
  256. fi[1].i -= MAGIC_INT;
  257. fi[2].i -= MAGIC_INT;
  258. fi[3].i -= MAGIC_INT;
  259. fi += 4;
  260. xp += 4;
  261. }
  262. }
  263. #else
  264. static void Quantize(const double *xr, int *ix, double istep)
  265. {
  266. int j;
  268.     for (j = FRAME_LEN/8; j > 0; --j) {
  269. double x1, x2, x3, x4, x5, x6, x7, x8;
  270. int rx1, rx2, rx3, rx4, rx5, rx6, rx7, rx8;
  272. x1 = *xr++ * istep;
  273. x2 = *xr++ * istep;
  274. XRPOW_FTOI(x1, rx1);
  275. x3 = *xr++ * istep;
  276. XRPOW_FTOI(x2, rx2);
  277. x4 = *xr++ * istep;
  278. XRPOW_FTOI(x3, rx3);
  279. x5 = *xr++ * istep;
  280. XRPOW_FTOI(x4, rx4);
  281. x6 = *xr++ * istep;
  282. XRPOW_FTOI(x5, rx5);
  283. x7 = *xr++ * istep;
  284. XRPOW_FTOI(x6, rx6);
  285. x8 = *xr++ * istep;
  286. XRPOW_FTOI(x7, rx7);
  287. x1 += QUANTFAC(rx1);
  288. XRPOW_FTOI(x8, rx8);
  289. x2 += QUANTFAC(rx2);
  290. XRPOW_FTOI(x1,*ix++);
  291. x3 += QUANTFAC(rx3);
  292. XRPOW_FTOI(x2,*ix++);
  293. x4 += QUANTFAC(rx4);
  294. XRPOW_FTOI(x3,*ix++);
  295. x5 += QUANTFAC(rx5);
  296. XRPOW_FTOI(x4,*ix++);
  297. x6 += QUANTFAC(rx6);
  298. XRPOW_FTOI(x5,*ix++);
  299. x7 += QUANTFAC(rx7);
  300. XRPOW_FTOI(x6,*ix++);
  301. x8 += QUANTFAC(rx8);
  302. XRPOW_FTOI(x7,*ix++);
  303. XRPOW_FTOI(x8,*ix++);
  304.     }
  305. }
  306. #endif
  308. static int CountBitsLong(CoderInfo *coderInfo, int *xi)
  309. {
  310. int i, bits = 0;
  312. /* find a good method to section the scalefactor bands into huffman codebook sections */
  313. BitSearch(coderInfo, xi);
  315. /* calculate the amount of bits needed for encoding the huffman codebook numbers */
  316. bits += SortBookNumbers(coderInfo, NULL, 0);
  318. /* calculate the amount of bits needed for the spectral values */
  319. coderInfo->spectral_count = 0;
  320. for(i = 0; i < coderInfo->nr_of_sfb; i++) {  
  321. bits += CalcBits(coderInfo,
  322. coderInfo->book_vector[i],
  323. xi,
  324. coderInfo->sfb_offset[i], 
  325. coderInfo->sfb_offset[i+1] - coderInfo->sfb_offset[i]);
  326. }
  328. /* the number of bits for the scalefactors */
  329. bits += WriteScalefactors(coderInfo, NULL, 0);
  331. /* the total amount of bits required */
  332. return bits;
  333. }
  335. static int CountBits(CoderInfo *coderInfo, int *ix, const double *xr)
  336. {
  337. int bits = 0, i;
  339. /* since quantize uses table lookup, we need to check this first: */
  340. double w = (IXMAX_VAL) / IPOW20(coderInfo->global_gain);
  341. for ( i = 0; i < FRAME_LEN; i++ )  {
  342. if (xr[i] > w)
  343. return LARGE_BITS;
  344. }
  346. Quantize(xr, ix, IPOW20(coderInfo->global_gain));
  348. bits = CountBitsLong(coderInfo, ix);
  350. return bits;
  351. }
  353. static int InnerLoop(CoderInfo *coderInfo,
  354.  double *xr_pow,
  355.  int *xi,
  356.  int max_bits)
  357. {
  358. int bits;
  360. /*  count bits */
  361. bits = CountBits(coderInfo, xi, xr_pow);
  363. /*  increase quantizer stepsize until needed bits are below maximum */
  364. while (bits > max_bits) {
  365. coderInfo->global_gain += 1;
  366. bits = CountBits(coderInfo, xi, xr_pow);
  367. }
  369. return bits;
  370. }
  372. static void CalcAllowedDist(PsyInfo *psyInfo, int *cb_width, int num_cb,
  373. double *xr, double *xmin)
  374. {
  375. int sfb, start, end, i;
  376. double en0, xmin0;
  378. end = 0;
  379. for (sfb = 0; sfb < num_cb; sfb++)
  380. {
  381. start = end;
  382. end += cb_width[sfb];
  384. for (en0 = 0.0, i = start; i < end; i++)
  385. {
  386. en0 += xr[i] * xr[i];
  387. }
  388. en0 /= cb_width[sfb];
  390. xmin0 = psyInfo->maskEn[sfb];
  391. if (xmin0 > 0.0)
  392. xmin0 = en0 * psyInfo->maskThr[sfb] / xmin0;
  393. xmin[sfb] = xmin0;
  394. }
  395. }
  397. static int OuterLoop(CoderInfo *coderInfo,
  398.  double *xr,
  399.  double *xr_pow,
  400.  int *xi,
  401.  double *xmin,
  402.  int target_bits)
  403. {
  404. int sb;
  405. int notdone, over, better;
  406. int store_global_gain, outer_loop_count;
  407. int best_global_gain, age;
  409.     calcNoiseResult noiseInfo;
  410.     calcNoiseResult bestNoiseInfo;
  412. double sfQuantFac = pow(2.0, 0.1875);
  413. int *scale_factor = coderInfo->scale_factor;
  415. int *best_scale_factor;
  416. int *save_xi;
  417. double *distort;
  419. distort = (double*)AllocMemory(MAX_SCFAC_BANDS*sizeof(double));
  420. best_scale_factor = (int*)AllocMemory(MAX_SCFAC_BANDS*sizeof(int));
  422. save_xi = (int*)AllocMemory(FRAME_LEN*sizeof(int));
  424. notdone = 1;
  425. outer_loop_count = 0;
  427. do { /* outer iteration loop */
  429. over = 0;
  430. outer_loop_count++;
  432. InnerLoop(coderInfo, xr_pow, xi, target_bits);
  434. store_global_gain = coderInfo->global_gain;
  436. over = CalcNoise(coderInfo, xr, xi, coderInfo->requantFreq, distort, xmin, &noiseInfo);
  438. if (outer_loop_count == 1)
  439. better = 1;
  440. else
  441. better = QuantCompare(&bestNoiseInfo, &noiseInfo);
  443. if (better) {
  444. bestNoiseInfo = noiseInfo;
  445. best_global_gain = store_global_gain;
  447. for (sb = 0; sb < coderInfo->nr_of_sfb; sb++) {
  448. best_scale_factor[sb] = scale_factor[sb];
  449. }
  450. memcpy(save_xi, xi, sizeof(int)*BLOCK_LEN_LONG);
  451. age = 0;
  452. } else
  453. age++;
  455.         if (age > 3 && bestNoiseInfo.over_count == 0)
  456.             break;
  458.         notdone = BalanceNoise(coderInfo, distort, xr_pow);
  460. for (sb = 0; sb < coderInfo->nr_of_sfb; sb++)
  461. if (scale_factor[sb] > 30)
  462. notdone = 0;
  464. if (notdone == 0) 
  465.             break;
  467. } while (1);
  469. coderInfo->global_gain = best_global_gain;
  470. for (sb = 0; sb < coderInfo->nr_of_sfb; sb++) {
  471. scale_factor[sb] = best_scale_factor[sb];
  472. }
  473. memcpy(xi, save_xi, sizeof(int)*BLOCK_LEN_LONG);
  475. if (best_scale_factor) FreeMemory(best_scale_factor);
  476. if (save_xi) FreeMemory(save_xi);
  477. if (distort) FreeMemory(distort);
  479. return 0;
  480. }
  482. static int CalcNoise(CoderInfo *coderInfo,
  483.  double *xr,
  484.  int *xi,
  485.  double *requant_xr,
  486.  double *error_energy,
  487.  double *xmin,
  488.  calcNoiseResult *res
  489.  )
  490. {
  491. int i, sb, sbw;
  492. int over = 0, count = 0;
  493. double invQuantFac;
  494. double linediff, noise;
  496. double over_noise = 1;
  497. double tot_noise = 1;
  498. double max_noise = 1E-20;
  500. for (sb = 0; sb < coderInfo->nr_of_sfb; sb++) {
  502. sbw = coderInfo->sfb_offset[sb+1] - coderInfo->sfb_offset[sb];
  504. invQuantFac = pow(2.0, -0.25*(coderInfo->scale_factor[sb] - coderInfo->global_gain));
  506. error_energy[sb] = 0.0;
  508. for (i = coderInfo->sfb_offset[sb]; i < coderInfo->sfb_offset[sb+1]; i++){
  509. requant_xr[i] = pow43[xi[i]] * invQuantFac; 
  511. /* measure the distortion in each scalefactor band */
  512. linediff = fabs(xr[i]) - requant_xr[i];
  513. error_energy[sb] += linediff * linediff;
  514. }
  515. error_energy[sb] = error_energy[sb] / sbw;
  517. noise = error_energy[sb] / xmin[sb];
  519. /* multiplying here is adding in dB */
  520. tot_noise *= max(noise, 1E-20);
  521. if (noise>1) {
  522. over++;
  523. /* multiplying here is adding in dB */
  524. over_noise *= noise;
  525. }
  526. max_noise = max(max_noise,noise);
  527. error_energy[sb] = noise;
  528. count++;
  529.    }
  531. res->tot_count  = count;
  532. res->over_count = over;
  533. res->tot_noise   = 10.*log10(max(1e-20,tot_noise )); 
  534. res->over_noise  = 10.*log10(max(1e+00,over_noise)); 
  535. res->max_noise   = 10.*log10(max(1e-20,max_noise ));
  537. return over;
  538. }
  541. static int QuantCompare(calcNoiseResult *best,
  542. calcNoiseResult *calc)
  543. {
  544. int better;
  546. better = calc->over_count  < best->over_count
  547. ||  ( calc->over_count == best->over_count  &&
  548. calc->over_noise  < best->over_noise )
  549. ||  ( calc->over_count == best->over_count  &&
  550. calc->over_noise == best->over_noise  &&
  551. calc->tot_noise   < best->tot_noise  ); 
  553. return better;
  554. }
  556. static int BalanceNoise(CoderInfo *coderInfo,
  557. double *distort,
  558. double *xrpow)
  559. {
  560. int status = 0, sb;
  562. AmpScalefacBands(coderInfo, distort, xrpow);
  564. for (sb = 0; sb < coderInfo->nr_of_sfb; sb++)
  565. if (coderInfo->scale_factor[sb] == 0)
  566. status = 1;
  568. return status;
  569. }
  571. static void AmpScalefacBands(CoderInfo *coderInfo,
  572.  double *distort,
  573.  double *xr_pow)
  574. {
  575. int start, end, l, sfb;
  576. double ifqstep, distort_thresh;
  578. ifqstep = pow(2.0, 0.1875);
  580. distort_thresh = -900;
  581. for (sfb = 0; sfb < coderInfo->nr_of_sfb; sfb++) {
  582. distort_thresh = max(distort[sfb], distort_thresh);
  583. }
  585. if (distort_thresh>1.0)
  586. distort_thresh=1.0;
  587. else
  588. distort_thresh *= .95;
  590.     for ( sfb = 0; sfb < coderInfo->nr_of_sfb; sfb++ ) {
  591. if (distort[sfb] > distort_thresh) {
  592. coderInfo->scale_factor[sfb]++;
  593. start = coderInfo->sfb_offset[sfb];
  594. end   = coderInfo->sfb_offset[sfb+1];
  595. for ( l = start; l < end; l++ ) {
  596. xr_pow[l] *= ifqstep;
  597. }
  598. }
  599.     }
  600. }
  603. static int SortForGrouping(CoderInfo* coderInfo,
  604.    PsyInfo *psyInfo,
  605.    ChannelInfo *channelInfo,
  606.    int *sfb_width_table,
  607.    double *xr)
  608. {
  609. int i,j,ii;
  610. int index = 0;
  611. double xr_tmp[1024];
  612. double thr_tmp[150];
  613. double en_tmp[150];
  614. int book=1;
  615. int group_offset=0;
  616. int k=0;
  617. int windowOffset = 0;
  620. /* set up local variables for used quantInfo elements */
  621. int* sfb_offset = coderInfo->sfb_offset;
  622. int* nr_of_sfb = &(coderInfo->nr_of_sfb);
  623. int* window_group_length;
  624. int num_window_groups;
  625. *nr_of_sfb = coderInfo->max_sfb;              /* Init to max_sfb */
  626. window_group_length = coderInfo->window_group_length;
  627. num_window_groups = coderInfo->num_window_groups;
  629. /* calc org sfb_offset just for shortblock */
  630. sfb_offset[k]=0;
  631. for (k=1 ; k <*nr_of_sfb+1; k++) {
  632. sfb_offset[k] = sfb_offset[k-1] + sfb_width_table[k-1];
  633. }
  635. /* sort the input spectral coefficients */
  636. index = 0;
  637. group_offset=0;
  638. for (i=0; i< num_window_groups; i++) {
  639. for (k=0; k<*nr_of_sfb; k++) {
  640. for (j=0; j < window_group_length[i]; j++) {
  641. for (ii=0;ii< sfb_width_table[k];ii++)
  642. xr_tmp[index++] = xr[ii+ sfb_offset[k] + 128*j +group_offset];
  643. }
  644. }
  645. group_offset +=  128*window_group_length[i];     
  646. }
  648. for (k=0; k<1024; k++){
  649. xr[k] = xr_tmp[k];
  650. }
  653. /* now calc the new sfb_offset table for the whole p_spectrum vector*/
  654. index = 0;
  655. sfb_offset[index++] = 0;
  656. windowOffset = 0;
  657. for (i=0; i < num_window_groups; i++) {
  658. for (k=0 ; k <*nr_of_sfb; k++) {
  659. int w;
  660. double worstTHR;
  661. double worstEN;
  663. /* for this window group and this band, find worst case inverse sig-mask-ratio */
  664. if (channelInfo->msInfo.is_present && channelInfo->msInfo.ms_usedS[windowOffset][k]) {
  665. worstTHR = psyInfo->maskThrSMS[windowOffset][k];
  666. worstEN = psyInfo->maskEnSMS[windowOffset][k];
  667. } else {
  668. worstTHR = psyInfo->maskThrS[windowOffset][k];
  669. worstEN = psyInfo->maskEnS[windowOffset][k];
  670. }
  672. for (w=1;w<window_group_length[i];w++) {
  673. if (channelInfo->msInfo.is_present && channelInfo->msInfo.ms_usedS[w+windowOffset][k]) {
  674. if (psyInfo->maskThrSMS[w+windowOffset][k] < worstTHR) {
  675. worstTHR = psyInfo->maskThrSMS[w+windowOffset][k];
  676. worstEN = psyInfo->maskEnSMS[w+windowOffset][k];
  677. }
  678. } else {
  679. if (psyInfo->maskThrS[w+windowOffset][k] < worstTHR) {
  680. worstTHR = psyInfo->maskThrS[w+windowOffset][k];
  681. worstEN = psyInfo->maskEnS[w+windowOffset][k];
  682. }
  683. }
  684. }
  685. thr_tmp[k+ i* *nr_of_sfb] = worstTHR;
  686. en_tmp[k+ i* *nr_of_sfb] = worstEN;
  687. sfb_offset[index] = sfb_offset[index-1] + sfb_width_table[k]*window_group_length[i] ;
  688. index++;
  689. }
  690. windowOffset += window_group_length[i];
  691. }
  693. *nr_of_sfb = *nr_of_sfb * num_window_groups;  /* Number interleaved bands. */
  695. for (k = 0; k < *nr_of_sfb; k++){
  696. psyInfo->maskThr[k] = thr_tmp[k];
  697. psyInfo->maskEn[k] = en_tmp[k];
  698. }
  700. return 0;
  701. }