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