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_enc.h"
39 : #include "rom_com.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_enc.h"
45 : #ifdef DEBUGGING
46 : #include "debug.h"
47 : #endif
48 : #include "wmc_auto.h"
49 : #ifdef DEBUG_PLOT
50 : #include "deb_out.h"
51 : #endif
52 : #ifdef DEBUG_MODE_DFT
53 : static FILE *pF = NULL;
54 : #endif
55 :
56 :
57 : /*-------------------------------------------------------------------*
58 : * Local constants
59 : *-------------------------------------------------------------------*/
60 :
61 : #define STEREO_DFT_NRG_PAST_MAX_BAND 9
62 : #define STEREO_DFT_NRG_PAST_MAX_BAND_LB 4
63 : #define STEREO_DFT_DMX_CROSSOVER ( int16_t )( 132 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) + 0.5f ) /* crossover bin between binwise and bandwise DMX */
64 : #define ITD_VAD_E_BAND_N_INIT 200000
65 : #define ITD_SID_PREV_FRAMES 5
66 :
67 :
68 : /*-------------------------------------------------------------------------
69 : * Local function prototypes
70 : *------------------------------------------------------------------------*/
71 :
72 : static void stereo_dft_enc_open( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, const int32_t input_Fs, const int16_t max_bwidth );
73 :
74 : static void stereo_dft_enc_compute_prm( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, float *DFT_L, float *DFT_R, int16_t k_offset, int16_t flag_quant, const int16_t sp_aud_decision0, const int16_t vad_flag, float *bin_nrgL, float *bin_nrgR, float *dot_prod_nrg_ratio );
75 :
76 : static float stereo_dft_calc_mean_bipd( float *pIpd, float ipd_buf[STEREO_DFT_IPD_BUF_LEN] );
77 :
78 : static float stereo_dft_calc_mean_ipd_change( float *pIpd, float *ipd_smooth, int16_t gipd_band_max );
79 :
80 : static void stereo_dft_gipd_stabilization( float *pgIpd, float prev_gipd, float ipd_mean_change );
81 :
82 : #ifdef DEBUG_MODE_DFT
83 : static void stereo_dft_enc_get_nipd_flag( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, float *pgIpd, const int16_t sp_aud_decision0, const float gainIPD );
84 : #else
85 : static void stereo_dft_enc_get_nipd_flag( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, const int16_t sp_aud_decision0, const float gainIPD );
86 : #endif
87 :
88 : static void stereo_dft_enc_get_reverb_flag( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, float *pPredGain, float *sub_nrg_DMX, const float *sub_nrg_L, const float *sub_nrg_R, const int16_t k_offset, const float *bin_nrgL, const float *bin_nrgR );
89 :
90 : static float stereo_dft_gain_offset( const float c, const int16_t itd );
91 :
92 : static void side_gain_mode_decision( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, int16_t encoded_ind_GR[], const int16_t sp_aud_decision0, const int32_t last_core_brate );
93 :
94 : static void res_pred_gain_mode_decision( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, int16_t encoded_ind_pred_GR[], const int16_t k_offset, const int32_t last_core_brate );
95 :
96 : static void stereo_dft_enc_calculate_nrg_for_icbwe( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, const float *DMX, const int32_t input_Fs );
97 :
98 : static void stereo_dft_enc_get_res_cod_mode_flag( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, const float res_nrg_all_curr, const float dmx_nrg_all_curr, float *res_dmx_ratio, float *frame_nrg_ratio );
99 :
100 :
101 : /*-------------------------------------------------------------------------
102 : * stereo_dft_quantize_res_gains()
103 : *
104 : * Joint quantization routine for residual gains
105 : *------------------------------------------------------------------------*/
106 :
107 8053528 : void stereo_dft_quantize_res_gains(
108 : const float *g,
109 : const float *r,
110 : float *gq,
111 : float *rq,
112 : int16_t *ig,
113 : int16_t *ir )
114 : {
115 : int8_t sign;
116 : int16_t min_ind, i;
117 : float min_val, old_val, gg, rr;
118 : int16_t level, index;
119 : float ild;
120 :
121 8053528 : gg = *g;
122 :
123 8053528 : if ( rq != NULL )
124 : {
125 8016477 : rr = *r;
126 : }
127 : else
128 : {
129 37051 : rr = 0;
130 : }
131 :
132 8053528 : if ( gg < 0 )
133 : {
134 3899959 : gg = -gg;
135 3899959 : sign = -1;
136 : }
137 : else
138 : {
139 4153569 : sign = 1;
140 : }
141 :
142 : #ifdef DEBUGGING
143 : /* the following assertions should be satisfied by the input data: */
144 : assert( 1 - gg * gg + EPSILON >= rr * rr / 2 );
145 : assert( gg <= 1 );
146 : #endif
147 :
148 8053528 : gg = min( gg, 1 - EPSILON );
149 8053528 : rr = min( rr, sqrtf( 1 - gg * gg ) - EPSILON );
150 :
151 : /* we calculate the ILD ... */
152 8053528 : ild = 10.f * log10f( ( ( 1 + gg ) * ( 1 + gg ) + rr * rr ) / ( ( 1 - gg ) * ( 1 - gg ) + rr * rr ) );
153 :
154 : /* ... which is truncated to the range [0,50] ... */
155 8053528 : ild = ild > 50 ? 50 : ild;
156 :
157 : /* ... and determine the optimal ILD quantization ...*/
158 8053528 : min_ind = 0;
159 8053528 : old_val = fabsf( ild_q[0] - ild );
160 :
161 26438171 : for ( i = 1; i < 16; i++ )
162 : {
163 26231523 : min_val = fabsf( ild_q[i] - ild );
164 26231523 : if ( min_val < old_val )
165 : {
166 18384643 : min_ind = i;
167 : }
168 : else
169 : {
170 7846880 : break;
171 : }
172 18384643 : old_val = min_val;
173 : }
174 :
175 : /* ... which determines the quantization level: */
176 8053528 : level = min_ind;
177 :
178 : /* Now we look for the closest quantization point in the corresponding column of res_gain_energy_q*/
179 8053528 : old_val = FLT_MAX;
180 8053528 : min_ind = 0;
181 8053528 : index = -1;
182 72481752 : for ( i = 0; i < 8; i++ )
183 : {
184 64428224 : min_val = ( gg - dft_res_gains_q[8 * level + i][0] ) * ( gg - dft_res_gains_q[8 * level + i][0] ) + ( rr - dft_res_gains_q[8 * level + i][1] ) * ( rr - dft_res_gains_q[8 * level + i][1] );
185 :
186 64428224 : min_ind = min_val < old_val ? i : min_ind;
187 64428224 : old_val = min_val < old_val ? min_val : old_val;
188 :
189 64428224 : index = min_ind;
190 : }
191 :
192 : /* and here we are: */
193 8053528 : if ( rq != NULL )
194 : {
195 8016477 : *gq = dft_res_gains_q[8 * level + index][0] * sign;
196 8016477 : *rq = dft_res_gains_q[8 * level + index][1];
197 :
198 8016477 : *ir = index;
199 : }
200 8053528 : *ig = sign < 0 ? 15 - level : 15 + level;
201 :
202 8053528 : return;
203 : }
204 :
205 : /*-------------------------------------------------------------------------
206 : * stereo_dft_quantize_ipd()
207 : *
208 : * Quantize the IPD between [-PI, PI] on 3 or 4 bits
209 : *------------------------------------------------------------------------*/
210 :
211 31361 : static void stereo_dft_quantize_ipd(
212 : const float *in,
213 : float *out,
214 : int16_t *ind,
215 : const int16_t bits )
216 : {
217 : int16_t max_ind;
218 : float delta;
219 :
220 31361 : if ( bits == 2 ) /* New 2-bit phase quantization for the highest frequency band only */
221 : {
222 850 : delta = EVS_PI / 2.0f;
223 850 : max_ind = 3;
224 : }
225 30511 : else if ( bits == 3 )
226 : {
227 0 : delta = EVS_PI / 4.f;
228 0 : max_ind = 7;
229 : }
230 30511 : else if ( bits == 4 )
231 : {
232 30511 : delta = EVS_PI / 8.f;
233 30511 : max_ind = 15;
234 : }
235 : else
236 : {
237 0 : delta = EVS_PI / 4.f;
238 0 : max_ind = 7;
239 0 : assert( 0 );
240 : }
241 :
242 31361 : *ind = (int16_t) ( ( ( *in + EVS_PI ) / delta ) + 0.5f );
243 :
244 : /*modulo 2*PI*/
245 31361 : if ( *ind == max_ind + 1 )
246 : {
247 496 : *ind = 0;
248 : }
249 :
250 : /*Sanity check since no saturation can normally happen*/
251 31361 : *ind = min( max( *ind, 0 ), max_ind );
252 :
253 31361 : *out = *ind * delta - EVS_PI;
254 :
255 31361 : return;
256 : }
257 :
258 :
259 : /*-------------------------------------------------------------------------
260 : * stereo_dft_enc_create()
261 : *
262 : * Create DFT stereo handle
263 : *------------------------------------------------------------------------*/
264 :
265 19424 : ivas_error stereo_dft_enc_create(
266 : STEREO_DFT_ENC_DATA_HANDLE *hStereoDft, /* i/o: encoder DFT stereo handle */
267 : const int32_t input_Fs, /* i : input sampling rate */
268 : const int16_t max_bwidth /* i : maximum encoded bandwidth */
269 : )
270 : {
271 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft_loc;
272 : int16_t tmpS;
273 :
274 19424 : if ( *hStereoDft != NULL )
275 : {
276 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: DFT Stereo memory already allocated\n" );
277 : }
278 :
279 19424 : if ( ( hStereoDft_loc = (STEREO_DFT_ENC_DATA_HANDLE) malloc( sizeof( STEREO_DFT_ENC_DATA ) ) ) == NULL )
280 : {
281 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DFT Stereo\n" ) );
282 : }
283 :
284 19424 : if ( ( hStereoDft_loc->hConfig = (STEREO_DFT_CONFIG_DATA_HANDLE) malloc( sizeof( STEREO_DFT_CONFIG_DATA ) ) ) == NULL )
285 : {
286 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DFT Stereo Config\n" ) );
287 : }
288 :
289 19424 : if ( ( hStereoDft_loc->hItd = (ITD_DATA_HANDLE) malloc( sizeof( ITD_DATA ) ) ) == NULL )
290 : {
291 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for ITD data\n" ) );
292 : }
293 :
294 19424 : hStereoDft_loc->hConfig->force_mono_transmission = 0;
295 :
296 19424 : stereo_dft_config( hStereoDft_loc->hConfig, IVAS_24k4, &tmpS, &tmpS );
297 :
298 19424 : stereo_dft_enc_open( hStereoDft_loc, input_Fs, max_bwidth );
299 :
300 19424 : stereo_dft_hybrid_ITD_flag( hStereoDft_loc->hConfig, input_Fs,
301 19424 : hStereoDft_loc->hItd->hybrid_itd_max );
302 :
303 19424 : *hStereoDft = hStereoDft_loc;
304 :
305 19424 : return IVAS_ERR_OK;
306 : }
307 :
308 :
309 : /*-------------------------------------------------------------------------
310 : * stereo_dft_enc_open()
311 : *
312 : * Initialize DFT stereo handle
313 : *------------------------------------------------------------------------*/
314 :
315 19424 : static void stereo_dft_enc_open(
316 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder DFT stereo handle */
317 : const int32_t input_Fs, /* i : input sampling rate */
318 : const int16_t max_bwidth /* i : maximum encoded bandwidth */
319 : )
320 : {
321 : int16_t NFFT_inner;
322 : float win[STEREO_DFT_OVL_MAX];
323 :
324 : /*Sizes*/
325 19424 : hStereoDft->N = (int16_t) ( STEREO_DFT_HOP_MAX_ENC * input_Fs / 48000 );
326 19424 : assert( ( ( input_Fs / FRAMES_PER_SEC ) / hStereoDft->N ) == 1 );
327 :
328 : /*Init. DFT sizes*/
329 19424 : hStereoDft->NFFT = (int16_t) ( STEREO_DFT_N_MAX_ENC * input_Fs / 48000 );
330 19424 : hStereoDft->dft_ovl = (int16_t) ( STEREO_DFT_OVL_MAX * input_Fs / 48000 );
331 19424 : mdct_window_sine( win, input_Fs, hStereoDft->dft_ovl, FULL_OVERLAP, IVAS_CPE_DFT );
332 :
333 19424 : hStereoDft->win_ana_energy = (float) hStereoDft->N - hStereoDft->dft_ovl;
334 19424 : hStereoDft->win_ana_energy += 2 * sum_f( win, hStereoDft->dft_ovl );
335 19424 : hStereoDft->win_ana_energy = hStereoDft->win_ana_energy / hStereoDft->NFFT;
336 19424 : set_f( hStereoDft->output_mem_dmx_32k, 0, STEREO_DFT_OVL_32k );
337 :
338 19424 : hStereoDft->dft_zp = (int16_t) ( STEREO_DFT_ZP_MAX_ENC * input_Fs / 48000 );
339 :
340 19424 : hStereoDft->dft_trigo_8k = dft_trigo_32k;
341 19424 : hStereoDft->dft_trigo_12k8 = dft_trigo_12k8;
342 19424 : hStereoDft->dft_trigo_16k = dft_trigo_32k;
343 19424 : hStereoDft->dft_trigo_32k = dft_trigo_32k;
344 :
345 19424 : hStereoDft->win_ana_8k = win_ana_8k;
346 19424 : hStereoDft->win_ana_12k8 = win_ana_12k8;
347 19424 : hStereoDft->win_ana_16k = win_ana_16k;
348 19424 : hStereoDft->win_ana_32k = win_ana_32k;
349 :
350 19424 : hStereoDft->win_8k = win_syn_8k;
351 19424 : hStereoDft->win_12k8 = win_syn_12k8;
352 19424 : hStereoDft->win_16k = win_syn_16k;
353 19424 : hStereoDft->win_32k = win_syn_32k;
354 :
355 19424 : if ( input_Fs == 16000 )
356 : {
357 155 : hStereoDft->dft_trigo = dft_trigo_32k;
358 155 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
359 155 : hStereoDft->win_ana = win_ana_16k;
360 155 : hStereoDft->win = win_syn_16k;
361 : }
362 19269 : else if ( input_Fs == 32000 )
363 : {
364 2530 : hStereoDft->dft_trigo = dft_trigo_32k;
365 2530 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
366 2530 : hStereoDft->win_ana = win_ana_32k;
367 2530 : hStereoDft->win = win_syn_32k;
368 : }
369 : else
370 : {
371 16739 : assert( input_Fs == 48000 );
372 16739 : hStereoDft->dft_trigo = dft_trigo_48k;
373 16739 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_48k_STEP;
374 16739 : hStereoDft->win_ana = win_ana_48k;
375 16739 : hStereoDft->win = win_syn_48k;
376 : }
377 :
378 19424 : hStereoDft->win_mdct_8k = win_mdct_8k;
379 :
380 : /*I/O Buffers*/
381 19424 : set_zero( hStereoDft->output_mem_dmx, STEREO_DFT_OVL_MAX );
382 19424 : set_zero( hStereoDft->output_mem_dmx_12k8, STEREO_DFT_OVL_12k8 );
383 19424 : set_zero( hStereoDft->output_mem_dmx_16k, STEREO_DFT_OVL_16k );
384 19424 : set_zero( hStereoDft->output_mem_dmx_16k_shb, STEREO_DFT_OVL_16k );
385 19424 : set_zero( hStereoDft->output_mem_res_8k, STEREO_DFT_OVL_8k );
386 :
387 : /*Bands: find the number of bands, Nyquist freq. is not taken into account*/
388 19424 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[max_bwidth] / L_FRAME48k;
389 19424 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
390 19424 : hStereoDft->nbands_dmx = stereo_dft_band_config( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
391 :
392 : /*Set configuration*/
393 19424 : set_s( hStereoDft->band_res, hStereoDft->hConfig->band_res, STEREO_DFT_ENC_DFT_NB );
394 19424 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode && hStereoDft->NFFT == STEREO_DFT_N_16k_ENC )
395 : {
396 : /* residual coding is only applied for 16 kHz sampling rate */
397 0 : set_s( hStereoDft->res_cod_mode, hStereoDft->hConfig->ada_wb_res_cod_mode, STEREO_DFT_ENC_DFT_NB );
398 : }
399 : else
400 : {
401 19424 : set_s( hStereoDft->res_cod_mode, hStereoDft->hConfig->res_cod_mode, STEREO_DFT_ENC_DFT_NB );
402 : }
403 19424 : set_s( hStereoDft->res_pred_mode, hStereoDft->hConfig->res_pred_mode, STEREO_DFT_ENC_DFT_NB );
404 :
405 : /* reset DFT stereo memories */
406 19424 : stereo_dft_enc_reset( hStereoDft );
407 :
408 19424 : return;
409 : }
410 :
411 : /*-------------------------------------------------------------------------
412 : * stereo_dft_enc_reset()
413 : *
414 : * Reset DFT stereo memories
415 : *------------------------------------------------------------------------*/
416 :
417 38029 : void stereo_dft_enc_reset(
418 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft /* i/o: encoder stereo handle */
419 : )
420 : {
421 : int16_t i;
422 : /*reset parameters*/
423 38029 : set_zero( hStereoDft->side_gain, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
424 38029 : set_s( hStereoDft->side_gain_index_EC, 15, STEREO_DFT_BAND_MAX );
425 38029 : set_s( hStereoDft->side_gain_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
426 38029 : set_s( hStereoDft->side_gain_index_ECprevious, 15, STEREO_DFT_BAND_MAX );
427 38029 : hStereoDft->side_gain_counter = 0;
428 38029 : hStereoDft->side_gain_bitdiff_lp = STEREO_DFT_BITDIFF_INIT;
429 38029 : set_zero( hStereoDft->gipd, STEREO_DFT_ENC_DFT_NB );
430 38029 : set_zero( hStereoDft->dot_prod_real_smooth, STEREO_DFT_BAND_MAX );
431 38029 : set_zero( hStereoDft->dot_prod_img_smooth, STEREO_DFT_BAND_MAX );
432 532406 : for ( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
433 : {
434 494377 : set_zero( hStereoDft->ipd_buf[i], STEREO_DFT_IPD_BUF_LEN );
435 : }
436 38029 : hStereoDft->prev_gipd = 0.f;
437 38029 : hStereoDft->gipd_index = 0;
438 38029 : set_zero( hStereoDft->res_pred_gain, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
439 38029 : set_s( hStereoDft->res_pred_index_EC, 0, STEREO_DFT_BAND_MAX );
440 38029 : set_s( hStereoDft->res_pred_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
441 38029 : set_s( hStereoDft->res_pred_index_ECprevious, 0, STEREO_DFT_BAND_MAX );
442 38029 : hStereoDft->res_pred_counter = 0;
443 38029 : set_zero( hStereoDft->past_nrgL, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
444 38029 : set_zero( hStereoDft->past_nrgR, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
445 38029 : set_zero( hStereoDft->past_dot_prod_real, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
446 38029 : set_zero( hStereoDft->past_dot_prod_imag, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
447 38029 : hStereoDft->nrg_past_pos = 0;
448 :
449 38029 : hStereoDft->res_dmx_ratio_lt = 1.0f;
450 38029 : hStereoDft->hangover_cnt0 = 0;
451 38029 : hStereoDft->hangover_cnt1 = 0;
452 38029 : hStereoDft->dmx_res_all_prev = EPSILON;
453 38029 : hStereoDft->last_res_cod_mode_modify_flag = 0;
454 38029 : hStereoDft->res_cod_sw_flag = 0;
455 38029 : hStereoDft->switch_fade_factor = 0.5f;
456 38029 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1] = STEREO_DFT_RES_COD_1kHz;
457 532406 : for ( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
458 : {
459 494377 : hStereoDft->res_cod_NRG_M[i] = 0;
460 494377 : hStereoDft->res_cod_NRG_S[i] = 0;
461 : }
462 38029 : hStereoDft->old_snr = 0.f;
463 :
464 :
465 38029 : hStereoDft->reverb_flag = 0;
466 38029 : set_zero( hStereoDft->pre_sub_nrg_DMX, STEREO_DFT_BAND_MAX );
467 38029 : hStereoDft->diff_l_h_sm = 0.0f;
468 38029 : hStereoDft->diff_r_h_sm = 0.0f;
469 38029 : hStereoDft->prev_fac2 = 1.0f;
470 :
471 38029 : set_zero( hStereoDft->res_pred_gain_f, STEREO_DFT_BAND_MAX );
472 :
473 : /*misc*/
474 38029 : hStereoDft->no_ipd_flag = 1; /* Initialization of the no IPD variables */
475 38029 : hStereoDft->prev_no_ipd_flag = 1;
476 38029 : hStereoDft->no_ipd_cnt = 0;
477 38029 : hStereoDft->no_ipd_cnt1 = 0;
478 38029 : hStereoDft->attackPresent = 0;
479 38029 : hStereoDft->wasTransient = 0;
480 38029 : hStereoDft->gainIPD_sm = 1.f;
481 :
482 :
483 38029 : hStereoDft->voicing_lt = 0;
484 :
485 38029 : hStereoDft->flip_sign = 1;
486 :
487 38029 : hStereoDft->sfm = 0.f;
488 38029 : hStereoDft->sum_dot_prod_real = 0.f;
489 38029 : hStereoDft->sum_dot_prod_img = 0.f;
490 :
491 : /*Coherence*/
492 38029 : set_f( hStereoDft->xspec_smooth, 1.0f, STEREO_DFT_N_32k_ENC );
493 38029 : set_f( hStereoDft->Spd_L_smooth, 1.0f, STEREO_DFT_N_32k_ENC / 2 );
494 38029 : set_f( hStereoDft->Spd_R_smooth, 1.0f, STEREO_DFT_N_32k_ENC / 2 );
495 :
496 38029 : hStereoDft->currentNumUpdates = 0;
497 38029 : hStereoDft->expectedNumUpdates = FIXED_SID_RATE;
498 38029 : hStereoDft->resetFrames = 0;
499 38029 : hStereoDft->sid_gipd = 0;
500 38029 : hStereoDft->prev_sid_gipd = 0;
501 38029 : hStereoDft->prev_sid_no_ipd_flag = 1;
502 :
503 38029 : hStereoDft->coh_fade_counter = 0;
504 :
505 : /* Xtalk classifier */
506 38029 : hStereoDft->hItd->prev_m1 = 0;
507 38029 : hStereoDft->hItd->prev_m2 = 0;
508 38029 : hStereoDft->hItd->prev_itd1 = 0;
509 38029 : hStereoDft->hItd->prev_itd2 = 0;
510 :
511 38029 : hStereoDft->first_frm_flag = 1;
512 :
513 : #ifdef DEBUG_MODE_DFT
514 : hStereoDft->verbose = 1;
515 : #endif
516 :
517 38029 : stereo_enc_itd_init( hStereoDft->hItd );
518 :
519 38029 : return;
520 : }
521 :
522 :
523 : /*-------------------------------------------------------------------------
524 : * stereo_enc_itd_init()
525 : *
526 : * initialize ITD struct
527 : *------------------------------------------------------------------------*/
528 :
529 39862 : void stereo_enc_itd_init(
530 : ITD_DATA_HANDLE hItd /* i/o: encoder ITD handle */
531 : )
532 : {
533 39862 : hItd->prev_itd = 0;
534 39862 : set_zero( hItd->itd, STEREO_DFT_ENC_DFT_NB );
535 39862 : set_zero( hItd->deltaItd, STEREO_DFT_ENC_DFT_NB );
536 39862 : set_s( hItd->td_itd, 0, STEREO_DFT_ENC_DFT_NB );
537 39862 : set_s( hItd->td_itd_32k, 0, STEREO_DFT_ENC_DFT_NB );
538 39862 : set_s( hItd->itd_index, 0, STEREO_DFT_ENC_DFT_NB );
539 39862 : set_zero( hItd->xcorr_smooth, STEREO_DFT_N_32k_ENC );
540 39862 : hItd->lp_phat_peak = 0.f;
541 39862 : hItd->itd_hangover = 0;
542 39862 : hItd->itd_cnt = 0;
543 39862 : hItd->prev_sum_nrg_L_lb = 0.f;
544 39862 : set_zero( hItd->prev_xcorr_lb, STEREO_DFT_XCORR_LB_MAX );
545 39862 : set_f( hItd->E_band_n, (float) ITD_VAD_E_BAND_N_INIT, STEREO_DFT_ITD_VAD_BAND_NUM );
546 39862 : hItd->vad_frm_cnt = 0;
547 39862 : hItd->pre_vad = 0;
548 39862 : hItd->itd_nonzero_cnt = 0;
549 39862 : set_zero( hItd->acorr_L, STEREO_DFT_BAND_MAX );
550 39862 : set_zero( hItd->acorr_R, STEREO_DFT_BAND_MAX );
551 39862 : hItd->cohSNR = 15.f;
552 39862 : hItd->itd_thres = 0.f;
553 39862 : hItd->valid_itd_cnt = 0;
554 :
555 39862 : hItd->detected_itd_flag = 0;
556 39862 : hItd->itd_tracking = 0;
557 39862 : hItd->prev_max = 0.f;
558 39862 : hItd->prev_index = 0;
559 39862 : hItd->prev_avg_max = 0.f;
560 39862 : hItd->currFlatness = 0.f;
561 :
562 : /* Xtalk classifier */
563 39862 : hItd->prev_m1 = 0;
564 39862 : hItd->prev_m2 = 0;
565 39862 : hItd->prev_itd1 = 0;
566 39862 : hItd->prev_itd2 = 0;
567 :
568 39862 : hItd->hybrid_itd_max = 0;
569 39862 : return;
570 : }
571 :
572 :
573 : /*--------------------------------------------------------------------------
574 : * stereo_dft_enc_update()
575 : *
576 : * Update DFT stereo memories for new frame
577 : *--------------------------------------------------------------------------*/
578 :
579 871106 : void stereo_dft_enc_update(
580 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
581 : const int16_t max_bwidth /* i : maximum encoded bandwidth */
582 : )
583 : {
584 : int16_t i, k_offset;
585 : int16_t NFFT_inner;
586 :
587 : /* Initialization */
588 871106 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
589 :
590 : /* Update the parameters and serial */
591 12195484 : for ( i = 0; i < k_offset * STEREO_DFT_BAND_MAX; i++ )
592 : {
593 11324378 : hStereoDft->side_gain[i] = hStereoDft->side_gain[STEREO_DFT_BAND_MAX + i];
594 11324378 : hStereoDft->res_pred_gain[i] = hStereoDft->res_pred_gain[STEREO_DFT_BAND_MAX + i];
595 : }
596 :
597 1742212 : for ( i = 0; i < k_offset; i++ )
598 : {
599 871106 : hStereoDft->gipd[i] = hStereoDft->gipd[i + 1];
600 : }
601 :
602 : /*Update configurations*/
603 1742212 : for ( i = 0; i < k_offset; i++ )
604 : {
605 871106 : hStereoDft->band_res[i] = hStereoDft->band_res[i + 1];
606 871106 : hStereoDft->hItd->itd[i] = hStereoDft->hItd->itd[i + 1];
607 871106 : hStereoDft->res_cod_mode[i] = hStereoDft->res_cod_mode[i + 1];
608 871106 : hStereoDft->res_pred_mode[i] = hStereoDft->res_pred_mode[i + 1];
609 : }
610 :
611 : /*Set new configurations*/
612 871106 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
613 :
614 871106 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode && hStereoDft->NFFT == STEREO_DFT_N_16k_ENC )
615 : {
616 35514 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->ada_wb_res_cod_mode;
617 : }
618 : else
619 : {
620 835592 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->res_cod_mode;
621 : }
622 871106 : hStereoDft->res_pred_mode[k_offset] = hStereoDft->hConfig->res_pred_mode;
623 :
624 871106 : hStereoDft->last_res_cod_mode_modify_flag = hStereoDft->res_cod_sw_flag;
625 871106 : hStereoDft->res_cod_sw_flag = 0;
626 :
627 : /* update band limits in case of rate switching assuming max_bwidth as BWD output not yet know here */
628 871106 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[max_bwidth] / L_FRAME48k;
629 :
630 871106 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
631 871106 : hStereoDft->nbands_dmx = stereo_dft_band_config( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
632 :
633 : /*Compute main parameters*/
634 871106 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
635 871106 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
636 871106 : hStereoDft->res_cod_line_max = (int16_t) ( 0.5f + ( hStereoDft->band_limits[hStereoDft->res_cod_band_max] - 1 ) * 2.f * hStereoDft->N / (float) ( hStereoDft->NFFT ) );
637 871106 : hStereoDft->res_cod_line_max = 8 * ( hStereoDft->res_cod_line_max / 8 );
638 871106 : hStereoDft->res_pred_band_min = max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
639 :
640 : #ifdef DEBUG_MODE_DFT
641 : /*Compute the expected bitrate*/
642 : if ( hStereoDft->verbose )
643 : {
644 : int16_t tmp, nbits, N_div_param, bits_itd;
645 : int16_t input_frame = hStereoDft->N;
646 : int32_t input_Fs;
647 : input_Fs = input_frame * FRAMES_PER_SEC;
648 :
649 : hStereoDft->verbose = 0;
650 :
651 : /*init*/
652 : N_div_param = 1;
653 :
654 : nbits = 0; /*header: 0 bits*/
655 :
656 : fprintf( stderr, "Stereo DFT\n" );
657 :
658 : /*ITD*/
659 : tmp = 1 + STEREO_DFT_ITD_NBITS;
660 : nbits += 1;
661 : bits_itd = STEREO_DFT_ITD_NBITS;
662 : fprintf( stderr, "\t ITD: %.2f kbps\n", tmp * input_Fs / ( 1000.f * input_frame ) );
663 :
664 : /*SIDE_GAIN*/
665 : tmp = hStereoDft->nbands * 5 * N_div_param;
666 : nbits += tmp;
667 : fprintf( stderr, "\t SIDE_GAIN: %.2f kbps\n", tmp * input_Fs / ( 1000.f * input_frame ) );
668 :
669 :
670 : /*residual coding prediction*/
671 : tmp = 0;
672 : if ( hStereoDft->hConfig->res_pred_mode )
673 : {
674 : tmp = ( hStereoDft->nbands - hStereoDft->res_pred_band_min ) * 3 * N_div_param;
675 : fprintf( stderr, "\t Res pred.: %.2f kbps\n", tmp * input_Fs / ( 1000.f * input_frame ) );
676 : }
677 : nbits += max( tmp, bits_itd );
678 :
679 : /*residual coding*/
680 : if ( hStereoDft->hConfig->res_cod_mode )
681 : {
682 : tmp = hStereoDft->res_cod_bits;
683 : nbits += tmp;
684 : fprintf( stderr, "\t Res cod.: %.2f kbps\n", tmp * input_Fs / ( 1000.f * input_frame ) );
685 : }
686 :
687 : fprintf( stderr, "\t Total: %.2f kbps\n", nbits * input_Fs / ( 1000.f * input_frame ) );
688 : }
689 : #endif /*DEBUGGING*/
690 :
691 871106 : return;
692 : }
693 :
694 :
695 : /*-------------------------------------------------------------------------
696 : * stereo_dft_enc_destroy()
697 : *
698 : * destroy DFT stereo handle
699 : *-------------------------------------------------------------------------*/
700 :
701 19424 : void stereo_dft_enc_destroy(
702 : STEREO_DFT_ENC_DATA_HANDLE *hStereoDft /* i/o: encoder DFT stereo handle */
703 : )
704 : {
705 19424 : if ( ( *hStereoDft )->hConfig != NULL )
706 : {
707 19424 : free( ( *hStereoDft )->hConfig );
708 19424 : ( *hStereoDft )->hConfig = NULL;
709 : }
710 :
711 19424 : if ( ( *hStereoDft )->hItd != NULL )
712 : {
713 19424 : free( ( *hStereoDft )->hItd );
714 19424 : ( *hStereoDft )->hItd = NULL;
715 : }
716 :
717 19424 : free( *hStereoDft );
718 19424 : *hStereoDft = NULL;
719 :
720 19424 : return;
721 : }
722 :
723 :
724 : /*-------------------------------------------------------------------------
725 : * stereo_dft_enc_analyze()
726 : *
727 : * DFT analysis on a 20ms frame
728 : *-------------------------------------------------------------------------*/
729 :
730 1038781 : void stereo_dft_enc_analyze(
731 : Encoder_State **sts, /* i/o: encoder state structure */
732 : const int16_t n_channels, /* i : number of input channels */
733 : const int16_t input_frame, /* i : input frame length */
734 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
735 : STEREO_MDCT_ENC_DATA_HANDLE hStereoMdct, /* i/o: encoder MDCT stereo handle */
736 : float DFT[CPE_CHANNELS][STEREO_DFT_N_MAX_ENC], /* o : DFT buffers */
737 : float *input_mem[CPE_CHANNELS] /* i/o: input buffer memory */
738 : )
739 : {
740 : int16_t i, n;
741 : float *pDFT_L, *pDFT_R;
742 : int16_t N, NFFT;
743 : int16_t dft_zp, dft_ovl;
744 : const float *pWin, *pTrigo;
745 : int16_t offset;
746 : float *input[CPE_CHANNELS], *mem[CPE_CHANNELS];
747 : float trigo_enc[STEREO_DFT_N_MAX_ENC / 2 + 1];
748 : int16_t trigo_step;
749 :
750 :
751 1038781 : push_wmops( "DFT_analysis" );
752 :
753 : /*-----------------------------------------------------------------*
754 : * Initialization
755 : *-----------------------------------------------------------------*/
756 :
757 3116343 : for ( n = 0; n < n_channels; n++ )
758 : {
759 2077562 : input[n] = sts[n]->input;
760 2077562 : mem[n] = input_mem[n];
761 : }
762 :
763 : #ifdef DEBUG_MODE_DFT
764 : {
765 : int16_t tmp[1024];
766 :
767 : /* stereo side info is only simulated */
768 : for ( i = 0; i < input_frame; i++ )
769 : {
770 : tmp[i] = (int16_t) ( input[0][i] + 0.5f );
771 : }
772 : dbgwrite( tmp, sizeof( int16_t ), input_frame, 1, "./res/stereo_dft_ch0_input.pcm" );
773 : for ( i = 0; i < input_frame; i++ )
774 : {
775 : tmp[i] = (int16_t) ( input[1][i] + 0.5f );
776 : }
777 : dbgwrite( tmp, sizeof( int16_t ), input_frame, 1, "./res/stereo_dft_ch1_input.pcm" );
778 : }
779 : #endif
780 :
781 : /*-----------------------------------------------------------------*
782 : * DFT Analysis
783 : *-----------------------------------------------------------------*/
784 :
785 1038781 : pDFT_L = DFT[0];
786 1038781 : pDFT_R = DFT[1];
787 :
788 1038781 : if ( hStereoDft != NULL )
789 : {
790 871106 : N = hStereoDft->N;
791 871106 : NFFT = hStereoDft->NFFT;
792 871106 : dft_zp = hStereoDft->dft_zp;
793 871106 : dft_ovl = hStereoDft->dft_ovl;
794 871106 : offset = -dft_ovl;
795 871106 : pWin = hStereoDft->win_ana;
796 871106 : pTrigo = hStereoDft->dft_trigo;
797 871106 : trigo_step = hStereoDft->dft_trigo_step;
798 : }
799 : else
800 : {
801 167675 : N = hStereoMdct->hDft_ana->N;
802 167675 : NFFT = hStereoMdct->hDft_ana->NFFT;
803 167675 : dft_zp = hStereoMdct->hDft_ana->dft_zp;
804 167675 : dft_ovl = hStereoMdct->hDft_ana->dft_ovl;
805 167675 : offset = -dft_ovl;
806 167675 : pWin = hStereoMdct->hDft_ana->win_ana;
807 167675 : pTrigo = hStereoMdct->hDft_ana->dft_trigo;
808 167675 : trigo_step = hStereoMdct->hDft_ana->dft_trigo_step;
809 : }
810 :
811 371618461 : for ( i = 0; i < NFFT / 4; i++ )
812 : {
813 370579680 : trigo_enc[i] = pTrigo[i * trigo_step];
814 370579680 : trigo_enc[NFFT / 2 - i] = pTrigo[i * trigo_step];
815 : }
816 1038781 : trigo_enc[NFFT / 4] = pTrigo[NFFT / 4 * trigo_step];
817 :
818 : /*Forwards FFT: L and R*/
819 : /*zero padding*/
820 209489851 : for ( i = 0; i < dft_zp; i++ )
821 : {
822 208451070 : pDFT_L[i] = 0.f;
823 208451070 : pDFT_L[NFFT - 1 - i] = 0.f;
824 :
825 208451070 : pDFT_R[i] = 0.f;
826 208451070 : pDFT_R[NFFT - 1 - i] = 0.f;
827 : }
828 :
829 : /*overlapping parts*/
830 325296001 : for ( i = 0; i < dft_ovl; i++ )
831 : {
832 324257220 : pDFT_L[dft_zp + i] = mem[0][i] * pWin[i];
833 324257220 : pDFT_L[dft_zp + N + dft_ovl - 1 - i] = input[0][offset + N + dft_ovl - 1 - i] * pWin[i];
834 :
835 324257220 : pDFT_R[dft_zp + i] = mem[1][i] * pWin[i];
836 324257220 : pDFT_R[dft_zp + N + dft_ovl - 1 - i] = input[1][offset + N + dft_ovl - 1 - i] * pWin[i];
837 : }
838 :
839 : /*middle part*/
840 417940921 : for ( i = 0; i < N - dft_ovl; i++ )
841 : {
842 416902140 : pDFT_L[dft_zp + dft_ovl + i] = input[0][offset + dft_ovl + i];
843 :
844 416902140 : pDFT_R[dft_zp + dft_ovl + i] = input[1][offset + dft_ovl + i];
845 : }
846 :
847 1038781 : rfft( pDFT_L, trigo_enc, NFFT, -1 );
848 1038781 : rfft( pDFT_R, trigo_enc, NFFT, -1 );
849 :
850 : /* update pointers to overlap memory */
851 3116343 : for ( n = 0; n < n_channels; n++ )
852 : {
853 2077562 : mem[n] = &input[n][N - dft_ovl];
854 : }
855 :
856 : #ifdef DEBUG_MODE_DFT
857 : if ( hStereoDft != NULL && hStereoDft->hConfig->hybrid_itd_flag && hStereoDft->hConfig->itd_mode && hStereoDft->hItd->td_itd[STEREO_DFT_OFFSET] )
858 : #else
859 1038781 : if ( hStereoDft != NULL && hStereoDft->hConfig->hybrid_itd_flag && hStereoDft->hItd->td_itd[STEREO_DFT_OFFSET] )
860 : #endif
861 : {
862 245838 : for ( n = 0; n < n_channels; n++ )
863 : {
864 163892 : mvr2r( hStereoDft->input_mem_itd[n], input_mem[n], dft_ovl );
865 : }
866 : }
867 : else
868 : {
869 2870505 : for ( n = 0; n < n_channels; n++ )
870 : {
871 1913670 : mvr2r( input[n] + input_frame - dft_ovl, input_mem[n], dft_ovl );
872 : }
873 : }
874 :
875 1038781 : pop_wmops();
876 1038781 : return;
877 : }
878 :
879 :
880 : /*-------------------------------------------------------------------------
881 : * stereo_dft_enc_synthesize()
882 : *
883 : * Inverse DFT on a 20ms frame
884 : *-------------------------------------------------------------------------*/
885 :
886 3161561 : float stereo_dft_enc_synthesize(
887 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
888 : float *output, /* o : output synthesis */
889 : const int16_t chan, /* i : channel number */
890 : const int32_t input_Fs, /* i : input sampling rate */
891 : const int32_t output_sampling_rate, /* i : output sampling rate */
892 : const int16_t L_frame /* i : frame length at internal Fs */
893 : )
894 : {
895 : int16_t i, j, sign;
896 : float *pDFT_in;
897 : int16_t offset, NFFT, N, ovl, zp;
898 : float fac;
899 : float *mem;
900 : const float *trigo, *win, *win_ana;
901 : float tmp[STEREO_DFT_N_MAX_ENC];
902 : float nrg;
903 : float trigo_enc[STEREO_DFT_N_MAX_ENC / 2 + 1];
904 : int16_t trigo_step;
905 :
906 :
907 : /*-----------------------------------------------------------------*
908 : * Initialization
909 : *-----------------------------------------------------------------*/
910 :
911 3161561 : if ( L_frame > 0 )
912 : {
913 401410 : assert( ( output_sampling_rate == 16000 ) && "High-band generation only possible at 16kHz!" );
914 : }
915 3161561 : nrg = 0.f;
916 :
917 3161561 : hStereoDft->icbweRefEner = 0;
918 3161561 : hStereoDft->lbEner = 0;
919 :
920 3161561 : if ( chan == 0 )
921 : {
922 2896477 : pDFT_in = hStereoDft->DFT[0];
923 : }
924 : else
925 : {
926 265084 : pDFT_in = hStereoDft->DFT[1];
927 : }
928 :
929 3161561 : if ( output_sampling_rate == input_Fs )
930 : {
931 871106 : assert( chan == 0 );
932 :
933 871106 : NFFT = hStereoDft->NFFT;
934 871106 : fac = 1.f;
935 871106 : N = hStereoDft->N;
936 871106 : ovl = hStereoDft->dft_ovl;
937 871106 : zp = hStereoDft->dft_zp;
938 871106 : trigo = hStereoDft->dft_trigo;
939 871106 : trigo_step = hStereoDft->dft_trigo_step;
940 871106 : if ( L_frame > 0 )
941 : {
942 0 : mem = hStereoDft->output_mem_dmx_16k_shb;
943 : }
944 : else
945 : {
946 871106 : mem = hStereoDft->output_mem_dmx;
947 : }
948 871106 : win = hStereoDft->win;
949 871106 : win_ana = hStereoDft->win_ana;
950 :
951 871106 : push_wmops( "DFT_synth_fs" );
952 : }
953 2290455 : else if ( output_sampling_rate == INT_FS_12k8 )
954 : {
955 871106 : assert( chan == 0 );
956 :
957 871106 : NFFT = STEREO_DFT_N_12k8_ENC;
958 871106 : N = STEREO_DFT_HOP_12k8_ENC;
959 871106 : zp = STEREO_DFT_ZP_12k8_ENC;
960 871106 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
961 871106 : ovl = STEREO_DFT_OVL_12k8;
962 871106 : trigo = hStereoDft->dft_trigo_12k8;
963 871106 : trigo_step = STEREO_DFT_TRIGO_SRATE_12k8_STEP;
964 871106 : mem = hStereoDft->output_mem_dmx_12k8;
965 871106 : win = hStereoDft->win_12k8;
966 871106 : win_ana = hStereoDft->win_ana_12k8;
967 :
968 871106 : push_wmops( "DFT_synth_12k8" );
969 : }
970 1419349 : else if ( output_sampling_rate == 16000 )
971 : {
972 1122228 : assert( chan == 0 );
973 :
974 1122228 : NFFT = STEREO_DFT_N_16k_ENC;
975 1122228 : N = STEREO_DFT_HOP_16k_ENC;
976 1122228 : zp = STEREO_DFT_ZP_16k_ENC;
977 1122228 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
978 1122228 : ovl = STEREO_DFT_OVL_16k;
979 1122228 : trigo = hStereoDft->dft_trigo_16k;
980 1122228 : trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
981 1122228 : if ( L_frame > 0 )
982 : {
983 401410 : mem = hStereoDft->output_mem_dmx_16k_shb;
984 :
985 401410 : push_wmops( "DFT_synth_16k_shb" );
986 : }
987 : else
988 : {
989 720818 : mem = hStereoDft->output_mem_dmx_16k;
990 :
991 720818 : push_wmops( "DFT_synth_16k" );
992 : }
993 1122228 : win = hStereoDft->win_16k;
994 1122228 : win_ana = hStereoDft->win_ana_16k;
995 : }
996 297121 : else if ( output_sampling_rate == 32000 )
997 : {
998 32037 : assert( chan == 0 );
999 :
1000 32037 : NFFT = STEREO_DFT_N_32k_ENC;
1001 32037 : N = STEREO_DFT_HOP_32k_ENC;
1002 32037 : zp = STEREO_DFT_ZP_32k_ENC;
1003 32037 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1004 32037 : ovl = STEREO_DFT_OVL_32k;
1005 32037 : trigo = hStereoDft->dft_trigo_32k;
1006 32037 : trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
1007 32037 : mem = hStereoDft->output_mem_dmx_32k;
1008 32037 : win = hStereoDft->win_32k;
1009 32037 : win_ana = hStereoDft->win_ana_32k;
1010 :
1011 32037 : push_wmops( "DFT_synth_32k" );
1012 : }
1013 265084 : else if ( output_sampling_rate == 8000 )
1014 : {
1015 265084 : assert( chan == 1 );
1016 :
1017 265084 : NFFT = STEREO_DFT_N_8k_ENC;
1018 265084 : N = STEREO_DFT_HOP_8k_ENC;
1019 265084 : zp = STEREO_DFT_ZP_8k_ENC;
1020 265084 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1021 265084 : ovl = STEREO_DFT_OVL_8k;
1022 265084 : trigo = hStereoDft->dft_trigo_8k;
1023 265084 : trigo_step = STEREO_DFT_TRIGO_SRATE_8k_STEP;
1024 265084 : mem = hStereoDft->output_mem_res_8k;
1025 265084 : win = hStereoDft->win_8k;
1026 265084 : win_ana = hStereoDft->win_ana_8k;
1027 :
1028 265084 : push_wmops( "DFT_synth_8k" );
1029 : }
1030 : else
1031 : {
1032 0 : assert( 0 && "DFT stereo: sampling rate not supported!" );
1033 : NFFT = -1; /* to avoid compilation warning */
1034 : fac = -1; /* to avoid compilation warning */
1035 : N = -1; /* to avoid compilation warning */
1036 : zp = -1; /* to avoid compilation warning */
1037 : win = NULL; /* to avoid compilation warning */
1038 : trigo = NULL; /* to avoid compilation warning */
1039 : trigo_step = -1; /* to avoid compilation warning */
1040 : ovl = -1; /* to avoid compilation warning */
1041 : mem = NULL; /* to avoid compilation warning */
1042 : win_ana = NULL; /* to avoid compilation warning */
1043 : }
1044 :
1045 3161561 : offset = 0;
1046 :
1047 645194649 : for ( i = 0; i < NFFT / 4; i++ )
1048 : {
1049 642033088 : trigo_enc[i] = trigo[i * trigo_step];
1050 642033088 : trigo_enc[NFFT / 2 - i] = trigo[i * trigo_step];
1051 : }
1052 3161561 : trigo_enc[NFFT / 4] = trigo[NFFT / 4 * trigo_step];
1053 :
1054 : /*-----------------------------------------------------------------*
1055 : * Synthesizing & resampling
1056 : *-----------------------------------------------------------------*/
1057 :
1058 3161561 : offset = -ovl;
1059 :
1060 3161561 : if ( L_frame == L_FRAME || L_frame == L_FRAME16k )
1061 : {
1062 128852610 : for ( i = (int16_t) ( 200 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ); i < (int16_t) ( 400 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ); i++ )
1063 : {
1064 128451200 : hStereoDft->icbweRefEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1065 : }
1066 128852610 : for ( i = 0; i < (int16_t) ( 200 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ); i++ )
1067 : {
1068 128451200 : hStereoDft->lbEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1069 : }
1070 401410 : hStereoDft->icbweRefEner *= fac;
1071 401410 : hStereoDft->lbEner *= fac;
1072 : }
1073 :
1074 : /*Flip?*/
1075 3161561 : if ( L_frame == L_FRAME )
1076 : {
1077 : /* 6 to 14 kHz SHB target signal*/
1078 216899 : j = 2;
1079 216899 : set_zero( tmp, STEREO_DFT_N_MAX_ENC );
1080 216899 : sign = hStereoDft->flip_sign;
1081 :
1082 69841478 : for ( i = (int16_t) ( 350 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ); i >= (int16_t) 150 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i-- )
1083 : {
1084 : /* alternate sign between frames for even starting index */
1085 69624579 : tmp[j++] = sign * pDFT_in[2 * i] * fac;
1086 69624579 : tmp[j++] = -sign * pDFT_in[2 * i + 1] * fac;
1087 : }
1088 216899 : hStereoDft->flip_sign = -sign;
1089 :
1090 35137638 : for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1091 : {
1092 34920739 : nrg += tmp[2 * i] * tmp[2 * i];
1093 34920739 : nrg += tmp[2 * i + 1] * tmp[2 * i + 1];
1094 : }
1095 : }
1096 2944662 : else if ( L_frame == L_FRAME16k )
1097 : {
1098 : /* 7.5 - 15.5 kHz SHB target signal*/
1099 184511 : j = 2;
1100 184511 : set_zero( tmp, STEREO_DFT_N_MAX_ENC );
1101 59228031 : for ( i = (int16_t) ( 400 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ) - 1; i >= (int16_t) 200 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i-- )
1102 : {
1103 59043520 : tmp[j++] = pDFT_in[2 * i] * fac;
1104 59043520 : tmp[j++] = -1.f * pDFT_in[2 * i + 1] * fac;
1105 : }
1106 :
1107 29890782 : for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1108 : {
1109 29706271 : nrg += tmp[2 * i] * tmp[2 * i];
1110 29706271 : nrg += tmp[2 * i + 1] * tmp[2 * i + 1];
1111 : }
1112 : }
1113 2760151 : else if ( fac != 1.f )
1114 : {
1115 : /*Copy and scale*/
1116 1889045 : tmp[0] = pDFT_in[0] * fac;
1117 1889045 : tmp[1] = 0.f;
1118 1031274987 : for ( i = 2; i < NFFT; i++ )
1119 : {
1120 1029385942 : tmp[i] = pDFT_in[i] * fac;
1121 : }
1122 :
1123 1889045 : if ( fac < 1.f )
1124 : {
1125 1889045 : tmp[1] = 0.f; /*Nyquist is set to 0*/
1126 1889045 : tmp[0] = 0.f; /*DC is set to 0*/
1127 : }
1128 : }
1129 : else
1130 : {
1131 1278937026 : for ( i = 0; i < NFFT; i++ )
1132 : {
1133 1278065920 : tmp[i] = pDFT_in[i];
1134 : }
1135 : }
1136 :
1137 : /*Reconstruct */
1138 : /*IFFT*/
1139 3161561 : rfft( tmp, trigo_enc, NFFT, +1 );
1140 :
1141 564940513 : for ( i = 0; i < ovl; i++ )
1142 : {
1143 561778952 : output[offset + i] = mem[i] + tmp[zp + i] * win[i];
1144 561778952 : mem[i] = tmp[zp + N + i] * win[ovl - 1 - i];
1145 : }
1146 :
1147 : /*Middle->Copy*/
1148 725448785 : for ( i = 0; i < N - ovl; i++ )
1149 : {
1150 722287224 : output[offset + ovl + i] = tmp[zp + ovl + i];
1151 : }
1152 :
1153 : /*-----------------------------------------------------------------*
1154 : * Lookahead: redress signal
1155 : *-----------------------------------------------------------------*/
1156 :
1157 564940513 : for ( i = 0; i < ovl; i++ )
1158 : {
1159 561778952 : float ifft_deviation = tmp[zp + N + ovl];
1160 561778952 : output[offset + N + i] = ( tmp[zp + N + i] - ifft_deviation ) / win_ana[ovl - 1 - i] + ifft_deviation;
1161 : }
1162 :
1163 : #ifdef DEBUG_MODE_DFT
1164 : {
1165 : int16_t tmp_dbg[L_FRAME48k];
1166 : #ifdef DEBUG_STEREO_DFT_NOCORE
1167 : static float mem_win[2][STEREO_DFT_OVL_MAX] = { { 0 }, { 0 } };
1168 : #endif
1169 : char file_name[50] = { 0 };
1170 : int16_t input_frame = N;
1171 : int16_t b = 0;
1172 : offset = -ovl;
1173 : b = L_frame;
1174 :
1175 : #ifdef DEBUG_STEREO_DFT_NOCORE
1176 : /*Simulate the un-windowing process which breaks partly TDAC of MDCT*/
1177 : if ( ( ( chan == 1 ) || ( output_sampling_rate == input_Fs ) ) && ( L_frame <= 0 ) )
1178 : {
1179 : float tmp_f[L_FRAME48k + STEREO_DFT_OVL_MAX];
1180 : float MDCT[L_FRAME48k];
1181 :
1182 : /*window signal*/
1183 : for ( i = 0; i < ovl; i++ )
1184 : {
1185 : tmp_f[i] = output[offset + i] * sqrt( win_ana[i] * win[i] );
1186 : tmp_f[input_frame + i] = output[offset + input_frame + i] * sqrt( win_ana[ovl - 1 - i] * win[ovl - 1 - i] );
1187 : }
1188 : /*Middle->Copy*/
1189 : for ( ; i < input_frame; i++ )
1190 : {
1191 : tmp_f[i] = output[offset + i];
1192 : }
1193 :
1194 : /*MDCT -IMDCT (inject Time domain aliasing)*/
1195 : TCX_MDCT( tmp_f, MDCT, ovl, input_frame - ovl, ovl, IVAS_CPE_DFT );
1196 : TCX_MDCT_Inverse( MDCT, tmp_f, ovl, input_frame - ovl, ovl, IVAS_CPE_DFT );
1197 :
1198 : /*OLA*/
1199 : /*overlapping parts*/
1200 : for ( i = 0; i < ovl; i++ )
1201 : {
1202 : tmp_f[i] = mem_win[chan][i] + tmp_f[i] * sqrt( win_ana[i] * win[i] );
1203 : mem_win[chan][i] = tmp_f[input_frame + i] * sqrt( win_ana[ovl - 1 - i] * win[ovl - 1 - i] );
1204 : }
1205 : for ( i = 0; i < input_frame; i++ )
1206 : {
1207 : tmp_dbg[i] = (int16_t) ( tmp_f[i] + 0.5f );
1208 : }
1209 : }
1210 : else
1211 : #endif
1212 : {
1213 : for ( i = 0; i < input_frame; i++ )
1214 : {
1215 : tmp_dbg[i] = (int16_t) ( output[offset + i] + 0.5f );
1216 : }
1217 : }
1218 :
1219 : sprintf( file_name, "./res/stereo_dft_enc_M_S_%d_c%d_b%d.pcm", output_sampling_rate, chan, b );
1220 : dbgwrite( tmp_dbg, sizeof( int16_t ), input_frame, 1, file_name );
1221 : }
1222 : #endif
1223 :
1224 3161561 : pop_wmops();
1225 3161561 : return ( nrg );
1226 : }
1227 :
1228 :
1229 : /*-------------------------------------------------------------------------
1230 : * stereo_dft_enc_process()
1231 : *
1232 : * DFT-based stereo main processing function:
1233 : * 1) compute/encode stereo parameters
1234 : * 2) Mid/Side computation
1235 : *-------------------------------------------------------------------------*/
1236 :
1237 871106 : void stereo_dft_enc_process(
1238 : CPE_ENC_HANDLE hCPE, /* i/o: CPE encoder structure */
1239 : const int16_t vad_flag_dtx[], /* i : VAD dtx flags */
1240 : const int16_t vad_hover_flag[], /* i : VAD hangover flags */
1241 : const int16_t input_frame /* i : input frame length */
1242 : )
1243 : {
1244 : int16_t i, j, b;
1245 : float *pDFT_L, *pDFT_R;
1246 : float *pDFT_DMX;
1247 : float *pDFT_RES;
1248 : int16_t k_offset;
1249 : float *pgIpd;
1250 : float *pSideGain;
1251 : float c, alpha, g;
1252 : float wL, wR, wS;
1253 : float tmp;
1254 : float s, c1, s1;
1255 : float fac_att;
1256 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft;
1257 : float DFT_DMX[STEREO_DFT_N_MAX_ENC];
1258 : float DFT_RES[STEREO_DFT_N_8k_ENC];
1259 : int32_t input_Fs;
1260 : float bin_nrgL[STEREO_DFT_N_MAX_ENC];
1261 : float bin_nrgR[STEREO_DFT_N_MAX_ENC];
1262 : float *pNrgL, *pNrgR;
1263 : float res_nrg_all_curr, dmx_nrg_all_curr;
1264 : float res_dmx_ratio, frame_nrg_ratio;
1265 : float dot_prod_nrg_ratio[STEREO_DFT_BAND_MAX]; /* contains only dot product for higher bands */
1266 : float sum_nrg_L2, sum_nrg_R2, dot_prod_real2;
1267 : float sum_nrg_Mid, sum_abs;
1268 :
1269 : /*------------------------------------------------------------------*
1270 : * Initialization
1271 : *-----------------------------------------------------------------*/
1272 :
1273 871106 : input_Fs = input_frame * FRAMES_PER_SEC;
1274 :
1275 871106 : hStereoDft = hCPE->hStereoDft;
1276 :
1277 871106 : wL = 0; /* avoid compilation warning */
1278 871106 : wR = 0; /* avoid compilation warning */
1279 :
1280 : /* Initialization */
1281 871106 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
1282 :
1283 871106 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
1284 871106 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->res_cod_mode[k_offset]];
1285 871106 : hStereoDft->res_cod_line_max = (int16_t) ( 0.5f + ( hStereoDft->band_limits[hStereoDft->res_cod_band_max] - 1 ) * 2.f * input_frame / (float) ( hStereoDft->NFFT ) );
1286 871106 : hStereoDft->res_cod_line_max = 8 * ( hStereoDft->res_cod_line_max / 8 );
1287 :
1288 871106 : hStereoDft->res_pred_band_min = max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
1289 :
1290 : #ifdef DEBUG_MODE_DFT
1291 : dbgwrite( &( hStereoDft->nbands ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_nbands.dat" );
1292 : #endif
1293 :
1294 871106 : hStereoDft->voicing_lt = 0.75f * hStereoDft->voicing_lt + 0.25f * hCPE->hCoreCoder[0]->voicing[0];
1295 871106 : hStereoDft->voicing_lt = 0.75f * hStereoDft->voicing_lt + 0.25f * hCPE->hCoreCoder[0]->voicing[1];
1296 :
1297 : /*------------------------------------------------------------------*
1298 : * Compute stereo parameters
1299 : *-----------------------------------------------------------------*/
1300 :
1301 : /*ITD in Frequency domain*/
1302 871106 : fac_att = 1.0f;
1303 :
1304 871106 : pDFT_L = hStereoDft->DFT[0];
1305 871106 : pDFT_R = hStereoDft->DFT[1];
1306 :
1307 : #ifdef DEBUG_MODE_DFT
1308 : if ( hStereoDft->hConfig->itd_mode )
1309 : #endif
1310 : {
1311 871106 : stereo_dft_enc_compute_itd( hCPE, pDFT_L, pDFT_R, k_offset, input_frame, vad_flag_dtx, vad_hover_flag, bin_nrgL, bin_nrgR );
1312 871106 : if ( hCPE->element_mode == IVAS_CPE_MDCT )
1313 : {
1314 0 : return;
1315 : }
1316 :
1317 871106 : if ( hStereoDft->hItd->deltaItd[k_offset] != 0 && hStereoDft->hConfig->dmx_active )
1318 : {
1319 : #ifdef NONBE_FIX_NONBE_BETWEEN_OPTIMIZATION_LEVELS
1320 : /* Note: this variable is used as an in-between step when passing the angle to the trig functions.
1321 : * this keeps the compilter from applying optimizations at higher optimizaton levels which can break bit-exactness */
1322 : volatile float alpha_tmp;
1323 : #endif
1324 : /*time shift channels*/
1325 194732 : alpha = -2.0f * EVS_PI * hStereoDft->hItd->deltaItd[k_offset] / hStereoDft->NFFT;
1326 194732 : c = 1.f; /*cos(0)*/
1327 194732 : s = 0.f; /*sin(0)*/
1328 : #ifdef NONBE_FIX_NONBE_BETWEEN_OPTIMIZATION_LEVELS
1329 :
1330 194732 : alpha_tmp = alpha;
1331 194732 : c1 = cosf( alpha_tmp );
1332 194732 : s1 = sinf( alpha_tmp );
1333 : #else
1334 : c1 = cosf( alpha );
1335 : s1 = sinf( alpha );
1336 : #endif
1337 :
1338 194732 : if ( alpha >= 0 )
1339 : {
1340 74966720 : for ( i = 1; i < hStereoDft->NFFT / 2; i++ )
1341 : {
1342 74865132 : tmp = s * c1 + c * s1;
1343 74865132 : c = c * c1 - s * s1;
1344 74865132 : s = tmp;
1345 :
1346 : /*time shift of L*/
1347 74865132 : tmp = pDFT_L[2 * i] * c - pDFT_L[2 * i + 1] * s;
1348 74865132 : pDFT_L[2 * i + 1] = pDFT_L[2 * i] * s + pDFT_L[2 * i + 1] * c;
1349 74865132 : pDFT_L[2 * i] = tmp;
1350 : }
1351 : }
1352 : else
1353 : {
1354 63914240 : for ( i = 1; i < hStereoDft->NFFT / 2; i++ )
1355 : {
1356 63821096 : tmp = s * c1 + c * s1;
1357 63821096 : c = c * c1 - s * s1;
1358 63821096 : s = tmp;
1359 :
1360 : /*time shift of R*/
1361 63821096 : tmp = pDFT_R[2 * i] * c + pDFT_R[2 * i + 1] * s;
1362 63821096 : pDFT_R[2 * i + 1] = -pDFT_R[2 * i] * s + pDFT_R[2 * i + 1] * c;
1363 63821096 : pDFT_R[2 * i] = tmp;
1364 : }
1365 : }
1366 :
1367 194732 : if ( fabsf( hStereoDft->hItd->deltaItd[k_offset] * 32000.f / input_Fs ) > 80.0f )
1368 : {
1369 23614 : fac_att = min( 1.0f, max( 0.2f, 2.6f - 0.02f * fabsf( hStereoDft->hItd->deltaItd[1] ) * 32000.f / input_Fs ) );
1370 : }
1371 : }
1372 :
1373 : /* compute remaining binwise energies for FB mode (ITD function only computes energies up to 16 kHz) */
1374 130488386 : for ( i = STEREO_DFT_N_32k_ENC / 2; i < hStereoDft->NFFT / 2; i++ )
1375 : {
1376 129617280 : bin_nrgL[i] = pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
1377 129617280 : bin_nrgR[i] = pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
1378 : }
1379 : }
1380 : #ifdef DEBUG_MODE_DFT
1381 : else
1382 : {
1383 : /* no ITD computation, get binwise energies here */
1384 :
1385 : for ( i = 0; i < hStereoDft->NFFT / 2; i++ )
1386 : {
1387 : bin_nrgL[i] = pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
1388 : bin_nrgR[i] = pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
1389 : }
1390 : }
1391 : #endif
1392 :
1393 : /* DFT stereo parameters */
1394 871106 : stereo_dft_enc_compute_prm( hStereoDft, pDFT_L, pDFT_R, k_offset, 1, hCPE->hCoreCoder[0]->sp_aud_decision0, hCPE->hCoreCoder[0]->vad_flag, bin_nrgL, bin_nrgR, dot_prod_nrg_ratio );
1395 :
1396 871106 : if ( vad_flag_dtx[0] == 0 )
1397 : {
1398 43803 : if ( hCPE->hStereoCng->cng_counter == 0 && !hCPE->hStereoCng->first_SID_after_TD )
1399 : {
1400 882 : hStereoDft->sid_gipd = hStereoDft->prev_sid_gipd;
1401 882 : hStereoDft->no_ipd_flag = hStereoDft->prev_sid_no_ipd_flag;
1402 : }
1403 :
1404 43803 : if ( hCPE->hStereoCng->cng_counter > ITD_SID_PREV_FRAMES )
1405 : {
1406 38276 : hStereoDft->prev_sid_gipd = hStereoDft->sid_gipd;
1407 38276 : hStereoDft->prev_sid_no_ipd_flag = hStereoDft->no_ipd_flag;
1408 : }
1409 : }
1410 :
1411 : /*----------------------------------------------------------------*
1412 : * UNCLR classifier (detection of uncorrelated L and R channels)
1413 : *----------------------------------------------------------------*/
1414 :
1415 871106 : unclr_classifier_dft( hCPE );
1416 :
1417 : /*------------------------------------------------------------------*
1418 : * Channel mapping: computation of DMX and RES
1419 : *-----------------------------------------------------------------*/
1420 : #ifdef DEBUG_MODE_DFT
1421 : {
1422 : int16_t tmp_dbg = (int16_t) ( 100 * fac_att );
1423 : dbgwrite( &tmp_dbg, sizeof( int16_t ), 1, 1, "./res/stereo_dft_enc_facAtt.pcm" );
1424 : }
1425 : #endif
1426 :
1427 871106 : res_nrg_all_curr = EPSILON;
1428 871106 : dmx_nrg_all_curr = EPSILON;
1429 :
1430 871106 : pDFT_DMX = DFT_DMX;
1431 871106 : pDFT_RES = DFT_RES;
1432 871106 : pNrgL = bin_nrgL;
1433 871106 : pNrgR = bin_nrgR;
1434 :
1435 871106 : set_zero( pDFT_DMX, STEREO_DFT_N_MAX_ENC );
1436 871106 : set_zero( pDFT_RES, STEREO_DFT_N_8k_ENC );
1437 :
1438 871106 : pgIpd = hStereoDft->gipd + k_offset;
1439 871106 : pSideGain = hStereoDft->side_gain + k_offset * STEREO_DFT_BAND_MAX;
1440 :
1441 871106 : if ( hStereoDft->hConfig->dmx_active )
1442 : {
1443 : /*Active DMX*/
1444 871106 : alpha = 0; /* to avoid compilation warning */
1445 871106 : g = 1.f;
1446 :
1447 : /*Apply active DMX*/
1448 871106 : pDFT_DMX[0] = 0.f;
1449 871106 : pDFT_RES[0] = 0.f;
1450 11212437 : for ( b = 0; b < hStereoDft->nbands_dmx; b++ )
1451 : {
1452 10341331 : g = pSideGain[b];
1453 :
1454 10341331 : if ( pgIpd[0] != 0.f )
1455 : {
1456 : #ifdef NONBE_FIX_NONBE_BETWEEN_OPTIMIZATION_LEVELS_2
1457 : volatile float pgIpd_tmp;
1458 :
1459 2441769 : pgIpd_tmp = pgIpd[0];
1460 2441769 : c = cosf( pgIpd_tmp );
1461 2441769 : s = sinf( pgIpd_tmp );
1462 : #else
1463 : c = cosf( pgIpd[0] );
1464 : s = sinf( pgIpd[0] );
1465 : #endif
1466 127350401 : for ( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
1467 : {
1468 : /*rotate L*/
1469 124908632 : tmp = pDFT_L[2 * i] * c + pDFT_L[2 * i + 1] * s;
1470 124908632 : pDFT_L[2 * i + 1] = pDFT_L[2 * i + 1] * c - pDFT_L[2 * i] * s;
1471 124908632 : pDFT_L[2 * i] = tmp;
1472 : }
1473 : }
1474 :
1475 10341331 : if ( b < hStereoDft->res_cod_band_max && vad_flag_dtx[0] )
1476 : {
1477 : #ifdef DEBUGGING
1478 : assert( hStereoDft->nbands == hStereoDft->nbands_dmx && "Don't use coarser stereo parameter resolution for residual coding bitrates!" );
1479 : #endif
1480 : #ifdef DEBUG_MODE_DFT
1481 : dbgwrite( &g, sizeof( float ), 1, 1, "./res/stereo_dft_enc_g.pcm" );
1482 : dbgwrite( &alpha, sizeof( float ), 1, 1, "./res/stereo_dft_enc_alpha.pcm" );
1483 : #endif
1484 :
1485 : /*Get the previous frame energy*/
1486 1280505 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode )
1487 : {
1488 : /*Calculate the energy of RES and DMX*/
1489 : /* 90% of old frame ... */
1490 1280505 : dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.9f;
1491 1280505 : res_nrg_all_curr += hStereoDft->res_cod_NRG_S[b] * 0.9f;
1492 : }
1493 1280505 : hStereoDft->res_cod_NRG_M[b] = EPSILON;
1494 1280505 : hStereoDft->res_cod_NRG_S[b] = EPSILON;
1495 :
1496 11780646 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1497 : {
1498 10500141 : pDFT_DMX[2 * i] = ( pDFT_L[2 * i] + pDFT_R[2 * i] ) * 0.5f;
1499 10500141 : pDFT_DMX[2 * i + 1] = ( pDFT_L[2 * i + 1] + pDFT_R[2 * i + 1] ) * 0.5f;
1500 :
1501 10500141 : pDFT_RES[2 * i] = ( pDFT_L[2 * i] - pDFT_R[2 * i] ) * 0.5f;
1502 10500141 : pDFT_RES[2 * i + 1] = ( pDFT_L[2 * i + 1] - pDFT_R[2 * i + 1] ) * 0.5f;
1503 :
1504 : /*Prediction of RES with DMX*/
1505 10500141 : pDFT_RES[2 * i] = pDFT_RES[2 * i] - g * pDFT_DMX[2 * i];
1506 10500141 : pDFT_RES[2 * i + 1] = pDFT_RES[2 * i + 1] - g * pDFT_DMX[2 * i + 1];
1507 :
1508 10500141 : pDFT_RES[2 * i] *= fac_att;
1509 10500141 : pDFT_RES[2 * i + 1] *= fac_att;
1510 :
1511 : /*Energy of the DMX and RES*/
1512 10500141 : hStereoDft->res_cod_NRG_M[b] += pDFT_DMX[2 * i] * pDFT_DMX[2 * i] + pDFT_DMX[2 * i + 1] * pDFT_DMX[2 * i + 1];
1513 10500141 : hStereoDft->res_cod_NRG_S[b] += pDFT_RES[2 * i] * pDFT_RES[2 * i] + pDFT_RES[2 * i + 1] * pDFT_RES[2 * i + 1];
1514 : }
1515 :
1516 1280505 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode )
1517 : {
1518 : /*Calculate the energy of RES and DMX*/
1519 : /* ... + 10% of current frame. */
1520 1280505 : dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.1f;
1521 1280505 : res_nrg_all_curr += hStereoDft->res_cod_NRG_S[b] * 0.1f;
1522 : }
1523 : }
1524 : else
1525 : {
1526 : int16_t upper_border;
1527 : int16_t triple_bin;
1528 : float frac_dot_prod; /* fraction of dot product according to energy ratio of current bins and whole band */
1529 : float Sr, Si;
1530 : float comb_nrgL, comb_nrgR;
1531 :
1532 9060826 : upper_border = min( STEREO_DFT_DMX_CROSSOVER, hStereoDft->band_limits_dmx[b + 1] );
1533 :
1534 9060826 : triple_bin = 0;
1535 9060826 : if ( upper_border > hStereoDft->band_limits_dmx[b] && ( upper_border - hStereoDft->band_limits_dmx[b] ) % 2 )
1536 : {
1537 : /* if odd number of bins in band, combine last 3 bins */
1538 2716121 : triple_bin = 1;
1539 2716121 : upper_border -= 3;
1540 : }
1541 :
1542 91202704 : for ( i = hStereoDft->band_limits_dmx[b]; i < upper_border; i += 2 )
1543 : {
1544 82141878 : comb_nrgL = pNrgL[i] + pNrgL[i + 1];
1545 82141878 : comb_nrgR = pNrgR[i] + pNrgR[i + 1];
1546 82141878 : Sr = ( pDFT_L[2 * i] + pDFT_R[2 * i] ) * ( pDFT_L[2 * i] + pDFT_R[2 * i] ) + ( pDFT_L[2 * i + 2] + pDFT_R[2 * i + 2] ) * ( pDFT_L[2 * i + 2] + pDFT_R[2 * i + 2] );
1547 82141878 : Si = ( pDFT_L[2 * i + 1] + pDFT_R[2 * i + 1] ) * ( pDFT_L[2 * i + 1] + pDFT_R[2 * i + 1] ) + ( pDFT_L[2 * i + 3] + pDFT_R[2 * i + 3] ) * ( pDFT_L[2 * i + 3] + pDFT_R[2 * i + 3] );
1548 :
1549 82141878 : sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
1550 82141878 : frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
1551 82141878 : wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
1552 :
1553 82141878 : wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
1554 :
1555 : /*DMX Mapping*/
1556 82141878 : pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
1557 82141878 : pDFT_DMX[2 * i + 1] = ( wL * pDFT_L[2 * i + 1] + wR * pDFT_R[2 * i + 1] ) * INV_SQRT_2;
1558 82141878 : pDFT_DMX[2 * i + 2] = ( wL * pDFT_L[2 * i + 2] + wR * pDFT_R[2 * i + 2] ) * INV_SQRT_2;
1559 82141878 : pDFT_DMX[2 * i + 3] = ( wL * pDFT_L[2 * i + 3] + wR * pDFT_R[2 * i + 3] ) * INV_SQRT_2;
1560 : }
1561 :
1562 9060826 : if ( triple_bin )
1563 : {
1564 2716121 : comb_nrgL = comb_nrgR = 0.f;
1565 2716121 : Sr = Si = 0.f;
1566 10864484 : for ( j = i; j < i + 3; j++ )
1567 : {
1568 8148363 : comb_nrgL += pNrgL[j];
1569 8148363 : comb_nrgR += pNrgR[j];
1570 8148363 : Sr += ( pDFT_L[2 * j] + pDFT_R[2 * j] ) * ( pDFT_L[2 * j] + pDFT_R[2 * j] );
1571 8148363 : Si += ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] ) * ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] );
1572 : }
1573 :
1574 2716121 : sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
1575 2716121 : frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
1576 2716121 : wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
1577 2716121 : wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
1578 :
1579 10864484 : for ( j = i; j < i + 3; j++ )
1580 : {
1581 8148363 : pDFT_DMX[2 * j] = ( wL * pDFT_L[2 * j] + wR * pDFT_R[2 * j] ) * INV_SQRT_2;
1582 8148363 : pDFT_DMX[2 * j + 1] = ( wL * pDFT_L[2 * j + 1] + wR * pDFT_R[2 * j + 1] ) * INV_SQRT_2;
1583 : }
1584 2716121 : i += 3;
1585 : }
1586 :
1587 9060826 : if ( i < hStereoDft->band_limits_dmx[b + 1] )
1588 : {
1589 2501377 : sum_nrg_L2 = EPSILON;
1590 2501377 : sum_nrg_R2 = EPSILON;
1591 2501377 : dot_prod_real2 = EPSILON;
1592 394125211 : for ( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
1593 : {
1594 391623834 : sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
1595 391623834 : sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
1596 391623834 : dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
1597 : }
1598 :
1599 2501377 : sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
1600 2501377 : sum_abs = sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) + EPSILON;
1601 2501377 : wR = sqrtf( 0.5f * ( sum_nrg_L2 + sum_nrg_R2 ) + dot_prod_nrg_ratio[b] ) / sum_abs;
1602 2501377 : wL = wR + sqrtf( 2.f ) * ( 1.f - sqrtf( sum_nrg_Mid ) / sum_abs );
1603 : }
1604 :
1605 400684660 : for ( ; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
1606 : {
1607 : /*DMX Mapping*/
1608 391623834 : pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
1609 391623834 : pDFT_DMX[2 * i + 1] = ( wL * pDFT_L[2 * i + 1] + wR * pDFT_R[2 * i + 1] ) * INV_SQRT_2;
1610 : }
1611 : }
1612 : }
1613 :
1614 64476866 : for ( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->NFFT / 2; i++ )
1615 : {
1616 63605760 : pDFT_DMX[2 * i] = 0.f;
1617 63605760 : pDFT_DMX[2 * i + 1] = 0.f;
1618 : }
1619 :
1620 : /*Nyquist Freq.*/
1621 871106 : if ( hStereoDft->band_limits_dmx[b] >= hStereoDft->NFFT / 2 )
1622 : {
1623 685784 : pDFT_DMX[1] = ( pDFT_L[1] + pDFT_R[1] ) * 0.5f;
1624 : }
1625 : else
1626 : {
1627 185322 : pDFT_DMX[1] = 0.f;
1628 : }
1629 :
1630 : /* DC component */
1631 871106 : pDFT_DMX[0] = ( pDFT_L[0] + pDFT_R[0] ) * 0.5f;
1632 : }
1633 : else
1634 : {
1635 : #ifndef DEBUG_STEREO_DFT_NOSTEREO
1636 : /*passive DMX*/
1637 0 : assert( hStereoDft->nbands == hStereoDft->nbands_dmx && "Don't use coarser stereo parameter resolution for residual coding bitrates!" );
1638 0 : for ( i = 0; i < hStereoDft->band_limits[hStereoDft->res_cod_band_max]; i++ )
1639 : {
1640 0 : pDFT_DMX[i] = ( pDFT_L[i] + pDFT_R[i] ) * 0.5f;
1641 0 : pDFT_RES[i] = ( pDFT_L[i] - pDFT_R[i] ) * 0.5f;
1642 : }
1643 0 : for ( ; i < hStereoDft->NFFT; i++ )
1644 : {
1645 0 : pDFT_DMX[i] = ( pDFT_L[i] + pDFT_R[i] ) * 0.5f;
1646 : }
1647 : #else
1648 : /*Copy Left channel to DMX and reset residual coding*/
1649 : mvr2r( pDFT_L, DFT_DMX, hStereoDft->NFFT );
1650 : set_zero( pDFT_RES, hStereoDft->NFFT );
1651 :
1652 : /*for( b=0; b<hStereoDft->nbands; b++ )
1653 : {
1654 : if( hStereoDft->res_pred_mode[k+k_offset] && b>= hStereoDft->res_pred_band_min )
1655 : {
1656 : if( (k % hStereoDft->prm_res_enc[k+k_offset]) == (hStereoDft->prm_res_enc[k+k_offset]-1) )
1657 : {
1658 : stereo_dft_quantize_res_pred_gain( pPredGain+b, pPredGain+b, 1, hStereoDft->Ind+(k_offset+k)*STEREO_DFT_PRM_MAX, hStereoDft->nInd+k+k_offset );
1659 : }
1660 : }
1661 : }*/
1662 : #endif
1663 : }
1664 :
1665 : /*------------------------------------------------------------------*
1666 : * Recalculate RES and DMX
1667 : *-----------------------------------------------------------------*/
1668 :
1669 871106 : if ( hStereoDft->NFFT == STEREO_DFT_N_16k_ENC && hStereoDft->hConfig->ada_wb_res_cod_mode )
1670 : {
1671 35514 : stereo_dft_enc_get_res_cod_mode_flag( hStereoDft, res_nrg_all_curr, dmx_nrg_all_curr, &res_dmx_ratio, &frame_nrg_ratio );
1672 :
1673 35514 : if ( hStereoDft->res_cod_sw_flag )
1674 : {
1675 : int16_t res_cod_band_max;
1676 :
1677 288 : res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->hConfig->ada_wb_res_cod_mode];
1678 :
1679 : /* Recalculate RES and DMX */
1680 1728 : for ( b = 0; b < res_cod_band_max; b++ )
1681 : {
1682 1440 : sum_nrg_L2 = EPSILON;
1683 1440 : sum_nrg_R2 = EPSILON;
1684 1440 : dot_prod_real2 = EPSILON;
1685 13248 : for ( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
1686 : {
1687 11808 : sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
1688 11808 : sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
1689 11808 : dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
1690 : }
1691 :
1692 1440 : sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
1693 1440 : wL = 0.5f * max( sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) - sqrtf( sum_nrg_Mid ), 0 ) * inv_sqrt( sum_nrg_L2 + EPSILON );
1694 1440 : wS = 1;
1695 :
1696 1440 : if ( hStereoDft->res_cod_sw_flag )
1697 : {
1698 1440 : wL *= ( 1 - hStereoDft->switch_fade_factor );
1699 1440 : wS = hStereoDft->switch_fade_factor;
1700 : }
1701 :
1702 13248 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1703 : {
1704 : /*DMX Recalculation*/
1705 11808 : DFT_DMX[2 * i] += wL * pDFT_L[2 * i];
1706 11808 : DFT_DMX[2 * i + 1] += wL * pDFT_L[2 * i + 1];
1707 :
1708 : /*RES Recalculation*/
1709 11808 : DFT_RES[2 * i] *= wS;
1710 11808 : DFT_RES[2 * i + 1] *= wS;
1711 : }
1712 : }
1713 : }
1714 : }
1715 :
1716 871106 : if ( input_Fs >= 32000 )
1717 : {
1718 720818 : stereo_dft_enc_calculate_nrg_for_icbwe( hStereoDft, DFT_DMX, input_Fs );
1719 : }
1720 :
1721 871106 : mvr2r( DFT_DMX, hStereoDft->DFT[0], STEREO_DFT_N_MAX_ENC );
1722 871106 : mvr2r( DFT_RES, hStereoDft->DFT[1], STEREO_DFT_N_8k_ENC );
1723 871106 : set_zero( hStereoDft->DFT[1] + STEREO_DFT_N_8k_ENC, STEREO_DFT_N_MAX_ENC - STEREO_DFT_N_8k_ENC );
1724 :
1725 871106 : return;
1726 : }
1727 :
1728 :
1729 : /*-------------------------------------------------------------------------
1730 : * stereo_dft_enc_get_res_cod_mode_flag()
1731 : *
1732 : * Get the residual signal coding flag
1733 : *-------------------------------------------------------------------------*/
1734 :
1735 35514 : static void stereo_dft_enc_get_res_cod_mode_flag(
1736 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
1737 : const float res_nrg_all_curr,
1738 : const float dmx_nrg_all_curr,
1739 : float *res_dmx_ratio,
1740 : float *frame_nrg_ratio )
1741 : {
1742 : int16_t b, k_offset;
1743 : float dmx_res_all, g;
1744 : int16_t fast_update_flag;
1745 : int16_t prev_res_cod_mode_flag, res_cod_mode_flag;
1746 :
1747 35514 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
1748 :
1749 : /*Calculate energy ratio between residual signal and downmix signal */
1750 35514 : *res_dmx_ratio = 0;
1751 :
1752 213084 : for ( b = 0; b < hStereoDft->res_cod_band_max; b++ )
1753 : {
1754 177570 : g = fabsf( hStereoDft->side_gain[(k_offset) *STEREO_DFT_BAND_MAX + b] );
1755 177570 : *res_dmx_ratio = max( hStereoDft->res_cod_NRG_S[b] / ( hStereoDft->res_cod_NRG_S[b] + ( 1 - g ) * ( 1 - g ) * hStereoDft->res_cod_NRG_M[b] + 1 ), *res_dmx_ratio );
1756 : }
1757 35514 : *res_dmx_ratio = check_bounds( *res_dmx_ratio, 0, 1 ); /*should always be satisfied*/
1758 :
1759 : /*Calculate the total energy of RES and DMX*/
1760 35514 : dmx_res_all = res_nrg_all_curr + dmx_nrg_all_curr;
1761 :
1762 : /*Calculate the energy ratio of the inter-frame */
1763 35514 : *frame_nrg_ratio = dmx_res_all / hStereoDft->dmx_res_all_prev;
1764 35514 : *frame_nrg_ratio = min( 5.0f, max( 0.2f, *frame_nrg_ratio ) );
1765 :
1766 : /* Get fast update flag */
1767 35514 : fast_update_flag = 0;
1768 35514 : if ( ( *frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f ) || ( *frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f ) )
1769 : {
1770 803 : fast_update_flag = 1;
1771 : }
1772 :
1773 : /* Calculate long term energy ratio between residual signal and downmix signal */
1774 35514 : if ( fast_update_flag )
1775 : {
1776 803 : hStereoDft->res_dmx_ratio_lt = *res_dmx_ratio * 0.2f + hStereoDft->res_dmx_ratio_lt * 0.8f;
1777 : }
1778 : else
1779 : {
1780 34711 : hStereoDft->res_dmx_ratio_lt = *res_dmx_ratio * 0.05f + hStereoDft->res_dmx_ratio_lt * 0.95f;
1781 : }
1782 :
1783 : /*Get the residual signal coding initial flag */
1784 35514 : if ( hStereoDft->res_dmx_ratio_lt > 0.01f )
1785 : {
1786 33152 : res_cod_mode_flag = 1;
1787 : }
1788 : else
1789 : {
1790 2362 : res_cod_mode_flag = 0;
1791 : }
1792 :
1793 : /* Get the residual signal coding flag */
1794 35514 : if ( hStereoDft->first_frm_flag )
1795 : {
1796 33 : prev_res_cod_mode_flag = res_cod_mode_flag;
1797 33 : hStereoDft->first_frm_flag = 0;
1798 : }
1799 : else
1800 : {
1801 35481 : prev_res_cod_mode_flag = hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1];
1802 : }
1803 35514 : if ( res_cod_mode_flag != prev_res_cod_mode_flag )
1804 : {
1805 1628 : if ( prev_res_cod_mode_flag == 1 )
1806 : {
1807 74 : if ( hStereoDft->hangover_cnt0 < 5 && hStereoDft->last_res_cod_mode_modify_flag == 0 && fast_update_flag == 0 )
1808 : {
1809 50 : res_cod_mode_flag = prev_res_cod_mode_flag;
1810 50 : hStereoDft->hangover_cnt0++;
1811 : }
1812 : else
1813 : {
1814 : /* reset hangover */
1815 24 : hStereoDft->hangover_cnt0 = 0;
1816 : }
1817 : }
1818 : else
1819 : {
1820 1554 : if ( *frame_nrg_ratio > 2.5f || *frame_nrg_ratio < 0.21f )
1821 : {
1822 : /* reset hangover */
1823 51 : hStereoDft->hangover_cnt1 = 0;
1824 : }
1825 : else
1826 : {
1827 1503 : if ( hStereoDft->hangover_cnt1 < 5 )
1828 : {
1829 1275 : res_cod_mode_flag = prev_res_cod_mode_flag;
1830 1275 : hStereoDft->hangover_cnt1++;
1831 : }
1832 : else
1833 : {
1834 : /* reset hangover */
1835 228 : hStereoDft->hangover_cnt1 = 0;
1836 : }
1837 : }
1838 : }
1839 : }
1840 :
1841 : /* handle switching frames */
1842 35514 : if ( res_cod_mode_flag != prev_res_cod_mode_flag && hStereoDft->last_res_cod_mode_modify_flag == 0 )
1843 : {
1844 288 : hStereoDft->res_cod_sw_flag = 1;
1845 :
1846 : /* Update switch_fade_factor */
1847 288 : if ( *frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f )
1848 : {
1849 2 : hStereoDft->switch_fade_factor = 0.75f;
1850 : }
1851 286 : else if ( *frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f )
1852 : {
1853 3 : hStereoDft->switch_fade_factor = 0.25f;
1854 : }
1855 : else
1856 : {
1857 283 : hStereoDft->switch_fade_factor = 0.5f;
1858 : }
1859 :
1860 288 : if ( res_cod_mode_flag == 0 )
1861 : {
1862 12 : res_cod_mode_flag = 1;
1863 : }
1864 : }
1865 :
1866 : /*update previous frame's total energy of RES and DMX */
1867 35514 : hStereoDft->dmx_res_all_prev = dmx_res_all;
1868 :
1869 : /* update residual coding mode */
1870 35514 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] = res_cod_mode_flag;
1871 35514 : if ( !hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
1872 : {
1873 3575 : hStereoDft->res_cod_band_max = 0;
1874 3575 : hStereoDft->res_cod_line_max = 0;
1875 : }
1876 :
1877 : /*Update residual signal memory when switching from not coding residual signal to coding it*/
1878 35514 : if ( prev_res_cod_mode_flag == 0 && res_cod_mode_flag == 1 )
1879 : {
1880 279 : set_zero( hStereoDft->output_mem_res_8k, STEREO_DFT_OVL_8k );
1881 : }
1882 :
1883 : #ifdef DEBUG_MODE_DFT
1884 : /* look at res_nrg_all value */
1885 : {
1886 : static FILE *ResNrgAll_FILE = NULL;
1887 :
1888 : if ( ResNrgAll_FILE == NULL )
1889 : ResNrgAll_FILE = fopen( "./res/stereo_dft_res_nrg.txt", "w" );
1890 : fprintf( ResNrgAll_FILE, "%f\t\t%d\n", hStereoDft->res_dmx_ratio_lt, hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] );
1891 : dbgwrite( &hStereoDft->res_cod_mode[STEREO_DFT_OFFSET], sizeof( int16_t ), 1, 320, "./res/stereo_dft_res_cod_mode_flag.pcm" );
1892 : }
1893 : #endif
1894 35514 : return;
1895 : }
1896 :
1897 :
1898 : /*-------------------------------------------------------------------------
1899 : * stereo_dft_enc_res()
1900 : *
1901 : * Code the residual signal
1902 : *-------------------------------------------------------------------------*/
1903 :
1904 868644 : void stereo_dft_enc_res(
1905 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
1906 : const float *input_8k, /* i : input buffer sampled at 8kHz*/
1907 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
1908 : int16_t *nb_bits, /* o : number of bits written */
1909 : const int16_t max_bits )
1910 : {
1911 : int16_t i, b;
1912 : RangeUniEncState range_uni_enc_state;
1913 : ECSQ_instance ecsq_inst;
1914 : float MDCT_RES[L_FRAME8k];
1915 : float win[L_FRAME8k + STEREO_DFT_OVL_8k];
1916 : int16_t global_gain_index;
1917 : int16_t total_bit_count;
1918 : float max_snr;
1919 : float panning_gain, panning_gain_min;
1920 : float res_cod_gain[10];
1921 : float in_phase_ratio;
1922 : #ifdef DEBUG_MODE_DFT
1923 : float MDCT_RES_dec[L_FRAME8k] = { 0 };
1924 : #endif
1925 868644 : assert( hStereoDft->res_cod_line_max <= L_FRAME8k );
1926 :
1927 868644 : if ( hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
1928 : {
1929 : /* Windowing */
1930 : /* overlapping parts */
1931 : /*input_8k-=STEREO_DFT_OVL_8k;*/
1932 18043088 : for ( i = 0; i < STEREO_DFT_OVL_8k; i++ )
1933 : {
1934 17788960 : win[i] = input_8k[i] * hStereoDft->win_mdct_8k[i];
1935 17788960 : win[L_FRAME8k + i] = input_8k[L_FRAME8k + i] * hStereoDft->win_mdct_8k[STEREO_DFT_OVL_8k - 1 - i];
1936 : }
1937 : /* middle part */
1938 23125648 : for ( ; i < L_FRAME8k; i++ )
1939 : {
1940 22871520 : win[i] = input_8k[i];
1941 : }
1942 :
1943 : /* MDCT analysis */
1944 254128 : TCX_MDCT( win, MDCT_RES, STEREO_DFT_OVL_8k, L_FRAME8k - STEREO_DFT_OVL_8k, STEREO_DFT_OVL_8k, IVAS_CPE_DFT );
1945 :
1946 : /*Compute the DMX to RES for each band*/
1947 254128 : max_snr = 0.f; /*minimum gain for residual coding -> no coding*/
1948 1524768 : for ( b = 0; b < hStereoDft->res_cod_band_max; b++ )
1949 : {
1950 : /*Get side gain information and it is we*/
1951 1270640 : panning_gain = hStereoDft->side_gain[STEREO_DFT_OFFSET * STEREO_DFT_BAND_MAX + b];
1952 1270640 : panning_gain_min = 1.f - fabsf( panning_gain );
1953 :
1954 1270640 : in_phase_ratio = ( panning_gain_min * panning_gain_min * hStereoDft->res_cod_NRG_M[b] ) / ( panning_gain_min * panning_gain_min * hStereoDft->res_cod_NRG_M[b] + hStereoDft->res_cod_NRG_S[b] + 1 );
1955 1270640 : in_phase_ratio = check_bounds( in_phase_ratio, 0, 1 );
1956 1270640 : res_cod_gain[b] = in_phase_ratio * STEREO_DFT_RES_COD_SNR_MIN + ( 1 - in_phase_ratio ) * STEREO_DFT_RES_COD_SNR_MAX;
1957 :
1958 : /*get the maximum through bands*/
1959 1270640 : if ( res_cod_gain[b] > max_snr )
1960 : {
1961 675447 : max_snr = res_cod_gain[b];
1962 : }
1963 : }
1964 :
1965 : /*Smooth max_snr because of several perturbations in computation*/
1966 : #ifdef DEBUG_MODE_DFT
1967 : dbgwrite( &max_snr, sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_target_snr0.dat" );
1968 : #endif
1969 254128 : hStereoDft->old_snr = 0.2f * max_snr + 0.8f * hStereoDft->old_snr;
1970 254128 : max_snr = hStereoDft->old_snr;
1971 :
1972 254128 : if ( max_snr < STEREO_DFT_RES_COD_SNR_MIN )
1973 : {
1974 6529 : max_snr = STEREO_DFT_RES_COD_SNR_MIN;
1975 : }
1976 : #ifdef DEBUG_MODE_DFT
1977 : dbgwrite( &max_snr, sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_target_snr.dat" );
1978 : #endif
1979 :
1980 254128 : push_wmops( "residual_encode" );
1981 : /* residual encoding */
1982 254128 : ECSQ_init_instance( &ecsq_inst, 0 /*dummy index*/, &range_uni_enc_state );
1983 254128 : rc_uni_enc_init( &range_uni_enc_state );
1984 :
1985 254128 : ecsq_inst.bit_count_estimate = 0;
1986 254128 : ecsq_inst.config_index = 2 * hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] - 1;
1987 :
1988 : /* 7 bits (STEREO_DFT_RES_GLOBAL_GAIN_BITS) for global_gain_index, 2 bits for closing of the arithmetic coder, 8 safety bits to account for the size estimation accuracy */
1989 : #ifndef DEBUG_MODE_DFT
1990 254128 : ECSQ_encode_target_SNR( &ecsq_inst, MDCT_RES, hStereoDft->res_cod_line_max, max_snr, max_bits - ( *nb_bits ) - STEREO_DFT_RES_GLOBAL_GAIN_BITS - 2 - 8, NULL, &global_gain_index );
1991 : #else
1992 : total_bit_count = (int16_t) ECSQ_encode_target_SNR( &ecsq_inst, MDCT_RES, hStereoDft->res_cod_line_max, max_snr, max_bits - ( *nb_bits ) - STEREO_DFT_RES_GLOBAL_GAIN_BITS - 2 - 8, MDCT_RES_dec, &global_gain_index );
1993 : #endif
1994 254128 : if ( global_gain_index != ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO )
1995 : {
1996 235270 : total_bit_count = rc_uni_enc_finish( &range_uni_enc_state );
1997 :
1998 235270 : if ( total_bit_count <= max_bits - *nb_bits - STEREO_DFT_RES_GLOBAL_GAIN_BITS )
1999 : {
2000 : int16_t idx;
2001 : uint8_t *byte_buffer;
2002 :
2003 : /* Global gain */
2004 235263 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2005 235263 : ( *nb_bits ) += STEREO_DFT_RES_GLOBAL_GAIN_BITS;
2006 : #ifdef DEBUG_MODE_DFT
2007 : fprintf( pF, "Gain: %d ", global_gain_index );
2008 : #endif
2009 :
2010 : /* Push arithmetic coded bits */
2011 235263 : byte_buffer = range_uni_enc_state.byte_buffer;
2012 4047038 : for ( idx = 0; idx < ( total_bit_count >> 3 ); ++idx )
2013 : {
2014 3811775 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, byte_buffer[idx], 8 );
2015 : }
2016 235263 : if ( ( total_bit_count & 7 ) != 0 )
2017 : {
2018 : /* move the last 1 to 7 bits from the MSB position of the last byte to the LSB postion */
2019 206149 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, byte_buffer[idx] >> ( 8 - ( total_bit_count & 7 ) ), total_bit_count & 7 );
2020 : }
2021 235263 : ( *nb_bits ) += total_bit_count;
2022 : #ifdef DEBUG_MODE_DFT
2023 : fprintf( pF, "%d (max: %d)\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS + total_bit_count, max_bits );
2024 : #endif
2025 : }
2026 : else
2027 : {
2028 : /* Global gain -> 127*/
2029 7 : global_gain_index = ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO;
2030 7 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2031 7 : ( *nb_bits ) += STEREO_DFT_RES_GLOBAL_GAIN_BITS;
2032 : #ifdef DEBUG_MODE_DFT
2033 : fprintf( pF, "Gain: %d ", global_gain_index );
2034 : fprintf( pF, "%d (max: %d)\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS, max_bits );
2035 : #endif
2036 : }
2037 : }
2038 : else
2039 : {
2040 : /* Global gain -> 127*/
2041 18858 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2042 18858 : ( *nb_bits ) += STEREO_DFT_RES_GLOBAL_GAIN_BITS;
2043 : #ifdef DEBUG_MODE_DFT
2044 : fprintf( pF, "Gain: %d ", global_gain_index );
2045 : fprintf( pF, "%d (max: %d)\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS, max_bits );
2046 : #endif
2047 : }
2048 : #ifdef DEBUG_MODE_DFT
2049 : {
2050 : static FILE *resCodingSNR = NULL;
2051 : if ( resCodingSNR == NULL )
2052 : resCodingSNR = fopen( "./res/resCodingSNR.txt", "w" );
2053 : fprintf( resCodingSNR, "%d\t%d\t%f\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS + total_bit_count, max_bits, max_snr );
2054 : }
2055 : #endif
2056 :
2057 254128 : pop_wmops();
2058 : #ifdef DEBUG_MODE_DFT
2059 : {
2060 : int16_t tmp[1024];
2061 : static float mem_win[STEREO_DFT_OVL_8k];
2062 : float global_gain;
2063 : int16_t input_frame = L_FRAME8k;
2064 : float res_cod_error, res_cod_nrg, res_cod_snr;
2065 :
2066 : for ( i = 0; i < input_frame; i++ )
2067 : {
2068 : tmp[i] = (int16_t) ( input_8k[i] + 0.5f );
2069 : }
2070 : dbgwrite( &tmp, sizeof( int16_t ), input_frame, 1, "./res/stereo_dft_enc_res_original.pcm" );
2071 :
2072 : if ( global_gain_index != ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO )
2073 : {
2074 : global_gain = ECSQ_dequantize_gain( global_gain_index );
2075 : }
2076 : else
2077 : {
2078 : global_gain = 0.f;
2079 : }
2080 : dbgwrite( &global_gain, sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_gain.dat" );
2081 :
2082 : tmp[0] = total_bit_count;
2083 : dbgwrite( &tmp, sizeof( int16_t ), 1, 1, "./res/stereo_dft_res_cod_bits.dat" );
2084 :
2085 : dbgwrite( &( hStereoDft->res_cod_line_max ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_res_cod_line.dat" );
2086 : dbgwrite( &( hStereoDft->res_cod_band_max ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_res_cod_band_max.dat" );
2087 : dbgwrite( &( hStereoDft->res_cod_NRG_M ), sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_dmx_nrg.dat" );
2088 : dbgwrite( &( hStereoDft->res_cod_NRG_S ), sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_res_nrg.dat" );
2089 :
2090 : /*Compute coding SNR*/
2091 : res_cod_nrg = EPSILON;
2092 : res_cod_error = EPSILON;
2093 : for ( i = 0; i < hStereoDft->res_cod_line_max; i++ )
2094 : {
2095 : res_cod_nrg += MDCT_RES[i] * MDCT_RES[i];
2096 : res_cod_error += ( MDCT_RES[i] - MDCT_RES_dec[i] ) * ( MDCT_RES[i] - MDCT_RES_dec[i] );
2097 : }
2098 :
2099 : res_cod_snr = 10.f * log10f( res_cod_nrg / res_cod_error );
2100 : dbgwrite( &( res_cod_snr ), sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_snr.dat" );
2101 :
2102 : /*IMDCT*/
2103 : TCX_MDCT_Inverse( MDCT_RES_dec, win, STEREO_DFT_OVL_8k, L_FRAME8k - STEREO_DFT_OVL_8k, STEREO_DFT_OVL_8k, IVAS_CPE_DFT );
2104 :
2105 : /*OLA*/
2106 : /*overlapping parts*/
2107 : for ( i = 0; i < STEREO_DFT_OVL_8k; i++ )
2108 : {
2109 : win[i] = mem_win[i] + win[i] * hStereoDft->win_mdct_8k[i];
2110 : mem_win[i] = win[input_frame + i] * hStereoDft->win_mdct_8k[STEREO_DFT_OVL_8k - 1 - i];
2111 : }
2112 : for ( i = 0; i < input_frame; i++ )
2113 : {
2114 : tmp[i] = (int16_t) ( win[i] + 0.5f );
2115 : }
2116 : dbgwrite( tmp, sizeof( int16_t ), input_frame, 1, "./res/stereo_dft_enc_res_decoded.pcm" );
2117 : }
2118 : #endif
2119 : }
2120 :
2121 : #ifdef DEBUG_MODE_DFT
2122 : {
2123 : int16_t input_frame = L_FRAME8k;
2124 : static FILE *bits_consumed = NULL;
2125 : if ( bits_consumed == NULL )
2126 : bits_consumed = fopen( "./res/stereo_dft_bits_consumed.txt", "w" );
2127 :
2128 : fprintf( bits_consumed, " %d \n", *nb_bits );
2129 : dbgwrite( nb_bits, sizeof( int16_t ), 1, input_frame, "./res/stereo_dft_bits_consumed.dat" );
2130 : }
2131 : #endif
2132 :
2133 868644 : return;
2134 : }
2135 :
2136 :
2137 : /*-------------------------------------------------------------------------
2138 : * stereo_dft_enc_write_BS()
2139 : *
2140 : * Write DFT stereo bitstream
2141 : *-------------------------------------------------------------------------*/
2142 :
2143 705634 : void stereo_dft_enc_write_BS(
2144 : CPE_ENC_HANDLE hCPE, /* i/o: CPE encoder structure */
2145 : int16_t *nb_bits /* o : number of bits written */
2146 : )
2147 : {
2148 : int16_t b, k_offset, itd, nb, nbands, sp_aud_decision0;
2149 : int16_t NFFT_inner, nbands_full;
2150 : int16_t no_GR_ord;
2151 : int16_t encoded_ind_GR[STEREO_DFT_BAND_MAX];
2152 : int16_t encoded_ind_pred_GR[STEREO_DFT_BAND_MAX];
2153 : int16_t sid_gIpd_index, sid_itd;
2154 : float cohBand[STEREO_DFT_BAND_MAX / 2];
2155 : BSTR_ENC_HANDLE hBstr;
2156 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft;
2157 : int32_t core_brate;
2158 : #ifdef DEBUG_MODE_DFT
2159 : static FILE *ITD_values = NULL, *side_gain_values = NULL, *RPG_values = NULL;
2160 : static FILE *cum_freq_enc = NULL;
2161 :
2162 : if ( pF == NULL )
2163 : pF = fopen( "./res/stereo_dft_enc_ind.txt", "w" );
2164 : if ( ITD_values == NULL )
2165 : ITD_values = fopen( "./res/itd_indicies_enc.txt", "w" );
2166 : if ( side_gain_values == NULL )
2167 : side_gain_values = fopen( "./res/side_gain_indicies_enc.txt", "w" );
2168 : if ( RPG_values == NULL )
2169 : RPG_values = fopen( "./res/rpg_indicies_enc.txt", "w" );
2170 : if ( cum_freq_enc == NULL )
2171 : cum_freq_enc = fopen( "./res/cum_freq_enc.txt", "w" );
2172 : #endif
2173 :
2174 : /*------------------------------------------------------------------*
2175 : * Initialization
2176 : *-----------------------------------------------------------------*/
2177 :
2178 705634 : hStereoDft = hCPE->hStereoDft;
2179 705634 : hBstr = hCPE->hMetaData;
2180 705634 : core_brate = hCPE->hCoreCoder[0]->core_brate;
2181 :
2182 705634 : sp_aud_decision0 = 0;
2183 705634 : if ( hCPE->last_element_mode == IVAS_CPE_DFT )
2184 : {
2185 697878 : sp_aud_decision0 = hCPE->hCoreCoder[0]->sp_aud_decision0;
2186 : }
2187 :
2188 705634 : *nb_bits = 0;
2189 705634 : k_offset = STEREO_DFT_OFFSET;
2190 :
2191 705634 : nbands_full = hStereoDft->nbands;
2192 :
2193 705634 : if ( core_brate == FRAME_NO_DATA || core_brate == SID_2k40 )
2194 : {
2195 40511 : NFFT_inner = min( STEREO_DFT_N_32k_ENC, STEREO_DFT_N_MAX_ENC * inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth] / L_FRAME48k );
2196 40511 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
2197 40511 : hStereoDft->res_pred_mode[k_offset] = 0;
2198 40511 : hStereoDft->res_cod_mode[k_offset] = 0;
2199 : }
2200 : else
2201 : {
2202 665123 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth] / L_FRAME48k;
2203 : }
2204 :
2205 : /* set number of bands according to bandwidth after BWD */
2206 705634 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->band_res[k_offset], NFFT_inner, ENC );
2207 :
2208 705634 : if ( core_brate == FRAME_NO_DATA )
2209 : {
2210 : /* No data frame */
2211 34447 : ( *nb_bits ) = 0;
2212 34447 : return;
2213 : }
2214 :
2215 : /* attack present */
2216 : /* attackPresent not sent in inactive frames, receiver assumes = 0 */
2217 671187 : if ( core_brate != SID_2k40 )
2218 : {
2219 665123 : push_indice( hBstr, IND_STEREO_DFT_ATTACK_PRESENT, hStereoDft->attackPresent, 1 );
2220 665123 : ( *nb_bits )++;
2221 : }
2222 :
2223 : /* Writing coding residual coding mode into bitstream */
2224 671187 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode && hCPE->hCoreCoder[0]->bwidth == WB )
2225 : {
2226 51380 : push_indice( hBstr, IND_STEREO_DFT_RES_COD, hStereoDft->res_cod_mode[k_offset], 1 );
2227 51380 : ( *nb_bits )++;
2228 51380 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
2229 51380 : hStereoDft->res_pred_band_min = max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
2230 : #ifdef DEBUG_MODE_DFT
2231 : fprintf( pF, "res_cod_mode: %d\n", hStereoDft->res_cod_mode[k_offset] );
2232 : #endif
2233 : }
2234 :
2235 : #ifdef DEBUG_MODE_DFT
2236 : fprintf( pF, "stereo Data: %d %d %d %d %d\n", hStereoDft->band_res[k_offset], 1, hStereoDft->res_pred_mode[k_offset], hStereoDft->res_cod_mode[k_offset], hStereoDft->res_cod_band_max );
2237 : fprintf( pF, "stereo Bands: %d\n", hStereoDft->nbands );
2238 :
2239 : dbgwrite( &( hStereoDft->nbands ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_encBS_nbands.dat" );
2240 : dbgwrite( &( hCPE->hCoreCoder[0]->bwidth ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_encBS_bwidth.dat" );
2241 :
2242 : #endif
2243 :
2244 671187 : if ( nbands_full < hStereoDft->nbands )
2245 : {
2246 0 : hStereoDft->reverb_flag = 0;
2247 : }
2248 :
2249 : /* Side gains */
2250 671187 : hStereoDft->side_gain_flag_1 = 0; /* EC coding by default */
2251 671187 : side_gain_mode_decision( hStereoDft, encoded_ind_GR, sp_aud_decision0, hCPE->hCoreCoder[0]->last_core_brate );
2252 :
2253 : /* residual pred. gains */
2254 671187 : hStereoDft->res_pred_flag_1 = 0; /* EC coding by default */
2255 :
2256 671187 : res_pred_gain_mode_decision( hStereoDft, encoded_ind_pred_GR, k_offset, hCPE->hCoreCoder[0]->last_core_brate );
2257 :
2258 : /*------------------------------------------------------------------*
2259 : * write ITD indices
2260 : *-----------------------------------------------------------------*/
2261 :
2262 671187 : if ( core_brate != SID_2k40 )
2263 : {
2264 665123 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, ( hStereoDft->hItd->itd[k_offset] != 0 ), STEREO_DFT_ITD_MODE_NBITS );
2265 665123 : ( *nb_bits ) += STEREO_DFT_ITD_MODE_NBITS; /*ITD mode flag: 1bit*/
2266 : }
2267 :
2268 : #ifdef DEBUG_MODE_DFT
2269 : fprintf( pF, "ITD: %d ", hStereoDft->hConfig->itd_mode && ( hStereoDft->hItd->itd[k_offset] != 0 ) );
2270 : #endif
2271 671187 : if ( core_brate != SID_2k40 )
2272 : {
2273 665123 : if ( hStereoDft->hItd->itd[k_offset] )
2274 : {
2275 200636 : itd = hStereoDft->hItd->itd_index[k_offset];
2276 200636 : if ( itd > 255 )
2277 : {
2278 89064 : itd -= 256;
2279 :
2280 89064 : if ( itd < 20 )
2281 : {
2282 52867 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2283 52867 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2284 52867 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2285 52867 : ( *nb_bits ) += dft_len_itd[itd] + 2;
2286 : }
2287 : else
2288 : {
2289 36197 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 0, 1 ); /* don't use Huffman */
2290 36197 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2291 36197 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS - 1 );
2292 36197 : ( *nb_bits ) += STEREO_DFT_ITD_NBITS + 1;
2293 : }
2294 : }
2295 : else
2296 : {
2297 111572 : if ( itd < 20 )
2298 : {
2299 75784 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2300 75784 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* positive */
2301 75784 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2302 75784 : ( *nb_bits ) += dft_len_itd[itd] + 2;
2303 : }
2304 : else
2305 : {
2306 : /* don't use Huffman and positive*/
2307 35788 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS + 1 );
2308 35788 : ( *nb_bits ) += STEREO_DFT_ITD_NBITS + 1;
2309 : }
2310 : }
2311 : #ifdef DEBUG_MODE_DFT
2312 : fprintf( pF, "ITD: %d ", hStereoDft->hItd->itd_index[k_offset] );
2313 : fprintf( ITD_values, "%d %d ", frame, hStereoDft->hItd->itd_index[k_offset] );
2314 : #endif
2315 : }
2316 : }
2317 :
2318 : #ifdef DEBUG_MODE_DFT_BITS
2319 : fprintf( ITD_bits, "%d ", *nb_bits );
2320 : #endif
2321 :
2322 : /*------------------------------------------------------------------*
2323 : * write Side gain indices
2324 : *-----------------------------------------------------------------*/
2325 :
2326 : /* Side Gain flag 1 */
2327 671187 : nb = 0;
2328 671187 : if ( hStereoDft->side_gain_flag_1 > 0 )
2329 : {
2330 203252 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, 2 );
2331 203252 : nb += 2;
2332 : }
2333 : else
2334 : {
2335 467935 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, STEREO_DFT_FLAG_BITS );
2336 467935 : nb += STEREO_DFT_FLAG_BITS;
2337 : }
2338 :
2339 671187 : no_GR_ord = 3;
2340 :
2341 : #ifdef DEBUG_MODE_DFT
2342 : for ( b = 0; b < hStereoDft->nbands; b++ )
2343 : {
2344 : fprintf( pF, "Side gain: %d ", hStereoDft->side_gain_index_EC[b] );
2345 : fprintf( side_gain_values, " %d ", hStereoDft->side_gain_index_EC[b] );
2346 : }
2347 : #endif
2348 671187 : if ( hStereoDft->side_gain_flag_1 == 0 )
2349 : {
2350 467935 : nb += write_bitstream_adapt_GR( hBstr, IND_STEREO_DFT_SIDEGAINS, encoded_ind_GR, hStereoDft->nbands, hStereoDft->side_gain_flag_2, no_GR_ord );
2351 : }
2352 : else
2353 : {
2354 203252 : if ( hStereoDft->side_gain_flag_1 == 2 )
2355 : {
2356 198690 : nb += write_bitstream_GR( hBstr, IND_STEREO_DFT_SIDEGAINS, hStereoDft->side_gain_index_ECDiff, hStereoDft->nbands, hStereoDft->side_gain_flag_2 - no_GR_ord );
2357 : }
2358 : else
2359 : {
2360 38204 : for ( b = 0; b < hStereoDft->nbands; b++ )
2361 : {
2362 : /*ILD*/
2363 33642 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAINS, hStereoDft->side_gain_index_EC[b], STEREO_DFT_SIDEGAIN_NBITS );
2364 33642 : nb += STEREO_DFT_SIDEGAIN_NBITS;
2365 : }
2366 : }
2367 : }
2368 :
2369 : /* nb bits are used for side gain*/
2370 671187 : ( *nb_bits ) += nb;
2371 : #ifdef DEBUG_MODE_DFT_BITS
2372 : fprintf( SG_bits, "%d ", nb );
2373 : #endif
2374 671187 : nb = 0;
2375 :
2376 671187 : if ( core_brate == SID_2k40 )
2377 : {
2378 6064 : stereo_dft_enc_sid_calc_coh( hStereoDft, hCPE->hStereoCng->prev_cohBand, &hCPE->hStereoCng->td_active, &hCPE->hStereoCng->first_SID, cohBand );
2379 :
2380 6064 : if ( *nb_bits <= ( ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS - STEREO_DFT_ITD_MODE_NBITS - STEREO_DFT_SID_ITD_NBITS - 1 ) )
2381 : {
2382 6064 : if ( hStereoDft->hItd->itd[k_offset] != 0 )
2383 : {
2384 : /* Re-quantize ITD with lower resolution for Stereo CNG */
2385 653 : itd = hStereoDft->hItd->itd_index[k_offset];
2386 653 : if ( itd > 255 )
2387 : {
2388 167 : itd -= 256;
2389 : }
2390 653 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2391 :
2392 653 : sid_itd = itd && 1;
2393 : }
2394 : else
2395 : {
2396 5411 : sid_itd = 0;
2397 : }
2398 :
2399 6064 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, sid_itd, STEREO_DFT_ITD_MODE_NBITS );
2400 6064 : ( *nb_bits ) += STEREO_DFT_ITD_MODE_NBITS; /*ITD mode flag: 1bit*/
2401 :
2402 6064 : if ( sid_itd )
2403 : {
2404 364 : itd = hStereoDft->hItd->itd_index[k_offset];
2405 364 : if ( itd > 255 )
2406 : {
2407 60 : itd -= 256;
2408 60 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2409 :
2410 60 : if ( itd > ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) )
2411 : {
2412 22 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
2413 : }
2414 :
2415 60 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2416 60 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
2417 60 : ( *nb_bits ) += STEREO_DFT_SID_ITD_NBITS + 1;
2418 : }
2419 : else
2420 : {
2421 304 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2422 :
2423 304 : if ( itd > ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) )
2424 : {
2425 75 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
2426 : }
2427 :
2428 304 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* Positive */
2429 304 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
2430 304 : ( *nb_bits ) += STEREO_DFT_SID_ITD_NBITS + 1;
2431 : }
2432 :
2433 : #ifdef DEBUG_MODE_DFT
2434 : fprintf( pF, "ITD: %d ", hStereoDft->hItd->itd_index[k_offset] );
2435 : fprintf( ITD_values, "%d %d ", frame, hStereoDft->hItd->itd_index[k_offset] );
2436 : #endif
2437 : }
2438 : }
2439 : }
2440 :
2441 : /*------------------------------------------------------------------*
2442 : * write IPD indices
2443 : *-----------------------------------------------------------------*/
2444 :
2445 671187 : if ( core_brate != SID_2k40 )
2446 : {
2447 665123 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
2448 665123 : nb += STEREO_DFT_FLAG_BITS; /*IPD mode flag: 1bit*/
2449 :
2450 665123 : if ( hStereoDft->no_ipd_flag == 0 )
2451 : {
2452 23611 : push_indice( hBstr, IND_STEREO_DFT_GIPD, hStereoDft->gipd_index, STEREO_DFT_GIPD_NBITS );
2453 23611 : nb += STEREO_DFT_GIPD_NBITS;
2454 : }
2455 : }
2456 6064 : else if ( *nb_bits <= ( ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS - STEREO_DFT_FLAG_BITS - STEREO_DFT_SID_GIPD_NBITS ) )
2457 : {
2458 6064 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
2459 6064 : nb += STEREO_DFT_FLAG_BITS; /*IPD mode flag: 1bit*/
2460 :
2461 6064 : if ( hStereoDft->no_ipd_flag == 0 )
2462 : {
2463 850 : stereo_dft_quantize_ipd( &hStereoDft->sid_gipd, &hStereoDft->sid_gipd, &sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
2464 850 : push_indice( hBstr, IND_STEREO_DFT_GIPD, sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
2465 850 : nb += STEREO_DFT_SID_GIPD_NBITS;
2466 : }
2467 : }
2468 :
2469 :
2470 : #ifdef DEBUG_MODE_DFT_BITS
2471 : fprintf( IPD_bits, "%d ", nb );
2472 : #endif
2473 671187 : ( *nb_bits ) += nb;
2474 :
2475 : /*----------------------------------------------------------------*
2476 : * Residual prediction
2477 : *----------------------------------------------------------------*/
2478 :
2479 671187 : nb = 0; /* bits for residual pred gains */
2480 671187 : if ( hStereoDft->res_pred_mode[k_offset] )
2481 : {
2482 665123 : if ( hStereoDft->attackPresent == 0 )
2483 : {
2484 645696 : nbands = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
2485 645696 : b = hStereoDft->res_pred_band_min;
2486 :
2487 : /*Adaptive SF*/
2488 645696 : if ( hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
2489 : {
2490 : /*read flag*/
2491 396363 : push_indice( hBstr, IND_STEREO_DFT_REVERB_MODE, hStereoDft->reverb_flag, STEREO_DFT_REVERB_MODE_NBITS );
2492 396363 : nb += STEREO_DFT_REVERB_MODE_NBITS;
2493 : #ifdef DEBUG_MODE_DFT
2494 : fprintf( RPG_values, " reverb_flag %d ", hStereoDft->reverb_flag );
2495 : #endif
2496 396363 : if ( hStereoDft->reverb_flag )
2497 : {
2498 146624 : nbands -= STEREO_DFT_RES_PRED_BAND_MIN_CONST;
2499 : }
2500 : }
2501 :
2502 : /* Res Pred Gain flag 0 */
2503 645696 : if ( hStereoDft->res_pred_flag_1 > 0 )
2504 : {
2505 467221 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, 2 );
2506 467221 : nb += 2; /*pred gain mode flag: 2 bits*/
2507 : }
2508 : else
2509 : {
2510 178475 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, STEREO_DFT_FLAG_BITS );
2511 178475 : nb += STEREO_DFT_FLAG_BITS; /*pred gain mode flag: 1bit*/
2512 : }
2513 :
2514 645696 : no_GR_ord = 2;
2515 645696 : if ( hStereoDft->res_pred_flag_1 == 0 )
2516 : {
2517 : #ifdef DEBUG_MODE_DFT
2518 : fprintf( RPG_values, "flag: 0" );
2519 : #endif
2520 178475 : if ( encoded_ind_pred_GR[0] == dft_maps_rpg[8 * NO_SYMB_GR_PRED_G] )
2521 : {
2522 88430 : nb += write_GR1( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, encoded_ind_pred_GR, 1 );
2523 : }
2524 : else
2525 : {
2526 90045 : nb += write_bitstream_adapt_GR( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, encoded_ind_pred_GR, nbands - hStereoDft->res_pred_band_min, hStereoDft->res_pred_flag_2, 2 );
2527 : }
2528 : }
2529 : else
2530 : {
2531 467221 : if ( hStereoDft->res_pred_flag_1 == 2 )
2532 : {
2533 : #ifdef DEBUG_MODE_DFT
2534 : fprintf( RPG_values, "flag: 2" );
2535 : #endif
2536 423880 : nb += write_bitstream_GR( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, &hStereoDft->res_pred_index_ECDiff[hStereoDft->res_pred_band_min], nbands - hStereoDft->res_pred_band_min, hStereoDft->res_pred_flag_2 - no_GR_ord );
2537 : }
2538 : else
2539 : {
2540 : #ifdef DEBUG_MODE_DFT
2541 : fprintf( RPG_values, "flag: 1" );
2542 : #endif
2543 332066 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2544 : {
2545 288725 : push_indice( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, hStereoDft->res_pred_index_EC[b], STEREO_DFT_RES_GAINS_BITS );
2546 288725 : nb += STEREO_DFT_RES_GAINS_BITS;
2547 : }
2548 : }
2549 : }
2550 :
2551 : #ifdef DEBUG_MODE_DFT
2552 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2553 : {
2554 : fprintf( pF, "Res pred values: %d ", hStereoDft->res_pred_index_EC[b] );
2555 : if ( hStereoDft->res_pred_flag_1 == 2 )
2556 : {
2557 : fprintf( RPG_values, " %d(%d) ", hStereoDft->res_pred_index_EC[b], hStereoDft->res_pred_index_EC[b] + ( ( hStereoDft->res_pred_index_ECDiff[b] % 2 ) ? -( hStereoDft->res_pred_index_ECDiff[b] + 1 ) / 2 : ( hStereoDft->res_pred_index_ECDiff[b] ) / 2 ) );
2558 : }
2559 : else
2560 : {
2561 : fprintf( RPG_values, " %d ", hStereoDft->res_pred_index_EC[b] );
2562 : }
2563 : }
2564 : #endif
2565 : }
2566 : else
2567 : {
2568 19427 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands - hStereoDft->res_pred_band_min );
2569 : }
2570 : }
2571 : else
2572 : {
2573 6064 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands - hStereoDft->res_pred_band_min );
2574 : }
2575 :
2576 671187 : ( *nb_bits ) += nb;
2577 :
2578 671187 : if ( core_brate == SID_2k40 )
2579 : {
2580 6064 : stereo_dft_enc_sid_coh( hBstr, hCPE->hStereoCng->mem_cohBand, hStereoDft->nbands, nb_bits, cohBand );
2581 : }
2582 :
2583 : #ifdef DEBUG_MODE_DFT
2584 : /*fprintf(pF, "Total bits: %d", (*nb_bits));*/
2585 : fprintf( pF, "\n" );
2586 : fprintf( ITD_values, "\n" );
2587 : fprintf( side_gain_values, "\n" );
2588 : fprintf( RPG_values, "\n" );
2589 : #endif
2590 :
2591 671187 : return;
2592 : }
2593 :
2594 :
2595 : /*-------------------------------------------------------------------------
2596 : * stereo_dft_enc_compute_prm()
2597 : *
2598 : * Compute stereo parameters: IPD and SIDE_GAIN
2599 : * SIDE_GAIN: Interchannel Level Difference
2600 : * IPD: Interchannel Phase Difference: angle(L)-angle(R) = acos(<L,R>/(|L|.|R|)) or atan2(Img(L.R*)/Re(L.R*))
2601 : *------------------------------------------------------------------------*/
2602 :
2603 871106 : static void stereo_dft_enc_compute_prm(
2604 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
2605 : float *DFT_L,
2606 : float *DFT_R,
2607 : int16_t k_offset,
2608 : int16_t flag_quant,
2609 : const int16_t sp_aud_decision0,
2610 : const int16_t vad_flag,
2611 : float *bin_nrgL,
2612 : float *bin_nrgR,
2613 : float *dot_prod_nrg_ratio )
2614 : {
2615 : int16_t b, i;
2616 : int16_t b2;
2617 : float *pDFT_L, *pDFT_R;
2618 : float sum_nrg_L, sum_nrg_R;
2619 : float dot_prod_real, dot_prod_img;
2620 : float sum_nrg_L2, sum_nrg_R2;
2621 : float dot_prod_real2, dot_prod_img2;
2622 : float *pPredGain;
2623 : float *pSideGain;
2624 : float sum_energy_L, sum_energy_R;
2625 : float g, c;
2626 : float abs_L_R;
2627 : float abs_L_R2;
2628 : float gain_IPD;
2629 : float sub_nrg_DMX[STEREO_DFT_BAND_MAX];
2630 : float sub_nrg_DMX2;
2631 : float sub_nrg_L[STEREO_DFT_BAND_MAX];
2632 : float sub_nrg_R[STEREO_DFT_BAND_MAX];
2633 : float diff_ipd;
2634 : float *pNrgL, *pNrgR;
2635 : float reg;
2636 : float *pgIpd, sum_dot_prod_real, sum_dot_prod_img;
2637 : float sum_past_nrgL, sum_past_nrgL2;
2638 : float sum_past_nrgR, sum_past_nrgR2;
2639 : float sum_past_dpr, sum_past_dpr2;
2640 : float sum_past_dpi, sum_past_dpi2;
2641 : float sum_past_dot_prod_abs, sum_past_dot_prod_abs2;
2642 : float sum_past_nrg_dmx;
2643 : int16_t pos;
2644 : float pIpd[STEREO_DFT_BAND_MAX];
2645 : float ipd_smooth[STEREO_DFT_BAND_MAX];
2646 : float ipd_mean_change;
2647 :
2648 : /*------------------------------------------------------------------*
2649 : * Initialization
2650 : *-----------------------------------------------------------------*/
2651 :
2652 871106 : sum_past_dot_prod_abs2 = 0.0f;
2653 871106 : pos = hStereoDft->nrg_past_pos;
2654 :
2655 871106 : set_f( sub_nrg_DMX, 0, STEREO_DFT_BAND_MAX );
2656 871106 : set_f( sub_nrg_L, 0, STEREO_DFT_BAND_MAX );
2657 871106 : set_f( sub_nrg_R, 0, STEREO_DFT_BAND_MAX );
2658 :
2659 871106 : pSideGain = hStereoDft->side_gain + k_offset * STEREO_DFT_BAND_MAX;
2660 871106 : pgIpd = hStereoDft->gipd + k_offset;
2661 871106 : pPredGain = hStereoDft->res_pred_gain + k_offset * STEREO_DFT_BAND_MAX;
2662 871106 : gain_IPD = EPSILON;
2663 871106 : sum_energy_L = EPSILON; /* Set the accumulations for the no IPD Calculation */
2664 871106 : sum_energy_R = EPSILON;
2665 871106 : sum_dot_prod_real = EPSILON;
2666 871106 : sum_dot_prod_img = EPSILON;
2667 871106 : sub_nrg_DMX2 = 0.f;
2668 : #ifdef DEBUG_MODE_DFT
2669 : sum_nrg_L = EPSILON;
2670 : sum_nrg_R = EPSILON;
2671 : #endif
2672 :
2673 : /*------------------------------------------------------------------*
2674 : * Band-wise processing
2675 : *-----------------------------------------------------------------*/
2676 :
2677 871106 : b2 = 0;
2678 8887583 : for ( b = 0; b < hStereoDft->nbands; b++ )
2679 : {
2680 8016477 : pPredGain[b] = 1.f;
2681 8016477 : sum_nrg_L = EPSILON;
2682 8016477 : sum_nrg_R = EPSILON;
2683 8016477 : dot_prod_real = EPSILON;
2684 8016477 : dot_prod_img = EPSILON;
2685 8016477 : sum_past_nrgL = 0;
2686 8016477 : sum_past_nrgR = 0;
2687 8016477 : sum_past_dpr = 0;
2688 8016477 : sum_past_dpi = 0;
2689 :
2690 18357808 : while ( hStereoDft->band_limits_dmx[b2] < hStereoDft->band_limits[b + 1] )
2691 : {
2692 10341331 : pDFT_L = DFT_L;
2693 10341331 : pDFT_R = DFT_R;
2694 10341331 : pNrgL = bin_nrgL;
2695 10341331 : pNrgR = bin_nrgR;
2696 :
2697 10341331 : sum_nrg_L2 = EPSILON;
2698 10341331 : sum_nrg_R2 = EPSILON;
2699 10341331 : dot_prod_real2 = EPSILON;
2700 10341331 : dot_prod_img2 = EPSILON;
2701 :
2702 584897425 : for ( i = hStereoDft->band_limits_dmx[b2]; i < hStereoDft->band_limits_dmx[b2 + 1]; i++ )
2703 : {
2704 574556094 : sum_nrg_L2 += pNrgL[i];
2705 574556094 : sum_nrg_R2 += pNrgR[i];
2706 :
2707 : /* compute dot product*/
2708 574556094 : dot_prod_real2 += pDFT_L[2 * i] * pDFT_R[2 * i] + pDFT_L[2 * i + 1] * pDFT_R[2 * i + 1];
2709 574556094 : dot_prod_img2 += pDFT_L[2 * i + 1] * pDFT_R[2 * i] - pDFT_L[2 * i] * pDFT_R[2 * i + 1];
2710 : }
2711 10341331 : abs_L_R2 = sqrtf( dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2 );
2712 10341331 : sub_nrg_DMX2 = sum_nrg_L2 + sum_nrg_R2 + 2 * abs_L_R2;
2713 :
2714 10341331 : if ( b2 < hStereoDft->gipd_band_max )
2715 : {
2716 6968848 : hStereoDft->dot_prod_real_smooth[b2] = 0.5f * hStereoDft->dot_prod_real_smooth[b2] + 0.5f * dot_prod_real2;
2717 6968848 : hStereoDft->dot_prod_img_smooth[b2] = 0.5f * hStereoDft->dot_prod_img_smooth[b2] + 0.5f * dot_prod_img2;
2718 6968848 : pIpd[b2] = (float) atan2f( hStereoDft->dot_prod_img_smooth[b2], hStereoDft->dot_prod_real_smooth[b2] );
2719 :
2720 6968848 : ipd_smooth[b2] = stereo_dft_calc_mean_bipd( &pIpd[b2], hStereoDft->ipd_buf[b2] );
2721 :
2722 6968848 : gain_IPD += ( sum_nrg_L2 + sum_nrg_R2 + 2 * dot_prod_real2 ) / sub_nrg_DMX2 / hStereoDft->gipd_band_max;
2723 : }
2724 :
2725 10341331 : sum_past_nrgL2 = EPSILON;
2726 10341331 : sum_past_nrgR2 = EPSILON;
2727 10341331 : sum_past_dpr2 = EPSILON;
2728 10341331 : sum_past_dpi2 = EPSILON;
2729 10341331 : if ( ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_HIGH && b2 < STEREO_DFT_NRG_PAST_MAX_BAND ) ||
2730 6117343 : ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW && b2 < 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) )
2731 : {
2732 7438180 : hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_L2;
2733 7438180 : hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_R2;
2734 7438180 : hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_real2;
2735 7438180 : hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_img2;
2736 :
2737 29752720 : for ( i = 0; i < STEREO_DFT_NRG_PAST_LEN; i++ )
2738 : {
2739 22314540 : sum_past_nrgL2 += hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2740 22314540 : sum_past_nrgR2 += hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2741 22314540 : sum_past_dpr2 += hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2742 22314540 : sum_past_dpi2 += hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2743 : }
2744 :
2745 7438180 : if ( hStereoDft->attackPresent )
2746 : {
2747 : /* omit transient frames from past part of parameter estimation in following frames */
2748 245206 : int16_t prev_pos = ( pos + STEREO_DFT_NRG_PAST_LEN - 1 ) % STEREO_DFT_NRG_PAST_LEN;
2749 245206 : hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2750 245206 : hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2751 245206 : hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2752 245206 : hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2753 : }
2754 :
2755 7438180 : sum_past_dot_prod_abs2 = sqrtf( sum_past_dpr2 * sum_past_dpr2 + sum_past_dpi2 * sum_past_dpi2 );
2756 7438180 : dot_prod_nrg_ratio[b2] = sum_past_dot_prod_abs2 / ( sum_past_nrgL2 + sum_past_nrgR2 + EPSILON );
2757 : }
2758 : else
2759 : {
2760 2903151 : sum_past_nrgL2 += sum_nrg_L2;
2761 2903151 : sum_past_nrgR2 += sum_nrg_R2;
2762 2903151 : dot_prod_nrg_ratio[b2] = sqrtf( dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2 );
2763 2903151 : if ( b2 == 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) /* hStereoDft->band_res[k_offset] == 2 */
2764 : {
2765 401774 : dot_prod_nrg_ratio[b2] /= ( sum_nrg_L2 + sum_nrg_R2 + EPSILON );
2766 : }
2767 : }
2768 10341331 : sum_nrg_L += sum_nrg_L2;
2769 10341331 : sum_nrg_R += sum_nrg_R2;
2770 10341331 : dot_prod_real += dot_prod_real2;
2771 10341331 : dot_prod_img += dot_prod_img2;
2772 :
2773 10341331 : sum_past_nrgL += sum_past_nrgL2;
2774 10341331 : sum_past_nrgR += sum_past_nrgR2;
2775 10341331 : sum_past_dpr += sum_past_dpr2;
2776 10341331 : sum_past_dpi += sum_past_dpi2;
2777 :
2778 10341331 : b2++;
2779 : }
2780 8016477 : sum_energy_L += sum_nrg_L; /* Energies of the individual Band for Left and Right */
2781 8016477 : sum_energy_R += sum_nrg_R;
2782 8016477 : sum_dot_prod_real += dot_prod_real;
2783 8016477 : sum_dot_prod_img += dot_prod_img;
2784 :
2785 : /* compute side and residual gains over two frames */
2786 8016477 : abs_L_R = sqrtf( dot_prod_real * dot_prod_real + dot_prod_img * dot_prod_img );
2787 :
2788 8016477 : if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW && b < 4 )
2789 : {
2790 1607096 : sum_past_dot_prod_abs = sqrtf( sum_past_dpr * sum_past_dpr + sum_past_dpi * sum_past_dpi );
2791 : }
2792 6409381 : else if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_HIGH && b < 9 )
2793 : {
2794 4223988 : sum_past_dot_prod_abs = sum_past_dot_prod_abs2;
2795 : }
2796 : else
2797 : {
2798 2185393 : sum_past_dot_prod_abs = abs_L_R;
2799 : }
2800 :
2801 8016477 : c = sqrtf( sum_past_nrgL / sum_past_nrgR );
2802 8016477 : sum_past_nrg_dmx = sum_past_nrgL + sum_past_nrgR + 2 * sum_past_dot_prod_abs;
2803 8016477 : sub_nrg_DMX[b] = sum_nrg_L + sum_nrg_R + 2 * abs_L_R;
2804 :
2805 8016477 : sub_nrg_L[b] = sum_nrg_L;
2806 8016477 : sub_nrg_R[b] = sum_nrg_R;
2807 :
2808 8016477 : if ( ( hStereoDft->res_pred_mode[k_offset] && b >= hStereoDft->res_pred_band_min ) || ( b < hStereoDft->res_cod_band_max ) )
2809 : {
2810 7185971 : g = ( sum_past_nrgL - sum_past_nrgR ) / ( sum_past_nrg_dmx );
2811 7185971 : pSideGain[b] = g;
2812 : }
2813 : else
2814 : {
2815 830506 : g = 0.0f; /* to avoid compilation warning */
2816 830506 : pSideGain[b] = ( c - 1 ) / ( c + 1 );
2817 : }
2818 :
2819 8016477 : if ( hStereoDft->res_pred_mode[k_offset] && b >= hStereoDft->res_pred_band_min && !( hStereoDft->attackPresent ) )
2820 : {
2821 : /*(1-g)^2*L*L' + (1+g)^2*R*R' - 2(1-g^2)*abs(L*R')*/
2822 5656760 : pPredGain[b] = max( 0, ( ( 1 - g ) * sum_past_nrgL + ( 1 + g ) * sum_past_nrgR - 2 * sum_past_dot_prod_abs ) );
2823 :
2824 : /*Normalized with energy of DMX*/
2825 :
2826 : /*Regularized gain computation by adding a coherent low energy contribution->avoid singularity for very low energy signals */
2827 :
2828 5656760 : reg = ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) * sqrtf( STEREO_DFT_N_32k_ENC );
2829 5656760 : reg *= reg;
2830 :
2831 5656760 : pPredGain[b] = sqrtf( pPredGain[b] / ( reg + sum_past_nrg_dmx ) );
2832 :
2833 5656760 : if ( hStereoDft->hItd->deltaItd[k_offset] != 0 )
2834 : {
2835 : float gain_offset, conversion_factor;
2836 : int16_t dItd32;
2837 :
2838 : /* factor for converting deltaItd to 32kHz */
2839 1230201 : conversion_factor = 1.f;
2840 1230201 : if ( hStereoDft->NFFT == STEREO_DFT_N_16k_ENC )
2841 : {
2842 235580 : conversion_factor = 2.f;
2843 : }
2844 994621 : else if ( hStereoDft->NFFT == STEREO_DFT_N_MAX_ENC )
2845 : {
2846 480166 : conversion_factor = 2.f / 3;
2847 : }
2848 1230201 : dItd32 = (int16_t) floorf( conversion_factor * hStereoDft->hItd->deltaItd[k_offset] + 0.5f );
2849 :
2850 1230201 : gain_offset = stereo_dft_gain_offset( c, dItd32 );
2851 1230201 : pPredGain[b] = max( 0, pPredGain[b] - gain_offset );
2852 : }
2853 :
2854 : /*Limiter for active speech*/
2855 5656760 : if ( sp_aud_decision0 == 0 && vad_flag )
2856 : {
2857 : /*Avoid jump of residual prediction gain when ITD is changing*/
2858 2900359 : if ( hStereoDft->hItd->deltaItd[k_offset] != hStereoDft->hItd->deltaItd[0] )
2859 : {
2860 148440 : pPredGain[b] = min( hStereoDft->res_pred_gain_f[b], pPredGain[b] );
2861 : }
2862 :
2863 : /*Limiter*/
2864 2900359 : hStereoDft->res_pred_gain_f[b] = 0.9f * hStereoDft->res_pred_gain_f[b] + 0.1f * pPredGain[b];
2865 2900359 : pPredGain[b] = min( 1.1f * hStereoDft->res_pred_gain_f[b], pPredGain[b] );
2866 : }
2867 : else
2868 : {
2869 2756401 : hStereoDft->res_pred_gain_f[b] = pPredGain[b];
2870 : }
2871 : }
2872 : else
2873 : {
2874 2359717 : pPredGain[b] = 0.f;
2875 : }
2876 :
2877 :
2878 8016477 : if ( b2 == hStereoDft->gipd_band_max )
2879 : {
2880 871106 : ipd_mean_change = stereo_dft_calc_mean_ipd_change( pIpd, ipd_smooth, hStereoDft->gipd_band_max );
2881 871106 : hStereoDft->sum_dot_prod_real = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_real + hStereoDft->sfm * sum_dot_prod_real;
2882 871106 : hStereoDft->sum_dot_prod_img = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_img + hStereoDft->sfm * sum_dot_prod_img;
2883 :
2884 871106 : pgIpd[0] = (float) atan2f( hStereoDft->sum_dot_prod_img, hStereoDft->sum_dot_prod_real );
2885 :
2886 871106 : stereo_dft_gipd_stabilization( &pgIpd[0], hStereoDft->prev_gipd, ipd_mean_change );
2887 871106 : hStereoDft->prev_gipd = pgIpd[0];
2888 : }
2889 : }
2890 :
2891 871106 : hStereoDft->nrg_past_pos = ( pos + 1 ) % STEREO_DFT_NRG_PAST_LEN;
2892 :
2893 : #ifdef DEBUG_MODE_DFT
2894 : {
2895 : float tmp_f;
2896 : dbgwrite( pPredGain, sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_gainPred.pcm" );
2897 : dbgwrite( pSideGain, sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_gainSide.pcm" );
2898 :
2899 : for ( i = 0; i < hStereoDft->nbands; i++ )
2900 : {
2901 : float regularization;
2902 :
2903 : regularization = ( hStereoDft->band_limits[i + 1] - hStereoDft->band_limits[i] ) * sqrtf( hStereoDft->NFFT );
2904 : tmp_f = sub_nrg_DMX[i] / ( regularization * regularization );
2905 : dbgwrite( &tmp_f, sizeof( float ), 1, 1, "./res/stereo_dft_nrgDMX.pcm" );
2906 :
2907 : g = sqrtf( sum_nrg_L / sum_nrg_R );
2908 : tmp_f = ( g - 1 ) / ( g + 1 );
2909 : dbgwrite( &tmp_f, sizeof( float ), 1, 1, "./res/stereo_dft_gainILD.pcm" );
2910 : }
2911 : }
2912 : #endif
2913 :
2914 : /*------------------------------------------------------------------*
2915 : * Compute IPDs
2916 : *-----------------------------------------------------------------*/
2917 :
2918 : #ifdef DEBUG_MODE_DFT
2919 : stereo_dft_enc_get_nipd_flag( hStereoDft, pgIpd, sp_aud_decision0, gain_IPD );
2920 : #else
2921 871106 : stereo_dft_enc_get_nipd_flag( hStereoDft, sp_aud_decision0, gain_IPD );
2922 : #endif
2923 :
2924 : #ifdef DEBUG_MODE_DFT
2925 : hStereoDft->no_ipd_flag = ( hStereoDft->hConfig->gipd_mode == 0 ) ? 1 : hStereoDft->no_ipd_flag;
2926 : #endif
2927 :
2928 871106 : if ( flag_quant )
2929 : {
2930 871106 : if ( hStereoDft->no_ipd_flag == 0 )
2931 : {
2932 30511 : hStereoDft->sid_gipd = *pgIpd;
2933 30511 : stereo_dft_quantize_ipd( pgIpd, pgIpd, &( hStereoDft->gipd_index ), STEREO_DFT_GIPD_NBITS );
2934 : }
2935 : else
2936 : {
2937 840595 : pgIpd[0] = 0;
2938 : }
2939 : }
2940 871106 : diff_ipd = pgIpd[0] - pgIpd[-1];
2941 :
2942 871106 : if ( diff_ipd < -EVS_PI )
2943 : {
2944 63438 : pgIpd[0] += PI2;
2945 : }
2946 807668 : else if ( diff_ipd > EVS_PI )
2947 : {
2948 65650 : pgIpd[0] -= PI2;
2949 : }
2950 :
2951 871106 : if ( !hStereoDft->attackPresent )
2952 : {
2953 842138 : if ( hStereoDft->wasTransient )
2954 : {
2955 27258 : pgIpd[0] = 0.8f * pgIpd[0] + 0.2f * pgIpd[-1];
2956 : }
2957 : else
2958 : {
2959 814880 : pgIpd[0] = 0.5f * pgIpd[0] + 0.5f * pgIpd[-1];
2960 : }
2961 : }
2962 :
2963 871106 : c = sqrtf( sum_energy_L / sum_energy_R );
2964 871106 : g = fabsf( ( c - 1 ) / ( c + 1 ) );
2965 871106 : if ( g > 0.8f )
2966 : {
2967 42416 : g = max( 0.f, -10.f * g + 9.0f );
2968 418190 : for ( b = 0; b < hStereoDft->nbands; b++ )
2969 : {
2970 375774 : pPredGain[b] *= g;
2971 : }
2972 : }
2973 :
2974 871106 : if ( hStereoDft->hConfig->band_res == STEREO_DFT_BAND_RES_LOW )
2975 : {
2976 401774 : hStereoDft->reverb_flag = 1;
2977 : }
2978 : else
2979 : {
2980 469332 : stereo_dft_enc_get_reverb_flag( hStereoDft, pPredGain, sub_nrg_DMX, sub_nrg_L, sub_nrg_R, k_offset, bin_nrgL, bin_nrgR );
2981 : }
2982 :
2983 :
2984 : /*------------------------------------------------------------------*
2985 : * Compute Side gains
2986 : *-----------------------------------------------------------------*/
2987 :
2988 8887583 : for ( b = 0; b < hStereoDft->nbands; b++ )
2989 : {
2990 8016477 : hStereoDft->sidSideGain[b] = *( pSideGain + b );
2991 :
2992 : /* Quantization */
2993 8016477 : if ( flag_quant )
2994 : {
2995 8016477 : stereo_dft_quantize_res_gains( pSideGain + b, pPredGain + b, pSideGain + b, pPredGain + b, hStereoDft->side_gain_index_EC + b, hStereoDft->res_pred_index_EC + b );
2996 : }
2997 :
2998 :
2999 8016477 : if ( !hStereoDft->attackPresent )
3000 : {
3001 7761517 : if ( b < hStereoDft->res_cod_band_max )
3002 : {
3003 1308110 : pSideGain[b] = dft_res_cod_alpha[b] * pSideGain[b] + ( 1 - dft_res_cod_alpha[b] ) * pSideGain[b - STEREO_DFT_BAND_MAX];
3004 : }
3005 : }
3006 : }
3007 :
3008 : /*------------------------------------------------------------------*
3009 : * simulate prediction of parameters at the decoder
3010 : *-----------------------------------------------------------------*/
3011 :
3012 871106 : if ( hStereoDft->reverb_flag )
3013 : {
3014 : int16_t ipred, bpred0, bpred1, max_dev, sum_abs_dev;
3015 :
3016 573054 : ipred = 0;
3017 573054 : max_dev = 0;
3018 573054 : sum_abs_dev = 0;
3019 :
3020 : /* parameters for bred0 <= b < bpred1 are estimated from parameters of
3021 : the remaining bands with ptrans0 <= b < btrans1. */
3022 573054 : bpred1 = ( hStereoDft->nbands > 10 ) ? STEREO_DFT_RES_PRED_BAND_MAX - 2 : hStereoDft->nbands;
3023 573054 : if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW )
3024 : {
3025 401774 : bpred1 = min( bpred1, 6 );
3026 : }
3027 573054 : bpred0 = bpred1 - STEREO_DFT_RES_PRED_BAND_MIN_CONST;
3028 :
3029 : /* get estimate (currently the maximal index) */
3030 2891546 : for ( b = hStereoDft->res_pred_band_min; b < bpred0; b++ )
3031 : {
3032 2318492 : ipred = max( ipred, hStereoDft->res_pred_index_EC[b] );
3033 : }
3034 :
3035 : /* check prediction error */
3036 2292216 : for ( b = bpred0; b < bpred1; b++ )
3037 : {
3038 1719162 : max_dev = (int16_t) max( max_dev, abs( ipred - hStereoDft->res_pred_index_EC[b] ) );
3039 1719162 : sum_abs_dev += (int16_t) abs( ipred - hStereoDft->res_pred_index_EC[b] );
3040 : }
3041 :
3042 573054 : hStereoDft->reverb_flag = ( max_dev <= 1 && sum_abs_dev <= 2 );
3043 :
3044 573054 : if ( hStereoDft->reverb_flag && hStereoDft->nbands > 10 ) /*SWB and FB*/
3045 : {
3046 221370 : for ( b = STEREO_DFT_RES_PRED_BAND_MAX - 1; b >= STEREO_DFT_RES_PRED_BAND_MAX - 2; b-- )
3047 : {
3048 147580 : hStereoDft->res_pred_index_EC[b - STEREO_DFT_RES_PRED_BAND_MIN_CONST] = hStereoDft->res_pred_index_EC[b];
3049 : }
3050 : }
3051 : #ifdef DEBUG_MODE_DFT
3052 : if ( hStereoDft->reverb_flag )
3053 : {
3054 : dbgwrite( &ipred, sizeof( ipred ), 1, 1, "./res/stereo_dft_enc_ipred" );
3055 : }
3056 : #endif
3057 : }
3058 : #ifdef DEBUG_MODE_DFT
3059 : dbgwrite( &( hStereoDft->reverb_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_reverb_flag2.pcm" );
3060 : #endif
3061 :
3062 871106 : assert( hStereoDft->nbands <= 13 ); /* always use band_limits_erb4 and not band_limits_erb2 */
3063 :
3064 871106 : return;
3065 : }
3066 :
3067 :
3068 : /*---------------------------------------------------------------------*
3069 : * side_gain_mode_decision()
3070 : *
3071 : *
3072 : *---------------------------------------------------------------------*/
3073 :
3074 671187 : static void side_gain_mode_decision(
3075 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
3076 : int16_t encoded_ind_GR[],
3077 : const int16_t sp_aud_decision0, /* i : Speech/audio decision 0 */
3078 : const int32_t last_core_brate /* i : Last core bitrate */
3079 : )
3080 : {
3081 : int16_t try_diff, nb_diff, no_GR_ord, n_bits, i;
3082 :
3083 671187 : try_diff = sp_aud_decision0;
3084 671187 : if ( try_diff )
3085 : {
3086 244061 : if ( hStereoDft->side_gain_counter == STEREO_DFT_FEC_THRESHOLD )
3087 : {
3088 8714 : try_diff = 0;
3089 8714 : hStereoDft->side_gain_counter = 0;
3090 : }
3091 : }
3092 : else
3093 : {
3094 427126 : hStereoDft->side_gain_counter = 0;
3095 : }
3096 :
3097 : /* If last frame SID/NO_DATA do not use differential coding */
3098 671187 : if ( last_core_brate <= SID_2k40 )
3099 : {
3100 6036 : try_diff = 0;
3101 : }
3102 671187 : no_GR_ord = 3;
3103 1342374 : hStereoDft->side_gain_flag_2 = adapt_GR_ief( hStereoDft->side_gain_index_EC, hStereoDft->side_gain_index_ECDiff, hStereoDft->side_gain_index_ECprevious,
3104 671187 : hStereoDft->nbands, NO_SYMB_GR_SIDE_G, &n_bits, encoded_ind_GR, dft_maps_sg, no_GR_ord, &nb_diff,
3105 671187 : hStereoDft->side_gain_counter, &hStereoDft->side_gain_bitdiff_lp, try_diff );
3106 :
3107 :
3108 7278552 : for ( i = 0; i < hStereoDft->nbands; i++ )
3109 : {
3110 6607365 : hStereoDft->side_gain_index_ECprevious[i] = hStereoDft->side_gain_index_EC[i];
3111 : }
3112 :
3113 671187 : if ( n_bits > ( hStereoDft->nbands * STEREO_DFT_SIDE_GAIN_NBITS - 1 ) )
3114 : {
3115 : /* use fixed rate */
3116 4562 : hStereoDft->side_gain_flag_1 = 3;
3117 4562 : hStereoDft->side_gain_counter = 0;
3118 : }
3119 : else
3120 : {
3121 666625 : if ( hStereoDft->side_gain_flag_2 >= no_GR_ord )
3122 : {
3123 198690 : hStereoDft->side_gain_flag_1 = 2;
3124 198690 : hStereoDft->side_gain_counter += 1;
3125 : }
3126 : else
3127 : {
3128 467935 : hStereoDft->side_gain_flag_1 = 0;
3129 467935 : hStereoDft->side_gain_counter = 0;
3130 : }
3131 : }
3132 :
3133 671187 : return;
3134 : }
3135 :
3136 :
3137 : /*---------------------------------------------------------------------*
3138 : * res_pred_gain_mode_decision()
3139 : *
3140 : *
3141 : *---------------------------------------------------------------------*/
3142 :
3143 671187 : static void res_pred_gain_mode_decision(
3144 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
3145 : int16_t encoded_ind_pred_GR[],
3146 : const int16_t k_offset, /* i : Parameter offset */
3147 : const int32_t last_core_brate /* i : Last core bitrate */
3148 : )
3149 : {
3150 : int16_t nb_diff, try_diff, no_GR_ord, i, n_bits;
3151 : int16_t nbands;
3152 :
3153 : /* Residual Prediction Gain */
3154 671187 : if ( hStereoDft->res_pred_mode[k_offset] )
3155 : {
3156 665123 : if ( hStereoDft->attackPresent == 0 )
3157 : {
3158 645696 : nbands = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
3159 :
3160 645696 : if ( hStereoDft->reverb_flag )
3161 : {
3162 146624 : nbands -= STEREO_DFT_RES_PRED_BAND_MIN_CONST;
3163 : }
3164 :
3165 645696 : try_diff = 1;
3166 645696 : if ( hStereoDft->res_pred_counter == STEREO_DFT_FEC_THRESHOLD )
3167 : {
3168 29352 : try_diff = 0;
3169 29352 : hStereoDft->res_pred_counter = 0;
3170 : }
3171 :
3172 : /* If last frame SID/NO_DATA do not use differential coding */
3173 645696 : if ( last_core_brate <= SID_2k40 )
3174 : {
3175 1425 : try_diff = 0;
3176 : }
3177 :
3178 645696 : no_GR_ord = 2;
3179 :
3180 645696 : hStereoDft->res_pred_flag_2 = adapt_GR_rpg1_ief( &hStereoDft->res_pred_index_EC[hStereoDft->res_pred_band_min], &hStereoDft->res_pred_index_ECDiff[hStereoDft->res_pred_band_min], &hStereoDft->res_pred_index_ECprevious[hStereoDft->res_pred_band_min], nbands - hStereoDft->res_pred_band_min, NO_SYMB_GR_PRED_G, &n_bits, encoded_ind_pred_GR, dft_maps_rpg, &nb_diff, no_GR_ord, try_diff );
3181 :
3182 6428679 : for ( i = 0; i < nbands; i++ )
3183 : {
3184 5782983 : hStereoDft->res_pred_index_ECprevious[i] = hStereoDft->res_pred_index_EC[i];
3185 : }
3186 :
3187 1239611 : for ( ; i < hStereoDft->nbands; i++ )
3188 : {
3189 593915 : hStereoDft->res_pred_index_ECprevious[i] = 0;
3190 : }
3191 :
3192 645696 : if ( n_bits > ( nbands - hStereoDft->res_pred_band_min ) * STEREO_DFT_RES_GAINS_BITS - 1 )
3193 : {
3194 43341 : hStereoDft->res_pred_flag_1 = 3;
3195 43341 : hStereoDft->res_pred_counter = 0;
3196 : }
3197 : else
3198 : {
3199 602355 : if ( hStereoDft->res_pred_flag_2 > 1 )
3200 : {
3201 : /* differential coding */
3202 423880 : hStereoDft->res_pred_flag_1 = 2;
3203 423880 : hStereoDft->res_pred_counter += 1;
3204 : }
3205 : else
3206 : {
3207 178475 : hStereoDft->res_pred_counter = 0;
3208 178475 : hStereoDft->res_pred_flag_1 = 0;
3209 : }
3210 : }
3211 : }
3212 : else
3213 : {
3214 19427 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
3215 : }
3216 : }
3217 : else
3218 : {
3219 6064 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
3220 : }
3221 :
3222 671187 : return;
3223 : }
3224 :
3225 :
3226 : /*-------------------------------------------------------------------------
3227 : * stereo_dft_calc_mean_bipd()
3228 : *
3229 : * Calculate mean of previous bandwise IPD values
3230 : *------------------------------------------------------------------------*/
3231 :
3232 6968848 : static float stereo_dft_calc_mean_bipd(
3233 : float *pIpd, /* i : current bandwise IPD */
3234 : float ipd_buf[STEREO_DFT_IPD_BUF_LEN] /* i/o: previous bandwise IPDs */
3235 : )
3236 : {
3237 : int16_t i;
3238 : float ipd_smooth;
3239 : float diff_to_last;
3240 :
3241 6968848 : assert( *pIpd <= EVS_PI && *pIpd >= -EVS_PI );
3242 :
3243 6968848 : ipd_smooth = 0.f;
3244 41813088 : for ( i = 0; i < STEREO_DFT_IPD_BUF_LEN; i++ )
3245 : {
3246 34844240 : if ( i == 0 )
3247 : {
3248 6968848 : diff_to_last = ipd_buf[0];
3249 : }
3250 : else
3251 : {
3252 27875392 : diff_to_last = fabsf( ipd_buf[i] - ipd_smooth );
3253 : }
3254 34844240 : if ( diff_to_last > EVS_PI )
3255 : {
3256 461328 : if ( ipd_buf[i] > 0 )
3257 : {
3258 263739 : ipd_buf[i] -= 2 * EVS_PI;
3259 : }
3260 : else
3261 : {
3262 197589 : ipd_buf[i] += 2 * EVS_PI;
3263 : }
3264 : }
3265 34844240 : ipd_smooth = ( i / (float) ( i + 1 ) ) * ipd_smooth + ( 1 / (float) ( i + 1 ) ) * ipd_buf[i];
3266 34844240 : if ( ipd_smooth < -EVS_PI )
3267 : {
3268 162520 : ipd_smooth += 2 * EVS_PI;
3269 : }
3270 34681720 : else if ( ipd_smooth > EVS_PI )
3271 : {
3272 96223 : ipd_smooth -= 2 * EVS_PI;
3273 : }
3274 : }
3275 :
3276 34844240 : for ( i = 0; i < STEREO_DFT_IPD_BUF_LEN - 1; i++ )
3277 : {
3278 27875392 : ipd_buf[i] = ipd_buf[i + 1];
3279 : }
3280 6968848 : ipd_buf[STEREO_DFT_IPD_BUF_LEN - 1] = *pIpd;
3281 :
3282 : #ifdef DEBUG_MODE_DFT
3283 : dbgwrite( pIpd, sizeof( float ), 1, 1, "res/stereo_dft_bipd.pcm" );
3284 : dbgwrite( &ipd_smooth, sizeof( float ), 1, 1, "res/stereo_dft_bipd_smooth.pcm" );
3285 : #endif
3286 :
3287 6968848 : return ipd_smooth;
3288 : }
3289 :
3290 :
3291 : /*-------------------------------------------------------------------------
3292 : * stereo_dft_calc_mean_ipd_change()
3293 : *
3294 : * Calculate mean IPD change over all bands
3295 : *------------------------------------------------------------------------*/
3296 :
3297 871106 : static float stereo_dft_calc_mean_ipd_change(
3298 : float *pIpd, /* i : bandwise IPDs */
3299 : float *ipd_smooth, /* i : mean of previous bandwise IPDs */
3300 : int16_t gipd_band_max /* i : number of IPD bands */
3301 : )
3302 : {
3303 : int16_t b;
3304 : float ipd_mean_change;
3305 : float ipd_change[STEREO_DFT_BAND_MAX];
3306 :
3307 871106 : ipd_mean_change = 0.f;
3308 7839954 : for ( b = 0; b < gipd_band_max; b++ )
3309 : {
3310 6968848 : ipd_change[b] = fabsf( pIpd[b] - ipd_smooth[b] );
3311 6968848 : if ( ipd_change[b] > EVS_PI )
3312 : {
3313 188763 : ipd_change[b] = 2 * EVS_PI - ipd_change[b];
3314 : }
3315 6968848 : ipd_mean_change += ipd_change[b];
3316 : }
3317 871106 : ipd_mean_change /= gipd_band_max;
3318 :
3319 : #ifdef DEBUG_MODE_DFT
3320 : dbgwrite( ipd_change, sizeof( float ), gipd_band_max, 1, "res/stereo_dft_ipd_change.pcm" );
3321 : dbgwrite( &ipd_mean_change, sizeof( float ), 1, 1, "res/stereo_dft_ipd_mean_change.pcm" );
3322 : #endif
3323 :
3324 871106 : return ipd_mean_change;
3325 : }
3326 :
3327 :
3328 : /*-------------------------------------------------------------------------
3329 : * stereo_dft_gipd_stabilization()
3330 : *
3331 : * stabilize global IPD based on stability of bandwise IPDs
3332 : *------------------------------------------------------------------------*/
3333 :
3334 871106 : static void stereo_dft_gipd_stabilization(
3335 : float *pgIpd, /* i/o: global IPD to be stabilized */
3336 : float prev_gipd, /* i : previous global IPD */
3337 : float ipd_mean_change /* i : mean of previous bandwise IPDs */
3338 : )
3339 : {
3340 : float diff_gipd;
3341 :
3342 871106 : if ( ipd_mean_change < 0.3f )
3343 : {
3344 504577 : *pgIpd = prev_gipd;
3345 : }
3346 : else
3347 : {
3348 366529 : diff_gipd = fabsf( *pgIpd - prev_gipd );
3349 366529 : if ( diff_gipd > EVS_PI )
3350 : {
3351 10543 : diff_gipd = 2 * EVS_PI - diff_gipd;
3352 : }
3353 366529 : if ( diff_gipd > ipd_mean_change )
3354 : {
3355 46908 : if ( *pgIpd > prev_gipd )
3356 : {
3357 23249 : if ( *pgIpd - prev_gipd < EVS_PI )
3358 : {
3359 19776 : *pgIpd = prev_gipd + ipd_mean_change;
3360 : }
3361 : else
3362 : {
3363 3473 : *pgIpd = prev_gipd - ipd_mean_change;
3364 3473 : if ( *pgIpd < -EVS_PI )
3365 : {
3366 1711 : *pgIpd += 2 * EVS_PI;
3367 : }
3368 : }
3369 : }
3370 : else
3371 : {
3372 23659 : if ( prev_gipd - *pgIpd < EVS_PI )
3373 : {
3374 19281 : *pgIpd = prev_gipd - ipd_mean_change;
3375 : }
3376 : else
3377 : {
3378 4378 : *pgIpd = prev_gipd + ipd_mean_change;
3379 4378 : if ( *pgIpd > EVS_PI )
3380 : {
3381 2265 : *pgIpd -= 2 * EVS_PI;
3382 : }
3383 : }
3384 : }
3385 : }
3386 : }
3387 871106 : return;
3388 : }
3389 :
3390 :
3391 : /*-------------------------------------------------------------------------
3392 : * stereo_dft_enc_get_nipd_flag()
3393 : *
3394 : *
3395 : *------------------------------------------------------------------------*/
3396 :
3397 871106 : static void stereo_dft_enc_get_nipd_flag(
3398 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
3399 : #ifdef DEBUG_MODE_DFT
3400 : float *pgIpd,
3401 : #endif
3402 : const int16_t sp_aud_decision0,
3403 : const float gainIPD )
3404 : {
3405 871106 : hStereoDft->gainIPD_sm = 0.5f * hStereoDft->gainIPD_sm + 0.5f * gainIPD; /* to decide on use of no IPD */
3406 :
3407 871106 : hStereoDft->no_ipd_flag = 0; /* Set flag initially to zero - subband IPD */
3408 :
3409 871106 : if ( hStereoDft->gainIPD_sm >= 0.75f || ( hStereoDft->prev_no_ipd_flag && ( sp_aud_decision0 || hStereoDft->voicing_lt > 0.98f ) ) )
3410 : {
3411 827795 : hStereoDft->no_ipd_flag = 1; /* Set the flag */
3412 : }
3413 :
3414 : #ifdef DEBUG_MODE_DFT
3415 : {
3416 : int16_t tmp;
3417 : dbgwrite( &( hStereoDft->no_ipd_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_nipd_first.pcm" );
3418 : tmp = (int16_t) ( hStereoDft->gainIPD_sm * 100.f );
3419 : dbgwrite( &tmp, sizeof( int16_t ), 1, 640, "./res/stereo_dft_gipd_gain_IPD.pcm" );
3420 : dbgwrite( pgIpd, sizeof( float ), 1, 1, "./res/stereo_dft_gipd_IPD.pcm" );
3421 : }
3422 : #endif
3423 :
3424 : /* hangover between the group IPD and subband IPD */
3425 871106 : if ( hStereoDft->prev_no_ipd_flag != hStereoDft->no_ipd_flag && hStereoDft->no_ipd_cnt < 5 )
3426 : {
3427 40466 : hStereoDft->no_ipd_flag = hStereoDft->prev_no_ipd_flag;
3428 40466 : hStereoDft->no_ipd_cnt++;
3429 : }
3430 : else
3431 : {
3432 830640 : hStereoDft->no_ipd_cnt = 0;
3433 : }
3434 :
3435 871106 : hStereoDft->prev_no_ipd_flag = hStereoDft->no_ipd_flag; /* Save the no IPD flag for the next frame */
3436 :
3437 : #ifdef DEBUG_MODE_DFT
3438 : /*fprintf(pF2, "%d\n",hStereoDft->no_ipd_flag);*/
3439 : dbgwrite( &( hStereoDft->no_ipd_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_nipd_final.pcm" );
3440 : #endif
3441 :
3442 871106 : return;
3443 : }
3444 :
3445 :
3446 : /*---------------------------------------------------------------
3447 : * stereo_dft_enc_get_reverb_flag()
3448 : *
3449 : *
3450 : * ---------------------------------------------------------------*/
3451 :
3452 469332 : static void stereo_dft_enc_get_reverb_flag(
3453 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
3454 : float *pPredGain,
3455 : float *sub_nrg_DMX,
3456 : const float *sub_nrg_L,
3457 : const float *sub_nrg_R,
3458 : const int16_t k_offset,
3459 : const float *bin_nrgL,
3460 : const float *bin_nrgR )
3461 : {
3462 : int16_t i, b, b1, index_min, nbands;
3463 : float nrg_DMX_min;
3464 : float norm_r, norm_l, norm_dmx;
3465 : float diff_l_l, diff_r_l, diff_l_h, diff_r_h;
3466 : float ener_l, ener_r, ener_dmx;
3467 : float nrg_DMX_max_avrg, nrg_DMX_min_avrg;
3468 : float fac;
3469 :
3470 469332 : hStereoDft->reverb_flag = 0;
3471 469332 : if ( hStereoDft->res_pred_mode[k_offset] && hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
3472 : {
3473 200673 : diff_r_l = EPSILON;
3474 200673 : diff_l_l = EPSILON;
3475 200673 : diff_r_h = EPSILON;
3476 200673 : diff_l_h = EPSILON;
3477 :
3478 1605384 : for ( b = 0; b <= min( hStereoDft->nbands, 6 ); b++ ) /* choose the subbands used for stereo filling */
3479 : {
3480 1404711 : norm_dmx = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_DMX[b] );
3481 1404711 : norm_l = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_L[b] );
3482 1404711 : norm_r = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_R[b] );
3483 :
3484 19264608 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
3485 : {
3486 17859897 : ener_l = bin_nrgL[i];
3487 17859897 : ener_r = bin_nrgR[i];
3488 17859897 : ener_dmx = ( ener_l + ener_r + 2 * sqrtf( ener_l * ener_r ) ) * norm_dmx; /*approximation of nrg of DMX per line*/
3489 17859897 : ener_l *= norm_l;
3490 17859897 : ener_r *= norm_r;
3491 :
3492 17859897 : diff_l_l += fabsf( ener_l - ener_dmx );
3493 17859897 : diff_r_l += fabsf( ener_r - ener_dmx );
3494 : }
3495 : }
3496 200673 : if ( hStereoDft->nbands <= 10 )
3497 : {
3498 145316 : for ( ; b < min( hStereoDft->nbands, 10 ); b++ ) /* choose the subbands used for stereo filling */
3499 : {
3500 108987 : norm_dmx = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_DMX[b] );
3501 108987 : norm_l = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_L[b] );
3502 108987 : norm_r = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_R[b] );
3503 :
3504 8464657 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
3505 : {
3506 8355670 : ener_l = bin_nrgL[i];
3507 8355670 : ener_r = bin_nrgR[i];
3508 8355670 : ener_dmx = ( ener_l + ener_r + 2 * sqrtf( ener_l * ener_r ) ) * norm_dmx; /*approximation of nrg of DMX per line*/
3509 8355670 : ener_l *= norm_l;
3510 8355670 : ener_r *= norm_r;
3511 :
3512 8355670 : diff_l_h += fabsf( ener_l - ener_dmx );
3513 8355670 : diff_r_h += fabsf( ener_r - ener_dmx );
3514 : }
3515 : }
3516 : }
3517 :
3518 2572140 : for ( b = 0; b < hStereoDft->nbands; b++ ) /* choose the subbands used for stereo filling */
3519 : {
3520 2371467 : sub_nrg_DMX[b] /= ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] );
3521 2371467 : sub_nrg_DMX[b] = 0.6f * hStereoDft->pre_sub_nrg_DMX[b] + 0.4f * sub_nrg_DMX[b];
3522 2371467 : hStereoDft->pre_sub_nrg_DMX[b] = sub_nrg_DMX[b];
3523 : }
3524 :
3525 : /* adaptively select the subbands to predict based on the energy */
3526 200673 : nbands = ( hStereoDft->nbands > 10 ) ? ( hStereoDft->nbands - 2 ) : hStereoDft->nbands;
3527 200673 : nrg_DMX_min_avrg = 0.0f;
3528 401346 : for ( b = 2; b < STEREO_DFT_RES_PRED_BAND_MIN_RED; b++ )
3529 : {
3530 200673 : nrg_DMX_min = sub_nrg_DMX[b];
3531 200673 : index_min = b;
3532 :
3533 1842106 : for ( b1 = 2; b1 < nbands; b1++ )
3534 : {
3535 1641433 : if ( nrg_DMX_min > sub_nrg_DMX[b1] )
3536 : {
3537 1096967 : nrg_DMX_min = sub_nrg_DMX[b1];
3538 1096967 : index_min = b1;
3539 : }
3540 : }
3541 :
3542 200673 : nrg_DMX_min_avrg += nrg_DMX_min;
3543 200673 : sub_nrg_DMX[index_min] = FLT_MAX;
3544 : }
3545 :
3546 200673 : nrg_DMX_max_avrg = 0.0f;
3547 1842106 : for ( b = 2, b1 = STEREO_DFT_RES_PRED_BAND_MIN_RED; b < nbands; b++ )
3548 : {
3549 1641433 : if ( sub_nrg_DMX[b] != FLT_MAX )
3550 : {
3551 1440760 : nrg_DMX_max_avrg += sub_nrg_DMX[b];
3552 : }
3553 : }
3554 :
3555 200673 : if ( hStereoDft->nbands <= 10 ) /*WB*/
3556 : {
3557 36329 : if ( hStereoDft->res_pred_mode[0] == STEREO_DFT_RESPRED_OFF || hStereoDft->hConfig->res_cod_mode != STEREO_DFT_RES_COD_OFF )
3558 : {
3559 2940 : hStereoDft->diff_l_h_sm = diff_l_h;
3560 2940 : hStereoDft->diff_r_h_sm = diff_r_h;
3561 : }
3562 : else
3563 : {
3564 33389 : hStereoDft->diff_l_h_sm = 0.9f * hStereoDft->diff_l_h_sm + 0.1f * diff_l_h;
3565 33389 : hStereoDft->diff_r_h_sm = 0.9f * hStereoDft->diff_r_h_sm + 0.1f * diff_r_h;
3566 : }
3567 :
3568 36329 : if ( hStereoDft->diff_l_h_sm > 120.0f || hStereoDft->diff_r_h_sm > 120.0f )
3569 : {
3570 21811 : hStereoDft->reverb_flag = 1;
3571 : }
3572 : }
3573 : else /*SWB/FB*/
3574 : {
3575 164344 : if ( 3 * nrg_DMX_max_avrg > 64 * 5 * nrg_DMX_min_avrg )
3576 : {
3577 149469 : hStereoDft->reverb_flag = 1;
3578 : }
3579 : }
3580 :
3581 : /*Stereo Filling gain damping*/
3582 200673 : fac = ( ( diff_l_l > diff_r_l ) ? diff_r_l / diff_l_l : diff_l_l / diff_r_l );
3583 200673 : fac = fac > 0.25f ? 1.0f : 4.f * fac;
3584 200673 : fac = 0.98f * hStereoDft->prev_fac2 + 0.02f * fac;
3585 200673 : hStereoDft->prev_fac2 = fac;
3586 :
3587 2572140 : for ( b = 0; b < hStereoDft->nbands; b++ )
3588 : {
3589 2371467 : if ( b < 5 )
3590 : {
3591 1003365 : pPredGain[b] *= max( 0.5f, fac );
3592 : }
3593 : else
3594 : {
3595 1368102 : pPredGain[b] *= min( 1.0f, max( 0.75f, 0.5f + fac ) );
3596 : }
3597 : }
3598 : }
3599 :
3600 : #ifdef DEBUG_MODE_DFT
3601 : dbgwrite( &( hStereoDft->reverb_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_reverb_flag.pcm" );
3602 : #endif
3603 :
3604 469332 : return;
3605 : }
3606 :
3607 : /*---------------------------------------------------------------
3608 : * stereo_dft_gain_offset()
3609 : *
3610 : * c = gain between L and R, itd = itd in samples @ 32kHz
3611 : * ---------------------------------------------------------------*/
3612 :
3613 1230201 : static float stereo_dft_gain_offset(
3614 : const float c,
3615 : const int16_t itd )
3616 : {
3617 : float wnt, go, alpha;
3618 : int16_t tau, k0;
3619 :
3620 1230201 : tau = (int16_t) min( abs( itd ), 160 );
3621 : /* Wn_table contains every 8th sample of the window's cross-correlation
3622 : * function @ 32kHz from which the values are interpolated: */
3623 1230201 : k0 = tau >> 3;
3624 1230201 : alpha = ( tau & 7 ) / 8.f;
3625 1230201 : wnt = ( 1 - alpha ) * Wn_table[k0] + alpha * Wn_table[k0 + 1];
3626 :
3627 1230201 : go = sqrtf( 8 * c * c / ( ( 1 + c ) * ( 1 + c ) ) * ( 1 - wnt ) / ( 1 + c * c + 2 * c * wnt ) );
3628 :
3629 1230201 : return go;
3630 : }
3631 :
3632 : /*---------------------------------------------------------------
3633 : * stereo_dft_enc_calculate_nrg_for_icbwe()
3634 : *
3635 : * calculate energy of downmix and left and right channel in the
3636 : * SHB region for later use in ICBWE
3637 : * ---------------------------------------------------------------*/
3638 :
3639 720818 : static void stereo_dft_enc_calculate_nrg_for_icbwe(
3640 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder DFT stereo handle */
3641 : const float *DMX, /* i : DFT Stereo downmix */
3642 : const int32_t input_Fs /* i : input sampling rate */
3643 : )
3644 : {
3645 : float *pDFT_L, *pDFT_R, bandResDft;
3646 : int16_t i, shbBins[3];
3647 :
3648 720818 : bandResDft = ( (float) input_Fs ) / hStereoDft->NFFT;
3649 720818 : shbBins[0] = (int16_t) ( 6400 / bandResDft );
3650 720818 : shbBins[1] = (int16_t) ( 10400 / bandResDft );
3651 720818 : shbBins[2] = (int16_t) ( 14400 / bandResDft );
3652 720818 : assert( shbBins[1] <= hStereoDft->NFFT / 2 );
3653 :
3654 720818 : set_f( hStereoDft->nrg_L, EPSILON, 2 );
3655 720818 : set_f( hStereoDft->nrg_R, EPSILON, 2 );
3656 720818 : set_f( hStereoDft->nrg_DMX, EPSILON, 2 );
3657 :
3658 720818 : pDFT_L = hStereoDft->DFT[0];
3659 720818 : pDFT_R = hStereoDft->DFT[1];
3660 :
3661 116051698 : for ( i = shbBins[0]; i < shbBins[1]; i++ )
3662 : {
3663 115330880 : hStereoDft->nrg_L[0] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
3664 115330880 : hStereoDft->nrg_R[0] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
3665 115330880 : hStereoDft->nrg_DMX[0] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
3666 : }
3667 116051698 : for ( ; i < shbBins[2]; i++ )
3668 : {
3669 115330880 : hStereoDft->nrg_L[1] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
3670 115330880 : hStereoDft->nrg_R[1] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
3671 115330880 : hStereoDft->nrg_DMX[1] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
3672 : }
3673 :
3674 720818 : return;
3675 : }
|
