Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : /*====================================================================================
34 : EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
35 : ====================================================================================*/
36 :
37 : #include <assert.h>
38 : #include <stdint.h>
39 : #include "options.h"
40 : #ifdef DEBUGGING
41 : #include "debug.h"
42 : #endif
43 : #include <math.h>
44 : #include "prot.h"
45 : #include "ivas_prot.h"
46 : #include "cnst.h"
47 : #include "stat_enc.h"
48 : #include "wmc_auto.h"
49 : #ifdef DEBUG_PLOT
50 : #include "deb_out.h"
51 : #endif
52 :
53 :
54 : /*-------------------------------------------------------------------*
55 : * IGF_write_bit()
56 : *
57 : * write single bit to stream
58 : *-------------------------------------------------------------------*/
59 :
60 106580562 : static void IGF_write_bit(
61 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
62 : int16_t *bitCount, /* i/o: bit counter */
63 : const int16_t value /* i : value */
64 : )
65 : {
66 106580562 : if ( hBstr )
67 : {
68 53941497 : push_next_indice( hBstr, value, 1 );
69 : }
70 :
71 106580562 : ( *bitCount )++;
72 :
73 106580562 : return;
74 : }
75 :
76 :
77 : /*-------------------------------------------------------------------*
78 : * IGF_write_bits()
79 : *
80 : * write bits to stream
81 : *-------------------------------------------------------------------*/
82 :
83 89463202 : static void IGF_write_bits(
84 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
85 : int16_t *bitCount, /* i/o: bit counter */
86 : const int16_t value, /* i/o: value */
87 : int16_t bits /* i : number of bits */
88 : )
89 : {
90 178926404 : while ( bits-- )
91 : {
92 89463202 : IGF_write_bit( hBstr, bitCount, ( ( value & ( 1 << bits ) ) == 0 ) ? 0 : 1 );
93 : }
94 :
95 89463202 : return;
96 : }
97 :
98 :
99 : /*-------------------------------------------------------------------*
100 : * IGF_getCrest_new()
101 : *
102 : * crest factor calculation
103 : *-------------------------------------------------------------------*/
104 :
105 : /*! r: crest factor */
106 83381367 : static float IGF_getCrest_new(
107 : const int16_t *logSpec, /* i : power spectrum */
108 : const int16_t start, /* i : start subband index */
109 : const int16_t stop /* i : stop subband index */
110 : )
111 : {
112 : int16_t i;
113 : int16_t x;
114 83381367 : int32_t x_eff = 0;
115 83381367 : int16_t x_max = 0;
116 83381367 : float crest = 1.f;
117 :
118 5522894033 : for ( i = start; i < stop; i++ )
119 : {
120 5439512666 : x = logSpec[i];
121 5439512666 : x_eff += x * x;
122 :
123 5439512666 : if ( x > x_max )
124 : {
125 246810963 : x_max = x;
126 : }
127 : }
128 :
129 83381367 : x_eff /= ( stop - start );
130 :
131 83381367 : if ( x_eff > 0 && x_max > 0 )
132 : {
133 70160204 : crest = max( 1.f, (float) x_max / sqrtf( (float) x_eff ) );
134 : }
135 :
136 83381367 : return crest;
137 : }
138 :
139 :
140 : /*-------------------------------------------------------------------*
141 : * IGF_getSFM_new()
142 : *
143 : * calculates spectral flatness measurement
144 : *-------------------------------------------------------------------*/
145 :
146 : /*! r: SFM value */
147 83381367 : static float IGF_getSFM_new(
148 : const float *powerSpectrum, /* i : power spectrum */
149 : const int16_t *logSpec, /* i : log of power spectrum */
150 : const int16_t start, /* i : start subband index */
151 : const int16_t stop /* i : stop subband index */
152 : )
153 : {
154 : int16_t n;
155 : int16_t i;
156 : int16_t num;
157 : float denom;
158 : float numf;
159 : float tmp;
160 : float sfm;
161 :
162 83381367 : num = 0;
163 83381367 : denom = 1.f;
164 83381367 : sfm = 1.f;
165 :
166 5522894033 : for ( i = start; i < stop; i++ )
167 : {
168 5439512666 : tmp = powerSpectrum[i];
169 5439512666 : n = logSpec[i /*-start*/];
170 5439512666 : num += n;
171 5439512666 : denom += tmp;
172 : }
173 :
174 83381367 : numf = (float) num / (float) ( stop - start );
175 83381367 : denom /= (float) ( stop - start );
176 :
177 83381367 : if ( denom != 0 )
178 : {
179 83381367 : sfm = min( ( powf( 2.0f, numf + 0.5f ) / denom ), 1.0f );
180 : }
181 :
182 83381367 : return sfm;
183 : }
184 :
185 :
186 : /*-------------------------------------------------------------------*
187 : * IGF_getTilt()
188 : *
189 : * calculates spectral tilt
190 : *-------------------------------------------------------------------*/
191 :
192 : /*! r: spectral tilt value */
193 156095 : static float IGF_getTilt(
194 : const float *powerSpectrum, /* i : energies */
195 : const int16_t start, /* i : start subband index */
196 : const int16_t stop /* i : stop subband index */
197 : )
198 : {
199 : int16_t i;
200 : int16_t x;
201 : int16_t width;
202 : float y;
203 : float mean_x, mean_y, mean_xy, mean_x2;
204 : float slope;
205 :
206 156095 : x = 1;
207 156095 : mean_x = mean_y = mean_xy = mean_x2 = 0.f;
208 :
209 156095 : width = stop - start;
210 9108337 : for ( i = start; i < stop; i++ )
211 : {
212 8952242 : mean_x += x;
213 8952242 : mean_x2 += x * x;
214 8952242 : y = 20.f * log10f( max( 1.f, powerSpectrum[i] ) );
215 8952242 : mean_y += y;
216 8952242 : mean_xy += y * x;
217 :
218 8952242 : x++;
219 : }
220 156095 : mean_y /= width;
221 156095 : mean_x /= width;
222 156095 : mean_xy /= width;
223 156095 : mean_x2 /= width;
224 156095 : slope = ( mean_xy - mean_x * mean_y ) / ( mean_x2 - mean_x * mean_x );
225 :
226 156095 : return slope;
227 : }
228 :
229 :
230 : /*-------------------------------------------------------------------*
231 : * IGF_getTNR()
232 : *
233 : * calculates tonal-to-noise ratio
234 : *-------------------------------------------------------------------*/
235 :
236 : /*! r: spectral tilt value */
237 175748 : static float IGF_getTNR(
238 : const float *powerSpectrum, /* i : energies */
239 : const int16_t start, /* i : start subband index */
240 : const int16_t stop, /* i : stop subband index */
241 : const float adap /* i : SFB width adaptation */
242 : )
243 : {
244 : int16_t i;
245 : int16_t width;
246 175748 : float avg = 0.f;
247 175748 : float tonal = 0.f;
248 175748 : float noise = EPSILON;
249 : float tonalToNoise;
250 : float rootSpec[300];
251 :
252 175748 : set_f( rootSpec, 0, 300 );
253 :
254 175748 : width = stop - start;
255 10143766 : for ( i = start; i < stop; i++ )
256 : {
257 9968018 : rootSpec[i - start] = sqrtf( powerSpectrum[i] );
258 9968018 : avg += rootSpec[i - start];
259 : }
260 175748 : avg /= width;
261 :
262 10143766 : for ( i = start; i < stop; i++ )
263 : {
264 9968018 : float normSpec = rootSpec[i - start] / avg;
265 9968018 : if ( normSpec > 1 + adap )
266 : {
267 852155 : tonal += rootSpec[i - start];
268 : }
269 9115863 : else if ( normSpec < 1 )
270 : {
271 7964544 : noise += rootSpec[i - start];
272 : }
273 : }
274 :
275 175748 : tonalToNoise = 20.f * log10f( max( 1e-018f, tonal / noise ) );
276 :
277 175748 : return tonalToNoise;
278 : }
279 :
280 :
281 : /*-------------------------------------------------------------------*
282 : * IGF_getCrest()
283 : *
284 : * crest factor calculation
285 : *-------------------------------------------------------------------*/
286 :
287 : /*! r: crest factor */
288 16358770 : static float IGF_getCrest(
289 : const float *powerSpectrum, /* i : power spectrum */
290 : const int16_t start, /* i : start subband index */
291 : const int16_t stop /* i : stop subband index */
292 : )
293 : {
294 : int16_t i;
295 : int16_t x;
296 16358770 : int32_t x_eff = 0;
297 16358770 : int16_t x_max = 0;
298 16358770 : float crest = 1.f;
299 :
300 886570514 : for ( i = start; i < stop; i++ )
301 : {
302 870211744 : x = max( 0, (int16_t) ( logf( max( FLT_MIN, powerSpectrum[i] ) ) * INV_LOG_2 ) );
303 870211744 : x_eff += x * x;
304 :
305 870211744 : if ( x > x_max )
306 : {
307 50383185 : x_max = x;
308 : }
309 : }
310 :
311 16358770 : x_eff /= ( stop - start );
312 :
313 16358770 : if ( x_eff > 0 && x_max > 0 )
314 : {
315 15184075 : crest = max( 1.f, (float) x_max / sqrtf( (float) x_eff ) );
316 : }
317 :
318 16358770 : return crest;
319 : }
320 :
321 :
322 : /*-------------------------------------------------------------------*
323 : * IGF_getSFM()
324 : *
325 : * calculates spectral flatness measurement
326 : *-------------------------------------------------------------------*/
327 :
328 : /*! r: SFM value */
329 16358770 : static float IGF_getSFM(
330 : const float *powerSpectrum, /* i : energies */
331 : const int16_t start, /* i : start subband index */
332 : const int16_t stop /* i : stop subband index */
333 : )
334 : {
335 : int16_t n;
336 : int16_t i;
337 : int16_t num;
338 : float denom;
339 : float numf;
340 : float tmp;
341 : float sfm;
342 :
343 16358770 : num = 0;
344 16358770 : denom = 1.f;
345 16358770 : sfm = 1.f;
346 :
347 886570514 : for ( i = start; i < stop; i++ )
348 : {
349 870211744 : tmp = powerSpectrum[i];
350 870211744 : n = max( 0, (int16_t) ( logf( max( FLT_MIN, tmp ) ) * INV_LOG_2 ) );
351 870211744 : num += n;
352 870211744 : denom += tmp;
353 : }
354 :
355 16358770 : numf = (float) num / (float) ( stop - start );
356 16358770 : denom /= (float) ( stop - start );
357 :
358 16358770 : if ( denom != 0 )
359 : {
360 16358770 : sfm = min( ( powf( 2.0f, numf + 0.5f ) / denom ), 1.0f );
361 : }
362 :
363 16358770 : return sfm;
364 : }
365 :
366 :
367 : /*-------------------------------------------------------------------*
368 : * IGF_CalculateEnvelope()
369 : *
370 : * envelope estimation
371 : *-------------------------------------------------------------------*/
372 :
373 6907205 : static void IGF_CalculateEnvelope(
374 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
375 : const float *pMDCTSpectrum, /* i : MDCT spectrum */
376 : const float *pPowerSpectrum, /* i : MDCT^2 + MDST^2 spectrum, or estimate */
377 : const int16_t igfGridIdx, /* i : IGF grid index */
378 : const int16_t isTransient, /* i : flag indicating if transient is detected */
379 : const int16_t last_core_acelp, /* i : indicator if last frame was ACELP core */
380 : const int16_t element_mode, /* i : IVAS element_mode */
381 : const float att /* i : attenuation */
382 : )
383 : {
384 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
385 : H_IGF_GRID hGrid;
386 : int16_t *swb_offset;
387 : int16_t sfb; /* this is the actual scalefactor band */
388 : int16_t width; /* this is width in subbands of the actual scalefactor band */
389 : int16_t tile_idx;
390 : int16_t strt_cpy;
391 : float gain; /* the gain which has to be applied to the source tile to get the destination energy */
392 : int16_t sb;
393 : float sfbEnergyR;
394 : float sfbEnergyC; /* the energy of the destination region of the tile */
395 : float sfbEnergyTileR;
396 : float sfbEnergyTileC; /* the energy of the destination region of the tile */
397 : int16_t tmp;
398 : float tmp_tb;
399 : float tmp_sb;
400 : int16_t sfbCnt;
401 :
402 6907205 : hPrivateData = &hIGFEnc->igfData;
403 6907205 : hGrid = &hPrivateData->igfInfo.grid[(int16_t) igfGridIdx];
404 6907205 : swb_offset = hGrid->swb_offset;
405 :
406 6907205 : if ( element_mode > EVS_MONO )
407 : {
408 6886143 : if ( igfGridIdx != IGF_GRID_LB_NORM )
409 : {
410 2229896 : for ( sfbCnt = 0; sfbCnt < hGrid->sfbWrap[hGrid->nTiles] - hGrid->sfbWrap[0]; sfbCnt++ )
411 : {
412 : /* reset filter */
413 1881733 : hPrivateData->prevSFM_FIR_SFB_TB[sfbCnt] = 0.f;
414 1881733 : hPrivateData->prevSFM_IIR_SFB_TB[sfbCnt] = 0.f;
415 1881733 : hPrivateData->prevSFM_FIR_SFB_SB[sfbCnt] = 0.f;
416 1881733 : hPrivateData->prevSFM_IIR_SFB_SB[sfbCnt] = 0.f;
417 1881733 : hPrivateData->prevDampingFactor_IIR[sfbCnt] = -1.f;
418 1881733 : hPrivateData->dampingFactorSmoothing[sfbCnt] = 2;
419 : }
420 : }
421 : }
422 :
423 6907205 : if ( pPowerSpectrum )
424 : {
425 3333322071 : for ( sb = hGrid->sbWrap[0]; sb < swb_offset[hGrid->sfbWrap[hGrid->nTiles]]; sb++ )
426 : {
427 3327135396 : hPrivateData->logSpec[sb] = max( 0, (int16_t) ( log( max( FLT_MIN, pPowerSpectrum[sb] ) ) * INV_LOG_2 ) );
428 : }
429 : }
430 :
431 33678127 : for ( tile_idx = 0; tile_idx < hGrid->nTiles; tile_idx++ )
432 : {
433 26770922 : strt_cpy = hGrid->sbWrap[tile_idx];
434 :
435 66229784 : for ( sfb = hGrid->sfbWrap[tile_idx]; sfb < hGrid->sfbWrap[tile_idx + 1]; sfb++ )
436 : {
437 39458862 : width = swb_offset[sfb + 1] - swb_offset[sfb];
438 :
439 39458862 : sfbEnergyTileR = EPSILON;
440 39458862 : sfbEnergyTileC = EPSILON;
441 39458862 : sfbEnergyC = EPSILON;
442 :
443 39458862 : if ( pPowerSpectrum )
444 : {
445 35722909 : tmp = strt_cpy;
446 2004078487 : for ( sb = swb_offset[sfb]; sb < swb_offset[sfb + 1]; sb++ )
447 : {
448 1968355578 : sfbEnergyC += pPowerSpectrum[sb];
449 1968355578 : sfbEnergyTileR += pMDCTSpectrum[strt_cpy] * pMDCTSpectrum[strt_cpy];
450 1968355578 : sfbEnergyTileC += pPowerSpectrum[strt_cpy];
451 :
452 1968355578 : strt_cpy++;
453 : }
454 :
455 35722909 : sfbEnergyTileR /= width;
456 35722909 : gain = (float) ( sfbEnergyTileR * ( sfbEnergyC / sfbEnergyTileC ) );
457 :
458 35722909 : if ( element_mode > EVS_MONO )
459 : {
460 35607829 : if ( !isTransient )
461 : {
462 : float diffSFM;
463 35539861 : float shiftedSFM = 0.f;
464 :
465 35539861 : 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] );
466 35539861 : tmp_sb = IGF_getSFM_new( pPowerSpectrum, hPrivateData->logSpec, tmp, strt_cpy ) / IGF_getCrest_new( hPrivateData->logSpec, tmp, strt_cpy );
467 :
468 35539861 : if ( last_core_acelp || hPrivateData->wasTransient )
469 : {
470 1178656 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = hPrivateData->prevSFM_IIR_SFB_TB[sfb] = tmp_tb;
471 1178656 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = hPrivateData->prevSFM_IIR_SFB_SB[sfb] = tmp_sb;
472 : }
473 :
474 35539861 : hPrivateData->SFM_tb[sfb] = tmp_tb + hPrivateData->prevSFM_FIR_SFB_TB[sfb] + 0.5f * hPrivateData->prevSFM_IIR_SFB_TB[sfb];
475 35539861 : hPrivateData->SFM_tb[sfb] = min( 2.7f, hPrivateData->SFM_tb[sfb] );
476 35539861 : hPrivateData->SFM_sb[sfb] = tmp_sb + hPrivateData->prevSFM_FIR_SFB_SB[sfb] + 0.5f * hPrivateData->prevSFM_IIR_SFB_SB[sfb];
477 35539861 : hPrivateData->SFM_sb[sfb] = min( 2.7f, hPrivateData->SFM_sb[sfb] );
478 :
479 35539861 : diffSFM = hPrivateData->SFM_sb[sfb] - hPrivateData->SFM_tb[sfb];
480 :
481 35539861 : if ( diffSFM > 0.f && hPrivateData->SFM_tb[sfb] < 0.1f ) /* check whether target SFB is more tonal than source SFB */
482 156095 : {
483 : float currDampingFactor, dampingFactor;
484 : float slope, threshold;
485 : float tonalToNoise, adap;
486 : float alpha;
487 :
488 : /* calculate spectral tilt to detect sudden drops (or increases) in energy in the current SFB */
489 156095 : slope = IGF_getTilt( pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1] );
490 :
491 : /* determine whether strong tilt is due to a step in the spectrum (e.g. band limitation, no damping)
492 : or a tonal component close the band border (apply damping) by calculating SFM for a shift of 1/2 SFB width*/
493 156095 : threshold = 60.f / ( (float) width );
494 156095 : if ( slope < -threshold )
495 : {
496 8339 : int16_t shift = width >> 1;
497 8339 : shiftedSFM = IGF_getSFM_new( pPowerSpectrum, hPrivateData->logSpec, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift ) / IGF_getCrest_new( hPrivateData->logSpec, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift );
498 : }
499 147756 : else if ( ( slope > 1.f * threshold ) && ( sfb != hGrid->sfbWrap[hGrid->nTiles] - 1 ) )
500 : {
501 2611 : int16_t shift = width >> 1;
502 2611 : shiftedSFM = IGF_getSFM_new( pPowerSpectrum, hPrivateData->logSpec, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift ) / IGF_getCrest_new( hPrivateData->logSpec, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift );
503 : }
504 :
505 156095 : if ( shiftedSFM > 0.04f )
506 : {
507 5766 : currDampingFactor = 1.f;
508 : }
509 : else
510 : {
511 150329 : alpha = min( 320.f / (float) swb_offset[sfb + 1], 1.25f );
512 150329 : currDampingFactor = expf( 1.25f * alpha * logf( hPrivateData->SFM_tb[sfb] / hPrivateData->SFM_sb[sfb] ) );
513 :
514 :
515 : /* calculate tonal-to-noise ratio and reduce damping for low values*/
516 150329 : adap = (float) width / 40.f;
517 150329 : tonalToNoise = IGF_getTNR( pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1], adap );
518 150329 : if ( ( tonalToNoise - ( 10 + adap ) ) < 0 )
519 : {
520 118208 : currDampingFactor += 0.03f * ( ( 10 + adap ) - tonalToNoise );
521 : }
522 : }
523 :
524 156095 : if ( last_core_acelp || hPrivateData->wasTransient || hPrivateData->prevDampingFactor_IIR[sfb] == -1 )
525 : {
526 77607 : hPrivateData->prevDampingFactor_IIR[sfb] = max( currDampingFactor, 0.1f );
527 : }
528 156095 : if ( last_core_acelp )
529 : {
530 5708 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
531 : }
532 :
533 156095 : dampingFactor = ( currDampingFactor + hPrivateData->prevDampingFactor_IIR[sfb] ) / 2;
534 :
535 156095 : gain *= min( dampingFactor + hPrivateData->dampingFactorSmoothing[sfb] * 0.1f, 1 );
536 :
537 156095 : hPrivateData->prevDampingFactor_IIR[sfb] = dampingFactor;
538 156095 : if ( hPrivateData->dampingFactorSmoothing[sfb] > 0 )
539 : {
540 93915 : hPrivateData->dampingFactorSmoothing[sfb]--;
541 : }
542 : }
543 : else
544 : {
545 35383766 : hPrivateData->prevDampingFactor_IIR[sfb] = -1;
546 35383766 : hPrivateData->dampingFactorSmoothing[sfb] = 1;
547 : }
548 :
549 35539861 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = tmp_tb;
550 35539861 : hPrivateData->prevSFM_IIR_SFB_TB[sfb] = hPrivateData->SFM_tb[sfb];
551 35539861 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = tmp_sb;
552 35539861 : hPrivateData->prevSFM_IIR_SFB_SB[sfb] = hPrivateData->SFM_sb[sfb];
553 : }
554 : else
555 : {
556 67968 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = 0.f;
557 67968 : hPrivateData->prevSFM_IIR_SFB_TB[sfb] = 0.f;
558 67968 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = 0.f;
559 67968 : hPrivateData->prevSFM_IIR_SFB_SB[sfb] = 0.f;
560 67968 : hPrivateData->prevDampingFactor_IIR[sfb] = -1.f;
561 67968 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
562 : }
563 : }
564 : }
565 : else
566 : {
567 3735953 : sfbEnergyR = EPSILON + sum2_f( pMDCTSpectrum + swb_offset[sfb], width ) / width;
568 3735953 : gain = (float) ( sfbEnergyR );
569 :
570 3735953 : if ( element_mode > EVS_MONO )
571 : {
572 3731727 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = 0.f;
573 3731727 : hPrivateData->prevSFM_IIR_SFB_TB[sfb] = 0.f;
574 3731727 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = 0.f;
575 3731727 : hPrivateData->prevSFM_IIR_SFB_SB[sfb] = 0.f;
576 3731727 : hPrivateData->prevDampingFactor_IIR[sfb] = -1.f;
577 3731727 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
578 : }
579 : }
580 :
581 39458862 : gain *= att;
582 :
583 39458862 : gain = 0.5f + (float) ( 2.885390081777927f * logf( gain ) + 16.f );
584 39458862 : if ( !isTransient && ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_48000_CPE || hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_FB_48000_CPE ) )
585 : {
586 6768653 : gain += 0.25f; /* better preservation of original HF band energy */
587 : }
588 39458862 : if ( !isTransient && ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_64000_CPE || hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_FB_64000_CPE ) )
589 : {
590 8986663 : gain += 0.125f;
591 : }
592 39458862 : gain = min( gain, 91.f ); /* 13+15+63, see arithcode encode residual */
593 39458862 : gain = max( gain, 0.f );
594 :
595 39458862 : hPrivateData->igfScfQuantized[sfb] = (int16_t) ( gain );
596 : }
597 : }
598 :
599 6907205 : return;
600 : }
601 :
602 :
603 : /*-------------------------------------------------------------------*
604 : * IGF_CalculateStereoEnvelope()
605 : *
606 : * envelope estimation
607 : *-------------------------------------------------------------------*/
608 :
609 1819458 : static void IGF_CalculateStereoEnvelope(
610 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
611 : const float *pMDCTSpectrum, /* i : MDCT spectrum */
612 : const float *pMDCTSpectrumMsInv, /* i : MDCT spectrum */
613 : const float *pPowerSpectrum, /* i : MDCT^2 + MDST^2 spectrum, or estimate */
614 : const float *pPowerSpectrumMsInv, /* i : inverse power spectrum */
615 : const int16_t igfGridIdx, /* i : IGF grid index */
616 : const int16_t coreMsMask[N_MAX], /* i : line wise ms Mask */
617 : const int16_t isTransient, /* i : flag indicating if transient is detected */
618 : const int16_t last_core_acelp /* i : indicator if last frame was ACELP core */
619 : )
620 : {
621 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
622 : H_IGF_GRID hGrid;
623 : int16_t *swb_offset;
624 : int16_t sfb; /* this is the actual scalefactor band */
625 : int16_t width; /* this is width in subbands of the actual scalefactor band */
626 : int16_t tile_idx;
627 : int16_t strt_cpy;
628 : float gain; /* the gain which has to be applied to the source tile to get the destination energy */
629 : int16_t sb;
630 : float sfbEnergyR;
631 : float sfbEnergyC; /* the energy of the destination region of the tile */
632 : float sfbEnergyTileR;
633 : float sfbEnergyTileC; /* the energy of the destination region of the tile */
634 : int16_t tmp, x, y;
635 : float mean_x, mean_y, mean_xy, mean_x2;
636 : float slope;
637 : float tmp_tb;
638 : float tmp_sb;
639 : int16_t sfbCnt;
640 : float tileSrcSpec[MAX_IGF_SFB_LEN];
641 :
642 1819458 : hPrivateData = &hIGFEnc->igfData;
643 1819458 : hGrid = &hPrivateData->igfInfo.grid[(int16_t) igfGridIdx];
644 1819458 : swb_offset = hGrid->swb_offset;
645 :
646 1819458 : if ( igfGridIdx != IGF_GRID_LB_NORM )
647 : {
648 471022 : for ( sfbCnt = 0; sfbCnt < hGrid->sfbWrap[hGrid->nTiles] - hGrid->sfbWrap[0]; sfbCnt++ )
649 : {
650 : /* reset filter */
651 389466 : hPrivateData->prevSFM_FIR_SFB_TB[sfbCnt] = 0.f;
652 389466 : hPrivateData->prevSFM_IIR_SFB_TB[sfbCnt] = 0.f;
653 389466 : hPrivateData->prevSFM_FIR_SFB_SB[sfbCnt] = 0.f;
654 389466 : hPrivateData->prevSFM_IIR_SFB_SB[sfbCnt] = 0.f;
655 : }
656 : }
657 :
658 1819458 : if ( pPowerSpectrum )
659 : {
660 763096010 : for ( sb = hGrid->sbWrap[0]; sb < swb_offset[hGrid->sfbWrap[hGrid->nTiles]]; sb++ )
661 : {
662 761572528 : hPrivateData->logSpec[sb] = max( 0, (int16_t) ( logf( max( FLT_MIN, pPowerSpectrum[sb] ) ) * INV_LOG_2 ) );
663 : }
664 : }
665 :
666 7742250 : for ( tile_idx = 0; tile_idx < hGrid->nTiles; tile_idx++ )
667 : {
668 5922792 : strt_cpy = hGrid->sbWrap[tile_idx];
669 :
670 15667686 : for ( sfb = hGrid->sfbWrap[tile_idx]; sfb < hGrid->sfbWrap[tile_idx + 1]; sfb++ )
671 : {
672 9744894 : width = swb_offset[sfb + 1] - swb_offset[sfb];
673 9744894 : sfbEnergyTileR = EPSILON;
674 9744894 : sfbEnergyTileC = EPSILON;
675 9744894 : sfbEnergyC = EPSILON;
676 :
677 9744894 : if ( pPowerSpectrum )
678 : {
679 8179086 : tmp = strt_cpy;
680 :
681 443270814 : for ( sb = swb_offset[sfb]; sb < swb_offset[sfb + 1]; sb++ )
682 : {
683 435091728 : if ( coreMsMask[sb] != coreMsMask[strt_cpy] )
684 : {
685 271682864 : sfbEnergyC += pPowerSpectrum[sb];
686 271682864 : sfbEnergyTileR += pMDCTSpectrumMsInv[strt_cpy] * pMDCTSpectrumMsInv[strt_cpy];
687 271682864 : sfbEnergyTileC += pPowerSpectrumMsInv[strt_cpy];
688 271682864 : tileSrcSpec[strt_cpy - tmp] = pPowerSpectrumMsInv[strt_cpy];
689 : }
690 : else
691 : {
692 163408864 : sfbEnergyC += pPowerSpectrum[sb];
693 163408864 : sfbEnergyTileR += pMDCTSpectrum[strt_cpy] * pMDCTSpectrum[strt_cpy];
694 163408864 : sfbEnergyTileC += pPowerSpectrum[strt_cpy];
695 163408864 : tileSrcSpec[strt_cpy - tmp] = pPowerSpectrum[strt_cpy];
696 : }
697 435091728 : strt_cpy++;
698 : }
699 :
700 8179086 : sfbEnergyTileR /= width;
701 8179086 : gain = (float) ( sfbEnergyTileR * ( sfbEnergyC / sfbEnergyTileC ) );
702 :
703 8179086 : if ( !isTransient )
704 : {
705 : float diffSFM;
706 8179086 : float shiftedSFM = 0.f;
707 :
708 8179086 : tmp_tb = IGF_getSFM( pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1] ) / IGF_getCrest( pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1] );
709 8179086 : tmp_sb = IGF_getSFM( tileSrcSpec, 0, strt_cpy - tmp ) / IGF_getCrest( tileSrcSpec, 0, strt_cpy - tmp );
710 :
711 8179086 : if ( last_core_acelp || hPrivateData->wasTransient )
712 : {
713 149866 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = hPrivateData->prevSFM_IIR_SFB_TB[sfb] = tmp_tb;
714 149866 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = hPrivateData->prevSFM_IIR_SFB_SB[sfb] = tmp_sb;
715 : }
716 :
717 8179086 : hPrivateData->SFM_tb[sfb] = tmp_tb + hPrivateData->prevSFM_FIR_SFB_TB[sfb] + 0.5f * hPrivateData->prevSFM_IIR_SFB_TB[sfb];
718 8179086 : hPrivateData->SFM_tb[sfb] = min( 2.7f, hPrivateData->SFM_tb[sfb] );
719 8179086 : hPrivateData->SFM_sb[sfb] = tmp_sb + hPrivateData->prevSFM_FIR_SFB_SB[sfb] + 0.5f * hPrivateData->prevSFM_IIR_SFB_SB[sfb];
720 8179086 : hPrivateData->SFM_sb[sfb] = min( 2.7f, hPrivateData->SFM_sb[sfb] );
721 :
722 8179086 : diffSFM = hPrivateData->SFM_sb[sfb] - hPrivateData->SFM_tb[sfb];
723 :
724 8179086 : if ( diffSFM > 0.f && hPrivateData->SFM_tb[sfb] < 0.1f ) /* check whether target SFB is more tonal than source SFB */
725 25419 : {
726 : float currDampingFactor, dampingFactor, threshold, alpha;
727 :
728 : /* calculate spectral tilt to detect sudden drops (or increases) in energy in the current SFB */
729 25419 : x = 1;
730 25419 : mean_x = mean_y = mean_xy = mean_x2 = 0;
731 1335551 : for ( sb = swb_offset[sfb]; sb < swb_offset[sfb + 1]; sb++ )
732 : {
733 1310132 : mean_x += x;
734 1310132 : mean_x2 += x * x;
735 1310132 : y = 20 * (int16_t) log10f( max( 1e-018f, pPowerSpectrum[sb] ) );
736 1310132 : mean_y += y;
737 1310132 : mean_xy += y * x;
738 :
739 1310132 : x++;
740 : }
741 25419 : mean_y /= width;
742 25419 : mean_x /= width;
743 25419 : mean_xy /= width;
744 25419 : mean_x2 /= width;
745 25419 : slope = ( mean_xy - mean_x * mean_y ) / ( mean_x2 - mean_x * mean_x );
746 :
747 : /* determine whether strong tilt is due to a step in the spectrum (e.g. band limitation, no damping)
748 : or a tonal component close the band border (apply damping) by calculating SFM for a shift of 1/2 SFB width*/
749 25419 : threshold = 60.f / ( (float) width );
750 25419 : if ( slope < -threshold )
751 : {
752 494 : int16_t shift = width >> 1;
753 494 : shiftedSFM = IGF_getSFM( pPowerSpectrum, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift ) / IGF_getCrest( pPowerSpectrum, swb_offset[sfb] - shift, swb_offset[sfb + 1] - shift );
754 : }
755 24925 : else if ( ( slope > 1.f * threshold ) && ( sfb != hGrid->sfbWrap[hGrid->nTiles] - 1 ) )
756 : {
757 104 : int16_t shift = width >> 1;
758 104 : shiftedSFM = IGF_getSFM( pPowerSpectrum, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift ) / IGF_getCrest( pPowerSpectrum, swb_offset[sfb] + shift, swb_offset[sfb + 1] + shift );
759 : }
760 :
761 25419 : alpha = min( 320.f / (float) swb_offset[sfb + 1], 1.25f );
762 25419 : currDampingFactor = expf( alpha * logf( hPrivateData->SFM_tb[sfb] / hPrivateData->SFM_sb[sfb] ) );
763 :
764 25419 : if ( shiftedSFM > 0.04f )
765 : {
766 412 : currDampingFactor = 1.f;
767 : }
768 :
769 25419 : if ( last_core_acelp || hPrivateData->wasTransient || hPrivateData->prevDampingFactor_IIR[sfb] == -1 )
770 : {
771 12302 : hPrivateData->prevDampingFactor_IIR[sfb] = max( currDampingFactor, 0.1f );
772 : }
773 :
774 : {
775 : float tonalToNoise;
776 25419 : float adap = ( (float) width ) / 30.f;
777 25419 : tonalToNoise = IGF_getTNR( pPowerSpectrum, swb_offset[sfb], swb_offset[sfb + 1], adap );
778 25419 : if ( ( tonalToNoise - ( 10 + adap ) ) < 0 )
779 : {
780 21092 : currDampingFactor += 0.1f * ( ( 10 + adap ) - tonalToNoise );
781 : }
782 : }
783 :
784 25419 : dampingFactor = ( currDampingFactor + hPrivateData->prevDampingFactor_IIR[sfb] ) / 2;
785 25419 : dampingFactor = max( dampingFactor, hPrivateData->prevDampingFactor_IIR[sfb] / 2 );
786 :
787 25419 : gain *= min( dampingFactor + hPrivateData->dampingFactorSmoothing[sfb] * 0.1f, 1 );
788 :
789 25419 : hPrivateData->prevDampingFactor_IIR[sfb] = dampingFactor;
790 25419 : if ( hPrivateData->dampingFactorSmoothing[sfb] > 0 )
791 : {
792 14436 : hPrivateData->dampingFactorSmoothing[sfb]--;
793 : }
794 : }
795 : else
796 : {
797 8153667 : hPrivateData->prevDampingFactor_IIR[sfb] = -1;
798 8153667 : hPrivateData->dampingFactorSmoothing[sfb] = 1;
799 : }
800 :
801 8179086 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = tmp_tb;
802 8179086 : hPrivateData->prevSFM_IIR_SFB_TB[sfb] = hPrivateData->SFM_tb[sfb];
803 8179086 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = tmp_sb;
804 8179086 : hPrivateData->prevSFM_IIR_SFB_SB[sfb] = hPrivateData->SFM_sb[sfb];
805 : }
806 : else
807 : {
808 0 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = 0.f;
809 0 : hPrivateData->prevSFM_IIR_SFB_TB[sfb] = 0.f;
810 0 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = 0.f;
811 0 : hPrivateData->prevSFM_IIR_SFB_SB[sfb] = 0.f;
812 :
813 0 : hPrivateData->dampingFactorSmoothing[sfb] = 2;
814 : }
815 : }
816 : else
817 : {
818 1565808 : sfbEnergyR = EPSILON + sum2_f( pMDCTSpectrum + swb_offset[sfb], width ) / width;
819 1565808 : gain = (float) ( sfbEnergyR );
820 :
821 1565808 : hPrivateData->prevSFM_FIR_SFB_TB[sfb] = 0.f;
822 1565808 : hPrivateData->prevSFM_IIR_SFB_TB[sfb] = 0.f;
823 1565808 : hPrivateData->prevSFM_FIR_SFB_SB[sfb] = 0.f;
824 1565808 : hPrivateData->prevSFM_IIR_SFB_SB[sfb] = 0.f;
825 : }
826 :
827 9744894 : gain = 0.5f + (float) ( 2.885390081777927f * logf( gain ) + 16.f );
828 9744894 : if ( !isTransient && ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_48000_CPE || hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_FB_48000_CPE ) )
829 : {
830 2617583 : gain += 0.25f; /* better preservation of original HF band energy */
831 : }
832 9744894 : if ( !isTransient && ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_64000_CPE || hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_FB_64000_CPE ) )
833 : {
834 3019270 : gain += 0.125f;
835 : }
836 9744894 : gain = min( gain, 91.f ); /* 13+15+63, see arithcode encode residual */
837 9744894 : gain = max( gain, 0.f );
838 :
839 9744894 : hPrivateData->igfScfQuantized[sfb] = (int16_t) ( gain );
840 : }
841 : }
842 :
843 1819458 : return;
844 : }
845 :
846 :
847 : /*-------------------------------------------------------------------*
848 : * IGF_WriteEnvelope()
849 : *
850 : * writes IGF SCF values
851 : *-------------------------------------------------------------------*/
852 :
853 : /*! r: number of bits writen */
854 17117360 : static int16_t IGF_WriteEnvelope(
855 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
856 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
857 : int16_t *pBitOffset, /* i : ptr to bitOffset counter */
858 : const int16_t igfGridIdx, /* i : igf grid index see declaration of IGF_GRID_IDX for details */
859 : const int16_t isIndepFlag, /* i : if 1 frame is independent, 0 = frame is coded with data from previous frame */
860 : int16_t *igfAllZero /* i : returns 1 if all IGF scfs are zero, else 0 */
861 : )
862 : {
863 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
864 : H_IGF_GRID hGrid;
865 : int16_t totBitCount;
866 : int16_t startBitCount;
867 : int16_t sfb;
868 :
869 17117360 : startBitCount = *pBitOffset;
870 17117360 : totBitCount = 0;
871 17117360 : *igfAllZero = 1;
872 17117360 : hPrivateData = &hIGFEnc->igfData;
873 17117360 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
874 :
875 19991754 : for ( sfb = hGrid->startSfb; sfb < hGrid->stopSfb; sfb++ )
876 : {
877 19633842 : if ( hPrivateData->igfScfQuantized[sfb] != 0 )
878 : {
879 16759448 : *igfAllZero = 0;
880 16759448 : break;
881 : }
882 : }
883 :
884 17117360 : if ( *igfAllZero )
885 : {
886 357912 : IGF_write_bit( hBstr, pBitOffset, 1 );
887 :
888 357912 : if ( hBstr == NULL )
889 : {
890 178213 : IGFSCFEncoderSaveContextState( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
891 : }
892 :
893 357912 : IGFSCFEncoderReset( &hPrivateData->hIGFSCFArithEnc );
894 :
895 357912 : if ( hBstr == NULL )
896 : {
897 178213 : IGFSCFEncoderRestoreContextState( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
898 : }
899 : }
900 : else
901 : {
902 16759448 : IGF_write_bit( hBstr, pBitOffset, 0 );
903 :
904 16759448 : if ( hBstr == NULL )
905 : {
906 8212484 : IGFSCFEncoderSaveContextState( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
907 : }
908 :
909 16759448 : *pBitOffset = IGFSCFEncoderEncode( &hPrivateData->hIGFSCFArithEnc, hBstr, *pBitOffset, &hPrivateData->igfScfQuantized[hGrid->startSfb], igfGridIdx, isIndepFlag );
910 :
911 16759448 : if ( hBstr == NULL )
912 : {
913 8212484 : IGFSCFEncoderRestoreContextState( &hPrivateData->hIGFSCFArithEnc, igfGridIdx );
914 : }
915 : }
916 17117360 : totBitCount = *pBitOffset - startBitCount;
917 :
918 17117360 : return totBitCount;
919 : }
920 :
921 :
922 : /*-------------------------------------------------------------------*
923 : * IGF_ErodeSpectrum()
924 : *
925 : * identifies significant spectral content
926 : *-------------------------------------------------------------------*/
927 :
928 : /*! r: highPassEnergy */
929 8726663 : static float IGF_ErodeSpectrum(
930 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
931 : float *pSpectrum, /* i/o: MDCT spectrum */
932 : float *pPowerSpectrum, /* i/o: power spectrum */
933 : const int16_t igfGridIdx, /* i : IGF grid index */
934 : const int16_t mct_on /* i : flag mct block (1) or stereo (0) */
935 : )
936 : {
937 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
938 : H_IGF_GRID hGrid;
939 : int16_t i;
940 : int16_t igfBgn;
941 : int16_t igfEnd;
942 : float highPassEner;
943 : float lastLine;
944 : float nextLine;
945 : float factor;
946 : int16_t *igfScaleF;
947 : int16_t startSfb;
948 : int16_t stopSfb;
949 : int16_t *swb_offset;
950 : int16_t tmp;
951 : int16_t sfb;
952 : int16_t line;
953 :
954 8726663 : highPassEner = 0.f;
955 8726663 : hPrivateData = &hIGFEnc->igfData;
956 8726663 : hGrid = &hPrivateData->igfInfo.grid[(int16_t) igfGridIdx];
957 8726663 : igfBgn = hGrid->startLine;
958 8726663 : igfEnd = hGrid->stopLine;
959 8726663 : startSfb = hGrid->startSfb;
960 8726663 : stopSfb = hGrid->stopSfb;
961 8726663 : swb_offset = hGrid->swb_offset;
962 8726663 : igfScaleF = hPrivateData->igfScfQuantized;
963 :
964 8726663 : if ( pPowerSpectrum == NULL )
965 : {
966 72477118 : for ( i = igfBgn; i < hGrid->infoGranuleLen; i++ )
967 : {
968 72141152 : pSpectrum[i] = 0.f;
969 : }
970 335966 : return 0;
971 : }
972 :
973 8390697 : if ( igfBgn > 0 )
974 : {
975 3734533003 : for ( i = 0; i < igfBgn; i++ )
976 : {
977 3726142306 : highPassEner += (float) i * pPowerSpectrum[i];
978 : }
979 :
980 8390697 : if ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_9600 ||
981 8390136 : hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_RF_SWB_13200 ||
982 8390008 : hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_13200 ||
983 8385530 : hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_16400_CPE )
984 : {
985 269017 : factor = 1.f;
986 : }
987 8121680 : else if ( mct_on && ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_48000_CPE || hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_64000_CPE ) )
988 : {
989 73666 : factor = 0.7f;
990 : }
991 : else
992 : {
993 8048014 : factor = 2.f;
994 : }
995 8390697 : highPassEner /= igfBgn * factor; /* for 9.6kbs use 1.f */
996 8390697 : lastLine = pSpectrum[i - 1];
997 8390697 : nextLine = ( pPowerSpectrum[i - 1] < highPassEner ) ? 0.0f : pSpectrum[i];
998 :
999 2599494436 : for ( /*i*/; i < igfEnd - 1; i++ )
1000 : {
1001 2591103739 : if ( pPowerSpectrum[i] < highPassEner )
1002 : {
1003 2517240502 : lastLine = pSpectrum[i];
1004 2517240502 : pSpectrum[i] = nextLine;
1005 2517240502 : nextLine = 0.0f;
1006 : }
1007 : else
1008 : {
1009 73863237 : pSpectrum[i - 1] = lastLine;
1010 73863237 : lastLine = pSpectrum[i];
1011 73863237 : nextLine = pSpectrum[i + 1];
1012 : }
1013 : }
1014 :
1015 : /* i == igfEnd - 1 */
1016 8390697 : if ( pPowerSpectrum[i] < highPassEner )
1017 : {
1018 8105394 : pSpectrum[i] = 0.f;
1019 : }
1020 : }
1021 :
1022 : /* delete spectrum above igfEnd: */
1023 1030394915 : for ( i = igfEnd; i < hGrid->infoGranuleLen; i++ )
1024 : {
1025 1022004218 : pSpectrum[i] = 0.f;
1026 1022004218 : pPowerSpectrum[i] = 0.f;
1027 : }
1028 :
1029 8390697 : if ( NULL != pPowerSpectrum )
1030 : {
1031 55997393 : for ( sfb = startSfb; sfb < stopSfb; sfb++ )
1032 : {
1033 47606696 : tmp = 0;
1034 2647101132 : for ( line = swb_offset[sfb]; line < swb_offset[sfb + 1]; line++ )
1035 : {
1036 2599494436 : if ( pSpectrum[line] != 0.f )
1037 : {
1038 30306524 : tmp++;
1039 : }
1040 : }
1041 :
1042 47606696 : if ( tmp && igfScaleF[sfb] )
1043 : {
1044 1184317 : igfScaleF[sfb]--;
1045 : }
1046 : }
1047 : }
1048 :
1049 8390697 : return highPassEner;
1050 : }
1051 :
1052 :
1053 : /*-------------------------------------------------------------------*
1054 : * IGF_Whitening()
1055 : *
1056 : * calculates the IGF whitening levels by SFM and crest
1057 : *-------------------------------------------------------------------*/
1058 :
1059 8726663 : static void IGF_Whitening(
1060 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : | instance handle of IGF Encoder */
1061 : float *powerSpectrum, /* i : Q31 | MDCT/MDST power spectrum */
1062 : const int16_t igfGridIdx, /* i : Q0 | IGF grid index */
1063 : const int16_t isTransient, /* i : Q0 | flag indicating if transient is detected */
1064 : const int16_t last_core_acelp, /* i : Q0 | indicator if last frame was ACELP core */
1065 : const int16_t isTNSActive, /* i : Q0 | indicator if TNS is active */
1066 : const int16_t sp_aud_decision0, /* i : Q0 | first stage classifier decision */
1067 : const int32_t brate, /* i : Q0 | bitrate */
1068 : const int16_t element_mode /* i : Q0 | element mode */
1069 : )
1070 : {
1071 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1072 : H_IGF_GRID hGrid;
1073 : int16_t p;
1074 : float tmp;
1075 : float SFM_src;
1076 : float SFM_tar;
1077 : int16_t num_Tiles;
1078 : float SFM;
1079 :
1080 8726663 : SFM = -1.f;
1081 :
1082 8726663 : hPrivateData = &hIGFEnc->igfData;
1083 8726663 : hGrid = &hPrivateData->igfInfo.grid[(int16_t) igfGridIdx];
1084 :
1085 8726663 : if ( igfGridIdx != IGF_GRID_LB_NORM )
1086 : {
1087 1983079 : for ( p = 0; p < hGrid->nTiles; p++ )
1088 : {
1089 : /* reset filter */
1090 1552322 : hPrivateData->prevSFM_FIR[p] = 0.f;
1091 1552322 : hPrivateData->prevSFM_IIR[p] = 0.f;
1092 :
1093 : /* preset values: */
1094 1552322 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
1095 : }
1096 : }
1097 :
1098 95993293 : for ( p = 0; p < IGF_MAX_TILES; p++ )
1099 : {
1100 : /* update prev data: */
1101 87266630 : hPrivateData->igfPrevWhiteningLevel[p] = hPrivateData->igfCurrWhiteningLevel[p];
1102 : /* preset values: */
1103 87266630 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
1104 : }
1105 :
1106 8726663 : if ( !( isTransient || hPrivateData->wasTransient ) )
1107 : {
1108 8225642 : if ( powerSpectrum )
1109 : {
1110 39237645 : for ( p = 0; p < hGrid->nTiles; p++ )
1111 : {
1112 : int16_t sb;
1113 :
1114 31027929 : if ( isTNSActive )
1115 : {
1116 183791122 : for ( sb = hGrid->tile[p]; sb < hGrid->tile[p + 1]; sb++ )
1117 : {
1118 181702684 : hPrivateData->logSpec[sb] = max( 0, (int16_t) ( logf( max( FLT_MIN, powerSpectrum[sb] ) ) * INV_LOG_2 ) );
1119 : }
1120 : }
1121 :
1122 : /* if current tile contains only a single SFB, reuse already computed SFM values */
1123 31027929 : if ( element_mode > EVS_MONO && ( hGrid->sfbWrap[p + 1] - hGrid->sfbWrap[p] ) == 1 )
1124 : {
1125 18737234 : tmp = hPrivateData->SFM_tb[p];
1126 : }
1127 : else
1128 : {
1129 12290695 : tmp = IGF_getSFM_new( powerSpectrum, hPrivateData->logSpec, hGrid->tile[p], hGrid->tile[p + 1] ) / IGF_getCrest_new( hPrivateData->logSpec, hGrid->tile[p], hGrid->tile[p + 1] );
1130 : }
1131 :
1132 31027929 : if ( last_core_acelp || hPrivateData->wasTransient )
1133 : {
1134 580987 : hPrivateData->prevSFM_FIR[p] = hPrivateData->prevSFM_IIR[p] = tmp;
1135 : }
1136 :
1137 31027929 : if ( brate <= IVAS_48k && element_mode == IVAS_CPE_MDCT )
1138 : {
1139 8292676 : num_Tiles = 0;
1140 8292676 : SFM_src = 0.f;
1141 8292676 : SFM_tar = 0.f;
1142 :
1143 17350698 : for ( sb = hGrid->sfbWrap[p]; sb < hGrid->sfbWrap[p + 1]; sb++ )
1144 : {
1145 9058022 : num_Tiles++;
1146 9058022 : SFM_src += hPrivateData->SFM_sb[sb];
1147 9058022 : SFM_tar += hPrivateData->SFM_tb[sb];
1148 : }
1149 :
1150 : /* compute the average */
1151 8292676 : SFM_src /= num_Tiles;
1152 8292676 : SFM_tar /= num_Tiles;
1153 :
1154 8292676 : if ( ( p > 0 ) && ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_48000_CPE || hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_FB_48000_CPE ) )
1155 : {
1156 7038121 : if ( ( p == 1 ) && ( abs( hPrivateData->igfCurrWhiteningLevel[0] - hPrivateData->igfCurrWhiteningLevel[1] ) == 2 ) ) /* OFF vs. STRONG */
1157 : {
1158 97069 : hPrivateData->igfCurrWhiteningLevel[0] = IGF_WHITENING_MID;
1159 : }
1160 7038121 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfCurrWhiteningLevel[p - 1];
1161 : }
1162 1254555 : else if ( sp_aud_decision0 )
1163 : {
1164 : /* Music */
1165 : /* whitening Off: when tonality of target is more than source or tonality of target is close to that of source */
1166 594662 : if ( ( SFM_tar <= SFM_src ) || ( SFM_tar <= ( SFM_src + 0.5f ) ) )
1167 : {
1168 467062 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
1169 : }
1170 :
1171 : /* whitening mid: */
1172 594662 : if ( ( SFM_tar > ( SFM_src + 0.5f ) ) && ( SFM_tar <= ( SFM_src + 1.25f ) ) )
1173 : {
1174 111715 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
1175 : }
1176 :
1177 : /* whitening strong */
1178 594662 : if ( SFM_tar > ( SFM_src + 1.25f ) )
1179 : {
1180 15885 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_STRONG;
1181 : }
1182 : }
1183 : else
1184 : {
1185 : /* Speech */
1186 : /* whitening Off: when tonality of target is more than source or tonality of target is close to that of source */
1187 659893 : if ( ( SFM_tar <= SFM_src ) || ( SFM_tar <= ( SFM_src + 0.1f ) ) )
1188 : {
1189 381060 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
1190 : }
1191 :
1192 : /* whitening mid: */
1193 659893 : if ( ( SFM_tar > ( SFM_src + 0.1f ) ) && ( SFM_tar <= ( SFM_src + 0.5f ) ) )
1194 : {
1195 189120 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
1196 : }
1197 :
1198 : /* whitening strong */
1199 659893 : if ( SFM_tar > ( SFM_src + 0.5f ) )
1200 : {
1201 89713 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_STRONG;
1202 : }
1203 : }
1204 :
1205 8292676 : SFM = SFM_tar;
1206 : }
1207 : else
1208 : {
1209 22735253 : if ( element_mode > EVS_MONO && ( hGrid->sfbWrap[p + 1] - hGrid->sfbWrap[p] ) == 1 )
1210 : {
1211 11209904 : SFM = tmp;
1212 : }
1213 : else
1214 : {
1215 11525349 : SFM = tmp + hPrivateData->prevSFM_FIR[p] + 0.5f * hPrivateData->prevSFM_IIR[p];
1216 11525349 : SFM = min( 2.7f, SFM );
1217 : }
1218 :
1219 22735253 : hPrivateData->prevSFM_FIR[p] = tmp;
1220 22735253 : hPrivateData->prevSFM_IIR[p] = SFM;
1221 :
1222 22735253 : if ( SFM > hGrid->whiteningThreshold[1][p] )
1223 : {
1224 9873053 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_STRONG;
1225 : }
1226 12862200 : else if ( SFM > hGrid->whiteningThreshold[0][p] )
1227 : {
1228 8023666 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
1229 : }
1230 : else
1231 : {
1232 4838534 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_OFF;
1233 : }
1234 : }
1235 :
1236 31027929 : if ( element_mode > EVS_MONO )
1237 : {
1238 30982790 : if ( last_core_acelp ) /* reset */
1239 : {
1240 579411 : set_f( hPrivateData->igfPastSFM[p], -1.f, IGF_PAST_SFM_LEN );
1241 579411 : hPrivateData->igfWhiteningHangoverCnt[p] = 2;
1242 : }
1243 : else
1244 : {
1245 : /* check whether change in whitening level should be allowed or not (if SFM is inside a certain margin around thresholds) */
1246 30403379 : if ( hPrivateData->igfCurrWhiteningLevel[p] != hPrivateData->igfPrevWhiteningLevel[p] &&
1247 8156053 : ( ( SFM > hGrid->whiteningThreshold[0][p] - 0.15f && SFM < hGrid->whiteningThreshold[0][p] + 0.15f ) ||
1248 6624600 : ( SFM > hGrid->whiteningThreshold[1][p] - 0.15f && SFM < hGrid->whiteningThreshold[1][p] + 0.15f ) ) )
1249 : {
1250 3915480 : float mean_past_SFM = 0.f;
1251 3915480 : int16_t countable = 0;
1252 : int16_t i;
1253 :
1254 : /* compute mean of last (available) SFM values */
1255 23492880 : for ( i = 0; i < IGF_PAST_SFM_LEN; i++ )
1256 : {
1257 19577400 : if ( hPrivateData->igfPastSFM[p][i] >= 0.f )
1258 : {
1259 17030813 : mean_past_SFM += hPrivateData->igfPastSFM[p][i];
1260 17030813 : countable++;
1261 : }
1262 : }
1263 3915480 : if ( countable )
1264 : {
1265 3834391 : mean_past_SFM /= countable;
1266 :
1267 : /* deny change in whitening level for small deviations from mean SFM */
1268 3834391 : if ( fabs( SFM - mean_past_SFM ) < 0.2f )
1269 : {
1270 1889142 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfPrevWhiteningLevel[p];
1271 : }
1272 : }
1273 : }
1274 : }
1275 :
1276 30982790 : hPrivateData->igfPastSFM[p][hPrivateData->igfPastSFM_pos] = SFM;
1277 : }
1278 : }
1279 :
1280 8209716 : switch ( hPrivateData->igfInfo.bitRateIndex )
1281 : {
1282 1283560 : case IGF_BITRATE_WB_9600:
1283 : case IGF_BITRATE_RF_WB_13200:
1284 : case IGF_BITRATE_WB_13200_CPE:
1285 : case IGF_BITRATE_WB_16400_CPE:
1286 : case IGF_BITRATE_RF_SWB_13200:
1287 : case IGF_BITRATE_SWB_9600:
1288 : case IGF_BITRATE_SWB_13200_CPE:
1289 : case IGF_BITRATE_SWB_16400:
1290 : case IGF_BITRATE_SWB_24400:
1291 : case IGF_BITRATE_SWB_24400_CPE:
1292 : case IGF_BITRATE_SWB_32000_CPE:
1293 : case IGF_BITRATE_SWB_32000:
1294 : case IGF_BITRATE_FB_16400:
1295 : case IGF_BITRATE_FB_24400:
1296 : case IGF_BITRATE_FB_24400_CPE:
1297 : case IGF_BITRATE_FB_32000_CPE:
1298 : case IGF_BITRATE_FB_32000:
1299 1283560 : hPrivateData->igfCurrWhiteningLevel[hGrid->nTiles - 1] = hPrivateData->igfCurrWhiteningLevel[hGrid->nTiles - 2];
1300 1283560 : break;
1301 6926156 : default:
1302 6926156 : break;
1303 : }
1304 : }
1305 : else
1306 : {
1307 71851 : for ( p = 0; p < hGrid->nTiles; p++ )
1308 : {
1309 55925 : hPrivateData->igfCurrWhiteningLevel[p] = IGF_WHITENING_MID;
1310 : }
1311 : }
1312 : }
1313 : else
1314 : {
1315 : /* reset filter */
1316 5511231 : for ( p = 0; p < IGF_MAX_TILES; p++ )
1317 : {
1318 5010210 : hPrivateData->prevSFM_FIR[p] = 0.f;
1319 5010210 : hPrivateData->prevSFM_IIR[p] = 0.f;
1320 : }
1321 : }
1322 :
1323 8726663 : if ( element_mode > EVS_MONO )
1324 : {
1325 8705601 : if ( SFM == -1.f ) /* reset */
1326 : {
1327 2180795 : for ( p = 0; p < hGrid->nTiles; p++ )
1328 : {
1329 1664671 : set_f( hPrivateData->igfPastSFM[p], -1.f, IGF_PAST_SFM_LEN );
1330 1664671 : hPrivateData->igfWhiteningHangoverCnt[p] = 2;
1331 : }
1332 : }
1333 :
1334 : /* vibrato handling */
1335 27673260 : for ( p = 0; p < hGrid->nTiles; p = p + 2 )
1336 : {
1337 18967659 : if ( ( hPrivateData->igfPrevWhiteningLevel[p] == IGF_WHITENING_OFF && hPrivateData->igfCurrWhiteningLevel[p] != IGF_WHITENING_OFF ) ||
1338 16683631 : ( hPrivateData->igfPrevWhiteningLevel[p + 1] == IGF_WHITENING_OFF && hPrivateData->igfCurrWhiteningLevel[p + 1] != IGF_WHITENING_OFF ) )
1339 : {
1340 : int16_t i;
1341 : float pastSfm_a[4], pastSfm_b[4];
1342 : float pastSfmDiffSum_a, pastSfmDiffSum_b;
1343 :
1344 14201030 : for ( i = 0; i < 4; i++ )
1345 : {
1346 11360824 : pastSfm_a[i] = hPrivateData->igfPastSFM[p][( hPrivateData->igfPastSFM_pos + 4 - i ) % IGF_PAST_SFM_LEN];
1347 11360824 : pastSfm_b[i] = hPrivateData->igfPastSFM[p + 1][( hPrivateData->igfPastSFM_pos + 4 - i ) % IGF_PAST_SFM_LEN];
1348 : }
1349 2840206 : pastSfmDiffSum_a = pastSfmDiffSum_b = 0;
1350 8241272 : for ( i = 0; i < 3; i++ )
1351 : {
1352 6718309 : if ( pastSfm_a[i + 1] != -1.f )
1353 : {
1354 5401066 : pastSfmDiffSum_a += ( pastSfm_a[i] - pastSfm_a[i + 1] );
1355 5401066 : pastSfmDiffSum_b += ( pastSfm_b[i] - pastSfm_b[i + 1] );
1356 : }
1357 : else
1358 : {
1359 1317243 : break;
1360 : }
1361 : }
1362 :
1363 : /* if tonality oscillates between two tiles, turn whitening off in both */
1364 2840206 : if ( ( ( pastSfmDiffSum_a > 0.f && pastSfmDiffSum_b < 0.f ) ||
1365 408155 : ( pastSfmDiffSum_a < 0.f && pastSfmDiffSum_b > 0.f ) ) &&
1366 439123 : ( fabs( pastSfmDiffSum_a - pastSfmDiffSum_b ) > 0.5f ) )
1367 : {
1368 198073 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfCurrWhiteningLevel[p + 1] = IGF_WHITENING_OFF;
1369 : }
1370 : }
1371 : }
1372 :
1373 : /* hangover */
1374 41353062 : for ( p = 0; p < hGrid->nTiles; p++ )
1375 : {
1376 32647461 : if ( hPrivateData->igfCurrWhiteningLevel[p] != hPrivateData->igfPrevWhiteningLevel[p] )
1377 : {
1378 6292511 : hPrivateData->igfWhiteningHangoverCnt[p]++;
1379 6292511 : if ( hPrivateData->igfWhiteningHangoverCnt[p] == 3 )
1380 : {
1381 1623709 : hPrivateData->igfWhiteningHangoverCnt[p] = 0;
1382 : }
1383 : else
1384 : {
1385 4668802 : hPrivateData->igfCurrWhiteningLevel[p] = hPrivateData->igfPrevWhiteningLevel[p];
1386 : }
1387 : }
1388 : else
1389 : {
1390 26354950 : hPrivateData->igfWhiteningHangoverCnt[p] = 0;
1391 : }
1392 : }
1393 :
1394 8705601 : hPrivateData->igfPastSFM_pos = ( hPrivateData->igfPastSFM_pos + 1 ) % IGF_PAST_SFM_LEN;
1395 : }
1396 :
1397 8726663 : hPrivateData->wasTransient = isTransient;
1398 :
1399 8726663 : return;
1400 : }
1401 :
1402 :
1403 : /*-------------------------------------------------------------------*
1404 : * IGF_WriteWhiteningTile()
1405 : *
1406 : * write whitening levels into bitstream
1407 : *-------------------------------------------------------------------*/
1408 :
1409 : /*! r: number of bits written */
1410 35300557 : static int16_t IGF_WriteWhiteningTile(
1411 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1412 : int16_t *pBitOffset, /* i : ptr to bitOffset counter */
1413 : int16_t whiteningLevel /* i : whitening levels to write */
1414 : )
1415 : {
1416 : int16_t totBitCount;
1417 : int16_t startBitCount;
1418 :
1419 35300557 : totBitCount = 0;
1420 35300557 : startBitCount = *pBitOffset;
1421 :
1422 35300557 : if ( whiteningLevel == IGF_WHITENING_MID )
1423 : {
1424 12740244 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1425 : }
1426 : else
1427 : {
1428 22560313 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1429 22560313 : if ( whiteningLevel == IGF_WHITENING_OFF )
1430 : {
1431 11455923 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1432 : }
1433 : else
1434 : {
1435 11104390 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1436 : }
1437 : }
1438 35300557 : totBitCount = *pBitOffset - startBitCount;
1439 :
1440 35300557 : return totBitCount;
1441 : }
1442 :
1443 :
1444 : /*-------------------------------------------------------------------*
1445 : * IGF_WriteWhiteningLevels()
1446 : *
1447 : * writes the whitening levels
1448 : *-------------------------------------------------------------------*/
1449 :
1450 : /*! r: total number of bits written */
1451 17117360 : static int16_t IGF_WriteWhiteningLevels(
1452 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF encoder */
1453 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1454 : int16_t *pBitOffset, /* i : ptr to bitOffset counter */
1455 : const int16_t igfGridIdx, /* i : igf grid index see declaration of IGF_GRID_IDX for details */
1456 : const int16_t isIndepFlag /* i : if 1 frame is independent, 0 = frame is coded with data from previous frame */
1457 : )
1458 : {
1459 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1460 : H_IGF_GRID hGrid;
1461 : int16_t p;
1462 : int16_t nTiles;
1463 : int16_t totBitCount;
1464 : int16_t isSame;
1465 : int16_t startBitCount;
1466 :
1467 17117360 : totBitCount = 0;
1468 17117360 : isSame = 1;
1469 17117360 : startBitCount = *pBitOffset;
1470 17117360 : hPrivateData = &hIGFEnc->igfData;
1471 17117360 : hGrid = &hPrivateData->igfInfo.grid[igfGridIdx];
1472 17117360 : nTiles = hGrid->nTiles;
1473 :
1474 17117360 : if ( isIndepFlag )
1475 : {
1476 16949377 : isSame = 0;
1477 : }
1478 : else
1479 : {
1480 622078 : for ( p = 0; p < nTiles; p++ )
1481 : {
1482 462235 : if ( hPrivateData->igfCurrWhiteningLevel[p] != hPrivateData->igfPrevWhiteningLevel[p] )
1483 : {
1484 8140 : isSame = 0;
1485 8140 : break;
1486 : }
1487 : }
1488 : }
1489 :
1490 17117360 : if ( isSame )
1491 : {
1492 159843 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1493 : }
1494 : else
1495 : {
1496 16957517 : if ( !isIndepFlag )
1497 : {
1498 8140 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1499 : }
1500 :
1501 16957517 : IGF_WriteWhiteningTile( hBstr, pBitOffset, hPrivateData->igfCurrWhiteningLevel[0] );
1502 :
1503 16957517 : if ( hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_SWB_48000_CPE || hPrivateData->igfInfo.bitRateIndex == IGF_BITRATE_FB_48000_CPE )
1504 : {
1505 2640528 : isSame = 1;
1506 : }
1507 : else
1508 : {
1509 32222971 : for ( p = 1; p < nTiles; p++ )
1510 : {
1511 22481618 : isSame = 1;
1512 22481618 : if ( hPrivateData->igfCurrWhiteningLevel[p] != hPrivateData->igfCurrWhiteningLevel[p - 1] )
1513 : {
1514 4575636 : isSame = 0;
1515 4575636 : break;
1516 : }
1517 : }
1518 : }
1519 :
1520 16957517 : if ( !isSame )
1521 : {
1522 9847225 : IGF_write_bits( hBstr, pBitOffset, 1, 1 );
1523 :
1524 28190265 : for ( p = 1; p < nTiles; p++ )
1525 : {
1526 18343040 : IGF_WriteWhiteningTile( hBstr, pBitOffset, hPrivateData->igfCurrWhiteningLevel[p] );
1527 : }
1528 : }
1529 7110292 : else if ( hPrivateData->igfInfo.bitRateIndex != IGF_BITRATE_SWB_48000_CPE && hPrivateData->igfInfo.bitRateIndex != IGF_BITRATE_FB_48000_CPE )
1530 : {
1531 4469764 : IGF_write_bits( hBstr, pBitOffset, 0, 1 );
1532 : }
1533 : }
1534 :
1535 17117360 : totBitCount = *pBitOffset - startBitCount;
1536 :
1537 17117360 : return totBitCount;
1538 : }
1539 :
1540 :
1541 : /*-------------------------------------------------------------------*
1542 : * IGF_WriteFlatteningTrigger()
1543 : *
1544 : * write flattening trigger
1545 : *-------------------------------------------------------------------*/
1546 :
1547 : /*! r: number of bits written */
1548 17117360 : static int16_t IGF_WriteFlatteningTrigger(
1549 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
1550 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1551 : int16_t *pBitOffset /* i : ptr to bitOffset counter */
1552 : )
1553 : {
1554 : int16_t totBitCount;
1555 : int16_t startBitCount;
1556 : int16_t flatteningTrigger;
1557 :
1558 17117360 : totBitCount = 0;
1559 17117360 : startBitCount = *pBitOffset;
1560 17117360 : flatteningTrigger = hIGFEnc->flatteningTrigger;
1561 :
1562 17117360 : IGF_write_bits( hBstr, pBitOffset, flatteningTrigger, 1 );
1563 :
1564 17117360 : totBitCount = *pBitOffset - startBitCount;
1565 :
1566 17117360 : return totBitCount;
1567 : }
1568 :
1569 :
1570 : /*-------------------------------------------------------------------*
1571 : * IGF_UpdateInfo()
1572 : *
1573 : * updates the start/stop frequency of IGF according to igfGridIdx
1574 : *-------------------------------------------------------------------*/
1575 :
1576 17453326 : static void IGF_UpdateInfo(
1577 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
1578 : const int16_t igfGridIdx /* i : IGF grid index */
1579 : )
1580 : {
1581 : H_IGF_GRID hGrid;
1582 :
1583 17453326 : hGrid = &hIGFEnc->igfData.igfInfo.grid[igfGridIdx];
1584 17453326 : hIGFEnc->infoStartFrequency = hGrid->startFrequency;
1585 17453326 : hIGFEnc->infoStopFrequency = hGrid->stopFrequency;
1586 17453326 : hIGFEnc->infoStartLine = hGrid->startLine;
1587 17453326 : hIGFEnc->infoStopLine = hGrid->stopLine;
1588 :
1589 17453326 : return;
1590 : }
1591 :
1592 :
1593 : /*-------------------------------------------------------------------*
1594 : * IGFEncWriteBitstream()
1595 : *
1596 : * IGF bitstream writer
1597 : *-------------------------------------------------------------------*/
1598 :
1599 : /*! r: number of bits written per frame */
1600 17117360 : int16_t IGFEncWriteBitstream(
1601 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
1602 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
1603 : int16_t *pBitOffset, /* i : ptr to bitOffset counter */
1604 : const int16_t igfGridIdx, /* i : igf grid index see declaration of IGF_GRID_IDX for details */
1605 : const int16_t isIndepFlag /* i : if 1 frame is independent, 0 = frame is coded with data from previous frame */
1606 : )
1607 : {
1608 : int16_t igfAllZero;
1609 17117360 : int16_t startBitCount = *pBitOffset;
1610 :
1611 17117360 : hIGFEnc->infoTotalBitsPerFrameWritten = 0;
1612 17117360 : if ( isIndepFlag )
1613 : {
1614 16949377 : hIGFEnc->infoTotalBitsWritten = 0;
1615 : }
1616 :
1617 17117360 : IGF_WriteEnvelope( hIGFEnc, hBstr, pBitOffset, igfGridIdx, isIndepFlag, &igfAllZero );
1618 :
1619 17117360 : IGF_WriteWhiteningLevels( hIGFEnc, hBstr, pBitOffset, igfGridIdx, isIndepFlag );
1620 :
1621 17117360 : IGF_WriteFlatteningTrigger( hIGFEnc, hBstr, pBitOffset );
1622 :
1623 17117360 : hIGFEnc->infoTotalBitsPerFrameWritten = ( *pBitOffset - startBitCount );
1624 17117360 : hIGFEnc->infoTotalBitsWritten += hIGFEnc->infoTotalBitsPerFrameWritten;
1625 :
1626 17117360 : return hIGFEnc->infoTotalBitsPerFrameWritten;
1627 : }
1628 :
1629 :
1630 : /*-------------------------------------------------------------------*
1631 : * IGFEncSetMode()
1632 : *
1633 : * sets the IGF mode according to given bitrate
1634 : *-------------------------------------------------------------------*/
1635 :
1636 529216 : void IGFEncSetMode(
1637 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i/o: instance handle of IGF Encoder */
1638 : const int32_t total_brate, /* i : encoder total bitrate */
1639 : const int16_t bwidth, /* i : encoder audio bandwidth */
1640 : const int16_t element_mode, /* i : IVAS element mode */
1641 : const int16_t rf_mode /* i : flag to signal the RF mode */
1642 : )
1643 : {
1644 : int16_t i;
1645 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1646 :
1647 529216 : hPrivateData = &hIGFEnc->igfData;
1648 529216 : hPrivateData->igfBitstreamBits = 0;
1649 529216 : set_s( hPrivateData->igfScfQuantized, 0, IGF_MAX_SFB );
1650 529216 : set_s( hPrivateData->igfCurrWhiteningLevel, 0, IGF_MAX_TILES );
1651 529216 : set_s( hPrivateData->igfPrevWhiteningLevel, 0, IGF_MAX_TILES );
1652 529216 : set_s( hPrivateData->igfWhiteningHangoverCnt, 0, IGF_MAX_TILES );
1653 :
1654 5821376 : for ( i = 0; i < IGF_MAX_TILES; i++ )
1655 : {
1656 5292160 : set_f( hPrivateData->igfPastSFM[i], -1.f, IGF_PAST_SFM_LEN );
1657 : }
1658 :
1659 529216 : hPrivateData->igfPastSFM_pos = 0;
1660 :
1661 169878336 : for ( i = 0; i < IGF_BITBUFSIZE / 8; i++ )
1662 : {
1663 169349120 : hPrivateData->igfBitstream[i] = 0;
1664 : }
1665 :
1666 529216 : hPrivateData->wasTransient = 0;
1667 529216 : set_f( hPrivateData->prevSFM_FIR, 0, IGF_MAX_TILES );
1668 529216 : set_f( hPrivateData->prevSFM_IIR, 0, IGF_MAX_TILES );
1669 529216 : set_s( hPrivateData->dampingFactorSmoothing, 2, IGF_MAX_SFB );
1670 529216 : set_f( hPrivateData->prevSFM_FIR_SFB_SB, 0, IGF_MAX_SFB );
1671 529216 : set_f( hPrivateData->prevSFM_IIR_SFB_SB, 0, IGF_MAX_SFB );
1672 529216 : set_f( hPrivateData->prevSFM_FIR_SFB_TB, 0, IGF_MAX_SFB );
1673 529216 : set_f( hPrivateData->prevSFM_IIR_SFB_TB, 0, IGF_MAX_SFB );
1674 529216 : set_f( hPrivateData->prevDampingFactor_IIR, -1, IGF_MAX_SFB );
1675 529216 : set_s( hPrivateData->logSpec, 0, L_FRAME_PLUS );
1676 529216 : set_f( hPrivateData->SFM_sb, 0.f, IGF_MAX_SFB );
1677 529216 : set_f( hPrivateData->SFM_tb, 0.f, IGF_MAX_SFB );
1678 :
1679 529216 : if ( IGFCommonFuncsIGFConfiguration( total_brate, bwidth, element_mode, &hPrivateData->igfInfo, rf_mode ) )
1680 : {
1681 529062 : IGFSCFEncoderOpen( &hPrivateData->hIGFSCFArithEnc, &hPrivateData->igfInfo, total_brate, bwidth, element_mode, rf_mode );
1682 :
1683 529062 : hIGFEnc->infoSamplingRate = hPrivateData->igfInfo.sampleRate;
1684 529062 : hIGFEnc->infoStartFrequency = hPrivateData->igfInfo.grid[0].startFrequency;
1685 529062 : hIGFEnc->infoStopFrequency = hPrivateData->igfInfo.grid[0].stopFrequency;
1686 529062 : hIGFEnc->infoStartLine = hPrivateData->igfInfo.grid[0].startLine;
1687 529062 : hIGFEnc->infoStopLine = hPrivateData->igfInfo.grid[0].stopLine;
1688 : }
1689 : else
1690 : {
1691 : /* IGF configuration failed -> error! */
1692 154 : hIGFEnc->infoSamplingRate = 0;
1693 154 : hIGFEnc->infoStartFrequency = -1;
1694 154 : hIGFEnc->infoStopFrequency = -1;
1695 154 : hIGFEnc->infoStartLine = -1;
1696 154 : hIGFEnc->infoStopLine = -1;
1697 154 : IVAS_ERROR( IVAS_ERR_INTERNAL, "IGFEncSetMode: initialization error!" );
1698 : }
1699 :
1700 : /* reset remaining variables */
1701 529216 : hIGFEnc->infoTotalBitsWritten = 0;
1702 529216 : hIGFEnc->infoTotalBitsPerFrameWritten = 0;
1703 529216 : hIGFEnc->flatteningTrigger = 0;
1704 529216 : hIGFEnc->tns_predictionGain = 0;
1705 529216 : set_f( hIGFEnc->spec_be_igf, 0, N_MAX_TCX - IGF_START_MN );
1706 :
1707 529216 : return;
1708 : }
1709 :
1710 :
1711 : /*-------------------------------------------------------------------*
1712 : * pack_bit()
1713 : *
1714 : * insert a bit into packed octet
1715 : *-------------------------------------------------------------------*/
1716 :
1717 8357476 : static void pack_bit(
1718 : const int16_t bit, /* i : bit to be packed */
1719 : uint8_t **pt, /* i/o: pointer to octet array into which bit will be placed */
1720 : uint8_t *omask /* i/o: output mask to indicate where in the octet the bit is to be written */
1721 : )
1722 : {
1723 8357476 : if ( *omask == 0x80 )
1724 : {
1725 1118462 : **pt = 0;
1726 : }
1727 :
1728 8357476 : if ( bit != 0 )
1729 : {
1730 4379979 : **pt = **pt | *omask;
1731 : }
1732 :
1733 8357476 : *omask >>= 1;
1734 8357476 : if ( *omask == 0 )
1735 : {
1736 971696 : *omask = 0x80;
1737 971696 : ( *pt )++;
1738 : }
1739 :
1740 8357476 : return;
1741 : }
1742 :
1743 :
1744 : /*-------------------------------------------------------------------*
1745 : * IGFEncConcatenateBitstream()
1746 : *
1747 : * IGF bitstream concatenation for TCX10 modes
1748 : *-------------------------------------------------------------------*/
1749 :
1750 335966 : void IGFEncConcatenateBitstream(
1751 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
1752 : const int16_t bsBits, /* i : number of IGF bits written to list of indices */
1753 : BSTR_ENC_HANDLE hBstr /* i/o: bitstream handle */
1754 : )
1755 : {
1756 : int16_t i;
1757 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1758 : Indice *ind_list;
1759 : uint8_t *pFrame; /* byte array with bit packet and byte aligned coded speech data */
1760 : int16_t *pFrame_size; /* number of bits in the binary encoded access unit [bits] */
1761 : int16_t k, nb_bits_written;
1762 : int32_t imask;
1763 : uint8_t omask;
1764 :
1765 335966 : hPrivateData = &hIGFEnc->igfData;
1766 :
1767 335966 : ind_list = &hBstr->ind_list[hBstr->nb_ind_tot - bsBits]; /* here, we assume that each bit has been written as a single indice */
1768 335966 : pFrame = hPrivateData->igfBitstream;
1769 335966 : pFrame_size = &hPrivateData->igfBitstreamBits;
1770 335966 : nb_bits_written = 0;
1771 :
1772 335966 : omask = ( 0x80 >> ( *pFrame_size & 0x7 ) );
1773 335966 : pFrame += *pFrame_size >> 3;
1774 :
1775 : /* bitstream packing (conversion of individual indices into a serial stream) */
1776 8693442 : for ( i = 0; i < bsBits; i++ )
1777 : {
1778 8357476 : if ( ind_list[i].nb_bits > 0 )
1779 : {
1780 : /* mask from MSB to LSB */
1781 8357476 : imask = 1 << ( ind_list[i].nb_bits - 1 );
1782 :
1783 : /* write bit by bit */
1784 16714952 : for ( k = 0; k < ind_list[i].nb_bits; k++ )
1785 : {
1786 8357476 : pack_bit( ind_list[i].value & imask, &pFrame, &omask );
1787 8357476 : imask >>= 1;
1788 : }
1789 8357476 : nb_bits_written += ind_list[i].nb_bits;
1790 :
1791 : /* delete the indice */
1792 8357476 : ind_list[i].nb_bits = -1;
1793 : }
1794 : }
1795 :
1796 335966 : *pFrame_size += nb_bits_written;
1797 :
1798 : /* update list of indices */
1799 335966 : hBstr->nb_ind_tot -= bsBits;
1800 335966 : hBstr->nb_bits_tot -= nb_bits_written;
1801 :
1802 335966 : return;
1803 : }
1804 :
1805 :
1806 : /*-------------------------------------------------------------------*
1807 : * IGFEncResetTCX10BitCounter()
1808 : *
1809 : * IGF reset bitstream bit counter for TCX10 modes
1810 : *-------------------------------------------------------------------*/
1811 :
1812 167983 : void IGFEncResetTCX10BitCounter(
1813 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc /* i : instance handle of IGF Encoder */
1814 : )
1815 : {
1816 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1817 :
1818 167983 : hPrivateData = &hIGFEnc->igfData;
1819 167983 : hPrivateData->igfBitstreamBits = 0;
1820 167983 : hIGFEnc->infoTotalBitsWritten = 0;
1821 :
1822 167983 : return;
1823 : }
1824 :
1825 :
1826 : /*-------------------------------------------------------------------*
1827 : * IGFEncWriteConcatenatedBitstream()
1828 : *
1829 : *
1830 : *-------------------------------------------------------------------*/
1831 :
1832 : /*! r: total number of bits written */
1833 167983 : int16_t IGFEncWriteConcatenatedBitstream(
1834 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i : instance handle of IGF Encoder */
1835 : BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */
1836 : )
1837 : {
1838 : IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData;
1839 : int16_t i;
1840 : int16_t bitsLeft;
1841 : UWord8 *pBitstream;
1842 :
1843 167983 : hPrivateData = &hIGFEnc->igfData;
1844 167983 : pBitstream = hPrivateData->igfBitstream;
1845 :
1846 1139679 : for ( i = 0; i < ( hPrivateData->igfBitstreamBits >> 3 ); i++ )
1847 : {
1848 971696 : push_next_indice( hBstr, pBitstream[i], 8 );
1849 : }
1850 :
1851 167983 : bitsLeft = hPrivateData->igfBitstreamBits & 0x7;
1852 167983 : if ( bitsLeft > 0 )
1853 : {
1854 146766 : push_next_indice( hBstr, pBitstream[i] >> ( 8 - bitsLeft ), bitsLeft );
1855 : }
1856 :
1857 167983 : return hIGFEnc->infoTotalBitsWritten;
1858 : }
1859 :
1860 :
1861 : /*-------------------------------------------------------------------*
1862 : * IGFEncApplyMono()
1863 : *
1864 : * apply the IGF encoder, main encoder interface
1865 : *-------------------------------------------------------------------*/
1866 :
1867 6907205 : void IGFEncApplyMono(
1868 : Encoder_State *st, /* i : Encoder state */
1869 : const int16_t igfGridIdx, /* i : IGF grid index */
1870 : float *pMDCTSpectrum, /* i/o: MDCT spectrum */
1871 : float *pPowerSpectrum, /* i/o: MDCT^2 + MDST^2 spectrum, or estimate */
1872 : const int16_t isTCX20, /* i : flag indicating if the input is TCX20 or TCX10/2xTCX5 */
1873 : const int16_t isTNSActive, /* i : flag indicating if the TNS is active */
1874 : const int16_t sp_aud_decision0, /* i : first stage switching decision */
1875 : const int16_t vad_hover_flag /* i : VAD hangover flag */
1876 : )
1877 : {
1878 : float *pPowerSpectrumParameter; /* If it is NULL it informs a function that specific handling is needed */
1879 6907205 : float att = 1.0f;
1880 : int16_t last_core_acelp;
1881 :
1882 6907205 : last_core_acelp = ( st->last_core == ACELP_CORE );
1883 :
1884 6907205 : pPowerSpectrumParameter = !isTNSActive && isTCX20 ? pPowerSpectrum : NULL;
1885 :
1886 6907205 : IGF_UpdateInfo( st->hIGFEnc, igfGridIdx );
1887 :
1888 6907205 : if ( st->element_mode == IVAS_CPE_DFT || st->element_mode == IVAS_CPE_TD )
1889 : {
1890 294833 : calculate_hangover_attenuation_gain( st, &att, vad_hover_flag );
1891 : }
1892 :
1893 :
1894 6907205 : IGF_CalculateEnvelope( st->hIGFEnc, pMDCTSpectrum, pPowerSpectrumParameter, igfGridIdx, st->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp, st->element_mode, att );
1895 :
1896 6907205 : pPowerSpectrumParameter = isTCX20 ? pPowerSpectrum : NULL;
1897 :
1898 6907205 : IGF_Whitening( st->hIGFEnc, pPowerSpectrumParameter, igfGridIdx, st->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp, isTNSActive, sp_aud_decision0, ( st->element_mode == IVAS_CPE_MDCT ? st->element_brate : st->total_brate ), st->element_mode );
1899 :
1900 6907205 : IGF_ErodeSpectrum( st->hIGFEnc, pMDCTSpectrum, pPowerSpectrumParameter, igfGridIdx, 0 );
1901 :
1902 6907205 : return;
1903 : }
1904 :
1905 :
1906 : /*-------------------------------------------------------------------*
1907 : * IGFEncApplyStereo()
1908 : *
1909 : * apply the IGF encoder, main encoder interface
1910 : *-------------------------------------------------------------------*/
1911 :
1912 909729 : void IGFEncApplyStereo(
1913 : STEREO_MDCT_ENC_DATA_HANDLE hStereoMdct, /* i/o: MDCT stereo encoder structure */
1914 : int16_t ms_mask[2][MAX_SFB], /* i : bandwise MS mask */
1915 : const IGF_ENC_INSTANCE_HANDLE hIGFEnc[CPE_CHANNELS], /* i : instance handle of IGF Encoder */
1916 : const int16_t igfGridIdx, /* i : IGF grid index */
1917 : Encoder_State *sts[CPE_CHANNELS], /* i : Encoder state */
1918 : float *pPowerSpectrum[CPE_CHANNELS], /* i/o: MDCT^2 + MDST^2 spectrum, or estimate */
1919 : float *pPowerSpectrumMsInv[CPE_CHANNELS][NB_DIV], /* i/o: inverse power spectrum */
1920 : float *inv_spectrum[CPE_CHANNELS][NB_DIV], /* i : inverse spectrum */
1921 : const int16_t frameno, /* i : flag indicating index of current subfr. */
1922 : const int16_t sp_aud_decision0, /* i : sp_aud_decision0 */
1923 : const int32_t element_brate, /* i : element bitrate */
1924 : const int16_t mct_on /* i : flag mct block (1) or stereo (0) */
1925 : )
1926 : {
1927 : float *pPowerSpectrumParameter[NB_DIV]; /* If it is NULL it informs a function that specific handling is needed */
1928 : float *pPowerSpectrumParameterMsInv[NB_DIV];
1929 : int16_t coreMsMask[N_MAX];
1930 : int16_t sfb, ch, last_core_acelp;
1931 : STEREO_MDCT_BAND_PARAMETERS *sfbConf;
1932 :
1933 : /* assumptions: stereo filling was already done on the flattened spectra
1934 : * IGF region is always coded M/S, never L/R (to be done in the encoder)
1935 : * for residual bands with stereo filling infoTcxNoise is set to zero
1936 : * both channels have the same IGF configuration
1937 : */
1938 :
1939 : /* sanity checks: check if both channels have the same configuration...*/
1940 909729 : assert( ( sts[0]->core == sts[1]->core ) );
1941 :
1942 : /* initialization */
1943 909729 : sfbConf = ( sts[0]->core == TCX_20_CORE ) ? &hStereoMdct->stbParamsTCX20 : &hStereoMdct->stbParamsTCX10;
1944 909729 : if ( sts[0]->last_core == ACELP_CORE )
1945 : {
1946 0 : sfbConf = &hStereoMdct->stbParamsTCX20afterACELP;
1947 : }
1948 :
1949 : /* create line wise ms mask for the core bands */
1950 909729 : set_s( coreMsMask, 0, N_MAX );
1951 38631372 : for ( sfb = 0; sfb < sfbConf->sfbCnt; sfb++ )
1952 : {
1953 37721643 : set_s( &coreMsMask[sfbConf->sfbOffset[sfb]], ms_mask[frameno][sfb], sfbConf->sfbOffset[sfb + 1] - sfbConf->sfbOffset[sfb] );
1954 : }
1955 :
1956 909729 : if ( sts[0]->core == TCX_20_CORE && !sts[0]->hTcxEnc->fUseTns[frameno] && !sts[1]->hTcxEnc->fUseTns[frameno] )
1957 : {
1958 761741 : pPowerSpectrumParameter[0] = &pPowerSpectrum[0][0];
1959 761741 : pPowerSpectrumParameter[1] = &pPowerSpectrum[1][0];
1960 761741 : pPowerSpectrumParameterMsInv[0] = pPowerSpectrumMsInv[0][0];
1961 761741 : pPowerSpectrumParameterMsInv[1] = pPowerSpectrumMsInv[1][0];
1962 : }
1963 : else
1964 : {
1965 147988 : pPowerSpectrumParameter[0] = NULL;
1966 147988 : pPowerSpectrumParameter[1] = NULL;
1967 147988 : pPowerSpectrumParameterMsInv[0] = NULL;
1968 147988 : pPowerSpectrumParameterMsInv[1] = NULL;
1969 : }
1970 :
1971 2729187 : for ( ch = 0; ch < CPE_CHANNELS; ch++ )
1972 : {
1973 1819458 : last_core_acelp = ( sts[ch]->last_core == ACELP_CORE );
1974 :
1975 1819458 : IGF_UpdateInfo( hIGFEnc[ch], igfGridIdx );
1976 :
1977 1819458 : IGF_CalculateStereoEnvelope( hIGFEnc[ch], sts[ch]->hTcxEnc->spectrum[frameno], inv_spectrum[ch][frameno], pPowerSpectrumParameter[ch], pPowerSpectrumParameterMsInv[ch], igfGridIdx, coreMsMask, sts[ch]->hTranDet->transientDetector.bIsAttackPresent, last_core_acelp );
1978 :
1979 1819458 : pPowerSpectrumParameter[ch] = sts[ch]->core == TCX_20_CORE ? pPowerSpectrum[ch] : NULL;
1980 :
1981 1819458 : IGF_Whitening( hIGFEnc[ch], pPowerSpectrumParameter[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 );
1982 :
1983 1819458 : IGF_ErodeSpectrum( hIGFEnc[ch], sts[ch]->hTcxEnc->spectrum[frameno], pPowerSpectrumParameter[ch], igfGridIdx, mct_on );
1984 : }
1985 :
1986 909729 : return;
1987 : }
1988 :
1989 :
1990 : /*-------------------------------------------------------------------*
1991 : * IGFSaveSpectrumForITF()
1992 : *
1993 : *
1994 : *-------------------------------------------------------------------*/
1995 :
1996 8726663 : void IGFSaveSpectrumForITF(
1997 : IGF_ENC_INSTANCE_HANDLE hIGFEnc, /* i/o: instance handle of IGF Encoder */
1998 : const int16_t igfGridIdx, /* i : IGF grid index */
1999 : const float *pITFSpectrum /* i : MDCT spectrum */
2000 : )
2001 : {
2002 8726663 : IGF_UpdateInfo( hIGFEnc, igfGridIdx );
2003 :
2004 8726663 : mvr2r( pITFSpectrum + IGF_START_MN, hIGFEnc->spec_be_igf, hIGFEnc->infoStopLine - IGF_START_MN );
2005 :
2006 8726663 : return;
2007 : }
2008 :
2009 :
2010 298280 : ivas_error IGF_Reconfig(
2011 : IGF_ENC_INSTANCE_HANDLE *hIGFEnc, /* i/o: instance handle of IGF Encoder */
2012 : const int16_t igf, /* i : IGF on/off */
2013 : const int16_t reset, /* i : reset flag */
2014 : const int32_t brate, /* i : bitrate for configuration */
2015 : const int16_t bwidth, /* i : signal bandwidth */
2016 : const int16_t element_mode, /* i : IVAS element mode */
2017 : const int16_t rf_mode /* i : flag to signal the RF mode */
2018 : )
2019 : {
2020 : ivas_error error;
2021 :
2022 298280 : error = IVAS_ERR_OK;
2023 :
2024 298280 : if ( igf && *hIGFEnc == NULL )
2025 : {
2026 24313 : if ( ( *hIGFEnc = (IGF_ENC_INSTANCE_HANDLE) malloc( sizeof( IGF_ENC_INSTANCE ) ) ) == NULL )
2027 : {
2028 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for hIGFEnc\n" ) );
2029 : }
2030 24313 : IGFEncSetMode( *hIGFEnc, brate, bwidth, element_mode, rf_mode );
2031 : }
2032 273967 : else if ( igf && reset )
2033 : {
2034 39661 : IGFEncSetMode( *hIGFEnc, brate, bwidth, element_mode, rf_mode );
2035 : }
2036 234306 : else if ( !igf && *hIGFEnc != NULL )
2037 : {
2038 29179 : free( *hIGFEnc );
2039 29179 : *hIGFEnc = NULL;
2040 : }
2041 :
2042 298280 : return error;
2043 : }
|
