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