Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 : #include <stdio.h>
6 : #include <stdlib.h>
7 : #include <assert.h>
8 : #include "options.h"
9 : #include "cnst.h"
10 : #include "stl.h"
11 : #include "prot_fx.h"
12 : #include "prot_fx_enc.h" /* Function prototypes */
13 : #include "stat_enc.h"
14 : #include "basop_util.h"
15 :
16 :
17 : /*-------------------------------------------------------------------*
18 : * IGF_write_bit_fx()
19 : *
20 : * write single bit to stream
21 : *-------------------------------------------------------------------*/
22 :
23 8758605 : static void IGF_write_bit_fx(
24 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
25 : Word16 *bitCount, /* i/o: bit counter */
26 : const Word16 value /* i : value */
27 : )
28 : {
29 8758605 : IF( hBstr )
30 : {
31 4431224 : push_next_indice( hBstr, value, 1 );
32 : }
33 :
34 8758605 : ( *bitCount ) = add( ( *bitCount ), 1 );
35 8758605 : move16();
36 :
37 8758605 : return;
38 : }
39 :
40 : /*-------------------------------------------------------------------*
41 : * IGF_write_bits()
42 : *
43 : * write bits to stream
44 : *-------------------------------------------------------------------*/
45 :
46 7392469 : static void IGF_write_bits(
47 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
48 : Word16 *bitCount, /* i/o: bit counter */
49 : const Word16 value, /* i/o: value */
50 : Word16 bits /* i : number of bits */
51 : )
52 : {
53 14784938 : WHILE( bits-- )
54 : {
55 7392469 : IF( s_and( value, shl( 1, bits ) ) == 0 )
56 : {
57 2364856 : IGF_write_bit_fx( hBstr, bitCount, 0 );
58 : }
59 : ELSE
60 : {
61 5027613 : IGF_write_bit_fx( hBstr, bitCount, 1 );
62 : }
63 : }
64 :
65 7392469 : return;
66 : }
67 :
68 :
69 : /**********************************************************************/ /*
70 : envelope estimation
71 : **************************************************************************/
72 634 : static void IGF_CalculateEnvelope(
73 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
74 : Word32 *pMDCTSpectrum, /**< in: Q31 | MDCT spectrum */
75 : Word16 MDCTSpectrum_e, /**< in: | exponent of MDCT spectrum */
76 : Word32 *pPowerSpectrum, /**< in: Q31 | MDCT^2 + MDST^2 spectrum, or estimate */
77 : Word16 PowerSpectrum_e, /**< in: | exponent of MDCT^2 + MDST^2 spectrum, or estimate */
78 : const Word16 igfGridIdx /**< in: Q0 | IGF grid index */
79 :
80 : )
81 : {
82 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
83 : H_IGF_GRID hGrid;
84 : Word16 *swb_offset;
85 : Word16 sfb; /* this is the actual scalefactor band */
86 : Word16 width; /* this is width in subbands of the actual scalefactor band */
87 : Word16 tile_idx;
88 : Word16 strt_cpy;
89 : Word16 gain; /* the gain which has to be applied to the source tile to get the destination energy */
90 : Word16 gain_exp;
91 : Word16 tb;
92 : Word16 zeroNrg; /* Q0 | flag indicating if the signal contains almost no energy */
93 : Word32 sfbEnergyR[IGF_MAX_SFB];
94 : Word16 sfbEnergyR_exp[IGF_MAX_SFB];
95 : Word32 sfbEnergyC[IGF_MAX_SFB]; /* the energy of the destination region of the tile */
96 : Word16 sfbEnergyC_exp[IGF_MAX_SFB];
97 : Word32 sfbEnergyTileR[IGF_MAX_SFB];
98 : Word16 sfbEnergyTileR_exp[IGF_MAX_SFB];
99 : Word32 sfbEnergyTileC[IGF_MAX_SFB]; /* the energy of the destination region of the tile */
100 : Word16 sfbEnergyTileC_exp[IGF_MAX_SFB];
101 : Word32 LFMDCTSpectrum[N_MAX];
102 : Word16 LFMDCTSpectrum_exp;
103 : Word32 LFPowerSpectrum[N_MAX];
104 : Word16 tmp;
105 : Word16 tmp_exp;
106 : Word32 L_tmp;
107 : Word16 shift;
108 :
109 : /* initialize variables */
110 634 : Copy32( pMDCTSpectrum + IGF_START_MN, hInstance->spec_be_igf, hInstance->infoStopLine - IGF_START_MN );
111 634 : hPrivateData = &hInstance->igfData;
112 634 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
113 634 : swb_offset = hGrid->swb_offset;
114 634 : move16();
115 634 : hInstance->spec_be_igf_e = MDCTSpectrum_e;
116 634 : move16();
117 634 : zeroNrg = 0;
118 634 : move16();
119 :
120 :
121 634 : IF( pPowerSpectrum != NULL )
122 : {
123 2258 : FOR( tile_idx = 0; tile_idx < hGrid->nTiles; tile_idx++ )
124 : {
125 1628 : strt_cpy = hGrid->sbWrap[tile_idx];
126 1628 : move16();
127 6144 : FOR( sfb = hGrid->sfbWrap[tile_idx]; sfb < hGrid->sfbWrap[tile_idx + 1]; sfb++ )
128 : {
129 230426 : FOR( tb = swb_offset[sfb]; tb < swb_offset[sfb + 1]; tb++ )
130 : {
131 225910 : LFMDCTSpectrum[tb] = pMDCTSpectrum[strt_cpy];
132 225910 : move32();
133 225910 : LFPowerSpectrum[tb] = pPowerSpectrum[strt_cpy];
134 225910 : move32();
135 225910 : strt_cpy = add( strt_cpy, 1 );
136 : }
137 : }
138 : }
139 630 : IGFCommonFuncsCalcSfbEnergyPowerSpec( hGrid->startSfb,
140 630 : hGrid->stopSfb,
141 630 : hGrid->swb_offset,
142 : pPowerSpectrum,
143 : &PowerSpectrum_e,
144 : sfbEnergyC,
145 : sfbEnergyC_exp );
146 630 : IGFCommonFuncsCalcSfbEnergyPowerSpec( hGrid->startSfb,
147 630 : hGrid->stopSfb,
148 630 : hGrid->swb_offset,
149 : LFPowerSpectrum,
150 : &PowerSpectrum_e,
151 : sfbEnergyTileC,
152 : sfbEnergyTileC_exp );
153 630 : IGFCommonFuncsMDCTSquareSpec( hGrid->startLine,
154 630 : hGrid->stopLine,
155 : LFMDCTSpectrum,
156 : MDCTSpectrum_e,
157 : LFMDCTSpectrum,
158 : &LFMDCTSpectrum_exp,
159 : 0 );
160 630 : IGFCommonFuncsCalcSfbEnergyPowerSpec( hGrid->startSfb,
161 630 : hGrid->stopSfb,
162 630 : hGrid->swb_offset,
163 : LFMDCTSpectrum,
164 : &LFMDCTSpectrum_exp,
165 : sfbEnergyTileR,
166 : sfbEnergyTileR_exp );
167 : }
168 : ELSE
169 : {
170 4 : IGFCommonFuncsMDCTSquareSpec( hGrid->startLine,
171 4 : hGrid->stopLine,
172 : pMDCTSpectrum,
173 : MDCTSpectrum_e,
174 : LFMDCTSpectrum,
175 : &LFMDCTSpectrum_exp,
176 : 0 );
177 4 : IGFCommonFuncsCalcSfbEnergyPowerSpec( hGrid->startSfb,
178 4 : hGrid->stopSfb,
179 4 : hGrid->swb_offset,
180 : LFMDCTSpectrum,
181 : &LFMDCTSpectrum_exp,
182 : sfbEnergyR,
183 : sfbEnergyR_exp );
184 : }
185 :
186 2274 : FOR( tile_idx = 0; tile_idx < hGrid->nTiles; tile_idx++ )
187 : {
188 :
189 6188 : FOR( sfb = hGrid->sfbWrap[tile_idx]; sfb < hGrid->sfbWrap[tile_idx + 1]; sfb++ )
190 : {
191 :
192 :
193 4548 : width = sub( swb_offset[sfb + 1], swb_offset[sfb] );
194 4548 : L_tmp = 0;
195 4548 : move16();
196 4548 : gain_exp = 0;
197 4548 : move16();
198 :
199 4548 : IF( pPowerSpectrum )
200 : {
201 4516 : IF( sfbEnergyTileR[sfb] == 0 )
202 : {
203 0 : sfbEnergyTileR[sfb] = 0x00010000;
204 0 : move32();
205 0 : sfbEnergyTileR_exp[sfb] = 0;
206 0 : move16();
207 0 : zeroNrg = 1;
208 0 : move16();
209 : }
210 4516 : IF( sfbEnergyTileC[sfb] == 0 )
211 : {
212 0 : sfbEnergyTileC[sfb] = 0x00010000;
213 0 : move32();
214 0 : sfbEnergyTileC_exp[sfb] = 0;
215 0 : move16();
216 0 : zeroNrg = 1;
217 0 : move16();
218 : }
219 4516 : IF( sfbEnergyC[sfb] == 0 )
220 : {
221 0 : sfbEnergyC[sfb] = 0x00010000;
222 0 : move32();
223 0 : sfbEnergyC_exp[sfb] = 0;
224 0 : move16();
225 0 : zeroNrg = 1;
226 0 : move16();
227 : }
228 :
229 4516 : BASOP_Util_Divide_MantExp( round_fx_sat( sfbEnergyTileR[sfb] ), sfbEnergyTileR_exp[sfb], width, 15, &gain, &gain_exp );
230 4516 : BASOP_Util_Divide_MantExp( round_fx_sat( sfbEnergyC[sfb] ), sfbEnergyC_exp[sfb], round_fx_sat( sfbEnergyTileC[sfb] ), sfbEnergyTileC_exp[sfb], &tmp, &tmp_exp );
231 4516 : L_tmp = L_mult( gain, tmp );
232 4516 : gain_exp = add( gain_exp, tmp_exp );
233 : }
234 : ELSE
235 : {
236 32 : IF( sfbEnergyR[sfb] == 0 )
237 : {
238 0 : sfbEnergyR[sfb] = 0x00010000;
239 0 : move32();
240 0 : sfbEnergyR_exp[sfb] = 0;
241 0 : move16();
242 0 : zeroNrg = 1;
243 0 : move16();
244 : }
245 32 : BASOP_Util_Divide_MantExp( round_fx_sat( sfbEnergyR[sfb] ),
246 32 : sfbEnergyR_exp[sfb],
247 : width,
248 : 15,
249 : &gain,
250 : &gain_exp );
251 32 : L_tmp = L_deposit_h( gain );
252 : }
253 :
254 : /* gain = 0.5f + (float)((2.885390081777927f * log(gain) + 16.f)); */
255 4548 : L_tmp = BASOP_Util_Log2( L_tmp );
256 4548 : L_tmp = L_add( L_tmp, L_deposit_h( shl( gain_exp, 15 - 6 ) ) );
257 4548 : shift = norm_l( L_tmp );
258 4548 : gain = round_fx_sat( L_shl( L_tmp, shift ) );
259 4548 : gain_exp = sub( 7, shift );
260 4548 : gain_exp = BASOP_Util_Add_MantExp( gain, gain_exp, 32767 /*16 Q11*/, 4, &gain );
261 4548 : gain_exp = BASOP_Util_Add_MantExp( gain, gain_exp, 0x4000, 0, &gain );
262 4548 : gain = shr( gain, s_min( sub( 15, gain_exp ), 15 ) );
263 :
264 4548 : if ( gain > 91 )
265 : {
266 0 : gain = s_min( gain, 91 ); /* 13+15+63, see arithocde encode residual */
267 : }
268 4548 : if ( gain < 0 )
269 : {
270 0 : gain = s_max( gain, 0 );
271 : }
272 :
273 : /* set gain to zero if the signal contains too less energy */
274 4548 : if ( zeroNrg != 0 )
275 : {
276 0 : gain = 0;
277 0 : move16();
278 : }
279 :
280 4548 : hPrivateData->igfScfQuantized[sfb] = gain;
281 4548 : move16();
282 : }
283 : }
284 :
285 634 : return;
286 : }
287 :
288 :
289 : /**********************************************************************/ /*
290 : writes IGF SCF values
291 : **************************************************************************/
292 :
293 : /**< out: Q0 | number of bits writen */
294 1268 : static void IGF_WriteEnvelope(
295 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
296 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
297 : Word16 *pBitOffset, /**< in: | ptr to bitOffset counter */
298 : const Word16 igfGridIdx, /**< in: Q0 | igf grid index see declaration of IGF_GRID_IDX for details */
299 : const Word16 isIndepFlag, /**< in: Q0 | if 1 frame is independent, 0 = frame is coded with data from previous frame */
300 : Word16 *igfAllZero /**< in: Q0 | returns 1 if all IGF scfs are zero, else 0 */
301 : )
302 : {
303 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
304 : H_IGF_GRID hGrid;
305 : Word16 sfb;
306 :
307 1268 : *igfAllZero = 1;
308 1268 : move16();
309 1268 : hPrivateData = &hInstance->igfData;
310 1268 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
311 :
312 1268 : FOR( sfb = hGrid->startSfb; sfb < hGrid->stopSfb; sfb++ )
313 : {
314 1268 : IF( hPrivateData->igfScfQuantized[sfb] != 0 )
315 : {
316 1268 : *igfAllZero = 0;
317 1268 : move16();
318 1268 : BREAK;
319 : }
320 : }
321 :
322 1268 : IF( *igfAllZero != 0 )
323 : {
324 0 : IGF_write_bit_fx( hBstr, pBitOffset, 1 );
325 0 : if ( NULL == hBstr )
326 : {
327 0 : IGFSCFEncoderSaveContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
328 : }
329 0 : IGFSCFEncoderReset_fx( &hPrivateData->hIGFSCFArithEnc );
330 0 : if ( NULL == hBstr )
331 : {
332 0 : IGFSCFEncoderRestoreContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
333 : }
334 : }
335 : ELSE
336 : {
337 1268 : IGF_write_bit_fx( hBstr, pBitOffset, 0 );
338 1268 : if ( NULL == hBstr )
339 : {
340 634 : IGFSCFEncoderSaveContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
341 : }
342 :
343 1268 : *pBitOffset = IGFSCFEncoderEncode_fx( &hPrivateData->hIGFSCFArithEnc, hBstr, *pBitOffset, &hPrivateData->igfScfQuantized[hGrid->startSfb], igfGridIdx, isIndepFlag );
344 1268 : move16();
345 :
346 1268 : if ( NULL == hBstr )
347 : {
348 634 : IGFSCFEncoderRestoreContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
349 : }
350 : }
351 1268 : }
352 :
353 : /**********************************************************************/ /*
354 : identifies significant spectral content
355 : **************************************************************************/
356 634 : void IGF_ErodeSpectrum( Word16 *highPassEner_exp, /**< out: | exponent of highPassEner */
357 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
358 : Word32 *pSpectrum, /**< in/out: | MDCT spectrum */
359 : Word32 *pPowerSpectrum, /**< in/out: | power spectrum */
360 : Word16 pPowerSpectrum_exp, /**< in: | exponent of power spectrum */
361 : const Word16 igfGridIdx /**< in: Q0 | IGF grid index */
362 : )
363 : {
364 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
365 : H_IGF_GRID hGrid;
366 : Word16 i;
367 : Word16 igfBgn;
368 : Word16 igfEnd;
369 : Word32 highPassEner; /* Q31 */
370 : Word32 lastLine;
371 : Word32 nextLine;
372 : Word32 highPassEner_Ovfl;
373 : Word16 s;
374 : Word16 tmploop;
375 : Word16 *swb_offset;
376 : Word16 sfb;
377 : Word16 startSfb;
378 : Word16 stopSfb;
379 : Word16 line;
380 : Word16 flag;
381 : Word16 *igfScaleF;
382 : Word16 tmp;
383 : Word32 L_tmp;
384 :
385 634 : hPrivateData = &hInstance->igfData;
386 634 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
387 634 : igfBgn = hGrid->startLine;
388 634 : move16();
389 634 : igfEnd = hGrid->stopLine;
390 634 : move16();
391 634 : swb_offset = hGrid->swb_offset;
392 634 : move16();
393 634 : startSfb = hGrid->startSfb;
394 634 : move16();
395 634 : stopSfb = hGrid->stopSfb;
396 634 : move16();
397 634 : igfScaleF = hPrivateData->igfScfQuantized;
398 634 : move16();
399 634 : *highPassEner_exp = 0;
400 634 : move16();
401 634 : highPassEner = 0;
402 634 : move32();
403 :
404 634 : IF( NULL == pPowerSpectrum )
405 : {
406 0 : FOR( i = igfBgn; i < hGrid->infoGranuleLen; i++ )
407 : {
408 0 : pSpectrum[i] = L_deposit_l( 0 );
409 : }
410 0 : return;
411 : }
412 :
413 634 : IF( igfBgn > 0 )
414 : {
415 634 : Word64 W_highPassEner = 0;
416 634 : move64();
417 165370 : FOR( i = 0; i < igfBgn; i++ )
418 : {
419 164736 : W_highPassEner = W_add( W_highPassEner, W_deposit32_l( Mpy_32_16_1( pPowerSpectrum[i], shl( i, 4 ) /*Q4*/ ) ) /*Q20, pPowerSpectrum_exp*/ );
420 : }
421 :
422 634 : highPassEner = w_norm_llQ31( W_highPassEner, highPassEner_exp ); /*Q20, highPassEner_exp*/
423 634 : *highPassEner_exp = add( *highPassEner_exp, pPowerSpectrum_exp );
424 634 : move16();
425 634 : test();
426 634 : test();
427 1268 : if ( NE_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_9600 ) &&
428 1268 : NE_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_RF_SWB_13200 ) &&
429 634 : NE_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_13200 ) )
430 : {
431 372 : igfBgn = shl( igfBgn, 1 );
432 : }
433 634 : highPassEner = L_deposit_l( BASOP_Util_Divide3216_Scale( highPassEner /*Q20, highPassEner_exp*/, igfBgn /*Q0*/, &s ) ); /*Q15, highPassEner_exp+11-16+s*/
434 634 : *highPassEner_exp = add( add( *highPassEner_exp, s ), 12 - 16 + ( 31 - 15 ) ); /*Q15->Q31,highPassEner_exp*/
435 634 : lastLine = pSpectrum[i - 1];
436 634 : move32();
437 634 : nextLine = 0;
438 634 : move32();
439 :
440 : /* May overflow - just for threshold comparison */
441 : /* negate because the negated may be 1 larger in abs, */
442 : /* so whenever compared to the negation of a maximum possible pPowerspectrum, it is still larger */
443 634 : highPassEner_Ovfl = L_shl_sat( L_negate( highPassEner ), sub( *highPassEner_exp, pPowerSpectrum_exp ) );
444 634 : L_tmp = L_add_sat( pPowerSpectrum[i - 1], highPassEner_Ovfl );
445 :
446 634 : if ( L_tmp >= 0 )
447 : {
448 0 : nextLine = pSpectrum[i];
449 0 : move32();
450 : }
451 634 : tmploop = sub( igfEnd, 1 );
452 227446 : FOR( /*i*/; i < tmploop; i++ )
453 : {
454 : /* May overflow - just for threshold comparison */
455 : BASOP_SATURATE_WARNING_OFF_EVS
456 226812 : L_tmp = L_add_sat( pPowerSpectrum[i], highPassEner_Ovfl );
457 : BASOP_SATURATE_WARNING_ON_EVS;
458 :
459 226812 : IF( L_tmp < 0 )
460 : {
461 226781 : lastLine = pSpectrum[i];
462 226781 : move32();
463 226781 : pSpectrum[i] = nextLine;
464 226781 : move32();
465 226781 : nextLine = 0;
466 226781 : move32();
467 : }
468 : ELSE
469 : {
470 31 : pSpectrum[i - 1] = lastLine;
471 31 : move32();
472 31 : lastLine = pSpectrum[i];
473 31 : move32();
474 31 : nextLine = pSpectrum[i + 1];
475 31 : move32();
476 : }
477 : }
478 :
479 : /* May overflow - just for threshold comparison */
480 : BASOP_SATURATE_WARNING_OFF_EVS
481 634 : L_tmp = L_add_sat( pPowerSpectrum[i], highPassEner_Ovfl );
482 : BASOP_SATURATE_WARNING_ON_EVS
483 634 : if ( L_tmp < 0 )
484 : {
485 634 : pSpectrum[i] = L_deposit_l( 0 );
486 634 : move32();
487 : }
488 : }
489 :
490 : /* delete spectrum above igfEnd: */
491 20292 : FOR( i = igfEnd; i < hGrid->infoGranuleLen; i++ )
492 : {
493 19658 : pSpectrum[i] = L_deposit_l( 0 );
494 19658 : move32();
495 19658 : pPowerSpectrum[i] = L_deposit_l( 0 );
496 19658 : move32();
497 : }
498 :
499 5182 : FOR( sfb = startSfb; sfb < stopSfb; sfb++ )
500 : {
501 4548 : flag = 0;
502 4548 : move16();
503 231994 : FOR( line = swb_offset[sfb]; line < swb_offset[sfb + 1]; line++ )
504 : {
505 227446 : if ( pSpectrum[line] != 0 )
506 : {
507 61 : flag = 1;
508 61 : move16();
509 : }
510 : }
511 4548 : tmp = igfScaleF[sfb];
512 4548 : move16();
513 4548 : if ( flag )
514 : {
515 7 : tmp = sub( igfScaleF[sfb], 1 );
516 : }
517 4548 : if ( igfScaleF[sfb] )
518 : {
519 4548 : igfScaleF[sfb] = tmp;
520 4548 : move16();
521 : }
522 : }
523 : }
524 :
525 695699 : void IGF_ErodeSpectrum_ivas_fx( const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
526 : Word32 *pSpectrum, /**< in/out: | MDCT spectrum Qx*/
527 : Word32 *pPowerSpectrum, /**< in/out: | power spectrum */
528 : Word16 pPowerSpectrum_exp, /**< in: | exponent of power spectrum */
529 : const Word16 igfGridIdx, /**< in: Q0 | IGF grid index */
530 : const Word16 mct_on )
531 : {
532 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
533 : H_IGF_GRID hGrid;
534 : Word16 i;
535 : Word16 igfBgn;
536 : Word16 igfEnd;
537 : Word32 highPassEner; /* Q31 */
538 : Word32 lastLine;
539 : Word32 nextLine;
540 : Word16 *swb_offset;
541 : Word16 sfb;
542 : Word16 startSfb;
543 : Word16 stopSfb;
544 : Word16 line;
545 : Word16 *igfScaleF;
546 : Word16 tmp;
547 : Word16 factor;
548 : Word16 exp1, exp2;
549 : Word16 num, den;
550 : Word32 temp;
551 :
552 695699 : hPrivateData = &hInstance->igfData;
553 695699 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
554 695699 : igfBgn = hGrid->startLine;
555 695699 : move16();
556 695699 : igfEnd = hGrid->stopLine;
557 695699 : move16();
558 695699 : swb_offset = hGrid->swb_offset;
559 695699 : move16();
560 695699 : startSfb = hGrid->startSfb;
561 695699 : move16();
562 695699 : stopSfb = hGrid->stopSfb;
563 695699 : move16();
564 695699 : igfScaleF = hPrivateData->igfScfQuantized;
565 695699 : move16();
566 :
567 695699 : IF( NULL == pPowerSpectrum )
568 : {
569 5411730 : FOR( i = igfBgn; i < hGrid->infoGranuleLen; i++ )
570 : {
571 5385200 : pSpectrum[i] = 0;
572 5385200 : move32();
573 : }
574 26530 : return;
575 : }
576 :
577 669169 : IF( igfBgn > 0 )
578 : {
579 669169 : Word64 sum = 0;
580 669169 : move64();
581 300714911 : FOR( i = 0; i < igfBgn; i++ )
582 : {
583 300045742 : sum = W_mac_32_16( sum, pPowerSpectrum[i], i ); // Q: 31-pPowerSpectrum_exp+1
584 : }
585 669169 : exp1 = W_norm( sum );
586 669169 : sum = W_shl( sum, sub( exp1, 1 ) ); // Q: 31-pPowerSpectrum_exp+1+exp1-1
587 669169 : num = extract_h( W_extract_h( sum ) ); // Q: 31-pPowerSpectrum_exp+exp1-48 = -pPowerSpectrum_exp+exp1-17
588 669169 : exp1 = add( 32, sub( pPowerSpectrum_exp, exp1 ) ); // exp: 32+pPowerSpectrum_exp-exp1
589 :
590 669169 : IF( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_9600 ) ||
591 : EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_RF_SWB_13200 ) ||
592 : EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_13200 ) ||
593 : EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_16400_CPE ) )
594 : {
595 29660 : factor = ONE_IN_Q14; // Q14
596 29660 : move16();
597 : }
598 639509 : ELSE IF( mct_on && ( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_48000_CPE ) || EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_64000_CPE ) ) )
599 : {
600 4144 : factor = 11469; // 0.7f in Q14
601 4144 : move16();
602 : }
603 : ELSE
604 : {
605 635365 : factor = 32767; // 2.f in Q14
606 635365 : move16();
607 : }
608 :
609 669169 : temp = L_mult( igfBgn, factor ); // exp: 16
610 669169 : exp2 = norm_l( temp );
611 669169 : den = extract_h( L_shl( temp, exp2 ) ); // exp: 16-exp2
612 669169 : exp2 = sub( 16, exp2 );
613 :
614 669169 : highPassEner = L_deposit_h( div_s( num, den ) ); // exp: exp1-exp2
615 :
616 : /* highPassEner is used only for comparison, saturation doesn't effect the outcome */
617 669169 : highPassEner = L_shl_sat( highPassEner, sub( sub( exp1, exp2 ), pPowerSpectrum_exp ) ); // exp: pPowerSpectrum_exp
618 :
619 669169 : lastLine = pSpectrum[i - 1]; // Qx
620 669169 : move32();
621 669169 : nextLine = pSpectrum[i]; // Qx
622 669169 : move32();
623 :
624 669169 : if ( LT_32( pPowerSpectrum[i - 1], highPassEner ) )
625 : {
626 660734 : nextLine = 0;
627 660734 : move32();
628 : }
629 :
630 203790404 : FOR( /*i*/; i < igfEnd - 1; i++ )
631 : {
632 : /* May overflow - just for threshold comparison */
633 203121235 : IF( LT_32( pPowerSpectrum[i], highPassEner ) )
634 : {
635 199376038 : lastLine = pSpectrum[i]; // Qx
636 199376038 : move32();
637 199376038 : pSpectrum[i] = nextLine; // Qx
638 199376038 : move32();
639 199376038 : nextLine = 0;
640 199376038 : move32();
641 : }
642 : ELSE
643 : {
644 3745197 : pSpectrum[i - 1] = lastLine; // Qx
645 3745197 : move32();
646 3745197 : lastLine = pSpectrum[i]; // Qx
647 3745197 : move32();
648 3745197 : nextLine = pSpectrum[i + 1]; // Qx
649 3745197 : move32();
650 : }
651 : }
652 :
653 : /* May overflow - just for threshold comparison */
654 669169 : if ( LT_32( pPowerSpectrum[i], highPassEner ) )
655 : {
656 660715 : pSpectrum[i] = 0;
657 660715 : move32();
658 : }
659 : }
660 :
661 : /* delete spectrum above igfEnd: */
662 82378863 : FOR( i = igfEnd; i < hGrid->infoGranuleLen; i++ )
663 : {
664 81709694 : pSpectrum[i] = 0;
665 81709694 : pPowerSpectrum[i] = 0;
666 81709694 : move32();
667 81709694 : move32();
668 : }
669 :
670 : // Below check is present at the beginning of the function and is not required here
671 : /* IF( NULL != pPowerSpectrum ) */
672 : {
673 4277592 : FOR( sfb = startSfb; sfb < stopSfb; sfb++ )
674 : {
675 3608423 : tmp = 0;
676 3608423 : move16();
677 207398827 : FOR( line = swb_offset[sfb]; line < swb_offset[sfb + 1]; line++ )
678 : {
679 203790404 : if ( pSpectrum[line] != 0 )
680 : {
681 83699 : tmp = add( tmp, 1 );
682 : }
683 : }
684 :
685 3608423 : Word16 igfScaleF_cnt = igfScaleF[sfb];
686 3608423 : move16();
687 3608423 : test();
688 3608423 : if ( tmp && igfScaleF[sfb] )
689 : {
690 2989 : igfScaleF_cnt = sub( igfScaleF[sfb], 1 );
691 : }
692 3608423 : igfScaleF[sfb] = igfScaleF_cnt;
693 3608423 : move16();
694 : }
695 : }
696 : }
697 :
698 : /**********************************************************************/ /*
699 : crest factor calculation
700 : **************************************************************************/
701 1224 : Word16 IGF_getCrest( /**< out: Q15| crest factor */
702 : Word16 *crest_exp, /**< out: | exponent of crest factor */
703 : const Word32 *powerSpectrum, /**< in: Q31 | power spectrum */
704 : const Word16 powerSpectrum_exp, /**< in: | exponent of power spectrum */
705 : const Word16 start, /**< in: Q0 | start subband index */
706 : const Word16 stop /**< in: Q0 | stop subband index */
707 : )
708 : {
709 : Word16 i;
710 : Word16 x;
711 : Word16 s;
712 : Word32 x_eff32;
713 : Word16 x_max;
714 : Word16 crest;
715 : Word16 tmp;
716 : Word32 tmp32;
717 :
718 1224 : x_eff32 = 0;
719 1224 : move32();
720 1224 : x_max = 0;
721 1224 : move16();
722 1224 : crest = 16384 /*.5f Q15*/;
723 1224 : move16();
724 1224 : *crest_exp = 1;
725 1224 : move16();
726 :
727 197654 : FOR( i = start; i < stop; i++ )
728 : {
729 : /*x = max(0, (int)(log(powerSpectrum[i]) * INV_LOG_2));*/
730 :
731 : /*see IGF_getSFM for more comment */
732 196430 : x = sub( sub( powerSpectrum_exp, norm_l( powerSpectrum[i] ) ), 1 ); /*Q0*/
733 196430 : if ( powerSpectrum[i] == 0 ) /*special case: energy is zero*/
734 : {
735 564 : x = 0;
736 564 : move16();
737 : }
738 196430 : x = s_max( 0, x );
739 196430 : x_eff32 = L_mac0( x_eff32, x, x ); /*Q0*/
740 196430 : x_max = s_max( x_max, x ); /*Q0*/
741 : }
742 :
743 : /*x_eff /= (stop - start);*/
744 1224 : x_eff32 = BASOP_Util_Divide3216_Scale( x_eff32, sub( stop, start ), &s ); /*Q-1, s*/
745 1224 : s = add( s, 32 ); /*make x_eff Q31*/
746 :
747 : /*trunkate to int*/
748 1224 : x_eff32 = L_shr( x_eff32, sub( 31, s ) );
749 1224 : x_eff32 = L_shl( x_eff32, sub( 31, s ) );
750 :
751 1224 : test();
752 1224 : IF( x_eff32 > 0 && x_max > 0 )
753 : {
754 : /*crest = max(1.f, (float)x_max/sqrt(x_eff));*/
755 1034 : tmp32 = ISqrt32( x_eff32, &s ); /*Q31, s*/
756 1034 : tmp32 = Mpy_32_16_1( tmp32 /*Q31, s*/, x_max /*Q0*/ ); /*Q16, s*/
757 1034 : i = norm_l( tmp32 );
758 1034 : tmp32 = L_shl( tmp32, i ); /*Q31, s-i+15*/
759 1034 : crest = extract_h( tmp32 );
760 1034 : *crest_exp = add( sub( s, i ), 15 );
761 1034 : move16();
762 : /* limit crest factor to a lower bound of 1, may overflow */
763 : BASOP_SATURATE_WARNING_OFF_EVS
764 1034 : tmp = shl_sat( -1, sub( 15, *crest_exp ) ); /* build negative threshold */
765 1034 : tmp = add_sat( crest, tmp );
766 : BASOP_SATURATE_WARNING_ON_EVS
767 1034 : if ( tmp < 0 )
768 : {
769 0 : crest = 1;
770 0 : move16();
771 : }
772 1034 : if ( tmp < 0 )
773 : {
774 0 : *crest_exp = 15;
775 0 : move16();
776 : }
777 : }
778 :
779 1224 : return crest;
780 : }
781 :
782 1069327 : Word16 IGF_getCrest_ivas( /**< out: Q15| crest factor */
783 : Word16 *crest_exp, /**< out: | exponent of crest factor */
784 : const Word32 *powerSpectrum, /**< in: Q31 | power spectrum */
785 : const Word16 *powerSpectrum_exp, /**< in: | exponent of power spectrum */
786 : const Word16 start, /**< in: Q0 | start subband index */
787 : const Word16 stop /**< in: Q0 | stop subband index */
788 : )
789 : {
790 : Word16 i;
791 : Word16 x;
792 : Word16 s;
793 : Word32 x_eff32;
794 : Word16 x_max;
795 : Word16 crest;
796 : Word16 tmp;
797 : Word32 tmp32;
798 :
799 1069327 : x_eff32 = 0;
800 1069327 : move32();
801 1069327 : x_max = 0;
802 1069327 : move16();
803 1069327 : crest = 16384 /*.5f Q15*/;
804 1069327 : move16();
805 1069327 : *crest_exp = 1;
806 1069327 : move16();
807 :
808 56846291 : FOR( i = start; i < stop; i++ )
809 : {
810 : /*x = max(0, (int)(log(powerSpectrum[i]) * INV_LOG_2));*/
811 :
812 : /*see IGF_getSFM for more comment */
813 55776964 : x = sub( sub( powerSpectrum_exp[i], norm_l( powerSpectrum[i] ) ), 1 ); /*Q0*/
814 55776964 : if ( powerSpectrum[i] == 0 ) /*special case: energy is zero*/
815 : {
816 2413 : x = 0;
817 2413 : move16();
818 : }
819 55776964 : x = s_max( 0, x );
820 55776964 : x_eff32 = L_mac0( x_eff32, x, x ); /*Q0*/
821 55776964 : x_max = s_max( x_max, x ); /*Q0*/
822 : }
823 :
824 : /*x_eff /= (stop - start);*/
825 1069327 : x_eff32 = BASOP_Util_Divide3216_Scale( x_eff32, sub( stop, start ), &s ); /*Q-1, s*/
826 1069327 : s = add( s, 32 ); /*make x_eff Q31*/
827 :
828 : /*trunkate to int*/
829 1069327 : x_eff32 = L_shr( x_eff32, sub( 31, s ) );
830 1069327 : x_eff32 = L_shl( x_eff32, sub( 31, s ) );
831 :
832 1069327 : test();
833 1069327 : IF( x_eff32 > 0 && x_max > 0 )
834 : {
835 : /*crest = max(1.f, (float)x_max/sqrt(x_eff));*/
836 1004696 : tmp32 = ISqrt32( x_eff32, &s ); /*Q31, s*/
837 1004696 : tmp32 = Mpy_32_16_1( tmp32 /*Q31, s*/, x_max /*Q0*/ ); /*Q16, s*/
838 1004696 : i = norm_l( tmp32 );
839 1004696 : tmp32 = L_shl( tmp32, i ); /*Q31, s-i+15*/
840 1004696 : crest = extract_h( tmp32 );
841 1004696 : *crest_exp = add( sub( s, i ), 15 );
842 1004696 : move16();
843 : /* limit crest factor to a lower bound of 1, may overflow */
844 : BASOP_SATURATE_WARNING_OFF_EVS
845 1004696 : tmp = shl_sat( -1, sub( 15, *crest_exp ) ); /* build negative threshold */
846 1004696 : tmp = add_sat( crest, tmp );
847 : BASOP_SATURATE_WARNING_ON_EVS
848 1004696 : if ( tmp < 0 )
849 : {
850 2 : crest = 1;
851 2 : move16();
852 : }
853 1004696 : if ( tmp < 0 )
854 : {
855 2 : *crest_exp = 15;
856 2 : move16();
857 : }
858 : }
859 :
860 1069327 : return crest;
861 : }
862 :
863 : /*************************************************************************
864 : calculates spectral flatness measurment
865 : **************************************************************************/
866 1224 : Word16 IGF_getSFM( /**< out: Q15| SFM value */
867 : Word16 *SFM_exp, /**< out: | exponent of SFM Factor */
868 : const Word32 *energy, /**< in: Q31| energies */
869 : const Word16 *energy_exp, /**< in: | exponent of energies */
870 : const Word16 start, /**< in: Q0 | start subband index */
871 : const Word16 stop /**< in: Q0 | stop subband index */
872 : )
873 : {
874 : Word16 n, i, s;
875 : Word32 num;
876 : Word32 denom;
877 : Word16 denom_exp;
878 : Word16 invDenom_exp, numf_exp;
879 : Word16 numf;
880 : Word32 SFM32;
881 : Word16 invDenom, SFM;
882 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
883 1224 : move32();
884 1224 : move32();
885 : #endif
886 :
887 1224 : move32();
888 1224 : num = 0;
889 1224 : move32();
890 1224 : denom = L_shr( 2147483 /*0,001 in Q31 - float is "1", here*/, s_min( *energy_exp, 31 ) );
891 1224 : denom = L_max( denom, 1 );
892 1224 : *SFM_exp = 0;
893 1224 : move16();
894 1224 : SFM = 32767 /*1.0f Q15*/;
895 1224 : move16();
896 :
897 1224 : Word64 W_denom = W_deposit32_l( denom );
898 197654 : FOR( i = start; i < stop; i++ )
899 : {
900 : /*ln(x * 2^-Qx * 2^xExp) = ln(x) - Qx + xExp*/
901 :
902 : /* n = sub(sub(31,norm_l(tmp32)),1); */ /*<- ld */
903 : /* n = sub(n,31); */ /*<- -Qx */
904 : /* n = add(n,*energy_exp); */ /*<- +xExp */
905 :
906 196430 : n = sub( sub( *energy_exp, norm_l( energy[i] ) ), 1 ); /*<-- short form*/
907 :
908 196430 : if ( energy[i] == 0 ) /*special case: energy is zero*/
909 : {
910 564 : n = 0;
911 564 : move16();
912 : }
913 :
914 196430 : n = s_max( 0, n );
915 196430 : num = L_add( num, L_deposit_l( n ) ); /*Q0*/
916 :
917 196430 : W_denom = W_add( W_deposit32_l( energy[i] ), W_denom );
918 : }
919 :
920 1224 : denom = w_norm_llQ31( W_denom, &denom_exp ); /*Q31*/
921 1224 : denom_exp = add( denom_exp, *energy_exp );
922 :
923 : /* calculate SFM only if signal is present */
924 1224 : IF( denom != 0 )
925 : {
926 : /*numf = (float)num / (float)(stop - start);*/
927 1224 : numf = BASOP_Util_Divide3216_Scale( num, /*Q0*/
928 1224 : sub( stop, start ), /*Q0*/
929 : &s ); /*Q-1 s*/
930 1224 : numf_exp = add( s, 16 ); /*-> numf Q15 numf_exp*/
931 : /*denom /= (float)(stop - start);*/
932 : /*return ((float)pow(2.0, numf + 0.5f) / denom);*/
933 :
934 : /*SFM= ((float)pow(2.0, numf + 0.5f) * invDenom);*/
935 1224 : invDenom = BASOP_Util_Divide3232_uu_1616_Scale( L_deposit_l( sub( stop, start ) ) /*Q0*/,
936 : denom /*Q31, denom_exp*/,
937 : &s ); /*Q-16, s-denom_exp*/
938 1224 : invDenom_exp = add( sub( s, denom_exp ), 31 ); /*invDenom: Q15, invDenom_exp*/
939 :
940 : /*add .5f to numf*/
941 1224 : SFM32 = L_add( L_shl( L_deposit_l( numf ), numf_exp ) /*16Q15*/, 16384l /*.5f Q15*/ ); /*16Q15*/
942 1224 : s = norm_l( SFM32 );
943 1224 : SFM32 = L_shl( SFM32, s );
944 1224 : s = sub( 16, s ); /*SFM32(numf) is Q31 now*/
945 :
946 : /*do the pow2 and the mult*/
947 1224 : SFM32 = BASOP_util_Pow2( SFM32, s, &s );
948 1224 : SFM32 = Mpy_32_16_1( SFM32, invDenom );
949 1224 : *SFM_exp = add( s, invDenom_exp );
950 :
951 : /*Transform to Q15*/
952 1224 : s = norm_l( SFM32 );
953 1224 : SFM = round_fx_sat( L_shl_sat( SFM32, s ) );
954 1224 : *SFM_exp = sub( *SFM_exp, s );
955 1224 : move16();
956 : /**SFM_exp = s_min(*SFM_exp, 0);*/
957 1224 : IF( *SFM_exp > 0 )
958 : {
959 187 : *SFM_exp = 0;
960 187 : move16();
961 187 : SFM = 32767 /*1.0f Q15*/;
962 187 : move16();
963 : }
964 : }
965 :
966 1224 : return SFM /*Q15*/;
967 : }
968 :
969 : /*************************************************************************
970 : calculates spectral flatness measurment
971 : **************************************************************************/
972 1069327 : Word16 IGF_getSFM_ivas_fx( /**< out: Q15| SFM value */
973 : Word16 *SFM_exp, /**< out: | exponent of SFM Factor */
974 : const Word32 *energy, /**< in: Q31| energies */
975 : const Word16 *energy_exp, /**< in: | exponent of energies */
976 : const Word16 start, /**< in: Q0 | start subband index */
977 : const Word16 stop /**< in: Q0 | stop subband index */
978 : )
979 : {
980 : Word16 n, i, s;
981 : Word32 num;
982 : Word32 denom;
983 : Word16 denom_exp;
984 : Word16 invDenom_exp, numf_exp;
985 : Word16 numf;
986 : Word32 SFM32;
987 : Word16 invDenom, SFM;
988 :
989 1069327 : num = 0;
990 1069327 : move32();
991 1069327 : denom = 65536; // 1.f in Q16
992 1069327 : denom_exp = 15;
993 1069327 : *SFM_exp = 0;
994 1069327 : move16();
995 1069327 : SFM = 32767 /*1.0f Q15*/;
996 1069327 : move16();
997 :
998 56846291 : FOR( i = start; i < stop; i++ )
999 : {
1000 : /*ln(x * 2^-Qx * 2^xExp) = ln(x) - Qx + xExp*/
1001 :
1002 : /* n = sub(sub(31,norm_l(tmp32)),1); */ /*<- ld */
1003 : /* n = sub(n,31); */ /*<- -Qx */
1004 : /* n = add(n,*energy_exp); */ /*<- +xExp */
1005 :
1006 55776964 : n = sub( sub( energy_exp[i], norm_l( energy[i] ) ), 1 ); /*<-- short form*/
1007 :
1008 55776964 : if ( energy[i] == 0 ) /*special case: energy is zero*/
1009 : {
1010 2413 : n = 0;
1011 2413 : move16();
1012 : }
1013 :
1014 55776964 : n = s_max( 0, n );
1015 55776964 : num = L_add( num, L_deposit_l( n ) ); /*Q0*/
1016 :
1017 55776964 : denom = BASOP_Util_Add_Mant32Exp( energy[i], energy_exp[i], denom, denom_exp, &denom_exp );
1018 : }
1019 :
1020 : /* calculate SFM only if signal is present */
1021 1069327 : IF( denom != 0 )
1022 : {
1023 : /*numf = (float)num / (float)(stop - start);*/
1024 1069327 : numf = BASOP_Util_Divide3216_Scale( num, /*Q0*/
1025 1069327 : sub( stop, start ), /*Q0*/
1026 : &s ); /*Q-1 s*/
1027 1069327 : numf_exp = add( s, 16 ); /*-> numf Q15 numf_exp*/
1028 : /*denom /= (float)(stop - start);*/
1029 : /*return ((float)pow(2.0, numf + 0.5f) / denom);*/
1030 :
1031 : /*SFM= ((float)pow(2.0, numf + 0.5f) * invDenom);*/
1032 1069327 : invDenom = BASOP_Util_Divide3232_uu_1616_Scale( L_deposit_l( sub( stop, start ) ) /*Q0*/,
1033 : denom /*Q31, denom_exp*/,
1034 : &s ); /*Q-16, s-denom_exp*/
1035 1069327 : invDenom_exp = add( sub( s, denom_exp ), 31 ); /*invDenom: Q15, invDenom_exp*/
1036 :
1037 : /*add .5f to numf*/
1038 1069327 : SFM32 = L_add( L_shl( L_deposit_l( numf ), numf_exp ) /*16Q15*/, 16384l /*.5f Q15*/ ); /*16Q15*/
1039 1069327 : s = norm_l( SFM32 );
1040 1069327 : SFM32 = L_shl( SFM32, s );
1041 1069327 : s = sub( 16, s ); /*SFM32(numf) is Q31 now*/
1042 :
1043 : /*do the pow2 and the mult*/
1044 1069327 : SFM32 = BASOP_util_Pow2( SFM32, s, &s );
1045 1069327 : SFM32 = Mpy_32_16_1( SFM32, invDenom );
1046 1069327 : *SFM_exp = add( s, invDenom_exp );
1047 :
1048 : /*Transform to Q15*/
1049 1069327 : s = norm_l( SFM32 );
1050 1069327 : SFM = round_fx_sat( L_shl_sat( SFM32, s ) );
1051 1069327 : *SFM_exp = sub( *SFM_exp, s );
1052 1069327 : move16();
1053 : /**SFM_exp = s_min(*SFM_exp, 0);*/
1054 1069327 : IF( *SFM_exp > 0 )
1055 : {
1056 63122 : *SFM_exp = 0;
1057 63122 : move16();
1058 63122 : SFM = 32767 /*1.0f Q15*/;
1059 63122 : move16();
1060 : }
1061 : }
1062 :
1063 1069327 : return SFM /*Q15*/;
1064 : }
1065 :
1066 : /**********************************************************************/ /*
1067 : calculates the IGF whitening levels by SFM and crest
1068 : **************************************************************************/
1069 634 : static void IGF_Whitening( const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
1070 : Word32 *powerSpectrum, /**< in: Q31 | MDCT/MDST power spectrum */
1071 : const Word16 powerSpectrum_exp, /**< in: | exponent of powerspectrum */
1072 : const Word16 igfGridIdx, /**< in: Q0 | IGF grid index */
1073 : Word16 isTransient, /**< in: Q0 | boolean, indicating if transient is detected */
1074 : Word16 last_core_acelp /**< in: Q0 | indictaor if last frame was acelp coded */
1075 : )
1076 : {
1077 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1078 : H_IGF_GRID hGrid;
1079 : Word16 p; /*Q0*/
1080 : Word16 tmp;
1081 : Word16 SFM;
1082 : Word16 crest;
1083 : Word16 SFM_exp;
1084 : Word16 crest_exp;
1085 : Word16 s;
1086 : Word32 tmp32;
1087 : Word32 SFM32;
1088 :
1089 634 : hPrivateData = &hInstance->igfData;
1090 634 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
1091 :
1092 634 : IF( igfGridIdx != IGF_GRID_LB_NORM )
1093 : {
1094 137 : FOR( p = 0; p < hGrid->nTiles; p++ )
1095 : {
1096 : /* reset filter */
1097 99 : hPrivateData->prevSFM_FIR[p] = L_deposit_l( 0 );
1098 99 : move32();
1099 99 : hPrivateData->prevSFM_IIR[p] = 0;
1100 99 : move16();
1101 :
1102 : /* preset values: */
1103 99 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
1104 99 : move16();
1105 : }
1106 : }
1107 6974 : FOR( p = 0; p < IGF_MAX_TILES; p++ )
1108 : {
1109 : /* update prev data: */
1110 6340 : hPrivateData->igfPrevWhiteningLevel[p] = hPrivateData->igfCurrWhiteningLevel[p];
1111 6340 : move16();
1112 : /* preset values: */
1113 6340 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
1114 6340 : move16();
1115 : }
1116 :
1117 634 : IF( !s_or( isTransient, hPrivateData->wasTransient ) )
1118 : {
1119 612 : IF( powerSpectrum )
1120 : {
1121 612 : Word16 nT = hGrid->nTiles;
1122 612 : move16();
1123 612 : SWITCH( hPrivateData->igfInfo.bitRateIndex )
1124 : {
1125 370 : case IGF_BITRATE_WB_9600:
1126 : case IGF_BITRATE_SWB_9600:
1127 : case IGF_BITRATE_SWB_16400:
1128 : case IGF_BITRATE_SWB_24400:
1129 : case IGF_BITRATE_SWB_32000:
1130 : case IGF_BITRATE_FB_16400:
1131 : case IGF_BITRATE_FB_24400:
1132 : case IGF_BITRATE_FB_32000:
1133 370 : nT = sub( nT, 1 );
1134 370 : BREAK;
1135 242 : default:
1136 242 : BREAK;
1137 : }
1138 1836 : FOR( p = 0; p < nT; p++ )
1139 : {
1140 : /*tmp = IGF_getSFM(powerSpectrum, hGrid->tile[p], hGrid->tile[p+1]) / IGF_getCrest(powerSpectrum, hGrid->tile[p], hGrid->tile[p+1]);*/
1141 1224 : SFM = IGF_getSFM( &SFM_exp, powerSpectrum, &powerSpectrum_exp, hGrid->tile[p], hGrid->tile[p + 1] );
1142 1224 : crest = IGF_getCrest( &crest_exp, powerSpectrum, powerSpectrum_exp, hGrid->tile[p], hGrid->tile[p + 1] );
1143 :
1144 1224 : tmp = BASOP_Util_Divide1616_Scale( SFM, crest, &s ); /* Q15 */
1145 1224 : s = add( s, sub( SFM_exp, crest_exp ) );
1146 1224 : tmp32 = L_shl( L_deposit_l( tmp ) /*16Q15, s*/, add( s, 1 ) ); /* 15Q16 */
1147 :
1148 1224 : test();
1149 1224 : IF( last_core_acelp || hPrivateData->wasTransient )
1150 : {
1151 76 : hPrivateData->prevSFM_FIR[p] = tmp32; /* 15Q16 */
1152 76 : move32();
1153 76 : hPrivateData->prevSFM_IIR[p] = shr( tmp, 2 ); /* 2Q13 */
1154 76 : move16();
1155 : }
1156 :
1157 : /*SFM = tmp + hPrivateData->prevSFM_FIR[p] + 0.5f * hPrivateData->prevSFM_IIR[p];*/
1158 1224 : SFM32 = L_add( tmp32, hPrivateData->prevSFM_FIR[p] );
1159 1224 : SFM32 = L_mac0( SFM32, hPrivateData->prevSFM_IIR[p] /*Q13*/, 4 /*.5f Q3*/ ); /*15Q16*/
1160 :
1161 : BASOP_SATURATE_WARNING_OFF_EVS
1162 : /*SFM = min(2.7f, SFM);*/
1163 : /*Overflow possible in shift, intended*/
1164 1224 : tmp = add_sat( crest, tmp );
1165 1224 : SFM = s_min( 22118 /*2.7f Q13*/, extract_h( L_shr_sat( SFM32, 16 - 29 ) /*->Q29*/ ) /*->Q13*/ );
1166 : BASOP_SATURATE_WARNING_ON_EVS
1167 :
1168 1224 : hPrivateData->prevSFM_FIR[p] = tmp32; /*15Q16*/
1169 1224 : move32();
1170 1224 : hPrivateData->prevSFM_IIR[p] = SFM;
1171 1224 : move16();
1172 :
1173 1224 : IF( GT_16( SFM, hGrid->whiteningThreshold[1][p] ) )
1174 : {
1175 585 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_STRONG;
1176 585 : move16();
1177 : }
1178 639 : ELSE IF( GT_16( SFM, hGrid->whiteningThreshold[0][p] ) )
1179 : {
1180 436 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
1181 436 : move16();
1182 : }
1183 : }
1184 612 : SWITCH( hPrivateData->igfInfo.bitRateIndex )
1185 : {
1186 370 : case IGF_BITRATE_WB_9600:
1187 : case IGF_BITRATE_RF_WB_13200:
1188 : case IGF_BITRATE_RF_SWB_13200:
1189 : case IGF_BITRATE_SWB_9600:
1190 : case IGF_BITRATE_SWB_16400:
1191 : case IGF_BITRATE_SWB_24400:
1192 : case IGF_BITRATE_SWB_32000:
1193 : case IGF_BITRATE_FB_16400:
1194 : case IGF_BITRATE_FB_24400:
1195 : case IGF_BITRATE_FB_32000:
1196 370 : move16();
1197 370 : hPrivateData->igfCurrWhiteningLevel[hGrid->nTiles - 1] = hPrivateData->igfCurrWhiteningLevel[hGrid->nTiles - 2];
1198 370 : BREAK;
1199 242 : default:
1200 242 : BREAK;
1201 : }
1202 : }
1203 : ELSE
1204 : {
1205 0 : FOR( p = 0; p < hGrid->nTiles; p++ )
1206 : {
1207 0 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
1208 0 : move16();
1209 : }
1210 : }
1211 : }
1212 : ELSE
1213 : {
1214 : /* reset filter */
1215 242 : FOR( p = 0; p < IGF_MAX_TILES; p++ )
1216 : {
1217 220 : hPrivateData->prevSFM_FIR[p] = L_deposit_l( 0 );
1218 220 : move32();
1219 220 : hPrivateData->prevSFM_IIR[p] = 0;
1220 220 : move16();
1221 : }
1222 : }
1223 634 : hPrivateData->wasTransient = isTransient;
1224 634 : move16();
1225 :
1226 634 : return;
1227 : }
1228 :
1229 :
1230 : /**********************************************************************/ /*
1231 : write whitening levels into bitstream
1232 : **************************************************************************/
1233 :
1234 : /**< out: Q0 | number of bits written */
1235 2032 : static void IGF_WriteWhiteningTile_fx(
1236 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1237 : Word16 *pBitOffset, /**< in: | ptr to bitOffset counter */
1238 : Word16 whiteningLevel /**< in: Q0 | whitening levels to write */
1239 : )
1240 : {
1241 2032 : IF( EQ_32( whiteningLevel, IGF_WHITENING_MID ) )
1242 : {
1243 708 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1244 : }
1245 : ELSE
1246 : {
1247 1324 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1248 1324 : IF( EQ_32( whiteningLevel, IGF_WHITENING_OFF ) )
1249 : {
1250 374 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1251 : }
1252 : ELSE
1253 : {
1254 950 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1255 : }
1256 : }
1257 :
1258 2032 : return;
1259 : }
1260 :
1261 : /**********************************************************************/ /*
1262 : writes the whitening levels
1263 : **************************************************************************/
1264 1268 : static void IGF_WriteWhiteningLevels_fx( /**< out: Q0 | total number of bits written */
1265 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF encoder */
1266 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1267 : Word16 *pBitOffset, /**< in: | ptr to bitOffset counter */
1268 : const Word16 igfGridIdx, /**< in: Q0 | igf grid index see declaration of IGF_GRID_IDX for details */
1269 : const Word16 isIndepFlag /**< in: Q0 | if 1 frame is independent, 0 = frame is coded with data from previous frame */
1270 : )
1271 : {
1272 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1273 : H_IGF_GRID hGrid;
1274 : Word16 p;
1275 : Word16 nTiles;
1276 : Word16 isSame;
1277 : Word32 tmp32;
1278 :
1279 :
1280 1268 : isSame = 1;
1281 1268 : move16();
1282 1268 : hPrivateData = &hInstance->igfData;
1283 1268 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
1284 1268 : nTiles = hGrid->nTiles;
1285 1268 : move16();
1286 :
1287 1268 : IF( isIndepFlag )
1288 : {
1289 1268 : isSame = 0;
1290 1268 : move16();
1291 : }
1292 : ELSE
1293 : {
1294 0 : p = 0;
1295 0 : move16();
1296 0 : tmp32 = 0;
1297 0 : move32();
1298 0 : test();
1299 0 : WHILE( ( LT_16( p, nTiles ) ) && ( tmp32 == 0 ) )
1300 : {
1301 0 : test();
1302 0 : tmp32 = L_sub( hPrivateData->igfCurrWhiteningLevel[p], hPrivateData->igfPrevWhiteningLevel[p] );
1303 0 : if ( tmp32 != 0 )
1304 : {
1305 0 : isSame = 0;
1306 0 : move16();
1307 : }
1308 0 : p++;
1309 : }
1310 : }
1311 1268 : IF( isSame )
1312 : {
1313 0 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1314 : }
1315 : ELSE
1316 : {
1317 1268 : IF( !isIndepFlag )
1318 : {
1319 0 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1320 : }
1321 1268 : IGF_WriteWhiteningTile_fx( hBstr, pBitOffset, hPrivateData->igfCurrWhiteningLevel[0] );
1322 1268 : p = 1;
1323 1268 : move16();
1324 1268 : tmp32 = 0;
1325 1268 : move32();
1326 1268 : if ( LT_16( p, nTiles ) )
1327 : {
1328 1268 : isSame = 1;
1329 1268 : move16();
1330 : }
1331 1268 : test();
1332 2972 : WHILE( ( LT_16( p, nTiles ) ) && ( tmp32 == 0 ) )
1333 : {
1334 1704 : test();
1335 1704 : tmp32 = L_sub( hPrivateData->igfCurrWhiteningLevel[p], hPrivateData->igfCurrWhiteningLevel[p - 1] );
1336 1704 : if ( tmp32 != 0 )
1337 : {
1338 456 : isSame = 0;
1339 456 : move16();
1340 : }
1341 1704 : p++;
1342 : }
1343 :
1344 1268 : IF( !isSame )
1345 : {
1346 456 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1347 1220 : FOR( p = 1; p < nTiles; p++ )
1348 : {
1349 764 : IGF_WriteWhiteningTile_fx( hBstr, pBitOffset, hPrivateData->igfCurrWhiteningLevel[p] );
1350 : }
1351 : }
1352 : ELSE
1353 : {
1354 812 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1355 : }
1356 : }
1357 1268 : }
1358 :
1359 : /**********************************************************************/ /*
1360 : write flattening trigger
1361 : **************************************************************************/
1362 1268 : static void IGF_WriteFlatteningTrigger_fx( /**< out: | number of bits written */
1363 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
1364 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1365 : Word16 *pBitOffset /**< in: | ptr to bitOffset counter */
1366 : )
1367 : {
1368 : Word16 flatteningTrigger;
1369 :
1370 :
1371 1268 : flatteningTrigger = hInstance->flatteningTrigger;
1372 1268 : move16();
1373 :
1374 1268 : IGF_write_bits( hBstr, pBitOffset, flatteningTrigger, 1 );
1375 1268 : }
1376 :
1377 : /**********************************************************************/ /*
1378 : updates the start/stop frequency of IGF according to igfGridIdx
1379 : **************************************************************************/
1380 1392032 : void IGF_UpdateInfo( const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
1381 : const Word16 igfGridIdx /**< in: Q0 | IGF grid index */
1382 : )
1383 : {
1384 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1385 : H_IGF_GRID hGrid;
1386 :
1387 :
1388 1392032 : hPrivateData = &hInstance->igfData;
1389 1392032 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
1390 1392032 : hInstance->infoStartFrequency = hGrid->startFrequency;
1391 1392032 : move16();
1392 1392032 : hInstance->infoStopFrequency = hGrid->stopFrequency;
1393 1392032 : move16();
1394 1392032 : hInstance->infoStartLine = hGrid->startLine;
1395 1392032 : move16();
1396 1392032 : hInstance->infoStopLine = hGrid->stopLine;
1397 1392032 : move16();
1398 :
1399 1392032 : return;
1400 : }
1401 :
1402 : /**********************************************************************/ /*
1403 : IGF bitsream writer
1404 : **************************************************************************/
1405 1268 : Word16 IGFEncWriteBitstream_fx( /**< out: | number of bits written per frame */
1406 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
1407 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1408 : Word16 *pBitOffset, /**< in: | ptr to bitOffset counter */
1409 : const Word16 igfGridIdx, /**< in: Q0 | igf grid index see declaration of IGF_GRID_IDX for details */
1410 : const Word16 isIndepFlag /**< in: Q0 | if 1 frame is independent, 0 = frame is coded with data from previous frame */
1411 : )
1412 : {
1413 : Word16 igfAllZero;
1414 : Word16 startBitCount;
1415 :
1416 :
1417 1268 : startBitCount = *pBitOffset;
1418 1268 : move16();
1419 1268 : hInstance->infoTotalBitsPerFrameWritten = 0;
1420 1268 : move16();
1421 :
1422 1268 : if ( isIndepFlag )
1423 : {
1424 1268 : hInstance->infoTotalBitsWritten = 0;
1425 1268 : move16();
1426 : }
1427 :
1428 1268 : IGF_WriteEnvelope( hInstance, /* i: instance handle of IGF Encoder */
1429 : hBstr, /* i: encoder state */
1430 : pBitOffset, /* i: ptr to bitOffset counter */
1431 : igfGridIdx, /* i: igf grid index see definition of IGF_GRID_IDX for details */
1432 : isIndepFlag, /* i: if 1 frame is independent, 0 = frame is coded with data from previous frame */
1433 : &igfAllZero ); /* o: *igfAllZero */
1434 :
1435 1268 : IGF_WriteWhiteningLevels_fx( hInstance, /* i: instance handle of IGF Encoder */
1436 : hBstr, /* i: encoder state */
1437 : pBitOffset, /* i: ptr to bitOffset counter */
1438 : igfGridIdx, /* i: igf grid index see definition of IGF_GRID_IDX for details */
1439 : isIndepFlag ); /* i: if 1 frame is independent, 0 = frame is coded with data from previous frame */
1440 :
1441 1268 : IGF_WriteFlatteningTrigger_fx( hInstance, /* i: instance handle of IGF Encoder */
1442 : hBstr, /* i: encoder state */
1443 : pBitOffset ); /* i: ptr to bitOffset counter */
1444 :
1445 1268 : hInstance->infoTotalBitsPerFrameWritten = sub( *pBitOffset, startBitCount );
1446 1268 : hInstance->infoTotalBitsWritten = add( hInstance->infoTotalBitsWritten, hInstance->infoTotalBitsPerFrameWritten );
1447 1268 : move16();
1448 1268 : move16();
1449 1268 : return hInstance->infoTotalBitsPerFrameWritten;
1450 : }
1451 :
1452 : /**********************************************************************/ /*
1453 : sets the IGF mode according to given bitrate
1454 : **************************************************************************/
1455 89 : void IGFEncSetMode_fx(
1456 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i/o: instance handle of IGF Encoder */
1457 : const Word32 total_brate, /* i : encoder total bitrate */
1458 : const Word16 bwidth, /* i : encoder audio bandwidth */
1459 : const Word16 element_mode, /* i : IVAS element mode */
1460 : const Word16 rf_mode /* i : flag to signal the RF mode */
1461 : )
1462 : {
1463 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1464 : Word16 i;
1465 :
1466 89 : hPrivateData = &hIGFEnc->igfData;
1467 89 : hPrivateData->igfBitstreamBits = 0;
1468 89 : move16();
1469 89 : set16_fx( hPrivateData->igfScfQuantized, 0, IGF_MAX_SFB );
1470 89 : set16_fx( hPrivateData->igfCurrWhiteningLevel, 0, IGF_MAX_TILES );
1471 89 : set16_fx( hPrivateData->igfPrevWhiteningLevel, 0, IGF_MAX_TILES );
1472 28569 : FOR( i = 0; i < IGF_BITBUFSIZE / 8; i++ )
1473 : {
1474 28480 : hPrivateData->igfBitstream[i] = 0;
1475 28480 : move16();
1476 : }
1477 89 : hPrivateData->wasTransient = 0;
1478 89 : move16();
1479 89 : set32_fx( hPrivateData->prevSFM_FIR, 0, IGF_MAX_TILES );
1480 89 : set16_fx( hPrivateData->prevSFM_IIR, 0, IGF_MAX_TILES );
1481 :
1482 89 : IF( IGFCommonFuncsIGFConfiguration( total_brate, bwidth, element_mode, &hPrivateData->igfInfo, rf_mode ) != 0 )
1483 : {
1484 89 : IGFSCFEncoderOpen_fx( &hPrivateData->hIGFSCFArithEnc, &hPrivateData->igfInfo, total_brate, bwidth, element_mode, rf_mode );
1485 :
1486 89 : hIGFEnc->infoSamplingRate = hPrivateData->igfInfo.sampleRate;
1487 89 : move32();
1488 89 : hIGFEnc->infoStartFrequency = hPrivateData->igfInfo.grid[0].startFrequency;
1489 89 : move16();
1490 89 : hIGFEnc->infoStopFrequency = hPrivateData->igfInfo.grid[0].stopFrequency;
1491 89 : move16();
1492 89 : hIGFEnc->infoStartLine = hPrivateData->igfInfo.grid[0].startLine;
1493 89 : move16();
1494 89 : hIGFEnc->infoStopLine = hPrivateData->igfInfo.grid[0].stopLine;
1495 89 : move16();
1496 : }
1497 : ELSE
1498 : {
1499 : /* IGF configuration failed -> error! */
1500 0 : hIGFEnc->infoSamplingRate = 0;
1501 0 : move32();
1502 0 : hIGFEnc->infoStartFrequency = -1;
1503 0 : move16();
1504 0 : hIGFEnc->infoStopFrequency = -1;
1505 0 : move16();
1506 0 : hIGFEnc->infoStartLine = -1;
1507 0 : move16();
1508 0 : hIGFEnc->infoStopLine = -1;
1509 0 : move16();
1510 0 : fprintf( stderr, "IGFEncSetMode_fx: initialization error!\n" );
1511 : }
1512 :
1513 : /* reset remaining variables */
1514 89 : hIGFEnc->infoTotalBitsWritten = 0;
1515 89 : move16();
1516 89 : hIGFEnc->infoTotalBitsPerFrameWritten = 0;
1517 89 : move16();
1518 89 : hIGFEnc->flatteningTrigger = 0;
1519 89 : move16();
1520 89 : hIGFEnc->spec_be_igf_e = 0;
1521 89 : move16();
1522 89 : hIGFEnc->tns_predictionGain = 0;
1523 89 : move16();
1524 89 : set32_fx( hIGFEnc->spec_be_igf, 0, N_MAX_TCX - IGF_START_MN );
1525 89 : return;
1526 : }
1527 :
1528 : /*-------------------------------------------------------------------*
1529 : * pack_bit()
1530 : *
1531 : * insert a bit into packed octet
1532 : *-------------------------------------------------------------------*/
1533 :
1534 598230 : static void pack_bit_fx(
1535 : const Word16 bit, /* i : bit to be packed */
1536 : UWord8 **pt, /* i/o: pointer to octet array into which bit will be placed */
1537 : UWord8 *omask /* i/o: output mask to indicate where in the octet the bit is to be written */
1538 : )
1539 : {
1540 598230 : if ( EQ_16( *omask, 0x80 ) )
1541 : {
1542 80877 : **pt = 0;
1543 80877 : move16();
1544 : }
1545 :
1546 598230 : if ( bit != 0 )
1547 : {
1548 319699 : **pt = (UWord8) s_or( **pt, *omask );
1549 319699 : move16();
1550 : }
1551 :
1552 598230 : *omask = (UWord8) UL_lshr( *omask, 1 );
1553 598230 : move16();
1554 598230 : IF( *omask == 0 )
1555 : {
1556 69018 : *omask = 0x80;
1557 69018 : move16();
1558 69018 : ( *pt )++;
1559 : }
1560 :
1561 598230 : return;
1562 : }
1563 :
1564 : /*-------------------------------------------------------------------*
1565 : * IGFEncConcatenateBitstream_fx()
1566 : *
1567 : * IGF bitstream concatenation for TCX10 modes
1568 : *-------------------------------------------------------------------*/
1569 :
1570 26530 : void IGFEncConcatenateBitstream_ivas_fx( const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
1571 : const Word16 bsBits, /* i : number of IGF bits written to list of indices */
1572 : BSTR_ENC_HANDLE hBstr /* i/o: bitstream handle */
1573 : )
1574 : {
1575 : Word16 i;
1576 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1577 : Indice *ind_list;
1578 : UWord8 *pFrame; /* byte array with bit packet and byte aligned coded speech data */
1579 : Word16 *pFrame_size; /* number of bits in the binary encoded access unit [bits] */
1580 : Word16 k, nb_bits_written;
1581 : Word32 imask;
1582 : UWord8 omask;
1583 :
1584 26530 : hPrivateData = &hIGFEnc->igfData;
1585 :
1586 26530 : ind_list = &hBstr->ind_list[hBstr->nb_ind_tot - bsBits]; /* here, we assume that each bit has been written as a single indice */
1587 26530 : pFrame = hPrivateData->igfBitstream;
1588 26530 : move16();
1589 26530 : pFrame_size = &hPrivateData->igfBitstreamBits;
1590 26530 : move16();
1591 26530 : nb_bits_written = 0;
1592 26530 : move16();
1593 :
1594 26530 : omask = (UWord8) UL_lshr( 0x80, s_and( *pFrame_size, 0x7 ) );
1595 26530 : move16();
1596 26530 : pFrame += *pFrame_size >> 3;
1597 :
1598 : /* bitstream packing (conversion of individual indices into a serial stream) */
1599 624760 : FOR( i = 0; i < bsBits; i++ ){
1600 598230 : IF( ind_list[i].nb_bits > 0 ){
1601 : /* mask from MSB to LSB */
1602 598230 : imask = L_shl( 1, sub( ind_list[i].nb_bits, 1 ) );
1603 :
1604 : /* write bit by bit */
1605 1196460 : FOR( k = 0; k < ind_list[i].nb_bits; k++ )
1606 : {
1607 598230 : pack_bit_fx( extract_l( L_and( ind_list[i].value, imask ) ), &pFrame, &omask );
1608 598230 : imask = L_shr( imask, 1 );
1609 : }
1610 598230 : nb_bits_written = add( nb_bits_written, ind_list[i].nb_bits );
1611 :
1612 : /* delete the indice */
1613 598230 : ind_list[i].nb_bits = -1;
1614 598230 : move16();
1615 : }
1616 : }
1617 :
1618 26530 : *pFrame_size = add( *pFrame_size, nb_bits_written );
1619 26530 : move16();
1620 :
1621 : /* update list of indices */
1622 26530 : hBstr->nb_ind_tot = sub( hBstr->nb_ind_tot, bsBits );
1623 26530 : hBstr->nb_bits_tot = sub( hBstr->nb_bits_tot, nb_bits_written );
1624 :
1625 26530 : return;
1626 : }
1627 :
1628 :
1629 : /**********************************************************************/ /*
1630 : IGF write concatenated bitsream for TCX10 modes
1631 : **************************************************************************/
1632 :
1633 : /**< out: Q0 | total number of bits written */
1634 0 : Word16 IGFEncWriteConcatenatedBitstream_fx(
1635 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
1636 : BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */
1637 : )
1638 : {
1639 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1640 : Word16 i;
1641 : Word16 tmp;
1642 : Word16 bitsLeft;
1643 : UWord8 *pBitstream;
1644 :
1645 0 : hPrivateData = &hInstance->igfData;
1646 0 : pBitstream = &hPrivateData->igfBitstream[0];
1647 :
1648 0 : tmp = shr( hPrivateData->igfBitstreamBits, 3 );
1649 0 : FOR( i = 0; i < tmp; i++ )
1650 : {
1651 0 : push_next_indice( hBstr, pBitstream[i], 8 );
1652 : }
1653 :
1654 0 : bitsLeft = s_and( hPrivateData->igfBitstreamBits, 0x7 );
1655 0 : IF( bitsLeft > 0 )
1656 : {
1657 0 : push_next_indice( hBstr, shr( pBitstream[i], sub( 8, bitsLeft ) ), bitsLeft );
1658 : }
1659 :
1660 0 : return hInstance->infoTotalBitsWritten;
1661 : }
1662 13265 : Word16 IGFEncWriteConcatenatedBitstream_ivas_fx( /**< out: Q0 | total number of bits written */
1663 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
1664 : BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */
1665 : )
1666 : {
1667 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1668 : Word16 i;
1669 : Word16 tmp;
1670 : Word16 bitsLeft;
1671 : UWord8 *pBitstream;
1672 :
1673 13265 : hPrivateData = &hInstance->igfData;
1674 13265 : pBitstream = &hPrivateData->igfBitstream[0];
1675 :
1676 13265 : tmp = shr( hPrivateData->igfBitstreamBits, 3 );
1677 82283 : FOR( i = 0; i < tmp; i++ )
1678 : {
1679 69018 : push_next_indice( hBstr, pBitstream[i], 8 );
1680 : }
1681 :
1682 13265 : bitsLeft = s_and( hPrivateData->igfBitstreamBits, 0x7 );
1683 13265 : IF( bitsLeft > 0 )
1684 : {
1685 11859 : push_next_indice( hBstr, shr( pBitstream[i], sub( 8, bitsLeft ) ), bitsLeft );
1686 : }
1687 :
1688 13265 : return hInstance->infoTotalBitsWritten;
1689 : }
1690 :
1691 : /**********************************************************************/ /*
1692 : apply the IGF encoder, main encoder interface
1693 : **************************************************************************/
1694 634 : void IGFEncApplyMono_fx( const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
1695 : const Word16 igfGridIdx, /**< in: Q0 | IGF grid index */
1696 : Encoder_State *st, /**< in: | Encoder state */
1697 : Word32 *pMDCTSpectrum, /**< in: Q31 | MDCT spectrum */
1698 : Word16 MDCTSpectrum_e, /**< in: | exponent of MDCT spectrum */
1699 : Word32 *pPowerSpectrum, /**< in: Q31 | MDCT^2 + MDST^2 spectrum, or estimate */
1700 : Word16 PowerSpectrum_e, /**< in: | exponent of pPowerSpectrum */
1701 : Word16 isTCX20, /**< in: Q0 | flag indicating if the input is TCX20 or TCX10/2xTCX5 */
1702 : Word16 isTNSActive, /**< in: Q0 | flag indicating if the TNS is active */
1703 : Word16 last_core_acelp /**< in: Q0 | indicator if last frame was acelp coded */
1704 : )
1705 : {
1706 : Word32 *pPowerSpectrumParameter; /* If it is NULL it informs a function that specific handling is needed */
1707 : Word32 *pPowerSpectrumParameterWhitening; /* If it is NULL it informs a function that specific handling is needed */
1708 : Word16 highPassEner_exp; /*exponent of highpass energy - maybe not needed*/
1709 :
1710 :
1711 634 : pPowerSpectrumParameter = NULL;
1712 634 : test();
1713 634 : if ( ( isTNSActive == 0 ) && ( isTCX20 != 0 ) )
1714 : {
1715 630 : pPowerSpectrumParameter = pPowerSpectrum;
1716 : }
1717 634 : pPowerSpectrumParameterWhitening = NULL;
1718 634 : if ( isTCX20 != 0 )
1719 : {
1720 634 : pPowerSpectrumParameterWhitening = pPowerSpectrum;
1721 : }
1722 :
1723 634 : IGF_UpdateInfo( hInstance, /* i: instance handle of IGF Encoder */
1724 : igfGridIdx ); /* i: IGF grid index */
1725 :
1726 634 : IGF_CalculateEnvelope( hInstance, /* i: instance handle of IGF Encoder */
1727 : pMDCTSpectrum, /* i: MDCT spectrum */
1728 : MDCTSpectrum_e, /* i: exponent of MDCT spectrum */
1729 : pPowerSpectrumParameter, /* i: MDCT^2 + MDST^2 spectrum, or estimate */
1730 : PowerSpectrum_e, /* i: exponent of pPowerSpectrum */
1731 : igfGridIdx /* i: IGF grid index */
1732 : );
1733 :
1734 :
1735 634 : IGF_Whitening( hInstance, /* i: instance handle of IGF Encoder */
1736 : pPowerSpectrumParameterWhitening, /* i: MDCT^2 + MDST^2 spectrum, or estimate */
1737 : PowerSpectrum_e, /* i: exponent of powerSpectrum */
1738 : igfGridIdx, /* i: IGF grid index */
1739 634 : ( st->hTranDet->transientDetector.bIsAttackPresent == 1 ),
1740 : last_core_acelp ); /* i: last frame was acelp indicator */
1741 :
1742 634 : pPowerSpectrumParameter = NULL;
1743 634 : if ( isTCX20 != 0 )
1744 : {
1745 634 : pPowerSpectrumParameter = pPowerSpectrum;
1746 : }
1747 :
1748 634 : IGF_ErodeSpectrum( /* o: highpass energy */
1749 : &highPassEner_exp, /* o: exponent of highPassEner */
1750 : hInstance, /* i: instance handle of IGF Encoder */
1751 : pMDCTSpectrum, /* i: MDCT spectrum */
1752 : pPowerSpectrumParameter, /* i: MDCT^2 + MDST^2 spectrum, or estimate */
1753 : PowerSpectrum_e, /* i: exponent of pPowerSpectrum */
1754 : igfGridIdx ); /* i: IGF grid index */
1755 634 : }
1756 :
1757 :
1758 21820 : ivas_error IGF_Reconfig_fx(
1759 : IGF_ENC_INSTANCE_HANDLE *hIGFEnc, /* i/o: instance handle of IGF Encoder */
1760 : const Word16 igf, /* i : IGF on/off */
1761 : const Word16 reset, /* i : reset flag */
1762 : const Word32 brate, /* i : bitrate for configuration */
1763 : const Word16 bwidth, /* i : signal bandwidth */
1764 : const Word16 element_mode, /* i : IVAS element mode */
1765 : const Word16 rf_mode /* i : flag to signal the RF mode */
1766 : )
1767 : {
1768 : ivas_error error;
1769 :
1770 21820 : error = IVAS_ERR_OK;
1771 21820 : move32();
1772 :
1773 21820 : test();
1774 21820 : test();
1775 21820 : test();
1776 21820 : IF( igf && *hIGFEnc == NULL )
1777 : {
1778 1500 : IF( ( *hIGFEnc = (IGF_ENC_INSTANCE_HANDLE) malloc( sizeof( IGF_ENC_INSTANCE ) ) ) == NULL )
1779 : {
1780 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hIGFEnc\n" ) );
1781 : }
1782 1500 : IGFEncSetMode_ivas_fx( *hIGFEnc, brate, bwidth, element_mode, rf_mode );
1783 : }
1784 20320 : ELSE IF( igf && reset )
1785 : {
1786 0 : IGFEncSetMode_ivas_fx( *hIGFEnc, brate, bwidth, element_mode, rf_mode );
1787 : }
1788 20320 : ELSE IF( !igf && *hIGFEnc != NULL )
1789 : {
1790 1989 : free( *hIGFEnc );
1791 1989 : *hIGFEnc = NULL;
1792 : }
1793 :
1794 21820 : return error;
1795 : }
1796 :
1797 :
1798 : #define INV_Log2_10_Q15 9864 /*1/log2(10) in Q15*/
1799 : #define INV_Log2_10_Q12 1233 /*1/log2(10) in Q12*/
1800 : #define INV_Log2_e_Q15 22713 /*1/log2(e) in Q15*/
1801 :
1802 :
1803 : /*-------------------------------------------------------------------*
1804 : * IGF_getCrest_new()
1805 : *
1806 : * crest factor calculation
1807 : *-------------------------------------------------------------------*/
1808 :
1809 : /*! r: crest factor */
1810 6373721 : static Word16 IGF_getCrest_new_fx(
1811 : const Word16 *logSpec, /* i : power spectrum */
1812 : const Word16 start, /* i : start subband index */
1813 : const Word16 stop, /* i : stop subband index */
1814 : Word16 *crest_exp /*Stores the exponent of the result(return value)*/
1815 : )
1816 : {
1817 : Word16 i;
1818 : Word16 x;
1819 : Word32 x_eff;
1820 : Word16 x_max;
1821 : Word16 exp;
1822 : Word16 temp;
1823 : Word16 temp_e;
1824 : Word16 crest; /*1.0f in Q15*/
1825 6373721 : x_eff = 0;
1826 6373721 : x_max = 0;
1827 6373721 : exp = 0;
1828 6373721 : temp = 0;
1829 6373721 : crest = 32767; /*1.0f in Q15*/
1830 6373721 : move32();
1831 6373721 : move16();
1832 6373721 : move16();
1833 6373721 : move16();
1834 6373721 : move16();
1835 :
1836 439265685 : FOR( i = start; i < stop; i++ )
1837 : {
1838 432891964 : x = logSpec[i];
1839 432891964 : move16();
1840 432891964 : x_eff = L_mac0( x_eff, x, x );
1841 :
1842 432891964 : if ( GT_16( x, x_max ) )
1843 : {
1844 19539596 : x_max = x;
1845 19539596 : move16();
1846 : }
1847 : }
1848 :
1849 6373721 : x_eff = BASOP_Util_Divide3216_Scale( x_eff, sub( stop, start ), &temp_e );
1850 6373721 : temp_e = add( temp_e, 16 ); /*exp += 31 - 15 + 16(because x_eff is word32)*/
1851 6373721 : x_eff = L_shr( x_eff, sub( 15, temp_e ) );
1852 6373721 : temp_e = 15;
1853 6373721 : move16();
1854 6373721 : temp = Sqrt16( extract_l( x_eff ), &temp_e );
1855 :
1856 6373721 : test();
1857 6373721 : IF( x_eff > 0 && x_max > 0 )
1858 : {
1859 5636130 : temp = BASOP_Util_Divide1616_Scale( x_max, temp, &exp );
1860 5636130 : exp = add( exp, sub( 15, temp_e ) );
1861 5636130 : IF( exp < 0 )
1862 : {
1863 0 : temp = shl( temp, exp );
1864 0 : exp = 0;
1865 0 : move16();
1866 : }
1867 5636130 : crest = s_max( shl_sat( 1, sub( 15, exp ) ), temp );
1868 : }
1869 6373721 : *crest_exp = exp;
1870 6373721 : move16();
1871 6373721 : return crest;
1872 : }
1873 :
1874 :
1875 : /*-------------------------------------------------------------------*
1876 : * IGF_getSFM_new()
1877 : *
1878 : * calculates spectral flatness measurement
1879 : *-------------------------------------------------------------------*/
1880 :
1881 : /*! r: SFM value */
1882 6373721 : static Word16 IGF_getSFM_new_fx(
1883 : const Word32 *powerSpectrum, /* i : power spectrum */
1884 : const Word16 *logSpec, /* i : log of power spectrum */
1885 : const Word16 start, /* i : start subband index */
1886 : const Word16 stop, /* i : stop subband index */
1887 : Word16 *e_ps /*Stores exp related to power spectrum*/
1888 : )
1889 : {
1890 : Word16 n;
1891 : Word16 i;
1892 : Word16 num;
1893 : Word32 denom;
1894 : Word16 numf;
1895 : Word32 tmp;
1896 : Word16 sfm;
1897 : Word16 sfm_e;
1898 : Word16 denom_e;
1899 : Word16 numf_e; /*stores exponent for numf*/
1900 : Word16 tmp_e;
1901 :
1902 6373721 : num = 0;
1903 6373721 : denom = ONE_IN_Q30;
1904 6373721 : denom_e = 1;
1905 6373721 : sfm = MAX16B; // Q15
1906 6373721 : move16();
1907 6373721 : move32();
1908 6373721 : move16();
1909 6373721 : move16();
1910 :
1911 439265685 : FOR( i = start; i < stop; i++ )
1912 : {
1913 432891964 : tmp = powerSpectrum[i];
1914 432891964 : n = logSpec[i /*-start*/];
1915 432891964 : move32();
1916 432891964 : move16();
1917 432891964 : num = add( num, n );
1918 432891964 : denom = BASOP_Util_Add_Mant32Exp( tmp, e_ps[i], denom, denom_e, &denom_e );
1919 : }
1920 :
1921 6373721 : numf = BASOP_Util_Divide1616_Scale( num, sub( stop, start ), &numf_e );
1922 6373721 : denom = BASOP_Util_Divide3216_Scale( denom, sub( stop, start ), &tmp_e );
1923 6373721 : denom_e = add( add( denom_e, tmp_e ), 1 ); /*denom_e+tmp_e-15 +16(because type of denom is word32)*/
1924 :
1925 6373721 : IF( denom != 0 )
1926 : {
1927 6373721 : tmp = BASOP_util_Pow2( L_add( numf, shl_sat( 1, sub( 14, numf_e ) ) ), add( 16, numf_e ), &tmp_e );
1928 6373721 : sfm = BASOP_Util_Divide3232_Scale( tmp, denom, &sfm_e );
1929 6373721 : sfm_e = add( sfm_e, sub( tmp_e, denom_e ) );
1930 6373721 : sfm = shl_sat( extract_l( L_min( sfm, L_shl_sat( 1, sub( 15, sfm_e ) ) ) ), sfm_e );
1931 : }
1932 :
1933 6373721 : return sfm;
1934 : }
1935 : /*-------------------------------------------------------------------*
1936 : * IGF_getTilt()
1937 : *
1938 : * calculates spectral tilt
1939 : *-------------------------------------------------------------------*/
1940 :
1941 : /*! r: spectral tilt value */
1942 :
1943 : /*-------------------------------------------------------------------*
1944 : * IGF_getTNR()
1945 : *
1946 : * calculates tonal-to-noise ratio
1947 : *-------------------------------------------------------------------*/
1948 :
1949 : /*! r: spectral tilt value */
1950 : /* Returns value with exponent as 9 and Q as 22*/
1951 :
1952 14885 : static Word32 IGF_getTNR_ivas_fx(
1953 : const Word32 *powerSpectrum, /* i : energies */
1954 : const Word16 start, /* i : start subband index */
1955 : const Word16 stop, /* i : stop subband index */
1956 : const Word16 adap, /* i : SFB width adaptation */
1957 : Word16 *e_ps, /*Stores exponent for powerSpectrum*/
1958 : Word16 e_adap /*Stores exponent for adap*/
1959 : )
1960 : {
1961 : Word16 i;
1962 : Word16 width;
1963 : Word32 avg;
1964 : Word32 tonal;
1965 : Word16 tonal_e; /* holds exp for tonal*/
1966 : Word32 noise;
1967 : Word16 noise_e; /* holds exp for noise*/
1968 : Word32 tonalToNoise;
1969 : Word32 rootSpec[300];
1970 : Word16 rootSpec_e[300]; /*rootSpec_e[i] holds exp for rootSpec[i]*/
1971 : Word16 avg_e; /* holds exp for avg*/
1972 : Word16 tmp_e;
1973 14885 : avg = 0;
1974 14885 : tonal = 0;
1975 14885 : noise = EPSILON_FX;
1976 14885 : tonal_e = 0;
1977 14885 : noise_e = 0;
1978 14885 : avg_e = 0;
1979 14885 : tmp_e = 0;
1980 14885 : move32();
1981 14885 : move32();
1982 14885 : move32();
1983 14885 : move16();
1984 14885 : move16();
1985 14885 : move16();
1986 14885 : move16();
1987 :
1988 14885 : set32_fx( rootSpec, 0, 300 );
1989 14885 : set16_fx( rootSpec_e, 0, 300 );
1990 :
1991 14885 : width = sub( stop, start );
1992 906243 : FOR( i = start; i < stop; i++ )
1993 : {
1994 891358 : rootSpec_e[( i - start )] = e_ps[i];
1995 891358 : move16();
1996 891358 : rootSpec[( i - start )] = Sqrt32( powerSpectrum[i], &rootSpec_e[( i - start )] ); /*rootSpec[i - start] = sqrtf( powerSpectrum[i] );*/
1997 891358 : move32();
1998 891358 : avg = BASOP_Util_Add_Mant32Exp( avg, avg_e, rootSpec[( i - start )], rootSpec_e[( i - start )], &avg_e ); /*avg += rootSpec[i - start];resultant exponent is avg_e*/
1999 : }
2000 14885 : avg = BASOP_Util_Divide3216_Scale( avg, width, &tmp_e ); /*avg /= width;*/
2001 14885 : avg_e = add( 16, sub( add( avg_e, tmp_e ), 15 ) );
2002 :
2003 906243 : FOR( i = start; i < stop; i++ )
2004 : {
2005 : Word16 normSpec_e; /*stores resultant exponent for normSpec*/
2006 891358 : Word16 normSpec = BASOP_Util_Divide3232_Scale( rootSpec[i - start], avg, &normSpec_e ); /*rootSpec[i - start] / avg;*/
2007 891358 : normSpec_e = add( normSpec_e, sub( rootSpec_e[i - start], avg_e ) );
2008 891358 : IF( GT_32( normSpec, L_add_sat( L_shl_sat( 1, sub( 15, normSpec_e ) ), L_shl_sat( adap, sub( e_adap, normSpec_e ) ) ) ) )
2009 : {
2010 72105 : tonal = BASOP_Util_Add_Mant32Exp( tonal, tonal_e, rootSpec[( i - start )], rootSpec_e[( i - start )], &tonal_e ); /*tonal += rootSpec[i - start];*/
2011 : }
2012 819253 : ELSE IF( LT_32( normSpec, L_shl_sat( 1, sub( 15, normSpec_e ) ) ) )
2013 : {
2014 723725 : noise = BASOP_Util_Add_Mant32Exp( noise, noise_e, rootSpec[( i - start )], rootSpec_e[( i - start )], &noise_e ); /*noise += rootSpec[i - start];*/
2015 : }
2016 : }
2017 :
2018 : /*tonalToNoise = 20.f * log10f( max( 1e-018f, tonal / noise ) )*/
2019 14885 : IF( noise == 0 ) // To handle condition if denom = 0
2020 : {
2021 0 : tonalToNoise = imult3216( L_shr( L_add( L_shl( 18 /* log10f(1e-018f) */, Q25 ), Mpy_32_16_1( L_add( BASOP_Util_Log2( tonal ), L_shl( tonal_e, Q25 ) ) /*Q25*/, INV_Log2_10_Q15 ) /*25+15-15*/ ), 3 ) /*Q22*/, 20 );
2022 : }
2023 : ELSE
2024 : {
2025 14885 : Word16 temp = BASOP_Util_Divide3232_Scale( tonal, noise, &tmp_e ); /*tonal / noise*/
2026 14885 : tmp_e = add( tmp_e, sub( tonal_e, noise_e ) );
2027 14885 : IF( GE_16( temp, 1 ) )
2028 : {
2029 14884 : tonalToNoise = imult3216( Mult_32_16( L_add( BASOP_Util_Log2( temp ), L_shl( add( 16, tmp_e ), Q25 ) ) /*Q25*/, INV_Log2_10_Q12 ) /*25+12-15*/, 20 ); /*Q22*/
2030 : }
2031 : ELSE
2032 : {
2033 1 : tonalToNoise = -1509949440; /*-360.f Q22*/
2034 1 : move32();
2035 : }
2036 : }
2037 :
2038 14885 : return tonalToNoise;
2039 : }
2040 :
2041 : /*-------------------------------------------------------------------*
2042 : * IGF_CalculateEnvelope()
2043 : *
2044 : * envelope estimation
2045 : *-------------------------------------------------------------------*/
2046 :
2047 569951 : static void IGF_CalculateEnvelope_ivas_fx(
2048 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
2049 : Word32 *pMDCTSpectrum_fx, /* i : MDCT spectrum */
2050 : Word16 e_mdct, /* i : exp of MDCT spectrum */
2051 : Word32 *pPowerSpectrum_fx, /* i : MDCT^2 + MDST^2 spectrum, or estimate */
2052 : Word16 *e_ps, /* i : exp of power spectrum */
2053 : const Word16 igfGridIdx, /* i : IGF grid index */
2054 : const Word16 isTransient, /* i : flag indicating if transient is detected */
2055 : const Word16 last_core_acelp, /* i : indicator if last frame was ACELP core */
2056 : const Word16 element_mode, /* i : IVAS element_mode */
2057 : const Word16 att /* i : attenuation */
2058 : )
2059 : {
2060 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
2061 : H_IGF_GRID hGrid;
2062 : Word16 *swb_offset;
2063 : Word16 sfb; /* this is the actual scalefactor band */
2064 : Word16 width; /* this is width in subbands of the actual scalefactor band */
2065 : Word16 tile_idx;
2066 : Word16 strt_cpy;
2067 : Word32 gain; /* the gain which has to be applied to the source tile to get the destination energy */
2068 : Word16 sb;
2069 : Word32 sfbEnergyR;
2070 : Word32 sfbEnergyC; /* the energy of the destination region of the tile */
2071 : Word32 sfbEnergyTileR;
2072 : Word32 sfbEnergyTileC; /* the energy of the destination region of the tile */
2073 : Word16 tmp, x, y;
2074 : Word16 mean_x_fx, mean_y_fx;
2075 : Word32 mean_xy_fx, mean_x2_fx;
2076 : Word16 tmp_tb;
2077 : Word16 tmp_sb;
2078 : Word16 sfbCnt;
2079 : Word16 sfm;
2080 : Word16 crest;
2081 : Word16 temp;
2082 : Word16 mean_x_e, mean_y_e; /*Stores exponent for mean_x and mean_y respectively*/
2083 : Word16 mean_xy_e, mean_x2_e; /*stores exponent for mean_xy and mean_x2 respectively*/
2084 : Word16 sfbEnergyTileR_e; /*Exponent for sfbEnergyTileR*/
2085 : Word16 sfbEnergyTileC_e; /*Exponent for sfbEnergyTileC*/
2086 : Word16 sfbEnergyC_e; /*Exponent for sfbEnergyC*/
2087 : Word16 sfbEnergyR_e;
2088 : Word16 gain_e; /*exponent for gain*/
2089 : Word16 tmp_tb_e; /*Stores exponent for tmp_tb*/
2090 : Word16 tmp_sb_e; /*stores exponent for tmp_sb*/
2091 : Word16 crest_exp; /*Stores the exponent of the result(return value)*/
2092 : Word16 sfm_exp; /*stores exponent for ouput from sfm*/
2093 : Word16 tmp_e;
2094 :
2095 569951 : hPrivateData = &hIGFEnc->igfData;
2096 569951 : hGrid = &hPrivateData->igfInfo.grid[(Word16) igfGridIdx];
2097 569951 : swb_offset = hGrid->swb_offset;
2098 :
2099 569951 : IF( element_mode > EVS_MONO )
2100 : {
2101 569951 : IF( igfGridIdx != IGF_GRID_LB_NORM )
2102 : {
2103 202049 : FOR( sfbCnt = 0; sfbCnt < sub( hGrid->sfbWrap[hGrid->nTiles], hGrid->sfbWrap[0] ); sfbCnt++ )
2104 : {
2105 : /* reset filter */
2106 169501 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_FIR_TB_e[sfbCnt]
2107 169501 : hPrivateData->prevSFB_FIR_TB_e[sfbCnt] = 0;
2108 169501 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_IIR_TB_e[sfbCnt]
2109 169501 : hPrivateData->prevSFB_IIR_TB_e[sfbCnt] = 0;
2110 169501 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_FIR_SB_e[sfbCnt]
2111 169501 : hPrivateData->prevSFB_FIR_SB_e[sfbCnt] = 0;
2112 169501 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_IIR_SB_e[sfbCnt]
2113 169501 : hPrivateData->prevSFB_IIR_SB_e[sfbCnt] = 0;
2114 169501 : hPrivateData->prevDampingFactor_IIR_fx[sfbCnt] = MIN16B; /* -1.f in Q15*/
2115 169501 : hPrivateData->prevDampingFactor_IIR_e[sfbCnt] = 0;
2116 169501 : hPrivateData->dampingFactorSmoothing[sfbCnt] = 2;
2117 169501 : move16();
2118 169501 : move16();
2119 169501 : move16();
2120 169501 : move16();
2121 169501 : move16();
2122 169501 : move16();
2123 169501 : move16();
2124 169501 : move16();
2125 169501 : move16();
2126 169501 : move16();
2127 169501 : move16();
2128 : }
2129 : }
2130 : }
2131 :
2132 569951 : IF( pPowerSpectrum_fx )
2133 : {
2134 267693350 : FOR( sb = hGrid->sbWrap[0]; sb < swb_offset[hGrid->sfbWrap[hGrid->nTiles]]; sb++ )
2135 : {
2136 267194408 : IF( LT_32( 1, pPowerSpectrum_fx[sb] ) )
2137 : {
2138 260989841 : hPrivateData->logSpec[sb] = s_max( 0, extract_l( W_extract_l( W_shr( W_add( BASOP_Util_Log2( pPowerSpectrum_fx[sb] ), W_shl( e_ps[sb], Q25 ) ), Q25 ) ) ) );
2139 260989841 : move16();
2140 : }
2141 : ELSE
2142 : {
2143 6204567 : hPrivateData->logSpec[sb] = 0;
2144 6204567 : move16();
2145 : }
2146 : }
2147 : }
2148 :
2149 2621609 : FOR( tile_idx = 0; tile_idx < hGrid->nTiles; tile_idx++ )
2150 : {
2151 2051658 : strt_cpy = hGrid->sbWrap[tile_idx];
2152 2051658 : move16();
2153 :
2154 5133219 : FOR( sfb = hGrid->sfbWrap[tile_idx]; sfb < hGrid->sfbWrap[tile_idx + 1]; sfb++ )
2155 : {
2156 3081561 : width = sub( swb_offset[sfb + 1], swb_offset[sfb] );
2157 3081561 : sfbEnergyTileR = EPSILON_FIX;
2158 3081561 : sfbEnergyTileC = EPSILON_FIX;
2159 3081561 : sfbEnergyC = EPSILON_FX;
2160 3081561 : sfbEnergyTileR_e = 0;
2161 3081561 : sfbEnergyTileC_e = 0;
2162 3081561 : sfbEnergyC_e = 0;
2163 3081561 : move16();
2164 3081561 : move16();
2165 3081561 : move16();
2166 3081561 : move16();
2167 3081561 : move16();
2168 3081561 : move16();
2169 :
2170 3081561 : IF( pPowerSpectrum_fx != NULL )
2171 : {
2172 2752164 : tmp = strt_cpy;
2173 2752164 : move16();
2174 160448840 : FOR( sb = swb_offset[sfb]; sb < swb_offset[sfb + 1]; sb++ )
2175 : {
2176 157696676 : Word16 shift = norm_l( pPowerSpectrum_fx[sb] );
2177 157696676 : sfbEnergyC = BASOP_Util_Add_Mant32Exp( sfbEnergyC, sfbEnergyC_e, L_shl( pPowerSpectrum_fx[sb], shift ), sub( e_ps[sb], shift ), &sfbEnergyC_e );
2178 : // sfbEnergyTileR = BASOP_Util_Add_Mant32Exp( sfbEnergyTileR, sfbEnergyTileR_e, Mult_32_32( pMDCTSpectrum_fx[strt_cpy], pMDCTSpectrum_fx[strt_cpy] ), shl( e_mdct, 1 ), &sfbEnergyTileR_e );
2179 157696676 : Word64 tmp64 = W_mult_32_32( pMDCTSpectrum_fx[strt_cpy], pMDCTSpectrum_fx[strt_cpy] );
2180 157696676 : Word16 tmp64_e = W_norm( tmp64 );
2181 157696676 : tmp64 = W_shl( tmp64, tmp64_e );
2182 :
2183 157696676 : sfbEnergyTileR = BASOP_Util_Add_Mant32Exp( sfbEnergyTileR, sfbEnergyTileR_e, W_extract_h( tmp64 ), shl( e_mdct, 1 ) - tmp64_e, &sfbEnergyTileR_e );
2184 157696676 : shift = norm_l( pPowerSpectrum_fx[strt_cpy] );
2185 157696676 : sfbEnergyTileC = BASOP_Util_Add_Mant32Exp( sfbEnergyTileC, sfbEnergyTileC_e, L_shl( pPowerSpectrum_fx[strt_cpy], shift ), sub( e_ps[strt_cpy], shift ), &sfbEnergyTileC_e );
2186 :
2187 157696676 : strt_cpy = add( strt_cpy, 1 );
2188 : }
2189 :
2190 2752164 : sfbEnergyTileR = L_deposit_h( BASOP_Util_Divide3232_Scale( sfbEnergyTileR, width, &tmp_e ) );
2191 2752164 : sfbEnergyTileR_e = add( sub( sfbEnergyTileR_e, Q31 ), tmp_e );
2192 :
2193 2752164 : IF( sfbEnergyTileR == 0 )
2194 : {
2195 62937 : sfbEnergyTileR = EPSILON_FX;
2196 62937 : sfbEnergyTileR_e = 0;
2197 62937 : move32();
2198 62937 : move16();
2199 : }
2200 2752164 : IF( sfbEnergyC == 0 )
2201 : {
2202 62937 : sfbEnergyC = EPSILON_FX;
2203 62937 : sfbEnergyC_e = 0;
2204 62937 : move32();
2205 62937 : move16();
2206 : }
2207 2752164 : IF( sfbEnergyTileC == 0 )
2208 : {
2209 62937 : sfbEnergyTileC = EPSILON_FX;
2210 62937 : sfbEnergyTileC_e = 0;
2211 62937 : temp = BASOP_Util_Divide3232_Scale( sfbEnergyC, sfbEnergyTileC, &tmp_e );
2212 62937 : tmp_e = add( tmp_e, sub( sfbEnergyC_e, sfbEnergyTileC_e ) );
2213 62937 : move32();
2214 62937 : move16();
2215 : }
2216 : ELSE
2217 : {
2218 : /*gain = (float) ( sfbEnergyTileR * ( sfbEnergyC / sfbEnergyTileC ) );*/
2219 2689227 : temp = BASOP_Util_Divide3232_Scale( sfbEnergyC, sfbEnergyTileC, &tmp_e );
2220 2689227 : tmp_e = add( tmp_e, sub( sfbEnergyC_e, sfbEnergyTileC_e ) );
2221 : }
2222 :
2223 2752164 : gain = Mult_32_16( sfbEnergyTileR, temp ); // gain_e
2224 2752164 : gain_e = add( tmp_e, sfbEnergyTileR_e );
2225 :
2226 2752164 : IF( element_mode > EVS_MONO )
2227 : {
2228 2752164 : test();
2229 2752164 : IF( !isTransient )
2230 : {
2231 : Word16 diffSFM;
2232 2742832 : Word16 shiftedSFM = 0;
2233 2742832 : Word16 shiftedSFM_e = 0;
2234 2742832 : move16();
2235 2742832 : move16();
2236 :
2237 : // tmp_tb = IGF_getSFM_new( pPowerSpectrum, hPrivateData->logSpec, swb_offset[sfb], swb_offset[sfb + 1] ) / IGF_getCrest_new( hPrivateData->logSpec, swb_offset[sfb], swb_offset[sfb + 1] );
2238 2742832 : sfm = IGF_getSFM_new_fx( pPowerSpectrum_fx, hPrivateData->logSpec, swb_offset[sfb], swb_offset[sfb + 1], e_ps );
2239 2742832 : sfm_exp = 0;
2240 2742832 : move16();
2241 2742832 : crest = IGF_getCrest_new_fx( hPrivateData->logSpec, swb_offset[sfb], swb_offset[sfb + 1], &crest_exp );
2242 2742832 : tmp_tb = BASOP_Util_Divide1616_Scale( sfm, crest, &tmp_e ); // tmp_tb_e
2243 2742832 : tmp_tb_e = add( tmp_e, sub( sfm_exp, crest_exp ) );
2244 :
2245 : // tmp_sb = IGF_getSFM_new( pPowerSpectrum, hPrivateData->logSpec, tmp, strt_cpy ) / IGF_getCrest_new( hPrivateData->logSpec, tmp, strt_cpy );
2246 2742832 : sfm = IGF_getSFM_new_fx( pPowerSpectrum_fx, hPrivateData->logSpec, tmp, strt_cpy, e_ps );
2247 2742832 : crest = IGF_getCrest_new_fx( hPrivateData->logSpec, tmp, strt_cpy, &crest_exp );
2248 2742832 : tmp_sb = BASOP_Util_Divide1616_Scale( sfm, crest, &tmp_e ); // tmp_sb_e
2249 2742832 : tmp_sb_e = add( tmp_e, sub( sfm_exp, crest_exp ) );
2250 :
2251 2742832 : test();
2252 2742832 : IF( last_core_acelp || hPrivateData->wasTransient )
2253 : {
2254 112653 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = tmp_tb; /*Exponent for hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] : hPrivateData->prevSFB_FIR_TB_e[sfb] and hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] : hPrivateData->prevSFB_IIR_TB_e[sfb] */
2255 112653 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = tmp_sb; /*Exponent for hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] : hPrivateData->prevSFB_FIR_SB_e[sfb] and hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] : hPrivateData->prevSFB_IIR_SB_e[sfb] */
2256 112653 : hPrivateData->prevSFB_FIR_TB_e[sfb] = hPrivateData->prevSFB_IIR_TB_e[sfb] = tmp_tb_e;
2257 112653 : hPrivateData->prevSFB_FIR_SB_e[sfb] = hPrivateData->prevSFB_IIR_SB_e[sfb] = tmp_sb_e;
2258 112653 : move16();
2259 112653 : move16();
2260 112653 : move16();
2261 112653 : move16();
2262 112653 : move16();
2263 112653 : move16();
2264 112653 : move16();
2265 112653 : move16();
2266 : }
2267 :
2268 2742832 : tmp_tb = shr( tmp_tb, 2 ); /*taking 2 guard bits so it's exponent tmp_sb_e=+2*/
2269 2742832 : tmp_sb = shr( tmp_sb, 2 ); /*taking 2 guard bits so it's exponent tmp_tb_e=+2 */
2270 2742832 : tmp_sb_e = add( tmp_sb_e, 2 );
2271 2742832 : tmp_tb_e = add( tmp_tb_e, 2 );
2272 :
2273 : Word16 tmp0, tmp2, tmp3, tmp4;
2274 : Word16 tmp0_e, tmp2_e, tmp3_e, tmp4_e;
2275 2742832 : tmp0 = shr( hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb], 2 );
2276 2742832 : tmp0_e = add( hPrivateData->prevSFB_FIR_TB_e[sfb], 2 );
2277 2742832 : move16();
2278 2742832 : tmp2 = shr( hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb], 2 );
2279 2742832 : tmp2_e = add( hPrivateData->prevSFB_IIR_TB_e[sfb], 2 );
2280 2742832 : move16();
2281 2742832 : tmp3 = shr( hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb], 2 );
2282 2742832 : tmp3_e = add( hPrivateData->prevSFB_FIR_SB_e[sfb], 2 );
2283 2742832 : move16();
2284 2742832 : tmp4 = shr( hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb], 2 );
2285 2742832 : tmp4_e = add( hPrivateData->prevSFB_IIR_SB_e[sfb], 2 );
2286 2742832 : move16();
2287 : Word16 x1, x2;
2288 :
2289 2742832 : Word16 x1_e = BASOP_Util_Add_MantExp( tmp0, tmp0_e, tmp2, tmp2_e - 1, &x1 );
2290 2742832 : Word16 x2_e = BASOP_Util_Add_MantExp( tmp3, tmp3_e, tmp4, tmp4_e - 1, &x2 );
2291 2742832 : hPrivateData->sfb_tb_e[sfb] = BASOP_Util_Add_MantExp( tmp_tb, tmp_tb_e, x1, x1_e, &hPrivateData->SFM_tb_fx[sfb] ); // hPrivateData->sfb_sb_e[sfb]
2292 2742832 : move16();
2293 2742832 : BASOP_Util_Add_MantExp( 22118, 2, negate( hPrivateData->SFM_tb_fx[sfb] ), hPrivateData->sfb_tb_e[sfb], &tmp );
2294 :
2295 2742832 : IF( tmp < 0 )
2296 : {
2297 304777 : hPrivateData->sfb_tb_e[sfb] = 2;
2298 304777 : hPrivateData->SFM_tb_fx[sfb] = 22118;
2299 304777 : move16();
2300 304777 : move16();
2301 : }
2302 :
2303 2742832 : hPrivateData->sfb_sb_e[sfb] = BASOP_Util_Add_MantExp( tmp_sb, tmp_sb_e, x2, x2_e, &hPrivateData->SFM_sb_fx[sfb] ); // hPrivateData->sfb_tb_e[sfb]
2304 2742832 : move16();
2305 2742832 : BASOP_Util_Add_MantExp( 22118, 2, negate( hPrivateData->SFM_sb_fx[sfb] ), hPrivateData->sfb_sb_e[sfb], &tmp );
2306 :
2307 2742832 : IF( tmp < 0 )
2308 : {
2309 186004 : hPrivateData->sfb_sb_e[sfb] = 2;
2310 186004 : hPrivateData->SFM_sb_fx[sfb] = 22118;
2311 186004 : move16();
2312 186004 : move16();
2313 : }
2314 :
2315 2742832 : BASOP_Util_Add_MantExp( hPrivateData->SFM_sb_fx[sfb], hPrivateData->sfb_sb_e[sfb], negate( hPrivateData->SFM_tb_fx[sfb] ), hPrivateData->sfb_tb_e[sfb], &diffSFM );
2316 :
2317 2742832 : test();
2318 2742832 : IF( diffSFM > 0 && LT_32( hPrivateData->SFM_tb_fx[sfb], L_shr( 3277 /*0.1 Q15*/, hPrivateData->sfb_tb_e[sfb] ) ) ) /* check whether target SFB is more tonal than source SFB */
2319 13684 : {
2320 : Word16 currDampingFactor, dampingFactor;
2321 : Word16 slope, threshold;
2322 : Word16 alpha;
2323 : Word16 slope_e, threshold_e, currDampingFactor_e, dampingFactor_e, alpha_e;
2324 :
2325 : /* calculate spectral tilt to detect sudden drops (or increases) in energy in the current SFB */
2326 : // slope = IGF_getTilt_fx( pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1], e_ps, &slope_e );
2327 :
2328 13684 : x = 1;
2329 13684 : mean_x_fx = mean_y_fx = 0;
2330 13684 : Word32 mean_y_fx_tmp = 0;
2331 13684 : move32();
2332 13684 : mean_xy_fx = mean_x2_fx = 0;
2333 13684 : mean_x_e = 15;
2334 13684 : mean_xy_e = mean_y_e = mean_x2_e = 31;
2335 13684 : move16();
2336 13684 : move16();
2337 13684 : move16();
2338 13684 : move16();
2339 13684 : move16();
2340 13684 : move16();
2341 13684 : move16();
2342 13684 : move16();
2343 13684 : move16();
2344 :
2345 839586 : FOR( sb = swb_offset[sfb]; sb < swb_offset[sfb + 1]; sb++ )
2346 : {
2347 825902 : mean_x_fx = add( mean_x_fx, x ); /*Q0*/
2348 825902 : mean_x2_fx = L_add( mean_x2_fx, L_mult0( x, x ) ); /*Q0*/
2349 :
2350 : /*y = 20.f * log10f( max( 1.f, powerSpectrum[i] ) );*/
2351 825902 : IF( LE_64( W_deposit32_l( pPowerSpectrum_fx[sb] ), W_shl( 1, ( sub( 31, e_ps[sb] ) ) ) ) )
2352 : {
2353 98482 : y = 0;
2354 98482 : move16();
2355 : }
2356 : ELSE
2357 : {
2358 727420 : y = imult1616( 20, extract_l( L_shr( Mult_32_16( ( L_add( BASOP_Util_Log2( pPowerSpectrum_fx[sb] ), L_shl( e_ps[sb], Q25 ) ) ), INV_Log2_10_Q15 ), Q25 ) ) ); /*Q0*/
2359 : }
2360 825902 : mean_y_fx_tmp = L_mac0( mean_y_fx_tmp, y, 1 ); /*Q0*/
2361 825902 : mean_xy_fx = L_add( mean_xy_fx, L_mult0( y, x ) ); /*Q0*/
2362 :
2363 825902 : x = add( x, 1 );
2364 : }
2365 13684 : mean_y_fx = BASOP_Util_Divide3216_Scale( mean_y_fx_tmp, width, &tmp_e ); /* mean_y_e*/
2366 :
2367 13684 : mean_y_e = add( mean_y_e, sub( tmp_e, 15 ) );
2368 13684 : mean_x_fx = BASOP_Util_Divide1616_Scale( mean_x_fx, width, &tmp_e ); /* mean_x_e*/
2369 13684 : mean_x_e = add( mean_x_e, sub( tmp_e, 15 ) );
2370 13684 : mean_xy_fx = BASOP_Util_Divide3216_Scale( mean_xy_fx, width, &tmp_e ); /* mean_xy_e*/
2371 13684 : mean_xy_e = add( mean_xy_e, sub( tmp_e, 15 ) );
2372 13684 : mean_x2_fx = BASOP_Util_Divide3216_Scale( mean_x2_fx, width, &tmp_e ); /* mean_x2_e*/
2373 13684 : mean_x2_e = add( mean_x2_e, sub( tmp_e, 15 ) );
2374 :
2375 : /*slope = ( mean_xy - mean_x * mean_y ) / ( mean_x2 - mean_x * mean_x );*/
2376 13684 : slope = BASOP_Util_Divide3232_Scale( ( L_sub( mean_xy_fx, L_shl( mult( mean_x_fx, mean_y_fx ), sub( add( mean_x_e, mean_y_e ), mean_xy_e ) ) ) ), ( L_sub( mean_x2_fx, L_shl( mult( mean_x_fx, mean_x_fx ), sub( add( mean_x_e, mean_x_e ), mean_x2_e ) ) ) ), &slope_e );
2377 13684 : slope_e = add( slope_e, sub( mean_xy_e, mean_x2_e ) );
2378 :
2379 : /* determine whether strong tilt is due to a step in the spectrum (e.g. band limitation, no damping)
2380 : or a tonal component close the band border (apply damping) by calculating SFM for a shift of 1/2 SFB width*/
2381 13684 : threshold = BASOP_Util_Divide1616_Scale( 60, width, &threshold_e );
2382 :
2383 13684 : test();
2384 13684 : IF( EQ_16( BASOP_Util_Cmp_Mant32Exp( slope, add( slope_e, 16 ), negate( threshold ), add( threshold_e, 16 ) ), -1 ) )
2385 : {
2386 284 : Word16 shift = shr( width, 1 );
2387 284 : sfm = IGF_getSFM_new_fx( pPowerSpectrum_fx, hPrivateData->logSpec, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift, e_ps );
2388 284 : crest = IGF_getCrest_new_fx( hPrivateData->logSpec, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift, &crest_exp );
2389 284 : shiftedSFM = BASOP_Util_Divide1616_Scale( sfm, crest, &shiftedSFM_e );
2390 : }
2391 13400 : ELSE IF( EQ_16( BASOP_Util_Cmp_Mant32Exp( slope, add( slope_e, 16 ), threshold, add( threshold_e, 16 ) ), 1 ) && ( NE_16( sfb, sub( hGrid->sfbWrap[hGrid->nTiles], 1 ) ) ) )
2392 : {
2393 115 : Word16 shift = shr( width, 1 );
2394 115 : shiftedSFM = BASOP_Util_Divide1616_Scale( IGF_getSFM_new_fx( pPowerSpectrum_fx, hPrivateData->logSpec, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift, e_ps ), IGF_getCrest_new_fx( hPrivateData->logSpec, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift, &crest_exp ), &tmp_e );
2395 115 : sfm = IGF_getSFM_new_fx( pPowerSpectrum_fx, hPrivateData->logSpec, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift, e_ps );
2396 115 : crest = IGF_getCrest_new_fx( hPrivateData->logSpec, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift, &crest_exp );
2397 115 : shiftedSFM = BASOP_Util_Divide1616_Scale( sfm, crest, &shiftedSFM_e );
2398 : }
2399 13684 : shiftedSFM_e = add( shiftedSFM_e, sub( sfm_exp, crest_exp ) );
2400 :
2401 13684 : IF( GT_32( shiftedSFM, L_shl( 1311 /*0.04f Q15*/, negate( shiftedSFM_e ) ) ) )
2402 : {
2403 121 : currDampingFactor = 32767; /*1.f Q15*/
2404 121 : currDampingFactor_e = 0;
2405 121 : move16();
2406 121 : move16();
2407 : }
2408 : ELSE
2409 : {
2410 : // alpha = min( 320.f / (float) swb_offset[sfb + 1], 1.25f );
2411 13563 : temp = BASOP_Util_Divide1616_Scale( 320, swb_offset[sfb + 1], &alpha_e );
2412 13563 : alpha = extract_l( L_min( temp, L_shl( 20480 /*1.25 Q14*/, sub( 1, alpha_e ) ) ) ); // alpha_e
2413 :
2414 : // currDampingFactor = expf( 1.25f * alpha * logf( hPrivateData->SFM_tb[sfb] / hPrivateData->SFM_sb[sfb] ) );
2415 13563 : temp = BASOP_Util_Divide1616_Scale( hPrivateData->SFM_tb_fx[sfb], hPrivateData->SFM_sb_fx[sfb], &tmp_e ); // tmp_e
2416 13563 : tmp_e = add( tmp_e, sub( hPrivateData->sfb_tb_e[sfb], hPrivateData->sfb_sb_e[sfb] ) );
2417 13563 : Word16 temp1 = mult( 20480 /* 1.25f in Q14 */, alpha );
2418 13563 : Word16 tmp1_e = add( 1, alpha_e );
2419 13563 : currDampingFactor = round_fx( BASOP_util_Pow2( Mpy_32_16_1( L_add( BASOP_Util_Log2( temp ), L_shl_sat( add( 16, tmp_e ), 25 ) ), temp1 ), add( tmp1_e, 6 ), &currDampingFactor_e ) ); // currDampingFactor_e
2420 :
2421 : /* calculate tonal-to-noise ratio and reduce damping for low values*/
2422 :
2423 : Word32 tonalToNoise;
2424 : Word16 adap;
2425 : Word16 adap_e; /*stores exp for adap*/
2426 : Word16 tonalToNoise_e; /*stores exponent for tonalToNoise*/
2427 13563 : tonalToNoise_e = 9;
2428 13563 : move16();
2429 13563 : adap = BASOP_Util_Divide1616_Scale( width, 40, &adap_e );
2430 13563 : tonalToNoise = IGF_getTNR_ivas_fx( pPowerSpectrum_fx, swb_offset[sfb], swb_offset[sfb + 1], adap, e_ps, adap_e ); /*Q22*/
2431 :
2432 13563 : IF( EQ_16( BASOP_Util_Cmp_Mant32Exp( tonalToNoise, tonalToNoise_e, L_add( L_shl( 10, sub( 15, adap_e ) ), adap ), add( 16, adap_e ) ), -1 ) )
2433 : {
2434 : // currDampingFactor += 0.03f * ( ( 10 + adap ) - tonalToNoise );
2435 9804 : Word32 temp2 = BASOP_Util_Add_Mant32Exp( L_add( L_shl( 10, sub( 15, adap_e ) ) /*exp:adap_e*/, adap ), add( adap_e, 16 ), L_negate( tonalToNoise ), tonalToNoise_e, &tmp_e ); // tmp_e
2436 9804 : currDampingFactor_e = BASOP_Util_Add_MantExp( currDampingFactor, currDampingFactor_e, extract_l( Mult_32_32( 983 /*0.03f Q15*/, temp2 ) ), tmp_e, &currDampingFactor ); // currDampingFactor_e
2437 : }
2438 : }
2439 :
2440 13684 : Word32 L_tmp = hPrivateData->prevDampingFactor_IIR_fx[sfb];
2441 13684 : move32();
2442 13684 : L_tmp = L_shl( L_tmp, hPrivateData->prevDampingFactor_IIR_e[sfb] );
2443 13684 : test();
2444 13684 : test();
2445 13684 : IF( last_core_acelp || hPrivateData->wasTransient || EQ_32( L_tmp, MIN16B ) )
2446 : {
2447 4821 : tmp = BASOP_Util_Cmp_Mant32Exp( currDampingFactor, currDampingFactor_e, 3277 /* 0.1f in Q15 */, 0 );
2448 4821 : IF( tmp >= 0 )
2449 : {
2450 4777 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = currDampingFactor;
2451 4777 : hPrivateData->prevDampingFactor_IIR_e[sfb] = currDampingFactor_e;
2452 4777 : move16();
2453 4777 : move16();
2454 : }
2455 : ELSE
2456 : {
2457 44 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = 3277; /* 0.1 in Q15 */
2458 44 : hPrivateData->prevDampingFactor_IIR_e[sfb] = 0;
2459 44 : move16();
2460 44 : move16();
2461 : }
2462 : }
2463 13684 : IF( last_core_acelp )
2464 : {
2465 759 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
2466 759 : move16();
2467 : }
2468 :
2469 13684 : dampingFactor_e = BASOP_Util_Add_MantExp( currDampingFactor, currDampingFactor_e, hPrivateData->prevDampingFactor_IIR_fx[sfb], hPrivateData->prevDampingFactor_IIR_e[sfb], &dampingFactor ); // dampingFactor_e
2470 13684 : dampingFactor = shr( dampingFactor, 1 );
2471 :
2472 13684 : gain = Mult_32_16( gain, shl_sat( extract_l( L_min( L_add( dampingFactor, Mult_32_16( L_shl( hPrivateData->dampingFactorSmoothing[sfb], sub( 15, dampingFactor_e ) ) /*Q:15-dampingFactor_e*/, 3277 /*0.1f Q15*/ ) /*Q:15-dampingFactor_e*/ ), shl_sat( 1, sub( 15, dampingFactor_e ) ) ) ), dampingFactor_e ) /*Q15*/ );
2473 :
2474 13684 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = dampingFactor;
2475 13684 : move16();
2476 13684 : hPrivateData->prevDampingFactor_IIR_e[sfb] = dampingFactor_e;
2477 13684 : move16();
2478 13684 : if ( hPrivateData->dampingFactorSmoothing[sfb] > 0 )
2479 : {
2480 6043 : hPrivateData->dampingFactorSmoothing[sfb] = sub( hPrivateData->dampingFactorSmoothing[sfb], 1 );
2481 6043 : move16();
2482 : }
2483 : }
2484 : ELSE
2485 : {
2486 2729148 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = MIN16B; // exponent : hPrivateData->prevDampingFactor_IIR_e[sfb]
2487 2729148 : hPrivateData->prevDampingFactor_IIR_e[sfb] = 0;
2488 2729148 : hPrivateData->dampingFactorSmoothing[sfb] = 1;
2489 2729148 : move16();
2490 2729148 : move16();
2491 2729148 : move16();
2492 : }
2493 :
2494 2742832 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = tmp_tb; // hPrivateData->prevSFB_FIR_TB_e[sfb]
2495 2742832 : hPrivateData->prevSFB_FIR_TB_e[sfb] = tmp_tb_e;
2496 2742832 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = hPrivateData->SFM_tb_fx[sfb]; // hPrivateData->prevSFB_IIR_TB_e[sfb]
2497 2742832 : hPrivateData->prevSFB_IIR_TB_e[sfb] = hPrivateData->sfb_tb_e[sfb];
2498 2742832 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = tmp_sb; // hPrivateData->prevSFB_FIR_SB_e[sfb]
2499 2742832 : hPrivateData->prevSFB_FIR_SB_e[sfb] = tmp_sb_e;
2500 2742832 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = hPrivateData->SFM_sb_fx[sfb]; // hPrivateData->prevSFB_IIR_SB_e[sfb]
2501 2742832 : hPrivateData->prevSFB_IIR_SB_e[sfb] = hPrivateData->sfb_sb_e[sfb];
2502 2742832 : move16();
2503 2742832 : move16();
2504 2742832 : move16();
2505 2742832 : move16();
2506 2742832 : move16();
2507 2742832 : move16();
2508 2742832 : move16();
2509 2742832 : move16();
2510 : }
2511 : ELSE
2512 : {
2513 9332 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = 0; // hPrivateData->prevSFB_FIR_TB_e[sfb]
2514 9332 : hPrivateData->prevSFB_FIR_TB_e[sfb] = 0;
2515 9332 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = 0; // hPrivateData->prevSFB_IIR_TB_e[sfb]
2516 9332 : hPrivateData->prevSFB_IIR_TB_e[sfb] = 0;
2517 9332 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = 0; // hPrivateData->prevSFB_IIR_TB_e[sfb]
2518 9332 : hPrivateData->prevSFB_FIR_SB_e[sfb] = 0;
2519 9332 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = 0; // hPrivateData->prevSFB_IIR_SB_e[sfb]
2520 9332 : hPrivateData->prevSFB_IIR_SB_e[sfb] = 0;
2521 9332 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = MIN16B; /* hPrivateData->prevDampingFactor_IIR_e[sfb]*/
2522 9332 : hPrivateData->prevDampingFactor_IIR_e[sfb] = 0;
2523 9332 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
2524 9332 : move16();
2525 9332 : move16();
2526 9332 : move16();
2527 9332 : move16();
2528 9332 : move16();
2529 9332 : move16();
2530 9332 : move16();
2531 9332 : move16();
2532 9332 : move16();
2533 9332 : move16();
2534 9332 : move16();
2535 : }
2536 : }
2537 : }
2538 : ELSE
2539 : {
2540 329397 : tmp_e = e_mdct;
2541 329397 : move16();
2542 329397 : sfbEnergyR = add_sat( EPSILON_FX, BASOP_Util_Divide3216_Scale( sum2_32_fx( pMDCTSpectrum_fx + swb_offset[sfb], width, &tmp_e ) /*exp: tmp_e*/, width, &sfbEnergyR_e ) ); // sfbEnergyR_e
2543 329397 : sfbEnergyR_e = add( sfbEnergyR_e, add( tmp_e, -15 ) );
2544 329397 : gain = L_shl( sfbEnergyR, 16 ); // gain_e
2545 329397 : move32();
2546 329397 : gain_e = sfbEnergyR_e;
2547 :
2548 329397 : IF( element_mode > EVS_MONO )
2549 : {
2550 329397 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = 0; // hPrivateData->prevSFB_FIR_TB_e[sfb]
2551 329397 : hPrivateData->prevSFB_FIR_TB_e[sfb] = 0;
2552 329397 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = 0; // hPrivateData->prevSFB_IIR_TB_e[sfb]
2553 329397 : hPrivateData->prevSFB_IIR_TB_e[sfb] = 0;
2554 329397 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = 0; // hPrivateData->prevSFB_IIR_TB_e[sfb]
2555 329397 : hPrivateData->prevSFB_FIR_SB_e[sfb] = 0;
2556 329397 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = 0; // hPrivateData->prevSFB_IIR_SB_e[sfb]
2557 329397 : hPrivateData->prevSFB_IIR_SB_e[sfb] = 0;
2558 329397 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = MIN16B; /* hPrivateData->prevDampingFactor_IIR_e[sfb]*/
2559 329397 : hPrivateData->prevDampingFactor_IIR_e[sfb] = 0;
2560 329397 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
2561 329397 : move16();
2562 329397 : move16();
2563 329397 : move16();
2564 329397 : move16();
2565 329397 : move16();
2566 329397 : move16();
2567 329397 : move16();
2568 329397 : move16();
2569 329397 : move16();
2570 329397 : move16();
2571 329397 : move16();
2572 : }
2573 : }
2574 :
2575 3081561 : gain = Mult_32_16( gain, att ); // gain_e
2576 3081561 : gain_e = add( gain_e, 0 );
2577 :
2578 : /*gain=0.5f+log2f(gain)*2+16 becuase 2.885390081777927f=2*1/loge(2) so 2*1/loge(2)*loge(x) can be written as 2*log2(x)*/
2579 3081561 : gain = L_add( ONE_IN_Q22, L_add( L_add( L_shr( BASOP_Util_Log2( gain ), 1 ), L_shl( gain_e, Q24 ) ), L_shl( 16, Q23 ) ) ); /*Q23*/
2580 3081561 : test();
2581 3081561 : test();
2582 3081561 : IF( !isTransient && ( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_48000_CPE ) || EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_FB_48000_CPE ) ) )
2583 : {
2584 407549 : gain = L_add( gain, ONE_IN_Q21 ); /* better preservation of original HF band energy */
2585 : }
2586 3081561 : test();
2587 3081561 : test();
2588 3081561 : IF( !isTransient && ( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_64000_CPE ) || EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_FB_64000_CPE ) ) )
2589 : {
2590 543305 : gain = L_add( gain, ONE_IN_Q20 );
2591 : }
2592 3081561 : gain = L_min( gain, 91 << Q23 ); /* 13+15+63, see arithcode encode residual */
2593 3081561 : gain = L_max( gain, 0 );
2594 3081561 : gain_e = 8; /* stores exponent for gain_fx*/
2595 3081561 : move16();
2596 3081561 : hPrivateData->igfScfQuantized[sfb] = extract_l( L_shr( gain, Q23 ) ); /*Q0*/
2597 3081561 : move16();
2598 : }
2599 : }
2600 :
2601 569951 : return;
2602 : }
2603 :
2604 : /*-------------------------------------------------------------------*
2605 : * IGF_CalculateStereoEnvelope_fx()
2606 : *
2607 : * envelope estimation
2608 :
2609 : *-------------------------------------------------------------------*/
2610 125748 : static void IGF_CalculateStereoEnvelope_fx(
2611 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
2612 : const Word32 *pMDCTSpectrum_fx, /* i : MDCT spectrum */
2613 : Word16 pMDCTSpectrum_e, /* i : exponent for pMDCTSpectrum_fx */
2614 : const Word32 *pMDCTSpectrumMsInv_fx, /* i : MDCT spectrum */
2615 : Word16 pMDCTSpectrumMsInv_e, /* i : expontent for pMDCTSpectrumMsInv_fx */
2616 : const Word32 *pPowerSpectrum_fx, /* i : MDCT^2 + MDST^2 spectrum, or estimate */
2617 : Word16 *pPowerSpectrum_e, /* i : exponent for pPowerSpectrum_fx */
2618 : const Word32 *pPowerSpectrumMsInv_fx, /* i : inverse power spectrum */
2619 : Word16 *q_pPowerSpectrumMsInv, /* i : Q for pPowerSpectrumMsInv_fx */
2620 : const Word16 igfGridIdx, /* i : IGF grid index */
2621 : const Word16 coreMsMask[N_MAX], /* i : line wise ms Mask */
2622 : const Word16 isTransient, /* i : flag indicating if transient is detected */
2623 : const Word16 last_core_acelp, /* i : indicator if last frame was ACELP core */
2624 : const Word16 mct_on )
2625 : {
2626 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
2627 : H_IGF_GRID hGrid;
2628 : Word16 *swb_offset;
2629 : Word16 sfb; /* this is the actual scalefactor band */
2630 : Word16 width; /* this is width in subbands of the actual scalefactor band */
2631 : Word16 tile_idx;
2632 : Word16 strt_cpy;
2633 : Word32 gain_fx; /* the gain which has to be applied to the source tile to get the destination energy */
2634 : Word16 sb;
2635 : Word16 sfbEnergyR_fx;
2636 : Word32 sfbEnergyC_fx; /* the energy of the destination region of the tile */
2637 : Word32 sfbEnergyTileR_fx;
2638 : Word32 sfbEnergyTileC_fx; /* the energy of the destination region of the tile */
2639 : Word16 tmp, x, y;
2640 : Word16 mean_x_fx, mean_y_fx;
2641 : Word32 mean_xy_fx, mean_x2_fx;
2642 : Word16 slope_fx;
2643 : Word16 tmp_tb_fx;
2644 : Word16 tmp_sb_fx;
2645 : Word16 sfbCnt;
2646 : Word32 tileSrcSpec_fx[MAX_IGF_SFB_LEN];
2647 : Word16 sfm;
2648 : Word16 crest;
2649 : Word16 temp;
2650 : Word16 mean_x_e, mean_y_e; /*Stores exponent for mean_x and mean_y respectively*/
2651 : Word16 mean_xy_e, mean_x2_e; /*stores exponent for mean_xy and mean_x2 respectively*/
2652 : Word16 tileSrcSpec_e[MAX_IGF_SFB_LEN]; /*Exponent for tileSrcSpec_fx*/
2653 : Word16 sfbEnergyTileR_e; /*Exponent for sfbEnergyTileR_fx*/
2654 : Word16 sfbEnergyTileC_e; /*Exponent for sfbEnergyTileC_fx*/
2655 : Word16 sfbEnergyC_e; /*Exponent for sfbEnergyC_fx*/
2656 : Word16 gain_e; /*exponent for gain_fx*/
2657 : Word16 crest_exp; /*stores exponent for output from crest*/
2658 : Word16 sfm_exp; /*stores exponent for ouput from sfm*/
2659 : Word16 tmp_tb_e; /*Stores exponent for tmp_tb_fx*/
2660 : Word16 tmp_sb_e; /*stores exponent for tmp_sb_fx*/
2661 : Word16 slope_e; /*stores exponent for slope_fx*/
2662 : Word16 sfbEnergyR_e; /*stores exponent for sfbEnergyR*/
2663 : Word16 tmp_e;
2664 : Word32 temp_pPowerSpectrumMsInv[N_MAX], length;
2665 125748 : Word16 q_temp_pPowerSpectrumMsInv = Q31, i;
2666 125748 : move16();
2667 :
2668 125748 : IF( pPowerSpectrumMsInv_fx != NULL )
2669 : {
2670 104270 : length = N_MAX;
2671 104270 : move16();
2672 104270 : if ( mct_on )
2673 : {
2674 54358 : length = L_FRAME48k;
2675 54358 : move16();
2676 : }
2677 112182350 : FOR( i = 0; i < length; i++ )
2678 : {
2679 112078080 : IF( pPowerSpectrumMsInv_fx[i] != 0 )
2680 : {
2681 80056832 : q_temp_pPowerSpectrumMsInv = s_min( q_temp_pPowerSpectrumMsInv, add( q_pPowerSpectrumMsInv[i], norm_l( pPowerSpectrumMsInv_fx[i] ) ) );
2682 : }
2683 : }
2684 112182350 : FOR( i = 0; i < length; i++ )
2685 : {
2686 112078080 : temp_pPowerSpectrumMsInv[i] = L_shl( pPowerSpectrumMsInv_fx[i], sub( q_temp_pPowerSpectrumMsInv, q_pPowerSpectrumMsInv[i] ) );
2687 112078080 : move32();
2688 : }
2689 : }
2690 :
2691 125748 : hPrivateData = &hIGFEnc->igfData;
2692 125748 : hGrid = &hPrivateData->igfInfo.grid[(Word16) igfGridIdx];
2693 125748 : swb_offset = hGrid->swb_offset;
2694 125748 : move16();
2695 :
2696 125748 : IF( igfGridIdx != IGF_GRID_LB_NORM )
2697 : {
2698 29968 : FOR( sfbCnt = 0; sfbCnt < sub( hGrid->sfbWrap[hGrid->nTiles], hGrid->sfbWrap[0] ); sfbCnt++ )
2699 : {
2700 : /* reset filter */
2701 24744 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_FIR_TB_e[sfbCnt]
2702 24744 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_IIR_TB_e[sfbCnt]
2703 24744 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_FIR_SB_e[sfbCnt]
2704 24744 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfbCnt] = 0; // exponent : hPrivateData->prevSFB_IIR_SB_e[sfbCnt]
2705 24744 : hPrivateData->prevSFB_FIR_TB_e[sfbCnt] = 0;
2706 24744 : hPrivateData->prevSFB_IIR_TB_e[sfbCnt] = 0;
2707 24744 : hPrivateData->prevSFB_FIR_SB_e[sfbCnt] = 0;
2708 24744 : hPrivateData->prevSFB_IIR_SB_e[sfbCnt] = 0;
2709 24744 : move16();
2710 24744 : move16();
2711 24744 : move16();
2712 24744 : move16();
2713 24744 : move16();
2714 24744 : move16();
2715 24744 : move16();
2716 24744 : move16();
2717 : }
2718 : }
2719 :
2720 125748 : IF( pPowerSpectrum_fx )
2721 : {
2722 50388478 : FOR( sb = hGrid->sbWrap[0]; sb < swb_offset[hGrid->sfbWrap[hGrid->nTiles]]; sb++ )
2723 : {
2724 : /*hPrivateData->logSpec[sb] = max( 0, (Word16) ( logf( max( FLT_MIN, pPowerSpectrum[sb] ) ) * INV_LOG_2 ) );*/
2725 50284208 : IF( LE_32( 1, pPowerSpectrum_fx[sb] ) )
2726 : {
2727 50281893 : hPrivateData->logSpec[sb] = s_max( 0, (Word16) L_shr( L_add( BASOP_Util_Log2( pPowerSpectrum_fx[sb] ), L_shl( pPowerSpectrum_e[sb], Q25 ) ), 25 ) );
2728 : }
2729 : ELSE
2730 : {
2731 2315 : hPrivateData->logSpec[sb] = 0; /*max(0,-126) is always 0*/
2732 : }
2733 50284208 : move16();
2734 : }
2735 : }
2736 :
2737 505236 : FOR( tile_idx = 0; tile_idx < hGrid->nTiles; tile_idx++ )
2738 : {
2739 379488 : strt_cpy = hGrid->sbWrap[tile_idx];
2740 379488 : move16();
2741 :
2742 1022460 : FOR( sfb = hGrid->sfbWrap[tile_idx]; sfb < hGrid->sfbWrap[tile_idx + 1]; sfb++ )
2743 : {
2744 642972 : width = sub( swb_offset[sfb + 1], swb_offset[sfb] );
2745 642972 : sfbEnergyTileR_fx = EPSILON_FX;
2746 642972 : sfbEnergyTileC_fx = EPSILON_FX;
2747 642972 : sfbEnergyC_fx = EPSILON_FX;
2748 642972 : sfbEnergyTileR_e = 0;
2749 642972 : sfbEnergyTileC_e = 0;
2750 642972 : sfbEnergyC_e = 0;
2751 642972 : move16();
2752 642972 : move16();
2753 642972 : move16();
2754 642972 : move32();
2755 642972 : move32();
2756 642972 : move32();
2757 642972 : IF( pPowerSpectrum_fx )
2758 : {
2759 : Word16 final_exp;
2760 : Word16 norm_exp;
2761 : Word32 scaled_value;
2762 534644 : tmp = strt_cpy;
2763 534644 : move16();
2764 :
2765 28422340 : FOR( sb = swb_offset[sfb]; sb < swb_offset[sfb + 1]; sb++ )
2766 : {
2767 27887696 : IF( NE_16( coreMsMask[sb], coreMsMask[strt_cpy] ) )
2768 : {
2769 16645392 : sfbEnergyC_fx = BASOP_Util_Add_Mant32Exp( sfbEnergyC_fx, sfbEnergyC_e, pPowerSpectrum_fx[sb], pPowerSpectrum_e[sb], &sfbEnergyC_e ); /*resultant exponent is stored in sfbEnergyC_e*/
2770 16645392 : norm_exp = norm_l( pMDCTSpectrumMsInv_fx[strt_cpy] );
2771 16645392 : final_exp = sub( pMDCTSpectrumMsInv_e, norm_exp );
2772 16645392 : scaled_value = L_shl( pMDCTSpectrumMsInv_fx[strt_cpy], norm_exp );
2773 16645392 : sfbEnergyTileR_fx = BASOP_Util_Add_Mant32Exp( sfbEnergyTileR_fx, sfbEnergyTileR_e, Mult_32_32( scaled_value, scaled_value ), shl( final_exp, 1 ), &sfbEnergyTileR_e ); /*resultant exponent is stored in sfbEnergyTileR_e*/
2774 16645392 : sfbEnergyTileC_fx = BASOP_Util_Add_Mant32Exp( sfbEnergyTileC_fx, sfbEnergyTileC_e, pPowerSpectrumMsInv_fx[strt_cpy], sub( 31, q_pPowerSpectrumMsInv[strt_cpy] ), &sfbEnergyTileC_e ); /*resultant exponent is stored in sfbEnergyTileC_e*/
2775 16645392 : tileSrcSpec_fx[strt_cpy - tmp] = temp_pPowerSpectrumMsInv[strt_cpy]; /*resultant exponent is stored in tileSrcSpec_e*/
2776 16645392 : tileSrcSpec_e[strt_cpy - tmp] = sub( 31, q_temp_pPowerSpectrumMsInv );
2777 : }
2778 : ELSE
2779 : {
2780 11242304 : sfbEnergyC_fx = BASOP_Util_Add_Mant32Exp( sfbEnergyC_fx, sfbEnergyC_e, pPowerSpectrum_fx[sb], pPowerSpectrum_e[sb], &sfbEnergyC_e ); /*resultant exponent is stored in sfbEnergyC_e*/
2781 11242304 : norm_exp = norm_l( pMDCTSpectrum_fx[strt_cpy] );
2782 11242304 : final_exp = sub( pMDCTSpectrum_e, norm_exp );
2783 11242304 : scaled_value = L_shl( pMDCTSpectrum_fx[strt_cpy], norm_exp );
2784 11242304 : sfbEnergyTileR_fx = BASOP_Util_Add_Mant32Exp( sfbEnergyTileR_fx, sfbEnergyTileR_e, Mult_32_32( scaled_value, scaled_value ), shl( final_exp, 1 ), &sfbEnergyTileR_e ); /*resultant exponent is stored in sfbEnergyTileR_e*/
2785 11242304 : sfbEnergyTileC_fx = BASOP_Util_Add_Mant32Exp( sfbEnergyTileC_fx, sfbEnergyTileC_e, pPowerSpectrum_fx[strt_cpy], pPowerSpectrum_e[strt_cpy], &sfbEnergyTileC_e ); /*resultant exponent is stored in sfbEnergyTileC_e*/
2786 11242304 : tileSrcSpec_fx[strt_cpy - tmp] = pPowerSpectrum_fx[strt_cpy]; /*resultant exponent is stored in tileSrcSpec_e*/
2787 11242304 : tileSrcSpec_e[strt_cpy - tmp] = pPowerSpectrum_e[strt_cpy];
2788 : }
2789 27887696 : move32();
2790 27887696 : move16();
2791 27887696 : strt_cpy = add( strt_cpy, 1 );
2792 : }
2793 :
2794 534644 : sfbEnergyTileR_fx = BASOP_Util_Divide3216_Scale( sfbEnergyTileR_fx, width, &tmp_e );
2795 534644 : sfbEnergyTileR_e = sub( add( sfbEnergyTileR_e, tmp_e ), 15 ); /*stores the resultant exponent for sfbEnergyTileR_fx*/
2796 :
2797 : /*gain = (float) ( sfbEnergyTileR * ( sfbEnergyC / sfbEnergyTileC ) );*/
2798 534644 : temp = BASOP_Util_Divide3232_Scale( sfbEnergyC_fx, L_add( sfbEnergyTileC_fx, EPSILON_FX ), &tmp_e );
2799 534644 : gain_e = add( tmp_e, sub( sfbEnergyC_e, sfbEnergyTileC_e ) );
2800 534644 : gain_fx = Mult_32_16( sfbEnergyTileR_fx, temp );
2801 534644 : gain_e = add( 16, add( gain_e, sfbEnergyTileR_e ) ); /*stores the resultant exponent for gain_fx*/
2802 :
2803 534644 : IF( !isTransient )
2804 : {
2805 : Word16 diffSFM_fx;
2806 : Word16 shiftedSFM_fx;
2807 : Word16 shiftedSFM_e; /*stores the resultant exponent for shiftedSFM_fx*/
2808 534644 : shiftedSFM_fx = 0;
2809 534644 : shiftedSFM_e = 0;
2810 534644 : move16();
2811 534644 : move16();
2812 :
2813 : // tmp_tb = IGF_getSFM_ivas(pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1]) / IGF_getCrest_ivas(pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1]);
2814 534644 : sfm = IGF_getSFM_ivas_fx( &sfm_exp, pPowerSpectrum_fx, pPowerSpectrum_e, swb_offset[sfb], swb_offset[sfb + 1] );
2815 534644 : crest = IGF_getCrest_ivas( &crest_exp, pPowerSpectrum_fx, pPowerSpectrum_e, swb_offset[sfb], swb_offset[sfb + 1] );
2816 534644 : tmp_tb_fx = BASOP_Util_Divide1616_Scale( sfm, crest, &tmp_e );
2817 534644 : tmp_tb_e = add( tmp_e, sub( sfm_exp, crest_exp ) ); /*stores the resultant exponent for tmp_tb_fx*/
2818 :
2819 : // tmp_sb = IGF_getSFM_ivas(tileSrcSpec, 0, strt_cpy - tmp) / IGF_getCrest_ivas(tileSrcSpec, 0, strt_cpy - tmp);
2820 534644 : sfm = IGF_getSFM_ivas_fx( &sfm_exp, tileSrcSpec_fx, tileSrcSpec_e, 0, sub( strt_cpy, tmp ) );
2821 534644 : crest = IGF_getCrest_ivas( &crest_exp, tileSrcSpec_fx, tileSrcSpec_e, 0, sub( strt_cpy, tmp ) );
2822 534644 : tmp_sb_fx = BASOP_Util_Divide1616_Scale( sfm, crest, &tmp_e );
2823 534644 : tmp_sb_e = add( tmp_e, sub( sfm_exp, crest_exp ) ); /*stores the resultant exponent for tmp_sb_fx*/
2824 :
2825 534644 : IF( last_core_acelp || hPrivateData->wasTransient )
2826 : {
2827 9790 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = tmp_tb_fx; /*Exponent for hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] and hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] values stored in hPrivateData->sfb_tb_e[sfb] */
2828 9790 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = tmp_sb_fx; /*Exponent for hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] and hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] values stored in hPrivateData->sfb_sb_e[sfb]*/
2829 9790 : hPrivateData->prevSFB_FIR_TB_e[sfb] = tmp_sb_e;
2830 9790 : hPrivateData->prevSFB_IIR_TB_e[sfb] = tmp_sb_e;
2831 9790 : hPrivateData->prevSFB_FIR_SB_e[sfb] = tmp_sb_e;
2832 9790 : hPrivateData->prevSFB_IIR_SB_e[sfb] = tmp_sb_e;
2833 9790 : move16();
2834 9790 : move16();
2835 9790 : move16();
2836 9790 : move16();
2837 9790 : move16();
2838 9790 : move16();
2839 9790 : move16();
2840 9790 : move16();
2841 : }
2842 : ELSE
2843 : {
2844 : /* Purpose of this block:
2845 : -to make the exponent of hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] and hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] equal to that of tmp_tb_fx
2846 : -to make the exponent of hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] and hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] equal to that of tmp_sb_fx
2847 : */
2848 : Word16 diff_sb_e; /*stores the difference of exponents for sb*/
2849 : Word16 diff_tb_e; /*stores the difference of exponents for tb*/
2850 524854 : diff_sb_e = sub( tmp_sb_e, hPrivateData->sfb_sb_e[sfb] );
2851 524854 : diff_tb_e = sub( tmp_tb_e, hPrivateData->sfb_tb_e[sfb] );
2852 524854 : IF( LE_16( tmp_tb_e, hPrivateData->sfb_tb_e[sfb] ) )
2853 : {
2854 516220 : tmp_tb_fx = shl( tmp_tb_fx, diff_tb_e );
2855 516220 : tmp_tb_e = hPrivateData->sfb_tb_e[sfb];
2856 516220 : move16();
2857 : }
2858 : ELSE
2859 : {
2860 8634 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = shr( hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb], diff_tb_e );
2861 8634 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = shr( hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb], diff_tb_e );
2862 8634 : move16();
2863 8634 : move16();
2864 8634 : hPrivateData->prevSFB_FIR_TB_e[sfb] = tmp_tb_e;
2865 8634 : hPrivateData->prevSFB_IIR_TB_e[sfb] = tmp_tb_e;
2866 8634 : move16();
2867 8634 : move16();
2868 : }
2869 524854 : IF( LE_16( tmp_sb_e, hPrivateData->sfb_sb_e[sfb] ) )
2870 : {
2871 516017 : tmp_sb_fx = shl( tmp_sb_fx, diff_sb_e );
2872 516017 : tmp_sb_e = hPrivateData->sfb_sb_e[sfb];
2873 516017 : move16();
2874 : }
2875 : ELSE
2876 : {
2877 8837 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = shr( hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb], diff_sb_e );
2878 8837 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = shr( hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb], diff_sb_e );
2879 8837 : move16();
2880 8837 : move16();
2881 8837 : hPrivateData->prevSFB_FIR_SB_e[sfb] = tmp_sb_e;
2882 8837 : hPrivateData->prevSFB_IIR_SB_e[sfb] = tmp_sb_e;
2883 8837 : move16();
2884 8837 : move16();
2885 : }
2886 : }
2887 534644 : tmp_tb_fx = shr_sat( tmp_tb_fx, sub( 2, tmp_tb_e ) ); /* Since we're limiting max value to 2.7f we can saturate to Q13 */
2888 534644 : tmp_sb_fx = shr_sat( tmp_sb_fx, sub( 2, tmp_sb_e ) ); /* Since we're limiting max value to 2.7f we can saturate to Q13 */
2889 534644 : hPrivateData->SFM_tb_fx[sfb] = add_sat( tmp_tb_fx, add_sat( shr( hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb], sub( 2, hPrivateData->prevSFB_FIR_TB_e[sfb] ) ), shr( hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb], sub( 3, hPrivateData->prevSFB_IIR_TB_e[sfb] ) ) ) ); /* Since we're limiting max value to 2.7f we can saturate to Q13 */
2890 534644 : hPrivateData->SFM_tb_fx[sfb] = s_min( 22118 /*2.7f Q13*/, hPrivateData->SFM_tb_fx[sfb] ); /* resultant exponent stored in hPrivateData->sfb_sb_e[sfb]*/
2891 534644 : hPrivateData->SFM_sb_fx[sfb] = add_sat( tmp_sb_fx, add_sat( shr( hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb], sub( 2, hPrivateData->prevSFB_FIR_SB_e[sfb] ) ), shr( hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb], sub( 3, hPrivateData->prevSFB_IIR_SB_e[sfb] ) ) ) ); /* Since we're limiting max value to 2.7f we can saturate to Q13 */
2892 534644 : hPrivateData->SFM_sb_fx[sfb] = s_min( 22118 /*2.7f Q13*/, hPrivateData->SFM_sb_fx[sfb] ); /*resultant exponent stores in hPrivateData->sfb_tb_e[sfb]*/
2893 534644 : move16();
2894 534644 : move16();
2895 534644 : move16();
2896 534644 : move16();
2897 534644 : hPrivateData->sfb_sb_e[sfb] = 2;
2898 534644 : hPrivateData->sfb_tb_e[sfb] = 2;
2899 534644 : move16();
2900 534644 : move16();
2901 :
2902 534644 : diffSFM_fx = sub( hPrivateData->SFM_sb_fx[sfb], hPrivateData->SFM_tb_fx[sfb] ); /*Q13*/
2903 :
2904 534644 : test();
2905 534644 : IF( diffSFM_fx > 0 && LT_16( hPrivateData->SFM_tb_fx[sfb], 819 /*0.1 Q13*/ ) ) /* check whether target SFB is more tonal than source SFB */
2906 1322 : {
2907 : Word16 currDampingFactor_fx, dampingFactor_fx, alpha_fx;
2908 : Word16 threshold_e, threshold_fx, alpha_e, currDampingFactor_e, dampingFactor_e;
2909 : /* calculate spectral tilt to detect sudden drops (or increases) in energy in the current SFB */
2910 1322 : x = 1;
2911 1322 : mean_x_fx = mean_y_fx = 0;
2912 1322 : mean_xy_fx = mean_x2_fx = 0;
2913 1322 : mean_x_e = mean_y_e = 15;
2914 1322 : mean_xy_e = mean_x2_e = 31;
2915 1322 : move16();
2916 1322 : move16();
2917 1322 : move16();
2918 1322 : move16();
2919 1322 : move16();
2920 1322 : move16();
2921 1322 : move16();
2922 1322 : move16();
2923 1322 : move16();
2924 74094 : FOR( sb = swb_offset[sfb]; sb < swb_offset[sfb + 1]; sb++ )
2925 : {
2926 72772 : mean_x_fx = add( mean_x_fx, x ); /*Q0*/
2927 72772 : mean_x2_fx = L_add( mean_x2_fx, L_mult0( x, x ) ); /*Q0*/
2928 :
2929 : /*y = 20 * (Word16) log10f( max( 1e-018f, pPowerSpectrum[sb] ) );*/
2930 72772 : IF( LT_32( pPowerSpectrum_fx[sb], 1 ) )
2931 : {
2932 0 : y = 20 * ( -18 );
2933 0 : move16();
2934 : }
2935 : ELSE
2936 : {
2937 72772 : y = imult1616( 20, extract_l( L_shr( Mult_32_16( ( L_add( BASOP_Util_Log2( pPowerSpectrum_fx[sb] ), L_shl( pPowerSpectrum_e[sb], Q25 ) ) ), INV_Log2_10_Q15 ), 25 ) ) ); /*Q0*/
2938 : }
2939 72772 : mean_y_fx = add( mean_y_fx, y ); /*Q0*/
2940 72772 : mean_xy_fx = L_add( mean_xy_fx, L_mult0( y, x ) ); /*Q0*/
2941 :
2942 72772 : x = add( x, 1 );
2943 : }
2944 1322 : mean_y_fx = BASOP_Util_Divide1616_Scale( mean_y_fx, width, &tmp_e ); /* resultant exp stores in mean_y_e*/
2945 1322 : mean_y_e = add( mean_y_e, sub( tmp_e, 15 ) );
2946 1322 : mean_x_fx = BASOP_Util_Divide1616_Scale( mean_x_fx, width, &tmp_e ); /* resultant exp stores in mean_x_e*/
2947 1322 : mean_x_e = add( mean_x_e, sub( tmp_e, 15 ) );
2948 1322 : mean_xy_fx = BASOP_Util_Divide3216_Scale( mean_xy_fx, width, &tmp_e ); /* resultant exp stores in mean_xy_e*/
2949 1322 : mean_xy_e = add( mean_xy_e, sub( tmp_e, 15 ) );
2950 1322 : mean_x2_fx = BASOP_Util_Divide3216_Scale( mean_x2_fx, width, &tmp_e ); /* resultant exp stores in mean_x2_e*/
2951 1322 : mean_x2_e = add( mean_x2_e, sub( tmp_e, 15 ) );
2952 :
2953 : /*slope = ( mean_xy - mean_x * mean_y ) / ( mean_x2 - mean_x * mean_x );*/
2954 1322 : slope_fx = BASOP_Util_Divide3232_Scale( ( L_sub( mean_xy_fx, L_shl( mult( mean_x_fx, mean_y_fx ), sub( add( mean_x_e, mean_y_e ), mean_xy_e ) ) ) ), ( L_sub( mean_x2_fx, L_shl( mult( mean_x_fx, mean_x_fx ), sub( add( mean_x_e, mean_x_e ), mean_x2_e ) ) ) ), &slope_e );
2955 1322 : slope_e = add( slope_e, sub( mean_xy_e, mean_x2_e ) ); /*stores resultant exponent for slope_fx*/
2956 :
2957 : /* determine whether strong tilt is due to a step in the spectrum (e.g. band limitation, no damping)
2958 : or a tonal component close the band border (apply damping) by calculating SFM for a shift of 1/2 SFB width*/
2959 1322 : threshold_fx = BASOP_Util_Divide1616_Scale( 60, width, &threshold_e ); /*stores resultant exponent for threshold_fx*/
2960 1322 : test();
2961 1322 : IF( EQ_16( BASOP_Util_Cmp_Mant32Exp( slope_fx, add( slope_e, 16 ), negate( threshold_fx ), add( threshold_e, 16 ) ), -1 ) )
2962 : {
2963 37 : Word16 shift = shr( width, 1 );
2964 : // shiftedSFM = IGF_getSFM_ivas( pPowerSpectrum, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift ) / IGF_getCrest_ivas( pPowerSpectrum, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift );
2965 37 : sfm = IGF_getSFM_ivas_fx( &sfm_exp, pPowerSpectrum_fx, pPowerSpectrum_e, sub( swb_offset[sfb], shift ), sub( swb_offset[sfb + 1], shift ) );
2966 37 : crest = IGF_getCrest_ivas( &crest_exp, pPowerSpectrum_fx, pPowerSpectrum_e, sub( swb_offset[sfb], shift ), sub( swb_offset[sfb + 1], shift ) );
2967 37 : shiftedSFM_fx = BASOP_Util_Divide1616_Scale( sfm, crest, &shiftedSFM_e );
2968 : }
2969 1285 : ELSE IF( EQ_16( BASOP_Util_Cmp_Mant32Exp( slope_fx, add( slope_e, 16 ), threshold_fx, add( threshold_e, 16 ) ), 1 ) && ( NE_16( sfb, sub( hGrid->sfbWrap[hGrid->nTiles], 1 ) ) ) )
2970 : {
2971 : Word16 shift;
2972 2 : shift = shr( width, 1 );
2973 : // shiftedSFM = IGF_getSFM_ivas( pPowerSpectrum, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift ) / IGF_getCrest_ivas( pPowerSpectrum, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift );
2974 2 : sfm = IGF_getSFM_ivas_fx( &sfm_exp, pPowerSpectrum_fx, pPowerSpectrum_e, add( swb_offset[sfb], shift ), add( swb_offset[sfb + 1], shift ) );
2975 2 : crest = IGF_getCrest_ivas( &crest_exp, pPowerSpectrum_fx, pPowerSpectrum_e, add( swb_offset[sfb], shift ), add( swb_offset[sfb + 1], shift ) );
2976 2 : shiftedSFM_fx = BASOP_Util_Divide1616_Scale( sfm, crest, &shiftedSFM_e );
2977 : }
2978 1322 : IF( shiftedSFM_fx )
2979 : {
2980 39 : shiftedSFM_e = add( shiftedSFM_e, sub( sfm_exp, crest_exp ) ); /* stores resultant exponent for shiftedSFM_fx*/
2981 : }
2982 :
2983 : // alpha = min( 320.f / (float) swb_offset[sfb + 1], 1.25f );
2984 1322 : temp = BASOP_Util_Divide1616_Scale( 320, swb_offset[sfb + 1], &alpha_e );
2985 1322 : alpha_fx = extract_l( L_min( temp, L_shl( 20480 /*1.25 Q14*/, sub( 1, alpha_e ) ) ) ); /* exponent is alpha_e*/
2986 1322 : temp = BASOP_Util_Divide1616_Scale( hPrivateData->SFM_tb_fx[sfb], hPrivateData->SFM_sb_fx[sfb], &tmp_e );
2987 1322 : tmp_e = add( tmp_e, sub( hPrivateData->sfb_tb_e[sfb], hPrivateData->sfb_sb_e[sfb] ) ); /* stores resultant exponent for temp */
2988 :
2989 : // currDampingFactor = expf( alpha * logf( hPrivateData->SFM_tb[sfb] / hPrivateData->SFM_sb[sfb] ) );
2990 1322 : currDampingFactor_fx = round_fx( BASOP_util_Pow2( Mpy_32_16_1( L_add( BASOP_Util_Log2( temp ), L_shl( add( 16, tmp_e ), 25 ) ), alpha_fx ), add( alpha_e, 6 ), &currDampingFactor_e ) ); /*exp is currDampingFactor_e*/
2991 :
2992 1322 : IF( GT_32( shiftedSFM_fx, L_shl( 1311 /*0.04f Q15*/, negate( shiftedSFM_e ) ) ) )
2993 : {
2994 8 : currDampingFactor_fx = 32767; /*1.f Q15*/
2995 8 : currDampingFactor_e = 0;
2996 8 : move16();
2997 8 : move16();
2998 : }
2999 1322 : test();
3000 1322 : test();
3001 1322 : IF( last_core_acelp || hPrivateData->wasTransient || EQ_32( hPrivateData->prevDampingFactor_IIR_fx[sfb], L_shl( -1, sub( 15, hPrivateData->prevDampingFactor_IIR_e[sfb] ) ) ) )
3002 : {
3003 630 : tmp = BASOP_Util_Cmp_Mant32Exp( currDampingFactor_fx, currDampingFactor_e, 3277, 0 );
3004 630 : IF( tmp >= 0 )
3005 : {
3006 630 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = currDampingFactor_fx;
3007 630 : hPrivateData->prevDampingFactor_IIR_e[sfb] = currDampingFactor_e;
3008 : }
3009 : ELSE
3010 : {
3011 0 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = 3277; /* 0.1 in Q15 */
3012 0 : hPrivateData->prevDampingFactor_IIR_e[sfb] = 0;
3013 : }
3014 :
3015 630 : move16();
3016 630 : move16();
3017 : }
3018 :
3019 : {
3020 : Word32 tonalToNoise;
3021 : Word16 adap;
3022 : Word16 adap_e; /*stores exp for adap*/
3023 : Word16 tonalToNoise_e; /*stores exponent for tonalToNoise*/
3024 1322 : tonalToNoise_e = 9; /*stores exponent for tonalToNoise*/
3025 1322 : move16();
3026 1322 : adap = BASOP_Util_Divide1616_Scale( width, 30, &adap_e );
3027 1322 : tonalToNoise = IGF_getTNR_ivas_fx( pPowerSpectrum_fx, swb_offset[sfb], swb_offset[sfb + 1], adap, pPowerSpectrum_e, adap_e ); /*Q22*/
3028 1322 : IF( EQ_16( BASOP_Util_Cmp_Mant32Exp( tonalToNoise, tonalToNoise_e, L_add( L_shl( 10, sub( 15, adap_e ) ), adap ), add( 16, adap_e ) ), -1 ) )
3029 : {
3030 : // currDampingFactor += 0.1f * ( ( 10 + adap ) - tonalToNoise );
3031 1196 : Word32 temp2 = BASOP_Util_Add_Mant32Exp( L_add( L_shl( 10, sub( 15, adap_e ) ) /*exp:adap_e*/, adap ), add( adap_e, 16 ), L_negate( tonalToNoise ), tonalToNoise_e, &tmp_e ); /* resultant exp is tmp_e*/
3032 1196 : currDampingFactor_e = BASOP_Util_Add_MantExp( currDampingFactor_fx, currDampingFactor_e, extract_l( Mult_32_16( temp2, 3277 /*0.1f Q15*/ ) ), tmp_e, &currDampingFactor_fx ); /*stores resultant exp for currDampingFactor_fx*/
3033 : }
3034 : }
3035 :
3036 1322 : dampingFactor_e = BASOP_Util_Add_MantExp( currDampingFactor_fx, currDampingFactor_e, hPrivateData->prevDampingFactor_IIR_fx[sfb], hPrivateData->prevDampingFactor_IIR_e[sfb], &dampingFactor_fx );
3037 1322 : dampingFactor_fx = shr( dampingFactor_fx, 1 ); /* resultant exponent is dampingFactor_e*/
3038 1322 : IF( NE_16( BASOP_Util_Cmp_Mant32Exp( dampingFactor_fx, add( dampingFactor_e, 16 ), shr( hPrivateData->prevDampingFactor_IIR_fx[sfb], 1 ), add( hPrivateData->prevDampingFactor_IIR_e[sfb], 16 ) ), -1 ) )
3039 : {
3040 : // do nothing
3041 : }
3042 : ELSE
3043 : {
3044 593 : dampingFactor_fx = shr( hPrivateData->prevDampingFactor_IIR_fx[sfb], 1 ); /* resultant exponent is hPrivateData->prevDampingFactor_IIR_e[sfb]*/
3045 593 : dampingFactor_e = hPrivateData->prevDampingFactor_IIR_e[sfb];
3046 593 : move16();
3047 : }
3048 1322 : IF( dampingFactor_e < 0 )
3049 : {
3050 63 : dampingFactor_fx = shl( dampingFactor_fx, dampingFactor_e );
3051 63 : dampingFactor_e = 0;
3052 63 : move16();
3053 : }
3054 1322 : gain_fx = Mult_32_16( gain_fx, shl_sat( extract_l( L_min( L_add( dampingFactor_fx, Mult_32_16( L_shl( hPrivateData->dampingFactorSmoothing[sfb], sub( 15, dampingFactor_e ) ) /*Q:15-dampingFactor_e*/, 3277 /*0.1f Q15*/ ) /*Q:15-dampingFactor_e*/ ), shl_sat( 1, sub( 15, dampingFactor_e ) ) ) ), dampingFactor_e ) /*Q15*/ );
3055 :
3056 1322 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = dampingFactor_fx;
3057 1322 : hPrivateData->prevDampingFactor_IIR_e[sfb] = dampingFactor_e;
3058 1322 : move16();
3059 1322 : move16();
3060 1322 : if ( hPrivateData->dampingFactorSmoothing[sfb] > 0 )
3061 : {
3062 749 : hPrivateData->dampingFactorSmoothing[sfb] = sub( hPrivateData->dampingFactorSmoothing[sfb], 1 );
3063 749 : move16();
3064 : }
3065 : }
3066 : ELSE
3067 : {
3068 533322 : hPrivateData->prevDampingFactor_IIR_fx[sfb] = -( 1 << 15 ); /* resultant exp which is 0 stores in hPrivateData->prevDampingFactor_IIR_e[sfb]*/
3069 533322 : hPrivateData->prevDampingFactor_IIR_e[sfb] = 0;
3070 533322 : hPrivateData->dampingFactorSmoothing[sfb] = 1;
3071 533322 : move16();
3072 533322 : move16();
3073 533322 : move16();
3074 : }
3075 :
3076 534644 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = tmp_tb_fx;
3077 534644 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = hPrivateData->SFM_tb_fx[sfb];
3078 534644 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = tmp_sb_fx;
3079 534644 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = hPrivateData->SFM_sb_fx[sfb];
3080 534644 : hPrivateData->prevSFB_FIR_TB_e[sfb] = hPrivateData->sfb_tb_e[sfb];
3081 534644 : hPrivateData->prevSFB_IIR_TB_e[sfb] = hPrivateData->sfb_tb_e[sfb];
3082 534644 : hPrivateData->prevSFB_FIR_SB_e[sfb] = hPrivateData->sfb_sb_e[sfb];
3083 534644 : hPrivateData->prevSFB_IIR_SB_e[sfb] = hPrivateData->sfb_sb_e[sfb];
3084 534644 : move16();
3085 534644 : move16();
3086 534644 : move16();
3087 534644 : move16();
3088 534644 : move16();
3089 534644 : move16();
3090 534644 : move16();
3091 534644 : move16();
3092 : }
3093 : ELSE
3094 : {
3095 0 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = 0;
3096 0 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = 0;
3097 0 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = 0;
3098 0 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = 0;
3099 0 : hPrivateData->prevSFB_FIR_TB_e[sfb] = 0;
3100 0 : hPrivateData->prevSFB_IIR_TB_e[sfb] = 0;
3101 0 : hPrivateData->prevSFB_FIR_SB_e[sfb] = 0;
3102 0 : hPrivateData->prevSFB_IIR_SB_e[sfb] = 0;
3103 :
3104 0 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
3105 0 : move16();
3106 0 : move16();
3107 0 : move16();
3108 0 : move16();
3109 0 : move16();
3110 0 : move16();
3111 0 : move16();
3112 0 : move16();
3113 0 : move16();
3114 : }
3115 : }
3116 : ELSE
3117 : {
3118 108328 : tmp_e = pMDCTSpectrum_e;
3119 108328 : sfbEnergyR_fx = add_sat( EPSILON_FX, BASOP_Util_Divide3216_Scale( sum2_32_fx( pMDCTSpectrum_fx + swb_offset[sfb], width, &tmp_e ) /*exp: tmp_e*/, width, &sfbEnergyR_e ) );
3120 108328 : sfbEnergyR_e = add( sfbEnergyR_e, add( tmp_e, -15 ) ); /* stores resultant exponent for sfbEnergyR_fx*/
3121 108328 : gain_fx = sfbEnergyR_fx; /*resultant exponent stored in gain_e=sfbEnergyR_e*/
3122 108328 : move32();
3123 108328 : gain_e = add( sfbEnergyR_e, 16 ); /* because gain_fx is word32;only after adding 16 q of gain_fx is 15-sfbEnergyR_e*/
3124 :
3125 108328 : hPrivateData->prevSFM_FIR_SFB_TB_fx[sfb] = 0;
3126 108328 : hPrivateData->prevSFM_IIR_SFB_TB_fx[sfb] = 0;
3127 108328 : hPrivateData->prevSFM_FIR_SFB_SB_fx[sfb] = 0;
3128 108328 : hPrivateData->prevSFM_IIR_SFB_SB_fx[sfb] = 0;
3129 108328 : hPrivateData->prevSFB_FIR_TB_e[sfb] = 0;
3130 108328 : hPrivateData->prevSFB_IIR_TB_e[sfb] = 0;
3131 108328 : hPrivateData->prevSFB_FIR_SB_e[sfb] = 0;
3132 108328 : hPrivateData->prevSFB_IIR_SB_e[sfb] = 0;
3133 108328 : move16();
3134 108328 : move16();
3135 108328 : move16();
3136 108328 : move16();
3137 108328 : move16();
3138 108328 : move16();
3139 108328 : move16();
3140 108328 : move16();
3141 : }
3142 : /*gain=0.5f+log2f(gain)*2+16 becuase 2.885390081777927f=2*1/loge(2) so 2*1/loge(2)*loge(x) can be written as 2*log2(x)*/
3143 642972 : gain_fx = L_add( ONE_IN_Q22, L_add( L_add( L_shr( BASOP_Util_Log2( gain_fx ), 1 ), L_shl( gain_e, Q24 ) ), L_shl( 16, Q23 ) ) ); /*Q23*/
3144 642972 : test();
3145 642972 : test();
3146 642972 : if ( !isTransient && ( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_48000_CPE ) || EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_FB_48000_CPE ) ) )
3147 : {
3148 130581 : gain_fx = L_add( gain_fx, ONE_IN_Q21 ); /* better preservation of original HF band energy */
3149 : }
3150 642972 : test();
3151 642972 : test();
3152 642972 : if ( !isTransient && ( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_64000_CPE ) || EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_FB_64000_CPE ) ) )
3153 : {
3154 254910 : gain_fx = L_add( gain_fx, ONE_IN_Q20 );
3155 : }
3156 642972 : gain_fx = L_min( gain_fx, 91 << Q23 ); /* 13+15+63, see arithcode encode residual */
3157 642972 : gain_fx = L_max( gain_fx, 0 );
3158 642972 : gain_e = 8; /* stores exponent for gain_fx*/
3159 642972 : move16();
3160 642972 : hPrivateData->igfScfQuantized[sfb] = (Word16) ( L_shr( gain_fx, 23 ) ); /*Q0*/
3161 642972 : move16();
3162 : }
3163 : }
3164 :
3165 125748 : return;
3166 : }
3167 :
3168 :
3169 : /*-------------------------------------------------------------------*
3170 : * IGF_WriteEnvelope()
3171 : *
3172 : * writes IGF SCF values
3173 : *-------------------------------------------------------------------*/
3174 : /*! r: number of bits writen */
3175 1364868 : static Word16 IGF_WriteEnvelope_ivas(
3176 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
3177 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
3178 : Word16 *pBitOffset, /* i : ptr to bitOffset counter */
3179 : const Word16 igfGridIdx, /* i : igf grid index see declaration of IGF_GRID_IDX for details */
3180 : const Word16 isIndepFlag, /* i : if 1 frame is independent, 0 = frame is coded with data from previous frame */
3181 : Word16 *igfAllZero /* i : returns 1 if all IGF scfs are zero, else 0 */
3182 : )
3183 : {
3184 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
3185 : H_IGF_GRID hGrid;
3186 : Word16 sfb;
3187 : Word16 totBitCount;
3188 : Word16 startBitCount;
3189 :
3190 1364868 : startBitCount = *pBitOffset;
3191 1364868 : totBitCount = 0;
3192 1364868 : *igfAllZero = 1;
3193 1364868 : move16();
3194 1364868 : move16();
3195 1364868 : move16();
3196 1364868 : hPrivateData = &hIGFEnc->igfData;
3197 1364868 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
3198 :
3199 1530768 : FOR( sfb = hGrid->startSfb; sfb < hGrid->stopSfb; sfb++ )
3200 : {
3201 1508784 : IF( hPrivateData->igfScfQuantized[sfb] != 0 )
3202 : {
3203 1342884 : *igfAllZero = 0;
3204 1342884 : move16();
3205 1342884 : BREAK;
3206 : }
3207 : }
3208 :
3209 1364868 : IF( *igfAllZero != 0 )
3210 : {
3211 21984 : IGF_write_bit_fx( hBstr, pBitOffset, 1 );
3212 :
3213 21984 : if ( NULL == hBstr )
3214 : {
3215 10972 : IGFSCFEncoderSaveContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
3216 : }
3217 :
3218 21984 : IGFSCFEncoderReset_fx( &hPrivateData->hIGFSCFArithEnc );
3219 :
3220 21984 : if ( NULL == hBstr )
3221 : {
3222 10972 : IGFSCFEncoderRestoreContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
3223 : }
3224 : }
3225 : ELSE
3226 : {
3227 1342884 : IGF_write_bit_fx( hBstr, pBitOffset, 0 );
3228 :
3229 1342884 : if ( NULL == hBstr )
3230 : {
3231 658197 : IGFSCFEncoderSaveContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
3232 : }
3233 :
3234 1342884 : *pBitOffset = IGFSCFEncoderEncode_ivas_fx( &hPrivateData->hIGFSCFArithEnc, hBstr, *pBitOffset, &hPrivateData->igfScfQuantized[hGrid->startSfb], igfGridIdx, isIndepFlag );
3235 1342884 : move16();
3236 :
3237 1342884 : if ( NULL == hBstr )
3238 : {
3239 658197 : IGFSCFEncoderRestoreContextState_fx( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
3240 : }
3241 : }
3242 1364868 : totBitCount = sub( *pBitOffset, startBitCount );
3243 :
3244 1364868 : return totBitCount;
3245 : }
3246 :
3247 :
3248 : /*-------------------------------------------------------------------*
3249 : * IGF_Whitening()
3250 : *
3251 : * calculates the IGF whitening levels by SFM and crest
3252 : *-------------------------------------------------------------------*/
3253 :
3254 695699 : static void IGF_Whitening_ivas_fx(
3255 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : | instance handle of IGF Encoder */
3256 : Word32 *powerSpectrum, /* i : Q31 | MDCT/MDST power spectrum */
3257 : Word16 *powerSpectrum_e, /* i : Q31 | MDCT/MDST power spectrum */
3258 : const Word16 igfGridIdx, /* i : Q0 | IGF grid index */
3259 : const Word16 isTransient, /* i : Q0 | flag indicating if transient is detected */
3260 : const Word16 last_core_acelp, /* i : Q0 | indicator if last frame was ACELP core */
3261 : const Word16 isTNSActive, /* i : Q0 | indicator if TNS is active */
3262 : const Word16 sp_aud_decision0, /* i : Q0 | first stage classifier decision */
3263 : const Word32 brate, /* i : Q0 | bitrate */
3264 : const Word16 element_mode /* i : Q0 | element mode */
3265 : )
3266 : {
3267 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
3268 : H_IGF_GRID hGrid;
3269 : Word16 p; /*Q0*/
3270 : Word16 tmp;
3271 : Word16 tmp_e;
3272 : Word16 SFM_src;
3273 : Word16 SFM_tar;
3274 : Word16 SFM_src_e;
3275 : Word16 SFM_tar_e;
3276 : Word16 num_Tiles;
3277 : Word16 SFM;
3278 : Word16 crest_e;
3279 :
3280 695699 : SFM = -ONE_IN_Q13; /*1.0f Q13*/
3281 695699 : move16();
3282 :
3283 695699 : hPrivateData = &hIGFEnc->igfData;
3284 695699 : hGrid = &hPrivateData->igfInfo.grid[(Word16) igfGridIdx];
3285 :
3286 695699 : IF( NE_16( igfGridIdx, IGF_GRID_LB_NORM ) )
3287 : {
3288 167689 : FOR( p = 0; p < hGrid->nTiles; p++ )
3289 : {
3290 : /* reset filter */
3291 129917 : hPrivateData->prevSFM_FIR[p] = L_deposit_l( 0 );
3292 129917 : hPrivateData->prevSFM_IIR[p] = 0;
3293 129917 : move16();
3294 :
3295 : /* preset values: */
3296 129917 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
3297 129917 : move16();
3298 : }
3299 : }
3300 :
3301 7652689 : FOR( p = 0; p < IGF_MAX_TILES; p++ )
3302 : {
3303 : /* update prev data: */
3304 6956990 : hPrivateData->igfPrevWhiteningLevel[p] = hPrivateData->igfCurrWhiteningLevel[p];
3305 : /* preset values: */
3306 6956990 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
3307 6956990 : move16();
3308 6956990 : move16();
3309 : }
3310 :
3311 695699 : test();
3312 695699 : IF( !( isTransient || hPrivateData->wasTransient ) )
3313 : {
3314 654809 : IF( powerSpectrum )
3315 : {
3316 2964989 : FOR( p = 0; p < hGrid->nTiles; p++ )
3317 : {
3318 : Word16 sb;
3319 :
3320 2311734 : IF( isTNSActive )
3321 : {
3322 17005450 : FOR( sb = hGrid->tile[p]; sb < hGrid->tile[p + 1]; sb++ )
3323 : {
3324 16835804 : IF( LT_32( powerSpectrum[sb], 1 ) )
3325 27407 : hPrivateData->logSpec[sb] = 0; /* max(0,FLT_MIN_EXP )*/
3326 : ELSE
3327 16808397 : hPrivateData->logSpec[sb] = extract_l( L_max( 0, L_shr( L_add( BASOP_Util_Log2( powerSpectrum[sb] ), L_shl( powerSpectrum_e[sb], Q25 ) ), Q25 ) ) );
3328 16835804 : move16();
3329 : }
3330 : }
3331 :
3332 : /* if current tile contains only a single SFB, reuse already computed SFM values */
3333 2311734 : test();
3334 2311734 : IF( element_mode > EVS_MONO && EQ_16( sub( hGrid->sfbWrap[p + 1], hGrid->sfbWrap[p] ), 1 ) )
3335 : {
3336 1424191 : tmp = hPrivateData->SFM_tb_fx[p];
3337 1424191 : tmp_e = hPrivateData->sfb_tb_e[p];
3338 1424191 : move16();
3339 1424191 : move16();
3340 : }
3341 : ELSE
3342 : {
3343 887543 : tmp = BASOP_Util_Divide1616_Scale( IGF_getSFM_new_fx( powerSpectrum, hPrivateData->logSpec, hGrid->tile[p], hGrid->tile[p + 1], powerSpectrum_e ), IGF_getCrest_new_fx( hPrivateData->logSpec, hGrid->tile[p], hGrid->tile[p + 1], &crest_e ), &tmp_e );
3344 887543 : tmp_e = sub( tmp_e, crest_e );
3345 : }
3346 :
3347 2311734 : test();
3348 2311734 : IF( last_core_acelp || hPrivateData->wasTransient )
3349 : {
3350 64301 : hPrivateData->prevSFM_FIR[p] = L_shl( tmp, add( 1, tmp_e ) ); /*16-(15-exp)=>15Q16*/
3351 64301 : hPrivateData->prevSFM_IIR[p] = shl( tmp, sub( tmp_e, 2 ) ); /*13-(15-exp)=>2Q13*/
3352 64301 : move32();
3353 64301 : move16();
3354 : }
3355 :
3356 2311734 : test();
3357 2311734 : IF( LE_32( brate, IVAS_48k ) && EQ_16( element_mode, IVAS_CPE_MDCT ) )
3358 487669 : {
3359 : Word16 temp;
3360 487669 : num_Tiles = 0;
3361 487669 : SFM_src = 0;
3362 487669 : SFM_tar = 0;
3363 487669 : SFM_src_e = 0;
3364 487669 : SFM_tar_e = 0;
3365 487669 : move16();
3366 487669 : move16();
3367 487669 : move16();
3368 487669 : move16();
3369 487669 : move16();
3370 :
3371 1007343 : FOR( sb = hGrid->sfbWrap[p]; sb < hGrid->sfbWrap[p + 1]; sb++ )
3372 : {
3373 519674 : num_Tiles = add( num_Tiles, 1 );
3374 519674 : SFM_src_e = BASOP_Util_Add_MantExp( hPrivateData->SFM_sb_fx[sb], hPrivateData->sfb_sb_e[sb], SFM_src, SFM_src_e, &SFM_src );
3375 519674 : SFM_tar_e = BASOP_Util_Add_MantExp( hPrivateData->SFM_tb_fx[sb], hPrivateData->sfb_tb_e[sb], SFM_tar, SFM_tar_e, &SFM_tar );
3376 : }
3377 :
3378 : /* compute the average */
3379 487669 : SFM_src = shr( BASOP_Util_Divide1616_Scale( SFM_src, num_Tiles, &temp ), 2 );
3380 487669 : SFM_src_e = add( SFM_src_e, sub( temp, 13 ) ); /*temp-15+2:because right shifted by 2 which are the guard bits*/
3381 487669 : SFM_tar = shr( BASOP_Util_Divide1616_Scale( SFM_tar, num_Tiles, &temp ), 2 );
3382 487669 : SFM_tar_e = add( SFM_tar_e, sub( temp, 13 ) ); /*temp-15+2:because right shifted by 2 which are the guard bits*/
3383 :
3384 487669 : IF( LT_16( SFM_tar_e, SFM_src_e ) )
3385 : {
3386 39157 : SFM_tar = shl( SFM_tar, sub( SFM_tar_e, SFM_src_e ) ); /*making the q for SFM_tar and SFM_src equal with 2 as guard bits*/
3387 39157 : SFM_tar_e = SFM_src_e;
3388 : }
3389 : ELSE
3390 : {
3391 448512 : SFM_src = shr( SFM_src, sub( SFM_tar_e, SFM_src_e ) ); /*making the q for SFM_tar and SFM_src equal with 2 as guard bits*/
3392 448512 : SFM_src_e = SFM_tar_e;
3393 : }
3394 487669 : move16();
3395 :
3396 487669 : test();
3397 487669 : test();
3398 487669 : IF( ( p > 0 ) && ( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_48000_CPE ) || EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_FB_48000_CPE ) ) )
3399 : {
3400 411725 : test();
3401 411725 : if ( EQ_16( p, 1 ) && EQ_16( abs_s( sub( hPrivateData->igfCurrWhiteningLevel[0], hPrivateData->igfCurrWhiteningLevel[1] ) ), 2 ) ) /* OFF vs. STRONG */
3402 : {
3403 6520 : hPrivateData->igfCurrWhiteningLevel[0] = IGF_WHITENING_MID;
3404 6520 : move16();
3405 : }
3406 411725 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfCurrWhiteningLevel[p - 1];
3407 411725 : move16();
3408 : }
3409 75944 : ELSE IF( sp_aud_decision0 )
3410 : {
3411 : /* Music */
3412 : /* whitening Off: when tonality of target is more than source or tonality of target is close to that of source */
3413 37440 : test();
3414 37440 : if ( LE_16( SFM_tar, SFM_src ) || LE_32( SFM_tar, L_add( SFM_src, L_shl( 1, sub( 14, SFM_src_e /*0.5 with exponent SFM_src_e*/ ) ) ) ) )
3415 : {
3416 31420 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
3417 31420 : move16();
3418 : }
3419 :
3420 : /* whitening mid: */
3421 37440 : test();
3422 37440 : if ( GT_32( SFM_tar, L_add( SFM_src, L_shl( 1, sub( 14, SFM_src_e /*0.5 with exponent SFM_src_e*/ ) ) ) ) && LE_32( SFM_tar, L_add( SFM_src, L_shl( 5, sub( 13, SFM_src_e ) ) /*1.25 with exponent SFM_src_e*/ ) ) )
3423 : {
3424 5553 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
3425 5553 : move16();
3426 : }
3427 :
3428 : /* whitening strong */
3429 37440 : if ( GT_32( SFM_tar, L_add( SFM_src, L_shl( 5, sub( 13, SFM_src_e ) ) /*1.25 with exponent SFM_src_e*/ ) ) )
3430 : {
3431 467 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_STRONG;
3432 467 : move16();
3433 : }
3434 : }
3435 : ELSE
3436 : {
3437 : /* Speech */
3438 : /* whitening Off: when tonality of target is more than source or tonality of target is close to that of source */
3439 38504 : test();
3440 38504 : if ( LE_16( SFM_tar, SFM_src ) || LE_32( SFM_tar, L_add( SFM_src, L_shr( 3277 /*0.1 Q15*/, SFM_src_e ) ) ) )
3441 : {
3442 19344 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
3443 19344 : move16();
3444 : }
3445 :
3446 : /* whitening mid: */
3447 38504 : test();
3448 38504 : if ( GT_32( SFM_tar, L_add( SFM_src, L_shr( 3277 /*0.1 Q15*/, SFM_src_e ) ) ) && LE_32( SFM_tar, L_add( SFM_src, L_shl( 1, sub( 14, SFM_src_e /*0.5 with exponent SFM_src_e*/ ) ) ) ) )
3449 : {
3450 12439 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
3451 12439 : move16();
3452 : }
3453 :
3454 : /* whitening strong */
3455 38504 : if ( GT_32( SFM_tar, L_add( SFM_src, L_shl( 1, sub( 14, SFM_src_e /*0.5 with exponent SFM_src_e*/ ) ) ) ) )
3456 : {
3457 6721 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_STRONG;
3458 6721 : move16();
3459 : }
3460 : }
3461 :
3462 487669 : SFM = shl( SFM_tar, sub( SFM_tar_e, 2 ) ); /*2Q13*/
3463 : }
3464 : ELSE
3465 : {
3466 1824065 : test();
3467 1824065 : IF( element_mode > EVS_MONO && EQ_16( sub( hGrid->sfbWrap[p + 1], hGrid->sfbWrap[p] ), 1 ) )
3468 : {
3469 968527 : SFM = shl( tmp, sub( tmp_e, 2 ) ); /*2Q13*/
3470 : }
3471 : ELSE
3472 : {
3473 : Word32 temp;
3474 855538 : temp = L_add( L_shl( tmp, sub( tmp_e, 2 ) ), L_add( L_shr( hPrivateData->prevSFM_FIR[p], 3 ), L_shr( hPrivateData->prevSFM_IIR[p], 1 ) ) );
3475 855538 : SFM = extract_l( L_min( 22118 /*2.7*/, temp ) ); /*2Q13*/
3476 : }
3477 1824065 : hPrivateData->prevSFM_FIR[p] = L_shl( tmp, add( 1, tmp_e ) ); /*15Q16*/
3478 1824065 : hPrivateData->prevSFM_IIR[p] = SFM;
3479 1824065 : move32();
3480 1824065 : move16();
3481 :
3482 1824065 : IF( GT_16( SFM, hGrid->whiteningThreshold[1][p] ) )
3483 : {
3484 725057 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_STRONG;
3485 725057 : move16();
3486 : }
3487 1099008 : ELSE IF( GT_16( SFM, hGrid->whiteningThreshold[0][p] ) )
3488 : {
3489 691839 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
3490 691839 : move16();
3491 : }
3492 : ELSE
3493 : {
3494 407169 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
3495 407169 : move16();
3496 : }
3497 : }
3498 :
3499 2311734 : IF( element_mode > EVS_MONO )
3500 : {
3501 2311734 : IF( last_core_acelp ) /* reset */
3502 : {
3503 64301 : set16_fx( hPrivateData->igfPastSFM_fx[p], -ONE_IN_Q13, IGF_PAST_SFM_LEN );
3504 64301 : hPrivateData->igfWhiteningHangoverCnt[p] = 2;
3505 64301 : move16();
3506 : }
3507 : ELSE
3508 : {
3509 2247433 : test();
3510 2247433 : test();
3511 2247433 : test();
3512 2247433 : test();
3513 : /* check whether change in whitening level should be allowed or not (if SFM is inside a certain margin around thresholds) */
3514 2247433 : IF( NE_16( hPrivateData->igfCurrWhiteningLevel[p], hPrivateData->igfPrevWhiteningLevel[p] ) &&
3515 : ( ( GT_32( SFM, L_sub( hGrid->whiteningThreshold[0][p], 1229 /*0.15f Q13*/ ) ) && LT_32( SFM, L_add( hGrid->whiteningThreshold[0][p], 1229 ) ) ) ||
3516 : ( GT_32( SFM, L_sub( hGrid->whiteningThreshold[1][p], 1229 ) ) && LT_32( SFM, L_add( hGrid->whiteningThreshold[1][p], 1229 ) ) ) ) )
3517 : {
3518 : Word16 mean_past_SFM;
3519 : Word16 mean_past_SFM_e;
3520 : Word16 countable;
3521 : Word16 i;
3522 314325 : mean_past_SFM = 0;
3523 314325 : mean_past_SFM_e = 0;
3524 314325 : countable = 0;
3525 314325 : move16();
3526 314325 : move16();
3527 314325 : move16();
3528 :
3529 : /* compute mean of last (available) SFM values */
3530 1885950 : FOR( i = 0; i < IGF_PAST_SFM_LEN; i++ )
3531 : {
3532 1571625 : IF( hPrivateData->igfPastSFM_fx[p][i] >= 0 )
3533 : {
3534 1331289 : mean_past_SFM_e = BASOP_Util_Add_MantExp( mean_past_SFM, mean_past_SFM_e, hPrivateData->igfPastSFM_fx[p][i], 2, &mean_past_SFM );
3535 1331289 : countable = add( countable, 1 );
3536 : }
3537 : }
3538 314325 : IF( countable )
3539 : {
3540 : Word16 temp;
3541 307593 : mean_past_SFM = BASOP_Util_Divide1616_Scale( mean_past_SFM, countable, &temp );
3542 307593 : mean_past_SFM_e = add( mean_past_SFM_e, sub( temp, 15 ) );
3543 307593 : mean_past_SFM = shl( mean_past_SFM, sub( mean_past_SFM_e, 2 ) ); /*mean_past_SFM_e=2*/
3544 : /* deny change in whitening level for small deviations from mean SFM */
3545 307593 : if ( LT_16( abs_s( sub( SFM, mean_past_SFM ) ), 1638 ) /*0.2 in Q13*/ )
3546 : {
3547 147945 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfPrevWhiteningLevel[p];
3548 147945 : move16();
3549 : }
3550 : }
3551 : }
3552 : }
3553 :
3554 2311734 : hPrivateData->igfPastSFM_fx[p][hPrivateData->igfPastSFM_pos] = SFM; /*2Q13*/
3555 2311734 : move16();
3556 : }
3557 : }
3558 :
3559 653255 : SWITCH( hPrivateData->igfInfo.bitRateIndex )
3560 : {
3561 113245 : case IGF_BITRATE_WB_9600:
3562 : case IGF_BITRATE_RF_WB_13200:
3563 : case IGF_BITRATE_WB_13200_CPE:
3564 : case IGF_BITRATE_WB_16400_CPE:
3565 : case IGF_BITRATE_RF_SWB_13200:
3566 : case IGF_BITRATE_SWB_9600:
3567 : case IGF_BITRATE_SWB_13200_CPE:
3568 : case IGF_BITRATE_SWB_16400:
3569 : case IGF_BITRATE_SWB_24400:
3570 : case IGF_BITRATE_SWB_24400_CPE:
3571 : case IGF_BITRATE_SWB_32000_CPE:
3572 : case IGF_BITRATE_SWB_32000:
3573 : case IGF_BITRATE_FB_16400:
3574 : case IGF_BITRATE_FB_24400:
3575 : case IGF_BITRATE_FB_24400_CPE:
3576 : case IGF_BITRATE_FB_32000_CPE:
3577 : case IGF_BITRATE_FB_32000:
3578 113245 : hPrivateData->igfCurrWhiteningLevel[hGrid->nTiles - 1] = hPrivateData->igfCurrWhiteningLevel[hGrid->nTiles - 2];
3579 113245 : move16();
3580 113245 : break;
3581 540010 : default:
3582 540010 : break;
3583 : }
3584 : }
3585 : ELSE
3586 : {
3587 6897 : FOR( p = 0; p < hGrid->nTiles; p++ )
3588 : {
3589 5343 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
3590 5343 : move16();
3591 : }
3592 : }
3593 : }
3594 : ELSE
3595 : {
3596 : /* reset filter */
3597 449790 : FOR( p = 0; p < IGF_MAX_TILES; p++ )
3598 : {
3599 408900 : hPrivateData->prevSFM_FIR[p] = L_deposit_l( 0 );
3600 408900 : hPrivateData->prevSFM_IIR[p] = 0;
3601 408900 : move32();
3602 408900 : move16();
3603 : }
3604 : }
3605 :
3606 695699 : IF( element_mode > EVS_MONO )
3607 : {
3608 695699 : IF( EQ_16( SFM, -ONE_IN_Q13 /*1.0f 2Q13*/ ) ) /* reset */
3609 : {
3610 161856 : FOR( p = 0; p < hGrid->nTiles; p++ )
3611 : {
3612 119412 : set16_fx( hPrivateData->igfPastSFM_fx[p], -ONE_IN_Q13, IGF_PAST_SFM_LEN );
3613 119412 : hPrivateData->igfWhiteningHangoverCnt[p] = 2;
3614 119412 : move16();
3615 : }
3616 : }
3617 :
3618 : /* vibrato handling */
3619 2141385 : FOR( p = 0; p < hGrid->nTiles; p = p + 2 )
3620 : {
3621 1445686 : test();
3622 1445686 : test();
3623 1445686 : test();
3624 1445686 : IF( ( hPrivateData->igfPrevWhiteningLevel[p] == IGF_WHITENING_OFF && hPrivateData->igfCurrWhiteningLevel[p] != IGF_WHITENING_OFF ) ||
3625 : ( hPrivateData->igfPrevWhiteningLevel[p + 1] == IGF_WHITENING_OFF && hPrivateData->igfCurrWhiteningLevel[p + 1] != IGF_WHITENING_OFF ) )
3626 : {
3627 : Word16 i;
3628 : Word16 pastSfm_a[4], pastSfm_b[4];
3629 : Word16 pastSfmDiffSum_a, pastSfmDiffSum_b;
3630 :
3631 1101775 : FOR( i = 0; i < 4; i++ )
3632 : {
3633 881420 : pastSfm_a[i] = hPrivateData->igfPastSFM_fx[p][add( hPrivateData->igfPastSFM_pos, sub( 4, i ) ) % IGF_PAST_SFM_LEN];
3634 881420 : pastSfm_b[i] = hPrivateData->igfPastSFM_fx[p + 1][add( hPrivateData->igfPastSFM_pos, sub( 4, i ) ) % IGF_PAST_SFM_LEN];
3635 881420 : move16();
3636 881420 : move16();
3637 : }
3638 220355 : pastSfmDiffSum_a = pastSfmDiffSum_b = 0;
3639 220355 : move16();
3640 220355 : move16();
3641 607341 : FOR( i = 0; i < 3; i++ )
3642 : {
3643 503329 : IF( NE_16( pastSfm_a[i + 1], -ONE_IN_Q13 ) )
3644 : {
3645 386986 : pastSfmDiffSum_a = add( pastSfmDiffSum_a, sub( pastSfm_a[i], pastSfm_a[i + 1] ) );
3646 386986 : pastSfmDiffSum_b = add( pastSfmDiffSum_b, sub( pastSfm_b[i], pastSfm_b[i + 1] ) );
3647 : }
3648 : ELSE
3649 : {
3650 116343 : break;
3651 : }
3652 : }
3653 220355 : test();
3654 220355 : test();
3655 220355 : test();
3656 220355 : test();
3657 : /* if tonality oscillates between two tiles, turn whitening off in both */
3658 220355 : IF( ( ( pastSfmDiffSum_a > 0 && pastSfmDiffSum_b < 0 ) ||
3659 : ( pastSfmDiffSum_a < 0 && pastSfmDiffSum_b > 0 ) ) &&
3660 : ( GT_32( L_abs( L_sub( pastSfmDiffSum_a, pastSfmDiffSum_b ) ), ONE_IN_Q12 /* 0.5 in Q13 */ ) ) )
3661 : {
3662 10444 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfCurrWhiteningLevel[p + 1] = IGF_WHITENING_OFF;
3663 10444 : move16();
3664 10444 : move16();
3665 : }
3666 : }
3667 : }
3668 :
3669 : /* hangover */
3670 3126845 : FOR( p = 0; p < hGrid->nTiles; p++ )
3671 : {
3672 2431146 : IF( NE_16( hPrivateData->igfCurrWhiteningLevel[p], hPrivateData->igfPrevWhiteningLevel[p] ) )
3673 : {
3674 493015 : hPrivateData->igfWhiteningHangoverCnt[p] = add( hPrivateData->igfWhiteningHangoverCnt[p], 1 );
3675 493015 : IF( EQ_16( hPrivateData->igfWhiteningHangoverCnt[p], 3 ) )
3676 : {
3677 137300 : hPrivateData->igfWhiteningHangoverCnt[p] = 0;
3678 : }
3679 : ELSE
3680 : {
3681 355715 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfPrevWhiteningLevel[p];
3682 : }
3683 493015 : move16();
3684 493015 : move16();
3685 : }
3686 : ELSE
3687 : {
3688 1938131 : hPrivateData->igfWhiteningHangoverCnt[p] = 0;
3689 1938131 : move16();
3690 : }
3691 : }
3692 :
3693 695699 : hPrivateData->igfPastSFM_pos = add( hPrivateData->igfPastSFM_pos, 1 ) % IGF_PAST_SFM_LEN;
3694 695699 : move16();
3695 : }
3696 :
3697 695699 : hPrivateData->wasTransient = isTransient;
3698 695699 : move16();
3699 :
3700 695699 : return;
3701 : }
3702 :
3703 :
3704 : /*-------------------------------------------------------------------*
3705 : * IGF_WriteWhiteningTile_fx()
3706 : *
3707 : * write whitening levels into bitstream
3708 : *-------------------------------------------------------------------*/
3709 :
3710 : /*! r: number of bits written */
3711 2957002 : static Word16 IGF_WriteWhiteningTile_ivas_fx(
3712 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
3713 : Word16 *pBitOffset, /**< in: | ptr to bitOffset counter */
3714 : Word16 whiteningLevel /**< in: Q0 | whitening levels to write */
3715 : )
3716 : {
3717 : Word16 totBitCount;
3718 : Word16 startBitCount;
3719 :
3720 2957002 : totBitCount = 0;
3721 2957002 : startBitCount = *pBitOffset;
3722 2957002 : move16();
3723 2957002 : move16();
3724 :
3725 2957002 : IF( EQ_32( whiteningLevel, IGF_WHITENING_MID ) )
3726 : {
3727 1098482 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
3728 : }
3729 : ELSE
3730 : {
3731 1858520 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
3732 1858520 : IF( whiteningLevel == IGF_WHITENING_OFF )
3733 : {
3734 922308 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
3735 : }
3736 : ELSE
3737 : {
3738 936212 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
3739 : }
3740 : }
3741 2957002 : totBitCount = sub( *pBitOffset, startBitCount );
3742 :
3743 2957002 : return totBitCount;
3744 : }
3745 :
3746 :
3747 : /*-------------------------------------------------------------------*
3748 : * IGF_WriteWhiteningLevels_fx()
3749 : *
3750 : * writes the whitening levels
3751 : *-------------------------------------------------------------------*/
3752 :
3753 : /**< out: Q0 | total number of bits written */
3754 1364868 : static Word16 IGF_WriteWhiteningLevels_ivas_fx(
3755 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF encoder */
3756 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
3757 : Word16 *pBitOffset, /**< in: | ptr to bitOffset counter */
3758 : const Word16 igfGridIdx, /**< in: Q0 | igf grid index see declaration of IGF_GRID_IDX for details */
3759 : const Word16 isIndepFlag /**< in: Q0 | if 1 frame is independent, 0 = frame is coded with data from previous frame */
3760 : )
3761 : {
3762 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
3763 : H_IGF_GRID hGrid;
3764 : Word16 p;
3765 : Word16 nTiles;
3766 : Word16 isSame;
3767 : Word32 tmp32;
3768 : Word16 totBitCount;
3769 : Word16 startBitCount;
3770 :
3771 1364868 : totBitCount = 0;
3772 1364868 : move16();
3773 1364868 : isSame = 1;
3774 1364868 : move16();
3775 1364868 : startBitCount = *pBitOffset;
3776 1364868 : move16();
3777 1364868 : hPrivateData = &hInstance->igfData;
3778 1364868 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
3779 1364868 : nTiles = hGrid->nTiles;
3780 1364868 : move16();
3781 :
3782 1364868 : IF( isIndepFlag )
3783 : {
3784 1351603 : isSame = 0;
3785 1351603 : move16();
3786 : }
3787 : ELSE
3788 : {
3789 13265 : p = 0;
3790 13265 : move16();
3791 13265 : tmp32 = 0;
3792 13265 : move32();
3793 13265 : test();
3794 43687 : WHILE( ( LT_16( p, nTiles ) ) && ( tmp32 == 0 ) )
3795 : {
3796 30422 : test();
3797 30422 : tmp32 = L_sub( hPrivateData->igfCurrWhiteningLevel[p], hPrivateData->igfPrevWhiteningLevel[p] );
3798 30422 : if ( tmp32 != 0 )
3799 : {
3800 793 : isSame = 0;
3801 793 : move16();
3802 : }
3803 30422 : p++;
3804 : }
3805 : }
3806 1364868 : IF( isSame )
3807 : {
3808 12472 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
3809 : }
3810 : ELSE
3811 : {
3812 1352396 : IF( !isIndepFlag )
3813 : {
3814 793 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
3815 : }
3816 1352396 : IGF_WriteWhiteningTile_ivas_fx( hBstr, pBitOffset, hPrivateData->igfCurrWhiteningLevel[0] );
3817 1352396 : p = 1;
3818 1352396 : move16();
3819 1352396 : tmp32 = 0;
3820 1352396 : move32();
3821 1352396 : test();
3822 1352396 : IF( EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_48000_CPE ) || EQ_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_FB_48000_CPE ) )
3823 : {
3824 159474 : isSame = 1;
3825 159474 : move16();
3826 : }
3827 : ELSE
3828 : {
3829 1192922 : if ( LT_16( p, nTiles ) )
3830 : {
3831 647608 : isSame = 1;
3832 647608 : move16();
3833 : }
3834 1192922 : test();
3835 2886199 : WHILE( ( LT_16( p, nTiles ) ) && ( tmp32 == 0 ) )
3836 : {
3837 1693277 : test();
3838 1693277 : tmp32 = L_sub( hPrivateData->igfCurrWhiteningLevel[p], hPrivateData->igfCurrWhiteningLevel[p - 1] );
3839 1693277 : if ( tmp32 != 0 )
3840 : {
3841 353310 : isSame = 0;
3842 353310 : move16();
3843 : }
3844 1693277 : p++;
3845 : }
3846 : }
3847 1352396 : test();
3848 1352396 : IF( !isSame )
3849 : {
3850 898624 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
3851 2503230 : FOR( p = 1; p < nTiles; p++ )
3852 : {
3853 1604606 : IGF_WriteWhiteningTile_ivas_fx( hBstr, pBitOffset, hPrivateData->igfCurrWhiteningLevel[p] );
3854 : }
3855 : }
3856 453772 : ELSE IF( NE_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_SWB_48000_CPE ) && NE_16( hPrivateData->igfInfo.bitRateIndex, IGF_BITRATE_FB_48000_CPE ) )
3857 : {
3858 294298 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
3859 : }
3860 : }
3861 :
3862 1364868 : totBitCount = sub( *pBitOffset, startBitCount );
3863 :
3864 1364868 : return totBitCount;
3865 : }
3866 :
3867 :
3868 : /*-------------------------------------------------------------------*
3869 : * IGF_WriteFlatteningTrigger_fx()
3870 : *
3871 : * write flattening trigger
3872 : *-------------------------------------------------------------------*/
3873 :
3874 : /*! r: number of bits written */
3875 1364868 : static Word16 IGF_WriteFlatteningTrigger_ivas_fx(
3876 : const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
3877 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
3878 : Word16 *pBitOffset /**< in: | ptr to bitOffset counter */
3879 : )
3880 : {
3881 : Word16 flatteningTrigger;
3882 :
3883 : Word16 totBitCount;
3884 : Word16 startBitCount;
3885 1364868 : totBitCount = 0;
3886 1364868 : startBitCount = *pBitOffset;
3887 1364868 : flatteningTrigger = hInstance->flatteningTrigger;
3888 1364868 : move16();
3889 1364868 : move16();
3890 1364868 : move16();
3891 :
3892 1364868 : IGF_write_bits( hBstr, pBitOffset, flatteningTrigger, 1 );
3893 1364868 : totBitCount = sub( *pBitOffset, startBitCount );
3894 :
3895 1364868 : return totBitCount;
3896 : }
3897 :
3898 :
3899 : /*-------------------------------------------------------------------*
3900 : * IGFEncWriteBitstream()
3901 : *
3902 : * IGF bitstream writer
3903 : *-------------------------------------------------------------------*/
3904 :
3905 : /*! r: number of bits written per frame */
3906 1364868 : Word16 IGFEncWriteBitstream_ivas_fx(
3907 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
3908 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
3909 : Word16 *pBitOffset, /* i : ptr to bitOffset counter */
3910 : const Word16 igfGridIdx, /* i : igf grid index see declaration of IGF_GRID_IDX for details */
3911 : const Word16 isIndepFlag /* i : if 1 frame is independent, 0 = frame is coded with data from previous frame */
3912 : )
3913 : {
3914 : Word16 igfAllZero;
3915 : Word16 startBitCount;
3916 :
3917 1364868 : startBitCount = *pBitOffset;
3918 1364868 : move16();
3919 1364868 : hIGFEnc->infoTotalBitsPerFrameWritten = 0;
3920 1364868 : move16();
3921 :
3922 1364868 : if ( isIndepFlag )
3923 : {
3924 1351603 : hIGFEnc->infoTotalBitsWritten = 0;
3925 1351603 : move16();
3926 : }
3927 :
3928 1364868 : IGF_WriteEnvelope_ivas( hIGFEnc, /* i: instance handle of IGF Encoder */
3929 : hBstr, /* i: encoder state */
3930 : pBitOffset, /* i: ptr to bitOffset counter */
3931 : igfGridIdx, /* i: igf grid index see definition of IGF_GRID_IDX for details */
3932 : isIndepFlag, /* i: if 1 frame is independent, 0 = frame is coded with data from previous frame */
3933 : &igfAllZero ); /* o: *igfAllZero */
3934 :
3935 1364868 : IGF_WriteWhiteningLevels_ivas_fx( hIGFEnc, /* i: instance handle of IGF Encoder */
3936 : hBstr, /* i: encoder state */
3937 : pBitOffset, /* i: ptr to bitOffset counter */
3938 : igfGridIdx, /* i: igf grid index see definition of IGF_GRID_IDX for details */
3939 : isIndepFlag ); /* i: if 1 frame is independent, 0 = frame is coded with data from previous frame */
3940 :
3941 1364868 : IGF_WriteFlatteningTrigger_ivas_fx( hIGFEnc, /* i: instance handle of IGF Encoder */
3942 : hBstr, /* i: encoder state */
3943 : pBitOffset ); /* i: ptr to bitOffset counter */
3944 :
3945 1364868 : hIGFEnc->infoTotalBitsPerFrameWritten = sub( *pBitOffset, startBitCount );
3946 1364868 : hIGFEnc->infoTotalBitsWritten = add( hIGFEnc->infoTotalBitsWritten, hIGFEnc->infoTotalBitsPerFrameWritten );
3947 1364868 : move16();
3948 1364868 : move16();
3949 :
3950 1364868 : return hIGFEnc->infoTotalBitsPerFrameWritten;
3951 : }
3952 :
3953 :
3954 : /*-------------------------------------------------------------------*
3955 : * IGFEncSetMode()
3956 : *
3957 : * sets the IGF mode according to given bitrate
3958 : *-------------------------------------------------------------------*/
3959 :
3960 47534 : void IGFEncSetMode_ivas_fx(
3961 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i/o: instance handle of IGF Encoder */
3962 : const Word32 total_brate, /* i : encoder total bitrate */
3963 : const Word16 bwidth, /* i : encoder audio bandwidth */
3964 : const Word16 element_mode, /* i : IVAS element mode */
3965 : const Word16 rf_mode /* i : flag to signal the RF mode */
3966 : )
3967 : {
3968 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
3969 : Word16 i;
3970 :
3971 47534 : hPrivateData = &hIGFEnc->igfData;
3972 47534 : hPrivateData->igfBitstreamBits = 0;
3973 47534 : move16();
3974 47534 : set16_fx( hPrivateData->igfScfQuantized, 0, IGF_MAX_SFB );
3975 47534 : set16_fx( hPrivateData->igfCurrWhiteningLevel, 0, IGF_MAX_TILES );
3976 47534 : set16_fx( hPrivateData->igfPrevWhiteningLevel, 0, IGF_MAX_TILES );
3977 47534 : set16_fx( hPrivateData->igfWhiteningHangoverCnt, 0, IGF_MAX_TILES );
3978 522874 : FOR( i = 0; i < IGF_MAX_TILES; i++ )
3979 : {
3980 475340 : set16_fx( hPrivateData->igfPastSFM_fx[i], -( ONE_IN_Q13 ), IGF_PAST_SFM_LEN );
3981 : }
3982 :
3983 47534 : hPrivateData->igfPastSFM_pos = 0;
3984 47534 : move16();
3985 :
3986 15258414 : FOR( i = 0; i < IGF_BITBUFSIZE / 8; i++ )
3987 : {
3988 15210880 : hPrivateData->igfBitstream[i] = 0;
3989 15210880 : move16();
3990 : }
3991 47534 : hPrivateData->wasTransient = 0;
3992 47534 : move16();
3993 47534 : set32_fx( hPrivateData->prevSFM_FIR, 0, IGF_MAX_TILES );
3994 47534 : set16_fx( hPrivateData->prevSFM_IIR, 0, IGF_MAX_TILES );
3995 47534 : set16_fx( hPrivateData->dampingFactorSmoothing, 2, IGF_MAX_SFB );
3996 47534 : set16_fx( hPrivateData->prevSFM_FIR_SFB_SB_fx, 0, IGF_MAX_SFB );
3997 47534 : set16_fx( hPrivateData->prevSFB_FIR_TB_e, 15, IGF_MAX_SFB );
3998 47534 : set16_fx( hPrivateData->prevSFB_FIR_SB_e, 15, IGF_MAX_SFB );
3999 47534 : set16_fx( hPrivateData->prevSFM_IIR_SFB_SB_fx, 0, IGF_MAX_SFB );
4000 47534 : set16_fx( hPrivateData->prevSFB_IIR_SB_e, 15, IGF_MAX_SFB );
4001 47534 : set16_fx( hPrivateData->prevSFM_FIR_SFB_TB_fx, 0, IGF_MAX_SFB );
4002 47534 : set16_fx( hPrivateData->prevSFB_IIR_TB_e, 15, IGF_MAX_SFB );
4003 47534 : set16_fx( hPrivateData->sfb_tb_e, 15, IGF_MAX_SFB );
4004 47534 : set16_fx( hPrivateData->sfb_sb_e, 15, IGF_MAX_SFB );
4005 47534 : set16_fx( hPrivateData->prevSFM_IIR_SFB_TB_fx, 0, IGF_MAX_SFB );
4006 47534 : set16_fx( hPrivateData->prevDampingFactor_IIR_fx, -( ONE_IN_Q15 ), IGF_MAX_SFB );
4007 47534 : set16_fx( hPrivateData->prevDampingFactor_IIR_e, 0, IGF_MAX_SFB );
4008 47534 : set16_fx( hPrivateData->logSpec, 0, L_FRAME_PLUS );
4009 47534 : set16_fx( hPrivateData->SFM_sb_fx, 0, IGF_MAX_SFB );
4010 47534 : set16_fx( hPrivateData->SFM_tb_fx, 0, IGF_MAX_SFB );
4011 :
4012 47534 : IF( IGFCommonFuncsIGFConfiguration_ivas_fx( total_brate, bwidth, element_mode, &hPrivateData->igfInfo, rf_mode ) != 0 )
4013 : {
4014 47534 : IGFSCFEncoderOpen_fx( &hPrivateData->hIGFSCFArithEnc, &hPrivateData->igfInfo, total_brate, bwidth, element_mode, rf_mode );
4015 :
4016 47534 : hIGFEnc->infoSamplingRate = hPrivateData->igfInfo.sampleRate;
4017 47534 : move32();
4018 47534 : hIGFEnc->infoStartFrequency = hPrivateData->igfInfo.grid[0].startFrequency;
4019 47534 : move16();
4020 47534 : hIGFEnc->infoStopFrequency = hPrivateData->igfInfo.grid[0].stopFrequency;
4021 47534 : move16();
4022 47534 : hIGFEnc->infoStartLine = hPrivateData->igfInfo.grid[0].startLine;
4023 47534 : move16();
4024 47534 : hIGFEnc->infoStopLine = hPrivateData->igfInfo.grid[0].stopLine;
4025 47534 : move16();
4026 : }
4027 : ELSE
4028 : {
4029 : /* IGF configuration failed -> error! */
4030 0 : hIGFEnc->infoSamplingRate = 0;
4031 0 : move32();
4032 0 : hIGFEnc->infoStartFrequency = -1;
4033 0 : move16();
4034 0 : hIGFEnc->infoStopFrequency = -1;
4035 0 : move16();
4036 0 : hIGFEnc->infoStartLine = -1;
4037 0 : move16();
4038 0 : hIGFEnc->infoStopLine = -1;
4039 0 : move16();
4040 0 : fprintf( stderr, "IGFEncSetMode_fx: initialization error!\n" );
4041 : }
4042 :
4043 : /* reset remaining variables */
4044 47534 : hIGFEnc->infoTotalBitsWritten = 0;
4045 47534 : move16();
4046 47534 : hIGFEnc->infoTotalBitsPerFrameWritten = 0;
4047 47534 : move16();
4048 47534 : hIGFEnc->flatteningTrigger = 0;
4049 47534 : move16();
4050 47534 : hIGFEnc->spec_be_igf_e = 0;
4051 47534 : move16();
4052 47534 : hIGFEnc->tns_predictionGain = 0;
4053 47534 : move16();
4054 47534 : set32_fx( hIGFEnc->spec_be_igf, 0, N_MAX_TCX - IGF_START_MN );
4055 :
4056 47534 : return;
4057 : }
4058 :
4059 :
4060 : /*-------------------------------------------------------------------*
4061 : * IGFEncResetTCX10BitCounter_fx()
4062 : *
4063 : * IGF reset bitstream bit counter for TCX10 modes
4064 : *-------------------------------------------------------------------*/
4065 :
4066 13265 : void IGFEncResetTCX10BitCounter_fx(
4067 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc /* i : instance handle of IGF Encoder */
4068 : )
4069 : {
4070 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
4071 :
4072 13265 : hPrivateData = &hIGFEnc->igfData;
4073 13265 : hPrivateData->igfBitstreamBits = 0;
4074 13265 : hIGFEnc->infoTotalBitsWritten = 0;
4075 13265 : move16();
4076 13265 : move16();
4077 :
4078 13265 : return;
4079 : }
4080 :
4081 :
4082 : /*-------------------------------------------------------------------*
4083 : * IGFEncApplyMono()
4084 : *
4085 : * apply the IGF encoder, main encoder interface
4086 : *-------------------------------------------------------------------*/
4087 :
4088 569951 : void IGFEncApplyMono_ivas_fx(
4089 : Encoder_State *st, /* i : Encoder state */
4090 : Word16 powerSpectrum_len, /* i: length of pPowerSpectrum_fx buffer */
4091 : const Word16 igfGridIdx, /* i : IGF grid index */
4092 : Word32 *pMDCTSpectrum_fx, /* i/o: MDCT spectrum */
4093 : Word16 e_mdct, /* i : exponent of pMDCTspectrum */
4094 : Word32 *pPowerSpectrum_fx, /* i/o: MDCT^2 + MDST^2 spectrum, or estimate */
4095 : Word16 *e_ps, /* i : exponent of pPowerSpectrum */
4096 : const Word16 isTCX20, /* i : flag indicating if the input is TCX20 or TCX10/2xTCX5 */
4097 : const Word8 isTNSActive, /* i : flag indicating if the TNS is active */
4098 : const Word16 sp_aud_decision0, /* i : first stage switching decision */
4099 : const Word16 vad_hover_flag /* i : VAD hangover flag */
4100 : )
4101 : {
4102 : Word32 *pPowerSpectrumParameter_fx;
4103 : Word16 *pPowerSpectrumParameter_exp;
4104 569951 : Word16 att_fx = MAX16B;
4105 : Word16 last_core_acelp;
4106 569951 : move16();
4107 :
4108 : Word32 common_pPowerSpectrum_fx[N_MAX + L_MDCT_OVLP_MAX];
4109 :
4110 569951 : set32_fx( common_pPowerSpectrum_fx, 0, N_MAX );
4111 :
4112 569951 : Word16 common_pPowerSpectrum_exp = MIN16B;
4113 569951 : move16();
4114 569951 : IF( st->last_core == ACELP_CORE )
4115 : {
4116 11242 : last_core_acelp = 1;
4117 11242 : move16();
4118 : }
4119 : ELSE
4120 : {
4121 558709 : last_core_acelp = 0;
4122 558709 : move16();
4123 : }
4124 :
4125 569951 : test();
4126 569951 : IF( !isTNSActive && isTCX20 )
4127 : {
4128 498942 : pPowerSpectrumParameter_fx = pPowerSpectrum_fx;
4129 498942 : pPowerSpectrumParameter_exp = e_ps;
4130 : }
4131 : ELSE
4132 : {
4133 71009 : pPowerSpectrumParameter_fx = NULL;
4134 71009 : pPowerSpectrumParameter_exp = NULL;
4135 : }
4136 :
4137 569951 : IGF_UpdateInfo( st->hIGFEnc, igfGridIdx );
4138 :
4139 569951 : test();
4140 569951 : IF( EQ_16( st->element_mode, IVAS_CPE_DFT ) || EQ_16( st->element_mode, IVAS_CPE_TD ) )
4141 : {
4142 24613 : calculate_hangover_attenuation_gain_ivas_fx( st, &att_fx, vad_hover_flag );
4143 : }
4144 :
4145 569951 : IGF_CalculateEnvelope_ivas_fx( st->hIGFEnc, pMDCTSpectrum_fx, e_mdct, pPowerSpectrumParameter_fx, pPowerSpectrumParameter_exp, igfGridIdx, st->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp, st->element_mode, att_fx );
4146 :
4147 569951 : IF( isTCX20 )
4148 : {
4149 548645 : pPowerSpectrumParameter_fx = pPowerSpectrum_fx;
4150 548645 : pPowerSpectrumParameter_exp = e_ps;
4151 : }
4152 : ELSE
4153 : {
4154 21306 : pPowerSpectrumParameter_fx = NULL;
4155 21306 : pPowerSpectrumParameter_exp = NULL;
4156 : }
4157 :
4158 569951 : IF( EQ_16( st->element_mode, IVAS_CPE_MDCT ) )
4159 : {
4160 298840 : IGF_Whitening_ivas_fx( st->hIGFEnc, pPowerSpectrumParameter_fx, pPowerSpectrumParameter_exp, igfGridIdx, st->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp, isTNSActive, sp_aud_decision0, st->element_brate, st->element_mode );
4161 : }
4162 : ELSE
4163 : {
4164 271111 : IGF_Whitening_ivas_fx( st->hIGFEnc, pPowerSpectrumParameter_fx, pPowerSpectrumParameter_exp, igfGridIdx, st->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp, isTNSActive, sp_aud_decision0, st->total_brate, st->element_mode );
4165 : }
4166 :
4167 569951 : IF( pPowerSpectrumParameter_fx )
4168 : {
4169 728425745 : FOR( Word16 i = 0; i < powerSpectrum_len; i++ )
4170 : {
4171 727877100 : common_pPowerSpectrum_exp = s_max( common_pPowerSpectrum_exp, pPowerSpectrumParameter_exp[i] );
4172 : }
4173 :
4174 728425745 : FOR( Word16 i = 0; i < powerSpectrum_len; i++ )
4175 : {
4176 727877100 : common_pPowerSpectrum_fx[i] = L_shl( pPowerSpectrumParameter_fx[i], sub( pPowerSpectrumParameter_exp[i], common_pPowerSpectrum_exp ) );
4177 727877100 : move16();
4178 : }
4179 548645 : pPowerSpectrumParameter_fx = common_pPowerSpectrum_fx;
4180 : }
4181 :
4182 569951 : IGF_ErodeSpectrum_ivas_fx( st->hIGFEnc, pMDCTSpectrum_fx, pPowerSpectrumParameter_fx, common_pPowerSpectrum_exp, igfGridIdx, 0 );
4183 :
4184 569951 : return;
4185 : }
4186 :
4187 :
4188 : /*-------------------------------------------------------------------*
4189 : * IGFEncApplyStereo()
4190 : *
4191 : * apply the IGF encoder, main encoder interface
4192 : *-------------------------------------------------------------------*/
4193 :
4194 62874 : void IGFEncApplyStereo_fx(
4195 : STEREO_MDCT_ENC_DATA_HANDLE hStereoMdct, /* i/o: MDCT stereo encoder structure */
4196 : Word16 ms_mask[2][MAX_SFB], /* i : bandwise MS mask */
4197 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc[CPE_CHANNELS], /* i : instance handle of IGF Encoder */
4198 : const Word16 igfGridIdx, /* i : IGF grid index */
4199 : Encoder_State *sts[CPE_CHANNELS], /* i : Encoder state */
4200 : Word32 *pPowerSpectrum_fx[CPE_CHANNELS], /* i/o: MDCT^2 + MDST^2 spectrum, or estimate */
4201 : Word16 *exp_pPowerSpectrum_fx[CPE_CHANNELS], /* i/o: exp of pPowerSpectrum_fx */
4202 : Word32 *pPowerSpectrumMsInv_fx[CPE_CHANNELS][NB_DIV], /* i/o: inverse power spectrum */
4203 : Word16 *q_pPowerSpectrumMsInv_fx[CPE_CHANNELS][NB_DIV], /* i/o: Q of pPowerSpectrumMsInv_fx */
4204 : Word32 *inv_spectrum_fx[CPE_CHANNELS][NB_DIV], /* i : inverse spectrum */
4205 : Word16 exp_inv_spectrum_fx[CPE_CHANNELS], /* i : exp of inverse spectrum */
4206 : const Word16 frameno, /* i : flag indicating index of current subfr. */
4207 : const Word16 sp_aud_decision0, /* i : sp_aud_decision0 */
4208 : const Word32 element_brate, /* i : element bitrate */
4209 : const Word16 mct_on )
4210 : {
4211 : Word32 *pPowerSpectrumParameter_fx[NB_DIV]; /* If it is NULL it informs a function that specific handling is needed */
4212 : Word16 *exp_pPowerSpectrumParameter_fx[NB_DIV]; /* If it is NULL it informs a function that specific handling is needed */
4213 : Word32 *pPowerSpectrumParameterMsInv_fx[NB_DIV];
4214 : Word16 *q_pPowerSpectrumParameterMsInv_fx[NB_DIV];
4215 : Word16 coreMsMask[N_MAX];
4216 : Word16 sfb, ch, last_core_acelp;
4217 : STEREO_MDCT_BAND_PARAMETERS *sfbConf;
4218 : Word32 common_pPowerSpectrum_fx[N_MAX];
4219 :
4220 62874 : set32_fx( common_pPowerSpectrum_fx, 0, N_MAX );
4221 :
4222 62874 : Word16 common_pPowerSpectrum_exp = MIN16B;
4223 62874 : move16();
4224 :
4225 : /* assumptions: stereo filling was already done on the flattened spectra
4226 : * IGF region is always coded M/S, never L/R (to be done in the encoder)
4227 : * for residual bands with stereo filling infoTcxNoise is set to zero
4228 : * both channels have the same IGF configuration
4229 : */
4230 :
4231 : /* sanity checks: check if both channels have the same configuration...*/
4232 62874 : assert( ( sts[0]->core == sts[1]->core ) );
4233 :
4234 : /* initialization */
4235 62874 : IF( EQ_16( sts[0]->core, TCX_20_CORE ) )
4236 : {
4237 60262 : sfbConf = &hStereoMdct->stbParamsTCX20;
4238 : }
4239 : ELSE
4240 : {
4241 2612 : sfbConf = &hStereoMdct->stbParamsTCX10;
4242 : }
4243 62874 : if ( sts[0]->last_core == ACELP_CORE )
4244 : {
4245 0 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
4246 : }
4247 :
4248 : /* create line wise ms mask for the core bands */
4249 62874 : set16_fx( coreMsMask, 0, N_MAX );
4250 2686561 : FOR( sfb = 0; sfb < sfbConf->sfbCnt; sfb++ )
4251 : {
4252 2623687 : set16_fx( &coreMsMask[sfbConf->sfbOffset[sfb]], ms_mask[frameno][sfb], sub( sfbConf->sfbOffset[sfb + 1], sfbConf->sfbOffset[sfb] ) );
4253 : }
4254 :
4255 62874 : test();
4256 62874 : test();
4257 62874 : IF( EQ_16( sts[0]->core, TCX_20_CORE ) && !sts[0]->hTcxEnc->fUseTns[frameno] && !sts[1]->hTcxEnc->fUseTns[frameno] )
4258 : {
4259 52135 : pPowerSpectrumParameter_fx[0] = &pPowerSpectrum_fx[0][0];
4260 52135 : exp_pPowerSpectrumParameter_fx[0] = &exp_pPowerSpectrum_fx[0][0];
4261 52135 : pPowerSpectrumParameter_fx[1] = &pPowerSpectrum_fx[1][0];
4262 52135 : exp_pPowerSpectrumParameter_fx[1] = &exp_pPowerSpectrum_fx[1][0];
4263 52135 : pPowerSpectrumParameterMsInv_fx[0] = pPowerSpectrumMsInv_fx[0][0];
4264 52135 : pPowerSpectrumParameterMsInv_fx[1] = pPowerSpectrumMsInv_fx[1][0];
4265 52135 : q_pPowerSpectrumParameterMsInv_fx[0] = q_pPowerSpectrumMsInv_fx[0][0];
4266 52135 : q_pPowerSpectrumParameterMsInv_fx[1] = q_pPowerSpectrumMsInv_fx[1][0];
4267 : }
4268 : ELSE
4269 : {
4270 10739 : pPowerSpectrumParameter_fx[0] = NULL;
4271 10739 : pPowerSpectrumParameter_fx[1] = NULL;
4272 10739 : pPowerSpectrumParameterMsInv_fx[0] = NULL;
4273 10739 : pPowerSpectrumParameterMsInv_fx[1] = NULL;
4274 10739 : q_pPowerSpectrumParameterMsInv_fx[0] = NULL;
4275 10739 : q_pPowerSpectrumParameterMsInv_fx[1] = NULL;
4276 : }
4277 188622 : FOR( ch = 0; ch < CPE_CHANNELS; ch++ )
4278 : {
4279 125748 : last_core_acelp = extract_l( EQ_16( sts[ch]->last_core, ACELP_CORE ) );
4280 :
4281 125748 : IGF_UpdateInfo( hIGFEnc[ch], igfGridIdx );
4282 125748 : IGF_CalculateStereoEnvelope_fx( hIGFEnc[ch], sts[ch]->hTcxEnc->spectrum_fx[frameno], sts[ch]->hTcxEnc->spectrum_e[frameno], inv_spectrum_fx[ch][frameno],
4283 125748 : exp_inv_spectrum_fx[ch], pPowerSpectrumParameter_fx[ch], exp_pPowerSpectrum_fx[ch], pPowerSpectrumParameterMsInv_fx[ch],
4284 125748 : q_pPowerSpectrumParameterMsInv_fx[ch], igfGridIdx, coreMsMask, sts[ch]->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp, mct_on );
4285 :
4286 125748 : IF( EQ_16( sts[ch]->core, TCX_20_CORE ) )
4287 : {
4288 120524 : pPowerSpectrumParameter_fx[ch] = pPowerSpectrum_fx[ch];
4289 120524 : exp_pPowerSpectrumParameter_fx[ch] = exp_pPowerSpectrum_fx[ch];
4290 : }
4291 : ELSE
4292 : {
4293 5224 : pPowerSpectrumParameter_fx[ch] = NULL;
4294 : }
4295 :
4296 125748 : IGF_Whitening_ivas_fx( hIGFEnc[ch], pPowerSpectrumParameter_fx[ch], exp_pPowerSpectrumParameter_fx[ch], igfGridIdx, sts[ch]->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp, ( sts[0]->hTcxEnc->fUseTns[frameno] || sts[1]->hTcxEnc->fUseTns[frameno] ), sp_aud_decision0, element_brate, sts[ch]->element_mode );
4297 :
4298 125748 : IF( pPowerSpectrumParameter_fx[ch] )
4299 : {
4300 120524 : Word16 length = N_MAX;
4301 120524 : move16();
4302 120524 : if ( mct_on )
4303 : {
4304 64436 : length = L_FRAME48k;
4305 64436 : move16();
4306 : }
4307 129284684 : FOR( Word16 i = 0; i < length; i++ )
4308 : {
4309 129164160 : common_pPowerSpectrum_exp = s_max( common_pPowerSpectrum_exp, exp_pPowerSpectrumParameter_fx[ch][i] );
4310 : }
4311 :
4312 129284684 : FOR( Word16 i = 0; i < length; i++ )
4313 : {
4314 129164160 : common_pPowerSpectrum_fx[i] = L_shl( pPowerSpectrumParameter_fx[ch][i], sub( exp_pPowerSpectrumParameter_fx[ch][i], common_pPowerSpectrum_exp ) );
4315 129164160 : move32();
4316 : }
4317 120524 : pPowerSpectrumParameter_fx[ch] = common_pPowerSpectrum_fx;
4318 : }
4319 125748 : IGF_ErodeSpectrum_ivas_fx( hIGFEnc[ch], sts[ch]->hTcxEnc->spectrum_fx[frameno], pPowerSpectrumParameter_fx[ch], common_pPowerSpectrum_exp, igfGridIdx, mct_on );
4320 : }
4321 :
4322 62874 : return;
4323 : }
4324 :
4325 :
4326 : /*-------------------------------------------------------------------*
4327 : * IGFSaveSpectrumForITF()
4328 : *
4329 : *
4330 : *-------------------------------------------------------------------*/
4331 :
4332 695699 : void IGFSaveSpectrumForITF_ivas_fx(
4333 : IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i/o: instance handle of IGF Encoder */
4334 : const Word16 igfGridIdx, /* i : IGF grid index */
4335 : const Word32 *pITFSpectrum, /* i : MDCT spectrum */
4336 : Word16 exp_pITFSpectrum )
4337 : {
4338 695699 : IGF_UpdateInfo( hIGFEnc, igfGridIdx );
4339 :
4340 695699 : Copy32( pITFSpectrum + IGF_START_MN, hIGFEnc->spec_be_igf, sub( hIGFEnc->infoStopLine, IGF_START_MN ) );
4341 :
4342 695699 : scale_sig32( hIGFEnc->spec_be_igf, sub( hIGFEnc->infoStopLine, IGF_START_MN ), sub( exp_pITFSpectrum, s_max( exp_pITFSpectrum, hIGFEnc->spec_be_igf_e ) ) );
4343 695699 : scale_sig32( hIGFEnc->spec_be_igf + sub( hIGFEnc->infoStopLine, IGF_START_MN ), sub( N_MAX_TCX - IGF_START_MN, sub( hIGFEnc->infoStopLine, IGF_START_MN ) ), sub( hIGFEnc->spec_be_igf_e, s_max( exp_pITFSpectrum, hIGFEnc->spec_be_igf_e ) ) );
4344 695699 : hIGFEnc->spec_be_igf_e = s_max( exp_pITFSpectrum, hIGFEnc->spec_be_igf_e );
4345 695699 : move16();
4346 :
4347 695699 : return;
4348 : }
4349 :
4350 :
4351 : /*-------------------------------------------------------------------*
4352 : * IGF_Reconfig()
4353 : *
4354 : *
4355 : *-------------------------------------------------------------------*/
4356 :
4357 3472 : ivas_error IGF_Reconfig(
4358 : IGF_ENC_INSTANCE_HANDLE *hIGFEnc, /* i/o: instance handle of IGF Encoder */
4359 : const Word16 igf, /* i : IGF on/off */
4360 : const Word16 reset, /* i : reset flag */
4361 : const Word32 brate, /* i : bitrate for configuration */
4362 : const Word16 bwidth, /* i : signal bandwidth */
4363 : const Word16 element_mode, /* i : IVAS element mode */
4364 : const Word16 rf_mode /* i : flag to signal the RF mode */
4365 : )
4366 : {
4367 : ivas_error error;
4368 :
4369 3472 : error = IVAS_ERR_OK;
4370 3472 : move32();
4371 :
4372 3472 : test();
4373 3472 : test();
4374 3472 : test();
4375 3472 : IF( igf && *hIGFEnc == NULL )
4376 : {
4377 451 : IF( ( *hIGFEnc = (IGF_ENC_INSTANCE_HANDLE) malloc( sizeof( IGF_ENC_INSTANCE ) ) ) == NULL )
4378 : {
4379 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hIGFEnc\n" ) );
4380 : }
4381 451 : IGFEncSetMode_ivas_fx( *hIGFEnc, brate, bwidth, element_mode, rf_mode );
4382 : }
4383 3021 : ELSE IF( igf && reset )
4384 : {
4385 1983 : IGFEncSetMode_ivas_fx( *hIGFEnc, brate, bwidth, element_mode, rf_mode );
4386 : }
4387 1038 : ELSE IF( !igf && *hIGFEnc != NULL )
4388 : {
4389 655 : free( *hIGFEnc );
4390 655 : *hIGFEnc = NULL;
4391 : }
4392 :
4393 3472 : return error;
4394 : }
|
