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 298550 : 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 298550 : gg = *g;
122 :
123 298550 : if ( rq != NULL )
124 : {
125 294432 : rr = *r;
126 : }
127 : else
128 : {
129 4118 : rr = 0;
130 : }
131 :
132 298550 : if ( gg < 0 )
133 : {
134 187276 : gg = -gg;
135 187276 : sign = -1;
136 : }
137 : else
138 : {
139 111274 : 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 298550 : gg = min( gg, 1 - EPSILON );
149 298550 : rr = min( rr, sqrtf( 1 - gg * gg ) - EPSILON );
150 :
151 : /* we calculate the ILD ... */
152 298550 : 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 298550 : ild = ild > 50 ? 50 : ild;
156 :
157 : /* ... and determine the optimal ILD quantization ...*/
158 298550 : min_ind = 0;
159 298550 : old_val = fabsf( ild_q[0] - ild );
160 :
161 859258 : for ( i = 1; i < 16; i++ )
162 : {
163 858577 : min_val = fabsf( ild_q[i] - ild );
164 858577 : if ( min_val < old_val )
165 : {
166 560708 : min_ind = i;
167 : }
168 : else
169 : {
170 297869 : break;
171 : }
172 560708 : old_val = min_val;
173 : }
174 :
175 : /* ... which determines the quantization level: */
176 298550 : level = min_ind;
177 :
178 : /* Now we look for the closest quantization point in the corresponding column of res_gain_energy_q*/
179 298550 : old_val = FLT_MAX;
180 298550 : min_ind = 0;
181 298550 : index = -1;
182 2686950 : for ( i = 0; i < 8; i++ )
183 : {
184 2388400 : 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 2388400 : min_ind = min_val < old_val ? i : min_ind;
187 2388400 : old_val = min_val < old_val ? min_val : old_val;
188 :
189 2388400 : index = min_ind;
190 : }
191 :
192 : /* and here we are: */
193 298550 : if ( rq != NULL )
194 : {
195 294432 : *gq = dft_res_gains_q[8 * level + index][0] * sign;
196 294432 : *rq = dft_res_gains_q[8 * level + index][1];
197 :
198 294432 : *ir = index;
199 : }
200 298550 : *ig = sign < 0 ? 15 - level : 15 + level;
201 :
202 298550 : 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 3307 : 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 3307 : if ( bits == 2 ) /* New 2-bit phase quantization for the highest frequency band only */
221 : {
222 126 : delta = EVS_PI / 2.0f;
223 126 : max_ind = 3;
224 : }
225 3181 : else if ( bits == 3 )
226 : {
227 0 : delta = EVS_PI / 4.f;
228 0 : max_ind = 7;
229 : }
230 3181 : else if ( bits == 4 )
231 : {
232 3181 : delta = EVS_PI / 8.f;
233 3181 : 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 3307 : *ind = (int16_t) ( ( ( *in + EVS_PI ) / delta ) + 0.5f );
243 :
244 : /*modulo 2*PI*/
245 3307 : if ( *ind == max_ind + 1 )
246 : {
247 57 : *ind = 0;
248 : }
249 :
250 : /*Sanity check since no saturation can normally happen*/
251 3307 : *ind = min( max( *ind, 0 ), max_ind );
252 :
253 3307 : *out = *ind * delta - EVS_PI;
254 :
255 3307 : return;
256 : }
257 :
258 :
259 : /*-------------------------------------------------------------------------
260 : * stereo_dft_enc_create()
261 : *
262 : * Create DFT stereo handle
263 : *------------------------------------------------------------------------*/
264 :
265 486 : 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 486 : if ( *hStereoDft != NULL )
275 : {
276 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: DFT Stereo memory already allocated\n" );
277 : }
278 :
279 486 : 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 486 : 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 486 : 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 486 : hStereoDft_loc->hConfig->force_mono_transmission = 0;
295 :
296 486 : stereo_dft_config( hStereoDft_loc->hConfig, IVAS_24k4, &tmpS, &tmpS );
297 :
298 486 : stereo_dft_enc_open( hStereoDft_loc, input_Fs, max_bwidth );
299 :
300 486 : stereo_dft_hybrid_ITD_flag( hStereoDft_loc->hConfig, input_Fs,
301 486 : hStereoDft_loc->hItd->hybrid_itd_max );
302 :
303 486 : *hStereoDft = hStereoDft_loc;
304 :
305 486 : return IVAS_ERR_OK;
306 : }
307 :
308 :
309 : /*-------------------------------------------------------------------------
310 : * stereo_dft_enc_open()
311 : *
312 : * Initialize DFT stereo handle
313 : *------------------------------------------------------------------------*/
314 :
315 486 : 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 486 : hStereoDft->N = (int16_t) ( STEREO_DFT_HOP_MAX_ENC * input_Fs / 48000 );
326 486 : assert( ( ( input_Fs / FRAMES_PER_SEC ) / hStereoDft->N ) == 1 );
327 :
328 : /*Init. DFT sizes*/
329 486 : hStereoDft->NFFT = (int16_t) ( STEREO_DFT_N_MAX_ENC * input_Fs / 48000 );
330 486 : hStereoDft->dft_ovl = (int16_t) ( STEREO_DFT_OVL_MAX * input_Fs / 48000 );
331 486 : mdct_window_sine( win, input_Fs, hStereoDft->dft_ovl, FULL_OVERLAP, IVAS_CPE_DFT );
332 :
333 486 : hStereoDft->win_ana_energy = (float) hStereoDft->N - hStereoDft->dft_ovl;
334 486 : hStereoDft->win_ana_energy += 2 * sum_f( win, hStereoDft->dft_ovl );
335 486 : hStereoDft->win_ana_energy = hStereoDft->win_ana_energy / hStereoDft->NFFT;
336 486 : set_f( hStereoDft->output_mem_dmx_32k, 0, STEREO_DFT_OVL_32k );
337 :
338 486 : hStereoDft->dft_zp = (int16_t) ( STEREO_DFT_ZP_MAX_ENC * input_Fs / 48000 );
339 :
340 486 : hStereoDft->dft_trigo_8k = dft_trigo_32k;
341 486 : hStereoDft->dft_trigo_12k8 = dft_trigo_12k8;
342 486 : hStereoDft->dft_trigo_16k = dft_trigo_32k;
343 486 : hStereoDft->dft_trigo_32k = dft_trigo_32k;
344 :
345 486 : hStereoDft->win_ana_8k = win_ana_8k;
346 486 : hStereoDft->win_ana_12k8 = win_ana_12k8;
347 486 : hStereoDft->win_ana_16k = win_ana_16k;
348 486 : hStereoDft->win_ana_32k = win_ana_32k;
349 :
350 486 : hStereoDft->win_8k = win_syn_8k;
351 486 : hStereoDft->win_12k8 = win_syn_12k8;
352 486 : hStereoDft->win_16k = win_syn_16k;
353 486 : hStereoDft->win_32k = win_syn_32k;
354 :
355 486 : if ( input_Fs == 16000 )
356 : {
357 17 : hStereoDft->dft_trigo = dft_trigo_32k;
358 17 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
359 17 : hStereoDft->win_ana = win_ana_16k;
360 17 : hStereoDft->win = win_syn_16k;
361 : }
362 469 : else if ( input_Fs == 32000 )
363 : {
364 83 : hStereoDft->dft_trigo = dft_trigo_32k;
365 83 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
366 83 : hStereoDft->win_ana = win_ana_32k;
367 83 : hStereoDft->win = win_syn_32k;
368 : }
369 : else
370 : {
371 386 : assert( input_Fs == 48000 );
372 386 : hStereoDft->dft_trigo = dft_trigo_48k;
373 386 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_48k_STEP;
374 386 : hStereoDft->win_ana = win_ana_48k;
375 386 : hStereoDft->win = win_syn_48k;
376 : }
377 :
378 486 : hStereoDft->win_mdct_8k = win_mdct_8k;
379 :
380 : /*I/O Buffers*/
381 486 : set_zero( hStereoDft->output_mem_dmx, STEREO_DFT_OVL_MAX );
382 486 : set_zero( hStereoDft->output_mem_dmx_12k8, STEREO_DFT_OVL_12k8 );
383 486 : set_zero( hStereoDft->output_mem_dmx_16k, STEREO_DFT_OVL_16k );
384 486 : set_zero( hStereoDft->output_mem_dmx_16k_shb, STEREO_DFT_OVL_16k );
385 486 : 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 486 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[max_bwidth] / L_FRAME48k;
389 486 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
390 486 : hStereoDft->nbands_dmx = stereo_dft_band_config( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
391 :
392 : /*Set configuration*/
393 486 : set_s( hStereoDft->band_res, hStereoDft->hConfig->band_res, STEREO_DFT_ENC_DFT_NB );
394 486 : 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 486 : set_s( hStereoDft->res_cod_mode, hStereoDft->hConfig->res_cod_mode, STEREO_DFT_ENC_DFT_NB );
402 : }
403 486 : set_s( hStereoDft->res_pred_mode, hStereoDft->hConfig->res_pred_mode, STEREO_DFT_ENC_DFT_NB );
404 :
405 : /* reset DFT stereo memories */
406 486 : stereo_dft_enc_reset( hStereoDft );
407 :
408 486 : return;
409 : }
410 :
411 : /*-------------------------------------------------------------------------
412 : * stereo_dft_enc_reset()
413 : *
414 : * Reset DFT stereo memories
415 : *------------------------------------------------------------------------*/
416 :
417 913 : 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 913 : set_zero( hStereoDft->side_gain, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
424 913 : set_s( hStereoDft->side_gain_index_EC, 15, STEREO_DFT_BAND_MAX );
425 913 : set_s( hStereoDft->side_gain_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
426 913 : set_s( hStereoDft->side_gain_index_ECprevious, 15, STEREO_DFT_BAND_MAX );
427 913 : hStereoDft->side_gain_counter = 0;
428 913 : hStereoDft->side_gain_bitdiff_lp = STEREO_DFT_BITDIFF_INIT;
429 913 : set_zero( hStereoDft->gipd, STEREO_DFT_ENC_DFT_NB );
430 913 : set_zero( hStereoDft->dot_prod_real_smooth, STEREO_DFT_BAND_MAX );
431 913 : set_zero( hStereoDft->dot_prod_img_smooth, STEREO_DFT_BAND_MAX );
432 12782 : for ( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
433 : {
434 11869 : set_zero( hStereoDft->ipd_buf[i], STEREO_DFT_IPD_BUF_LEN );
435 : }
436 913 : hStereoDft->prev_gipd = 0.f;
437 913 : hStereoDft->gipd_index = 0;
438 913 : set_zero( hStereoDft->res_pred_gain, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
439 913 : set_s( hStereoDft->res_pred_index_EC, 0, STEREO_DFT_BAND_MAX );
440 913 : set_s( hStereoDft->res_pred_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
441 913 : set_s( hStereoDft->res_pred_index_ECprevious, 0, STEREO_DFT_BAND_MAX );
442 913 : hStereoDft->res_pred_counter = 0;
443 913 : set_zero( hStereoDft->past_nrgL, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
444 913 : set_zero( hStereoDft->past_nrgR, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
445 913 : set_zero( hStereoDft->past_dot_prod_real, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
446 913 : set_zero( hStereoDft->past_dot_prod_imag, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
447 913 : hStereoDft->nrg_past_pos = 0;
448 :
449 913 : hStereoDft->res_dmx_ratio_lt = 1.0f;
450 913 : hStereoDft->hangover_cnt0 = 0;
451 913 : hStereoDft->hangover_cnt1 = 0;
452 913 : hStereoDft->dmx_res_all_prev = EPSILON;
453 913 : hStereoDft->last_res_cod_mode_modify_flag = 0;
454 913 : hStereoDft->res_cod_sw_flag = 0;
455 913 : hStereoDft->switch_fade_factor = 0.5f;
456 913 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1] = STEREO_DFT_RES_COD_1kHz;
457 12782 : for ( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
458 : {
459 11869 : hStereoDft->res_cod_NRG_M[i] = 0;
460 11869 : hStereoDft->res_cod_NRG_S[i] = 0;
461 : }
462 913 : hStereoDft->old_snr = 0.f;
463 :
464 :
465 913 : hStereoDft->reverb_flag = 0;
466 913 : set_zero( hStereoDft->pre_sub_nrg_DMX, STEREO_DFT_BAND_MAX );
467 913 : hStereoDft->diff_l_h_sm = 0.0f;
468 913 : hStereoDft->diff_r_h_sm = 0.0f;
469 913 : hStereoDft->prev_fac2 = 1.0f;
470 :
471 913 : set_zero( hStereoDft->res_pred_gain_f, STEREO_DFT_BAND_MAX );
472 :
473 : /*misc*/
474 913 : hStereoDft->no_ipd_flag = 1; /* Initialization of the no IPD variables */
475 913 : hStereoDft->prev_no_ipd_flag = 1;
476 913 : hStereoDft->no_ipd_cnt = 0;
477 913 : hStereoDft->no_ipd_cnt1 = 0;
478 913 : hStereoDft->attackPresent = 0;
479 913 : hStereoDft->wasTransient = 0;
480 913 : hStereoDft->gainIPD_sm = 1.f;
481 :
482 :
483 913 : hStereoDft->voicing_lt = 0;
484 :
485 913 : hStereoDft->flip_sign = 1;
486 :
487 913 : hStereoDft->sfm = 0.f;
488 913 : hStereoDft->sum_dot_prod_real = 0.f;
489 913 : hStereoDft->sum_dot_prod_img = 0.f;
490 :
491 : /*Coherence*/
492 913 : set_f( hStereoDft->xspec_smooth, 1.0f, STEREO_DFT_N_32k_ENC );
493 913 : set_f( hStereoDft->Spd_L_smooth, 1.0f, STEREO_DFT_N_32k_ENC / 2 );
494 913 : set_f( hStereoDft->Spd_R_smooth, 1.0f, STEREO_DFT_N_32k_ENC / 2 );
495 :
496 913 : hStereoDft->currentNumUpdates = 0;
497 913 : hStereoDft->expectedNumUpdates = FIXED_SID_RATE;
498 913 : hStereoDft->resetFrames = 0;
499 913 : hStereoDft->sid_gipd = 0;
500 913 : hStereoDft->prev_sid_gipd = 0;
501 913 : hStereoDft->prev_sid_no_ipd_flag = 1;
502 :
503 913 : hStereoDft->coh_fade_counter = 0;
504 :
505 : /* Xtalk classifier */
506 913 : hStereoDft->hItd->prev_m1 = 0;
507 913 : hStereoDft->hItd->prev_m2 = 0;
508 913 : hStereoDft->hItd->prev_itd1 = 0;
509 913 : hStereoDft->hItd->prev_itd2 = 0;
510 :
511 913 : hStereoDft->first_frm_flag = 1;
512 :
513 : #ifdef DEBUG_MODE_DFT
514 : hStereoDft->verbose = 1;
515 : #endif
516 :
517 913 : stereo_enc_itd_init( hStereoDft->hItd );
518 :
519 913 : return;
520 : }
521 :
522 :
523 : /*-------------------------------------------------------------------------
524 : * stereo_enc_itd_init()
525 : *
526 : * initialize ITD struct
527 : *------------------------------------------------------------------------*/
528 :
529 1059 : void stereo_enc_itd_init(
530 : ITD_DATA_HANDLE hItd /* i/o: encoder ITD handle */
531 : )
532 : {
533 1059 : hItd->prev_itd = 0;
534 1059 : set_zero( hItd->itd, STEREO_DFT_ENC_DFT_NB );
535 1059 : set_zero( hItd->deltaItd, STEREO_DFT_ENC_DFT_NB );
536 1059 : set_s( hItd->td_itd, 0, STEREO_DFT_ENC_DFT_NB );
537 1059 : set_s( hItd->td_itd_32k, 0, STEREO_DFT_ENC_DFT_NB );
538 1059 : set_s( hItd->itd_index, 0, STEREO_DFT_ENC_DFT_NB );
539 1059 : set_zero( hItd->xcorr_smooth, STEREO_DFT_N_32k_ENC );
540 1059 : hItd->lp_phat_peak = 0.f;
541 1059 : hItd->itd_hangover = 0;
542 1059 : hItd->itd_cnt = 0;
543 1059 : hItd->prev_sum_nrg_L_lb = 0.f;
544 1059 : set_zero( hItd->prev_xcorr_lb, STEREO_DFT_XCORR_LB_MAX );
545 1059 : set_f( hItd->E_band_n, (float) ITD_VAD_E_BAND_N_INIT, STEREO_DFT_ITD_VAD_BAND_NUM );
546 1059 : hItd->vad_frm_cnt = 0;
547 1059 : hItd->pre_vad = 0;
548 1059 : hItd->itd_nonzero_cnt = 0;
549 1059 : set_zero( hItd->acorr_L, STEREO_DFT_BAND_MAX );
550 1059 : set_zero( hItd->acorr_R, STEREO_DFT_BAND_MAX );
551 1059 : hItd->cohSNR = 15.f;
552 1059 : hItd->itd_thres = 0.f;
553 1059 : hItd->valid_itd_cnt = 0;
554 :
555 1059 : hItd->detected_itd_flag = 0;
556 1059 : hItd->itd_tracking = 0;
557 1059 : hItd->prev_max = 0.f;
558 1059 : hItd->prev_index = 0;
559 1059 : hItd->prev_avg_max = 0.f;
560 1059 : hItd->currFlatness = 0.f;
561 :
562 : /* Xtalk classifier */
563 1059 : hItd->prev_m1 = 0;
564 1059 : hItd->prev_m2 = 0;
565 1059 : hItd->prev_itd1 = 0;
566 1059 : hItd->prev_itd2 = 0;
567 :
568 1059 : hItd->hybrid_itd_max = 0;
569 1059 : return;
570 : }
571 :
572 :
573 : /*--------------------------------------------------------------------------
574 : * stereo_dft_enc_update()
575 : *
576 : * Update DFT stereo memories for new frame
577 : *--------------------------------------------------------------------------*/
578 :
579 33102 : 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 33102 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
589 :
590 : /* Update the parameters and serial */
591 463428 : for ( i = 0; i < k_offset * STEREO_DFT_BAND_MAX; i++ )
592 : {
593 430326 : hStereoDft->side_gain[i] = hStereoDft->side_gain[STEREO_DFT_BAND_MAX + i];
594 430326 : hStereoDft->res_pred_gain[i] = hStereoDft->res_pred_gain[STEREO_DFT_BAND_MAX + i];
595 : }
596 :
597 66204 : for ( i = 0; i < k_offset; i++ )
598 : {
599 33102 : hStereoDft->gipd[i] = hStereoDft->gipd[i + 1];
600 : }
601 :
602 : /*Update configurations*/
603 66204 : for ( i = 0; i < k_offset; i++ )
604 : {
605 33102 : hStereoDft->band_res[i] = hStereoDft->band_res[i + 1];
606 33102 : hStereoDft->hItd->itd[i] = hStereoDft->hItd->itd[i + 1];
607 33102 : hStereoDft->res_cod_mode[i] = hStereoDft->res_cod_mode[i + 1];
608 33102 : hStereoDft->res_pred_mode[i] = hStereoDft->res_pred_mode[i + 1];
609 : }
610 :
611 : /*Set new configurations*/
612 33102 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
613 :
614 33102 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode && hStereoDft->NFFT == STEREO_DFT_N_16k_ENC )
615 : {
616 1936 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->ada_wb_res_cod_mode;
617 : }
618 : else
619 : {
620 31166 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->res_cod_mode;
621 : }
622 33102 : hStereoDft->res_pred_mode[k_offset] = hStereoDft->hConfig->res_pred_mode;
623 :
624 33102 : hStereoDft->last_res_cod_mode_modify_flag = hStereoDft->res_cod_sw_flag;
625 33102 : 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 33102 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[max_bwidth] / L_FRAME48k;
629 :
630 33102 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
631 33102 : hStereoDft->nbands_dmx = stereo_dft_band_config( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
632 :
633 : /*Compute main parameters*/
634 33102 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
635 33102 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
636 33102 : 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 33102 : hStereoDft->res_cod_line_max = 8 * ( hStereoDft->res_cod_line_max / 8 );
638 33102 : 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 33102 : return;
692 : }
693 :
694 :
695 : /*-------------------------------------------------------------------------
696 : * stereo_dft_enc_destroy()
697 : *
698 : * destroy DFT stereo handle
699 : *-------------------------------------------------------------------------*/
700 :
701 486 : void stereo_dft_enc_destroy(
702 : STEREO_DFT_ENC_DATA_HANDLE *hStereoDft /* i/o: encoder DFT stereo handle */
703 : )
704 : {
705 486 : if ( ( *hStereoDft )->hConfig != NULL )
706 : {
707 486 : free( ( *hStereoDft )->hConfig );
708 486 : ( *hStereoDft )->hConfig = NULL;
709 : }
710 :
711 486 : if ( ( *hStereoDft )->hItd != NULL )
712 : {
713 486 : free( ( *hStereoDft )->hItd );
714 486 : ( *hStereoDft )->hItd = NULL;
715 : }
716 :
717 486 : free( *hStereoDft );
718 486 : *hStereoDft = NULL;
719 :
720 486 : return;
721 : }
722 :
723 :
724 : /*-------------------------------------------------------------------------
725 : * stereo_dft_enc_analyze()
726 : *
727 : * DFT analysis on a 20ms frame
728 : *-------------------------------------------------------------------------*/
729 :
730 42342 : 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 42342 : push_wmops( "DFT_analysis" );
752 :
753 : /*-----------------------------------------------------------------*
754 : * Initialization
755 : *-----------------------------------------------------------------*/
756 :
757 127026 : for ( n = 0; n < n_channels; n++ )
758 : {
759 84684 : input[n] = sts[n]->input;
760 84684 : 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 42342 : pDFT_L = DFT[0];
786 42342 : pDFT_R = DFT[1];
787 :
788 42342 : if ( hStereoDft != NULL )
789 : {
790 33102 : N = hStereoDft->N;
791 33102 : NFFT = hStereoDft->NFFT;
792 33102 : dft_zp = hStereoDft->dft_zp;
793 33102 : dft_ovl = hStereoDft->dft_ovl;
794 33102 : offset = -dft_ovl;
795 33102 : pWin = hStereoDft->win_ana;
796 33102 : pTrigo = hStereoDft->dft_trigo;
797 33102 : trigo_step = hStereoDft->dft_trigo_step;
798 : }
799 : else
800 : {
801 9240 : N = hStereoMdct->hDft_ana->N;
802 9240 : NFFT = hStereoMdct->hDft_ana->NFFT;
803 9240 : dft_zp = hStereoMdct->hDft_ana->dft_zp;
804 9240 : dft_ovl = hStereoMdct->hDft_ana->dft_ovl;
805 9240 : offset = -dft_ovl;
806 9240 : pWin = hStereoMdct->hDft_ana->win_ana;
807 9240 : pTrigo = hStereoMdct->hDft_ana->dft_trigo;
808 9240 : trigo_step = hStereoMdct->hDft_ana->dft_trigo_step;
809 : }
810 :
811 14454502 : for ( i = 0; i < NFFT / 4; i++ )
812 : {
813 14412160 : trigo_enc[i] = pTrigo[i * trigo_step];
814 14412160 : trigo_enc[NFFT / 2 - i] = pTrigo[i * trigo_step];
815 : }
816 42342 : trigo_enc[NFFT / 4] = pTrigo[NFFT / 4 * trigo_step];
817 :
818 : /*Forwards FFT: L and R*/
819 : /*zero padding*/
820 8149182 : for ( i = 0; i < dft_zp; i++ )
821 : {
822 8106840 : pDFT_L[i] = 0.f;
823 8106840 : pDFT_L[NFFT - 1 - i] = 0.f;
824 :
825 8106840 : pDFT_R[i] = 0.f;
826 8106840 : pDFT_R[NFFT - 1 - i] = 0.f;
827 : }
828 :
829 : /*overlapping parts*/
830 12652982 : for ( i = 0; i < dft_ovl; i++ )
831 : {
832 12610640 : pDFT_L[dft_zp + i] = mem[0][i] * pWin[i];
833 12610640 : pDFT_L[dft_zp + N + dft_ovl - 1 - i] = input[0][offset + N + dft_ovl - 1 - i] * pWin[i];
834 :
835 12610640 : pDFT_R[dft_zp + i] = mem[1][i] * pWin[i];
836 12610640 : 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 16256022 : for ( i = 0; i < N - dft_ovl; i++ )
841 : {
842 16213680 : pDFT_L[dft_zp + dft_ovl + i] = input[0][offset + dft_ovl + i];
843 :
844 16213680 : pDFT_R[dft_zp + dft_ovl + i] = input[1][offset + dft_ovl + i];
845 : }
846 :
847 42342 : rfft( pDFT_L, trigo_enc, NFFT, -1 );
848 42342 : rfft( pDFT_R, trigo_enc, NFFT, -1 );
849 :
850 : /* update pointers to overlap memory */
851 127026 : for ( n = 0; n < n_channels; n++ )
852 : {
853 84684 : 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 42342 : if ( hStereoDft != NULL && hStereoDft->hConfig->hybrid_itd_flag && hStereoDft->hItd->td_itd[STEREO_DFT_OFFSET] )
860 : #endif
861 : {
862 17994 : for ( n = 0; n < n_channels; n++ )
863 : {
864 11996 : mvr2r( hStereoDft->input_mem_itd[n], input_mem[n], dft_ovl );
865 : }
866 : }
867 : else
868 : {
869 109032 : for ( n = 0; n < n_channels; n++ )
870 : {
871 72688 : mvr2r( input[n] + input_frame - dft_ovl, input_mem[n], dft_ovl );
872 : }
873 : }
874 :
875 42342 : pop_wmops();
876 42342 : return;
877 : }
878 :
879 :
880 : /*-------------------------------------------------------------------------
881 : * stereo_dft_enc_synthesize()
882 : *
883 : * Inverse DFT on a 20ms frame
884 : *-------------------------------------------------------------------------*/
885 :
886 119776 : 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 119776 : if ( L_frame > 0 )
912 : {
913 18088 : assert( ( output_sampling_rate == 16000 ) && "High-band generation only possible at 16kHz!" );
914 : }
915 119776 : nrg = 0.f;
916 :
917 119776 : hStereoDft->icbweRefEner = 0;
918 119776 : hStereoDft->lbEner = 0;
919 :
920 119776 : if ( chan == 0 )
921 : {
922 109821 : pDFT_in = hStereoDft->DFT[0];
923 : }
924 : else
925 : {
926 9955 : pDFT_in = hStereoDft->DFT[1];
927 : }
928 :
929 119776 : if ( output_sampling_rate == input_Fs )
930 : {
931 33102 : assert( chan == 0 );
932 :
933 33102 : NFFT = hStereoDft->NFFT;
934 33102 : fac = 1.f;
935 33102 : N = hStereoDft->N;
936 33102 : ovl = hStereoDft->dft_ovl;
937 33102 : zp = hStereoDft->dft_zp;
938 33102 : trigo = hStereoDft->dft_trigo;
939 33102 : trigo_step = hStereoDft->dft_trigo_step;
940 33102 : if ( L_frame > 0 )
941 : {
942 0 : mem = hStereoDft->output_mem_dmx_16k_shb;
943 : }
944 : else
945 : {
946 33102 : mem = hStereoDft->output_mem_dmx;
947 : }
948 33102 : win = hStereoDft->win;
949 33102 : win_ana = hStereoDft->win_ana;
950 :
951 33102 : push_wmops( "DFT_synth_fs" );
952 : }
953 86674 : else if ( output_sampling_rate == INT_FS_12k8 )
954 : {
955 33102 : assert( chan == 0 );
956 :
957 33102 : NFFT = STEREO_DFT_N_12k8_ENC;
958 33102 : N = STEREO_DFT_HOP_12k8_ENC;
959 33102 : zp = STEREO_DFT_ZP_12k8_ENC;
960 33102 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
961 33102 : ovl = STEREO_DFT_OVL_12k8;
962 33102 : trigo = hStereoDft->dft_trigo_12k8;
963 33102 : trigo_step = STEREO_DFT_TRIGO_SRATE_12k8_STEP;
964 33102 : mem = hStereoDft->output_mem_dmx_12k8;
965 33102 : win = hStereoDft->win_12k8;
966 33102 : win_ana = hStereoDft->win_ana_12k8;
967 :
968 33102 : push_wmops( "DFT_synth_12k8" );
969 : }
970 53572 : else if ( output_sampling_rate == 16000 )
971 : {
972 42671 : assert( chan == 0 );
973 :
974 42671 : NFFT = STEREO_DFT_N_16k_ENC;
975 42671 : N = STEREO_DFT_HOP_16k_ENC;
976 42671 : zp = STEREO_DFT_ZP_16k_ENC;
977 42671 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
978 42671 : ovl = STEREO_DFT_OVL_16k;
979 42671 : trigo = hStereoDft->dft_trigo_16k;
980 42671 : trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
981 42671 : if ( L_frame > 0 )
982 : {
983 18088 : mem = hStereoDft->output_mem_dmx_16k_shb;
984 :
985 18088 : push_wmops( "DFT_synth_16k_shb" );
986 : }
987 : else
988 : {
989 24583 : mem = hStereoDft->output_mem_dmx_16k;
990 :
991 24583 : push_wmops( "DFT_synth_16k" );
992 : }
993 42671 : win = hStereoDft->win_16k;
994 42671 : win_ana = hStereoDft->win_ana_16k;
995 : }
996 10901 : else if ( output_sampling_rate == 32000 )
997 : {
998 946 : assert( chan == 0 );
999 :
1000 946 : NFFT = STEREO_DFT_N_32k_ENC;
1001 946 : N = STEREO_DFT_HOP_32k_ENC;
1002 946 : zp = STEREO_DFT_ZP_32k_ENC;
1003 946 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1004 946 : ovl = STEREO_DFT_OVL_32k;
1005 946 : trigo = hStereoDft->dft_trigo_32k;
1006 946 : trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
1007 946 : mem = hStereoDft->output_mem_dmx_32k;
1008 946 : win = hStereoDft->win_32k;
1009 946 : win_ana = hStereoDft->win_ana_32k;
1010 :
1011 946 : push_wmops( "DFT_synth_32k" );
1012 : }
1013 9955 : else if ( output_sampling_rate == 8000 )
1014 : {
1015 9955 : assert( chan == 1 );
1016 :
1017 9955 : NFFT = STEREO_DFT_N_8k_ENC;
1018 9955 : N = STEREO_DFT_HOP_8k_ENC;
1019 9955 : zp = STEREO_DFT_ZP_8k_ENC;
1020 9955 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1021 9955 : ovl = STEREO_DFT_OVL_8k;
1022 9955 : trigo = hStereoDft->dft_trigo_8k;
1023 9955 : trigo_step = STEREO_DFT_TRIGO_SRATE_8k_STEP;
1024 9955 : mem = hStereoDft->output_mem_res_8k;
1025 9955 : win = hStereoDft->win_8k;
1026 9955 : win_ana = hStereoDft->win_ana_8k;
1027 :
1028 9955 : 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 119776 : offset = 0;
1046 :
1047 23829872 : for ( i = 0; i < NFFT / 4; i++ )
1048 : {
1049 23710096 : trigo_enc[i] = trigo[i * trigo_step];
1050 23710096 : trigo_enc[NFFT / 2 - i] = trigo[i * trigo_step];
1051 : }
1052 119776 : trigo_enc[NFFT / 4] = trigo[NFFT / 4 * trigo_step];
1053 :
1054 : /*-----------------------------------------------------------------*
1055 : * Synthesizing & resampling
1056 : *-----------------------------------------------------------------*/
1057 :
1058 119776 : offset = -ovl;
1059 :
1060 119776 : if ( L_frame == L_FRAME || L_frame == L_FRAME16k )
1061 : {
1062 5806248 : 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 5788160 : hStereoDft->icbweRefEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1065 : }
1066 5806248 : for ( i = 0; i < (int16_t) ( 200 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ); i++ )
1067 : {
1068 5788160 : hStereoDft->lbEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1069 : }
1070 18088 : hStereoDft->icbweRefEner *= fac;
1071 18088 : hStereoDft->lbEner *= fac;
1072 : }
1073 :
1074 : /*Flip?*/
1075 119776 : if ( L_frame == L_FRAME )
1076 : {
1077 : /* 6 to 14 kHz SHB target signal*/
1078 9352 : j = 2;
1079 9352 : set_zero( tmp, STEREO_DFT_N_MAX_ENC );
1080 9352 : sign = hStereoDft->flip_sign;
1081 :
1082 3011344 : 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 3001992 : tmp[j++] = sign * pDFT_in[2 * i] * fac;
1086 3001992 : tmp[j++] = -sign * pDFT_in[2 * i + 1] * fac;
1087 : }
1088 9352 : hStereoDft->flip_sign = -sign;
1089 :
1090 1515024 : for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1091 : {
1092 1505672 : nrg += tmp[2 * i] * tmp[2 * i];
1093 1505672 : nrg += tmp[2 * i + 1] * tmp[2 * i + 1];
1094 : }
1095 : }
1096 110424 : else if ( L_frame == L_FRAME16k )
1097 : {
1098 : /* 7.5 - 15.5 kHz SHB target signal*/
1099 8736 : j = 2;
1100 8736 : set_zero( tmp, STEREO_DFT_N_MAX_ENC );
1101 2804256 : 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 2795520 : tmp[j++] = pDFT_in[2 * i] * fac;
1104 2795520 : tmp[j++] = -1.f * pDFT_in[2 * i + 1] * fac;
1105 : }
1106 :
1107 1415232 : for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1108 : {
1109 1406496 : nrg += tmp[2 * i] * tmp[2 * i];
1110 1406496 : nrg += tmp[2 * i + 1] * tmp[2 * i + 1];
1111 : }
1112 : }
1113 101688 : else if ( fac != 1.f )
1114 : {
1115 : /*Copy and scale*/
1116 68586 : tmp[0] = pDFT_in[0] * fac;
1117 68586 : tmp[1] = 0.f;
1118 37009238 : for ( i = 2; i < NFFT; i++ )
1119 : {
1120 36940652 : tmp[i] = pDFT_in[i] * fac;
1121 : }
1122 :
1123 68586 : if ( fac < 1.f )
1124 : {
1125 68586 : tmp[1] = 0.f; /*Nyquist is set to 0*/
1126 68586 : tmp[0] = 0.f; /*DC is set to 0*/
1127 : }
1128 : }
1129 : else
1130 : {
1131 46219342 : for ( i = 0; i < NFFT; i++ )
1132 : {
1133 46186240 : tmp[i] = pDFT_in[i];
1134 : }
1135 : }
1136 :
1137 : /*Reconstruct */
1138 : /*IFFT*/
1139 119776 : rfft( tmp, trigo_enc, NFFT, +1 );
1140 :
1141 20866110 : for ( i = 0; i < ovl; i++ )
1142 : {
1143 20746334 : output[offset + i] = mem[i] + tmp[zp + i] * win[i];
1144 20746334 : mem[i] = tmp[zp + N + i] * win[ovl - 1 - i];
1145 : }
1146 :
1147 : /*Middle->Copy*/
1148 26793634 : for ( i = 0; i < N - ovl; i++ )
1149 : {
1150 26673858 : output[offset + ovl + i] = tmp[zp + ovl + i];
1151 : }
1152 :
1153 : /*-----------------------------------------------------------------*
1154 : * Lookahead: redress signal
1155 : *-----------------------------------------------------------------*/
1156 :
1157 20866110 : for ( i = 0; i < ovl; i++ )
1158 : {
1159 20746334 : float ifft_deviation = tmp[zp + N + ovl];
1160 20746334 : 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 119776 : pop_wmops();
1225 119776 : 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 33102 : 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 33102 : input_Fs = input_frame * FRAMES_PER_SEC;
1274 :
1275 33102 : hStereoDft = hCPE->hStereoDft;
1276 :
1277 33102 : wL = 0; /* avoid compilation warning */
1278 33102 : wR = 0; /* avoid compilation warning */
1279 :
1280 : /* Initialization */
1281 33102 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
1282 :
1283 33102 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
1284 33102 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->res_cod_mode[k_offset]];
1285 33102 : 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 33102 : hStereoDft->res_cod_line_max = 8 * ( hStereoDft->res_cod_line_max / 8 );
1287 :
1288 33102 : 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 33102 : hStereoDft->voicing_lt = 0.75f * hStereoDft->voicing_lt + 0.25f * hCPE->hCoreCoder[0]->voicing[0];
1295 33102 : 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 33102 : fac_att = 1.0f;
1303 :
1304 33102 : pDFT_L = hStereoDft->DFT[0];
1305 33102 : pDFT_R = hStereoDft->DFT[1];
1306 :
1307 : #ifdef DEBUG_MODE_DFT
1308 : if ( hStereoDft->hConfig->itd_mode )
1309 : #endif
1310 : {
1311 33102 : 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 33102 : if ( hCPE->element_mode == IVAS_CPE_MDCT )
1313 : {
1314 0 : return;
1315 : }
1316 :
1317 33102 : 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 14290 : alpha = -2.0f * EVS_PI * hStereoDft->hItd->deltaItd[k_offset] / hStereoDft->NFFT;
1326 14290 : c = 1.f; /*cos(0)*/
1327 14290 : s = 0.f; /*sin(0)*/
1328 : #ifdef NONBE_FIX_NONBE_BETWEEN_OPTIMIZATION_LEVELS
1329 :
1330 14290 : alpha_tmp = alpha;
1331 14290 : c1 = cosf( alpha_tmp );
1332 14290 : s1 = sinf( alpha_tmp );
1333 : #else
1334 : c1 = cosf( alpha );
1335 : s1 = sinf( alpha );
1336 : #endif
1337 :
1338 14290 : if ( alpha >= 0 )
1339 : {
1340 6874560 : for ( i = 1; i < hStereoDft->NFFT / 2; i++ )
1341 : {
1342 6864881 : tmp = s * c1 + c * s1;
1343 6864881 : c = c * c1 - s * s1;
1344 6864881 : s = tmp;
1345 :
1346 : /*time shift of L*/
1347 6864881 : tmp = pDFT_L[2 * i] * c - pDFT_L[2 * i + 1] * s;
1348 6864881 : pDFT_L[2 * i + 1] = pDFT_L[2 * i] * s + pDFT_L[2 * i + 1] * c;
1349 6864881 : pDFT_L[2 * i] = tmp;
1350 : }
1351 : }
1352 : else
1353 : {
1354 3097920 : for ( i = 1; i < hStereoDft->NFFT / 2; i++ )
1355 : {
1356 3093309 : tmp = s * c1 + c * s1;
1357 3093309 : c = c * c1 - s * s1;
1358 3093309 : s = tmp;
1359 :
1360 : /*time shift of R*/
1361 3093309 : tmp = pDFT_R[2 * i] * c + pDFT_R[2 * i + 1] * s;
1362 3093309 : pDFT_R[2 * i + 1] = -pDFT_R[2 * i] * s + pDFT_R[2 * i + 1] * c;
1363 3093309 : pDFT_R[2 * i] = tmp;
1364 : }
1365 : }
1366 :
1367 14290 : if ( fabsf( hStereoDft->hItd->deltaItd[k_offset] * 32000.f / input_Fs ) > 80.0f )
1368 : {
1369 2623 : 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 4667022 : for ( i = STEREO_DFT_N_32k_ENC / 2; i < hStereoDft->NFFT / 2; i++ )
1375 : {
1376 4633920 : bin_nrgL[i] = pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
1377 4633920 : 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 33102 : 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 33102 : if ( vad_flag_dtx[0] == 0 )
1397 : {
1398 5066 : if ( hCPE->hStereoCng->cng_counter == 0 && !hCPE->hStereoCng->first_SID_after_TD )
1399 : {
1400 68 : hStereoDft->sid_gipd = hStereoDft->prev_sid_gipd;
1401 68 : hStereoDft->no_ipd_flag = hStereoDft->prev_sid_no_ipd_flag;
1402 : }
1403 :
1404 5066 : if ( hCPE->hStereoCng->cng_counter > ITD_SID_PREV_FRAMES )
1405 : {
1406 4507 : hStereoDft->prev_sid_gipd = hStereoDft->sid_gipd;
1407 4507 : 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 33102 : 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 33102 : res_nrg_all_curr = EPSILON;
1428 33102 : dmx_nrg_all_curr = EPSILON;
1429 :
1430 33102 : pDFT_DMX = DFT_DMX;
1431 33102 : pDFT_RES = DFT_RES;
1432 33102 : pNrgL = bin_nrgL;
1433 33102 : pNrgR = bin_nrgR;
1434 :
1435 33102 : set_zero( pDFT_DMX, STEREO_DFT_N_MAX_ENC );
1436 33102 : set_zero( pDFT_RES, STEREO_DFT_N_8k_ENC );
1437 :
1438 33102 : pgIpd = hStereoDft->gipd + k_offset;
1439 33102 : pSideGain = hStereoDft->side_gain + k_offset * STEREO_DFT_BAND_MAX;
1440 :
1441 33102 : if ( hStereoDft->hConfig->dmx_active )
1442 : {
1443 : /*Active DMX*/
1444 33102 : alpha = 0; /* to avoid compilation warning */
1445 33102 : g = 1.f;
1446 :
1447 : /*Apply active DMX*/
1448 33102 : pDFT_DMX[0] = 0.f;
1449 33102 : pDFT_RES[0] = 0.f;
1450 416720 : for ( b = 0; b < hStereoDft->nbands_dmx; b++ )
1451 : {
1452 383618 : g = pSideGain[b];
1453 :
1454 383618 : if ( pgIpd[0] != 0.f )
1455 : {
1456 : #ifdef NONBE_FIX_NONBE_BETWEEN_OPTIMIZATION_LEVELS_2
1457 : volatile float pgIpd_tmp;
1458 :
1459 115261 : pgIpd_tmp = pgIpd[0];
1460 115261 : c = cosf( pgIpd_tmp );
1461 115261 : s = sinf( pgIpd_tmp );
1462 : #else
1463 : c = cosf( pgIpd[0] );
1464 : s = sinf( pgIpd[0] );
1465 : #endif
1466 6078737 : for ( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
1467 : {
1468 : /*rotate L*/
1469 5963476 : tmp = pDFT_L[2 * i] * c + pDFT_L[2 * i + 1] * s;
1470 5963476 : pDFT_L[2 * i + 1] = pDFT_L[2 * i + 1] * c - pDFT_L[2 * i] * s;
1471 5963476 : pDFT_L[2 * i] = tmp;
1472 : }
1473 : }
1474 :
1475 383618 : 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 42540 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode )
1487 : {
1488 : /*Calculate the energy of RES and DMX*/
1489 : /* 90% of old frame ... */
1490 42540 : dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.9f;
1491 42540 : res_nrg_all_curr += hStereoDft->res_cod_NRG_S[b] * 0.9f;
1492 : }
1493 42540 : hStereoDft->res_cod_NRG_M[b] = EPSILON;
1494 42540 : hStereoDft->res_cod_NRG_S[b] = EPSILON;
1495 :
1496 391368 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1497 : {
1498 348828 : pDFT_DMX[2 * i] = ( pDFT_L[2 * i] + pDFT_R[2 * i] ) * 0.5f;
1499 348828 : pDFT_DMX[2 * i + 1] = ( pDFT_L[2 * i + 1] + pDFT_R[2 * i + 1] ) * 0.5f;
1500 :
1501 348828 : pDFT_RES[2 * i] = ( pDFT_L[2 * i] - pDFT_R[2 * i] ) * 0.5f;
1502 348828 : 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 348828 : pDFT_RES[2 * i] = pDFT_RES[2 * i] - g * pDFT_DMX[2 * i];
1506 348828 : pDFT_RES[2 * i + 1] = pDFT_RES[2 * i + 1] - g * pDFT_DMX[2 * i + 1];
1507 :
1508 348828 : pDFT_RES[2 * i] *= fac_att;
1509 348828 : pDFT_RES[2 * i + 1] *= fac_att;
1510 :
1511 : /*Energy of the DMX and RES*/
1512 348828 : 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 348828 : 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 42540 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode )
1517 : {
1518 : /*Calculate the energy of RES and DMX*/
1519 : /* ... + 10% of current frame. */
1520 42540 : dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.1f;
1521 42540 : 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 341078 : upper_border = min( STEREO_DFT_DMX_CROSSOVER, hStereoDft->band_limits_dmx[b + 1] );
1533 :
1534 341078 : triple_bin = 0;
1535 341078 : 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 106884 : triple_bin = 1;
1539 106884 : upper_border -= 3;
1540 : }
1541 :
1542 3482048 : for ( i = hStereoDft->band_limits_dmx[b]; i < upper_border; i += 2 )
1543 : {
1544 3140970 : comb_nrgL = pNrgL[i] + pNrgL[i + 1];
1545 3140970 : comb_nrgR = pNrgR[i] + pNrgR[i + 1];
1546 3140970 : 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 3140970 : 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 3140970 : sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
1550 3140970 : frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
1551 3140970 : wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
1552 :
1553 3140970 : wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
1554 :
1555 : /*DMX Mapping*/
1556 3140970 : pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
1557 3140970 : pDFT_DMX[2 * i + 1] = ( wL * pDFT_L[2 * i + 1] + wR * pDFT_R[2 * i + 1] ) * INV_SQRT_2;
1558 3140970 : pDFT_DMX[2 * i + 2] = ( wL * pDFT_L[2 * i + 2] + wR * pDFT_R[2 * i + 2] ) * INV_SQRT_2;
1559 3140970 : pDFT_DMX[2 * i + 3] = ( wL * pDFT_L[2 * i + 3] + wR * pDFT_R[2 * i + 3] ) * INV_SQRT_2;
1560 : }
1561 :
1562 341078 : if ( triple_bin )
1563 : {
1564 106884 : comb_nrgL = comb_nrgR = 0.f;
1565 106884 : Sr = Si = 0.f;
1566 427536 : for ( j = i; j < i + 3; j++ )
1567 : {
1568 320652 : comb_nrgL += pNrgL[j];
1569 320652 : comb_nrgR += pNrgR[j];
1570 320652 : Sr += ( pDFT_L[2 * j] + pDFT_R[2 * j] ) * ( pDFT_L[2 * j] + pDFT_R[2 * j] );
1571 320652 : Si += ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] ) * ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] );
1572 : }
1573 :
1574 106884 : sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
1575 106884 : frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
1576 106884 : wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
1577 106884 : wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
1578 :
1579 427536 : for ( j = i; j < i + 3; j++ )
1580 : {
1581 320652 : pDFT_DMX[2 * j] = ( wL * pDFT_L[2 * j] + wR * pDFT_R[2 * j] ) * INV_SQRT_2;
1582 320652 : pDFT_DMX[2 * j + 1] = ( wL * pDFT_L[2 * j + 1] + wR * pDFT_R[2 * j + 1] ) * INV_SQRT_2;
1583 : }
1584 106884 : i += 3;
1585 : }
1586 :
1587 341078 : if ( i < hStereoDft->band_limits_dmx[b + 1] )
1588 : {
1589 85700 : sum_nrg_L2 = EPSILON;
1590 85700 : sum_nrg_R2 = EPSILON;
1591 85700 : dot_prod_real2 = EPSILON;
1592 13112698 : for ( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
1593 : {
1594 13026998 : sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
1595 13026998 : sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
1596 13026998 : dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
1597 : }
1598 :
1599 85700 : sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
1600 85700 : sum_abs = sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) + EPSILON;
1601 85700 : wR = sqrtf( 0.5f * ( sum_nrg_L2 + sum_nrg_R2 ) + dot_prod_nrg_ratio[b] ) / sum_abs;
1602 85700 : wL = wR + sqrtf( 2.f ) * ( 1.f - sqrtf( sum_nrg_Mid ) / sum_abs );
1603 : }
1604 :
1605 13368076 : for ( ; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
1606 : {
1607 : /*DMX Mapping*/
1608 13026998 : pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
1609 13026998 : 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 3114702 : for ( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->NFFT / 2; i++ )
1615 : {
1616 3081600 : pDFT_DMX[2 * i] = 0.f;
1617 3081600 : pDFT_DMX[2 * i + 1] = 0.f;
1618 : }
1619 :
1620 : /*Nyquist Freq.*/
1621 33102 : if ( hStereoDft->band_limits_dmx[b] >= hStereoDft->NFFT / 2 )
1622 : {
1623 24511 : pDFT_DMX[1] = ( pDFT_L[1] + pDFT_R[1] ) * 0.5f;
1624 : }
1625 : else
1626 : {
1627 8591 : pDFT_DMX[1] = 0.f;
1628 : }
1629 :
1630 : /* DC component */
1631 33102 : 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 33102 : if ( hStereoDft->NFFT == STEREO_DFT_N_16k_ENC && hStereoDft->hConfig->ada_wb_res_cod_mode )
1670 : {
1671 1936 : 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 1936 : if ( hStereoDft->res_cod_sw_flag )
1674 : {
1675 : int16_t res_cod_band_max;
1676 :
1677 60 : 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 360 : for ( b = 0; b < res_cod_band_max; b++ )
1681 : {
1682 300 : sum_nrg_L2 = EPSILON;
1683 300 : sum_nrg_R2 = EPSILON;
1684 300 : dot_prod_real2 = EPSILON;
1685 2760 : for ( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
1686 : {
1687 2460 : sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
1688 2460 : sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
1689 2460 : dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
1690 : }
1691 :
1692 300 : sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
1693 300 : wL = 0.5f * max( sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) - sqrtf( sum_nrg_Mid ), 0 ) * inv_sqrt( sum_nrg_L2 + EPSILON );
1694 300 : wS = 1;
1695 :
1696 300 : if ( hStereoDft->res_cod_sw_flag )
1697 : {
1698 300 : wL *= ( 1 - hStereoDft->switch_fade_factor );
1699 300 : wS = hStereoDft->switch_fade_factor;
1700 : }
1701 :
1702 2760 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1703 : {
1704 : /*DMX Recalculation*/
1705 2460 : DFT_DMX[2 * i] += wL * pDFT_L[2 * i];
1706 2460 : DFT_DMX[2 * i + 1] += wL * pDFT_L[2 * i + 1];
1707 :
1708 : /*RES Recalculation*/
1709 2460 : DFT_RES[2 * i] *= wS;
1710 2460 : DFT_RES[2 * i + 1] *= wS;
1711 : }
1712 : }
1713 : }
1714 : }
1715 :
1716 33102 : if ( input_Fs >= 32000 )
1717 : {
1718 24583 : stereo_dft_enc_calculate_nrg_for_icbwe( hStereoDft, DFT_DMX, input_Fs );
1719 : }
1720 :
1721 33102 : mvr2r( DFT_DMX, hStereoDft->DFT[0], STEREO_DFT_N_MAX_ENC );
1722 33102 : mvr2r( DFT_RES, hStereoDft->DFT[1], STEREO_DFT_N_8k_ENC );
1723 33102 : set_zero( hStereoDft->DFT[1] + STEREO_DFT_N_8k_ENC, STEREO_DFT_N_MAX_ENC - STEREO_DFT_N_8k_ENC );
1724 :
1725 33102 : 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 1936 : 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 1936 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
1748 :
1749 : /*Calculate energy ratio between residual signal and downmix signal */
1750 1936 : *res_dmx_ratio = 0;
1751 :
1752 11616 : for ( b = 0; b < hStereoDft->res_cod_band_max; b++ )
1753 : {
1754 9680 : g = fabsf( hStereoDft->side_gain[(k_offset) *STEREO_DFT_BAND_MAX + b] );
1755 9680 : *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 1936 : *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 1936 : dmx_res_all = res_nrg_all_curr + dmx_nrg_all_curr;
1761 :
1762 : /*Calculate the energy ratio of the inter-frame */
1763 1936 : *frame_nrg_ratio = dmx_res_all / hStereoDft->dmx_res_all_prev;
1764 1936 : *frame_nrg_ratio = min( 5.0f, max( 0.2f, *frame_nrg_ratio ) );
1765 :
1766 : /* Get fast update flag */
1767 1936 : fast_update_flag = 0;
1768 1936 : if ( ( *frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f ) || ( *frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f ) )
1769 : {
1770 38 : fast_update_flag = 1;
1771 : }
1772 :
1773 : /* Calculate long term energy ratio between residual signal and downmix signal */
1774 1936 : if ( fast_update_flag )
1775 : {
1776 38 : hStereoDft->res_dmx_ratio_lt = *res_dmx_ratio * 0.2f + hStereoDft->res_dmx_ratio_lt * 0.8f;
1777 : }
1778 : else
1779 : {
1780 1898 : 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 1936 : if ( hStereoDft->res_dmx_ratio_lt > 0.01f )
1785 : {
1786 1936 : res_cod_mode_flag = 1;
1787 : }
1788 : else
1789 : {
1790 0 : res_cod_mode_flag = 0;
1791 : }
1792 :
1793 : /* Get the residual signal coding flag */
1794 1936 : if ( hStereoDft->first_frm_flag )
1795 : {
1796 5 : prev_res_cod_mode_flag = res_cod_mode_flag;
1797 5 : hStereoDft->first_frm_flag = 0;
1798 : }
1799 : else
1800 : {
1801 1931 : prev_res_cod_mode_flag = hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1];
1802 : }
1803 1936 : if ( res_cod_mode_flag != prev_res_cod_mode_flag )
1804 : {
1805 354 : if ( prev_res_cod_mode_flag == 1 )
1806 : {
1807 0 : if ( hStereoDft->hangover_cnt0 < 5 && hStereoDft->last_res_cod_mode_modify_flag == 0 && fast_update_flag == 0 )
1808 : {
1809 0 : res_cod_mode_flag = prev_res_cod_mode_flag;
1810 0 : hStereoDft->hangover_cnt0++;
1811 : }
1812 : else
1813 : {
1814 : /* reset hangover */
1815 0 : hStereoDft->hangover_cnt0 = 0;
1816 : }
1817 : }
1818 : else
1819 : {
1820 354 : if ( *frame_nrg_ratio > 2.5f || *frame_nrg_ratio < 0.21f )
1821 : {
1822 : /* reset hangover */
1823 7 : hStereoDft->hangover_cnt1 = 0;
1824 : }
1825 : else
1826 : {
1827 347 : if ( hStereoDft->hangover_cnt1 < 5 )
1828 : {
1829 294 : res_cod_mode_flag = prev_res_cod_mode_flag;
1830 294 : hStereoDft->hangover_cnt1++;
1831 : }
1832 : else
1833 : {
1834 : /* reset hangover */
1835 53 : hStereoDft->hangover_cnt1 = 0;
1836 : }
1837 : }
1838 : }
1839 : }
1840 :
1841 : /* handle switching frames */
1842 1936 : if ( res_cod_mode_flag != prev_res_cod_mode_flag && hStereoDft->last_res_cod_mode_modify_flag == 0 )
1843 : {
1844 60 : hStereoDft->res_cod_sw_flag = 1;
1845 :
1846 : /* Update switch_fade_factor */
1847 60 : if ( *frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f )
1848 : {
1849 0 : hStereoDft->switch_fade_factor = 0.75f;
1850 : }
1851 60 : else if ( *frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f )
1852 : {
1853 0 : hStereoDft->switch_fade_factor = 0.25f;
1854 : }
1855 : else
1856 : {
1857 60 : hStereoDft->switch_fade_factor = 0.5f;
1858 : }
1859 :
1860 60 : if ( res_cod_mode_flag == 0 )
1861 : {
1862 0 : res_cod_mode_flag = 1;
1863 : }
1864 : }
1865 :
1866 : /*update previous frame's total energy of RES and DMX */
1867 1936 : hStereoDft->dmx_res_all_prev = dmx_res_all;
1868 :
1869 : /* update residual coding mode */
1870 1936 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] = res_cod_mode_flag;
1871 1936 : if ( !hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
1872 : {
1873 294 : hStereoDft->res_cod_band_max = 0;
1874 294 : hStereoDft->res_cod_line_max = 0;
1875 : }
1876 :
1877 : /*Update residual signal memory when switching from not coding residual signal to coding it*/
1878 1936 : if ( prev_res_cod_mode_flag == 0 && res_cod_mode_flag == 1 )
1879 : {
1880 60 : 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 1936 : return;
1895 : }
1896 :
1897 :
1898 : /*-------------------------------------------------------------------------
1899 : * stereo_dft_enc_res()
1900 : *
1901 : * Code the residual signal
1902 : *-------------------------------------------------------------------------*/
1903 :
1904 32572 : 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 32572 : assert( hStereoDft->res_cod_line_max <= L_FRAME8k );
1926 :
1927 32572 : if ( hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
1928 : {
1929 : /* Windowing */
1930 : /* overlapping parts */
1931 : /*input_8k-=STEREO_DFT_OVL_8k;*/
1932 605630 : for ( i = 0; i < STEREO_DFT_OVL_8k; i++ )
1933 : {
1934 597100 : win[i] = input_8k[i] * hStereoDft->win_mdct_8k[i];
1935 597100 : win[L_FRAME8k + i] = input_8k[L_FRAME8k + i] * hStereoDft->win_mdct_8k[STEREO_DFT_OVL_8k - 1 - i];
1936 : }
1937 : /* middle part */
1938 776230 : for ( ; i < L_FRAME8k; i++ )
1939 : {
1940 767700 : win[i] = input_8k[i];
1941 : }
1942 :
1943 : /* MDCT analysis */
1944 8530 : 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 8530 : max_snr = 0.f; /*minimum gain for residual coding -> no coding*/
1948 51180 : for ( b = 0; b < hStereoDft->res_cod_band_max; b++ )
1949 : {
1950 : /*Get side gain information and it is we*/
1951 42650 : panning_gain = hStereoDft->side_gain[STEREO_DFT_OFFSET * STEREO_DFT_BAND_MAX + b];
1952 42650 : panning_gain_min = 1.f - fabsf( panning_gain );
1953 :
1954 42650 : 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 42650 : in_phase_ratio = check_bounds( in_phase_ratio, 0, 1 );
1956 42650 : 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 42650 : if ( res_cod_gain[b] > max_snr )
1960 : {
1961 20765 : 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 8530 : hStereoDft->old_snr = 0.2f * max_snr + 0.8f * hStereoDft->old_snr;
1970 8530 : max_snr = hStereoDft->old_snr;
1971 :
1972 8530 : if ( max_snr < STEREO_DFT_RES_COD_SNR_MIN )
1973 : {
1974 434 : 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 8530 : push_wmops( "residual_encode" );
1981 : /* residual encoding */
1982 8530 : ECSQ_init_instance( &ecsq_inst, 0 /*dummy index*/, &range_uni_enc_state );
1983 8530 : rc_uni_enc_init( &range_uni_enc_state );
1984 :
1985 8530 : ecsq_inst.bit_count_estimate = 0;
1986 8530 : 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 8530 : 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 8530 : if ( global_gain_index != ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO )
1995 : {
1996 8129 : total_bit_count = rc_uni_enc_finish( &range_uni_enc_state );
1997 :
1998 8129 : 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 8129 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2005 8129 : ( *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 8129 : byte_buffer = range_uni_enc_state.byte_buffer;
2012 145716 : for ( idx = 0; idx < ( total_bit_count >> 3 ); ++idx )
2013 : {
2014 137587 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, byte_buffer[idx], 8 );
2015 : }
2016 8129 : 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 7064 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, byte_buffer[idx] >> ( 8 - ( total_bit_count & 7 ) ), total_bit_count & 7 );
2020 : }
2021 8129 : ( *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 0 : global_gain_index = ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO;
2030 0 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2031 0 : ( *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 401 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2042 401 : ( *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 8530 : 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 32572 : return;
2134 : }
2135 :
2136 :
2137 : /*-------------------------------------------------------------------------
2138 : * stereo_dft_enc_write_BS()
2139 : *
2140 : * Write DFT stereo bitstream
2141 : *-------------------------------------------------------------------------*/
2142 :
2143 28378 : 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 28378 : hStereoDft = hCPE->hStereoDft;
2179 28378 : hBstr = hCPE->hMetaData;
2180 28378 : core_brate = hCPE->hCoreCoder[0]->core_brate;
2181 :
2182 28378 : sp_aud_decision0 = 0;
2183 28378 : if ( hCPE->last_element_mode == IVAS_CPE_DFT )
2184 : {
2185 28175 : sp_aud_decision0 = hCPE->hCoreCoder[0]->sp_aud_decision0;
2186 : }
2187 :
2188 28378 : *nb_bits = 0;
2189 28378 : k_offset = STEREO_DFT_OFFSET;
2190 :
2191 28378 : nbands_full = hStereoDft->nbands;
2192 :
2193 28378 : if ( core_brate == FRAME_NO_DATA || core_brate == SID_2k40 )
2194 : {
2195 4475 : NFFT_inner = min( STEREO_DFT_N_32k_ENC, STEREO_DFT_N_MAX_ENC * inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth] / L_FRAME48k );
2196 4475 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
2197 4475 : hStereoDft->res_pred_mode[k_offset] = 0;
2198 4475 : hStereoDft->res_cod_mode[k_offset] = 0;
2199 : }
2200 : else
2201 : {
2202 23903 : 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 28378 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->band_res[k_offset], NFFT_inner, ENC );
2207 :
2208 28378 : if ( core_brate == FRAME_NO_DATA )
2209 : {
2210 : /* No data frame */
2211 3826 : ( *nb_bits ) = 0;
2212 3826 : return;
2213 : }
2214 :
2215 : /* attack present */
2216 : /* attackPresent not sent in inactive frames, receiver assumes = 0 */
2217 24552 : if ( core_brate != SID_2k40 )
2218 : {
2219 23903 : push_indice( hBstr, IND_STEREO_DFT_ATTACK_PRESENT, hStereoDft->attackPresent, 1 );
2220 23903 : ( *nb_bits )++;
2221 : }
2222 :
2223 : /* Writing coding residual coding mode into bitstream */
2224 24552 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode && hCPE->hCoreCoder[0]->bwidth == WB )
2225 : {
2226 2369 : push_indice( hBstr, IND_STEREO_DFT_RES_COD, hStereoDft->res_cod_mode[k_offset], 1 );
2227 2369 : ( *nb_bits )++;
2228 2369 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
2229 2369 : 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 24552 : if ( nbands_full < hStereoDft->nbands )
2245 : {
2246 0 : hStereoDft->reverb_flag = 0;
2247 : }
2248 :
2249 : /* Side gains */
2250 24552 : hStereoDft->side_gain_flag_1 = 0; /* EC coding by default */
2251 24552 : side_gain_mode_decision( hStereoDft, encoded_ind_GR, sp_aud_decision0, hCPE->hCoreCoder[0]->last_core_brate );
2252 :
2253 : /* residual pred. gains */
2254 24552 : hStereoDft->res_pred_flag_1 = 0; /* EC coding by default */
2255 :
2256 24552 : 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 24552 : if ( core_brate != SID_2k40 )
2263 : {
2264 23903 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, ( hStereoDft->hItd->itd[k_offset] != 0 ), STEREO_DFT_ITD_MODE_NBITS );
2265 23903 : ( *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 24552 : if ( core_brate != SID_2k40 )
2272 : {
2273 23903 : if ( hStereoDft->hItd->itd[k_offset] )
2274 : {
2275 14185 : itd = hStereoDft->hItd->itd_index[k_offset];
2276 14185 : if ( itd > 255 )
2277 : {
2278 8953 : itd -= 256;
2279 :
2280 8953 : if ( itd < 20 )
2281 : {
2282 5336 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2283 5336 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2284 5336 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2285 5336 : ( *nb_bits ) += dft_len_itd[itd] + 2;
2286 : }
2287 : else
2288 : {
2289 3617 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 0, 1 ); /* don't use Huffman */
2290 3617 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2291 3617 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS - 1 );
2292 3617 : ( *nb_bits ) += STEREO_DFT_ITD_NBITS + 1;
2293 : }
2294 : }
2295 : else
2296 : {
2297 5232 : if ( itd < 20 )
2298 : {
2299 2421 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2300 2421 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* positive */
2301 2421 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2302 2421 : ( *nb_bits ) += dft_len_itd[itd] + 2;
2303 : }
2304 : else
2305 : {
2306 : /* don't use Huffman and positive*/
2307 2811 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS + 1 );
2308 2811 : ( *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 24552 : nb = 0;
2328 24552 : if ( hStereoDft->side_gain_flag_1 > 0 )
2329 : {
2330 5349 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, 2 );
2331 5349 : nb += 2;
2332 : }
2333 : else
2334 : {
2335 19203 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, STEREO_DFT_FLAG_BITS );
2336 19203 : nb += STEREO_DFT_FLAG_BITS;
2337 : }
2338 :
2339 24552 : 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 24552 : if ( hStereoDft->side_gain_flag_1 == 0 )
2349 : {
2350 19203 : 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 5349 : if ( hStereoDft->side_gain_flag_1 == 2 )
2355 : {
2356 4818 : 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 3518 : for ( b = 0; b < hStereoDft->nbands; b++ )
2361 : {
2362 : /*ILD*/
2363 2987 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAINS, hStereoDft->side_gain_index_EC[b], STEREO_DFT_SIDEGAIN_NBITS );
2364 2987 : nb += STEREO_DFT_SIDEGAIN_NBITS;
2365 : }
2366 : }
2367 : }
2368 :
2369 : /* nb bits are used for side gain*/
2370 24552 : ( *nb_bits ) += nb;
2371 : #ifdef DEBUG_MODE_DFT_BITS
2372 : fprintf( SG_bits, "%d ", nb );
2373 : #endif
2374 24552 : nb = 0;
2375 :
2376 24552 : if ( core_brate == SID_2k40 )
2377 : {
2378 649 : stereo_dft_enc_sid_calc_coh( hStereoDft, hCPE->hStereoCng->prev_cohBand, &hCPE->hStereoCng->td_active, &hCPE->hStereoCng->first_SID, cohBand );
2379 :
2380 649 : 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 649 : if ( hStereoDft->hItd->itd[k_offset] != 0 )
2383 : {
2384 : /* Re-quantize ITD with lower resolution for Stereo CNG */
2385 21 : itd = hStereoDft->hItd->itd_index[k_offset];
2386 21 : if ( itd > 255 )
2387 : {
2388 9 : itd -= 256;
2389 : }
2390 21 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2391 :
2392 21 : sid_itd = itd && 1;
2393 : }
2394 : else
2395 : {
2396 628 : sid_itd = 0;
2397 : }
2398 :
2399 649 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, sid_itd, STEREO_DFT_ITD_MODE_NBITS );
2400 649 : ( *nb_bits ) += STEREO_DFT_ITD_MODE_NBITS; /*ITD mode flag: 1bit*/
2401 :
2402 649 : if ( sid_itd )
2403 : {
2404 11 : itd = hStereoDft->hItd->itd_index[k_offset];
2405 11 : if ( itd > 255 )
2406 : {
2407 0 : itd -= 256;
2408 0 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2409 :
2410 0 : if ( itd > ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) )
2411 : {
2412 0 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
2413 : }
2414 :
2415 0 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2416 0 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
2417 0 : ( *nb_bits ) += STEREO_DFT_SID_ITD_NBITS + 1;
2418 : }
2419 : else
2420 : {
2421 11 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2422 :
2423 11 : if ( itd > ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) )
2424 : {
2425 4 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
2426 : }
2427 :
2428 11 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* Positive */
2429 11 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
2430 11 : ( *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 24552 : if ( core_brate != SID_2k40 )
2446 : {
2447 23903 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
2448 23903 : nb += STEREO_DFT_FLAG_BITS; /*IPD mode flag: 1bit*/
2449 :
2450 23903 : if ( hStereoDft->no_ipd_flag == 0 )
2451 : {
2452 2205 : push_indice( hBstr, IND_STEREO_DFT_GIPD, hStereoDft->gipd_index, STEREO_DFT_GIPD_NBITS );
2453 2205 : nb += STEREO_DFT_GIPD_NBITS;
2454 : }
2455 : }
2456 649 : 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 649 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
2459 649 : nb += STEREO_DFT_FLAG_BITS; /*IPD mode flag: 1bit*/
2460 :
2461 649 : if ( hStereoDft->no_ipd_flag == 0 )
2462 : {
2463 126 : stereo_dft_quantize_ipd( &hStereoDft->sid_gipd, &hStereoDft->sid_gipd, &sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
2464 126 : push_indice( hBstr, IND_STEREO_DFT_GIPD, sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
2465 126 : 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 24552 : ( *nb_bits ) += nb;
2474 :
2475 : /*----------------------------------------------------------------*
2476 : * Residual prediction
2477 : *----------------------------------------------------------------*/
2478 :
2479 24552 : nb = 0; /* bits for residual pred gains */
2480 24552 : if ( hStereoDft->res_pred_mode[k_offset] )
2481 : {
2482 23903 : if ( hStereoDft->attackPresent == 0 )
2483 : {
2484 23043 : nbands = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
2485 23043 : b = hStereoDft->res_pred_band_min;
2486 :
2487 : /*Adaptive SF*/
2488 23043 : if ( hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
2489 : {
2490 : /*read flag*/
2491 14788 : push_indice( hBstr, IND_STEREO_DFT_REVERB_MODE, hStereoDft->reverb_flag, STEREO_DFT_REVERB_MODE_NBITS );
2492 14788 : nb += STEREO_DFT_REVERB_MODE_NBITS;
2493 : #ifdef DEBUG_MODE_DFT
2494 : fprintf( RPG_values, " reverb_flag %d ", hStereoDft->reverb_flag );
2495 : #endif
2496 14788 : if ( hStereoDft->reverb_flag )
2497 : {
2498 4021 : nbands -= STEREO_DFT_RES_PRED_BAND_MIN_CONST;
2499 : }
2500 : }
2501 :
2502 : /* Res Pred Gain flag 0 */
2503 23043 : if ( hStereoDft->res_pred_flag_1 > 0 )
2504 : {
2505 18430 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, 2 );
2506 18430 : nb += 2; /*pred gain mode flag: 2 bits*/
2507 : }
2508 : else
2509 : {
2510 4613 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, STEREO_DFT_FLAG_BITS );
2511 4613 : nb += STEREO_DFT_FLAG_BITS; /*pred gain mode flag: 1bit*/
2512 : }
2513 :
2514 23043 : no_GR_ord = 2;
2515 23043 : if ( hStereoDft->res_pred_flag_1 == 0 )
2516 : {
2517 : #ifdef DEBUG_MODE_DFT
2518 : fprintf( RPG_values, "flag: 0" );
2519 : #endif
2520 4613 : if ( encoded_ind_pred_GR[0] == dft_maps_rpg[8 * NO_SYMB_GR_PRED_G] )
2521 : {
2522 660 : nb += write_GR1( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, encoded_ind_pred_GR, 1 );
2523 : }
2524 : else
2525 : {
2526 3953 : 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 18430 : if ( hStereoDft->res_pred_flag_1 == 2 )
2532 : {
2533 : #ifdef DEBUG_MODE_DFT
2534 : fprintf( RPG_values, "flag: 2" );
2535 : #endif
2536 16509 : 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 13280 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2544 : {
2545 11359 : push_indice( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, hStereoDft->res_pred_index_EC[b], STEREO_DFT_RES_GAINS_BITS );
2546 11359 : 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 860 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands - hStereoDft->res_pred_band_min );
2569 : }
2570 : }
2571 : else
2572 : {
2573 649 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands - hStereoDft->res_pred_band_min );
2574 : }
2575 :
2576 24552 : ( *nb_bits ) += nb;
2577 :
2578 24552 : if ( core_brate == SID_2k40 )
2579 : {
2580 649 : 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 24552 : 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 33102 : 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 33102 : sum_past_dot_prod_abs2 = 0.0f;
2653 33102 : pos = hStereoDft->nrg_past_pos;
2654 :
2655 33102 : set_f( sub_nrg_DMX, 0, STEREO_DFT_BAND_MAX );
2656 33102 : set_f( sub_nrg_L, 0, STEREO_DFT_BAND_MAX );
2657 33102 : set_f( sub_nrg_R, 0, STEREO_DFT_BAND_MAX );
2658 :
2659 33102 : pSideGain = hStereoDft->side_gain + k_offset * STEREO_DFT_BAND_MAX;
2660 33102 : pgIpd = hStereoDft->gipd + k_offset;
2661 33102 : pPredGain = hStereoDft->res_pred_gain + k_offset * STEREO_DFT_BAND_MAX;
2662 33102 : gain_IPD = EPSILON;
2663 33102 : sum_energy_L = EPSILON; /* Set the accumulations for the no IPD Calculation */
2664 33102 : sum_energy_R = EPSILON;
2665 33102 : sum_dot_prod_real = EPSILON;
2666 33102 : sum_dot_prod_img = EPSILON;
2667 33102 : 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 33102 : b2 = 0;
2678 327534 : for ( b = 0; b < hStereoDft->nbands; b++ )
2679 : {
2680 294432 : pPredGain[b] = 1.f;
2681 294432 : sum_nrg_L = EPSILON;
2682 294432 : sum_nrg_R = EPSILON;
2683 294432 : dot_prod_real = EPSILON;
2684 294432 : dot_prod_img = EPSILON;
2685 294432 : sum_past_nrgL = 0;
2686 294432 : sum_past_nrgR = 0;
2687 294432 : sum_past_dpr = 0;
2688 294432 : sum_past_dpi = 0;
2689 :
2690 678050 : while ( hStereoDft->band_limits_dmx[b2] < hStereoDft->band_limits[b + 1] )
2691 : {
2692 383618 : pDFT_L = DFT_L;
2693 383618 : pDFT_R = DFT_R;
2694 383618 : pNrgL = bin_nrgL;
2695 383618 : pNrgR = bin_nrgR;
2696 :
2697 383618 : sum_nrg_L2 = EPSILON;
2698 383618 : sum_nrg_R2 = EPSILON;
2699 383618 : dot_prod_real2 = EPSILON;
2700 383618 : dot_prod_img2 = EPSILON;
2701 :
2702 20362036 : for ( i = hStereoDft->band_limits_dmx[b2]; i < hStereoDft->band_limits_dmx[b2 + 1]; i++ )
2703 : {
2704 19978418 : sum_nrg_L2 += pNrgL[i];
2705 19978418 : sum_nrg_R2 += pNrgR[i];
2706 :
2707 : /* compute dot product*/
2708 19978418 : dot_prod_real2 += pDFT_L[2 * i] * pDFT_R[2 * i] + pDFT_L[2 * i + 1] * pDFT_R[2 * i + 1];
2709 19978418 : dot_prod_img2 += pDFT_L[2 * i + 1] * pDFT_R[2 * i] - pDFT_L[2 * i] * pDFT_R[2 * i + 1];
2710 : }
2711 383618 : abs_L_R2 = sqrtf( dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2 );
2712 383618 : sub_nrg_DMX2 = sum_nrg_L2 + sum_nrg_R2 + 2 * abs_L_R2;
2713 :
2714 383618 : if ( b2 < hStereoDft->gipd_band_max )
2715 : {
2716 264816 : hStereoDft->dot_prod_real_smooth[b2] = 0.5f * hStereoDft->dot_prod_real_smooth[b2] + 0.5f * dot_prod_real2;
2717 264816 : hStereoDft->dot_prod_img_smooth[b2] = 0.5f * hStereoDft->dot_prod_img_smooth[b2] + 0.5f * dot_prod_img2;
2718 264816 : pIpd[b2] = (float) atan2f( hStereoDft->dot_prod_img_smooth[b2], hStereoDft->dot_prod_real_smooth[b2] );
2719 :
2720 264816 : ipd_smooth[b2] = stereo_dft_calc_mean_bipd( &pIpd[b2], hStereoDft->ipd_buf[b2] );
2721 :
2722 264816 : gain_IPD += ( sum_nrg_L2 + sum_nrg_R2 + 2 * dot_prod_real2 ) / sub_nrg_DMX2 / hStereoDft->gipd_band_max;
2723 : }
2724 :
2725 383618 : sum_past_nrgL2 = EPSILON;
2726 383618 : sum_past_nrgR2 = EPSILON;
2727 383618 : sum_past_dpr2 = EPSILON;
2728 383618 : sum_past_dpi2 = EPSILON;
2729 383618 : if ( ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_HIGH && b2 < STEREO_DFT_NRG_PAST_MAX_BAND ) ||
2730 227198 : ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW && b2 < 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) )
2731 : {
2732 282196 : hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_L2;
2733 282196 : hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_R2;
2734 282196 : hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_real2;
2735 282196 : hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_img2;
2736 :
2737 1128784 : for ( i = 0; i < STEREO_DFT_NRG_PAST_LEN; i++ )
2738 : {
2739 846588 : sum_past_nrgL2 += hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2740 846588 : sum_past_nrgR2 += hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2741 846588 : sum_past_dpr2 += hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2742 846588 : sum_past_dpi2 += hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2743 : }
2744 :
2745 282196 : if ( hStereoDft->attackPresent )
2746 : {
2747 : /* omit transient frames from past part of parameter estimation in following frames */
2748 8613 : int16_t prev_pos = ( pos + STEREO_DFT_NRG_PAST_LEN - 1 ) % STEREO_DFT_NRG_PAST_LEN;
2749 8613 : hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2750 8613 : hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2751 8613 : 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 8613 : 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 282196 : sum_past_dot_prod_abs2 = sqrtf( sum_past_dpr2 * sum_past_dpr2 + sum_past_dpi2 * sum_past_dpi2 );
2756 282196 : dot_prod_nrg_ratio[b2] = sum_past_dot_prod_abs2 / ( sum_past_nrgL2 + sum_past_nrgR2 + EPSILON );
2757 : }
2758 : else
2759 : {
2760 101422 : sum_past_nrgL2 += sum_nrg_L2;
2761 101422 : sum_past_nrgR2 += sum_nrg_R2;
2762 101422 : dot_prod_nrg_ratio[b2] = sqrtf( dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2 );
2763 101422 : if ( b2 == 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) /* hStereoDft->band_res[k_offset] == 2 */
2764 : {
2765 15722 : dot_prod_nrg_ratio[b2] /= ( sum_nrg_L2 + sum_nrg_R2 + EPSILON );
2766 : }
2767 : }
2768 383618 : sum_nrg_L += sum_nrg_L2;
2769 383618 : sum_nrg_R += sum_nrg_R2;
2770 383618 : dot_prod_real += dot_prod_real2;
2771 383618 : dot_prod_img += dot_prod_img2;
2772 :
2773 383618 : sum_past_nrgL += sum_past_nrgL2;
2774 383618 : sum_past_nrgR += sum_past_nrgR2;
2775 383618 : sum_past_dpr += sum_past_dpr2;
2776 383618 : sum_past_dpi += sum_past_dpi2;
2777 :
2778 383618 : b2++;
2779 : }
2780 294432 : sum_energy_L += sum_nrg_L; /* Energies of the individual Band for Left and Right */
2781 294432 : sum_energy_R += sum_nrg_R;
2782 294432 : sum_dot_prod_real += dot_prod_real;
2783 294432 : sum_dot_prod_img += dot_prod_img;
2784 :
2785 : /* compute side and residual gains over two frames */
2786 294432 : abs_L_R = sqrtf( dot_prod_real * dot_prod_real + dot_prod_img * dot_prod_img );
2787 :
2788 294432 : if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW && b < 4 )
2789 : {
2790 62888 : sum_past_dot_prod_abs = sqrtf( sum_past_dpr * sum_past_dpr + sum_past_dpi * sum_past_dpi );
2791 : }
2792 231544 : else if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_HIGH && b < 9 )
2793 : {
2794 156420 : sum_past_dot_prod_abs = sum_past_dot_prod_abs2;
2795 : }
2796 : else
2797 : {
2798 75124 : sum_past_dot_prod_abs = abs_L_R;
2799 : }
2800 :
2801 294432 : c = sqrtf( sum_past_nrgL / sum_past_nrgR );
2802 294432 : sum_past_nrg_dmx = sum_past_nrgL + sum_past_nrgR + 2 * sum_past_dot_prod_abs;
2803 294432 : sub_nrg_DMX[b] = sum_nrg_L + sum_nrg_R + 2 * abs_L_R;
2804 :
2805 294432 : sub_nrg_L[b] = sum_nrg_L;
2806 294432 : sub_nrg_R[b] = sum_nrg_R;
2807 :
2808 294432 : if ( ( hStereoDft->res_pred_mode[k_offset] && b >= hStereoDft->res_pred_band_min ) || ( b < hStereoDft->res_cod_band_max ) )
2809 : {
2810 271834 : g = ( sum_past_nrgL - sum_past_nrgR ) / ( sum_past_nrg_dmx );
2811 271834 : pSideGain[b] = g;
2812 : }
2813 : else
2814 : {
2815 22598 : g = 0.0f; /* to avoid compilation warning */
2816 22598 : pSideGain[b] = ( c - 1 ) / ( c + 1 );
2817 : }
2818 :
2819 294432 : 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 213713 : 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 213713 : reg = ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) * sqrtf( STEREO_DFT_N_32k_ENC );
2829 213713 : reg *= reg;
2830 :
2831 213713 : pPredGain[b] = sqrtf( pPredGain[b] / ( reg + sum_past_nrg_dmx ) );
2832 :
2833 213713 : 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 82923 : conversion_factor = 1.f;
2840 82923 : if ( hStereoDft->NFFT == STEREO_DFT_N_16k_ENC )
2841 : {
2842 23285 : conversion_factor = 2.f;
2843 : }
2844 59638 : else if ( hStereoDft->NFFT == STEREO_DFT_N_MAX_ENC )
2845 : {
2846 33459 : conversion_factor = 2.f / 3;
2847 : }
2848 82923 : dItd32 = (int16_t) floorf( conversion_factor * hStereoDft->hItd->deltaItd[k_offset] + 0.5f );
2849 :
2850 82923 : gain_offset = stereo_dft_gain_offset( c, dItd32 );
2851 82923 : pPredGain[b] = max( 0, pPredGain[b] - gain_offset );
2852 : }
2853 :
2854 : /*Limiter for active speech*/
2855 213713 : if ( sp_aud_decision0 == 0 && vad_flag )
2856 : {
2857 : /*Avoid jump of residual prediction gain when ITD is changing*/
2858 128229 : if ( hStereoDft->hItd->deltaItd[k_offset] != hStereoDft->hItd->deltaItd[0] )
2859 : {
2860 11202 : pPredGain[b] = min( hStereoDft->res_pred_gain_f[b], pPredGain[b] );
2861 : }
2862 :
2863 : /*Limiter*/
2864 128229 : hStereoDft->res_pred_gain_f[b] = 0.9f * hStereoDft->res_pred_gain_f[b] + 0.1f * pPredGain[b];
2865 128229 : pPredGain[b] = min( 1.1f * hStereoDft->res_pred_gain_f[b], pPredGain[b] );
2866 : }
2867 : else
2868 : {
2869 85484 : hStereoDft->res_pred_gain_f[b] = pPredGain[b];
2870 : }
2871 : }
2872 : else
2873 : {
2874 80719 : pPredGain[b] = 0.f;
2875 : }
2876 :
2877 :
2878 294432 : if ( b2 == hStereoDft->gipd_band_max )
2879 : {
2880 33102 : ipd_mean_change = stereo_dft_calc_mean_ipd_change( pIpd, ipd_smooth, hStereoDft->gipd_band_max );
2881 33102 : hStereoDft->sum_dot_prod_real = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_real + hStereoDft->sfm * sum_dot_prod_real;
2882 33102 : hStereoDft->sum_dot_prod_img = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_img + hStereoDft->sfm * sum_dot_prod_img;
2883 :
2884 33102 : pgIpd[0] = (float) atan2f( hStereoDft->sum_dot_prod_img, hStereoDft->sum_dot_prod_real );
2885 :
2886 33102 : stereo_dft_gipd_stabilization( &pgIpd[0], hStereoDft->prev_gipd, ipd_mean_change );
2887 33102 : hStereoDft->prev_gipd = pgIpd[0];
2888 : }
2889 : }
2890 :
2891 33102 : 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 33102 : 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 33102 : if ( flag_quant )
2929 : {
2930 33102 : if ( hStereoDft->no_ipd_flag == 0 )
2931 : {
2932 3181 : hStereoDft->sid_gipd = *pgIpd;
2933 3181 : stereo_dft_quantize_ipd( pgIpd, pgIpd, &( hStereoDft->gipd_index ), STEREO_DFT_GIPD_NBITS );
2934 : }
2935 : else
2936 : {
2937 29921 : pgIpd[0] = 0;
2938 : }
2939 : }
2940 33102 : diff_ipd = pgIpd[0] - pgIpd[-1];
2941 :
2942 33102 : if ( diff_ipd < -EVS_PI )
2943 : {
2944 766 : pgIpd[0] += PI2;
2945 : }
2946 32336 : else if ( diff_ipd > EVS_PI )
2947 : {
2948 262 : pgIpd[0] -= PI2;
2949 : }
2950 :
2951 33102 : if ( !hStereoDft->attackPresent )
2952 : {
2953 32088 : if ( hStereoDft->wasTransient )
2954 : {
2955 959 : pgIpd[0] = 0.8f * pgIpd[0] + 0.2f * pgIpd[-1];
2956 : }
2957 : else
2958 : {
2959 31129 : pgIpd[0] = 0.5f * pgIpd[0] + 0.5f * pgIpd[-1];
2960 : }
2961 : }
2962 :
2963 33102 : c = sqrtf( sum_energy_L / sum_energy_R );
2964 33102 : g = fabsf( ( c - 1 ) / ( c + 1 ) );
2965 33102 : if ( g > 0.8f )
2966 : {
2967 325 : g = max( 0.f, -10.f * g + 9.0f );
2968 2677 : for ( b = 0; b < hStereoDft->nbands; b++ )
2969 : {
2970 2352 : pPredGain[b] *= g;
2971 : }
2972 : }
2973 :
2974 33102 : if ( hStereoDft->hConfig->band_res == STEREO_DFT_BAND_RES_LOW )
2975 : {
2976 15722 : hStereoDft->reverb_flag = 1;
2977 : }
2978 : else
2979 : {
2980 17380 : 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 327534 : for ( b = 0; b < hStereoDft->nbands; b++ )
2989 : {
2990 294432 : hStereoDft->sidSideGain[b] = *( pSideGain + b );
2991 :
2992 : /* Quantization */
2993 294432 : if ( flag_quant )
2994 : {
2995 294432 : 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 294432 : if ( !hStereoDft->attackPresent )
3000 : {
3001 285647 : if ( b < hStereoDft->res_cod_band_max )
3002 : {
3003 49840 : 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 33102 : if ( hStereoDft->reverb_flag )
3013 : {
3014 : int16_t ipred, bpred0, bpred1, max_dev, sum_abs_dev;
3015 :
3016 21938 : ipred = 0;
3017 21938 : max_dev = 0;
3018 21938 : 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 21938 : bpred1 = ( hStereoDft->nbands > 10 ) ? STEREO_DFT_RES_PRED_BAND_MAX - 2 : hStereoDft->nbands;
3023 21938 : if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW )
3024 : {
3025 15722 : bpred1 = min( bpred1, 6 );
3026 : }
3027 21938 : bpred0 = bpred1 - STEREO_DFT_RES_PRED_BAND_MIN_CONST;
3028 :
3029 : /* get estimate (currently the maximal index) */
3030 107470 : for ( b = hStereoDft->res_pred_band_min; b < bpred0; b++ )
3031 : {
3032 85532 : ipred = max( ipred, hStereoDft->res_pred_index_EC[b] );
3033 : }
3034 :
3035 : /* check prediction error */
3036 87752 : for ( b = bpred0; b < bpred1; b++ )
3037 : {
3038 65814 : max_dev = (int16_t) max( max_dev, abs( ipred - hStereoDft->res_pred_index_EC[b] ) );
3039 65814 : sum_abs_dev += (int16_t) abs( ipred - hStereoDft->res_pred_index_EC[b] );
3040 : }
3041 :
3042 21938 : hStereoDft->reverb_flag = ( max_dev <= 1 && sum_abs_dev <= 2 );
3043 :
3044 21938 : if ( hStereoDft->reverb_flag && hStereoDft->nbands > 10 ) /*SWB and FB*/
3045 : {
3046 4806 : for ( b = STEREO_DFT_RES_PRED_BAND_MAX - 1; b >= STEREO_DFT_RES_PRED_BAND_MAX - 2; b-- )
3047 : {
3048 3204 : 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 33102 : assert( hStereoDft->nbands <= 13 ); /* always use band_limits_erb4 and not band_limits_erb2 */
3063 :
3064 33102 : return;
3065 : }
3066 :
3067 :
3068 : /*---------------------------------------------------------------------*
3069 : * side_gain_mode_decision()
3070 : *
3071 : *
3072 : *---------------------------------------------------------------------*/
3073 :
3074 24552 : 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 24552 : try_diff = sp_aud_decision0;
3084 24552 : if ( try_diff )
3085 : {
3086 5891 : if ( hStereoDft->side_gain_counter == STEREO_DFT_FEC_THRESHOLD )
3087 : {
3088 187 : try_diff = 0;
3089 187 : hStereoDft->side_gain_counter = 0;
3090 : }
3091 : }
3092 : else
3093 : {
3094 18661 : hStereoDft->side_gain_counter = 0;
3095 : }
3096 :
3097 : /* If last frame SID/NO_DATA do not use differential coding */
3098 24552 : if ( last_core_brate <= SID_2k40 )
3099 : {
3100 638 : try_diff = 0;
3101 : }
3102 24552 : no_GR_ord = 3;
3103 49104 : hStereoDft->side_gain_flag_2 = adapt_GR_ief( hStereoDft->side_gain_index_EC, hStereoDft->side_gain_index_ECDiff, hStereoDft->side_gain_index_ECprevious,
3104 24552 : hStereoDft->nbands, NO_SYMB_GR_SIDE_G, &n_bits, encoded_ind_GR, dft_maps_sg, no_GR_ord, &nb_diff,
3105 24552 : hStereoDft->side_gain_counter, &hStereoDft->side_gain_bitdiff_lp, try_diff );
3106 :
3107 :
3108 251424 : for ( i = 0; i < hStereoDft->nbands; i++ )
3109 : {
3110 226872 : hStereoDft->side_gain_index_ECprevious[i] = hStereoDft->side_gain_index_EC[i];
3111 : }
3112 :
3113 24552 : if ( n_bits > ( hStereoDft->nbands * STEREO_DFT_SIDE_GAIN_NBITS - 1 ) )
3114 : {
3115 : /* use fixed rate */
3116 531 : hStereoDft->side_gain_flag_1 = 3;
3117 531 : hStereoDft->side_gain_counter = 0;
3118 : }
3119 : else
3120 : {
3121 24021 : if ( hStereoDft->side_gain_flag_2 >= no_GR_ord )
3122 : {
3123 4818 : hStereoDft->side_gain_flag_1 = 2;
3124 4818 : hStereoDft->side_gain_counter += 1;
3125 : }
3126 : else
3127 : {
3128 19203 : hStereoDft->side_gain_flag_1 = 0;
3129 19203 : hStereoDft->side_gain_counter = 0;
3130 : }
3131 : }
3132 :
3133 24552 : return;
3134 : }
3135 :
3136 :
3137 : /*---------------------------------------------------------------------*
3138 : * res_pred_gain_mode_decision()
3139 : *
3140 : *
3141 : *---------------------------------------------------------------------*/
3142 :
3143 24552 : 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 24552 : if ( hStereoDft->res_pred_mode[k_offset] )
3155 : {
3156 23903 : if ( hStereoDft->attackPresent == 0 )
3157 : {
3158 23043 : nbands = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
3159 :
3160 23043 : if ( hStereoDft->reverb_flag )
3161 : {
3162 4021 : nbands -= STEREO_DFT_RES_PRED_BAND_MIN_CONST;
3163 : }
3164 :
3165 23043 : try_diff = 1;
3166 23043 : if ( hStereoDft->res_pred_counter == STEREO_DFT_FEC_THRESHOLD )
3167 : {
3168 881 : try_diff = 0;
3169 881 : hStereoDft->res_pred_counter = 0;
3170 : }
3171 :
3172 : /* If last frame SID/NO_DATA do not use differential coding */
3173 23043 : if ( last_core_brate <= SID_2k40 )
3174 : {
3175 129 : try_diff = 0;
3176 : }
3177 :
3178 23043 : no_GR_ord = 2;
3179 :
3180 23043 : 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 222140 : for ( i = 0; i < nbands; i++ )
3183 : {
3184 199097 : hStereoDft->res_pred_index_ECprevious[i] = hStereoDft->res_pred_index_EC[i];
3185 : }
3186 :
3187 39338 : for ( ; i < hStereoDft->nbands; i++ )
3188 : {
3189 16295 : hStereoDft->res_pred_index_ECprevious[i] = 0;
3190 : }
3191 :
3192 23043 : if ( n_bits > ( nbands - hStereoDft->res_pred_band_min ) * STEREO_DFT_RES_GAINS_BITS - 1 )
3193 : {
3194 1921 : hStereoDft->res_pred_flag_1 = 3;
3195 1921 : hStereoDft->res_pred_counter = 0;
3196 : }
3197 : else
3198 : {
3199 21122 : if ( hStereoDft->res_pred_flag_2 > 1 )
3200 : {
3201 : /* differential coding */
3202 16509 : hStereoDft->res_pred_flag_1 = 2;
3203 16509 : hStereoDft->res_pred_counter += 1;
3204 : }
3205 : else
3206 : {
3207 4613 : hStereoDft->res_pred_counter = 0;
3208 4613 : hStereoDft->res_pred_flag_1 = 0;
3209 : }
3210 : }
3211 : }
3212 : else
3213 : {
3214 860 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
3215 : }
3216 : }
3217 : else
3218 : {
3219 649 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
3220 : }
3221 :
3222 24552 : return;
3223 : }
3224 :
3225 :
3226 : /*-------------------------------------------------------------------------
3227 : * stereo_dft_calc_mean_bipd()
3228 : *
3229 : * Calculate mean of previous bandwise IPD values
3230 : *------------------------------------------------------------------------*/
3231 :
3232 264816 : 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 264816 : assert( *pIpd <= EVS_PI && *pIpd >= -EVS_PI );
3242 :
3243 264816 : ipd_smooth = 0.f;
3244 1588896 : for ( i = 0; i < STEREO_DFT_IPD_BUF_LEN; i++ )
3245 : {
3246 1324080 : if ( i == 0 )
3247 : {
3248 264816 : diff_to_last = ipd_buf[0];
3249 : }
3250 : else
3251 : {
3252 1059264 : diff_to_last = fabsf( ipd_buf[i] - ipd_smooth );
3253 : }
3254 1324080 : if ( diff_to_last > EVS_PI )
3255 : {
3256 27536 : if ( ipd_buf[i] > 0 )
3257 : {
3258 15727 : ipd_buf[i] -= 2 * EVS_PI;
3259 : }
3260 : else
3261 : {
3262 11809 : ipd_buf[i] += 2 * EVS_PI;
3263 : }
3264 : }
3265 1324080 : ipd_smooth = ( i / (float) ( i + 1 ) ) * ipd_smooth + ( 1 / (float) ( i + 1 ) ) * ipd_buf[i];
3266 1324080 : if ( ipd_smooth < -EVS_PI )
3267 : {
3268 9693 : ipd_smooth += 2 * EVS_PI;
3269 : }
3270 1314387 : else if ( ipd_smooth > EVS_PI )
3271 : {
3272 5855 : ipd_smooth -= 2 * EVS_PI;
3273 : }
3274 : }
3275 :
3276 1324080 : for ( i = 0; i < STEREO_DFT_IPD_BUF_LEN - 1; i++ )
3277 : {
3278 1059264 : ipd_buf[i] = ipd_buf[i + 1];
3279 : }
3280 264816 : 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 264816 : 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 33102 : 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 33102 : ipd_mean_change = 0.f;
3308 297918 : for ( b = 0; b < gipd_band_max; b++ )
3309 : {
3310 264816 : ipd_change[b] = fabsf( pIpd[b] - ipd_smooth[b] );
3311 264816 : if ( ipd_change[b] > EVS_PI )
3312 : {
3313 11257 : ipd_change[b] = 2 * EVS_PI - ipd_change[b];
3314 : }
3315 264816 : ipd_mean_change += ipd_change[b];
3316 : }
3317 33102 : 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 33102 : 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 33102 : 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 33102 : if ( ipd_mean_change < 0.3f )
3343 : {
3344 14665 : *pgIpd = prev_gipd;
3345 : }
3346 : else
3347 : {
3348 18437 : diff_gipd = fabsf( *pgIpd - prev_gipd );
3349 18437 : if ( diff_gipd > EVS_PI )
3350 : {
3351 653 : diff_gipd = 2 * EVS_PI - diff_gipd;
3352 : }
3353 18437 : if ( diff_gipd > ipd_mean_change )
3354 : {
3355 2773 : if ( *pgIpd > prev_gipd )
3356 : {
3357 1314 : if ( *pgIpd - prev_gipd < EVS_PI )
3358 : {
3359 1107 : *pgIpd = prev_gipd + ipd_mean_change;
3360 : }
3361 : else
3362 : {
3363 207 : *pgIpd = prev_gipd - ipd_mean_change;
3364 207 : if ( *pgIpd < -EVS_PI )
3365 : {
3366 84 : *pgIpd += 2 * EVS_PI;
3367 : }
3368 : }
3369 : }
3370 : else
3371 : {
3372 1459 : if ( prev_gipd - *pgIpd < EVS_PI )
3373 : {
3374 1153 : *pgIpd = prev_gipd - ipd_mean_change;
3375 : }
3376 : else
3377 : {
3378 306 : *pgIpd = prev_gipd + ipd_mean_change;
3379 306 : if ( *pgIpd > EVS_PI )
3380 : {
3381 143 : *pgIpd -= 2 * EVS_PI;
3382 : }
3383 : }
3384 : }
3385 : }
3386 : }
3387 33102 : return;
3388 : }
3389 :
3390 :
3391 : /*-------------------------------------------------------------------------
3392 : * stereo_dft_enc_get_nipd_flag()
3393 : *
3394 : *
3395 : *------------------------------------------------------------------------*/
3396 :
3397 33102 : 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 33102 : hStereoDft->gainIPD_sm = 0.5f * hStereoDft->gainIPD_sm + 0.5f * gainIPD; /* to decide on use of no IPD */
3406 :
3407 33102 : hStereoDft->no_ipd_flag = 0; /* Set flag initially to zero - subband IPD */
3408 :
3409 33102 : if ( hStereoDft->gainIPD_sm >= 0.75f || ( hStereoDft->prev_no_ipd_flag && ( sp_aud_decision0 || hStereoDft->voicing_lt > 0.98f ) ) )
3410 : {
3411 29020 : 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 33102 : if ( hStereoDft->prev_no_ipd_flag != hStereoDft->no_ipd_flag && hStereoDft->no_ipd_cnt < 5 )
3426 : {
3427 3485 : hStereoDft->no_ipd_flag = hStereoDft->prev_no_ipd_flag;
3428 3485 : hStereoDft->no_ipd_cnt++;
3429 : }
3430 : else
3431 : {
3432 29617 : hStereoDft->no_ipd_cnt = 0;
3433 : }
3434 :
3435 33102 : 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 33102 : return;
3443 : }
3444 :
3445 :
3446 : /*---------------------------------------------------------------
3447 : * stereo_dft_enc_get_reverb_flag()
3448 : *
3449 : *
3450 : * ---------------------------------------------------------------*/
3451 :
3452 17380 : 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 17380 : hStereoDft->reverb_flag = 0;
3471 17380 : if ( hStereoDft->res_pred_mode[k_offset] && hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
3472 : {
3473 7131 : diff_r_l = EPSILON;
3474 7131 : diff_l_l = EPSILON;
3475 7131 : diff_r_h = EPSILON;
3476 7131 : diff_l_h = EPSILON;
3477 :
3478 57048 : for ( b = 0; b <= min( hStereoDft->nbands, 6 ); b++ ) /* choose the subbands used for stereo filling */
3479 : {
3480 49917 : norm_dmx = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_DMX[b] );
3481 49917 : norm_l = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_L[b] );
3482 49917 : norm_r = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_R[b] );
3483 :
3484 684576 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
3485 : {
3486 634659 : ener_l = bin_nrgL[i];
3487 634659 : ener_r = bin_nrgR[i];
3488 634659 : ener_dmx = ( ener_l + ener_r + 2 * sqrtf( ener_l * ener_r ) ) * norm_dmx; /*approximation of nrg of DMX per line*/
3489 634659 : ener_l *= norm_l;
3490 634659 : ener_r *= norm_r;
3491 :
3492 634659 : diff_l_l += fabsf( ener_l - ener_dmx );
3493 634659 : diff_r_l += fabsf( ener_r - ener_dmx );
3494 : }
3495 : }
3496 7131 : if ( hStereoDft->nbands <= 10 )
3497 : {
3498 7748 : for ( ; b < min( hStereoDft->nbands, 10 ); b++ ) /* choose the subbands used for stereo filling */
3499 : {
3500 5811 : norm_dmx = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_DMX[b] );
3501 5811 : norm_l = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_L[b] );
3502 5811 : norm_r = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_R[b] );
3503 :
3504 451321 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
3505 : {
3506 445510 : ener_l = bin_nrgL[i];
3507 445510 : ener_r = bin_nrgR[i];
3508 445510 : ener_dmx = ( ener_l + ener_r + 2 * sqrtf( ener_l * ener_r ) ) * norm_dmx; /*approximation of nrg of DMX per line*/
3509 445510 : ener_l *= norm_l;
3510 445510 : ener_r *= norm_r;
3511 :
3512 445510 : diff_l_h += fabsf( ener_l - ener_dmx );
3513 445510 : diff_r_h += fabsf( ener_r - ener_dmx );
3514 : }
3515 : }
3516 : }
3517 :
3518 89481 : for ( b = 0; b < hStereoDft->nbands; b++ ) /* choose the subbands used for stereo filling */
3519 : {
3520 82350 : sub_nrg_DMX[b] /= ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] );
3521 82350 : sub_nrg_DMX[b] = 0.6f * hStereoDft->pre_sub_nrg_DMX[b] + 0.4f * sub_nrg_DMX[b];
3522 82350 : hStereoDft->pre_sub_nrg_DMX[b] = sub_nrg_DMX[b];
3523 : }
3524 :
3525 : /* adaptively select the subbands to predict based on the energy */
3526 7131 : nbands = ( hStereoDft->nbands > 10 ) ? ( hStereoDft->nbands - 2 ) : hStereoDft->nbands;
3527 7131 : nrg_DMX_min_avrg = 0.0f;
3528 14262 : for ( b = 2; b < STEREO_DFT_RES_PRED_BAND_MIN_RED; b++ )
3529 : {
3530 7131 : nrg_DMX_min = sub_nrg_DMX[b];
3531 7131 : index_min = b;
3532 :
3533 64831 : for ( b1 = 2; b1 < nbands; b1++ )
3534 : {
3535 57700 : if ( nrg_DMX_min > sub_nrg_DMX[b1] )
3536 : {
3537 39412 : nrg_DMX_min = sub_nrg_DMX[b1];
3538 39412 : index_min = b1;
3539 : }
3540 : }
3541 :
3542 7131 : nrg_DMX_min_avrg += nrg_DMX_min;
3543 7131 : sub_nrg_DMX[index_min] = FLT_MAX;
3544 : }
3545 :
3546 7131 : nrg_DMX_max_avrg = 0.0f;
3547 64831 : for ( b = 2, b1 = STEREO_DFT_RES_PRED_BAND_MIN_RED; b < nbands; b++ )
3548 : {
3549 57700 : if ( sub_nrg_DMX[b] != FLT_MAX )
3550 : {
3551 50569 : nrg_DMX_max_avrg += sub_nrg_DMX[b];
3552 : }
3553 : }
3554 :
3555 7131 : if ( hStereoDft->nbands <= 10 ) /*WB*/
3556 : {
3557 1937 : if ( hStereoDft->res_pred_mode[0] == STEREO_DFT_RESPRED_OFF || hStereoDft->hConfig->res_cod_mode != STEREO_DFT_RES_COD_OFF )
3558 : {
3559 356 : hStereoDft->diff_l_h_sm = diff_l_h;
3560 356 : hStereoDft->diff_r_h_sm = diff_r_h;
3561 : }
3562 : else
3563 : {
3564 1581 : hStereoDft->diff_l_h_sm = 0.9f * hStereoDft->diff_l_h_sm + 0.1f * diff_l_h;
3565 1581 : hStereoDft->diff_r_h_sm = 0.9f * hStereoDft->diff_r_h_sm + 0.1f * diff_r_h;
3566 : }
3567 :
3568 1937 : if ( hStereoDft->diff_l_h_sm > 120.0f || hStereoDft->diff_r_h_sm > 120.0f )
3569 : {
3570 1383 : hStereoDft->reverb_flag = 1;
3571 : }
3572 : }
3573 : else /*SWB/FB*/
3574 : {
3575 5194 : if ( 3 * nrg_DMX_max_avrg > 64 * 5 * nrg_DMX_min_avrg )
3576 : {
3577 4833 : hStereoDft->reverb_flag = 1;
3578 : }
3579 : }
3580 :
3581 : /*Stereo Filling gain damping*/
3582 7131 : fac = ( ( diff_l_l > diff_r_l ) ? diff_r_l / diff_l_l : diff_l_l / diff_r_l );
3583 7131 : fac = fac > 0.25f ? 1.0f : 4.f * fac;
3584 7131 : fac = 0.98f * hStereoDft->prev_fac2 + 0.02f * fac;
3585 7131 : hStereoDft->prev_fac2 = fac;
3586 :
3587 89481 : for ( b = 0; b < hStereoDft->nbands; b++ )
3588 : {
3589 82350 : if ( b < 5 )
3590 : {
3591 35655 : pPredGain[b] *= max( 0.5f, fac );
3592 : }
3593 : else
3594 : {
3595 46695 : 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 17380 : 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 82923 : 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 82923 : 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 82923 : k0 = tau >> 3;
3624 82923 : alpha = ( tau & 7 ) / 8.f;
3625 82923 : wnt = ( 1 - alpha ) * Wn_table[k0] + alpha * Wn_table[k0 + 1];
3626 :
3627 82923 : go = sqrtf( 8 * c * c / ( ( 1 + c ) * ( 1 + c ) ) * ( 1 - wnt ) / ( 1 + c * c + 2 * c * wnt ) );
3628 :
3629 82923 : 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 24583 : 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 24583 : bandResDft = ( (float) input_Fs ) / hStereoDft->NFFT;
3649 24583 : shbBins[0] = (int16_t) ( 6400 / bandResDft );
3650 24583 : shbBins[1] = (int16_t) ( 10400 / bandResDft );
3651 24583 : shbBins[2] = (int16_t) ( 14400 / bandResDft );
3652 24583 : assert( shbBins[1] <= hStereoDft->NFFT / 2 );
3653 :
3654 24583 : set_f( hStereoDft->nrg_L, EPSILON, 2 );
3655 24583 : set_f( hStereoDft->nrg_R, EPSILON, 2 );
3656 24583 : set_f( hStereoDft->nrg_DMX, EPSILON, 2 );
3657 :
3658 24583 : pDFT_L = hStereoDft->DFT[0];
3659 24583 : pDFT_R = hStereoDft->DFT[1];
3660 :
3661 3957863 : for ( i = shbBins[0]; i < shbBins[1]; i++ )
3662 : {
3663 3933280 : hStereoDft->nrg_L[0] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
3664 3933280 : hStereoDft->nrg_R[0] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
3665 3933280 : hStereoDft->nrg_DMX[0] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
3666 : }
3667 3957863 : for ( ; i < shbBins[2]; i++ )
3668 : {
3669 3933280 : hStereoDft->nrg_L[1] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
3670 3933280 : hStereoDft->nrg_R[1] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
3671 3933280 : hStereoDft->nrg_DMX[1] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
3672 : }
3673 :
3674 24583 : return;
3675 : }
|
