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 : #include <assert.h>
34 : #include <stdint.h>
35 : #include "options.h"
36 : #include <math.h>
37 : #include "cnst.h"
38 : #include "rom_com.h"
39 : #include "rom_dec.h"
40 : #include "prot.h"
41 : #include "ivas_prot.h"
42 : #include "ivas_cnst.h"
43 : #include "ivas_rom_com.h"
44 : #include "ivas_rom_dec.h"
45 : #ifdef DEBUGGING
46 : #include "debug.h"
47 : #endif
48 : #include "wmc_auto.h"
49 :
50 :
51 : /*-------------------------------------------------------------------*
52 : * Local constants
53 : *-------------------------------------------------------------------*/
54 :
55 : #define STEFI_DELAY_IND( d, buf_ind ) ( ( buf_ind ) + STEREO_DFT_PAST_MAX - ( d ) + 1 ) % STEREO_DFT_PAST_MAX
56 :
57 : #define STEREO_DFT_RES_RATIO_LIMIT 0.18f
58 : #define STEREO_DFT_LT_PREDGAIN_UPD 0.1f
59 : #define STEREO_DFT_VR_PREDGAIN_UPD 0.1f
60 : #define STEREO_DFT_STEFFI_PG_THRESHOLD 0.6f
61 : #define STEREO_DFT_STEFFI_RATIO_UP_HIGH 0.03f
62 : #define STEREO_DFT_STEFFI_RATIO_DOWN_HIGH 0.05f
63 : #define STEREO_DFT_STEFFI_RATIO_UP_LOW 0.1f
64 : #define STEREO_DFT_STEFFI_RATIO_DOWN_LOW 0.001f
65 : #define STEREO_DFT_STEFFI_DELAY_SHORT 2
66 : #define STEREO_DFT_STEFFI_DELAY_LONG 4
67 : #define STEREO_DFT_STEFFI_DELAY_OFFSET 2
68 : #define STEREO_DFT_STEFFI_GAIN_REST_AMT 0.6f
69 : #define STEREO_DFT_STEFFI_GAIN_AMP 1.0f
70 :
71 :
72 : #define STEREO_DFT_BPF_SIZE 40 /* BPF: Number of weights for BPF in DFT: 40*40Hz=1.6kHz*/
73 :
74 :
75 : /*-------------------------------------------------------------------------
76 : * Local function prototypes
77 : *-------------------------------------------------------------------------*/
78 :
79 : static void stereo_dft_dec_open( STEREO_DFT_DEC_DATA_HANDLE hStereoDft, const int32_t output_Fs, const int16_t nchan_transport );
80 :
81 : static void stereo_dft_compute_td_stefi_params( STEREO_DFT_DEC_DATA_HANDLE hStereoDft, const float samp_ratio );
82 :
83 : static void stereo_dft_adapt_sf_delay( STEREO_DFT_DEC_DATA_HANDLE hStereoDft, float *pPredGain );
84 :
85 :
86 : /*-------------------------------------------------------------------------
87 : * stereo_dft_dequantize_res_gains()
88 : *
89 : * joint dequantizer for side channel prediction gain and residual energy
90 : *-------------------------------------------------------------------------*/
91 :
92 19994022 : static void stereo_dft_dequantize_res_gains(
93 : int16_t *ind1,
94 : int16_t *ind2,
95 : float *gout,
96 : float *rout,
97 : const int16_t N )
98 : {
99 : int16_t i, index;
100 :
101 39988044 : for ( i = 0; i < N; i++ )
102 : {
103 : /* Ensure the indices are within range -- may go out of range due to frame loss */
104 19994022 : ind1[i] = check_bounds_s( ind1[i], 0, 30 );
105 19994022 : ind2[i] = check_bounds_s( ind2[i], 0, 7 );
106 19994022 : index = ( ( ind1[i] < 15 ? 15 - ind1[i] : ind1[i] - 15 ) << 3 ) + ind2[i];
107 19994022 : gout[i] = ind1[i] < 15 ? -dft_res_gains_q[index][0] : dft_res_gains_q[index][0];
108 19994022 : rout[i] = dft_res_gains_q[index][1];
109 : }
110 :
111 19994022 : return;
112 : }
113 :
114 : /*---------------------------------------------------------------------------
115 : * stereo_dft_dequantize_res_gains_f()
116 : *
117 : * returns interepolated values for non-integer indices
118 : *---------------------------------------------------------------------------*/
119 :
120 13466273 : static void stereo_dft_dequantize_res_gains_f(
121 : float *ind1,
122 : float *ind2,
123 : float *gout,
124 : float *rout,
125 : const int16_t N )
126 : {
127 : int16_t i, i1, j1, sign, ji, ij;
128 : float fi, fj;
129 :
130 26932546 : for ( i = 0; i < N; i++ )
131 : {
132 : /* Ensure the indices are within range -- may go out of range due to frame loss */
133 13466273 : ind1[i] = check_bounds( ind1[i], 0, 31 );
134 13466273 : ind2[i] = check_bounds( ind2[i], 0, 7 );
135 :
136 : /* compensate for the offset and extract/remove sign of first index */
137 13466273 : sign = ind1[i] < 15 ? -1 : 1;
138 13466273 : i1 = (int16_t) floorf( ind1[i] < 15 ? 15 - ind1[i] : ind1[i] - 15 );
139 13466273 : fi = ( ind1[i] < 15 ? 15 - ind1[i] : ind1[i] - 15 ) - i1;
140 :
141 13466273 : j1 = (int16_t) floorf( ind2[i] );
142 13466273 : fj = ind2[i] - j1;
143 :
144 : /* choose base indices for interpolation */
145 13466273 : ji = min( fj < .5 ? j1 : j1 + 1, 7 );
146 13466273 : ij = min( fi < .5 ? i1 : i1 + 1, 15 );
147 :
148 : /* interpolate values from table */
149 13466273 : if ( i1 < 15 )
150 : {
151 13145493 : gout[i] = sign * ( ( 1 - fi ) * dft_res_gains_q[( i1 << 3 ) + ji][0] + fi * dft_res_gains_q[( ( i1 + 1 ) << 3 ) + ji][0] );
152 : }
153 : else
154 : {
155 320780 : gout[i] = sign * dft_res_gains_q[120 + ji][0];
156 : }
157 :
158 13466273 : if ( j1 < 7 )
159 : {
160 13462368 : rout[i] = ( 1 - fj ) * dft_res_gains_q[( ij << 3 ) + j1][1] + fj * dft_res_gains_q[( ij << 3 ) + j1 + 1][1];
161 : }
162 : else
163 : {
164 3905 : rout[i] = dft_res_gains_q[( ij << 3 ) + 7][1];
165 : }
166 : }
167 :
168 13466273 : return;
169 : }
170 :
171 :
172 : /*-------------------------------------------------------------------------
173 : * stereo_dft_dequantize_ipd()
174 : *
175 : * Dequantize IPDs
176 : *-------------------------------------------------------------------------*/
177 :
178 67631 : static void stereo_dft_dequantize_ipd(
179 : int16_t *ind,
180 : float *out,
181 : const int16_t N,
182 : const int16_t bits )
183 : {
184 : int16_t i;
185 : float delta;
186 :
187 67631 : if ( bits == 2 ) /* 2-bit phase quantization for the highest frequency band only */
188 : {
189 2346 : delta = EVS_PI / 2.f;
190 : }
191 65285 : else if ( bits == 3 )
192 : {
193 0 : delta = EVS_PI / 4.f;
194 : }
195 65285 : else if ( bits == 4 )
196 : {
197 65285 : delta = EVS_PI / 8.f;
198 : }
199 : else
200 : {
201 0 : delta = EVS_PI / 4.f;
202 0 : assert( 0 );
203 : }
204 :
205 135262 : for ( i = 0; i < N; i++ )
206 : {
207 67631 : out[i] = ind[i] * delta - EVS_PI;
208 : }
209 :
210 67631 : return;
211 : }
212 :
213 :
214 : /*-------------------------------------------------------------------------
215 : * stereo_dft_dequantize_itd()
216 : *
217 : * Dequantize ITDs
218 : *-------------------------------------------------------------------------*/
219 :
220 718550 : void stereo_dft_dequantize_itd(
221 : int16_t *ind,
222 : float *out,
223 : const int32_t output_Fs )
224 : {
225 : int16_t itd;
226 : int16_t mask;
227 :
228 718550 : mask = ( 1 << ( STEREO_DFT_ITD_NBITS - 1 ) ) - 1;
229 718550 : itd = ( ind[0] & mask ) + STEREO_DFT_ITD_MIN;
230 :
231 718550 : if ( ( ind[0] >> ( STEREO_DFT_ITD_NBITS - 1 ) ) )
232 : {
233 347550 : itd *= -1;
234 : }
235 718550 : assert( ( ABSVAL( itd ) <= STEREO_DFT_ITD_MAX ) && ( ABSVAL( itd ) >= STEREO_DFT_ITD_MIN ) );
236 :
237 : /*Convert back @ fs*/
238 718550 : *out = (float) ( itd * output_Fs ) / ( (float) ( STEREO_DFT_ITD_FS ) );
239 :
240 718550 : return;
241 : }
242 :
243 :
244 : /*-------------------------------------------------------------------------
245 : * stereo_dft_dec_create()
246 : *
247 : * Create DFT stereo handle
248 : *------------------------------------------------------------------------*/
249 :
250 67722 : ivas_error stereo_dft_dec_create(
251 : STEREO_DFT_DEC_DATA_HANDLE *hStereoDft, /* i/o: decoder DFT stereo handle */
252 : const int32_t element_brate, /* i : element bitrate */
253 : const int32_t output_Fs, /* i : output sampling rate */
254 : const int16_t sba_dirac_stereo_flag, /* i : signal stereo output for SBA DirAC */
255 : const int16_t nchan_transport /* i : number of transport channels */
256 : )
257 : {
258 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft_loc;
259 : int16_t tmpS;
260 :
261 67722 : if ( *hStereoDft != NULL )
262 : {
263 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: DFT Stereo memory already allocated\n" );
264 : }
265 :
266 67722 : if ( ( hStereoDft_loc = (STEREO_DFT_DEC_DATA_HANDLE) malloc( sizeof( STEREO_DFT_DEC_DATA ) ) ) == NULL )
267 : {
268 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DFT Stereo\n" ) );
269 : }
270 :
271 67722 : if ( ( hStereoDft_loc->hConfig = (STEREO_DFT_CONFIG_DATA_HANDLE) malloc( sizeof( STEREO_DFT_CONFIG_DATA ) ) ) == NULL )
272 : {
273 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DFT Stereo Config\n" ) );
274 : }
275 :
276 67722 : if ( ( hStereoDft_loc->hBpf = (BPF_DEC_HANDLE) malloc( sizeof( BPF_DEC_DATA ) ) ) == NULL )
277 : {
278 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for BPF handle\n" ) );
279 : }
280 :
281 67722 : if ( ( hStereoDft_loc->hTcxLtpDec = (TCX_LTP_DEC_HANDLE) malloc( sizeof( TCX_LTP_DEC_DATA ) ) ) == NULL )
282 : {
283 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for TCX-LTP handle\n" ) );
284 : }
285 :
286 67722 : hStereoDft_loc->hConfig->force_mono_transmission = 0;
287 :
288 67722 : if ( sba_dirac_stereo_flag )
289 : {
290 5650 : ivas_sba_dirac_stereo_config( hStereoDft_loc->hConfig );
291 : }
292 : else
293 : {
294 62072 : stereo_dft_config( hStereoDft_loc->hConfig, element_brate, &tmpS, &tmpS );
295 : }
296 :
297 67722 : stereo_dft_dec_open( hStereoDft_loc, output_Fs, nchan_transport );
298 :
299 67722 : *hStereoDft = hStereoDft_loc;
300 :
301 67722 : return IVAS_ERR_OK;
302 : }
303 :
304 :
305 : /*-------------------------------------------------------------------------
306 : * stereo_dft_dec_open()
307 : *
308 : * Open DFT decoder stereo handle
309 : *-------------------------------------------------------------------------*/
310 :
311 67722 : static void stereo_dft_dec_open(
312 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft, /* i/o: decoder DFT stereo handle */
313 : const int32_t output_Fs, /* i : output sampling rate */
314 : const int16_t nchan_transport /* i : number of transport channels */
315 : )
316 : {
317 : /*Sizes*/
318 67722 : hStereoDft->N = (int16_t) ( STEREO_DFT_HOP_MAX * output_Fs / 48000 );
319 :
320 : /*Init. DFT sizes*/
321 67722 : hStereoDft->NFFT = (int16_t) ( STEREO_DFT32MS_N_MAX * output_Fs / 48000 );
322 :
323 67722 : hStereoDft->dft_trigo_8k = dft_trigo_32k;
324 67722 : hStereoDft->dft_trigo_12k8 = dft_trigo_12k8;
325 67722 : hStereoDft->dft_trigo_16k = dft_trigo_32k;
326 :
327 67722 : hStereoDft->dft32ms_ovl = (int16_t) ( ( STEREO_DFT32MS_OVL_MAX * output_Fs ) / 48000 );
328 67722 : hStereoDft->win232ms_8k = dft_win232ms_8k;
329 67722 : hStereoDft->win232ms_12k8 = dft_win232ms_12k8;
330 67722 : hStereoDft->win232ms_16k = dft_win232ms_16k;
331 :
332 67722 : hStereoDft->dft32ms_ovl2 = (int16_t) ( ( STEREO_DFT32MS_OVL2_MAX * output_Fs ) / 48000 );
333 67722 : hStereoDft->win32ms_8k = dft_win232ms_8k + 1;
334 67722 : hStereoDft->win32ms_12k8 = dft_win232ms_12k8 + 1;
335 67722 : hStereoDft->win32ms_16k = dft_win232ms_16k + 1;
336 :
337 67722 : if ( output_Fs == 16000 )
338 : {
339 7555 : hStereoDft->dft_trigo = dft_trigo_32k;
340 7555 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
341 7555 : hStereoDft->win232ms = dft_win232ms_16k;
342 7555 : hStereoDft->win32ms = dft_win232ms_16k + 1;
343 : }
344 60167 : else if ( output_Fs == 32000 )
345 : {
346 12239 : hStereoDft->dft_trigo = dft_trigo_32k;
347 12239 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
348 12239 : hStereoDft->win232ms = dft_win232ms_32k;
349 12239 : hStereoDft->win32ms = dft_win232ms_32k + 1;
350 : }
351 : else
352 : {
353 47928 : assert( output_Fs == 48000 );
354 47928 : hStereoDft->dft_trigo = dft_trigo_48k;
355 47928 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_48k_STEP;
356 47928 : hStereoDft->win232ms = dft_win232ms_48k;
357 47928 : hStereoDft->win32ms = dft_win232ms_48k + 1;
358 : }
359 :
360 67722 : hStereoDft->win_8k = dft_win_8k;
361 :
362 : /*Bands: find the number of bands, Nyquist freq. is not taken into account*/
363 67722 : set_s( hStereoDft->band_res, hStereoDft->hConfig->band_res, STEREO_DFT_DEC_DFT_NB );
364 :
365 67722 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->band_res[0], hStereoDft->NFFT, DEC );
366 67722 : hStereoDft->hb_stefi_delay = NS2SA( output_Fs, STEREO_DFT_TD_STEFI_DELAY_NS );
367 :
368 67722 : if ( nchan_transport > 2 )
369 : {
370 2228 : hStereoDft->min_smooth_gains = min_smooth_gains2;
371 2228 : hStereoDft->max_smooth_gains = max_smooth_gains2;
372 : }
373 : else
374 : {
375 65494 : hStereoDft->min_smooth_gains = min_smooth_gains1;
376 65494 : hStereoDft->max_smooth_gains = max_smooth_gains1;
377 : }
378 :
379 : /* reset DFT stereo memories */
380 67722 : stereo_dft_dec_reset( hStereoDft );
381 :
382 67722 : return;
383 : }
384 :
385 :
386 : /*-------------------------------------------------------------------------
387 : * stereo_dft_dec_reset()
388 : *
389 : * Reset DFT stereo memories
390 : *------------------------------------------------------------------------*/
391 :
392 67722 : void stereo_dft_dec_reset(
393 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft /* i/o: decoder DFT stereo handle */
394 : )
395 : {
396 : int16_t i;
397 : int16_t j, b;
398 :
399 : /*Configuration*/
400 67722 : set_s( hStereoDft->prm_res, hStereoDft->hConfig->prm_res, STEREO_DFT_DEC_DFT_NB );
401 :
402 : /* SIDE_GAIN */
403 67722 : set_s( hStereoDft->side_gain_index, 15, STEREO_DFT_BAND_MAX );
404 67722 : set_s( hStereoDft->side_gain_index_previous, 15, STEREO_DFT_BAND_MAX );
405 :
406 : /*residual prediction*/
407 67722 : set_s( hStereoDft->res_pred_mode, hStereoDft->hConfig->res_pred_mode, STEREO_DFT_DEC_DFT_NB );
408 338610 : for ( i = 0; i < STEREO_DFT_PAST_MAX; i++ )
409 : {
410 270888 : set_zero( hStereoDft->DFT_past_DMX[i], STEREO_DFT32MS_N_32k );
411 270888 : set_zero( hStereoDft->past_res_pred_gain[i], STEREO_DFT_BAND_MAX );
412 : }
413 :
414 67722 : hStereoDft->past_DMX_pos = 0;
415 :
416 67722 : set_s( hStereoDft->res_pred_index_previous, 0, STEREO_DFT_BAND_MAX );
417 :
418 948108 : for ( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
419 : {
420 880386 : hStereoDft->res_gains_ind[0][i] = 15.f;
421 : }
422 :
423 67722 : set_zero( hStereoDft->res_gains_ind[1], STEREO_DFT_BAND_MAX );
424 :
425 : /*residual coding*/
426 67722 : set_s( hStereoDft->res_cod_mode, hStereoDft->hConfig->res_cod_mode, STEREO_DFT_DEC_DFT_NB );
427 67722 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->hConfig->res_cod_mode];
428 67722 : set_zero( hStereoDft->res_cod_mem, STEREO_DFT_OVL_8k );
429 :
430 67722 : hStereoDft->res_pred_band_min = max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
431 :
432 67722 : hStereoDft->stab_fac_smooth_res = 0.f;
433 67722 : bass_psfilter_init( hStereoDft->hBpf );
434 :
435 67722 : tcxltp_dec_init( hStereoDft->hTcxLtpDec, 0, MODE1, IVAS_CPE_DFT, PIT_MAX, 12800 );
436 :
437 67722 : hStereoDft->reverb_flag = 0;
438 :
439 67722 : hStereoDft->bpf_error_signal_last = 0.0f;
440 67722 : hStereoDft->bpf_error_ratio_mem = 1.0f;
441 67722 : hStereoDft->res_hb_nrg_mem = 0.0f;
442 :
443 : /*reset parameters*/
444 67722 : set_zero( hStereoDft->side_gain, STEREO_DFT_DEC_DFT_NB * STEREO_DFT_BAND_MAX );
445 67722 : set_zero( hStereoDft->gipd, STEREO_DFT_DEC_DFT_NB );
446 67722 : set_zero( hStereoDft->itd, STEREO_DFT_DEC_DFT_NB );
447 67722 : set_zero( hStereoDft->res_pred_gain, STEREO_DFT_DEC_DFT_NB * STEREO_DFT_BAND_MAX );
448 :
449 67722 : hStereoDft->wasTransient = 0;
450 67722 : hStereoDft->attackPresent = 0;
451 :
452 67722 : hStereoDft->lt_pred_gain = 0.0f;
453 67722 : hStereoDft->lt_pred_gain_variation = 0.0f;
454 67722 : hStereoDft->lt_var_mean_ratio = STEREO_DFT_RES_RATIO_LIMIT;
455 67722 : hStereoDft->stefi_short_gain = 1.0f;
456 67722 : hStereoDft->stefi_long_gain = 0.0f;
457 :
458 67722 : set_zero( hStereoDft->g_state, STEREO_DFT_BAND_MAX );
459 :
460 67722 : init_basic_allpass( &hStereoDft->ap1, dft_ap_gains[0], dft_ap_delays[0] );
461 67722 : init_basic_allpass( &hStereoDft->ap2, dft_ap_gains[1], dft_ap_delays[1] );
462 67722 : init_basic_allpass( &hStereoDft->ap3, dft_ap_gains[2], dft_ap_delays[2] );
463 :
464 67722 : set_zero( hStereoDft->ap_delay_mem, NS2SA( 16000, DELAY_BWE_TOTAL_NS ) );
465 67722 : set_zero( hStereoDft->ap_fade_mem, STEREO_DFT_ALLPASS_FADELEN_16k );
466 67722 : hStereoDft->ap_wasTransient = 0;
467 67722 : set_zero( hStereoDft->smooth_dmx_nrg, STEREO_DFT_BAND_MAX );
468 67722 : set_zero( hStereoDft->smooth_res_nrg, STEREO_DFT_BAND_MAX );
469 :
470 67722 : set_s( hStereoDft->core_hist, ACELP_CORE, STEREO_DFT_CORE_HIST_MAX );
471 :
472 67722 : set_zero( hStereoDft->hb_stefi_sig, L_FRAME48k + NS2SA( 48000, STEREO_DFT_TD_STEFI_DELAY_NS ) );
473 67722 : set_zero( hStereoDft->hb_nrg, STEREO_DFT_CORE_HIST_MAX );
474 67722 : set_zero( hStereoDft->td_gain, STEREO_DFT_CORE_HIST_MAX );
475 :
476 : /* PLC parameters */
477 67722 : set_zero( hStereoDft->res_mem, STEREO_DFT_RES_BW_MAX );
478 67722 : hStereoDft->time_offs = 0;
479 67722 : hStereoDft->past_dmx_nrg = 0;
480 67722 : hStereoDft->sg_mean = 0.0f;
481 67722 : hStereoDft->sg_mem_corrupt = 0;
482 67722 : hStereoDft->recovery_flg = 0;
483 :
484 880386 : for ( i = 0; i < SBA_DIRAC_STEREO_NUM_BANDS; i++ )
485 : {
486 812664 : set_zero( hStereoDft->smooth_buf[i], SBA_DIRAC_NRG_SMOOTH_LONG + 1 );
487 : }
488 67722 : set_zero( hStereoDft->smooth_fac[0], SBA_DIRAC_STEREO_NUM_BANDS );
489 67722 : set_zero( hStereoDft->smooth_fac[1], SBA_DIRAC_STEREO_NUM_BANDS );
490 :
491 67722 : hStereoDft->itd_xfade_target = 0.0f;
492 67722 : hStereoDft->itd_xfade_step = 0.0f;
493 67722 : hStereoDft->itd_xfade_counter = 0;
494 67722 : hStereoDft->itd_xfade_prev = 0.0f;
495 67722 : hStereoDft->last_active_element_brate = 0;
496 67722 : hStereoDft->ipd_xfade_target = 0.0f;
497 67722 : hStereoDft->ipd_xfade_step = 0.0f;
498 67722 : hStereoDft->ipd_xfade_counter = 0;
499 67722 : hStereoDft->ipd_xfade_prev = 0.0f;
500 :
501 764853 : for ( b = 0; b < hStereoDft->nbands; b++ )
502 : {
503 2091393 : for ( i = 0; i < 2; i++ )
504 : {
505 6971310 : for ( j = 0; j < 4; j++ )
506 : {
507 5577048 : hStereoDft->mixer_mat_smooth[i][j][b] = 0.0f;
508 : }
509 : }
510 : }
511 67722 : hStereoDft->first_frame = 1;
512 67722 : hStereoDft->g_L_prev = 0.f;
513 67722 : hStereoDft->g_R_prev = 0.f;
514 :
515 67722 : return;
516 : }
517 :
518 :
519 : /*-------------------------------------------------------------------------
520 : * stereo_dft_dec_update()
521 : *
522 : * Update DFT memories for new frame
523 : *-------------------------------------------------------------------------*/
524 :
525 3176412 : void stereo_dft_dec_update(
526 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft, /* i/o: decoder DFT stereo handle */
527 : const int16_t output_frame, /* i : output frame length */
528 : const int16_t sba_dirac_stereo_flag /* i : signal stereo output for SBA DirAC */
529 : )
530 : {
531 : int16_t b, i, k_offset;
532 :
533 : /* Initialization */
534 3176412 : k_offset = STEREO_DFT_OFFSET; /*Add an offset*/
535 :
536 : /* Update parameters */
537 44469768 : for ( i = 0; i < k_offset * STEREO_DFT_BAND_MAX; i++ )
538 : {
539 41293356 : hStereoDft->side_gain[i] = hStereoDft->side_gain[STEREO_DFT_NBDIV * STEREO_DFT_BAND_MAX + i];
540 41293356 : hStereoDft->res_pred_gain[i] = hStereoDft->res_pred_gain[STEREO_DFT_NBDIV * STEREO_DFT_BAND_MAX + i];
541 : }
542 :
543 6352824 : for ( i = 0; i < k_offset; i++ )
544 : {
545 3176412 : hStereoDft->gipd[i] = hStereoDft->gipd[STEREO_DFT_NBDIV + i];
546 : }
547 :
548 : /* Update configuration memories */
549 6352824 : for ( i = 0; i < k_offset; i++ )
550 : {
551 3176412 : hStereoDft->band_res[i] = hStereoDft->band_res[i + STEREO_DFT_NBDIV];
552 3176412 : hStereoDft->prm_res[i] = hStereoDft->prm_res[i + STEREO_DFT_NBDIV];
553 3176412 : hStereoDft->itd[i] = hStereoDft->itd[STEREO_DFT_NBDIV + i];
554 3176412 : hStereoDft->res_cod_mode[i] = hStereoDft->res_cod_mode[i + STEREO_DFT_NBDIV];
555 3176412 : hStereoDft->res_pred_mode[i] = hStereoDft->res_pred_mode[i + STEREO_DFT_NBDIV];
556 : }
557 :
558 : /* Load new configurations */
559 3176412 : set_s( hStereoDft->band_res + k_offset, hStereoDft->hConfig->band_res, STEREO_DFT_NBDIV );
560 3176412 : set_s( hStereoDft->prm_res + k_offset, hStereoDft->hConfig->prm_res, STEREO_DFT_NBDIV );
561 3176412 : set_s( hStereoDft->res_pred_mode + k_offset, hStereoDft->hConfig->res_pred_mode, STEREO_DFT_NBDIV );
562 3176412 : set_s( hStereoDft->res_cod_mode + k_offset, hStereoDft->hConfig->res_cod_mode, STEREO_DFT_NBDIV );
563 :
564 : /*Update attack info*/
565 3176412 : if ( hStereoDft->attackPresent )
566 : {
567 59282 : hStereoDft->wasTransient = 1;
568 : }
569 3117130 : else if ( hStereoDft->wasTransient )
570 : {
571 52000 : hStereoDft->wasTransient = 0;
572 : }
573 :
574 9529236 : for ( i = STEREO_DFT_CORE_HIST_MAX - 1; i > 0; i-- )
575 : {
576 6352824 : hStereoDft->core_hist[i] = hStereoDft->core_hist[i - 1];
577 : }
578 :
579 3176412 : mvr2r( hStereoDft->hb_stefi_sig + output_frame, hStereoDft->hb_stefi_sig, hStereoDft->hb_stefi_delay );
580 3176412 : mvr2r( hStereoDft->hb_nrg, hStereoDft->hb_nrg + 1, STEREO_DFT_CORE_HIST_MAX - 1 );
581 3176412 : mvr2r( hStereoDft->td_gain, hStereoDft->td_gain + 1, STEREO_DFT_CORE_HIST_MAX - 1 );
582 :
583 3176412 : if ( sba_dirac_stereo_flag )
584 : {
585 : /* buffer update, push back by 2 because of 2 subframes */
586 5697714 : for ( b = 0; b < hStereoDft->nbands; b++ )
587 : {
588 52009420 : for ( i = SBA_DIRAC_NRG_SMOOTH_LONG; i > 1; i-- )
589 : {
590 46808478 : hStereoDft->smooth_buf[b][i] = hStereoDft->smooth_buf[b][i - 2];
591 : }
592 : }
593 : }
594 :
595 3176412 : return;
596 : }
597 :
598 :
599 : /*-------------------------------------------------------------------------
600 : * stereo_dft_dec_destroy()
601 : *
602 : * destroy DFT stereo handle
603 : *-------------------------------------------------------------------------*/
604 :
605 67722 : void stereo_dft_dec_destroy(
606 : STEREO_DFT_DEC_DATA_HANDLE *hStereoDft_glob /* i/o: decoder DFT stereo handle */
607 : )
608 : {
609 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft;
610 :
611 67722 : hStereoDft = *hStereoDft_glob;
612 :
613 67722 : if ( hStereoDft->hConfig != NULL )
614 : {
615 67722 : free( hStereoDft->hConfig );
616 67722 : hStereoDft->hConfig = NULL;
617 : }
618 :
619 67722 : if ( hStereoDft->hBpf != NULL )
620 : {
621 67722 : free( hStereoDft->hBpf );
622 67722 : hStereoDft->hBpf = NULL;
623 : }
624 :
625 67722 : if ( hStereoDft->hTcxLtpDec != NULL )
626 : {
627 67722 : free( hStereoDft->hTcxLtpDec );
628 67722 : hStereoDft->hTcxLtpDec = NULL;
629 : }
630 :
631 67722 : free( hStereoDft );
632 67722 : hStereoDft = NULL;
633 :
634 67722 : return;
635 : }
636 :
637 :
638 : /*-------------------------------------------------------------------------
639 : * stereo_dft_dec_analyze()
640 : *
641 : * DFT analysis on a 20ms frame
642 : *-------------------------------------------------------------------------*/
643 :
644 9809639 : void stereo_dft_dec_analyze(
645 : CPE_DEC_HANDLE hCPE, /* i/o: CPE decoder structure */
646 : const float *input, /* i : input signal */
647 : float out_DFT[CPE_CHANNELS][STEREO_DFT_BUF_MAX], /* o : DFT buffers */
648 : const int16_t chan, /* i : channel number */
649 : const int16_t input_frame, /* i : input frame size */
650 : const int16_t output_frame, /* i : output frame size */
651 : const DFT_STEREO_DEC_ANA_TYPE ana_type, /* i : type of signal to analyse */
652 : const int16_t k_offset, /* i : offset of DFT */
653 : const int16_t delay /* i : delay in samples for input signal */
654 : )
655 : {
656 : int16_t i, k;
657 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft;
658 : float *pInput, *pInput_buff;
659 : float *mem, input_buff[STEREO_DFT32MS_OVL_MAX + L_FRAME48k];
660 : float DFT[STEREO_DFT32MS_N_MAX], *pDFT_out;
661 : int16_t NFFT, NFFT_core, ovl, zp;
662 : #if defined( DEBUG_MODE_DFT ) || defined( DEBUG_STEREO_DFT_NOCORE )
663 : int16_t N;
664 : #endif
665 : int16_t offset;
666 : float fac;
667 : const float *trigo, *win_left, *win_right, *win2;
668 : float trigo_dec[STEREO_DFT32MS_N_MAX / 2 + 1];
669 : int16_t trigo_step;
670 : int32_t inputFs;
671 : int16_t delay_dec;
672 : int16_t mem_size;
673 : int16_t ovl2;
674 :
675 9809639 : push_wmops( "DFT_analysis" );
676 :
677 9809639 : hStereoDft = hCPE->hStereoDft;
678 :
679 9809639 : assert( output_frame == STEREO_DFT_NBDIV * hStereoDft->N );
680 :
681 : /*-----------------------------------------------------------------*
682 : * Initialization
683 : *-----------------------------------------------------------------*/
684 :
685 9809639 : if ( input_frame == output_frame )
686 : {
687 3811752 : trigo = hStereoDft->dft_trigo;
688 3811752 : trigo_step = hStereoDft->dft_trigo_step * STEREO_DFT_TRIGO_DEC_STEP;
689 3811752 : win_right = hStereoDft->win32ms;
690 3811752 : win_left = hStereoDft->win32ms;
691 3811752 : win2 = hStereoDft->win232ms;
692 :
693 3811752 : if ( ana_type == DFT_STEREO_DEC_ANA_BPF )
694 : {
695 272731 : assert( ( chan == 0 ) && "DFT stereo: BPF memory only for M channel" );
696 272731 : mem = hCPE->input_mem_BPF[chan];
697 : }
698 3539021 : else if ( ana_type == DFT_STEREO_DEC_ANA_LB || ana_type == DFT_STEREO_DEC_ANA_LB_ADD )
699 : {
700 135997 : mem = hCPE->input_mem_LB[chan];
701 : }
702 : else
703 : {
704 3403024 : mem = hCPE->input_mem[chan];
705 : }
706 : }
707 5997887 : else if ( input_frame == L_FRAME )
708 : {
709 2910854 : trigo = hStereoDft->dft_trigo_12k8;
710 2910854 : trigo_step = STEREO_DFT_TRIGO_SRATE_12k8_STEP * STEREO_DFT_TRIGO_DEC_STEP;
711 2910854 : win_right = hStereoDft->win32ms_12k8;
712 2910854 : win_left = hStereoDft->win32ms_12k8;
713 2910854 : win2 = hStereoDft->win232ms_12k8;
714 :
715 2910854 : if ( ana_type == DFT_STEREO_DEC_ANA_BPF )
716 : {
717 1185312 : assert( ( chan == 0 ) && "DFT stereo: BPF memory only for M channel" );
718 1185312 : mem = hCPE->input_mem_BPF[chan];
719 : }
720 1725542 : else if ( ana_type == DFT_STEREO_DEC_ANA_LB || ana_type == DFT_STEREO_DEC_ANA_LB_ADD )
721 : {
722 901792 : mem = hCPE->input_mem_LB[chan];
723 : }
724 : else
725 : {
726 823750 : assert( ( chan == 1 ) && "12.8kHz sampling rate only for second channel, i.e. residual coding or allpass signal" );
727 823750 : mem = hCPE->input_mem[chan];
728 : }
729 : }
730 3087033 : else if ( input_frame == L_FRAME16k )
731 : {
732 2332506 : trigo = hStereoDft->dft_trigo_16k;
733 2332506 : trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP * STEREO_DFT_TRIGO_DEC_STEP;
734 2332506 : win_right = hStereoDft->win32ms_16k;
735 2332506 : win_left = hStereoDft->win32ms_16k;
736 2332506 : win2 = hStereoDft->win232ms_16k;
737 :
738 2332506 : if ( ana_type == DFT_STEREO_DEC_ANA_BPF )
739 : {
740 1162469 : assert( ( chan == 0 ) && "DFT stereo: BPF memory only for M channel" );
741 1162469 : mem = hCPE->input_mem_BPF[chan];
742 : }
743 1170037 : else if ( ana_type == DFT_STEREO_DEC_ANA_LB || ana_type == DFT_STEREO_DEC_ANA_LB_ADD )
744 : {
745 556271 : mem = hCPE->input_mem_LB[chan];
746 : }
747 : else
748 : {
749 613766 : assert( ( chan == 1 ) && hCPE->hStereoDft->hConfig->res_pred_mode == STEREO_DFT_RESPRED_ESF && "16kHz sampling rate only for second channel with allpass signal" );
750 613766 : mem = hCPE->input_mem[chan];
751 : }
752 : }
753 754527 : else if ( input_frame == L_FRAME8k )
754 : {
755 754527 : assert( ( chan == 1 ) && "DFT stereo: 8kHz analysis only for residual coding" );
756 754527 : trigo = hStereoDft->dft_trigo_8k;
757 754527 : trigo_step = STEREO_DFT_TRIGO_SRATE_8k_STEP * STEREO_DFT_TRIGO_DEC_STEP;
758 754527 : win_right = hStereoDft->win32ms_8k;
759 754527 : win_left = hStereoDft->win32ms_8k;
760 754527 : win2 = hStereoDft->win232ms_8k;
761 754527 : mem = hCPE->input_mem[chan];
762 : }
763 : else
764 : {
765 0 : IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error in DFT stereo: sampling rate not supported" );
766 0 : mem = NULL; /* to avoid compilation warning */
767 0 : trigo = NULL; /* to avoid compilation warning */
768 0 : trigo_step = -1; /* to avoid compilation warning */
769 0 : win_right = NULL; /* to avoid compilation warning */
770 0 : win_left = NULL; /* to avoid compilation warning */
771 0 : win2 = NULL; /* to avoid compilation warning */
772 : }
773 :
774 9809639 : inputFs = input_frame * FRAMES_PER_SEC;
775 9809639 : delay_dec = NS2SA( inputFs, STEREO_DFT32MS_OVL_NS );
776 9809639 : zp = NS2SA( inputFs, STEREO_DFT32MS_ZP_NS );
777 9809639 : ovl = NS2SA( inputFs, STEREO_DFT32MS_OVL_NS );
778 : #ifdef DEBUG_MODE_DFT
779 : N = NS2SA( inputFs, STEREO_DFT32MS_HOP_NS );
780 : #endif
781 9809639 : NFFT = NS2SA( inputFs, STEREO_DFT32MS_N_NS );
782 9809639 : fac = (float) ( hStereoDft->NFFT ) / (float) ( NFFT );
783 9809639 : ovl2 = NS2SA( inputFs, STEREO_DFT32MS_OVL2_NS );
784 :
785 : /* Offset for the time buffers */
786 9809639 : assert( ( delay >= -NS2SA( input_frame * FRAMES_PER_SEC, STEREO_DFT_DELAY_DEC_BWE_NS + STEREO_DFT_OVL_NS / 2 ) ) && ( delay <= NS2SA( input_frame * FRAMES_PER_SEC, STEREO_DFT_OVL_NS ) ) );
787 9809639 : mem_size = delay_dec + delay;
788 :
789 : /* Update buffers */
790 9809639 : mvr2r( mem, input_buff, mem_size );
791 9809639 : mvr2r( input, input_buff + mem_size, input_frame );
792 9809639 : mvr2r( input_buff + input_frame, mem, mem_size );
793 9809639 : pInput_buff = input_buff;
794 :
795 9809639 : if ( hCPE->nchan_out == 1 && hCPE->hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
796 : {
797 2585049 : pop_wmops();
798 2585049 : return;
799 : }
800 :
801 : #ifdef DEBUG_MODE_DFT
802 : {
803 : int16_t tmp[L_FRAME48k];
804 : char file_name[50] = { 0 };
805 : #ifdef DEBUG_STEREO_DFT_NOCORE
806 : if ( ana_type == DFT_STEREO_DEC_ANA_NOCORE && delay == 0 )
807 : {
808 : sprintf( file_name, "./res/stereo_dft_enc_M_S_%d_c%d_b0.pcm", input_frame * FRAMES_PER_SEC, chan );
809 : dbgread( tmp, sizeof( int16_t ), 2 * N, file_name );
810 : for ( i = 0; i < input_frame; i++ )
811 : {
812 : pInput_buff[mem_size + i] = (float) ( tmp[i] );
813 : }
814 : mvr2r( input_buff + input_frame, mem, mem_size );
815 : }
816 : #endif
817 : offset = 0;
818 : pInput = pInput_buff + offset;
819 : for ( i = 0; i < 2 * N; i++ )
820 : {
821 : tmp[i] = (int16_t) ( pInput[i] + 0.5f );
822 : }
823 : if ( ana_type != DFT_STEREO_DEC_ANA_BPF )
824 : {
825 : sprintf( file_name, "./res/stereo_dft_dec_M_S_c%d_%d.pcm", input_frame * FRAMES_PER_SEC, chan );
826 : }
827 : else
828 : {
829 : sprintf( file_name, "./res/stereo_dft_dec_BPF_c%d_%d.pcm", input_frame * FRAMES_PER_SEC, chan );
830 : }
831 : dbgwrite( tmp, sizeof( int16_t ), 2 * N, 1, file_name );
832 : }
833 : #endif
834 :
835 : /*-----------------------------------------------------------------*
836 : * DFT Analysis: loop over frame
837 : *-----------------------------------------------------------------*/
838 :
839 7224590 : assert( k_offset <= STEREO_DFT_NBDIV );
840 :
841 770120486 : for ( i = 0; i < NFFT / 4; i++ )
842 : {
843 762895896 : trigo_dec[i] = trigo[i * trigo_step];
844 762895896 : trigo_dec[NFFT / 2 - i] = trigo[i * trigo_step];
845 : }
846 7224590 : trigo_dec[NFFT / 4] = trigo[NFFT / 4 * trigo_step];
847 :
848 18160318 : for ( k = 0; k < STEREO_DFT_NBDIV - k_offset; k++ )
849 : {
850 10935728 : set_f( DFT, 0, STEREO_DFT32MS_N_MAX );
851 10935728 : if ( k == 0 )
852 : {
853 5507770 : offset = 0;
854 : }
855 : else
856 : {
857 : /* If OVL2 = OVL offset = 10ms */
858 5427958 : offset = NS2SA( inputFs, STEREO_DFT32MS_WIN_CENTER_NS - STEREO_DFT32MS_OVL2_NS / 2 );
859 : }
860 :
861 10935728 : pInput = pInput_buff + offset;
862 10935728 : pDFT_out = out_DFT[chan] + k * STEREO_DFT32MS_N_MAX;
863 :
864 : /*Forwards FFT: L and R*/
865 : /* Zero Padding & Flat Portion */
866 10935728 : mvr2r( pInput, DFT + zp, NFFT - 2 * zp );
867 :
868 : /* Overlapping portions */
869 10935728 : if ( k == 0 )
870 : {
871 353293515 : for ( i = 0; i < ovl; i++ )
872 : {
873 347785745 : DFT[i + zp] *= win_left[STEREO_DFT32MS_STEP * i];
874 : }
875 1048865005 : for ( i = 0; i < ovl2; i++ )
876 : {
877 1043357235 : DFT[NFFT - zp - 1 - i] *= win2[i];
878 : }
879 : }
880 : else
881 : {
882 1029277603 : for ( i = 0; i < ovl2; i++ )
883 : {
884 1023849645 : DFT[i + zp] *= win2[i];
885 : }
886 346711173 : for ( i = 0; i < ovl; i++ )
887 : {
888 341283215 : DFT[NFFT - zp - i - 1] *= win_right[STEREO_DFT32MS_STEP * i];
889 : }
890 : }
891 :
892 10935728 : rfft( DFT, trigo_dec, NFFT, -1 );
893 :
894 : /*Resampling: filtering+scaling*/
895 10935728 : if ( ana_type == DFT_STEREO_DEC_ANA_FB || ana_type == DFT_STEREO_DEC_ANA_LB || ana_type == DFT_STEREO_DEC_ANA_NOCORE )
896 : {
897 9020908 : pDFT_out[0] = DFT[0] * fac; /*DC*/
898 9020908 : if ( NFFT == hStereoDft->NFFT ) /*Nyquist*/
899 : {
900 3591040 : pDFT_out[1] = DFT[1] * fac;
901 : }
902 : else
903 : {
904 5429868 : pDFT_out[1] = 0.f;
905 : }
906 3815202644 : for ( i = 2; i < NFFT; i++ )
907 : {
908 3806181736 : pDFT_out[i] = DFT[i] * fac;
909 : }
910 2513318956 : for ( i = NFFT; i < hStereoDft->NFFT; i++ )
911 : {
912 2504298048 : pDFT_out[i] = 0.f;
913 : }
914 : }
915 1914820 : else if ( ana_type == DFT_STEREO_DEC_ANA_BPF )
916 : {
917 1833494 : pDFT_out[0] -= DFT[0] * fac * dft_bpf_weights[0];
918 :
919 73339760 : for ( i = 1; i < STEREO_DFT_BPF_SIZE; i++ )
920 : {
921 71506266 : pDFT_out[2 * i] -= DFT[2 * i] * fac * dft_bpf_weights[i];
922 71506266 : pDFT_out[2 * i + 1] -= DFT[2 * i + 1] * fac * dft_bpf_weights[i];
923 : }
924 : }
925 81326 : else if ( ana_type == DFT_STEREO_DEC_ANA_HB_ADD )
926 : {
927 6226 : NFFT_core = NS2SA( hCPE->hCoreCoder[0]->L_frame * FRAMES_PER_SEC, STEREO_DFT32MS_N_NS );
928 :
929 3398674 : for ( i = NFFT_core; i < NFFT; i++ )
930 : {
931 3392448 : pDFT_out[i] += DFT[i] * fac;
932 : }
933 : }
934 : else
935 : {
936 75100 : pDFT_out[0] += DFT[0] * fac; /*DC*/
937 75100 : if ( NFFT == hStereoDft->NFFT ) /*Nyquist*/
938 : {
939 39708 : pDFT_out[1] += DFT[1] * fac;
940 : }
941 37670372 : for ( i = 2; i < NFFT; i++ )
942 : {
943 37595272 : pDFT_out[i] += DFT[i] * fac;
944 : }
945 : }
946 : }
947 :
948 7224590 : pop_wmops();
949 7224590 : return;
950 : }
951 :
952 : /*-------------------------------------------------------------------------
953 : * stereo_dft_dec_synthesize()
954 : *
955 : * Inverse DFT on a 20ms frame
956 : *-------------------------------------------------------------------------*/
957 :
958 4408555 : void stereo_dft_dec_synthesize(
959 : CPE_DEC_HANDLE hCPE, /* i/o: CPE decoder structure */
960 : float DFT[CPE_CHANNELS][STEREO_DFT_BUF_MAX], /* i : DFT buffers */
961 : const int16_t chan, /* i : channel number */
962 : float output[L_FRAME48k], /* o : output synthesis signal */
963 : const int16_t output_frame /* i : output frame length */
964 : )
965 : {
966 : int16_t i, k;
967 : int16_t offset;
968 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft;
969 : float *p_DFT;
970 : const float *win, *win2;
971 : float trigo_dec[STEREO_DFT32MS_N_MAX / 2 + 1];
972 : int16_t trigo_step;
973 : int16_t ovl, zp, NFFT;
974 : int32_t outputFs;
975 : int16_t ovl2, flat_portion_end;
976 : float ola_buff[STEREO_DFT32MS_OVL2_MAX];
977 : int16_t moffset;
978 4408555 : push_wmops( "DFT_synthesis" );
979 :
980 : /*-----------------------------------------------------------------*
981 : * Initialization
982 : *-----------------------------------------------------------------*/
983 :
984 4408555 : hStereoDft = hCPE->hStereoDft;
985 :
986 4408555 : outputFs = output_frame * FRAMES_PER_SEC;
987 :
988 4408555 : zp = NS2SA( outputFs, STEREO_DFT32MS_ZP_NS );
989 4408555 : ovl = NS2SA( outputFs, STEREO_DFT32MS_OVL_NS );
990 4408555 : win = hStereoDft->win32ms;
991 4408555 : NFFT = NS2SA( outputFs, STEREO_DFT32MS_N_NS );
992 4408555 : ovl2 = NS2SA( outputFs, STEREO_DFT32MS_OVL2_NS );
993 4408555 : flat_portion_end = NS2SA( outputFs, STEREO_DFT32MS_WIN_CENTER_NS - STEREO_DFT32MS_OVL2_NS / 2 );
994 4408555 : win2 = hStereoDft->win232ms;
995 :
996 4408555 : p_DFT = DFT[chan];
997 4408555 : set_f( output, 0, NS2SA( outputFs, FRAME_SIZE_NS ) );
998 :
999 : /* deactivating the spectrum scrambling on active speech */
1000 4408555 : if ( ( chan == 0 && hCPE->hCoreCoder[0]->last_coder_type > UNVOICED ) || hCPE->last_element_mode == IVAS_CPE_MDCT || hCPE->last_element_mode < IVAS_CPE_DFT )
1001 : {
1002 2593089 : hCPE->stereo_switching_counter = 10;
1003 : }
1004 :
1005 4408555 : if ( hCPE->stereo_switching_counter == 0 )
1006 : {
1007 : /* Set the level of dispersion */
1008 111 : hCPE->NbFrameMod = (int16_t) ( 12.0f * max( -0.1f, min( 0.4, hCPE->lt_es_em ) ) + 1.2f + 0.5f ); /* -0.1: -0.4 ; -0.1 -> 0, 0.4 -> 6*/
1009 : }
1010 4408555 : moffset = max( 0, 6 - hCPE->NbFrameMod );
1011 :
1012 : /*-----------------------------------------------------------------*
1013 : * Synthesis
1014 : *-----------------------------------------------------------------*/
1015 :
1016 4408555 : trigo_step = hStereoDft->dft_trigo_step * STEREO_DFT_TRIGO_DEC_STEP;
1017 772672875 : for ( i = 0; i < NFFT / 4; i++ )
1018 : {
1019 768264320 : trigo_dec[i] = hStereoDft->dft_trigo[i * trigo_step];
1020 768264320 : trigo_dec[NFFT / 2 - i] = hStereoDft->dft_trigo[i * trigo_step];
1021 : }
1022 4408555 : trigo_dec[NFFT / 4] = hStereoDft->dft_trigo[NFFT / 4 * trigo_step];
1023 :
1024 13225665 : for ( k = 0; k < STEREO_DFT_NBDIV; k++ )
1025 : {
1026 : /* scrambling the spectrum */
1027 8817110 : if ( hCPE->stereo_switching_counter <= 6 && chan == 1 && ( hCPE->lt_es_em > -0.4f || hCPE->NbFrameMod > 4 ) )
1028 : {
1029 3188082 : for ( i = 3; i < NFFT - moffset - 1; i++ )
1030 : {
1031 3184572 : p_DFT[i] = -p_DFT[i + moffset + 1];
1032 : }
1033 : }
1034 8813600 : else if ( hCPE->stereo_switching_counter < 7 && ( hCPE->lt_es_em > 0.2f || hCPE->NbFrameMod > 4 ) )
1035 : {
1036 3157692 : for ( i = 16 - hCPE->NbFrameMod; i < NFFT - moffset - 1; i++ )
1037 : {
1038 3154200 : p_DFT[i - 2] = -p_DFT[i + moffset + 1];
1039 : }
1040 : }
1041 :
1042 : /*IFFT*/
1043 8817110 : rfft( p_DFT, trigo_dec, NFFT, +1 );
1044 :
1045 8817110 : if ( k == 0 )
1046 : {
1047 4408555 : offset = 0;
1048 :
1049 : /* Left OLA - 3.125ms */
1050 484573755 : for ( i = 0; i < ovl; i++ )
1051 : {
1052 480165200 : output[offset + i] = hCPE->output_mem[chan][i] + p_DFT[zp + i] * win[STEREO_DFT32MS_STEP * i];
1053 : }
1054 : /* Flat Portion */
1055 580606795 : for ( i = ovl; i < flat_portion_end; i++ )
1056 : {
1057 576198240 : output[offset + i] = p_DFT[zp + i];
1058 : }
1059 : /* Right OLA */
1060 1444904155 : for ( i = 0; i < ovl2; i++ )
1061 : {
1062 1440495600 : ola_buff[i] = win2[ovl2 - 1 - i] * p_DFT[NFFT - zp - ovl2 + i];
1063 : }
1064 : }
1065 : else
1066 : {
1067 : /* If OVL2 = OVL offset = 10ms */
1068 4408555 : offset = flat_portion_end;
1069 :
1070 : /* Left OLA */
1071 1444904155 : for ( i = 0; i < ovl2; i++ )
1072 : {
1073 1440495600 : output[offset + i] = ola_buff[i] + p_DFT[zp + i] * win2[i];
1074 : }
1075 : /* Flat Portion */
1076 580606795 : for ( i = ovl2; i < NFFT - 2 * zp - ovl; i++ )
1077 : {
1078 576198240 : output[offset + i] = p_DFT[zp + i];
1079 : }
1080 : /* Right OLA - 3.125ms */
1081 484573755 : for ( i = 0; i < ovl; i++ )
1082 : {
1083 480165200 : hCPE->output_mem[chan][i] = win[STEREO_DFT32MS_STEP * ( ovl - 1 - i )] * p_DFT[NFFT - zp - ovl + i];
1084 : }
1085 : }
1086 :
1087 8817110 : p_DFT += STEREO_DFT32MS_N_MAX;
1088 : }
1089 :
1090 : #ifdef DEBUG_MODE_DFT
1091 : {
1092 : int16_t tmp[1024];
1093 : char file_name[50] = { 0 };
1094 :
1095 : for ( i = 0; i < output_frame; i++ )
1096 : {
1097 : tmp[i] = (int16_t) ( output[i] + 0.5f );
1098 : }
1099 : sprintf( file_name, "./res/stereo_dft_ch%d_output.pcm", chan );
1100 : dbgwrite( tmp, sizeof( int16_t ), output_frame, 1, file_name );
1101 : }
1102 : #endif
1103 :
1104 4408555 : pop_wmops();
1105 4408555 : return;
1106 : }
1107 :
1108 :
1109 : /*-------------------------------------------------------------------------
1110 : * stereo_dft_dec()
1111 : *
1112 : * DFT-based stereo main processing function
1113 : *-------------------------------------------------------------------------*/
1114 :
1115 2114593 : void stereo_dft_dec(
1116 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft, /* i/o: decoder DFT stereo handle */
1117 : Decoder_State *st0, /* i/o: decoder state structure */
1118 : float DFT[CPE_CHANNELS][STEREO_DFT_BUF_MAX], /* i/o: DFT buffers */
1119 : float *input_mem, /* i/o: mem of buffer DFT analysis */
1120 : STEREO_CNG_DEC_HANDLE hStereoCng, /* i/o: Stereo CNG data structure */
1121 : const int16_t sba_dirac_stereo_flag, /* i : signal stereo output for SBA DirAC */
1122 : const int16_t sba_mono_flag, /* i : signal mono output for SBA DirAC */
1123 : ivas_spar_md_dec_state_t *hMdDec, /* i : SPAR MD handle for upmixing */
1124 : const int16_t cross_fade_start_offset, /* i : SPAR mixer delay compensation */
1125 : const int32_t output_Fs, /* i : Fs for delay calculation */
1126 : const int16_t nchan_transport, /* i : number of transpor channels */
1127 : const int16_t num_md_sub_frames /* i : number of MD subframes */
1128 : )
1129 : {
1130 : int16_t i, k, b, N_div, stop;
1131 : float DFT_L[STEREO_DFT32MS_N_MAX];
1132 : float DFT_R[STEREO_DFT32MS_N_MAX];
1133 : float DFT_PRED_RES[STEREO_DFT32MS_N_32k];
1134 : float *pDFT_DMX;
1135 : float *pDFT_DMX1;
1136 : float *pDFT_RES;
1137 : float g, tmp;
1138 : float *pPredGain;
1139 : float *pSideGain;
1140 : float c0, s0;
1141 : int16_t k_offset;
1142 : float *pgIpd;
1143 : int16_t NFFT_inner;
1144 : float gamma;
1145 : float samp_ratio;
1146 : int16_t prev_bfi;
1147 : float dmx_nrg;
1148 : int16_t idx_k0, idx_k1;
1149 : int16_t output_frame;
1150 : int16_t plocs[STEREO_DFT_RES_N_PEAKS_MAX];
1151 : int16_t num_plocs;
1152 : float plocsi[STEREO_DFT_RES_N_PEAKS_MAX];
1153 : float ftmp, N1, N2, coh;
1154 : float lev1, lev2, cna_level, scale_fact0, scale_fact, *ptr_per;
1155 2114593 : HANDLE_FD_CNG_DEC hFdCngDec = st0->hFdCngDec;
1156 2114593 : HANDLE_FD_CNG_COM hFdCngCom = hFdCngDec->hFdCngCom;
1157 2114593 : int16_t *cna_seed = &( hFdCngCom->seed );
1158 : float DFT_W, DFT_Y;
1159 :
1160 2114593 : output_frame = (int16_t) ( st0->output_Fs / FRAMES_PER_SEC );
1161 :
1162 : /*------------------------------------------------------------------*
1163 : * Initialization
1164 : *-----------------------------------------------------------------*/
1165 :
1166 2114593 : samp_ratio = (float) st0->sr_core / (float) st0->output_Fs;
1167 :
1168 2114593 : stop = STEREO_DFT32MS_N_32k / 2;
1169 :
1170 : /* Analyze nature of current frame */
1171 1986977 : hStereoDft->trans = ( ( ( st0->clas_dec == ONSET ) || ( st0->clas_dec == SIN_ONSET ) || ( st0->clas_dec == UNVOICED_CLAS ) || ( st0->clas_dec == UNVOICED_TRANSITION ) ) || ( st0->stab_fac <= 0.25f ) ) ||
1172 4101570 : ( st0->core == TCX_20_CORE && ( ( st0->hTcxCfg->tcx_last_overlap_mode == MIN_OVERLAP ) || ( st0->hTcxCfg->tcx_last_overlap_mode == HALF_OVERLAP ) ) ) || ( st0->core == TCX_10_CORE );
1173 :
1174 : #ifdef DEBUG_MODE_DFT
1175 : {
1176 : int16_t tmps;
1177 : int16_t tmp_output_frame = (int16_t) ( st0->output_Fs / FRAMES_PER_SEC );
1178 : dbgwrite( &( hStereoDft->attackPresent ), sizeof( int16_t ), 1, tmp_output_frame, "res/stereo_attack.pcm" );
1179 : dbgwrite( &( hStereoDft->trans ), sizeof( int16_t ), 1, tmp_output_frame, "res/stereo_trans.pcm" );
1180 : tmps = (int16_t) ( 100.f * ( st0->stab_fac ) + 0.5f );
1181 : dbgwrite( &tmps, sizeof( int16_t ), 1, tmp_output_frame, "res/stereo_stab.pcm" );
1182 : }
1183 : #endif
1184 :
1185 : /* Initialization */
1186 2114593 : k_offset = 1;
1187 2114593 : N_div = STEREO_DFT_NBDIV;
1188 2114593 : prev_bfi = st0->prev_old_bfi; /* The core decoding is already completed here and the prev_bfi has been updated for the next frame.
1189 : The prev_old_bfi still holds the prev_bfi for the current frame. */
1190 : /* make sure number of bands corresponds to output bwidth in case it is lower than parameter bwidth */
1191 2114593 : if ( output_frame < inner_frame_tbl[st0->bwidth] && !sba_dirac_stereo_flag )
1192 : {
1193 234550 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->band_res[k_offset], hStereoDft->NFFT, DEC );
1194 : }
1195 :
1196 2114593 : if ( !st0->bfi )
1197 : {
1198 : /* Smoothing for the current frame */
1199 2048545 : if ( sba_dirac_stereo_flag )
1200 : {
1201 475773 : ivas_sba_dirac_stereo_smooth_parameters( hStereoDft, hMdDec, cross_fade_start_offset, output_Fs, num_md_sub_frames );
1202 : }
1203 : else
1204 : {
1205 1572772 : stereo_dft_dec_smooth_parameters( hStereoDft, hStereoCng->prev_sid_nodata, hStereoCng->active_frame_counter, st0->element_brate );
1206 : }
1207 : }
1208 :
1209 2114593 : dmx_nrg = 0.0f;
1210 2114593 : if ( prev_bfi )
1211 : {
1212 65798 : dmx_nrg = stereo_dft_dmx_swb_nrg( DFT[0], DFT[0] + STEREO_DFT32MS_N_MAX, min( hStereoDft->NFFT, STEREO_DFT32MS_N_32k ) );
1213 : }
1214 :
1215 : #ifdef DEBUG_MODE_DFT
1216 : dbgwrite( hStereoDft->res_pred_gain + STEREO_DFT_BAND_MAX, sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_dec_gainPred.pcm" );
1217 : #endif
1218 :
1219 : #ifdef DEBUG_PRINT
1220 : printf( "\nframe: %d\n", frame );
1221 : #endif
1222 6343779 : for ( k = 0; k < N_div; k++ )
1223 : {
1224 4229186 : pDFT_DMX = DFT[0] + k * STEREO_DFT32MS_N_MAX;
1225 4229186 : pDFT_RES = DFT[1] + k * STEREO_DFT32MS_N_MAX;
1226 4229186 : pDFT_DMX1 = 0;
1227 4229186 : if ( nchan_transport > 1 )
1228 : {
1229 546492 : pDFT_DMX1 = DFT[1] + k * STEREO_DFT32MS_N_MAX;
1230 : }
1231 :
1232 : /*Apply Stereo*/
1233 4229186 : if ( hStereoDft->hConfig->dmx_active )
1234 : {
1235 4229186 : g = 1.f;
1236 4229186 : c0 = 1.f;
1237 4229186 : s0 = 0.f;
1238 :
1239 : /* since delay is just 3.125ms, the parameters received are used for the second window */
1240 4229186 : pSideGain = hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX;
1241 4229186 : pgIpd = hStereoDft->gipd + ( k + k_offset );
1242 4229186 : pPredGain = hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX;
1243 :
1244 : #ifdef DEBUG_PRINT
1245 : if ( k == 0 )
1246 : {
1247 : printf( "Window0\n" );
1248 : }
1249 : else
1250 : {
1251 : printf( "Window1\n" );
1252 : }
1253 : for ( b = 0; b < hStereoDft->nbands; b++ )
1254 : printf( "%.6f ", pSideGain[b] );
1255 : printf( "\n" );
1256 : for ( b = 0; b < hStereoDft->nbands; b++ )
1257 : printf( "%.6f ", pPredGain[b] );
1258 : printf( "\n" );
1259 : #endif
1260 :
1261 : /* Use coarse band partition in inactive frames */
1262 4229186 : if ( hStereoDft->frame_sid_nodata && !sba_dirac_stereo_flag )
1263 : {
1264 131490 : NFFT_inner = STEREO_DFT32MS_N_MAX * inner_frame_tbl[st0->bwidth] / L_FRAME48k;
1265 131490 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, 2, NFFT_inner, DEC );
1266 : }
1267 :
1268 :
1269 4229186 : if ( st0->bfi )
1270 : {
1271 132096 : hStereoDft->past_DMX_pos = ( hStereoDft->past_DMX_pos + STEREO_DFT_PAST_MAX - 1 ) % STEREO_DFT_PAST_MAX;
1272 : }
1273 :
1274 4229186 : if ( !( sba_dirac_stereo_flag && nchan_transport >= 2 ) )
1275 : {
1276 3682694 : stereo_dft_generate_res_pred( hStereoDft, samp_ratio, pDFT_DMX, DFT_PRED_RES, pPredGain, k, DFT[1] + k * STEREO_DFT32MS_N_MAX, &stop, st0->bfi );
1277 : }
1278 :
1279 4229186 : if ( hStereoDft->res_cod_band_max > 0 )
1280 : {
1281 1123668 : if ( !st0->bfi )
1282 : {
1283 1086612 : if ( k == 1 )
1284 : {
1285 543306 : mvr2r( pDFT_RES, hStereoDft->res_mem, 2 * hStereoDft->band_limits[hStereoDft->res_cod_band_max] );
1286 543306 : hStereoDft->time_offs = 0;
1287 : }
1288 : }
1289 : else
1290 : {
1291 37056 : stereo_dft_res_ecu( hStereoDft, pDFT_RES, DFT_PRED_RES, k, output_frame, prev_bfi, dmx_nrg, &num_plocs, plocs, plocsi, input_mem );
1292 : }
1293 : }
1294 :
1295 : #ifdef DEBUGGING
1296 : if ( dbgflag( "write_res" ) )
1297 : {
1298 : dbgwrite( pDFT_RES, sizeof( float ), 2 * hStereoDft->band_limits[hStereoDft->res_cod_band_max], 1, "dec_res.float" );
1299 : }
1300 :
1301 : if ( dbgflag( "read_res" ) )
1302 : {
1303 : dbgread( pDFT_RES, sizeof( float ), 2 * hStereoDft->band_limits[hStereoDft->res_cod_band_max], "dec_res.float" );
1304 : }
1305 : #endif
1306 : /* Apply active DMX */
1307 : /* pDFT_RES is used for the second channel in inactive frames */
1308 4229186 : if ( hStereoDft->frame_sid_nodata && !sba_dirac_stereo_flag )
1309 : {
1310 131490 : DFT_L[0] = pDFT_DMX[0];
1311 131490 : DFT_R[0] = pDFT_RES[0];
1312 : }
1313 : else
1314 : {
1315 4097696 : DFT_L[0] = pDFT_DMX[0];
1316 4097696 : DFT_R[0] = pDFT_DMX[0];
1317 : }
1318 :
1319 4229186 : if ( hStereoDft->frame_sid_nodata || st0->VAD == 0 )
1320 : {
1321 750436 : hFdCngDec->cna_nbands = 0;
1322 : }
1323 :
1324 45977820 : for ( b = 0; b < hStereoDft->nbands; b++ )
1325 : {
1326 41748634 : g = pSideGain[b];
1327 41748634 : if ( hStereoDft->frame_sid_nodata && !sba_dirac_stereo_flag )
1328 : {
1329 771448 : g = hStereoDft->g_state[b];
1330 : }
1331 :
1332 : /* store side gains from inactive frames for later use by the stereo CNA */
1333 41748634 : if ( hStereoDft->band_limits[b] < L_FRAME16k && ( hStereoDft->frame_sid_nodata || st0->VAD == 0 ) )
1334 : {
1335 7253046 : hFdCngDec->cna_nbands = b + 1;
1336 7253046 : hFdCngDec->cna_band_limits[b] = hStereoDft->band_limits[b];
1337 7253046 : hFdCngDec->cna_g_state[b] = g;
1338 : }
1339 :
1340 : #ifdef DEBUG_MODE_DFT
1341 : if ( b < hStereoDft->res_cod_band_max )
1342 : {
1343 : dbgwrite( &g, sizeof( float ), 1, 1, "./res/stereo_dft_dec_g.pcm" );
1344 : }
1345 : #endif
1346 : /* No residual coding in inactive frames, instead pDFT_RES is used for the second channel */
1347 41748634 : if ( b >= hStereoDft->res_cod_band_max && !hStereoDft->frame_sid_nodata && !( sba_dirac_stereo_flag && hMdDec ) )
1348 : {
1349 : /*filter non-coded frequencies. It removes some MDCT frequency aliasing*/
1350 995686626 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1351 : {
1352 970103694 : pDFT_RES[2 * i] = 0.f;
1353 970103694 : pDFT_RES[2 * i + 1] = 0.f;
1354 : }
1355 : }
1356 :
1357 41748634 : if ( hStereoDft->frame_sid_nodata && !sba_dirac_stereo_flag )
1358 : {
1359 : /* Low pass filter coherence */
1360 : /* store coherence from inactive frames for later use by the stereo CNA */
1361 771448 : hFdCngDec->cna_cm[b] = hStereoCng->cm[b];
1362 :
1363 : /* Calculate gamma */
1364 771448 : if ( hStereoCng->cm[b] < 0.9f )
1365 : {
1366 771292 : gamma = hStereoCng->cm[b];
1367 771292 : gamma = gamma / ( 1 - gamma );
1368 771292 : gamma = sqrtf( gamma + 1 - g * g ) - sqrtf( gamma );
1369 : }
1370 : else
1371 : {
1372 156 : gamma = 0;
1373 : }
1374 :
1375 39918038 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1376 : {
1377 : /* Create L and R signals with the correct coherence by mixing channel 0 (pDFT_DMX) and channel 1 (pDFT_RES) */
1378 39146590 : DFT_L[2 * i] = ( 1 + g ) * pDFT_DMX[2 * i] + gamma * pDFT_RES[2 * i];
1379 39146590 : DFT_R[2 * i] = ( 1 - g ) * pDFT_DMX[2 * i] - gamma * pDFT_RES[2 * i];
1380 :
1381 39146590 : DFT_L[2 * i + 1] = ( 1 + g ) * pDFT_DMX[2 * i + 1] + gamma * pDFT_RES[2 * i + 1];
1382 39146590 : DFT_R[2 * i + 1] = ( 1 - g ) * pDFT_DMX[2 * i + 1] - gamma * pDFT_RES[2 * i + 1];
1383 : }
1384 :
1385 771448 : if ( pgIpd[0] != 0.f )
1386 : {
1387 : #ifdef NONBE_FIX_NONBE_BETWEEN_OPTIMIZATION_LEVELS_2
1388 : volatile float pgIpd_tmp;
1389 :
1390 214544 : pgIpd_tmp = pgIpd[0];
1391 214544 : c0 = cosf( pgIpd_tmp );
1392 214544 : s0 = sinf( pgIpd_tmp );
1393 : #else
1394 : c0 = cosf( pgIpd[0] );
1395 : s0 = sinf( pgIpd[0] );
1396 : #endif
1397 10456650 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1398 : {
1399 : /*rotate L*/
1400 10242106 : tmp = DFT_L[2 * i] * c0 - DFT_L[2 * i + 1] * s0;
1401 10242106 : DFT_L[2 * i + 1] = DFT_L[2 * i] * s0 + DFT_L[2 * i + 1] * c0;
1402 10242106 : DFT_L[2 * i] = tmp;
1403 : }
1404 : }
1405 : }
1406 40977186 : else if ( sba_dirac_stereo_flag && hMdDec )
1407 : {
1408 :
1409 9775914 : if ( nchan_transport == 1 )
1410 : {
1411 3611976 : if ( sba_mono_flag )
1412 : {
1413 1052592 : if ( b == 0 )
1414 : {
1415 90206 : i = 0;
1416 :
1417 90206 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i];
1418 90206 : DFT_L[2 * i] = DFT_W;
1419 90206 : DFT_R[2 * i] = 0.f;
1420 :
1421 90206 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1];
1422 90206 : DFT_L[2 * i + 1] = DFT_W;
1423 90206 : DFT_R[2 * i + 1] = 0.f;
1424 : }
1425 21888722 : for ( i = hStereoDft->band_limits[b]; i < min( stop, hStereoDft->band_limits[b + 1] ); i++ )
1426 : {
1427 20836130 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i] + ( hStereoDft->mixer_mat_smooth[0][1][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][2][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][3][b + k * IVAS_MAX_NUM_BANDS] ) * DFT_PRED_RES[2 * i];
1428 20836130 : DFT_L[2 * i] = DFT_W;
1429 20836130 : DFT_R[2 * i] = 0.f;
1430 :
1431 20836130 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1] + ( hStereoDft->mixer_mat_smooth[0][1][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][2][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][3][b + k * IVAS_MAX_NUM_BANDS] ) * DFT_PRED_RES[2 * i + 1];
1432 20836130 : DFT_L[2 * i + 1] = DFT_W;
1433 20836130 : DFT_R[2 * i + 1] = 0.f;
1434 : }
1435 18644336 : for ( ; i < hStereoDft->band_limits[b + 1]; i++ )
1436 : {
1437 17591744 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i];
1438 17591744 : DFT_L[2 * i] = DFT_W;
1439 17591744 : DFT_R[2 * i] = 0.f;
1440 :
1441 17591744 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1];
1442 17591744 : DFT_L[2 * i + 1] = DFT_W;
1443 17591744 : DFT_R[2 * i + 1] = 0.f;
1444 : }
1445 : }
1446 : else
1447 : {
1448 2559384 : if ( b == 0 )
1449 : {
1450 231652 : i = 0;
1451 :
1452 231652 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i];
1453 231652 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i];
1454 :
1455 231652 : DFT_L[2 * i] = DFT_W + DFT_Y;
1456 231652 : DFT_R[2 * i] = DFT_W - DFT_Y;
1457 :
1458 231652 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1];
1459 231652 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1];
1460 :
1461 231652 : DFT_L[2 * i + 1] = DFT_W + DFT_Y;
1462 231652 : DFT_R[2 * i + 1] = DFT_W - DFT_Y;
1463 : }
1464 55609780 : for ( i = hStereoDft->band_limits[b]; i < min( stop, hStereoDft->band_limits[b + 1] ); i++ )
1465 : {
1466 53050396 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i] + ( hStereoDft->mixer_mat_smooth[0][1][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][2][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][3][b + k * IVAS_MAX_NUM_BANDS] ) * DFT_PRED_RES[2 * i];
1467 53050396 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i] + ( hStereoDft->mixer_mat_smooth[1][1][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[1][2][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[1][3][b + k * IVAS_MAX_NUM_BANDS] ) * DFT_PRED_RES[2 * i];
1468 :
1469 53050396 : DFT_L[2 * i] = DFT_W + DFT_Y;
1470 53050396 : DFT_R[2 * i] = DFT_W - DFT_Y;
1471 :
1472 53050396 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1] + ( hStereoDft->mixer_mat_smooth[0][1][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][2][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[0][3][b + k * IVAS_MAX_NUM_BANDS] ) * DFT_PRED_RES[2 * i + 1];
1473 53050396 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1] + ( hStereoDft->mixer_mat_smooth[1][1][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[1][2][b + k * IVAS_MAX_NUM_BANDS] + hStereoDft->mixer_mat_smooth[1][3][b + k * IVAS_MAX_NUM_BANDS] ) * DFT_PRED_RES[2 * i + 1];
1474 :
1475 53050396 : DFT_L[2 * i + 1] = DFT_W + DFT_Y;
1476 53050396 : DFT_R[2 * i + 1] = DFT_W - DFT_Y;
1477 : }
1478 25199896 : for ( ; i < hStereoDft->band_limits[b + 1]; i++ )
1479 : {
1480 22640512 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i];
1481 22640512 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i];
1482 :
1483 22640512 : DFT_L[2 * i] = DFT_W + DFT_Y;
1484 22640512 : DFT_R[2 * i] = DFT_W - DFT_Y;
1485 :
1486 22640512 : DFT_W = hStereoDft->mixer_mat_smooth[0][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1];
1487 22640512 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1];
1488 :
1489 22640512 : DFT_L[2 * i + 1] = DFT_W + DFT_Y;
1490 22640512 : DFT_R[2 * i + 1] = DFT_W - DFT_Y;
1491 : }
1492 : }
1493 : }
1494 6163938 : else if ( nchan_transport >= 2 )
1495 : {
1496 6163938 : if ( b == 0 )
1497 : {
1498 546492 : i = 0;
1499 :
1500 546492 : DFT_W = pDFT_DMX[2 * i];
1501 546492 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i] + pDFT_DMX1[2 * i];
1502 :
1503 546492 : DFT_L[2 * i] = DFT_W + DFT_Y;
1504 546492 : DFT_R[2 * i] = DFT_W - DFT_Y;
1505 :
1506 546492 : DFT_W = pDFT_DMX[2 * i + 1];
1507 546492 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1] + pDFT_DMX1[2 * i + 1];
1508 :
1509 546492 : DFT_L[2 * i + 1] = DFT_W + DFT_Y;
1510 546492 : DFT_R[2 * i + 1] = DFT_W - DFT_Y;
1511 : }
1512 204899046 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1513 : {
1514 198735108 : DFT_W = pDFT_DMX[2 * i];
1515 198735108 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i] + pDFT_DMX1[2 * i];
1516 :
1517 198735108 : DFT_L[2 * i] = DFT_W + DFT_Y;
1518 198735108 : DFT_R[2 * i] = DFT_W - DFT_Y;
1519 :
1520 198735108 : DFT_W = pDFT_DMX[2 * i + 1];
1521 198735108 : DFT_Y = hStereoDft->mixer_mat_smooth[1][0][b + k * IVAS_MAX_NUM_BANDS] * pDFT_DMX[2 * i + 1] + pDFT_DMX1[2 * i + 1];
1522 :
1523 198735108 : DFT_L[2 * i + 1] = DFT_W + DFT_Y;
1524 198735108 : DFT_R[2 * i + 1] = DFT_W - DFT_Y;
1525 : }
1526 : }
1527 : else
1528 : {
1529 : assert( "nhcan_transport must be 1 or 1!" );
1530 : }
1531 : }
1532 : else
1533 : {
1534 706968470 : for ( i = hStereoDft->band_limits[b]; i < min( stop, hStereoDft->band_limits[b + 1] ); i++ )
1535 : {
1536 675767198 : tmp = g * pDFT_DMX[2 * i] + pDFT_RES[2 * i] + DFT_PRED_RES[2 * i];
1537 :
1538 675767198 : DFT_L[2 * i] = pDFT_DMX[2 * i] + tmp;
1539 675767198 : DFT_R[2 * i] = pDFT_DMX[2 * i] - tmp;
1540 :
1541 675767198 : tmp = g * pDFT_DMX[2 * i + 1] + pDFT_RES[2 * i + 1] + DFT_PRED_RES[2 * i + 1];
1542 :
1543 675767198 : DFT_L[2 * i + 1] = pDFT_DMX[2 * i + 1] + tmp;
1544 675767198 : DFT_R[2 * i + 1] = pDFT_DMX[2 * i + 1] - tmp;
1545 :
1546 : #ifdef DEBUG_STEREO_DFT_OUTRESPRED
1547 : DFT_L[2 * i] = DFT_PRED_RES[2 * i];
1548 : DFT_R[2 * i] = -DFT_PRED_RES[2 * i];
1549 : DFT_L[2 * i + 1] = DFT_PRED_RES[2 * i + 1];
1550 : DFT_R[2 * i + 1] = -DFT_PRED_RES[2 * i + 1];
1551 : #endif /* DEBUG_STEREO_DFT_OUTRESPRED */
1552 : }
1553 :
1554 348011128 : for ( ; i < hStereoDft->band_limits[b + 1]; i++ )
1555 : {
1556 316809856 : tmp = g * pDFT_DMX[2 * i] + pDFT_RES[2 * i];
1557 :
1558 316809856 : DFT_L[2 * i] = pDFT_DMX[2 * i] + tmp;
1559 316809856 : DFT_R[2 * i] = pDFT_DMX[2 * i] - tmp;
1560 :
1561 316809856 : tmp = g * pDFT_DMX[2 * i + 1] + pDFT_RES[2 * i + 1];
1562 :
1563 316809856 : DFT_L[2 * i + 1] = pDFT_DMX[2 * i + 1] + tmp;
1564 316809856 : DFT_R[2 * i + 1] = pDFT_DMX[2 * i + 1] - tmp;
1565 :
1566 : #ifdef DEBUG_STEREO_DFT_OUTRESPRED
1567 : DFT_L[2 * i] = 0.f;
1568 : DFT_R[2 * i] = 0.f;
1569 : DFT_L[2 * i + 1] = 0.f;
1570 : DFT_R[2 * i + 1] = 0.f;
1571 : #endif /* DEBUG_STEREO_DFT_OUTRESPRED */
1572 : }
1573 :
1574 : /* Active Upmix */
1575 31201272 : if ( pgIpd[0] != 0.f )
1576 : {
1577 : #ifdef NONBE_FIX_NONBE_BETWEEN_OPTIMIZATION_LEVELS_2
1578 : volatile float pgIpd_tmp;
1579 :
1580 4259224 : pgIpd_tmp = pgIpd[0];
1581 4259224 : c0 = cosf( pgIpd_tmp );
1582 4259224 : s0 = sinf( pgIpd_tmp );
1583 : #else
1584 : c0 = cosf( pgIpd[0] );
1585 : s0 = sinf( pgIpd[0] );
1586 : #endif
1587 136134240 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1588 : {
1589 : /*rotate L*/
1590 131875016 : tmp = DFT_L[2 * i] * c0 - DFT_L[2 * i + 1] * s0;
1591 131875016 : DFT_L[2 * i + 1] = DFT_L[2 * i] * s0 + DFT_L[2 * i + 1] * c0;
1592 131875016 : DFT_L[2 * i] = tmp;
1593 : }
1594 : }
1595 : }
1596 : }
1597 :
1598 4229186 : if ( hStereoDft->frame_sid_nodata || st0->VAD == 0 )
1599 : {
1600 750436 : hFdCngDec->cna_band_limits[hFdCngDec->cna_nbands] = hStereoDft->band_limits[hFdCngDec->cna_nbands];
1601 : }
1602 :
1603 4229186 : if ( hStereoDft->frame_sid_nodata && !sba_dirac_stereo_flag )
1604 : {
1605 131490 : hStereoCng->first_SID = 0;
1606 131490 : hStereoCng->first_SID_after_TD = 0;
1607 : }
1608 :
1609 138445506 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->NFFT / 2; i++ )
1610 : {
1611 134216320 : DFT_L[2 * i] = 0.f;
1612 134216320 : DFT_L[2 * i + 1] = 0.f;
1613 134216320 : DFT_R[2 * i] = 0.f;
1614 134216320 : DFT_R[2 * i + 1] = 0.f;
1615 : }
1616 :
1617 : /*Nyquist Freq.*/
1618 4229186 : if ( hStereoDft->band_limits[b] == hStereoDft->NFFT / 2 )
1619 : {
1620 3437418 : DFT_L[1] = pDFT_DMX[1] + g * pDFT_DMX[1];
1621 3437418 : DFT_R[1] = pDFT_DMX[1] - g * pDFT_DMX[1];
1622 3437418 : DFT_L[1] *= INV_SQRT_2;
1623 3437418 : DFT_R[1] *= INV_SQRT_2;
1624 : }
1625 : else
1626 : {
1627 791768 : DFT_L[1] = 0.f;
1628 791768 : DFT_R[1] = 0.f;
1629 : }
1630 : }
1631 : else
1632 : {
1633 0 : pPredGain = NULL; /* to avoid compilation warnings */
1634 0 : pSideGain = NULL;
1635 :
1636 : #ifndef DEBUG_STEREO_DFT_NOSTEREO
1637 : /* Dummy upmix-> mono binauralization */
1638 0 : for ( i = 0; i < hStereoDft->NFFT; i++ )
1639 : {
1640 0 : DFT_L[i] = ( pDFT_DMX[i] + pDFT_RES[i] );
1641 0 : DFT_R[i] = ( pDFT_DMX[i] - pDFT_RES[i] );
1642 : }
1643 : #else
1644 : /*Copy DMX to Left channel and reset Right channel*/
1645 : mvr2r( pDFT_DMX, DFT_L, hStereoDft->NFFT );
1646 : mvr2r( pDFT_DMX, DFT_R, hStereoDft->NFFT );
1647 : #endif
1648 : }
1649 :
1650 : /* Comfort Noise Addition */
1651 4229186 : if ( st0->flag_cna )
1652 : {
1653 3416624 : ptr_per = &hFdCngDec->smoothed_psd[hFdCngCom->startBand];
1654 :
1655 3416624 : scale_fact0 = 0.0f;
1656 3416624 : if ( hFdCngDec->cna_rescale_fact > 0 )
1657 : {
1658 2465178 : scale_fact0 = output_frame / 2 * sqrtf( hFdCngDec->cna_rescale_fact * 0.5f );
1659 : }
1660 :
1661 32203066 : for ( b = 0; b < hFdCngDec->cna_nbands; b++ )
1662 : {
1663 : /* calculate gamma factor reflecting inter-channel correlation and side gain (ILD) */
1664 28786442 : coh = hFdCngDec->cna_cm[b];
1665 28786442 : g = hFdCngDec->cna_g_state[b];
1666 :
1667 28786442 : if ( coh < 0.9f )
1668 : {
1669 23678330 : gamma = coh;
1670 23678330 : gamma = gamma / ( 1 - gamma );
1671 23678330 : gamma = sqrtf( gamma + 1 - g * g ) - sqrtf( gamma );
1672 : }
1673 : else
1674 : {
1675 5108112 : gamma = 0;
1676 : }
1677 :
1678 572029658 : for ( i = max( hFdCngDec->cna_band_limits[b], hFdCngCom->startBand / 2 ); i < min( hFdCngDec->cna_band_limits[b + 1], L_FRAME16k / 2 ); i++ )
1679 : {
1680 543243216 : lev1 = *ptr_per++;
1681 543243216 : lev2 = *ptr_per++;
1682 :
1683 543243216 : if ( lev1 > 0 && lev2 > 0 && max( lev1, lev2 ) / min( lev1, lev2 ) > 1.2f )
1684 : {
1685 : /* take the minimum of two adjacent frequency bins */
1686 31455344 : cna_level = min( lev1, lev2 );
1687 : }
1688 : else
1689 : {
1690 : /* take the average of two adjacent frequency bins */
1691 511787872 : cna_level = 0.5f * ( lev1 + lev2 );
1692 : }
1693 :
1694 543243216 : scale_fact = scale_fact0 * sqrtf( cna_level );
1695 :
1696 : /* generate comfort noise from gaussian noise and add to the decoded DFT spectrum */
1697 543243216 : N1 = scale_fact * rand_gauss( &ftmp, cna_seed );
1698 543243216 : N2 = scale_fact * rand_gauss( &ftmp, cna_seed );
1699 543243216 : DFT_L[2 * i] += ( 1 + g ) * N1 + gamma * N2;
1700 543243216 : DFT_R[2 * i] += ( 1 - g ) * N1 - gamma * N2;
1701 :
1702 543243216 : N1 = scale_fact * rand_gauss( &ftmp, cna_seed );
1703 543243216 : N2 = scale_fact * rand_gauss( &ftmp, cna_seed );
1704 543243216 : DFT_L[2 * i + 1] += ( 1 + g ) * N1 + gamma * N2;
1705 543243216 : DFT_R[2 * i + 1] += ( 1 - g ) * N1 - gamma * N2;
1706 : }
1707 : }
1708 :
1709 : /* update CNA re-scaling factor */
1710 3416624 : hFdCngDec->cna_rescale_fact = 0.8f * hFdCngDec->cna_act_fact;
1711 3416624 : if ( !hFdCngDec->first_cna_noise_updated )
1712 : {
1713 922412 : hFdCngDec->cna_rescale_fact = 0;
1714 : }
1715 : }
1716 :
1717 : /* Update memories */
1718 4229186 : hStereoDft->past_DMX_pos = ( hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX;
1719 4229186 : mvr2r( pDFT_DMX, hStereoDft->DFT_past_DMX[hStereoDft->past_DMX_pos], min( hStereoDft->NFFT, STEREO_DFT32MS_N_32k ) );
1720 : #ifndef DEBUG_STEREO_DFT_NOSTEREO
1721 4229186 : if ( pPredGain )
1722 : {
1723 4229186 : stereo_dft_adapt_sf_delay( hStereoDft, pPredGain );
1724 : }
1725 : #endif
1726 :
1727 4229186 : mvr2r( DFT_L, DFT[0] + k * STEREO_DFT32MS_N_MAX, hStereoDft->NFFT );
1728 4229186 : mvr2r( DFT_R, DFT[1] + k * STEREO_DFT32MS_N_MAX, hStereoDft->NFFT );
1729 : }
1730 :
1731 2114593 : if ( st0->bfi && !prev_bfi )
1732 : {
1733 38789 : idx_k0 = ( hStereoDft->past_DMX_pos + STEREO_DFT_PAST_MAX - 1 ) % STEREO_DFT_PAST_MAX;
1734 38789 : idx_k1 = ( idx_k0 + 1 ) % STEREO_DFT_PAST_MAX;
1735 : /*dmx energy memory*/
1736 38789 : hStereoDft->past_dmx_nrg = stereo_dft_dmx_swb_nrg( hStereoDft->DFT_past_DMX[idx_k0], hStereoDft->DFT_past_DMX[idx_k1], min( hStereoDft->NFFT, STEREO_DFT32MS_N_32k ) );
1737 : }
1738 :
1739 2114593 : stereo_dft_compute_td_stefi_params( hStereoDft, samp_ratio );
1740 :
1741 2114593 : return;
1742 : }
1743 :
1744 :
1745 : /*-------------------------------------------------------------------------
1746 : * stereo_dft_dec_res()
1747 : *
1748 : * Decode the residual signal
1749 : *-------------------------------------------------------------------------*/
1750 :
1751 754527 : void stereo_dft_dec_res(
1752 : CPE_DEC_HANDLE hCPE, /* i/o: decoder CPE handle */
1753 : float res_buf[STEREO_DFT_N_8k], /* i : residual buffer */
1754 : float *output /* o : output */
1755 : )
1756 : {
1757 : int16_t i;
1758 : float win[L_FRAME8k + STEREO_DFT_OVL_8k];
1759 : float bpf_error_signal_8k[L_FRAME8k];
1760 : int16_t prev_bfi;
1761 : float fac, step;
1762 : int16_t res_bpf_flag;
1763 :
1764 754527 : prev_bfi = hCPE->hCoreCoder[0]->prev_old_bfi; /* The core decoding is already completed here and the prev_bfi has been updated for the next frame.
1765 : The prev_old_bfi still holds the prev_bfi for the current frame. */
1766 :
1767 : /* flush memories when switching residual coding on */
1768 754527 : if ( hCPE->hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1] == STEREO_DFT_RES_COD_OFF )
1769 : {
1770 4302 : set_zero( hCPE->hStereoDft->res_cod_mem, STEREO_DFT_OVL_8k );
1771 4302 : set_zero( hCPE->input_mem[1], NS2SA( 8000, STEREO_DFT32MS_OVL_NS ) );
1772 4302 : set_zero( hCPE->hStereoDft->hBpf->pst_old_syn, STEREO_DFT_NBPSF_PIT_MAX_8k );
1773 4302 : hCPE->hStereoDft->hBpf->pst_mem_deemp_err = 0.f;
1774 : }
1775 :
1776 : /*Inverse MDCT*/
1777 754527 : TCX_MDCT_Inverse( res_buf, win, STEREO_DFT_OVL_8k, L_FRAME8k - STEREO_DFT_OVL_8k, STEREO_DFT_OVL_8k, IVAS_CPE_DFT );
1778 :
1779 754527 : if ( !prev_bfi )
1780 : {
1781 : /*OLA*/
1782 : /*overlapping parts*/
1783 52147228 : for ( i = 0; i < STEREO_DFT_OVL_8k; i++ )
1784 : {
1785 51412760 : win[i] = hCPE->hStereoDft->res_cod_mem[i] + win[i] * hCPE->hStereoDft->win_8k[i];
1786 51412760 : hCPE->hStereoDft->res_cod_mem[i] = win[L_FRAME8k + i] * hCPE->hStereoDft->win_8k[STEREO_DFT_OVL_8k - 1 - i];
1787 : }
1788 : }
1789 : else
1790 : {
1791 : /* For first good frame, ola memory contains extended ECU buffer -- need to crossfade instead of OLA */
1792 20059 : step = (float) ( 1.0f / STEREO_DFT_OVL_8k );
1793 20059 : fac = 0;
1794 1424189 : for ( i = 0; i < STEREO_DFT_OVL_8k; i++ )
1795 : {
1796 1404130 : win[i] = ( 1.0f - fac * fac ) * hCPE->hStereoDft->res_cod_mem[i] + ( 1.0f - ( 1.0f - fac ) * ( 1.0f - fac ) ) * win[i] * hCPE->hStereoDft->win_8k[i];
1797 1404130 : hCPE->hStereoDft->res_cod_mem[i] = win[L_FRAME8k + i] * hCPE->hStereoDft->win_8k[STEREO_DFT_OVL_8k - 1 - i];
1798 1404130 : fac += step;
1799 : }
1800 : }
1801 :
1802 : #ifdef DEBUG_STEREO_DFT_NOQRES
1803 : {
1804 : int16_t tmp[1024];
1805 : dbgread( &tmp, sizeof( int16_t ), L_FRAME8k, "./res/stereo_dft_enc_res_original.pcm" );
1806 : for ( i = 0; i < L_FRAME8k; i++ )
1807 : {
1808 : win[i] = (float) ( tmp[i] );
1809 : }
1810 : }
1811 : #endif
1812 754527 : mvr2r( win, output, L_FRAME8k );
1813 :
1814 : #ifdef DEBUG_MODE_DFT
1815 : {
1816 : int16_t tmp[L_FRAME8k];
1817 :
1818 : for ( i = 0; i < L_FRAME8k; i++ )
1819 : {
1820 : tmp[i] = (int16_t) ( win[i] );
1821 : }
1822 : dbgwrite( tmp, sizeof( int16_t ), L_FRAME8k, 1, "./res/stereo_dft_dec_res_decoded.pcm" );
1823 : }
1824 : #endif
1825 754527 : if ( hCPE->hCoreCoder[0]->core == ACELP_CORE )
1826 : {
1827 : /* bass post-filter */
1828 356230 : bass_psfilter( hCPE->hStereoDft->hBpf, hCPE->hCoreCoder[0]->Opt_AMR_WB, output, L_FRAME8k, hCPE->hCoreCoder[0]->old_pitch_buf + ( L_FRAME8k / STEREO_DFT_L_SUBFR_8k ), hCPE->hCoreCoder[0]->bpf_off,
1829 356230 : hCPE->hCoreCoder[0]->stab_fac, &hCPE->hStereoDft->stab_fac_smooth_res, hCPE->hCoreCoder[0]->last_coder_type, bpf_error_signal_8k );
1830 :
1831 356230 : res_bpf_flag = res_bpf_adapt( hCPE->hStereoDft, bpf_error_signal_8k, res_buf );
1832 356230 : if ( prev_bfi )
1833 : {
1834 : /* Ramp up BPF contribution for the first good frame */
1835 8794 : step = (float) ( 1.0f / L_FRAME8k );
1836 8794 : fac = 0;
1837 1415834 : for ( i = 0; i < L_FRAME8k; i++ )
1838 : {
1839 1407040 : bpf_error_signal_8k[i] *= fac;
1840 1407040 : fac += step;
1841 : }
1842 : }
1843 :
1844 356230 : if ( res_bpf_flag )
1845 : {
1846 335317 : v_sub( output, bpf_error_signal_8k, output, L_FRAME8k );
1847 : }
1848 : }
1849 398297 : else if ( hCPE->hCoreCoder[0]->last_core == ACELP_CORE )
1850 : {
1851 0 : set_zero( hCPE->hStereoDft->hBpf->pst_old_syn, STEREO_DFT_NBPSF_PIT_MAX_8k );
1852 0 : hCPE->hStereoDft->hBpf->pst_mem_deemp_err = 0.f;
1853 : }
1854 : #ifdef DEBUG_MODE_DFT
1855 : {
1856 : int16_t v;
1857 : int16_t out_bpf[L_FRAME8k];
1858 :
1859 : if ( hCPE->hCoreCoder[0]->core == ACELP_CORE )
1860 : {
1861 : for ( v = 0; v < L_FRAME8k; v++ )
1862 : {
1863 : out_bpf[v] = (int16_t) bpf_error_signal_8k[v];
1864 : }
1865 : }
1866 : else
1867 : {
1868 : set_s( out_bpf, 0, L_FRAME8k );
1869 : }
1870 : dbgwrite( out_bpf, sizeof( int16_t ), L_FRAME8k, 1, "res/bpf_res.pcm" );
1871 : }
1872 : #endif
1873 :
1874 754527 : return;
1875 : }
1876 :
1877 :
1878 : /*-------------------------------------------------------------------------
1879 : * stereo_dft_dec_read_BS()
1880 : *
1881 : * Read bitstream
1882 : *-------------------------------------------------------------------------*/
1883 :
1884 2123274 : void stereo_dft_dec_read_BS(
1885 : const int32_t ivas_total_brate, /* i : IVAS total bitrate */
1886 : const int32_t element_brate, /* i : element bitrate */
1887 : int32_t *total_brate, /* o : total bitrate */
1888 : Decoder_State *st, /* i/o: decoder state structure */
1889 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft, /* i/o: decoder stereo handle */
1890 : const int16_t bwidth, /* i : bandwidth */
1891 : const int16_t output_frame, /* i : output frame length */
1892 : float res_buf[STEREO_DFT_N_8k], /* o : residual buffer */
1893 : int16_t *nb_bits, /* o : number of bits read */
1894 : float *coh, /* i/o: Coherence */
1895 : const int16_t ivas_format /* i : ivas format */
1896 : )
1897 : {
1898 : int16_t b, N_div, nbands;
1899 : int16_t NFFT_inner;
1900 : int16_t k, k_offset;
1901 : int16_t I;
1902 : int16_t max_bits;
1903 : uint16_t bit_stream_side[800]; /*Max bits per frame for 30kbps*/
1904 : RangeUniDecState range_uni_dec_state;
1905 : ECSQ_instance ecsq_inst;
1906 :
1907 : /* needed for provisorial reordering of indices */
1908 : int16_t ind1[STEREO_DFT_BAND_MAX];
1909 : int16_t n_bits;
1910 : int16_t nb, ind1_ipd[STEREO_DFT_BAND_MAX], ind1_pred[STEREO_DFT_BAND_MAX];
1911 : int16_t sign_flag;
1912 : float sg_tmp[STEREO_DFT_BAND_MAX];
1913 : float res_pred_gain_tmp[STEREO_DFT_BAND_MAX];
1914 : int16_t itd_mode;
1915 :
1916 : #ifdef DEBUG_MODE_DFT
1917 : static FILE *pF = NULL;
1918 : static FILE *ITD_values = NULL, *side_gain_values = NULL, *RPG_values = NULL;
1919 :
1920 : if ( pF == NULL )
1921 : pF = fopen( "./res/stereo_dft_dec_ind.txt", "w" );
1922 : if ( ITD_values == NULL )
1923 : ITD_values = fopen( "./res/itd_indicies_dec.txt", "w" );
1924 : if ( side_gain_values == NULL )
1925 : side_gain_values = fopen( "./res/side_gain_indicies_dec.txt", "w" );
1926 : if ( RPG_values == NULL )
1927 : RPG_values = fopen( "./res/rpg_indicies_dec.txt", "w" );
1928 :
1929 : assert( *nb_bits <= 800 );
1930 : #endif
1931 : /*------------------------------------------------------------------*
1932 : * Initialization
1933 : *-----------------------------------------------------------------*/
1934 :
1935 2123274 : k_offset = STEREO_DFT_OFFSET;
1936 :
1937 2123274 : if ( ivas_total_brate == IVAS_SID_5k2 )
1938 : {
1939 17482 : if ( ivas_format == MASA_FORMAT )
1940 : {
1941 887 : hStereoDft->frame_nodata = 0;
1942 887 : hStereoDft->frame_sid_nodata = 1;
1943 887 : hStereoDft->frame_sid = 1;
1944 887 : *nb_bits = 0;
1945 : }
1946 : else
1947 : {
1948 16595 : hStereoDft->frame_nodata = 0;
1949 16595 : hStereoDft->frame_sid_nodata = 1;
1950 16595 : hStereoDft->frame_sid = 1;
1951 16595 : *nb_bits = ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS;
1952 : }
1953 : }
1954 2105792 : else if ( ivas_total_brate == FRAME_NO_DATA )
1955 : {
1956 105299 : hStereoDft->frame_nodata = 1;
1957 105299 : hStereoDft->frame_sid_nodata = 1;
1958 105299 : hStereoDft->frame_sid = 0;
1959 105299 : *nb_bits = 0;
1960 105299 : *total_brate = 0;
1961 105299 : hStereoDft->itd[k = hStereoDft->prm_res[k_offset] - 1 + k_offset] = hStereoDft->itd_xfade_target;
1962 105299 : hStereoDft->gipd[hStereoDft->prm_res[k_offset] - 1 + k_offset] = hStereoDft->ipd_xfade_target;
1963 :
1964 105299 : return;
1965 : }
1966 : else
1967 : {
1968 2000493 : hStereoDft->frame_nodata = 0;
1969 2000493 : hStereoDft->frame_sid_nodata = 0;
1970 2000493 : hStereoDft->frame_sid = 0;
1971 :
1972 2000493 : st->total_brate = *nb_bits * FRAMES_PER_SEC;
1973 : }
1974 :
1975 2017975 : hStereoDft->reverb_flag = 0;
1976 :
1977 : /* reverse the bitstream */
1978 389768969 : for ( b = 0; b < *nb_bits; b++ )
1979 : {
1980 387750994 : bit_stream_side[b] = st->bit_stream[-b];
1981 : }
1982 :
1983 : /* make sure the padding bits read ahead by the arithmetic coder (up to 16) or range coder (up to 32) have binary values */
1984 66593175 : for ( ; b < *nb_bits + 32; b++ )
1985 : {
1986 64575200 : bit_stream_side[b] = 0;
1987 : }
1988 2017975 : st->bit_stream = bit_stream_side;
1989 :
1990 : /*init*/
1991 2017975 : max_bits = *nb_bits;
1992 2017975 : *nb_bits = 0;
1993 2017975 : N_div = STEREO_DFT_NBDIV;
1994 :
1995 2017975 : if ( ivas_total_brate > IVAS_SID_5k2 )
1996 : {
1997 2000493 : mvr2r( hStereoDft->side_gain + 2 * STEREO_DFT_BAND_MAX, sg_tmp, STEREO_DFT_BAND_MAX );
1998 2000493 : mvr2r( hStereoDft->res_pred_gain + 2 * STEREO_DFT_BAND_MAX, res_pred_gain_tmp, STEREO_DFT_BAND_MAX );
1999 : }
2000 :
2001 : /* attackPresent always set to 0 in SID frames */
2002 2017975 : if ( hStereoDft->frame_sid )
2003 : {
2004 17482 : hStereoDft->attackPresent = 0;
2005 : }
2006 : else
2007 : {
2008 2000493 : hStereoDft->attackPresent = get_next_indice( st, 1 );
2009 2000493 : ( *nb_bits )++;
2010 : }
2011 :
2012 : /* read res_cod_mode from bitstream */
2013 2017975 : if ( bwidth == WB && hStereoDft->hConfig->ada_wb_res_cod_mode )
2014 : {
2015 154374 : hStereoDft->res_cod_mode[k_offset] = get_next_indice( st, 1 );
2016 154374 : ( *nb_bits )++;
2017 : #ifdef DEBUG_MODE_DFT
2018 : fprintf( pF, "res_cod_mode: %d\n", hStereoDft->res_cod_mode[k_offset] );
2019 : #endif
2020 : }
2021 :
2022 : /* read number of bands in the bitstream - depends on the audio bandwidth and not to output_Fs */
2023 2017975 : if ( hStereoDft->frame_sid )
2024 : {
2025 17482 : NFFT_inner = STEREO_DFT32MS_N_MAX * inner_frame_tbl[bwidth] / L_FRAME48k;
2026 : }
2027 : else
2028 : {
2029 2000493 : NFFT_inner = STEREO_DFT32MS_N_MAX * inner_frame_tbl[st->bwidth] / L_FRAME48k;
2030 : }
2031 :
2032 : /* Use coarse band partition in inactive frames */
2033 2017975 : if ( hStereoDft->frame_sid )
2034 : {
2035 17482 : hStereoDft->band_res[k_offset] = STEREO_DFT_BAND_RES_LOW;
2036 17482 : hStereoDft->res_cod_mode[k_offset] = STEREO_DFT_RES_COD_OFF;
2037 17482 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->band_res[k_offset], min( STEREO_DFT32MS_N_MAX, NFFT_inner ), DEC );
2038 :
2039 17482 : if ( hStereoDft->nbands > STEREO_DFT_COH_MAXBAND )
2040 : {
2041 2716 : hStereoDft->band_limits[STEREO_DFT_COH_MAXBAND] = hStereoDft->band_limits[hStereoDft->nbands];
2042 2716 : hStereoDft->nbands = STEREO_DFT_COH_MAXBAND;
2043 : }
2044 : }
2045 : else
2046 : {
2047 2000493 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->band_res[k_offset], NFFT_inner, DEC );
2048 : }
2049 :
2050 2017975 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->res_cod_mode[k_offset]];
2051 2017975 : hStereoDft->res_cod_line_max = (int16_t) ( 0.5f + ( hStereoDft->band_limits[hStereoDft->res_cod_band_max] - 1 ) * 2.f * output_frame / (float) ( hStereoDft->NFFT ) );
2052 2017975 : hStereoDft->res_cod_line_max = 8 * ( hStereoDft->res_cod_line_max / 8 );
2053 2017975 : hStereoDft->res_pred_band_min = max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
2054 :
2055 : #ifdef DEBUG_MODE_DFT
2056 : fprintf( pF, "stereo Data: %d %d %d %d %d\n", hStereoDft->band_res[k_offset], hStereoDft->prm_res[k_offset], hStereoDft->res_pred_mode[k_offset], hStereoDft->res_cod_mode[k_offset], hStereoDft->res_cod_band_max );
2057 : fprintf( pF, "stereo Bands: %d\n", hStereoDft->nbands );
2058 : #endif
2059 :
2060 : /*Copy config. for all DFT frames*/
2061 2017975 : set_s( hStereoDft->band_res + k_offset + 1, hStereoDft->band_res[k_offset], N_div - 1 );
2062 2017975 : set_s( hStereoDft->prm_res + k_offset + 1, hStereoDft->prm_res[k_offset], N_div - 1 );
2063 2017975 : set_s( hStereoDft->res_pred_mode + k_offset + 1, hStereoDft->res_pred_mode[k_offset], N_div - 1 );
2064 2017975 : set_s( hStereoDft->res_cod_mode + k_offset + 1, hStereoDft->res_cod_mode[k_offset], N_div - 1 );
2065 :
2066 : /*------------------------------------------------------------------*
2067 : * Read DFT stereo parameters
2068 : *-----------------------------------------------------------------*/
2069 :
2070 : /* Sent from the latest to the oldest */
2071 4035950 : for ( k = hStereoDft->prm_res[k_offset] - 1; k < N_div; k += hStereoDft->prm_res[k + k_offset] )
2072 : {
2073 : #ifdef DEBUG_MODE_DFT
2074 : fprintf( pF, "ch[%d]:", k );
2075 : #endif
2076 : /* reset parameters */
2077 2017975 : set_zero( hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX, STEREO_DFT_BAND_MAX );
2078 2017975 : hStereoDft->gipd[k + k_offset] = 0.f;
2079 2017975 : set_zero( hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX, STEREO_DFT_BAND_MAX );
2080 :
2081 : #ifdef DEBUG_MODE_DFT
2082 : fprintf( pF, "ITD: %d ", hStereoDft->hConfig->itd_mode );
2083 : #endif
2084 :
2085 2017975 : if ( !( ivas_format == MASA_FORMAT && ivas_total_brate <= IVAS_SID_5k2 ) )
2086 : {
2087 : /*------------------------------------------------------------------*
2088 : * read Side gains
2089 : *-----------------------------------------------------------------*/
2090 :
2091 : /* side gain */
2092 : /* get coding type */
2093 : /* Do not read and decode side gain if a NO_DATA frame */
2094 2017088 : if ( !hStereoDft->frame_nodata )
2095 : {
2096 2017088 : n_bits = 0;
2097 2017088 : nb = st->next_bit_pos;
2098 2017088 : n_bits = read_flag_EC_DFT( &st->bit_stream[nb], &hStereoDft->side_gain_flag_1 );
2099 2017088 : nb += n_bits;
2100 :
2101 2017088 : if ( hStereoDft->side_gain_flag_1 == 0 )
2102 : {
2103 1397064 : b = read_BS_adapt_GR_sg( st->bit_stream, nb, ind1, hStereoDft->nbands, &hStereoDft->side_gain_flag_2, dft_maps_sg );
2104 1397064 : n_bits += b;
2105 : }
2106 : else
2107 : {
2108 620024 : if ( hStereoDft->side_gain_flag_1 == 2 ) /* differential */
2109 : {
2110 607161 : b = read_BS_GR( st->bit_stream, nb, ind1, hStereoDft->nbands, &hStereoDft->side_gain_flag_2 );
2111 607161 : n_bits += b;
2112 6681512 : for ( b = 0; b < hStereoDft->nbands; b++ )
2113 : {
2114 6074351 : ind1[b] += hStereoDft->side_gain_index_previous[b];
2115 : }
2116 : }
2117 : else
2118 : {
2119 110212 : for ( b = 0; b < hStereoDft->nbands; b++ )
2120 : {
2121 97349 : ind1[b] = get_value( &st->bit_stream[nb], STEREO_DFT_SIDEGAIN_NBITS );
2122 97349 : nb += STEREO_DFT_SIDEGAIN_NBITS;
2123 97349 : n_bits += STEREO_DFT_SIDEGAIN_NBITS;
2124 : }
2125 : }
2126 : }
2127 :
2128 22011110 : for ( b = 0; b < hStereoDft->nbands; b++ )
2129 : {
2130 19994022 : hStereoDft->side_gain_index_previous[b] = ind1[b];
2131 :
2132 19994022 : hStereoDft->res_gains_ind[0][b + STEREO_DFT_BAND_MAX] = ind1[b];
2133 : }
2134 :
2135 : #ifdef DEBUG_MODE_DFT
2136 : for ( b = 0; b < hStereoDft->nbands; b++ )
2137 : {
2138 : fprintf( pF, "Side gain: %d ", ind1[b] );
2139 : fprintf( side_gain_values, " %d ", ind1[b] );
2140 : }
2141 : #endif
2142 2017088 : st->next_bit_pos += n_bits;
2143 2017088 : ( *nb_bits ) += n_bits;
2144 : }
2145 :
2146 : /*------------------------------------------------------------------*
2147 : * read ITDs
2148 : *-----------------------------------------------------------------*/
2149 :
2150 2017088 : if ( !hStereoDft->frame_sid_nodata )
2151 : {
2152 2000493 : itd_mode = get_next_indice( st, STEREO_DFT_ITD_MODE_NBITS );
2153 2000493 : ( *nb_bits ) += STEREO_DFT_ITD_MODE_NBITS; /*ITD mode flag: 1bit*/
2154 :
2155 2000493 : hStereoDft->itd[k + k_offset] = 0.f;
2156 2000493 : if ( itd_mode )
2157 : {
2158 616878 : ( *nb_bits ) += read_itd( st, &I );
2159 616878 : stereo_dft_dequantize_itd( &I, hStereoDft->itd + k + k_offset, st->output_Fs );
2160 : #ifdef DEBUG_MODE_DFT
2161 : fprintf( pF, "ITD: %d ", I );
2162 : fprintf( ITD_values, "%d %d ", frame, I );
2163 : #endif
2164 : }
2165 : }
2166 16595 : else if ( *nb_bits <= ( ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - STEREO_DFT_ITD_MODE_NBITS - STEREO_DFT_SID_ITD_NBITS - 1 - SID_FORMAT_NBITS ) )
2167 : {
2168 16595 : itd_mode = get_next_indice( st, STEREO_DFT_ITD_MODE_NBITS );
2169 16595 : ( *nb_bits ) += STEREO_DFT_ITD_MODE_NBITS; /*ITD mode flag: 1bit*/
2170 :
2171 16595 : hStereoDft->itd[k + k_offset] = 0.f;
2172 16595 : if ( itd_mode )
2173 : {
2174 1016 : sign_flag = get_next_indice( st, 1 );
2175 1016 : I = get_next_indice( st, STEREO_DFT_SID_ITD_NBITS );
2176 1016 : ( *nb_bits ) += STEREO_DFT_SID_ITD_NBITS + 1;
2177 1016 : I = I << STEREO_DFT_SID_ITD_FAC;
2178 1016 : I += 256 * sign_flag;
2179 1016 : stereo_dft_dequantize_itd( &I, hStereoDft->itd + k + k_offset, st->output_Fs );
2180 : #ifdef DEBUG_MODE_DFT
2181 : fprintf( pF, "ITD: %d ", I );
2182 : fprintf( ITD_values, "%d %d ", frame, I );
2183 : #endif
2184 : }
2185 : }
2186 :
2187 : /*------------------------------------------------------------------*
2188 : * read IPDs
2189 : *-----------------------------------------------------------------*/
2190 :
2191 2017088 : n_bits = 0;
2192 2017088 : nb = st->next_bit_pos;
2193 :
2194 2017088 : if ( !hStereoDft->frame_sid_nodata )
2195 : {
2196 : /* Active frame */
2197 2000493 : hStereoDft->no_ipd_flag = st->bit_stream[nb];
2198 2000493 : nb += 1;
2199 2000493 : n_bits += 1;
2200 2000493 : if ( hStereoDft->no_ipd_flag == 0 )
2201 : {
2202 65285 : ind1_ipd[0] = get_value( &st->bit_stream[nb], STEREO_DFT_GIPD_NBITS );
2203 65285 : nb += STEREO_DFT_GIPD_NBITS;
2204 65285 : n_bits += STEREO_DFT_GIPD_NBITS;
2205 65285 : stereo_dft_dequantize_ipd( &ind1_ipd[0], hStereoDft->gipd + ( k + k_offset ), 1, STEREO_DFT_GIPD_NBITS );
2206 : }
2207 : }
2208 16595 : else if ( *nb_bits <= ( ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - STEREO_DFT_FLAG_BITS - STEREO_DFT_SID_GIPD_NBITS - SID_FORMAT_NBITS ) )
2209 : {
2210 : /* SID frame, only read IPD only if enough bits left in bitstream */
2211 16595 : hStereoDft->no_ipd_flag = st->bit_stream[nb];
2212 16595 : nb += 1;
2213 16595 : n_bits += 1;
2214 16595 : if ( hStereoDft->no_ipd_flag == 0 )
2215 : {
2216 2346 : ind1_ipd[0] = get_value( &st->bit_stream[nb], STEREO_DFT_SID_GIPD_NBITS );
2217 2346 : nb += STEREO_DFT_SID_GIPD_NBITS;
2218 2346 : n_bits += STEREO_DFT_SID_GIPD_NBITS;
2219 2346 : stereo_dft_dequantize_ipd( &ind1_ipd[0], hStereoDft->gipd + ( k + k_offset ), 1, STEREO_DFT_SID_GIPD_NBITS );
2220 : }
2221 : }
2222 : else
2223 : {
2224 0 : hStereoDft->no_ipd_flag = 1;
2225 : }
2226 :
2227 2017088 : st->next_bit_pos += n_bits;
2228 2017088 : ( *nb_bits ) += n_bits;
2229 :
2230 : /*------------------------------------------------------------------*
2231 : * read Residual parameters
2232 : *-----------------------------------------------------------------*/
2233 :
2234 : /* Residual prediction */ /* Switch it off if ITD detected */
2235 2017088 : n_bits = 0;
2236 2017088 : nb = st->next_bit_pos;
2237 :
2238 : /* Not used in inactive frames */
2239 2017088 : if ( !hStereoDft->frame_sid_nodata )
2240 : {
2241 2000493 : if ( hStereoDft->res_pred_mode[k + k_offset] && ( hStereoDft->attackPresent == 0 ) )
2242 : {
2243 1941605 : nbands = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
2244 :
2245 1941605 : hStereoDft->reverb_flag = 0;
2246 1941605 : hStereoDft->nbands_respred = nbands;
2247 :
2248 : /* Read bit for adaptive SF (WB/SWB & FB) */
2249 1941605 : if ( hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
2250 : {
2251 1201927 : hStereoDft->reverb_flag = get_next_indice( st, STEREO_DFT_REVERB_MODE_NBITS );
2252 1201927 : ( *nb_bits ) += STEREO_DFT_REVERB_MODE_NBITS;
2253 1201927 : nb += STEREO_DFT_REVERB_MODE_NBITS;
2254 : #ifdef DEBUG_MODE_DFT
2255 : fprintf( RPG_values, " reverb_flag %d ", hStereoDft->reverb_flag );
2256 : #endif
2257 1201927 : if ( hStereoDft->reverb_flag )
2258 : {
2259 446872 : nbands -= STEREO_DFT_RES_PRED_BAND_MIN_CONST;
2260 : }
2261 : }
2262 :
2263 : /* get coding type */
2264 1941605 : b = read_flag_EC_DFT( &st->bit_stream[nb], &hStereoDft->res_pred_flag_0 );
2265 1941605 : nb += b;
2266 1941605 : n_bits += b;
2267 :
2268 1941605 : if ( hStereoDft->res_pred_flag_0 == 0 )
2269 : {
2270 : #ifdef DEBUG_MODE_DFT
2271 : fprintf( RPG_values, "flag: 0" );
2272 : #endif
2273 544517 : b = read_BS_adapt_GR_rpg( st->bit_stream, nb, ind1_pred, hStereoDft->res_pred_band_min, nbands, &hStereoDft->res_pred_flag_1 );
2274 544517 : n_bits += b;
2275 : }
2276 : else
2277 : {
2278 1397088 : if ( hStereoDft->res_pred_flag_0 == 2 )
2279 : {
2280 : #ifdef DEBUG_MODE_DFT
2281 : fprintf( RPG_values, "flag: 2" );
2282 : #endif
2283 1267614 : b = read_BS_GR( st->bit_stream, nb, &ind1_pred[hStereoDft->res_pred_band_min], nbands - hStereoDft->res_pred_band_min, &hStereoDft->res_pred_flag_1 );
2284 :
2285 1267614 : n_bits += b;
2286 10307972 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2287 : {
2288 9040358 : ind1_pred[b] += hStereoDft->res_pred_index_previous[b];
2289 : }
2290 : }
2291 : else
2292 : {
2293 : #ifdef DEBUG_MODE_DFT
2294 : fprintf( RPG_values, "flag: 1" );
2295 : #endif
2296 1005388 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2297 : {
2298 875914 : ind1_pred[b] = get_value( &st->bit_stream[nb], STEREO_DFT_RES_GAINS_BITS );
2299 875914 : nb += STEREO_DFT_RES_GAINS_BITS;
2300 875914 : n_bits += STEREO_DFT_RES_GAINS_BITS;
2301 : }
2302 : }
2303 : }
2304 :
2305 5608825 : for ( b = 0; b < hStereoDft->res_pred_band_min; b++ )
2306 : {
2307 3667220 : I = 0;
2308 3667220 : stereo_dft_dequantize_res_gains( ind1 + b, &I, hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
2309 3667220 : hStereoDft->res_pred_index_previous[b] = I;
2310 3667220 : hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] = 0;
2311 : }
2312 :
2313 15773008 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2314 : {
2315 13831403 : I = ind1_pred[b];
2316 13831403 : stereo_dft_dequantize_res_gains( ind1 + b, &I, hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
2317 : #ifdef DEBUG_MODE_DFT
2318 : fprintf( pF, "Res pred values: %d ", I );
2319 : if ( hStereoDft->res_pred_flag_0 == 2 )
2320 : fprintf( RPG_values, " %d(%d) ", I, hStereoDft->res_pred_index_previous[b] );
2321 : else
2322 : fprintf( RPG_values, " %d ", I );
2323 : #endif
2324 13831403 : hStereoDft->res_pred_index_previous[b] = I;
2325 13831403 : hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] = I;
2326 : }
2327 :
2328 3744468 : for ( ; b < hStereoDft->nbands; b++ )
2329 : {
2330 1802863 : I = 0;
2331 1802863 : stereo_dft_dequantize_res_gains( ind1 + b, &I, hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
2332 1802863 : hStereoDft->res_pred_index_previous[b] = I;
2333 1802863 : hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] = 0;
2334 : }
2335 : }
2336 : else
2337 : {
2338 655567 : for ( b = 0; b < hStereoDft->nbands; b++ )
2339 : {
2340 596679 : I = 0;
2341 596679 : stereo_dft_dequantize_res_gains( ind1 + b, &I, hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
2342 596679 : hStereoDft->res_pred_index_previous[b] = I;
2343 596679 : hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] = I;
2344 : }
2345 : }
2346 :
2347 2000493 : st->next_bit_pos += n_bits;
2348 2000493 : ( *nb_bits ) += n_bits;
2349 : }
2350 : else
2351 : {
2352 : /* Dequantize sidegain if SID frame */
2353 16595 : if ( hStereoDft->frame_sid )
2354 : {
2355 112452 : for ( b = 0; b < hStereoDft->nbands; b++ )
2356 : {
2357 95857 : I = 0;
2358 95857 : stereo_dft_dequantize_res_gains( ind1 + b, &I, hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
2359 : }
2360 : }
2361 : }
2362 : }
2363 :
2364 : #ifdef DEBUG_MODE_DFT
2365 : /*fprintf(stderr, "\nbres: %d\n", *nb_bits - nb_bits0);*/
2366 : #endif
2367 : }
2368 :
2369 2017975 : if ( !( ivas_format == MASA_FORMAT && ivas_total_brate <= IVAS_SID_5k2 ) )
2370 : {
2371 2017088 : if ( hStereoDft->side_gain_flag_1 != 2 )
2372 : {
2373 1409927 : hStereoDft->sg_mem_corrupt = 0;
2374 : }
2375 : }
2376 :
2377 2017975 : if ( ivas_total_brate > IVAS_SID_5k2 )
2378 : {
2379 2000493 : hStereoDft->recovery_flg = stereo_dft_sg_recovery( hStereoDft );
2380 :
2381 2000493 : if ( hStereoDft->recovery_flg )
2382 : {
2383 6732 : mvr2r( sg_tmp, hStereoDft->side_gain + 2 * STEREO_DFT_BAND_MAX, STEREO_DFT_BAND_MAX );
2384 6732 : mvr2r( res_pred_gain_tmp, hStereoDft->res_pred_gain + 2 * STEREO_DFT_BAND_MAX, STEREO_DFT_BAND_MAX );
2385 : }
2386 : }
2387 :
2388 : /*----------------------------------------------------------------*
2389 : * Residual decoding: spectral lines
2390 : *----------------------------------------------------------------*/
2391 :
2392 : /* Residual coding not used in inactive frames */
2393 2017975 : if ( hStereoDft->res_cod_band_max > 0 && !hStereoDft->frame_sid_nodata )
2394 : {
2395 : int16_t dec[STEREO_DFT_N_MAX_RES];
2396 :
2397 754527 : I = get_next_indice( st, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2398 754527 : ( *nb_bits ) += STEREO_DFT_RES_GLOBAL_GAIN_BITS;
2399 :
2400 : #ifdef DEBUG_MODE_DFT
2401 : fprintf( pF, "\nGain: %d ", I );
2402 : #endif
2403 :
2404 754527 : push_wmops( "residual_decode" );
2405 754527 : if ( I != ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO )
2406 : {
2407 692760 : ECSQ_init_instance( &ecsq_inst, 0 /*dummy index*/, &range_uni_dec_state );
2408 :
2409 692760 : rc_uni_dec_init( &range_uni_dec_state, bit_stream_side + *nb_bits, max_bits - *nb_bits );
2410 :
2411 692760 : hStereoDft->res_global_gain = ECSQ_dequantize_gain( I );
2412 :
2413 692760 : ecsq_inst.config_index = 2 * hStereoDft->res_cod_mode[k_offset] - 1;
2414 :
2415 692760 : ECSQ_decode( &ecsq_inst, hStereoDft->res_cod_line_max, dec );
2416 :
2417 692760 : n_bits = rc_uni_dec_finish( &range_uni_dec_state );
2418 :
2419 : #ifdef DEBUGGING
2420 : /* IVAS_fmToDo: the assert has to be changed with proper bitstream error handling */
2421 : assert( range_uni_dec_state.bit_error_detected == 0 );
2422 : #endif
2423 :
2424 692760 : set_zero( res_buf, STEREO_DFT_N_8k );
2425 692760 : ECSQ_dequantize_vector( dec, hStereoDft->res_global_gain, hStereoDft->res_cod_line_max, res_buf );
2426 : }
2427 : else
2428 : {
2429 61767 : set_s( dec, 0, hStereoDft->res_cod_line_max );
2430 61767 : hStereoDft->res_global_gain = 0.0f;
2431 61767 : n_bits = 0;
2432 61767 : set_zero( res_buf, STEREO_DFT_N_8k );
2433 : }
2434 :
2435 754527 : ( *nb_bits ) += n_bits;
2436 754527 : pop_wmops();
2437 :
2438 : #ifdef DEBUG_MODE_DFT
2439 : fprintf( pF, "%d (max: %d)", n_bits + STEREO_DFT_RES_GLOBAL_GAIN_BITS, max_bits );
2440 : /*fprintf(pF, "%d (max: %d)", n_bits, max_bits);*/
2441 : #endif
2442 : }
2443 :
2444 2017975 : if ( hStereoDft->frame_sid && !( ivas_format == MASA_FORMAT && ivas_total_brate <= IVAS_SID_5k2 ) )
2445 : {
2446 16595 : stereo_dft_dec_sid_coh( st, hStereoDft->nbands, coh, nb_bits );
2447 : }
2448 :
2449 2017975 : if ( ivas_total_brate == IVAS_SID_5k2 && ivas_format != MASA_FORMAT )
2450 : {
2451 16595 : *nb_bits = (int16_t) ( ( element_brate - SID_2k40 ) / FRAMES_PER_SEC ); /* => hCPE->hCoreCoder[0]->total_brate = SID_2k40; */
2452 : }
2453 : {
2454 2017975 : *total_brate = element_brate - ( *nb_bits * FRAMES_PER_SEC );
2455 : }
2456 :
2457 : #ifdef DEBUG_MODE_DFT
2458 : /*fprintf(pF, "Total bits: %d", (*nb_bits));*/
2459 : fprintf( pF, "\n" );
2460 : fprintf( ITD_values, "\n" );
2461 : fprintf( side_gain_values, "\n" );
2462 : fprintf( RPG_values, "\n" );
2463 : #endif
2464 :
2465 2017975 : return;
2466 : }
2467 :
2468 :
2469 : /*-------------------------------------------------------------------------
2470 : * stereo_dft_compute_td_stefi_params()
2471 : *
2472 : *
2473 : *-------------------------------------------------------------------------*/
2474 :
2475 2114593 : static void stereo_dft_compute_td_stefi_params(
2476 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft, /* i/o: decoder DFT stereo handle */
2477 : const float samp_ratio /* i : sampling ratio */
2478 : )
2479 : {
2480 : int16_t pdmx_ind;
2481 : float g2;
2482 : int16_t bin0;
2483 : int16_t band0;
2484 : int16_t b;
2485 : int16_t nbands;
2486 : int16_t bres;
2487 : float wsum;
2488 : float pred_gain_avg, pred_g;
2489 : float nrg_DMX, nrg_pred_DMX;
2490 :
2491 2114593 : pdmx_ind = hStereoDft->past_DMX_pos;
2492 2114593 : bres = hStereoDft->band_res[1];
2493 :
2494 2114593 : if ( hStereoDft->core_hist[1] != ACELP_CORE || hStereoDft->wasTransient )
2495 : {
2496 1242757 : hStereoDft->td_gain[0] = 0;
2497 :
2498 1242757 : return;
2499 : }
2500 :
2501 871836 : bin0 = (int16_t) ( samp_ratio * hStereoDft->NFFT / 2 + .5 );
2502 871836 : bin0 = min( bin0, hStereoDft->band_limits[hStereoDft->nbands] );
2503 871836 : b = hStereoDft->nbands;
2504 2769726 : while ( hStereoDft->band_limits[b] > bin0 )
2505 : {
2506 1897890 : b--;
2507 : }
2508 871836 : band0 = b;
2509 :
2510 : /* calculate averages over high bands */
2511 871836 : pred_g = pred_gain_avg = 0;
2512 871836 : nbands = 0;
2513 871836 : wsum = 0;
2514 2712254 : for ( b = band0; b < hStereoDft->nbands; b++ )
2515 : {
2516 1862765 : if ( min( hStereoDft->past_res_pred_gain[STEFI_DELAY_IND( STEREO_DFT_TD_STEFI_SUBFR_DELAY + 1, pdmx_ind )][b], hStereoDft->past_res_pred_gain[STEFI_DELAY_IND( STEREO_DFT_TD_STEFI_SUBFR_DELAY + 2, pdmx_ind )][b] ) < 0 )
2517 : {
2518 22347 : hStereoDft->td_gain[0] = 0;
2519 22347 : return;
2520 : }
2521 1840418 : pred_g += ( hStereoDft->res_pred_gain[b + STEREO_DFT_BAND_MAX] + hStereoDft->res_pred_gain[b + 2 * STEREO_DFT_BAND_MAX] ) / 2 * dft_res_pred_weights[bres][b - band0];
2522 1840418 : pred_gain_avg += ( hStereoDft->past_res_pred_gain[STEFI_DELAY_IND( STEREO_DFT_TD_STEFI_SUBFR_DELAY + 2, pdmx_ind )][b] + hStereoDft->past_res_pred_gain[STEFI_DELAY_IND( STEREO_DFT_TD_STEFI_SUBFR_DELAY + 1, pdmx_ind )][b] ) / 2 * dft_res_pred_weights[bres][b - band0];
2523 :
2524 1840418 : nbands++;
2525 1840418 : wsum += dft_res_pred_weights[bres][b - band0];
2526 : }
2527 :
2528 849489 : if ( nbands == 0 )
2529 : {
2530 : /* apparently, there is nothing to do here */
2531 105916 : hStereoDft->td_gain[0] = 0;
2532 105916 : return;
2533 : }
2534 :
2535 743573 : pred_g /= wsum;
2536 743573 : pred_gain_avg /= wsum;
2537 :
2538 743573 : nrg_DMX = hStereoDft->hb_nrg[0];
2539 743573 : nrg_pred_DMX = hStereoDft->hb_nrg[1];
2540 :
2541 743573 : g2 = pred_g * sqrtf( ( 0.001f + nrg_DMX ) / ( 0.001f + nrg_pred_DMX ) );
2542 :
2543 743573 : hStereoDft->td_gain[0] = min( pred_gain_avg * STEREO_DFT_STEFFI_GAIN_AMP, pred_gain_avg * ( 1 - STEREO_DFT_STEFFI_GAIN_REST_AMT ) + g2 * STEREO_DFT_STEFFI_GAIN_REST_AMT );
2544 :
2545 743573 : return;
2546 : }
2547 :
2548 :
2549 : /*-------------------------------------------------------------------------
2550 : * stereo_dft_generate_res_pred()
2551 : *
2552 : *
2553 : *-------------------------------------------------------------------------*/
2554 3704726 : void stereo_dft_generate_res_pred(
2555 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft, /* i/o: decoder DFT stereo handle */
2556 : const float samp_ratio, /* i : sampling ratio */
2557 : float *pDFT_DMX, /* i : downmix signal */
2558 : float *DFT_PRED_RES, /* o : residual prediction signal */
2559 : float *pPredGain, /* i : residual prediction gains */
2560 : const int16_t k, /* i : subframe index */
2561 : float *ap_filt_DMX, /* i : enhanced stereo filling signal */
2562 : int16_t *stop, /* o : last FD stereo filling bin */
2563 : const int16_t bfi /* i : BFI flag */
2564 : )
2565 : {
2566 : /* general variables */
2567 : int16_t i, b;
2568 : int16_t begin, end;
2569 : int16_t bin0, band0; /* ESF->Stefi crossover bin/band */
2570 : int16_t lb_stefi_start_band;
2571 :
2572 : /* variables for enhanced stereo filling */
2573 : float norm_fac;
2574 : float alpha, gain_limit;
2575 :
2576 : /* variables for stereo filling */
2577 : int16_t d_long, d_short, d_long_ind, d_short_ind;
2578 : float g_short, g_long;
2579 : float dmx_nrg, rev_nrg;
2580 : float past_dmx_nrg;
2581 : float pred_gain_avg;
2582 : float g2;
2583 : int16_t nbands_respred;
2584 :
2585 3704726 : push_wmops( "gen_respred" );
2586 :
2587 : /* smoothing and limiting parameters */
2588 3704726 : alpha = hStereoDft->wasTransient ? 0 : 0.2f; /* no smoothing after transients */
2589 3704726 : gain_limit = 2;
2590 :
2591 : /* residual prediction only used up to 16 kHz (SWB) */
2592 3704726 : nbands_respred = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
2593 :
2594 : /* In ACELP mode the downmix signal is not available in bandwidth extension area. *
2595 : * Therefore, the downmix energy in the corresponding subbands is estimated. */
2596 3704726 : bin0 = (int16_t) ( samp_ratio * hStereoDft->NFFT / 2 + .5 );
2597 3704726 : bin0 = min( bin0, hStereoDft->band_limits[hStereoDft->nbands] );
2598 3704726 : b = hStereoDft->nbands;
2599 12464990 : while ( hStereoDft->band_limits[b] >= bin0 )
2600 : {
2601 8760264 : b--;
2602 : }
2603 3704726 : band0 = b;
2604 :
2605 3704726 : if ( hStereoDft->res_pred_mode[k + STEREO_DFT_OFFSET] < STEREO_DFT_RESPRED_ESF )
2606 : {
2607 : /* no ESF signal available, use stereo filling over whole spectrum */
2608 1286004 : lb_stefi_start_band = max( hStereoDft->res_pred_band_min, hStereoDft->res_cod_band_max );
2609 : }
2610 : else
2611 : {
2612 : /* ESF signal available, use ESF in lowband, stereo filling in highband */
2613 2418722 : lb_stefi_start_band = max( band0, hStereoDft->res_cod_band_max );
2614 : }
2615 :
2616 3704726 : if ( bfi )
2617 : {
2618 128918 : lb_stefi_start_band = 0;
2619 : }
2620 :
2621 : /* lowband: use ESF if available, else use stereo filling */
2622 3704726 : if ( hStereoDft->res_pred_mode[k + STEREO_DFT_OFFSET] == STEREO_DFT_RESPRED_ESF )
2623 : {
2624 : /* ESF in lowband */
2625 : /* main loop over core region*/
2626 20965610 : for ( b = hStereoDft->res_cod_band_max; b <= band0; b++ )
2627 : {
2628 18546888 : dmx_nrg = EPSILON;
2629 18546888 : rev_nrg = EPSILON;
2630 :
2631 : /* calculate band energies (low band only in case of ACELP) */
2632 367270182 : for ( i = hStereoDft->band_limits[b]; i < min( hStereoDft->band_limits[b + 1], bin0 ); i++ )
2633 : {
2634 348723294 : dmx_nrg += pDFT_DMX[2 * i] * pDFT_DMX[2 * i] + pDFT_DMX[2 * i + 1] * pDFT_DMX[2 * i + 1];
2635 348723294 : rev_nrg += ap_filt_DMX[2 * i] * ap_filt_DMX[2 * i] + ap_filt_DMX[2 * i + 1] * ap_filt_DMX[2 * i + 1];
2636 : }
2637 :
2638 : /* smoothing */
2639 18546888 : hStereoDft->smooth_res_nrg[b] = alpha * hStereoDft->smooth_res_nrg[b] + ( 1 - alpha ) * rev_nrg;
2640 18546888 : hStereoDft->smooth_dmx_nrg[b] = alpha * hStereoDft->smooth_dmx_nrg[b] + ( 1 - alpha ) * dmx_nrg;
2641 :
2642 : /* normalization factor */
2643 18546888 : norm_fac = sqrtf( hStereoDft->smooth_dmx_nrg[b] / hStereoDft->smooth_res_nrg[b] );
2644 :
2645 : /* gain compressor */
2646 18546888 : norm_fac *= min( max( 0.8f, 1 / norm_fac ), 1.25f );
2647 :
2648 : /* gain limiter */
2649 18546888 : norm_fac = min( norm_fac, gain_limit );
2650 :
2651 367270182 : for ( i = hStereoDft->band_limits[b]; i < min( hStereoDft->band_limits[b + 1], bin0 ); i++ )
2652 : {
2653 348723294 : DFT_PRED_RES[2 * i] = norm_fac * pPredGain[b] * ap_filt_DMX[2 * i];
2654 348723294 : DFT_PRED_RES[2 * i + 1] = norm_fac * pPredGain[b] * ap_filt_DMX[2 * i + 1];
2655 : }
2656 : }
2657 : }
2658 1286004 : else if ( hStereoDft->res_pred_mode[k + STEREO_DFT_OFFSET] == STEREO_DFT_RESPRED_STEFI )
2659 : {
2660 : /* stefi in lowband */
2661 1154514 : set_zero( DFT_PRED_RES, 2 * hStereoDft->band_limits[lb_stefi_start_band] );
2662 :
2663 7156434 : for ( b = lb_stefi_start_band; b <= band0; b++ )
2664 : {
2665 6001920 : d_short_ind = STEREO_DFT_PAST_MAX - STEREO_DFT_STEFFI_DELAY_SHORT + b % 2;
2666 6001920 : d_long_ind = max( 4, (int16_t) ( ( STEREO_DFT_PAST_MAX + 4 - 1 ) * ( (float) b / ( hStereoDft->nbands - 1 ) ) + 0.5f ) ) - 4;
2667 : /* make sure d_short really corresponds to a shorter or equally long delay than d_long (e.g. not always the case for
2668 : * STEREO_DFT_STEFFI_DELAY_SHORT=3 and STEREO_DFT_STEFFI_DELAY_LONG=4)*/
2669 6001920 : d_short_ind = max( d_short_ind, d_long_ind );
2670 :
2671 : /* Even number of window sliding (assymmetric OLA) */
2672 6001920 : d_short_ind = 2 * ( d_short_ind / 2 );
2673 6001920 : d_long_ind = 2 * ( d_long_ind / 2 );
2674 :
2675 6001920 : d_short = STEREO_DFT_PAST_MAX - d_short_ind;
2676 6001920 : d_long = STEREO_DFT_PAST_MAX - d_long_ind;
2677 :
2678 6001920 : d_short_ind = ( d_short_ind + hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX;
2679 6001920 : d_long_ind = ( d_long_ind + hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX;
2680 :
2681 6001920 : g_short = hStereoDft->stefi_short_gain;
2682 6001920 : g_long = hStereoDft->stefi_long_gain;
2683 :
2684 : /* change mixing ratio if long and short delay are the same */
2685 6001920 : if ( d_short == d_long )
2686 : {
2687 893088 : g_short = 1;
2688 893088 : g_long = 0;
2689 : }
2690 :
2691 : /* Avoid transient components */
2692 6001920 : if ( hStereoDft->past_res_pred_gain[d_short_ind][b] == -1 && hStereoDft->past_res_pred_gain[d_long_ind][b] == -1 )
2693 : {
2694 186778 : g_long = 0.0f;
2695 186778 : g_short = 0.0f;
2696 : }
2697 5815142 : else if ( hStereoDft->past_res_pred_gain[d_short_ind][b] == -1 )
2698 : {
2699 126330 : g_long = 1.0f;
2700 126330 : g_short = 0.0f;
2701 : }
2702 5688812 : else if ( hStereoDft->past_res_pred_gain[d_long_ind][b] == -1 )
2703 : {
2704 126244 : g_long = 0.0f;
2705 126244 : g_short = 1.0f;
2706 : }
2707 :
2708 6001920 : if ( max( g_short, g_long ) > 0 )
2709 : {
2710 5815142 : past_dmx_nrg = EPSILON;
2711 5815142 : dmx_nrg = EPSILON;
2712 158964060 : for ( i = hStereoDft->band_limits[b]; i < min( bin0, hStereoDft->band_limits[b + 1] ); i++ )
2713 : {
2714 153148918 : dmx_nrg += pDFT_DMX[2 * i] * pDFT_DMX[2 * i] + pDFT_DMX[2 * i + 1] * pDFT_DMX[2 * i + 1];
2715 :
2716 153148918 : DFT_PRED_RES[2 * i] = g_short * ( hStereoDft->DFT_past_DMX[d_short_ind][2 * i] ) + g_long * ( hStereoDft->DFT_past_DMX[d_long_ind][2 * i] );
2717 153148918 : DFT_PRED_RES[2 * i + 1] = g_short * ( hStereoDft->DFT_past_DMX[d_short_ind][2 * i + 1] ) + g_long * ( hStereoDft->DFT_past_DMX[d_long_ind][2 * i + 1] );
2718 :
2719 153148918 : past_dmx_nrg += DFT_PRED_RES[2 * i] * DFT_PRED_RES[2 * i] + DFT_PRED_RES[2 * i + 1] * DFT_PRED_RES[2 * i + 1];
2720 : }
2721 5815142 : if ( !bfi || b >= hStereoDft->res_cod_band_max )
2722 : {
2723 5520002 : norm_fac = sqrtf( ( 0.001f + dmx_nrg ) / ( 0.001f + past_dmx_nrg ) );
2724 5520002 : g2 = pPredGain[b] * norm_fac;
2725 5520002 : pred_gain_avg = g_short * hStereoDft->past_res_pred_gain[d_short_ind][b] +
2726 5520002 : g_long * hStereoDft->past_res_pred_gain[d_long_ind][b];
2727 :
2728 5520002 : g2 = min( pred_gain_avg * STEREO_DFT_STEFFI_GAIN_AMP, pred_gain_avg * ( 1 - STEREO_DFT_STEFFI_GAIN_REST_AMT ) + g2 * STEREO_DFT_STEFFI_GAIN_REST_AMT );
2729 :
2730 157488360 : for ( i = hStereoDft->band_limits[b]; i < min( bin0, hStereoDft->band_limits[b + 1] ); i++ )
2731 : {
2732 151968358 : DFT_PRED_RES[2 * i] *= g2;
2733 151968358 : DFT_PRED_RES[2 * i + 1] *= g2;
2734 : }
2735 : }
2736 : }
2737 : else
2738 : {
2739 186778 : set_zero( DFT_PRED_RES + 2 * hStereoDft->band_limits[b], 2 * ( min( bin0, hStereoDft->band_limits[b + 1] ) - hStereoDft->band_limits[b] ) );
2740 : }
2741 : }
2742 : }
2743 :
2744 : #ifndef DEBUG_STEREO_DFT_NOCORE
2745 3704726 : if ( hStereoDft->band_limits[nbands_respred] > bin0 )
2746 : {
2747 : /* apply stereo filling in ACELP BWE region */
2748 3151852 : if ( hStereoDft->core_hist[0] == ACELP_CORE && hStereoDft->core_hist[STEREO_DFT_STEFFI_DELAY_SHORT / 2] == ACELP_CORE )
2749 : {
2750 : /* ACELP -> ACELP: nothing to do */
2751 1483550 : *stop = bin0;
2752 : }
2753 1668302 : else if ( hStereoDft->core_hist[STEREO_DFT_STEFFI_DELAY_SHORT / 2] == ACELP_CORE )
2754 : {
2755 : /* ACELP -> TCX/HQ core transition */
2756 : /* calculate high band energy only */
2757 102400 : dmx_nrg = EPSILON;
2758 26105216 : for ( i = bin0; i < hStereoDft->NFFT / 2; i++ )
2759 : {
2760 26002816 : dmx_nrg += pDFT_DMX[2 * i] * pDFT_DMX[2 * i] + pDFT_DMX[2 * i + 1] * pDFT_DMX[2 * i + 1];
2761 : }
2762 :
2763 102400 : hStereoDft->hb_nrg[0] += dmx_nrg * 2 / hStereoDft->NFFT;
2764 102400 : *stop = bin0;
2765 : }
2766 1565902 : else if ( hStereoDft->core_hist[0] == ACELP_CORE )
2767 : {
2768 : /* TCX/HQ core -> ACELP transition */
2769 : /* apply short delay only and blend to long/short gain */
2770 62346 : dmx_nrg = hStereoDft->hb_nrg_subr[k];
2771 62346 : d_short_ind = STEREO_DFT_PAST_MAX - STEREO_DFT_TD_STEFI_SUBFR_DELAY;
2772 :
2773 62346 : d_short_ind = ( d_short_ind + hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX;
2774 :
2775 : /* calculate high band energy of past dmx */
2776 62346 : past_dmx_nrg = EPSILON;
2777 9361034 : for ( i = bin0; i < min( hStereoDft->NFFT / 2, STEREO_DFT32MS_N_32k / 2 ); i++ )
2778 : {
2779 9298688 : past_dmx_nrg += hStereoDft->DFT_past_DMX[d_short_ind][2 * i] * hStereoDft->DFT_past_DMX[d_short_ind][2 * i] + hStereoDft->DFT_past_DMX[d_short_ind][2 * i + 1] * hStereoDft->DFT_past_DMX[d_short_ind][2 * i + 1];
2780 : }
2781 :
2782 221924 : for ( b = band0; b < nbands_respred; b++ )
2783 : {
2784 159578 : g_short = hStereoDft->past_res_pred_gain[d_short_ind][b] < 0 ? 0 : ( 1.f + hStereoDft->stefi_short_gain ) / 2;
2785 :
2786 159578 : if ( g_short > 0 )
2787 : {
2788 153190 : norm_fac = sqrtf( ( 0.001f + dmx_nrg ) / ( 0.001f + past_dmx_nrg ) );
2789 153190 : g2 = pPredGain[b] * norm_fac;
2790 153190 : pred_gain_avg = hStereoDft->past_res_pred_gain[d_short_ind][b] * g_short;
2791 :
2792 153190 : g2 = min( pred_gain_avg * STEREO_DFT_STEFFI_GAIN_AMP, pred_gain_avg * ( 1 - STEREO_DFT_STEFFI_GAIN_REST_AMT ) + g2 * STEREO_DFT_STEFFI_GAIN_REST_AMT );
2793 8993510 : for ( i = max( hStereoDft->band_limits[b], bin0 ); i < min( hStereoDft->band_limits[b + 1], STEREO_DFT32MS_N_32k / 2 ); i++ )
2794 : {
2795 8840320 : DFT_PRED_RES[2 * i] = g2 * hStereoDft->DFT_past_DMX[d_short_ind][2 * i];
2796 8840320 : DFT_PRED_RES[2 * i + 1] = g2 * hStereoDft->DFT_past_DMX[d_short_ind][2 * i + 1];
2797 : }
2798 : }
2799 : else
2800 : {
2801 6388 : begin = max( hStereoDft->band_limits[b], bin0 );
2802 6388 : end = min( hStereoDft->band_limits[b + 1], STEREO_DFT32MS_N_32k / 2 );
2803 6388 : set_zero( DFT_PRED_RES + 2 * begin, 2 * ( end - begin ) );
2804 : }
2805 : }
2806 : }
2807 : else
2808 : #endif
2809 : {
2810 5201966 : for ( b = band0; b < nbands_respred; b++ )
2811 : {
2812 : /* TCX/HQ core -> TCX/HQ core: business as usual */
2813 3698410 : d_short_ind = STEREO_DFT_PAST_MAX - STEREO_DFT_STEFFI_DELAY_SHORT + b % 2;
2814 3698410 : d_long_ind = max( 4, (int16_t) ( ( STEREO_DFT_PAST_MAX + 4 - 1 ) * ( (float) b / ( hStereoDft->nbands - 1 ) ) + 0.5f ) ) - 4;
2815 : /* make sure d_short really corresponds to a shorter or equally long delay than d_long (e.g. not always the case for
2816 : * STEREO_DFT_STEFFI_DELAY_SHORT=3 and STEREO_DFT_STEFFI_DELAY_LONG=4)*/
2817 3698410 : d_short_ind = max( d_short_ind, d_long_ind );
2818 :
2819 : /* Even number of window sliding (assymmetric OLA) */
2820 3698410 : d_short_ind = 2 * ( d_short_ind / 2 );
2821 3698410 : d_long_ind = 2 * ( d_long_ind / 2 );
2822 :
2823 3698410 : d_short = STEREO_DFT_PAST_MAX - d_short_ind;
2824 3698410 : d_long = STEREO_DFT_PAST_MAX - d_long_ind;
2825 :
2826 3698410 : d_short_ind = ( d_short_ind + hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX;
2827 3698410 : d_long_ind = ( d_long_ind + hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX;
2828 :
2829 3698410 : g_short = hStereoDft->stefi_short_gain;
2830 3698410 : g_long = hStereoDft->stefi_long_gain;
2831 :
2832 : /* change mixing ratio if long and short delay are the same */
2833 3698410 : if ( d_short == d_long )
2834 : {
2835 3290928 : g_short = 1;
2836 3290928 : g_long = 0;
2837 : }
2838 :
2839 : /* Avoid transient components */
2840 3698410 : if ( hStereoDft->past_res_pred_gain[d_short_ind][b] == -1 && hStereoDft->past_res_pred_gain[d_long_ind][b] == -1 )
2841 : {
2842 94140 : g_long = 0.0f;
2843 94140 : g_short = 0.0f;
2844 : }
2845 3604270 : else if ( hStereoDft->past_res_pred_gain[d_short_ind][b] == -1 )
2846 : {
2847 5616 : g_long = 1.0f;
2848 5616 : g_short = 0.0f;
2849 : }
2850 3598654 : else if ( hStereoDft->past_res_pred_gain[d_long_ind][b] == -1 )
2851 : {
2852 7722 : g_long = 0.0f;
2853 7722 : g_short = 1.0f;
2854 : }
2855 : #ifndef DEBUG_STEREO_DFT_NOCORE
2856 3698410 : if ( hStereoDft->core_hist[d_short / 2] == ACELP_CORE )
2857 : {
2858 0 : g_short = 0;
2859 : }
2860 3698410 : if ( hStereoDft->core_hist[d_long / 2] == ACELP_CORE )
2861 : {
2862 25556 : g_long = 0;
2863 : }
2864 : #endif
2865 :
2866 3698410 : if ( max( g_short, g_long ) > 0 )
2867 : {
2868 3601593 : past_dmx_nrg = EPSILON;
2869 3601593 : dmx_nrg = EPSILON;
2870 217969745 : for ( i = max( hStereoDft->band_limits[b], bin0 ); i < min( hStereoDft->band_limits[b + 1], STEREO_DFT32MS_N_32k / 2 ); i++ )
2871 : {
2872 214368152 : dmx_nrg += pDFT_DMX[2 * i] * pDFT_DMX[2 * i] + pDFT_DMX[2 * i + 1] * pDFT_DMX[2 * i + 1];
2873 :
2874 214368152 : DFT_PRED_RES[2 * i] = g_short * ( hStereoDft->DFT_past_DMX[d_short_ind][2 * i] ) + g_long * ( hStereoDft->DFT_past_DMX[d_long_ind][2 * i] );
2875 214368152 : DFT_PRED_RES[2 * i + 1] = g_short * ( hStereoDft->DFT_past_DMX[d_short_ind][2 * i + 1] ) + g_long * ( hStereoDft->DFT_past_DMX[d_long_ind][2 * i + 1] );
2876 :
2877 214368152 : past_dmx_nrg += DFT_PRED_RES[2 * i] * DFT_PRED_RES[2 * i] + DFT_PRED_RES[2 * i + 1] * DFT_PRED_RES[2 * i + 1];
2878 : }
2879 :
2880 3601593 : norm_fac = sqrtf( ( 0.001f + dmx_nrg ) / ( 0.001f + past_dmx_nrg ) );
2881 3601593 : g2 = pPredGain[b] * norm_fac;
2882 3601593 : pred_gain_avg = g_short * hStereoDft->past_res_pred_gain[d_short_ind][b] + g_long * hStereoDft->past_res_pred_gain[d_long_ind][b];
2883 :
2884 3601593 : g2 = min( pred_gain_avg * STEREO_DFT_STEFFI_GAIN_AMP, pred_gain_avg * ( 1 - STEREO_DFT_STEFFI_GAIN_REST_AMT ) + g2 * STEREO_DFT_STEFFI_GAIN_REST_AMT );
2885 :
2886 217969745 : for ( i = max( hStereoDft->band_limits[b], bin0 ); i < min( hStereoDft->band_limits[b + 1], STEREO_DFT32MS_N_32k / 2 ); i++ )
2887 : {
2888 214368152 : DFT_PRED_RES[2 * i] *= g2;
2889 214368152 : DFT_PRED_RES[2 * i + 1] *= g2;
2890 : }
2891 : }
2892 : else
2893 : {
2894 96817 : begin = max( hStereoDft->band_limits[b], bin0 );
2895 96817 : end = min( hStereoDft->band_limits[b + 1], STEREO_DFT32MS_N_32k / 2 );
2896 96817 : set_zero( DFT_PRED_RES + 2 * begin, 2 * ( end - begin ) );
2897 : }
2898 : }
2899 : }
2900 : #ifndef DEBUG_STEREO_DFT_NOCORE
2901 : }
2902 : #endif
2903 :
2904 : /* update buffers */
2905 33671082 : for ( b = hStereoDft->res_pred_band_min; b < hStereoDft->nbands; b++ )
2906 : {
2907 29966356 : if ( hStereoDft->attackPresent || hStereoDft->wasTransient )
2908 : {
2909 1523660 : hStereoDft->past_res_pred_gain[( hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX][b] = -1;
2910 : }
2911 : else
2912 : {
2913 28442696 : hStereoDft->past_res_pred_gain[( hStereoDft->past_DMX_pos + 1 ) % STEREO_DFT_PAST_MAX][b] = pPredGain[b];
2914 : }
2915 : }
2916 :
2917 3704726 : pop_wmops();
2918 3704726 : return;
2919 : }
2920 :
2921 :
2922 : /*---------------------------------------------------------------
2923 : * stereo_dft_dec_smooth_parameters()
2924 : *
2925 : *
2926 : * ---------------------------------------------------------------*/
2927 :
2928 1797244 : void stereo_dft_dec_smooth_parameters(
2929 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft, /* i/o: decoder DFT stereo handle */
2930 : const int16_t prev_sid_nodata, /* i : Previous SID/No data indicator */
2931 : const int16_t active_frame_counter, /* i : Active frame counter */
2932 : const int32_t element_brate /* i : Element bitrate */
2933 : )
2934 : {
2935 : int16_t k_offset, k, k2, b, N_div;
2936 : float *pIpd, *pInterpol;
2937 : float *pgIpd;
2938 : float *pSideGain;
2939 : float diff_ipd;
2940 : int16_t nbands;
2941 : int16_t max_res_pred_ind;
2942 :
2943 1797244 : N_div = STEREO_DFT_NBDIV;
2944 1797244 : k_offset = STEREO_DFT_OFFSET;
2945 :
2946 1797244 : if ( hStereoDft->frame_sid_nodata || prev_sid_nodata )
2947 : {
2948 69173 : k = 1;
2949 467236 : for ( b = 0; b < hStereoDft->nbands; b++ )
2950 : {
2951 398063 : *( hStereoDft->side_gain + ( ( k + k_offset ) - 1 ) * STEREO_DFT_BAND_MAX + b ) = *( hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b );
2952 : }
2953 :
2954 69173 : if ( hStereoDft->frame_sid_nodata )
2955 : {
2956 : /* set new xfade target if new itd received */
2957 65745 : if ( hStereoDft->ipd_xfade_counter < STEREO_DFT_ITD_CNG_XFADE )
2958 : {
2959 64845 : if ( ( hStereoDft->gipd[k + k_offset] - hStereoDft->ipd_xfade_prev ) > EVS_PI )
2960 : {
2961 0 : hStereoDft->ipd_xfade_target = hStereoDft->gipd[k + k_offset] - 2 * EVS_PI;
2962 0 : hStereoDft->ipd_xfade_step = ( hStereoDft->ipd_xfade_target - hStereoDft->ipd_xfade_prev ) / ( STEREO_DFT_ITD_CNG_XFADE - hStereoDft->ipd_xfade_counter );
2963 : }
2964 64845 : else if ( ( hStereoDft->ipd_xfade_prev - hStereoDft->gipd[k + k_offset] ) > EVS_PI )
2965 : {
2966 465 : hStereoDft->ipd_xfade_target = hStereoDft->gipd[k + k_offset] + 2 * EVS_PI;
2967 465 : hStereoDft->ipd_xfade_step = ( hStereoDft->ipd_xfade_target - hStereoDft->ipd_xfade_prev ) / ( STEREO_DFT_ITD_CNG_XFADE - hStereoDft->ipd_xfade_counter );
2968 : }
2969 : else
2970 : {
2971 64380 : hStereoDft->ipd_xfade_target = hStereoDft->gipd[k + k_offset];
2972 64380 : hStereoDft->ipd_xfade_step = ( hStereoDft->ipd_xfade_target - hStereoDft->ipd_xfade_prev ) / ( STEREO_DFT_ITD_CNG_XFADE - hStereoDft->ipd_xfade_counter );
2973 : }
2974 : }
2975 :
2976 : /* xfade */
2977 65745 : if ( hStereoDft->ipd_xfade_prev != hStereoDft->ipd_xfade_target && hStereoDft->ipd_xfade_counter < STEREO_DFT_ITD_CNG_XFADE && hStereoDft->last_active_element_brate <= 24400 )
2978 : {
2979 16101 : hStereoDft->gipd[k + k_offset] = hStereoDft->ipd_xfade_prev + hStereoDft->ipd_xfade_step;
2980 16101 : hStereoDft->ipd_xfade_prev = hStereoDft->gipd[k + k_offset];
2981 16101 : hStereoDft->ipd_xfade_counter++;
2982 : }
2983 : }
2984 : else
2985 : {
2986 : /* First active frame, "reset" everything if long enough active encoding, only triggered if STEREO_DFT_ITD_CNG_XFADE_RESET = -1 */
2987 3428 : if ( active_frame_counter > STEREO_DFT_ITD_CNG_XFADE_RESET )
2988 : {
2989 3 : hStereoDft->ipd_xfade_target = hStereoDft->gipd[k + k_offset];
2990 3 : hStereoDft->ipd_xfade_prev = hStereoDft->gipd[k + k_offset];
2991 3 : hStereoDft->ipd_xfade_counter = 0;
2992 : }
2993 : }
2994 :
2995 138346 : for ( k2 = 1; k2 < hStereoDft->prm_res[k + k_offset]; k2++ )
2996 : {
2997 69173 : hStereoDft->gipd[( k + k_offset ) - k2] = hStereoDft->gipd[k + k_offset];
2998 : }
2999 :
3000 69173 : if ( hStereoDft->frame_sid_nodata )
3001 : {
3002 : /* set new xfade target if new itd received */
3003 65745 : if ( hStereoDft->itd_xfade_counter < STEREO_DFT_ITD_CNG_XFADE )
3004 : {
3005 65502 : hStereoDft->itd_xfade_target = hStereoDft->itd[k + k_offset];
3006 65502 : hStereoDft->itd_xfade_step = ( hStereoDft->itd_xfade_target - hStereoDft->itd_xfade_prev ) / ( STEREO_DFT_ITD_CNG_XFADE - hStereoDft->itd_xfade_counter );
3007 : }
3008 :
3009 : /* xfade */
3010 65745 : if ( hStereoDft->itd_xfade_prev != hStereoDft->itd_xfade_target && hStereoDft->itd_xfade_counter < STEREO_DFT_ITD_CNG_XFADE && hStereoDft->last_active_element_brate <= 24400 )
3011 : {
3012 10147 : hStereoDft->itd[k + k_offset] = hStereoDft->itd_xfade_prev + hStereoDft->itd_xfade_step;
3013 10147 : hStereoDft->itd_xfade_prev = hStereoDft->itd[k + k_offset];
3014 10147 : hStereoDft->itd_xfade_counter++;
3015 : }
3016 : }
3017 : else
3018 : {
3019 : /* First active frame, "reset" everything if long enough active encoding, only triggered if STEREO_DFT_ITD_CNG_XFADE_RESET = -1 */
3020 3428 : if ( active_frame_counter > STEREO_DFT_ITD_CNG_XFADE_RESET )
3021 : {
3022 3 : hStereoDft->itd_xfade_target = hStereoDft->itd[k + k_offset];
3023 3 : hStereoDft->itd_xfade_prev = hStereoDft->itd[k + k_offset];
3024 3 : hStereoDft->itd_xfade_counter = 0;
3025 : }
3026 :
3027 3428 : hStereoDft->last_active_element_brate = element_brate;
3028 : }
3029 138346 : for ( k2 = 1; k2 < hStereoDft->prm_res[k + k_offset]; k2++ )
3030 : {
3031 69173 : hStereoDft->itd[( k + k_offset ) - k2] = hStereoDft->itd[k + k_offset];
3032 : }
3033 :
3034 69173 : return;
3035 : }
3036 :
3037 : /* Active frame, "reset" everything "reset" everything if long enough active encoding */
3038 1728071 : if ( active_frame_counter > STEREO_DFT_ITD_CNG_XFADE_RESET )
3039 : {
3040 1660094 : hStereoDft->itd_xfade_counter = 0;
3041 1660094 : hStereoDft->itd_xfade_target = hStereoDft->itd[STEREO_DFT_NBDIV - 1];
3042 1660094 : hStereoDft->itd_xfade_prev = hStereoDft->itd[STEREO_DFT_NBDIV - 1];
3043 1660094 : hStereoDft->ipd_xfade_counter = 0;
3044 1660094 : hStereoDft->ipd_xfade_target = hStereoDft->gipd[STEREO_DFT_NBDIV - 1];
3045 1660094 : hStereoDft->ipd_xfade_prev = hStereoDft->gipd[STEREO_DFT_NBDIV - 1];
3046 : }
3047 :
3048 1728071 : hStereoDft->last_active_element_brate = element_brate;
3049 :
3050 3456142 : for ( k = hStereoDft->prm_res[k_offset] - 1; k < N_div; k += hStereoDft->prm_res[k + k_offset] )
3051 : {
3052 1728071 : max_res_pred_ind = 0;
3053 :
3054 1728071 : if ( hStereoDft->reverb_flag == 1 )
3055 : {
3056 353018 : nbands = min( 10, hStereoDft->nbands_respred );
3057 :
3058 : /*Shift 2 last bands residual prediction gains for SWB/FB*/
3059 353018 : if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_HIGH )
3060 : {
3061 539401 : for ( b = hStereoDft->nbands_respred - 1; b >= nbands; b-- )
3062 : {
3063 346248 : hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] =
3064 346248 : hStereoDft->res_gains_ind[1][b - STEREO_DFT_RES_PRED_BAND_MIN_RED + hStereoDft->res_pred_band_min + STEREO_DFT_BAND_MAX];
3065 346248 : hStereoDft->res_gains_ind[1][b - STEREO_DFT_RES_PRED_BAND_MIN_RED + hStereoDft->res_pred_band_min + STEREO_DFT_BAND_MAX] = 0;
3066 : }
3067 : }
3068 :
3069 : /* Get maximal index */
3070 2139853 : for ( b = hStereoDft->res_pred_band_min; b < ( nbands - STEREO_DFT_RES_PRED_BAND_MIN_CONST ); b++ )
3071 : {
3072 1786835 : if ( max_res_pred_ind < hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] )
3073 : {
3074 525795 : max_res_pred_ind = (int16_t) hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX];
3075 : }
3076 : }
3077 :
3078 : /* predictive values */
3079 1412072 : for ( ; b < nbands; b++ )
3080 : {
3081 1059054 : assert( hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] == 0 );
3082 1059054 : hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] = max_res_pred_ind;
3083 : }
3084 : }
3085 :
3086 1728071 : for ( b = hStereoDft->res_pred_band_min; b < hStereoDft->res_cod_band_max; b++ )
3087 : {
3088 : float tmp;
3089 : int16_t tmps1, tmps2;
3090 :
3091 0 : hStereoDft->res_gains_ind[0][b] = hStereoDft->res_gains_ind[0][b + STEREO_DFT_BAND_MAX];
3092 : /*stereo_dft_dequantize_res_gains_f(&hStereoDft->res_gains_ind[0][b], &hStereoDft->res_gains_ind[1][b+STEREO_DFT_BAND_MAX],hStereoDft->side_gain+(k+k_offset)*STEREO_DFT_BAND_MAX+b, hStereoDft->res_pred_gain+(k+k_offset)*STEREO_DFT_BAND_MAX+b, 1);*/
3093 0 : tmps1 = (int16_t) ( hStereoDft->res_gains_ind[0][b] );
3094 0 : tmps2 = (int16_t) ( hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] );
3095 0 : stereo_dft_dequantize_res_gains( &tmps1, &tmps2, hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
3096 :
3097 0 : if ( hStereoDft->attackPresent )
3098 : {
3099 0 : hStereoDft->res_gains_ind[1][b] = 0.8f * hStereoDft->res_gains_ind[1][b];
3100 : }
3101 0 : else if ( hStereoDft->trans || ( hStereoDft->res_pred_mode[k] && ( hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] < 2.f ) ) )
3102 : {
3103 0 : hStereoDft->res_gains_ind[1][b] = 0.6f * hStereoDft->res_gains_ind[1][b] + 0.4f * hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX];
3104 : }
3105 : else
3106 : {
3107 0 : hStereoDft->res_gains_ind[1][b] = dft_alpha_s2[b] * hStereoDft->res_gains_ind[1][b] + ( 1 - dft_alpha_s2[b] ) * hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX];
3108 : }
3109 :
3110 0 : stereo_dft_dequantize_res_gains_f( &hStereoDft->res_gains_ind[0][b], &hStereoDft->res_gains_ind[1][b], &tmp, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
3111 : }
3112 :
3113 : /* Smoothing of prediction gains between ftrames */
3114 15232576 : for ( ; b < hStereoDft->nbands; b++ )
3115 : {
3116 13504505 : if ( hStereoDft->attackPresent )
3117 : {
3118 416748 : hStereoDft->res_gains_ind[0][b] = hStereoDft->res_gains_ind[0][b + STEREO_DFT_BAND_MAX];
3119 416748 : hStereoDft->res_gains_ind[1][b] = 0.8f * hStereoDft->res_gains_ind[1][b];
3120 : }
3121 13087757 : else if ( hStereoDft->trans || ( hStereoDft->res_pred_mode[k] && ( hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] < 2.f ) ) )
3122 : {
3123 8292289 : hStereoDft->res_gains_ind[0][b] = hStereoDft->res_gains_ind[0][b + STEREO_DFT_BAND_MAX];
3124 :
3125 8292289 : if ( hStereoDft->hConfig->band_res == STEREO_DFT_BAND_RES_LOW )
3126 : {
3127 1548107 : hStereoDft->res_gains_ind[1][b] = dft_alpha_w_b2[b] * hStereoDft->res_gains_ind[1][b] + ( 1 - dft_alpha_w_b2[b] ) * hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX];
3128 : }
3129 : else
3130 : {
3131 6744182 : hStereoDft->res_gains_ind[1][b] = dft_alpha_w[b] * hStereoDft->res_gains_ind[1][b] + ( 1 - dft_alpha_w[b] ) * hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX];
3132 : }
3133 : }
3134 : else
3135 : {
3136 4795468 : if ( hStereoDft->hConfig->band_res == STEREO_DFT_BAND_RES_LOW )
3137 : {
3138 955853 : hStereoDft->res_gains_ind[0][b] = dft_alpha_s_b2[b] * hStereoDft->res_gains_ind[0][b] + ( 1 - dft_alpha_s_b2[b] ) * hStereoDft->res_gains_ind[0][b + STEREO_DFT_BAND_MAX];
3139 955853 : hStereoDft->res_gains_ind[1][b] = dft_alpha_s2_b2[b] * hStereoDft->res_gains_ind[1][b] + ( 1 - dft_alpha_s2_b2[b] ) * hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX];
3140 : }
3141 : else
3142 : {
3143 3839615 : hStereoDft->res_gains_ind[0][b] = dft_alpha_s[b] * hStereoDft->res_gains_ind[0][b] + ( 1 - dft_alpha_s[b] ) * hStereoDft->res_gains_ind[0][b + STEREO_DFT_BAND_MAX];
3144 3839615 : hStereoDft->res_gains_ind[1][b] = dft_alpha_s2[b] * hStereoDft->res_gains_ind[1][b] + ( 1 - dft_alpha_s2[b] ) * hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX];
3145 : }
3146 : }
3147 :
3148 13504505 : if ( !hStereoDft->recovery_flg )
3149 : {
3150 13466273 : stereo_dft_dequantize_res_gains_f( &hStereoDft->res_gains_ind[0][b], &hStereoDft->res_gains_ind[1][b], hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, hStereoDft->res_pred_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b, 1 );
3151 : }
3152 : }
3153 :
3154 : /* Smoothing of IPDs*/
3155 1728071 : pgIpd = hStereoDft->gipd + ( k + k_offset );
3156 1728071 : diff_ipd = pgIpd[0] - pgIpd[-hStereoDft->prm_res[k + k_offset]];
3157 1728071 : if ( diff_ipd < -EVS_PI )
3158 : {
3159 93514 : pgIpd[0] += PI2;
3160 : }
3161 1634557 : else if ( diff_ipd > EVS_PI )
3162 : {
3163 72324 : pgIpd[0] -= PI2;
3164 : }
3165 :
3166 1728071 : if ( !hStereoDft->attackPresent )
3167 : {
3168 1677039 : if ( hStereoDft->wasTransient )
3169 : {
3170 48516 : pgIpd[0] = 0.8f * pgIpd[0] + 0.2f * pgIpd[-hStereoDft->prm_res[k + k_offset]];
3171 : }
3172 : else
3173 : {
3174 1628523 : pgIpd[0] = 0.5f * pgIpd[0] + 0.5f * pgIpd[-hStereoDft->prm_res[k + k_offset]];
3175 : }
3176 : }
3177 :
3178 :
3179 1728071 : if ( !hStereoDft->attackPresent )
3180 : {
3181 1677039 : pSideGain = hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX;
3182 5392499 : for ( b = 0; b < hStereoDft->res_cod_band_max; b++ )
3183 : {
3184 3715460 : pSideGain[b] = dft_res_cod_alpha[b] * pSideGain[b] + ( 1 - dft_res_cod_alpha[b] ) * pSideGain[b - hStereoDft->prm_res[k + k_offset] * STEREO_DFT_BAND_MAX];
3185 : }
3186 : }
3187 :
3188 : /*Interpolation between DFT slots*/
3189 3456142 : for ( k2 = 1; k2 < hStereoDft->prm_res[k + k_offset]; k2++ )
3190 : {
3191 1728071 : pInterpol = hStereoDft->gipd + ( ( k + k_offset ) - k2 );
3192 1728071 : pIpd = hStereoDft->gipd + ( k + k_offset );
3193 1728071 : if ( hStereoDft->attackPresent )
3194 : {
3195 51032 : *( pInterpol ) = *( pIpd );
3196 : }
3197 : else
3198 : {
3199 1677039 : *( pInterpol ) = *( hStereoDft->gipd + ( k + k_offset - hStereoDft->prm_res[k + k_offset] ) );
3200 : }
3201 :
3202 19053591 : for ( b = 0; b < hStereoDft->nbands; b++ )
3203 : {
3204 17325520 : *( hStereoDft->res_pred_gain + ( ( k + k_offset ) - k2 ) * STEREO_DFT_BAND_MAX + b ) = *( hStereoDft->res_pred_gain + ( k + k_offset - hStereoDft->prm_res[k + k_offset] ) * STEREO_DFT_BAND_MAX + b );
3205 :
3206 17325520 : if ( b < hStereoDft->res_cod_band_max || hStereoDft->attackPresent || hStereoDft->trans || ( hStereoDft->res_pred_mode[k] && ( hStereoDft->res_gains_ind[1][b + STEREO_DFT_BAND_MAX] < 2.f ) ) )
3207 : {
3208 12530052 : *( hStereoDft->side_gain + ( ( k + k_offset ) - k2 ) * STEREO_DFT_BAND_MAX + b ) = *( hStereoDft->side_gain + ( k + k_offset ) * STEREO_DFT_BAND_MAX + b );
3209 : }
3210 : else
3211 : {
3212 4795468 : *( hStereoDft->side_gain + ( ( k + k_offset ) - k2 ) * STEREO_DFT_BAND_MAX + b ) = *( hStereoDft->side_gain + ( k + k_offset - hStereoDft->prm_res[k + k_offset] ) * STEREO_DFT_BAND_MAX + b );
3213 : }
3214 : }
3215 :
3216 1728071 : hStereoDft->itd[( k + k_offset ) - k2] = hStereoDft->itd[k + k_offset];
3217 : } /*end of interpolation*/
3218 : }
3219 :
3220 1728071 : return;
3221 : }
3222 :
3223 :
3224 : /*---------------------------------------------------------------
3225 : * stereo_dft_adapt_sf_delay()
3226 : *
3227 : *
3228 : * ---------------------------------------------------------------*/
3229 :
3230 4229186 : static void stereo_dft_adapt_sf_delay(
3231 : STEREO_DFT_DEC_DATA_HANDLE hStereoDft,
3232 : float *pPredGain )
3233 : {
3234 : float var_mean_ratio;
3235 : float new_variation;
3236 : float target_delay;
3237 : float max_pg, sum_pg, alpha_up, alpha_down;
3238 : int16_t b;
3239 :
3240 4229186 : max_pg = 0.0f;
3241 4229186 : sum_pg = 0.0f;
3242 :
3243 : /* find sum and maximum of prediction gains */
3244 40359480 : for ( b = hStereoDft->res_pred_band_min; b < hStereoDft->nbands; b++ )
3245 : {
3246 36130294 : if ( pPredGain[b] > max_pg )
3247 : {
3248 10055727 : max_pg = pPredGain[b];
3249 : }
3250 36130294 : sum_pg += pPredGain[b];
3251 : }
3252 :
3253 4229186 : if ( sum_pg > 0.0f )
3254 : {
3255 : /* Calculate mean of the prediction gain */
3256 3822238 : hStereoDft->lt_pred_gain = STEREO_DFT_LT_PREDGAIN_UPD * sum_pg + ( 1.0f - STEREO_DFT_LT_PREDGAIN_UPD ) * hStereoDft->lt_pred_gain;
3257 :
3258 : /* Calculate the variation of the prediction gain */
3259 3822238 : new_variation = fabsf( sum_pg - hStereoDft->lt_pred_gain );
3260 3822238 : hStereoDft->lt_pred_gain_variation = STEREO_DFT_VR_PREDGAIN_UPD * new_variation + ( 1.0f - STEREO_DFT_VR_PREDGAIN_UPD ) * hStereoDft->lt_pred_gain_variation;
3261 : }
3262 :
3263 : /* Calculate ratio of variation and mean of prediction gain */
3264 4229186 : var_mean_ratio = STEREO_DFT_RES_RATIO_LIMIT;
3265 4229186 : if ( hStereoDft->lt_pred_gain > 0.0f )
3266 : {
3267 4040005 : var_mean_ratio = min( 1.5f * STEREO_DFT_RES_RATIO_LIMIT, hStereoDft->lt_pred_gain_variation / hStereoDft->lt_pred_gain );
3268 : }
3269 :
3270 4229186 : if ( max_pg > STEREO_DFT_STEFFI_PG_THRESHOLD )
3271 : {
3272 : /* slow upwards */
3273 2091188 : alpha_up = STEREO_DFT_STEFFI_RATIO_UP_HIGH;
3274 2091188 : alpha_down = STEREO_DFT_STEFFI_RATIO_DOWN_HIGH;
3275 : }
3276 : else
3277 : {
3278 : /* slow downwards */
3279 2137998 : alpha_up = STEREO_DFT_STEFFI_RATIO_UP_LOW;
3280 2137998 : alpha_down = STEREO_DFT_STEFFI_RATIO_DOWN_LOW;
3281 : }
3282 :
3283 4229186 : if ( var_mean_ratio > hStereoDft->lt_var_mean_ratio )
3284 : {
3285 1437836 : hStereoDft->lt_var_mean_ratio = alpha_up * var_mean_ratio + ( 1.0f - alpha_up ) * hStereoDft->lt_var_mean_ratio;
3286 : }
3287 : else
3288 : {
3289 2791350 : hStereoDft->lt_var_mean_ratio = alpha_down * var_mean_ratio + ( 1.0f - alpha_down ) * hStereoDft->lt_var_mean_ratio;
3290 : }
3291 :
3292 : /* Calculate a target delay for the stereo filling. Set the stereo filling delay lower when the prediction gain
3293 : variation is relatively high compared to the mean */
3294 4229186 : if ( hStereoDft->lt_var_mean_ratio >= STEREO_DFT_RES_RATIO_LIMIT )
3295 : {
3296 1928956 : target_delay = STEREO_DFT_STEFFI_DELAY_SHORT;
3297 : }
3298 : else
3299 : {
3300 2300230 : target_delay = min( STEREO_DFT_STEFFI_DELAY_LONG, STEREO_DFT_STEFFI_DELAY_SHORT + ( STEREO_DFT_STEFFI_DELAY_OFFSET + STEREO_DFT_STEFFI_DELAY_LONG - STEREO_DFT_STEFFI_DELAY_SHORT ) * ( 1.0f - hStereoDft->lt_var_mean_ratio / STEREO_DFT_RES_RATIO_LIMIT ) );
3301 : }
3302 :
3303 : /* Adapt the stereo filling delay by interpolating between two delay taps, one at the shortest delay and one at the longest delay */
3304 4229186 : hStereoDft->stefi_short_gain = ( STEREO_DFT_STEFFI_DELAY_LONG - target_delay ) / ( STEREO_DFT_STEFFI_DELAY_LONG - STEREO_DFT_STEFFI_DELAY_SHORT );
3305 4229186 : hStereoDft->stefi_long_gain = sqrtf( 1.0f - hStereoDft->stefi_short_gain * hStereoDft->stefi_short_gain );
3306 :
3307 : #ifdef DEBUG_MODE_DFT
3308 : dbgwrite( &hStereoDft->lt_pred_gain, sizeof( float ), 1, 1, "res/stereo_dft_lt_pred_gain_b.pcm" );
3309 : dbgwrite( &hStereoDft->lt_pred_gain_variation, sizeof( float ), 1, 1, "res/stereo_dft_lt_pred_gain_variance_b.pcm" );
3310 : dbgwrite( &hStereoDft->lt_var_mean_ratio, sizeof( float ), 1, 1, "res/stereo_dft_lt_var_mean_ratio_b.pcm" );
3311 : dbgwrite( &target_delay, sizeof( float ), 1, 1, "res/stereo_dft_target_delay.pcm" );
3312 : dbgwrite( &hStereoDft->stefi_short_gain, sizeof( float ), 1, 1, "res/stereo_dft_short_gain.pcm" );
3313 : dbgwrite( &hStereoDft->stefi_long_gain, sizeof( float ), 1, 1, "res/stereo_dft_long_gain.pcm" );
3314 : #endif /* DEBUG_MODE_DFT */
3315 :
3316 4229186 : return;
3317 : }
|
