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 556813 : 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 556813 : gg = *g;
122 :
123 556813 : if ( rq != NULL )
124 : {
125 548015 : rr = *r;
126 : }
127 : else
128 : {
129 8798 : rr = 0;
130 : }
131 :
132 556813 : if ( gg < 0 )
133 : {
134 352224 : gg = -gg;
135 352224 : sign = -1;
136 : }
137 : else
138 : {
139 204589 : 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 556813 : gg = min( gg, 1 - EPSILON );
149 556813 : rr = min( rr, sqrtf( 1 - gg * gg ) - EPSILON );
150 :
151 : /* we calculate the ILD ... */
152 556813 : 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 556813 : ild = ild > 50 ? 50 : ild;
156 :
157 : /* ... and determine the optimal ILD quantization ...*/
158 556813 : min_ind = 0;
159 556813 : old_val = fabsf( ild_q[0] - ild );
160 :
161 1590843 : for ( i = 1; i < 16; i++ )
162 : {
163 1589372 : min_val = fabsf( ild_q[i] - ild );
164 1589372 : if ( min_val < old_val )
165 : {
166 1034030 : min_ind = i;
167 : }
168 : else
169 : {
170 555342 : break;
171 : }
172 1034030 : old_val = min_val;
173 : }
174 :
175 : /* ... which determines the quantization level: */
176 556813 : level = min_ind;
177 :
178 : /* Now we look for the closest quantization point in the corresponding column of res_gain_energy_q*/
179 556813 : old_val = FLT_MAX;
180 556813 : min_ind = 0;
181 556813 : index = -1;
182 5011317 : for ( i = 0; i < 8; i++ )
183 : {
184 4454504 : 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 4454504 : min_ind = min_val < old_val ? i : min_ind;
187 4454504 : old_val = min_val < old_val ? min_val : old_val;
188 :
189 4454504 : index = min_ind;
190 : }
191 :
192 : /* and here we are: */
193 556813 : if ( rq != NULL )
194 : {
195 548015 : *gq = dft_res_gains_q[8 * level + index][0] * sign;
196 548015 : *rq = dft_res_gains_q[8 * level + index][1];
197 :
198 548015 : *ir = index;
199 : }
200 556813 : *ig = sign < 0 ? 15 - level : 15 + level;
201 :
202 556813 : 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 6313 : 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 6313 : if ( bits == 2 ) /* New 2-bit phase quantization for the highest frequency band only */
221 : {
222 275 : delta = EVS_PI / 2.0f;
223 275 : max_ind = 3;
224 : }
225 6038 : else if ( bits == 3 )
226 : {
227 0 : delta = EVS_PI / 4.f;
228 0 : max_ind = 7;
229 : }
230 6038 : else if ( bits == 4 )
231 : {
232 6038 : delta = EVS_PI / 8.f;
233 6038 : 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 6313 : *ind = (int16_t) ( ( ( *in + EVS_PI ) / delta ) + 0.5f );
243 :
244 : /*modulo 2*PI*/
245 6313 : if ( *ind == max_ind + 1 )
246 : {
247 107 : *ind = 0;
248 : }
249 :
250 : /*Sanity check since no saturation can normally happen*/
251 6313 : *ind = min( max( *ind, 0 ), max_ind );
252 :
253 6313 : *out = *ind * delta - EVS_PI;
254 :
255 6313 : return;
256 : }
257 :
258 :
259 : /*-------------------------------------------------------------------------
260 : * stereo_dft_enc_create()
261 : *
262 : * Create DFT stereo handle
263 : *------------------------------------------------------------------------*/
264 :
265 878 : 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 878 : if ( *hStereoDft != NULL )
275 : {
276 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: DFT Stereo memory already allocated\n" );
277 : }
278 :
279 878 : 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 878 : 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 878 : 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 878 : hStereoDft_loc->hConfig->force_mono_transmission = 0;
295 :
296 878 : stereo_dft_config( hStereoDft_loc->hConfig, IVAS_24k4, &tmpS, &tmpS );
297 :
298 878 : stereo_dft_enc_open( hStereoDft_loc, input_Fs, max_bwidth );
299 :
300 878 : stereo_dft_hybrid_ITD_flag( hStereoDft_loc->hConfig, input_Fs,
301 878 : hStereoDft_loc->hItd->hybrid_itd_max );
302 :
303 878 : *hStereoDft = hStereoDft_loc;
304 :
305 878 : return IVAS_ERR_OK;
306 : }
307 :
308 :
309 : /*-------------------------------------------------------------------------
310 : * stereo_dft_enc_open()
311 : *
312 : * Initialize DFT stereo handle
313 : *------------------------------------------------------------------------*/
314 :
315 878 : 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 878 : hStereoDft->N = (int16_t) ( STEREO_DFT_HOP_MAX_ENC * input_Fs / 48000 );
326 878 : assert( ( ( input_Fs / FRAMES_PER_SEC ) / hStereoDft->N ) == 1 );
327 :
328 : /*Init. DFT sizes*/
329 878 : hStereoDft->NFFT = (int16_t) ( STEREO_DFT_N_MAX_ENC * input_Fs / 48000 );
330 878 : hStereoDft->dft_ovl = (int16_t) ( STEREO_DFT_OVL_MAX * input_Fs / 48000 );
331 878 : mdct_window_sine( win, input_Fs, hStereoDft->dft_ovl, FULL_OVERLAP, IVAS_CPE_DFT );
332 :
333 878 : hStereoDft->win_ana_energy = (float) hStereoDft->N - hStereoDft->dft_ovl;
334 878 : hStereoDft->win_ana_energy += 2 * sum_f( win, hStereoDft->dft_ovl );
335 878 : hStereoDft->win_ana_energy = hStereoDft->win_ana_energy / hStereoDft->NFFT;
336 878 : set_f( hStereoDft->output_mem_dmx_32k, 0, STEREO_DFT_OVL_32k );
337 :
338 878 : hStereoDft->dft_zp = (int16_t) ( STEREO_DFT_ZP_MAX_ENC * input_Fs / 48000 );
339 :
340 878 : hStereoDft->dft_trigo_8k = dft_trigo_32k;
341 878 : hStereoDft->dft_trigo_12k8 = dft_trigo_12k8;
342 878 : hStereoDft->dft_trigo_16k = dft_trigo_32k;
343 878 : hStereoDft->dft_trigo_32k = dft_trigo_32k;
344 :
345 878 : hStereoDft->win_ana_8k = win_ana_8k;
346 878 : hStereoDft->win_ana_12k8 = win_ana_12k8;
347 878 : hStereoDft->win_ana_16k = win_ana_16k;
348 878 : hStereoDft->win_ana_32k = win_ana_32k;
349 :
350 878 : hStereoDft->win_8k = win_syn_8k;
351 878 : hStereoDft->win_12k8 = win_syn_12k8;
352 878 : hStereoDft->win_16k = win_syn_16k;
353 878 : hStereoDft->win_32k = win_syn_32k;
354 :
355 878 : if ( input_Fs == 16000 )
356 : {
357 23 : hStereoDft->dft_trigo = dft_trigo_32k;
358 23 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
359 23 : hStereoDft->win_ana = win_ana_16k;
360 23 : hStereoDft->win = win_syn_16k;
361 : }
362 855 : else if ( input_Fs == 32000 )
363 : {
364 165 : hStereoDft->dft_trigo = dft_trigo_32k;
365 165 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
366 165 : hStereoDft->win_ana = win_ana_32k;
367 165 : hStereoDft->win = win_syn_32k;
368 : }
369 : else
370 : {
371 690 : assert( input_Fs == 48000 );
372 690 : hStereoDft->dft_trigo = dft_trigo_48k;
373 690 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_48k_STEP;
374 690 : hStereoDft->win_ana = win_ana_48k;
375 690 : hStereoDft->win = win_syn_48k;
376 : }
377 :
378 878 : hStereoDft->win_mdct_8k = win_mdct_8k;
379 :
380 : /*I/O Buffers*/
381 878 : set_zero( hStereoDft->output_mem_dmx, STEREO_DFT_OVL_MAX );
382 878 : set_zero( hStereoDft->output_mem_dmx_12k8, STEREO_DFT_OVL_12k8 );
383 878 : set_zero( hStereoDft->output_mem_dmx_16k, STEREO_DFT_OVL_16k );
384 878 : set_zero( hStereoDft->output_mem_dmx_16k_shb, STEREO_DFT_OVL_16k );
385 878 : 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 878 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[max_bwidth] / L_FRAME48k;
389 878 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
390 878 : hStereoDft->nbands_dmx = stereo_dft_band_config( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
391 :
392 : /*Set configuration*/
393 878 : set_s( hStereoDft->band_res, hStereoDft->hConfig->band_res, STEREO_DFT_ENC_DFT_NB );
394 878 : 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 878 : set_s( hStereoDft->res_cod_mode, hStereoDft->hConfig->res_cod_mode, STEREO_DFT_ENC_DFT_NB );
402 : }
403 878 : set_s( hStereoDft->res_pred_mode, hStereoDft->hConfig->res_pred_mode, STEREO_DFT_ENC_DFT_NB );
404 :
405 : /* reset DFT stereo memories */
406 878 : stereo_dft_enc_reset( hStereoDft );
407 :
408 878 : return;
409 : }
410 :
411 : /*-------------------------------------------------------------------------
412 : * stereo_dft_enc_reset()
413 : *
414 : * Reset DFT stereo memories
415 : *------------------------------------------------------------------------*/
416 :
417 1657 : 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 1657 : set_zero( hStereoDft->side_gain, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
424 1657 : set_s( hStereoDft->side_gain_index_EC, 15, STEREO_DFT_BAND_MAX );
425 1657 : set_s( hStereoDft->side_gain_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
426 1657 : set_s( hStereoDft->side_gain_index_ECprevious, 15, STEREO_DFT_BAND_MAX );
427 1657 : hStereoDft->side_gain_counter = 0;
428 1657 : hStereoDft->side_gain_bitdiff_lp = STEREO_DFT_BITDIFF_INIT;
429 1657 : set_zero( hStereoDft->gipd, STEREO_DFT_ENC_DFT_NB );
430 1657 : set_zero( hStereoDft->dot_prod_real_smooth, STEREO_DFT_BAND_MAX );
431 1657 : set_zero( hStereoDft->dot_prod_img_smooth, STEREO_DFT_BAND_MAX );
432 23198 : for ( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
433 : {
434 21541 : set_zero( hStereoDft->ipd_buf[i], STEREO_DFT_IPD_BUF_LEN );
435 : }
436 1657 : hStereoDft->prev_gipd = 0.f;
437 1657 : hStereoDft->gipd_index = 0;
438 1657 : set_zero( hStereoDft->res_pred_gain, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
439 1657 : set_s( hStereoDft->res_pred_index_EC, 0, STEREO_DFT_BAND_MAX );
440 1657 : set_s( hStereoDft->res_pred_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
441 1657 : set_s( hStereoDft->res_pred_index_ECprevious, 0, STEREO_DFT_BAND_MAX );
442 1657 : hStereoDft->res_pred_counter = 0;
443 1657 : set_zero( hStereoDft->past_nrgL, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
444 1657 : set_zero( hStereoDft->past_nrgR, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
445 1657 : set_zero( hStereoDft->past_dot_prod_real, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
446 1657 : set_zero( hStereoDft->past_dot_prod_imag, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
447 1657 : hStereoDft->nrg_past_pos = 0;
448 :
449 1657 : hStereoDft->res_dmx_ratio_lt = 1.0f;
450 1657 : hStereoDft->hangover_cnt0 = 0;
451 1657 : hStereoDft->hangover_cnt1 = 0;
452 1657 : hStereoDft->dmx_res_all_prev = EPSILON;
453 1657 : hStereoDft->last_res_cod_mode_modify_flag = 0;
454 1657 : hStereoDft->res_cod_sw_flag = 0;
455 1657 : hStereoDft->switch_fade_factor = 0.5f;
456 1657 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1] = STEREO_DFT_RES_COD_1kHz;
457 23198 : for ( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
458 : {
459 21541 : hStereoDft->res_cod_NRG_M[i] = 0;
460 21541 : hStereoDft->res_cod_NRG_S[i] = 0;
461 : }
462 1657 : hStereoDft->old_snr = 0.f;
463 :
464 :
465 1657 : hStereoDft->reverb_flag = 0;
466 1657 : set_zero( hStereoDft->pre_sub_nrg_DMX, STEREO_DFT_BAND_MAX );
467 1657 : hStereoDft->diff_l_h_sm = 0.0f;
468 1657 : hStereoDft->diff_r_h_sm = 0.0f;
469 1657 : hStereoDft->prev_fac2 = 1.0f;
470 :
471 1657 : set_zero( hStereoDft->res_pred_gain_f, STEREO_DFT_BAND_MAX );
472 :
473 : /*misc*/
474 1657 : hStereoDft->no_ipd_flag = 1; /* Initialization of the no IPD variables */
475 1657 : hStereoDft->prev_no_ipd_flag = 1;
476 1657 : hStereoDft->no_ipd_cnt = 0;
477 1657 : hStereoDft->no_ipd_cnt1 = 0;
478 1657 : hStereoDft->attackPresent = 0;
479 1657 : hStereoDft->wasTransient = 0;
480 1657 : hStereoDft->gainIPD_sm = 1.f;
481 :
482 :
483 1657 : hStereoDft->voicing_lt = 0;
484 :
485 1657 : hStereoDft->flip_sign = 1;
486 :
487 1657 : hStereoDft->sfm = 0.f;
488 1657 : hStereoDft->sum_dot_prod_real = 0.f;
489 1657 : hStereoDft->sum_dot_prod_img = 0.f;
490 :
491 : /*Coherence*/
492 1657 : set_f( hStereoDft->xspec_smooth, 1.0f, STEREO_DFT_N_32k_ENC );
493 1657 : set_f( hStereoDft->Spd_L_smooth, 1.0f, STEREO_DFT_N_32k_ENC / 2 );
494 1657 : set_f( hStereoDft->Spd_R_smooth, 1.0f, STEREO_DFT_N_32k_ENC / 2 );
495 :
496 1657 : hStereoDft->currentNumUpdates = 0;
497 1657 : hStereoDft->expectedNumUpdates = FIXED_SID_RATE;
498 1657 : hStereoDft->resetFrames = 0;
499 1657 : hStereoDft->sid_gipd = 0;
500 1657 : hStereoDft->prev_sid_gipd = 0;
501 1657 : hStereoDft->prev_sid_no_ipd_flag = 1;
502 :
503 1657 : hStereoDft->coh_fade_counter = 0;
504 :
505 : /* Xtalk classifier */
506 1657 : hStereoDft->hItd->prev_m1 = 0;
507 1657 : hStereoDft->hItd->prev_m2 = 0;
508 1657 : hStereoDft->hItd->prev_itd1 = 0;
509 1657 : hStereoDft->hItd->prev_itd2 = 0;
510 :
511 1657 : hStereoDft->first_frm_flag = 1;
512 :
513 : #ifdef DEBUG_MODE_DFT
514 : hStereoDft->verbose = 1;
515 : #endif
516 :
517 1657 : stereo_enc_itd_init( hStereoDft->hItd );
518 :
519 1657 : return;
520 : }
521 :
522 :
523 : /*-------------------------------------------------------------------------
524 : * stereo_enc_itd_init()
525 : *
526 : * initialize ITD struct
527 : *------------------------------------------------------------------------*/
528 :
529 1808 : void stereo_enc_itd_init(
530 : ITD_DATA_HANDLE hItd /* i/o: encoder ITD handle */
531 : )
532 : {
533 1808 : hItd->prev_itd = 0;
534 1808 : set_zero( hItd->itd, STEREO_DFT_ENC_DFT_NB );
535 1808 : set_zero( hItd->deltaItd, STEREO_DFT_ENC_DFT_NB );
536 1808 : set_s( hItd->td_itd, 0, STEREO_DFT_ENC_DFT_NB );
537 1808 : set_s( hItd->td_itd_32k, 0, STEREO_DFT_ENC_DFT_NB );
538 1808 : set_s( hItd->itd_index, 0, STEREO_DFT_ENC_DFT_NB );
539 1808 : set_zero( hItd->xcorr_smooth, STEREO_DFT_N_32k_ENC );
540 1808 : hItd->lp_phat_peak = 0.f;
541 1808 : hItd->itd_hangover = 0;
542 1808 : hItd->itd_cnt = 0;
543 1808 : hItd->prev_sum_nrg_L_lb = 0.f;
544 1808 : set_zero( hItd->prev_xcorr_lb, STEREO_DFT_XCORR_LB_MAX );
545 1808 : set_f( hItd->E_band_n, (float) ITD_VAD_E_BAND_N_INIT, STEREO_DFT_ITD_VAD_BAND_NUM );
546 1808 : hItd->vad_frm_cnt = 0;
547 1808 : hItd->pre_vad = 0;
548 1808 : hItd->itd_nonzero_cnt = 0;
549 1808 : set_zero( hItd->acorr_L, STEREO_DFT_BAND_MAX );
550 1808 : set_zero( hItd->acorr_R, STEREO_DFT_BAND_MAX );
551 1808 : hItd->cohSNR = 15.f;
552 1808 : hItd->itd_thres = 0.f;
553 1808 : hItd->valid_itd_cnt = 0;
554 :
555 1808 : hItd->detected_itd_flag = 0;
556 1808 : hItd->itd_tracking = 0;
557 1808 : hItd->prev_max = 0.f;
558 1808 : hItd->prev_index = 0;
559 1808 : hItd->prev_avg_max = 0.f;
560 1808 : hItd->currFlatness = 0.f;
561 :
562 : /* Xtalk classifier */
563 1808 : hItd->prev_m1 = 0;
564 1808 : hItd->prev_m2 = 0;
565 1808 : hItd->prev_itd1 = 0;
566 1808 : hItd->prev_itd2 = 0;
567 :
568 1808 : hItd->hybrid_itd_max = 0;
569 1808 : return;
570 : }
571 :
572 :
573 : /*--------------------------------------------------------------------------
574 : * stereo_dft_enc_update()
575 : *
576 : * Update DFT stereo memories for new frame
577 : *--------------------------------------------------------------------------*/
578 :
579 59679 : 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 59679 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
589 :
590 : /* Update the parameters and serial */
591 835506 : for ( i = 0; i < k_offset * STEREO_DFT_BAND_MAX; i++ )
592 : {
593 775827 : hStereoDft->side_gain[i] = hStereoDft->side_gain[STEREO_DFT_BAND_MAX + i];
594 775827 : hStereoDft->res_pred_gain[i] = hStereoDft->res_pred_gain[STEREO_DFT_BAND_MAX + i];
595 : }
596 :
597 119358 : for ( i = 0; i < k_offset; i++ )
598 : {
599 59679 : hStereoDft->gipd[i] = hStereoDft->gipd[i + 1];
600 : }
601 :
602 : /*Update configurations*/
603 119358 : for ( i = 0; i < k_offset; i++ )
604 : {
605 59679 : hStereoDft->band_res[i] = hStereoDft->band_res[i + 1];
606 59679 : hStereoDft->hItd->itd[i] = hStereoDft->hItd->itd[i + 1];
607 59679 : hStereoDft->res_cod_mode[i] = hStereoDft->res_cod_mode[i + 1];
608 59679 : hStereoDft->res_pred_mode[i] = hStereoDft->res_pred_mode[i + 1];
609 : }
610 :
611 : /*Set new configurations*/
612 59679 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
613 :
614 59679 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode && hStereoDft->NFFT == STEREO_DFT_N_16k_ENC )
615 : {
616 2878 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->ada_wb_res_cod_mode;
617 : }
618 : else
619 : {
620 56801 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->res_cod_mode;
621 : }
622 59679 : hStereoDft->res_pred_mode[k_offset] = hStereoDft->hConfig->res_pred_mode;
623 :
624 59679 : hStereoDft->last_res_cod_mode_modify_flag = hStereoDft->res_cod_sw_flag;
625 59679 : 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 59679 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[max_bwidth] / L_FRAME48k;
629 :
630 59679 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
631 59679 : hStereoDft->nbands_dmx = stereo_dft_band_config( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
632 :
633 : /*Compute main parameters*/
634 59679 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
635 59679 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
636 59679 : 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 59679 : hStereoDft->res_cod_line_max = 8 * ( hStereoDft->res_cod_line_max / 8 );
638 59679 : 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 59679 : return;
692 : }
693 :
694 :
695 : /*-------------------------------------------------------------------------
696 : * stereo_dft_enc_destroy()
697 : *
698 : * destroy DFT stereo handle
699 : *-------------------------------------------------------------------------*/
700 :
701 878 : void stereo_dft_enc_destroy(
702 : STEREO_DFT_ENC_DATA_HANDLE *hStereoDft /* i/o: encoder DFT stereo handle */
703 : )
704 : {
705 878 : if ( ( *hStereoDft )->hConfig != NULL )
706 : {
707 878 : free( ( *hStereoDft )->hConfig );
708 878 : ( *hStereoDft )->hConfig = NULL;
709 : }
710 :
711 878 : if ( ( *hStereoDft )->hItd != NULL )
712 : {
713 878 : free( ( *hStereoDft )->hItd );
714 878 : ( *hStereoDft )->hItd = NULL;
715 : }
716 :
717 878 : free( *hStereoDft );
718 878 : *hStereoDft = NULL;
719 :
720 878 : return;
721 : }
722 :
723 :
724 : /*-------------------------------------------------------------------------
725 : * stereo_dft_enc_analyze()
726 : *
727 : * DFT analysis on a 20ms frame
728 : *-------------------------------------------------------------------------*/
729 :
730 74369 : 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 74369 : push_wmops( "DFT_analysis" );
752 :
753 : /*-----------------------------------------------------------------*
754 : * Initialization
755 : *-----------------------------------------------------------------*/
756 :
757 223107 : for ( n = 0; n < n_channels; n++ )
758 : {
759 148738 : input[n] = sts[n]->input;
760 148738 : 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 74369 : pDFT_L = DFT[0];
786 74369 : pDFT_R = DFT[1];
787 :
788 74369 : if ( hStereoDft != NULL )
789 : {
790 59679 : N = hStereoDft->N;
791 59679 : NFFT = hStereoDft->NFFT;
792 59679 : dft_zp = hStereoDft->dft_zp;
793 59679 : dft_ovl = hStereoDft->dft_ovl;
794 59679 : offset = -dft_ovl;
795 59679 : pWin = hStereoDft->win_ana;
796 59679 : pTrigo = hStereoDft->dft_trigo;
797 59679 : trigo_step = hStereoDft->dft_trigo_step;
798 : }
799 : else
800 : {
801 14690 : N = hStereoMdct->hDft_ana->N;
802 14690 : NFFT = hStereoMdct->hDft_ana->NFFT;
803 14690 : dft_zp = hStereoMdct->hDft_ana->dft_zp;
804 14690 : dft_ovl = hStereoMdct->hDft_ana->dft_ovl;
805 14690 : offset = -dft_ovl;
806 14690 : pWin = hStereoMdct->hDft_ana->win_ana;
807 14690 : pTrigo = hStereoMdct->hDft_ana->dft_trigo;
808 14690 : trigo_step = hStereoMdct->hDft_ana->dft_trigo_step;
809 : }
810 :
811 25097569 : for ( i = 0; i < NFFT / 4; i++ )
812 : {
813 25023200 : trigo_enc[i] = pTrigo[i * trigo_step];
814 25023200 : trigo_enc[NFFT / 2 - i] = pTrigo[i * trigo_step];
815 : }
816 74369 : trigo_enc[NFFT / 4] = pTrigo[NFFT / 4 * trigo_step];
817 :
818 : /*Forwards FFT: L and R*/
819 : /*zero padding*/
820 14149919 : for ( i = 0; i < dft_zp; i++ )
821 : {
822 14075550 : pDFT_L[i] = 0.f;
823 14075550 : pDFT_L[NFFT - 1 - i] = 0.f;
824 :
825 14075550 : pDFT_R[i] = 0.f;
826 14075550 : pDFT_R[NFFT - 1 - i] = 0.f;
827 : }
828 :
829 : /*overlapping parts*/
830 21969669 : for ( i = 0; i < dft_ovl; i++ )
831 : {
832 21895300 : pDFT_L[dft_zp + i] = mem[0][i] * pWin[i];
833 21895300 : pDFT_L[dft_zp + N + dft_ovl - 1 - i] = input[0][offset + N + dft_ovl - 1 - i] * pWin[i];
834 :
835 21895300 : pDFT_R[dft_zp + i] = mem[1][i] * pWin[i];
836 21895300 : 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 28225469 : for ( i = 0; i < N - dft_ovl; i++ )
841 : {
842 28151100 : pDFT_L[dft_zp + dft_ovl + i] = input[0][offset + dft_ovl + i];
843 :
844 28151100 : pDFT_R[dft_zp + dft_ovl + i] = input[1][offset + dft_ovl + i];
845 : }
846 :
847 74369 : rfft( pDFT_L, trigo_enc, NFFT, -1 );
848 74369 : rfft( pDFT_R, trigo_enc, NFFT, -1 );
849 :
850 : /* update pointers to overlap memory */
851 223107 : for ( n = 0; n < n_channels; n++ )
852 : {
853 148738 : 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 74369 : if ( hStereoDft != NULL && hStereoDft->hConfig->hybrid_itd_flag && hStereoDft->hItd->td_itd[STEREO_DFT_OFFSET] )
860 : #endif
861 : {
862 36405 : for ( n = 0; n < n_channels; n++ )
863 : {
864 24270 : mvr2r( hStereoDft->input_mem_itd[n], input_mem[n], dft_ovl );
865 : }
866 : }
867 : else
868 : {
869 186702 : for ( n = 0; n < n_channels; n++ )
870 : {
871 124468 : mvr2r( input[n] + input_frame - dft_ovl, input_mem[n], dft_ovl );
872 : }
873 : }
874 :
875 74369 : pop_wmops();
876 74369 : return;
877 : }
878 :
879 :
880 : /*-------------------------------------------------------------------------
881 : * stereo_dft_enc_synthesize()
882 : *
883 : * Inverse DFT on a 20ms frame
884 : *-------------------------------------------------------------------------*/
885 :
886 224732 : 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 224732 : if ( L_frame > 0 )
912 : {
913 35725 : assert( ( output_sampling_rate == 16000 ) && "High-band generation only possible at 16kHz!" );
914 : }
915 224732 : nrg = 0.f;
916 :
917 224732 : hStereoDft->icbweRefEner = 0;
918 224732 : hStereoDft->lbEner = 0;
919 :
920 224732 : if ( chan == 0 )
921 : {
922 204777 : pDFT_in = hStereoDft->DFT[0];
923 : }
924 : else
925 : {
926 19955 : pDFT_in = hStereoDft->DFT[1];
927 : }
928 :
929 224732 : if ( output_sampling_rate == input_Fs )
930 : {
931 59679 : assert( chan == 0 );
932 :
933 59679 : NFFT = hStereoDft->NFFT;
934 59679 : fac = 1.f;
935 59679 : N = hStereoDft->N;
936 59679 : ovl = hStereoDft->dft_ovl;
937 59679 : zp = hStereoDft->dft_zp;
938 59679 : trigo = hStereoDft->dft_trigo;
939 59679 : trigo_step = hStereoDft->dft_trigo_step;
940 59679 : if ( L_frame > 0 )
941 : {
942 0 : mem = hStereoDft->output_mem_dmx_16k_shb;
943 : }
944 : else
945 : {
946 59679 : mem = hStereoDft->output_mem_dmx;
947 : }
948 59679 : win = hStereoDft->win;
949 59679 : win_ana = hStereoDft->win_ana;
950 :
951 59679 : push_wmops( "DFT_synth_fs" );
952 : }
953 165053 : else if ( output_sampling_rate == INT_FS_12k8 )
954 : {
955 59679 : assert( chan == 0 );
956 :
957 59679 : NFFT = STEREO_DFT_N_12k8_ENC;
958 59679 : N = STEREO_DFT_HOP_12k8_ENC;
959 59679 : zp = STEREO_DFT_ZP_12k8_ENC;
960 59679 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
961 59679 : ovl = STEREO_DFT_OVL_12k8;
962 59679 : trigo = hStereoDft->dft_trigo_12k8;
963 59679 : trigo_step = STEREO_DFT_TRIGO_SRATE_12k8_STEP;
964 59679 : mem = hStereoDft->output_mem_dmx_12k8;
965 59679 : win = hStereoDft->win_12k8;
966 59679 : win_ana = hStereoDft->win_ana_12k8;
967 :
968 59679 : push_wmops( "DFT_synth_12k8" );
969 : }
970 105374 : else if ( output_sampling_rate == 16000 )
971 : {
972 83849 : assert( chan == 0 );
973 :
974 83849 : NFFT = STEREO_DFT_N_16k_ENC;
975 83849 : N = STEREO_DFT_HOP_16k_ENC;
976 83849 : zp = STEREO_DFT_ZP_16k_ENC;
977 83849 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
978 83849 : ovl = STEREO_DFT_OVL_16k;
979 83849 : trigo = hStereoDft->dft_trigo_16k;
980 83849 : trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
981 83849 : if ( L_frame > 0 )
982 : {
983 35725 : mem = hStereoDft->output_mem_dmx_16k_shb;
984 :
985 35725 : push_wmops( "DFT_synth_16k_shb" );
986 : }
987 : else
988 : {
989 48124 : mem = hStereoDft->output_mem_dmx_16k;
990 :
991 48124 : push_wmops( "DFT_synth_16k" );
992 : }
993 83849 : win = hStereoDft->win_16k;
994 83849 : win_ana = hStereoDft->win_ana_16k;
995 : }
996 21525 : else if ( output_sampling_rate == 32000 )
997 : {
998 1570 : assert( chan == 0 );
999 :
1000 1570 : NFFT = STEREO_DFT_N_32k_ENC;
1001 1570 : N = STEREO_DFT_HOP_32k_ENC;
1002 1570 : zp = STEREO_DFT_ZP_32k_ENC;
1003 1570 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1004 1570 : ovl = STEREO_DFT_OVL_32k;
1005 1570 : trigo = hStereoDft->dft_trigo_32k;
1006 1570 : trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
1007 1570 : mem = hStereoDft->output_mem_dmx_32k;
1008 1570 : win = hStereoDft->win_32k;
1009 1570 : win_ana = hStereoDft->win_ana_32k;
1010 :
1011 1570 : push_wmops( "DFT_synth_32k" );
1012 : }
1013 19955 : else if ( output_sampling_rate == 8000 )
1014 : {
1015 19955 : assert( chan == 1 );
1016 :
1017 19955 : NFFT = STEREO_DFT_N_8k_ENC;
1018 19955 : N = STEREO_DFT_HOP_8k_ENC;
1019 19955 : zp = STEREO_DFT_ZP_8k_ENC;
1020 19955 : fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1021 19955 : ovl = STEREO_DFT_OVL_8k;
1022 19955 : trigo = hStereoDft->dft_trigo_8k;
1023 19955 : trigo_step = STEREO_DFT_TRIGO_SRATE_8k_STEP;
1024 19955 : mem = hStereoDft->output_mem_res_8k;
1025 19955 : win = hStereoDft->win_8k;
1026 19955 : win_ana = hStereoDft->win_ana_8k;
1027 :
1028 19955 : 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 224732 : offset = 0;
1046 :
1047 43967884 : for ( i = 0; i < NFFT / 4; i++ )
1048 : {
1049 43743152 : trigo_enc[i] = trigo[i * trigo_step];
1050 43743152 : trigo_enc[NFFT / 2 - i] = trigo[i * trigo_step];
1051 : }
1052 224732 : trigo_enc[NFFT / 4] = trigo[NFFT / 4 * trigo_step];
1053 :
1054 : /*-----------------------------------------------------------------*
1055 : * Synthesizing & resampling
1056 : *-----------------------------------------------------------------*/
1057 :
1058 224732 : offset = -ovl;
1059 :
1060 224732 : if ( L_frame == L_FRAME || L_frame == L_FRAME16k )
1061 : {
1062 11467725 : 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 11432000 : hStereoDft->icbweRefEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1065 : }
1066 11467725 : for ( i = 0; i < (int16_t) ( 200 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ); i++ )
1067 : {
1068 11432000 : hStereoDft->lbEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1069 : }
1070 35725 : hStereoDft->icbweRefEner *= fac;
1071 35725 : hStereoDft->lbEner *= fac;
1072 : }
1073 :
1074 : /*Flip?*/
1075 224732 : if ( L_frame == L_FRAME )
1076 : {
1077 : /* 6 to 14 kHz SHB target signal*/
1078 17261 : j = 2;
1079 17261 : set_zero( tmp, STEREO_DFT_N_MAX_ENC );
1080 17261 : sign = hStereoDft->flip_sign;
1081 :
1082 5558042 : 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 5540781 : tmp[j++] = sign * pDFT_in[2 * i] * fac;
1086 5540781 : tmp[j++] = -sign * pDFT_in[2 * i + 1] * fac;
1087 : }
1088 17261 : hStereoDft->flip_sign = -sign;
1089 :
1090 2796282 : for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1091 : {
1092 2779021 : nrg += tmp[2 * i] * tmp[2 * i];
1093 2779021 : nrg += tmp[2 * i + 1] * tmp[2 * i + 1];
1094 : }
1095 : }
1096 207471 : else if ( L_frame == L_FRAME16k )
1097 : {
1098 : /* 7.5 - 15.5 kHz SHB target signal*/
1099 18464 : j = 2;
1100 18464 : set_zero( tmp, STEREO_DFT_N_MAX_ENC );
1101 5926944 : 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 5908480 : tmp[j++] = pDFT_in[2 * i] * fac;
1104 5908480 : tmp[j++] = -1.f * pDFT_in[2 * i + 1] * fac;
1105 : }
1106 :
1107 2991168 : for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1108 : {
1109 2972704 : nrg += tmp[2 * i] * tmp[2 * i];
1110 2972704 : nrg += tmp[2 * i + 1] * tmp[2 * i + 1];
1111 : }
1112 : }
1113 189007 : else if ( fac != 1.f )
1114 : {
1115 : /*Copy and scale*/
1116 129328 : tmp[0] = pDFT_in[0] * fac;
1117 129328 : tmp[1] = 0.f;
1118 69620880 : for ( i = 2; i < NFFT; i++ )
1119 : {
1120 69491552 : tmp[i] = pDFT_in[i] * fac;
1121 : }
1122 :
1123 129328 : if ( fac < 1.f )
1124 : {
1125 129328 : tmp[1] = 0.f; /*Nyquist is set to 0*/
1126 129328 : tmp[0] = 0.f; /*DC is set to 0*/
1127 : }
1128 : }
1129 : else
1130 : {
1131 82418079 : for ( i = 0; i < NFFT; i++ )
1132 : {
1133 82358400 : tmp[i] = pDFT_in[i];
1134 : }
1135 : }
1136 :
1137 : /*Reconstruct */
1138 : /*IFFT*/
1139 224732 : rfft( tmp, trigo_enc, NFFT, +1 );
1140 :
1141 38499990 : for ( i = 0; i < ovl; i++ )
1142 : {
1143 38275258 : output[offset + i] = mem[i] + tmp[zp + i] * win[i];
1144 38275258 : mem[i] = tmp[zp + N + i] * win[ovl - 1 - i];
1145 : }
1146 :
1147 : /*Middle->Copy*/
1148 49435778 : for ( i = 0; i < N - ovl; i++ )
1149 : {
1150 49211046 : output[offset + ovl + i] = tmp[zp + ovl + i];
1151 : }
1152 :
1153 : /*-----------------------------------------------------------------*
1154 : * Lookahead: redress signal
1155 : *-----------------------------------------------------------------*/
1156 :
1157 38499990 : for ( i = 0; i < ovl; i++ )
1158 : {
1159 38275258 : float ifft_deviation = tmp[zp + N + ovl];
1160 38275258 : 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 224732 : pop_wmops();
1225 224732 : 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 59679 : 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 59679 : input_Fs = input_frame * FRAMES_PER_SEC;
1274 :
1275 59679 : hStereoDft = hCPE->hStereoDft;
1276 :
1277 59679 : wL = 0; /* avoid compilation warning */
1278 59679 : wR = 0; /* avoid compilation warning */
1279 :
1280 : /* Initialization */
1281 59679 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
1282 :
1283 59679 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
1284 59679 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->res_cod_mode[k_offset]];
1285 59679 : 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 59679 : hStereoDft->res_cod_line_max = 8 * ( hStereoDft->res_cod_line_max / 8 );
1287 :
1288 59679 : 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 59679 : hStereoDft->voicing_lt = 0.75f * hStereoDft->voicing_lt + 0.25f * hCPE->hCoreCoder[0]->voicing[0];
1295 59679 : 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 59679 : fac_att = 1.0f;
1303 :
1304 59679 : pDFT_L = hStereoDft->DFT[0];
1305 59679 : pDFT_R = hStereoDft->DFT[1];
1306 :
1307 : #ifdef DEBUG_MODE_DFT
1308 : if ( hStereoDft->hConfig->itd_mode )
1309 : #endif
1310 : {
1311 59679 : 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 59679 : if ( hCPE->element_mode == IVAS_CPE_MDCT )
1313 : {
1314 0 : return;
1315 : }
1316 :
1317 59679 : if ( hStereoDft->hItd->deltaItd[k_offset] != 0 && hStereoDft->hConfig->dmx_active )
1318 : {
1319 : /*time shift channels*/
1320 22967 : alpha = -2.0f * EVS_PI * hStereoDft->hItd->deltaItd[k_offset] / hStereoDft->NFFT;
1321 22967 : c = 1.f; /*cos(0)*/
1322 22967 : s = 0.f; /*sin(0)*/
1323 22967 : c1 = cosf( alpha );
1324 22967 : s1 = sinf( alpha );
1325 :
1326 22967 : if ( alpha >= 0 )
1327 : {
1328 11085760 : for ( i = 1; i < hStereoDft->NFFT / 2; i++ )
1329 : {
1330 11070369 : tmp = s * c1 + c * s1;
1331 11070369 : c = c * c1 - s * s1;
1332 11070369 : s = tmp;
1333 :
1334 : /*time shift of L*/
1335 11070369 : tmp = pDFT_L[2 * i] * c - pDFT_L[2 * i + 1] * s;
1336 11070369 : pDFT_L[2 * i + 1] = pDFT_L[2 * i] * s + pDFT_L[2 * i + 1] * c;
1337 11070369 : pDFT_L[2 * i] = tmp;
1338 : }
1339 : }
1340 : else
1341 : {
1342 4977920 : for ( i = 1; i < hStereoDft->NFFT / 2; i++ )
1343 : {
1344 4970344 : tmp = s * c1 + c * s1;
1345 4970344 : c = c * c1 - s * s1;
1346 4970344 : s = tmp;
1347 :
1348 : /*time shift of R*/
1349 4970344 : tmp = pDFT_R[2 * i] * c + pDFT_R[2 * i + 1] * s;
1350 4970344 : pDFT_R[2 * i + 1] = -pDFT_R[2 * i] * s + pDFT_R[2 * i + 1] * c;
1351 4970344 : pDFT_R[2 * i] = tmp;
1352 : }
1353 : }
1354 :
1355 22967 : if ( fabsf( hStereoDft->hItd->deltaItd[k_offset] * 32000.f / input_Fs ) > 80.0f )
1356 : {
1357 5948 : fac_att = min( 1.0f, max( 0.2f, 2.6f - 0.02f * fabsf( hStereoDft->hItd->deltaItd[1] ) * 32000.f / input_Fs ) );
1358 : }
1359 : }
1360 :
1361 : /* compute remaining binwise energies for FB mode (ITD function only computes energies up to 16 kHz) */
1362 6741919 : for ( i = STEREO_DFT_N_32k_ENC / 2; i < hStereoDft->NFFT / 2; i++ )
1363 : {
1364 6682240 : bin_nrgL[i] = pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
1365 6682240 : bin_nrgR[i] = pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
1366 : }
1367 : }
1368 : #ifdef DEBUG_MODE_DFT
1369 : else
1370 : {
1371 : /* no ITD computation, get binwise energies here */
1372 :
1373 : for ( i = 0; i < hStereoDft->NFFT / 2; i++ )
1374 : {
1375 : bin_nrgL[i] = pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
1376 : bin_nrgR[i] = pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
1377 : }
1378 : }
1379 : #endif
1380 :
1381 : /* DFT stereo parameters */
1382 59679 : 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 );
1383 :
1384 59679 : if ( vad_flag_dtx[0] == 0 )
1385 : {
1386 10467 : if ( hCPE->hStereoCng->cng_counter == 0 && !hCPE->hStereoCng->first_SID_after_TD )
1387 : {
1388 135 : hStereoDft->sid_gipd = hStereoDft->prev_sid_gipd;
1389 135 : hStereoDft->no_ipd_flag = hStereoDft->prev_sid_no_ipd_flag;
1390 : }
1391 :
1392 10467 : if ( hCPE->hStereoCng->cng_counter > ITD_SID_PREV_FRAMES )
1393 : {
1394 9334 : hStereoDft->prev_sid_gipd = hStereoDft->sid_gipd;
1395 9334 : hStereoDft->prev_sid_no_ipd_flag = hStereoDft->no_ipd_flag;
1396 : }
1397 : }
1398 :
1399 : /*----------------------------------------------------------------*
1400 : * UNCLR classifier (detection of uncorrelated L and R channels)
1401 : *----------------------------------------------------------------*/
1402 :
1403 59679 : unclr_classifier_dft( hCPE );
1404 :
1405 : /*------------------------------------------------------------------*
1406 : * Channel mapping: computation of DMX and RES
1407 : *-----------------------------------------------------------------*/
1408 : #ifdef DEBUG_MODE_DFT
1409 : {
1410 : int16_t tmp_dbg = (int16_t) ( 100 * fac_att );
1411 : dbgwrite( &tmp_dbg, sizeof( int16_t ), 1, 1, "./res/stereo_dft_enc_facAtt.pcm" );
1412 : }
1413 : #endif
1414 :
1415 59679 : res_nrg_all_curr = EPSILON;
1416 59679 : dmx_nrg_all_curr = EPSILON;
1417 :
1418 59679 : pDFT_DMX = DFT_DMX;
1419 59679 : pDFT_RES = DFT_RES;
1420 59679 : pNrgL = bin_nrgL;
1421 59679 : pNrgR = bin_nrgR;
1422 :
1423 59679 : set_zero( pDFT_DMX, STEREO_DFT_N_MAX_ENC );
1424 59679 : set_zero( pDFT_RES, STEREO_DFT_N_8k_ENC );
1425 :
1426 59679 : pgIpd = hStereoDft->gipd + k_offset;
1427 59679 : pSideGain = hStereoDft->side_gain + k_offset * STEREO_DFT_BAND_MAX;
1428 :
1429 59679 : if ( hStereoDft->hConfig->dmx_active )
1430 : {
1431 : /*Active DMX*/
1432 59679 : alpha = 0; /* to avoid compilation warning */
1433 59679 : g = 1.f;
1434 :
1435 : /*Apply active DMX*/
1436 59679 : pDFT_DMX[0] = 0.f;
1437 59679 : pDFT_RES[0] = 0.f;
1438 760946 : for ( b = 0; b < hStereoDft->nbands_dmx; b++ )
1439 : {
1440 701267 : g = pSideGain[b];
1441 :
1442 701267 : if ( pgIpd[0] != 0.f )
1443 : {
1444 226758 : c = cosf( pgIpd[0] );
1445 226758 : s = sinf( pgIpd[0] );
1446 12284568 : for ( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
1447 : {
1448 : /*rotate L*/
1449 12057810 : tmp = pDFT_L[2 * i] * c + pDFT_L[2 * i + 1] * s;
1450 12057810 : pDFT_L[2 * i + 1] = pDFT_L[2 * i + 1] * c - pDFT_L[2 * i] * s;
1451 12057810 : pDFT_L[2 * i] = tmp;
1452 : }
1453 : }
1454 :
1455 701267 : if ( b < hStereoDft->res_cod_band_max && vad_flag_dtx[0] )
1456 : {
1457 : #ifdef DEBUGGING
1458 : assert( hStereoDft->nbands == hStereoDft->nbands_dmx && "Don't use coarser stereo parameter resolution for residual coding bitrates!" );
1459 : #endif
1460 : #ifdef DEBUG_MODE_DFT
1461 : dbgwrite( &g, sizeof( float ), 1, 1, "./res/stereo_dft_enc_g.pcm" );
1462 : dbgwrite( &alpha, sizeof( float ), 1, 1, "./res/stereo_dft_enc_alpha.pcm" );
1463 : #endif
1464 :
1465 : /*Get the previous frame energy*/
1466 86820 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode )
1467 : {
1468 : /*Calculate the energy of RES and DMX*/
1469 : /* 90% of old frame ... */
1470 86820 : dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.9f;
1471 86820 : res_nrg_all_curr += hStereoDft->res_cod_NRG_S[b] * 0.9f;
1472 : }
1473 86820 : hStereoDft->res_cod_NRG_M[b] = EPSILON;
1474 86820 : hStereoDft->res_cod_NRG_S[b] = EPSILON;
1475 :
1476 798744 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1477 : {
1478 711924 : pDFT_DMX[2 * i] = ( pDFT_L[2 * i] + pDFT_R[2 * i] ) * 0.5f;
1479 711924 : pDFT_DMX[2 * i + 1] = ( pDFT_L[2 * i + 1] + pDFT_R[2 * i + 1] ) * 0.5f;
1480 :
1481 711924 : pDFT_RES[2 * i] = ( pDFT_L[2 * i] - pDFT_R[2 * i] ) * 0.5f;
1482 711924 : pDFT_RES[2 * i + 1] = ( pDFT_L[2 * i + 1] - pDFT_R[2 * i + 1] ) * 0.5f;
1483 :
1484 : /*Prediction of RES with DMX*/
1485 711924 : pDFT_RES[2 * i] = pDFT_RES[2 * i] - g * pDFT_DMX[2 * i];
1486 711924 : pDFT_RES[2 * i + 1] = pDFT_RES[2 * i + 1] - g * pDFT_DMX[2 * i + 1];
1487 :
1488 711924 : pDFT_RES[2 * i] *= fac_att;
1489 711924 : pDFT_RES[2 * i + 1] *= fac_att;
1490 :
1491 : /*Energy of the DMX and RES*/
1492 711924 : hStereoDft->res_cod_NRG_M[b] += pDFT_DMX[2 * i] * pDFT_DMX[2 * i] + pDFT_DMX[2 * i + 1] * pDFT_DMX[2 * i + 1];
1493 711924 : hStereoDft->res_cod_NRG_S[b] += pDFT_RES[2 * i] * pDFT_RES[2 * i] + pDFT_RES[2 * i + 1] * pDFT_RES[2 * i + 1];
1494 : }
1495 :
1496 86820 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode )
1497 : {
1498 : /*Calculate the energy of RES and DMX*/
1499 : /* ... + 10% of current frame. */
1500 86820 : dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.1f;
1501 86820 : res_nrg_all_curr += hStereoDft->res_cod_NRG_S[b] * 0.1f;
1502 : }
1503 : }
1504 : else
1505 : {
1506 : int16_t upper_border;
1507 : int16_t triple_bin;
1508 : float frac_dot_prod; /* fraction of dot product according to energy ratio of current bins and whole band */
1509 : float Sr, Si;
1510 : float comb_nrgL, comb_nrgR;
1511 :
1512 614447 : upper_border = min( STEREO_DFT_DMX_CROSSOVER, hStereoDft->band_limits_dmx[b + 1] );
1513 :
1514 614447 : triple_bin = 0;
1515 614447 : if ( upper_border > hStereoDft->band_limits_dmx[b] && ( upper_border - hStereoDft->band_limits_dmx[b] ) % 2 )
1516 : {
1517 : /* if odd number of bins in band, combine last 3 bins */
1518 186624 : triple_bin = 1;
1519 186624 : upper_border -= 3;
1520 : }
1521 :
1522 6244844 : for ( i = hStereoDft->band_limits_dmx[b]; i < upper_border; i += 2 )
1523 : {
1524 5630397 : comb_nrgL = pNrgL[i] + pNrgL[i + 1];
1525 5630397 : comb_nrgR = pNrgR[i] + pNrgR[i + 1];
1526 5630397 : 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] );
1527 5630397 : 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] );
1528 :
1529 5630397 : sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
1530 5630397 : frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
1531 5630397 : wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
1532 :
1533 5630397 : wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
1534 :
1535 : /*DMX Mapping*/
1536 5630397 : pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
1537 5630397 : pDFT_DMX[2 * i + 1] = ( wL * pDFT_L[2 * i + 1] + wR * pDFT_R[2 * i + 1] ) * INV_SQRT_2;
1538 5630397 : pDFT_DMX[2 * i + 2] = ( wL * pDFT_L[2 * i + 2] + wR * pDFT_R[2 * i + 2] ) * INV_SQRT_2;
1539 5630397 : pDFT_DMX[2 * i + 3] = ( wL * pDFT_L[2 * i + 3] + wR * pDFT_R[2 * i + 3] ) * INV_SQRT_2;
1540 : }
1541 :
1542 614447 : if ( triple_bin )
1543 : {
1544 186624 : comb_nrgL = comb_nrgR = 0.f;
1545 186624 : Sr = Si = 0.f;
1546 746496 : for ( j = i; j < i + 3; j++ )
1547 : {
1548 559872 : comb_nrgL += pNrgL[j];
1549 559872 : comb_nrgR += pNrgR[j];
1550 559872 : Sr += ( pDFT_L[2 * j] + pDFT_R[2 * j] ) * ( pDFT_L[2 * j] + pDFT_R[2 * j] );
1551 559872 : Si += ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] ) * ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] );
1552 : }
1553 :
1554 186624 : sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
1555 186624 : frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
1556 186624 : wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
1557 186624 : wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
1558 :
1559 746496 : for ( j = i; j < i + 3; j++ )
1560 : {
1561 559872 : pDFT_DMX[2 * j] = ( wL * pDFT_L[2 * j] + wR * pDFT_R[2 * j] ) * INV_SQRT_2;
1562 559872 : pDFT_DMX[2 * j + 1] = ( wL * pDFT_L[2 * j + 1] + wR * pDFT_R[2 * j + 1] ) * INV_SQRT_2;
1563 : }
1564 186624 : i += 3;
1565 : }
1566 :
1567 614447 : if ( i < hStereoDft->band_limits_dmx[b + 1] )
1568 : {
1569 164156 : sum_nrg_L2 = EPSILON;
1570 164156 : sum_nrg_R2 = EPSILON;
1571 164156 : dot_prod_real2 = EPSILON;
1572 25156207 : for ( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
1573 : {
1574 24992051 : sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
1575 24992051 : sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
1576 24992051 : dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
1577 : }
1578 :
1579 164156 : sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
1580 164156 : sum_abs = sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) + EPSILON;
1581 164156 : wR = sqrtf( 0.5f * ( sum_nrg_L2 + sum_nrg_R2 ) + dot_prod_nrg_ratio[b] ) / sum_abs;
1582 164156 : wL = wR + sqrtf( 2.f ) * ( 1.f - sqrtf( sum_nrg_Mid ) / sum_abs );
1583 : }
1584 :
1585 25606498 : for ( ; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
1586 : {
1587 : /*DMX Mapping*/
1588 24992051 : pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
1589 24992051 : pDFT_DMX[2 * i + 1] = ( wL * pDFT_L[2 * i + 1] + wR * pDFT_R[2 * i + 1] ) * INV_SQRT_2;
1590 : }
1591 : }
1592 : }
1593 :
1594 3654559 : for ( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->NFFT / 2; i++ )
1595 : {
1596 3594880 : pDFT_DMX[2 * i] = 0.f;
1597 3594880 : pDFT_DMX[2 * i + 1] = 0.f;
1598 : }
1599 :
1600 : /*Nyquist Freq.*/
1601 59679 : if ( hStereoDft->band_limits_dmx[b] >= hStereoDft->NFFT / 2 )
1602 : {
1603 49484 : pDFT_DMX[1] = ( pDFT_L[1] + pDFT_R[1] ) * 0.5f;
1604 : }
1605 : else
1606 : {
1607 10195 : pDFT_DMX[1] = 0.f;
1608 : }
1609 :
1610 : /* DC component */
1611 59679 : pDFT_DMX[0] = ( pDFT_L[0] + pDFT_R[0] ) * 0.5f;
1612 : }
1613 : else
1614 : {
1615 : #ifndef DEBUG_STEREO_DFT_NOSTEREO
1616 : /*passive DMX*/
1617 0 : assert( hStereoDft->nbands == hStereoDft->nbands_dmx && "Don't use coarser stereo parameter resolution for residual coding bitrates!" );
1618 0 : for ( i = 0; i < hStereoDft->band_limits[hStereoDft->res_cod_band_max]; i++ )
1619 : {
1620 0 : pDFT_DMX[i] = ( pDFT_L[i] + pDFT_R[i] ) * 0.5f;
1621 0 : pDFT_RES[i] = ( pDFT_L[i] - pDFT_R[i] ) * 0.5f;
1622 : }
1623 0 : for ( ; i < hStereoDft->NFFT; i++ )
1624 : {
1625 0 : pDFT_DMX[i] = ( pDFT_L[i] + pDFT_R[i] ) * 0.5f;
1626 : }
1627 : #else
1628 : /*Copy Left channel to DMX and reset residual coding*/
1629 : mvr2r( pDFT_L, DFT_DMX, hStereoDft->NFFT );
1630 : set_zero( pDFT_RES, hStereoDft->NFFT );
1631 :
1632 : /*for( b=0; b<hStereoDft->nbands; b++ )
1633 : {
1634 : if( hStereoDft->res_pred_mode[k+k_offset] && b>= hStereoDft->res_pred_band_min )
1635 : {
1636 : if( (k % hStereoDft->prm_res_enc[k+k_offset]) == (hStereoDft->prm_res_enc[k+k_offset]-1) )
1637 : {
1638 : 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 );
1639 : }
1640 : }
1641 : }*/
1642 : #endif
1643 : }
1644 :
1645 : /*------------------------------------------------------------------*
1646 : * Recalculate RES and DMX
1647 : *-----------------------------------------------------------------*/
1648 :
1649 59679 : if ( hStereoDft->NFFT == STEREO_DFT_N_16k_ENC && hStereoDft->hConfig->ada_wb_res_cod_mode )
1650 : {
1651 2878 : stereo_dft_enc_get_res_cod_mode_flag( hStereoDft, res_nrg_all_curr, dmx_nrg_all_curr, &res_dmx_ratio, &frame_nrg_ratio );
1652 :
1653 2878 : if ( hStereoDft->res_cod_sw_flag )
1654 : {
1655 : int16_t res_cod_band_max;
1656 :
1657 60 : res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->hConfig->ada_wb_res_cod_mode];
1658 :
1659 : /* Recalculate RES and DMX */
1660 360 : for ( b = 0; b < res_cod_band_max; b++ )
1661 : {
1662 300 : sum_nrg_L2 = EPSILON;
1663 300 : sum_nrg_R2 = EPSILON;
1664 300 : dot_prod_real2 = EPSILON;
1665 2760 : for ( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
1666 : {
1667 2460 : sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
1668 2460 : sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
1669 2460 : dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
1670 : }
1671 :
1672 300 : sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
1673 300 : wL = 0.5f * max( sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) - sqrtf( sum_nrg_Mid ), 0 ) * inv_sqrt( sum_nrg_L2 + EPSILON );
1674 300 : wS = 1;
1675 :
1676 300 : if ( hStereoDft->res_cod_sw_flag )
1677 : {
1678 300 : wL *= ( 1 - hStereoDft->switch_fade_factor );
1679 300 : wS = hStereoDft->switch_fade_factor;
1680 : }
1681 :
1682 2760 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1683 : {
1684 : /*DMX Recalculation*/
1685 2460 : DFT_DMX[2 * i] += wL * pDFT_L[2 * i];
1686 2460 : DFT_DMX[2 * i + 1] += wL * pDFT_L[2 * i + 1];
1687 :
1688 : /*RES Recalculation*/
1689 2460 : DFT_RES[2 * i] *= wS;
1690 2460 : DFT_RES[2 * i + 1] *= wS;
1691 : }
1692 : }
1693 : }
1694 : }
1695 :
1696 59679 : if ( input_Fs >= 32000 )
1697 : {
1698 48124 : stereo_dft_enc_calculate_nrg_for_icbwe( hStereoDft, DFT_DMX, input_Fs );
1699 : }
1700 :
1701 59679 : mvr2r( DFT_DMX, hStereoDft->DFT[0], STEREO_DFT_N_MAX_ENC );
1702 59679 : mvr2r( DFT_RES, hStereoDft->DFT[1], STEREO_DFT_N_8k_ENC );
1703 59679 : set_zero( hStereoDft->DFT[1] + STEREO_DFT_N_8k_ENC, STEREO_DFT_N_MAX_ENC - STEREO_DFT_N_8k_ENC );
1704 :
1705 59679 : return;
1706 : }
1707 :
1708 :
1709 : /*-------------------------------------------------------------------------
1710 : * stereo_dft_enc_get_res_cod_mode_flag()
1711 : *
1712 : * Get the residual signal coding flag
1713 : *-------------------------------------------------------------------------*/
1714 :
1715 2878 : static void stereo_dft_enc_get_res_cod_mode_flag(
1716 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
1717 : const float res_nrg_all_curr,
1718 : const float dmx_nrg_all_curr,
1719 : float *res_dmx_ratio,
1720 : float *frame_nrg_ratio )
1721 : {
1722 : int16_t b, k_offset;
1723 : float dmx_res_all, g;
1724 : int16_t fast_update_flag;
1725 : int16_t prev_res_cod_mode_flag, res_cod_mode_flag;
1726 :
1727 2878 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
1728 :
1729 : /*Calculate energy ratio between residual signal and downmix signal */
1730 2878 : *res_dmx_ratio = 0;
1731 :
1732 17268 : for ( b = 0; b < hStereoDft->res_cod_band_max; b++ )
1733 : {
1734 14390 : g = fabsf( hStereoDft->side_gain[(k_offset) *STEREO_DFT_BAND_MAX + b] );
1735 14390 : *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 );
1736 : }
1737 2878 : *res_dmx_ratio = check_bounds( *res_dmx_ratio, 0, 1 ); /*should always be satisfied*/
1738 :
1739 : /*Calculate the total energy of RES and DMX*/
1740 2878 : dmx_res_all = res_nrg_all_curr + dmx_nrg_all_curr;
1741 :
1742 : /*Calculate the energy ratio of the inter-frame */
1743 2878 : *frame_nrg_ratio = dmx_res_all / hStereoDft->dmx_res_all_prev;
1744 2878 : *frame_nrg_ratio = min( 5.0f, max( 0.2f, *frame_nrg_ratio ) );
1745 :
1746 : /* Get fast update flag */
1747 2878 : fast_update_flag = 0;
1748 2878 : if ( ( *frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f ) || ( *frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f ) )
1749 : {
1750 63 : fast_update_flag = 1;
1751 : }
1752 :
1753 : /* Calculate long term energy ratio between residual signal and downmix signal */
1754 2878 : if ( fast_update_flag )
1755 : {
1756 63 : hStereoDft->res_dmx_ratio_lt = *res_dmx_ratio * 0.2f + hStereoDft->res_dmx_ratio_lt * 0.8f;
1757 : }
1758 : else
1759 : {
1760 2815 : hStereoDft->res_dmx_ratio_lt = *res_dmx_ratio * 0.05f + hStereoDft->res_dmx_ratio_lt * 0.95f;
1761 : }
1762 :
1763 : /*Get the residual signal coding initial flag */
1764 2878 : if ( hStereoDft->res_dmx_ratio_lt > 0.01f )
1765 : {
1766 2878 : res_cod_mode_flag = 1;
1767 : }
1768 : else
1769 : {
1770 0 : res_cod_mode_flag = 0;
1771 : }
1772 :
1773 : /* Get the residual signal coding flag */
1774 2878 : if ( hStereoDft->first_frm_flag )
1775 : {
1776 7 : prev_res_cod_mode_flag = res_cod_mode_flag;
1777 7 : hStereoDft->first_frm_flag = 0;
1778 : }
1779 : else
1780 : {
1781 2871 : prev_res_cod_mode_flag = hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1];
1782 : }
1783 2878 : if ( res_cod_mode_flag != prev_res_cod_mode_flag )
1784 : {
1785 354 : if ( prev_res_cod_mode_flag == 1 )
1786 : {
1787 0 : if ( hStereoDft->hangover_cnt0 < 5 && hStereoDft->last_res_cod_mode_modify_flag == 0 && fast_update_flag == 0 )
1788 : {
1789 0 : res_cod_mode_flag = prev_res_cod_mode_flag;
1790 0 : hStereoDft->hangover_cnt0++;
1791 : }
1792 : else
1793 : {
1794 : /* reset hangover */
1795 0 : hStereoDft->hangover_cnt0 = 0;
1796 : }
1797 : }
1798 : else
1799 : {
1800 354 : if ( *frame_nrg_ratio > 2.5f || *frame_nrg_ratio < 0.21f )
1801 : {
1802 : /* reset hangover */
1803 7 : hStereoDft->hangover_cnt1 = 0;
1804 : }
1805 : else
1806 : {
1807 347 : if ( hStereoDft->hangover_cnt1 < 5 )
1808 : {
1809 294 : res_cod_mode_flag = prev_res_cod_mode_flag;
1810 294 : hStereoDft->hangover_cnt1++;
1811 : }
1812 : else
1813 : {
1814 : /* reset hangover */
1815 53 : hStereoDft->hangover_cnt1 = 0;
1816 : }
1817 : }
1818 : }
1819 : }
1820 :
1821 : /* handle switching frames */
1822 2878 : if ( res_cod_mode_flag != prev_res_cod_mode_flag && hStereoDft->last_res_cod_mode_modify_flag == 0 )
1823 : {
1824 60 : hStereoDft->res_cod_sw_flag = 1;
1825 :
1826 : /* Update switch_fade_factor */
1827 60 : if ( *frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f )
1828 : {
1829 0 : hStereoDft->switch_fade_factor = 0.75f;
1830 : }
1831 60 : else if ( *frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f )
1832 : {
1833 0 : hStereoDft->switch_fade_factor = 0.25f;
1834 : }
1835 : else
1836 : {
1837 60 : hStereoDft->switch_fade_factor = 0.5f;
1838 : }
1839 :
1840 60 : if ( res_cod_mode_flag == 0 )
1841 : {
1842 0 : res_cod_mode_flag = 1;
1843 : }
1844 : }
1845 :
1846 : /*update previous frame's total energy of RES and DMX */
1847 2878 : hStereoDft->dmx_res_all_prev = dmx_res_all;
1848 :
1849 : /* update residual coding mode */
1850 2878 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] = res_cod_mode_flag;
1851 2878 : if ( !hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
1852 : {
1853 294 : hStereoDft->res_cod_band_max = 0;
1854 294 : hStereoDft->res_cod_line_max = 0;
1855 : }
1856 :
1857 : /*Update residual signal memory when switching from not coding residual signal to coding it*/
1858 2878 : if ( prev_res_cod_mode_flag == 0 && res_cod_mode_flag == 1 )
1859 : {
1860 60 : set_zero( hStereoDft->output_mem_res_8k, STEREO_DFT_OVL_8k );
1861 : }
1862 :
1863 : #ifdef DEBUG_MODE_DFT
1864 : /* look at res_nrg_all value */
1865 : {
1866 : static FILE *ResNrgAll_FILE = NULL;
1867 :
1868 : if ( ResNrgAll_FILE == NULL )
1869 : ResNrgAll_FILE = fopen( "./res/stereo_dft_res_nrg.txt", "w" );
1870 : fprintf( ResNrgAll_FILE, "%f\t\t%d\n", hStereoDft->res_dmx_ratio_lt, hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] );
1871 : dbgwrite( &hStereoDft->res_cod_mode[STEREO_DFT_OFFSET], sizeof( int16_t ), 1, 320, "./res/stereo_dft_res_cod_mode_flag.pcm" );
1872 : }
1873 : #endif
1874 2878 : return;
1875 : }
1876 :
1877 :
1878 : /*-------------------------------------------------------------------------
1879 : * stereo_dft_enc_res()
1880 : *
1881 : * Code the residual signal
1882 : *-------------------------------------------------------------------------*/
1883 :
1884 59149 : void stereo_dft_enc_res(
1885 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
1886 : const float *input_8k, /* i : input buffer sampled at 8kHz*/
1887 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
1888 : int16_t *nb_bits, /* o : number of bits written */
1889 : const int16_t max_bits )
1890 : {
1891 : int16_t i, b;
1892 : RangeUniEncState range_uni_enc_state;
1893 : ECSQ_instance ecsq_inst;
1894 : float MDCT_RES[L_FRAME8k];
1895 : float win[L_FRAME8k + STEREO_DFT_OVL_8k];
1896 : int16_t global_gain_index;
1897 : int16_t total_bit_count;
1898 : float max_snr;
1899 : float panning_gain, panning_gain_min;
1900 : float res_cod_gain[10];
1901 : float in_phase_ratio;
1902 : #ifdef DEBUG_MODE_DFT
1903 : float MDCT_RES_dec[L_FRAME8k] = { 0 };
1904 : #endif
1905 59149 : assert( hStereoDft->res_cod_line_max <= L_FRAME8k );
1906 :
1907 59149 : if ( hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
1908 : {
1909 : /* Windowing */
1910 : /* overlapping parts */
1911 : /*input_8k-=STEREO_DFT_OVL_8k;*/
1912 1235258 : for ( i = 0; i < STEREO_DFT_OVL_8k; i++ )
1913 : {
1914 1217860 : win[i] = input_8k[i] * hStereoDft->win_mdct_8k[i];
1915 1217860 : win[L_FRAME8k + i] = input_8k[L_FRAME8k + i] * hStereoDft->win_mdct_8k[STEREO_DFT_OVL_8k - 1 - i];
1916 : }
1917 : /* middle part */
1918 1583218 : for ( ; i < L_FRAME8k; i++ )
1919 : {
1920 1565820 : win[i] = input_8k[i];
1921 : }
1922 :
1923 : /* MDCT analysis */
1924 17398 : TCX_MDCT( win, MDCT_RES, STEREO_DFT_OVL_8k, L_FRAME8k - STEREO_DFT_OVL_8k, STEREO_DFT_OVL_8k, IVAS_CPE_DFT );
1925 :
1926 : /*Compute the DMX to RES for each band*/
1927 17398 : max_snr = 0.f; /*minimum gain for residual coding -> no coding*/
1928 104388 : for ( b = 0; b < hStereoDft->res_cod_band_max; b++ )
1929 : {
1930 : /*Get side gain information and it is we*/
1931 86990 : panning_gain = hStereoDft->side_gain[STEREO_DFT_OFFSET * STEREO_DFT_BAND_MAX + b];
1932 86990 : panning_gain_min = 1.f - fabsf( panning_gain );
1933 :
1934 86990 : 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 );
1935 86990 : in_phase_ratio = check_bounds( in_phase_ratio, 0, 1 );
1936 86990 : res_cod_gain[b] = in_phase_ratio * STEREO_DFT_RES_COD_SNR_MIN + ( 1 - in_phase_ratio ) * STEREO_DFT_RES_COD_SNR_MAX;
1937 :
1938 : /*get the maximum through bands*/
1939 86990 : if ( res_cod_gain[b] > max_snr )
1940 : {
1941 44328 : max_snr = res_cod_gain[b];
1942 : }
1943 : }
1944 :
1945 : /*Smooth max_snr because of several perturbations in computation*/
1946 : #ifdef DEBUG_MODE_DFT
1947 : dbgwrite( &max_snr, sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_target_snr0.dat" );
1948 : #endif
1949 17398 : hStereoDft->old_snr = 0.2f * max_snr + 0.8f * hStereoDft->old_snr;
1950 17398 : max_snr = hStereoDft->old_snr;
1951 :
1952 17398 : if ( max_snr < STEREO_DFT_RES_COD_SNR_MIN )
1953 : {
1954 536 : max_snr = STEREO_DFT_RES_COD_SNR_MIN;
1955 : }
1956 : #ifdef DEBUG_MODE_DFT
1957 : dbgwrite( &max_snr, sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_target_snr.dat" );
1958 : #endif
1959 :
1960 17398 : push_wmops( "residual_encode" );
1961 : /* residual encoding */
1962 17398 : ECSQ_init_instance( &ecsq_inst, 0 /*dummy index*/, &range_uni_enc_state );
1963 17398 : rc_uni_enc_init( &range_uni_enc_state );
1964 :
1965 17398 : ecsq_inst.bit_count_estimate = 0;
1966 17398 : ecsq_inst.config_index = 2 * hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] - 1;
1967 :
1968 : /* 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 */
1969 : #ifndef DEBUG_MODE_DFT
1970 17398 : 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 );
1971 : #else
1972 : 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 );
1973 : #endif
1974 17398 : if ( global_gain_index != ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO )
1975 : {
1976 16923 : total_bit_count = rc_uni_enc_finish( &range_uni_enc_state );
1977 :
1978 16923 : if ( total_bit_count <= max_bits - *nb_bits - STEREO_DFT_RES_GLOBAL_GAIN_BITS )
1979 : {
1980 : int16_t idx;
1981 : uint8_t *byte_buffer;
1982 :
1983 : /* Global gain */
1984 16923 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
1985 16923 : ( *nb_bits ) += STEREO_DFT_RES_GLOBAL_GAIN_BITS;
1986 : #ifdef DEBUG_MODE_DFT
1987 : fprintf( pF, "Gain: %d ", global_gain_index );
1988 : #endif
1989 :
1990 : /* Push arithmetic coded bits */
1991 16923 : byte_buffer = range_uni_enc_state.byte_buffer;
1992 304994 : for ( idx = 0; idx < ( total_bit_count >> 3 ); ++idx )
1993 : {
1994 288071 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, byte_buffer[idx], 8 );
1995 : }
1996 16923 : if ( ( total_bit_count & 7 ) != 0 )
1997 : {
1998 : /* move the last 1 to 7 bits from the MSB position of the last byte to the LSB postion */
1999 14722 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, byte_buffer[idx] >> ( 8 - ( total_bit_count & 7 ) ), total_bit_count & 7 );
2000 : }
2001 16923 : ( *nb_bits ) += total_bit_count;
2002 : #ifdef DEBUG_MODE_DFT
2003 : fprintf( pF, "%d (max: %d)\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS + total_bit_count, max_bits );
2004 : #endif
2005 : }
2006 : else
2007 : {
2008 : /* Global gain -> 127*/
2009 0 : global_gain_index = ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO;
2010 0 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2011 0 : ( *nb_bits ) += STEREO_DFT_RES_GLOBAL_GAIN_BITS;
2012 : #ifdef DEBUG_MODE_DFT
2013 : fprintf( pF, "Gain: %d ", global_gain_index );
2014 : fprintf( pF, "%d (max: %d)\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS, max_bits );
2015 : #endif
2016 : }
2017 : }
2018 : else
2019 : {
2020 : /* Global gain -> 127*/
2021 475 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2022 475 : ( *nb_bits ) += STEREO_DFT_RES_GLOBAL_GAIN_BITS;
2023 : #ifdef DEBUG_MODE_DFT
2024 : fprintf( pF, "Gain: %d ", global_gain_index );
2025 : fprintf( pF, "%d (max: %d)\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS, max_bits );
2026 : #endif
2027 : }
2028 : #ifdef DEBUG_MODE_DFT
2029 : {
2030 : static FILE *resCodingSNR = NULL;
2031 : if ( resCodingSNR == NULL )
2032 : resCodingSNR = fopen( "./res/resCodingSNR.txt", "w" );
2033 : fprintf( resCodingSNR, "%d\t%d\t%f\n", STEREO_DFT_RES_GLOBAL_GAIN_BITS + total_bit_count, max_bits, max_snr );
2034 : }
2035 : #endif
2036 :
2037 17398 : pop_wmops();
2038 : #ifdef DEBUG_MODE_DFT
2039 : {
2040 : int16_t tmp[1024];
2041 : static float mem_win[STEREO_DFT_OVL_8k];
2042 : float global_gain;
2043 : int16_t input_frame = L_FRAME8k;
2044 : float res_cod_error, res_cod_nrg, res_cod_snr;
2045 :
2046 : for ( i = 0; i < input_frame; i++ )
2047 : {
2048 : tmp[i] = (int16_t) ( input_8k[i] + 0.5f );
2049 : }
2050 : dbgwrite( &tmp, sizeof( int16_t ), input_frame, 1, "./res/stereo_dft_enc_res_original.pcm" );
2051 :
2052 : if ( global_gain_index != ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO )
2053 : {
2054 : global_gain = ECSQ_dequantize_gain( global_gain_index );
2055 : }
2056 : else
2057 : {
2058 : global_gain = 0.f;
2059 : }
2060 : dbgwrite( &global_gain, sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_gain.dat" );
2061 :
2062 : tmp[0] = total_bit_count;
2063 : dbgwrite( &tmp, sizeof( int16_t ), 1, 1, "./res/stereo_dft_res_cod_bits.dat" );
2064 :
2065 : dbgwrite( &( hStereoDft->res_cod_line_max ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_res_cod_line.dat" );
2066 : dbgwrite( &( hStereoDft->res_cod_band_max ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_res_cod_band_max.dat" );
2067 : dbgwrite( &( hStereoDft->res_cod_NRG_M ), sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_dmx_nrg.dat" );
2068 : dbgwrite( &( hStereoDft->res_cod_NRG_S ), sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_res_nrg.dat" );
2069 :
2070 : /*Compute coding SNR*/
2071 : res_cod_nrg = EPSILON;
2072 : res_cod_error = EPSILON;
2073 : for ( i = 0; i < hStereoDft->res_cod_line_max; i++ )
2074 : {
2075 : res_cod_nrg += MDCT_RES[i] * MDCT_RES[i];
2076 : res_cod_error += ( MDCT_RES[i] - MDCT_RES_dec[i] ) * ( MDCT_RES[i] - MDCT_RES_dec[i] );
2077 : }
2078 :
2079 : res_cod_snr = 10.f * log10f( res_cod_nrg / res_cod_error );
2080 : dbgwrite( &( res_cod_snr ), sizeof( float ), 1, 1, "./res/stereo_dft_res_cod_snr.dat" );
2081 :
2082 : /*IMDCT*/
2083 : TCX_MDCT_Inverse( MDCT_RES_dec, win, STEREO_DFT_OVL_8k, L_FRAME8k - STEREO_DFT_OVL_8k, STEREO_DFT_OVL_8k, IVAS_CPE_DFT );
2084 :
2085 : /*OLA*/
2086 : /*overlapping parts*/
2087 : for ( i = 0; i < STEREO_DFT_OVL_8k; i++ )
2088 : {
2089 : win[i] = mem_win[i] + win[i] * hStereoDft->win_mdct_8k[i];
2090 : mem_win[i] = win[input_frame + i] * hStereoDft->win_mdct_8k[STEREO_DFT_OVL_8k - 1 - i];
2091 : }
2092 : for ( i = 0; i < input_frame; i++ )
2093 : {
2094 : tmp[i] = (int16_t) ( win[i] + 0.5f );
2095 : }
2096 : dbgwrite( tmp, sizeof( int16_t ), input_frame, 1, "./res/stereo_dft_enc_res_decoded.pcm" );
2097 : }
2098 : #endif
2099 : }
2100 :
2101 : #ifdef DEBUG_MODE_DFT
2102 : {
2103 : int16_t input_frame = L_FRAME8k;
2104 : static FILE *bits_consumed = NULL;
2105 : if ( bits_consumed == NULL )
2106 : bits_consumed = fopen( "./res/stereo_dft_bits_consumed.txt", "w" );
2107 :
2108 : fprintf( bits_consumed, " %d \n", *nb_bits );
2109 : dbgwrite( nb_bits, sizeof( int16_t ), 1, input_frame, "./res/stereo_dft_bits_consumed.dat" );
2110 : }
2111 : #endif
2112 :
2113 59149 : return;
2114 : }
2115 :
2116 :
2117 : /*-------------------------------------------------------------------------
2118 : * stereo_dft_enc_write_BS()
2119 : *
2120 : * Write DFT stereo bitstream
2121 : *-------------------------------------------------------------------------*/
2122 :
2123 53511 : void stereo_dft_enc_write_BS(
2124 : CPE_ENC_HANDLE hCPE, /* i/o: CPE encoder structure */
2125 : int16_t *nb_bits /* o : number of bits written */
2126 : )
2127 : {
2128 : int16_t b, k_offset, itd, nb, nbands, sp_aud_decision0;
2129 : int16_t NFFT_inner, nbands_full;
2130 : int16_t no_GR_ord;
2131 : int16_t encoded_ind_GR[STEREO_DFT_BAND_MAX];
2132 : int16_t encoded_ind_pred_GR[STEREO_DFT_BAND_MAX];
2133 : int16_t sid_gIpd_index, sid_itd;
2134 : float cohBand[STEREO_DFT_BAND_MAX / 2];
2135 : BSTR_ENC_HANDLE hBstr;
2136 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft;
2137 : int32_t core_brate;
2138 : #ifdef DEBUG_MODE_DFT
2139 : static FILE *ITD_values = NULL, *side_gain_values = NULL, *RPG_values = NULL;
2140 : static FILE *cum_freq_enc = NULL;
2141 :
2142 : if ( pF == NULL )
2143 : pF = fopen( "./res/stereo_dft_enc_ind.txt", "w" );
2144 : if ( ITD_values == NULL )
2145 : ITD_values = fopen( "./res/itd_indicies_enc.txt", "w" );
2146 : if ( side_gain_values == NULL )
2147 : side_gain_values = fopen( "./res/side_gain_indicies_enc.txt", "w" );
2148 : if ( RPG_values == NULL )
2149 : RPG_values = fopen( "./res/rpg_indicies_enc.txt", "w" );
2150 : if ( cum_freq_enc == NULL )
2151 : cum_freq_enc = fopen( "./res/cum_freq_enc.txt", "w" );
2152 : #endif
2153 :
2154 : /*------------------------------------------------------------------*
2155 : * Initialization
2156 : *-----------------------------------------------------------------*/
2157 :
2158 53511 : hStereoDft = hCPE->hStereoDft;
2159 53511 : hBstr = hCPE->hMetaData;
2160 53511 : core_brate = hCPE->hCoreCoder[0]->core_brate;
2161 :
2162 53511 : sp_aud_decision0 = 0;
2163 53511 : if ( hCPE->last_element_mode == IVAS_CPE_DFT )
2164 : {
2165 53152 : sp_aud_decision0 = hCPE->hCoreCoder[0]->sp_aud_decision0;
2166 : }
2167 :
2168 53511 : *nb_bits = 0;
2169 53511 : k_offset = STEREO_DFT_OFFSET;
2170 :
2171 53511 : nbands_full = hStereoDft->nbands;
2172 :
2173 53511 : if ( core_brate == FRAME_NO_DATA || core_brate == SID_2k40 )
2174 : {
2175 9821 : NFFT_inner = min( STEREO_DFT_N_32k_ENC, STEREO_DFT_N_MAX_ENC * inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth] / L_FRAME48k );
2176 9821 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
2177 9821 : hStereoDft->res_pred_mode[k_offset] = 0;
2178 9821 : hStereoDft->res_cod_mode[k_offset] = 0;
2179 : }
2180 : else
2181 : {
2182 43690 : NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth] / L_FRAME48k;
2183 : }
2184 :
2185 : /* set number of bands according to bandwidth after BWD */
2186 53511 : hStereoDft->nbands = stereo_dft_band_config( hStereoDft->band_limits, hStereoDft->band_res[k_offset], NFFT_inner, ENC );
2187 :
2188 53511 : if ( core_brate == FRAME_NO_DATA )
2189 : {
2190 : /* No data frame */
2191 8376 : ( *nb_bits ) = 0;
2192 8376 : return;
2193 : }
2194 :
2195 : /* attack present */
2196 : /* attackPresent not sent in inactive frames, receiver assumes = 0 */
2197 45135 : if ( core_brate != SID_2k40 )
2198 : {
2199 43690 : push_indice( hBstr, IND_STEREO_DFT_ATTACK_PRESENT, hStereoDft->attackPresent, 1 );
2200 43690 : ( *nb_bits )++;
2201 : }
2202 :
2203 : /* Writing coding residual coding mode into bitstream */
2204 45135 : if ( hStereoDft->hConfig->ada_wb_res_cod_mode && hCPE->hCoreCoder[0]->bwidth == WB )
2205 : {
2206 3311 : push_indice( hBstr, IND_STEREO_DFT_RES_COD, hStereoDft->res_cod_mode[k_offset], 1 );
2207 3311 : ( *nb_bits )++;
2208 3311 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
2209 3311 : hStereoDft->res_pred_band_min = max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
2210 : #ifdef DEBUG_MODE_DFT
2211 : fprintf( pF, "res_cod_mode: %d\n", hStereoDft->res_cod_mode[k_offset] );
2212 : #endif
2213 : }
2214 :
2215 : #ifdef DEBUG_MODE_DFT
2216 : 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 );
2217 : fprintf( pF, "stereo Bands: %d\n", hStereoDft->nbands );
2218 :
2219 : dbgwrite( &( hStereoDft->nbands ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_encBS_nbands.dat" );
2220 : dbgwrite( &( hCPE->hCoreCoder[0]->bwidth ), sizeof( int16_t ), 1, 1, "./res/stereo_dft_encBS_bwidth.dat" );
2221 :
2222 : #endif
2223 :
2224 45135 : if ( nbands_full < hStereoDft->nbands )
2225 : {
2226 0 : hStereoDft->reverb_flag = 0;
2227 : }
2228 :
2229 : /* Side gains */
2230 45135 : hStereoDft->side_gain_flag_1 = 0; /* EC coding by default */
2231 45135 : side_gain_mode_decision( hStereoDft, encoded_ind_GR, sp_aud_decision0, hCPE->hCoreCoder[0]->last_core_brate );
2232 :
2233 : /* residual pred. gains */
2234 45135 : hStereoDft->res_pred_flag_1 = 0; /* EC coding by default */
2235 :
2236 45135 : res_pred_gain_mode_decision( hStereoDft, encoded_ind_pred_GR, k_offset, hCPE->hCoreCoder[0]->last_core_brate );
2237 :
2238 : /*------------------------------------------------------------------*
2239 : * write ITD indices
2240 : *-----------------------------------------------------------------*/
2241 :
2242 45135 : if ( core_brate != SID_2k40 )
2243 : {
2244 43690 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, ( hStereoDft->hItd->itd[k_offset] != 0 ), STEREO_DFT_ITD_MODE_NBITS );
2245 43690 : ( *nb_bits ) += STEREO_DFT_ITD_MODE_NBITS; /*ITD mode flag: 1bit*/
2246 : }
2247 :
2248 : #ifdef DEBUG_MODE_DFT
2249 : fprintf( pF, "ITD: %d ", hStereoDft->hConfig->itd_mode && ( hStereoDft->hItd->itd[k_offset] != 0 ) );
2250 : #endif
2251 45135 : if ( core_brate != SID_2k40 )
2252 : {
2253 43690 : if ( hStereoDft->hItd->itd[k_offset] )
2254 : {
2255 26205 : itd = hStereoDft->hItd->itd_index[k_offset];
2256 26205 : if ( itd > 255 )
2257 : {
2258 16783 : itd -= 256;
2259 :
2260 16783 : if ( itd < 20 )
2261 : {
2262 9691 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2263 9691 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2264 9691 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2265 9691 : ( *nb_bits ) += dft_len_itd[itd] + 2;
2266 : }
2267 : else
2268 : {
2269 7092 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 0, 1 ); /* don't use Huffman */
2270 7092 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2271 7092 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS - 1 );
2272 7092 : ( *nb_bits ) += STEREO_DFT_ITD_NBITS + 1;
2273 : }
2274 : }
2275 : else
2276 : {
2277 9422 : if ( itd < 20 )
2278 : {
2279 4058 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2280 4058 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* positive */
2281 4058 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2282 4058 : ( *nb_bits ) += dft_len_itd[itd] + 2;
2283 : }
2284 : else
2285 : {
2286 : /* don't use Huffman and positive*/
2287 5364 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS + 1 );
2288 5364 : ( *nb_bits ) += STEREO_DFT_ITD_NBITS + 1;
2289 : }
2290 : }
2291 : #ifdef DEBUG_MODE_DFT
2292 : fprintf( pF, "ITD: %d ", hStereoDft->hItd->itd_index[k_offset] );
2293 : fprintf( ITD_values, "%d %d ", frame, hStereoDft->hItd->itd_index[k_offset] );
2294 : #endif
2295 : }
2296 : }
2297 :
2298 : #ifdef DEBUG_MODE_DFT_BITS
2299 : fprintf( ITD_bits, "%d ", *nb_bits );
2300 : #endif
2301 :
2302 : /*------------------------------------------------------------------*
2303 : * write Side gain indices
2304 : *-----------------------------------------------------------------*/
2305 :
2306 : /* Side Gain flag 1 */
2307 45135 : nb = 0;
2308 45135 : if ( hStereoDft->side_gain_flag_1 > 0 )
2309 : {
2310 10060 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, 2 );
2311 10060 : nb += 2;
2312 : }
2313 : else
2314 : {
2315 35075 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, STEREO_DFT_FLAG_BITS );
2316 35075 : nb += STEREO_DFT_FLAG_BITS;
2317 : }
2318 :
2319 45135 : no_GR_ord = 3;
2320 :
2321 : #ifdef DEBUG_MODE_DFT
2322 : for ( b = 0; b < hStereoDft->nbands; b++ )
2323 : {
2324 : fprintf( pF, "Side gain: %d ", hStereoDft->side_gain_index_EC[b] );
2325 : fprintf( side_gain_values, " %d ", hStereoDft->side_gain_index_EC[b] );
2326 : }
2327 : #endif
2328 45135 : if ( hStereoDft->side_gain_flag_1 == 0 )
2329 : {
2330 35075 : nb += write_bitstream_adapt_GR( hBstr, IND_STEREO_DFT_SIDEGAINS, encoded_ind_GR, hStereoDft->nbands, hStereoDft->side_gain_flag_2, no_GR_ord );
2331 : }
2332 : else
2333 : {
2334 10060 : if ( hStereoDft->side_gain_flag_1 == 2 )
2335 : {
2336 9001 : nb += write_bitstream_GR( hBstr, IND_STEREO_DFT_SIDEGAINS, hStereoDft->side_gain_index_ECDiff, hStereoDft->nbands, hStereoDft->side_gain_flag_2 - no_GR_ord );
2337 : }
2338 : else
2339 : {
2340 7174 : for ( b = 0; b < hStereoDft->nbands; b++ )
2341 : {
2342 : /*ILD*/
2343 6115 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAINS, hStereoDft->side_gain_index_EC[b], STEREO_DFT_SIDEGAIN_NBITS );
2344 6115 : nb += STEREO_DFT_SIDEGAIN_NBITS;
2345 : }
2346 : }
2347 : }
2348 :
2349 : /* nb bits are used for side gain*/
2350 45135 : ( *nb_bits ) += nb;
2351 : #ifdef DEBUG_MODE_DFT_BITS
2352 : fprintf( SG_bits, "%d ", nb );
2353 : #endif
2354 45135 : nb = 0;
2355 :
2356 45135 : if ( core_brate == SID_2k40 )
2357 : {
2358 1445 : stereo_dft_enc_sid_calc_coh( hStereoDft, hCPE->hStereoCng->prev_cohBand, &hCPE->hStereoCng->td_active, &hCPE->hStereoCng->first_SID, cohBand );
2359 :
2360 1445 : 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 ) )
2361 : {
2362 1445 : if ( hStereoDft->hItd->itd[k_offset] != 0 )
2363 : {
2364 : /* Re-quantize ITD with lower resolution for Stereo CNG */
2365 53 : itd = hStereoDft->hItd->itd_index[k_offset];
2366 53 : if ( itd > 255 )
2367 : {
2368 22 : itd -= 256;
2369 : }
2370 53 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2371 :
2372 53 : sid_itd = itd && 1;
2373 : }
2374 : else
2375 : {
2376 1392 : sid_itd = 0;
2377 : }
2378 :
2379 1445 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, sid_itd, STEREO_DFT_ITD_MODE_NBITS );
2380 1445 : ( *nb_bits ) += STEREO_DFT_ITD_MODE_NBITS; /*ITD mode flag: 1bit*/
2381 :
2382 1445 : if ( sid_itd )
2383 : {
2384 30 : itd = hStereoDft->hItd->itd_index[k_offset];
2385 30 : if ( itd > 255 )
2386 : {
2387 0 : itd -= 256;
2388 0 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2389 :
2390 0 : if ( itd > ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) )
2391 : {
2392 0 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
2393 : }
2394 :
2395 0 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2396 0 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
2397 0 : ( *nb_bits ) += STEREO_DFT_SID_ITD_NBITS + 1;
2398 : }
2399 : else
2400 : {
2401 30 : itd = itd >> STEREO_DFT_SID_ITD_FAC;
2402 :
2403 30 : if ( itd > ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) )
2404 : {
2405 8 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
2406 : }
2407 :
2408 30 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* Positive */
2409 30 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
2410 30 : ( *nb_bits ) += STEREO_DFT_SID_ITD_NBITS + 1;
2411 : }
2412 :
2413 : #ifdef DEBUG_MODE_DFT
2414 : fprintf( pF, "ITD: %d ", hStereoDft->hItd->itd_index[k_offset] );
2415 : fprintf( ITD_values, "%d %d ", frame, hStereoDft->hItd->itd_index[k_offset] );
2416 : #endif
2417 : }
2418 : }
2419 : }
2420 :
2421 : /*------------------------------------------------------------------*
2422 : * write IPD indices
2423 : *-----------------------------------------------------------------*/
2424 :
2425 45135 : if ( core_brate != SID_2k40 )
2426 : {
2427 43690 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
2428 43690 : nb += STEREO_DFT_FLAG_BITS; /*IPD mode flag: 1bit*/
2429 :
2430 43690 : if ( hStereoDft->no_ipd_flag == 0 )
2431 : {
2432 4008 : push_indice( hBstr, IND_STEREO_DFT_GIPD, hStereoDft->gipd_index, STEREO_DFT_GIPD_NBITS );
2433 4008 : nb += STEREO_DFT_GIPD_NBITS;
2434 : }
2435 : }
2436 1445 : else if ( *nb_bits <= ( ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS - STEREO_DFT_FLAG_BITS - STEREO_DFT_SID_GIPD_NBITS ) )
2437 : {
2438 1445 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
2439 1445 : nb += STEREO_DFT_FLAG_BITS; /*IPD mode flag: 1bit*/
2440 :
2441 1445 : if ( hStereoDft->no_ipd_flag == 0 )
2442 : {
2443 275 : stereo_dft_quantize_ipd( &hStereoDft->sid_gipd, &hStereoDft->sid_gipd, &sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
2444 275 : push_indice( hBstr, IND_STEREO_DFT_GIPD, sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
2445 275 : nb += STEREO_DFT_SID_GIPD_NBITS;
2446 : }
2447 : }
2448 :
2449 :
2450 : #ifdef DEBUG_MODE_DFT_BITS
2451 : fprintf( IPD_bits, "%d ", nb );
2452 : #endif
2453 45135 : ( *nb_bits ) += nb;
2454 :
2455 : /*----------------------------------------------------------------*
2456 : * Residual prediction
2457 : *----------------------------------------------------------------*/
2458 :
2459 45135 : nb = 0; /* bits for residual pred gains */
2460 45135 : if ( hStereoDft->res_pred_mode[k_offset] )
2461 : {
2462 43690 : if ( hStereoDft->attackPresent == 0 )
2463 : {
2464 42086 : nbands = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
2465 42086 : b = hStereoDft->res_pred_band_min;
2466 :
2467 : /*Adaptive SF*/
2468 42086 : if ( hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
2469 : {
2470 : /*read flag*/
2471 25298 : push_indice( hBstr, IND_STEREO_DFT_REVERB_MODE, hStereoDft->reverb_flag, STEREO_DFT_REVERB_MODE_NBITS );
2472 25298 : nb += STEREO_DFT_REVERB_MODE_NBITS;
2473 : #ifdef DEBUG_MODE_DFT
2474 : fprintf( RPG_values, " reverb_flag %d ", hStereoDft->reverb_flag );
2475 : #endif
2476 25298 : if ( hStereoDft->reverb_flag )
2477 : {
2478 6717 : nbands -= STEREO_DFT_RES_PRED_BAND_MIN_CONST;
2479 : }
2480 : }
2481 :
2482 : /* Res Pred Gain flag 0 */
2483 42086 : if ( hStereoDft->res_pred_flag_1 > 0 )
2484 : {
2485 33650 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, 2 );
2486 33650 : nb += 2; /*pred gain mode flag: 2 bits*/
2487 : }
2488 : else
2489 : {
2490 8436 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, STEREO_DFT_FLAG_BITS );
2491 8436 : nb += STEREO_DFT_FLAG_BITS; /*pred gain mode flag: 1bit*/
2492 : }
2493 :
2494 42086 : no_GR_ord = 2;
2495 42086 : if ( hStereoDft->res_pred_flag_1 == 0 )
2496 : {
2497 : #ifdef DEBUG_MODE_DFT
2498 : fprintf( RPG_values, "flag: 0" );
2499 : #endif
2500 8436 : if ( encoded_ind_pred_GR[0] == dft_maps_rpg[8 * NO_SYMB_GR_PRED_G] )
2501 : {
2502 1029 : nb += write_GR1( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, encoded_ind_pred_GR, 1 );
2503 : }
2504 : else
2505 : {
2506 7407 : 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 );
2507 : }
2508 : }
2509 : else
2510 : {
2511 33650 : if ( hStereoDft->res_pred_flag_1 == 2 )
2512 : {
2513 : #ifdef DEBUG_MODE_DFT
2514 : fprintf( RPG_values, "flag: 2" );
2515 : #endif
2516 30339 : 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 );
2517 : }
2518 : else
2519 : {
2520 : #ifdef DEBUG_MODE_DFT
2521 : fprintf( RPG_values, "flag: 1" );
2522 : #endif
2523 23233 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2524 : {
2525 19922 : push_indice( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, hStereoDft->res_pred_index_EC[b], STEREO_DFT_RES_GAINS_BITS );
2526 19922 : nb += STEREO_DFT_RES_GAINS_BITS;
2527 : }
2528 : }
2529 : }
2530 :
2531 : #ifdef DEBUG_MODE_DFT
2532 : for ( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
2533 : {
2534 : fprintf( pF, "Res pred values: %d ", hStereoDft->res_pred_index_EC[b] );
2535 : if ( hStereoDft->res_pred_flag_1 == 2 )
2536 : {
2537 : 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 ) );
2538 : }
2539 : else
2540 : {
2541 : fprintf( RPG_values, " %d ", hStereoDft->res_pred_index_EC[b] );
2542 : }
2543 : }
2544 : #endif
2545 : }
2546 : else
2547 : {
2548 1604 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands - hStereoDft->res_pred_band_min );
2549 : }
2550 : }
2551 : else
2552 : {
2553 1445 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands - hStereoDft->res_pred_band_min );
2554 : }
2555 :
2556 45135 : ( *nb_bits ) += nb;
2557 :
2558 45135 : if ( core_brate == SID_2k40 )
2559 : {
2560 1445 : stereo_dft_enc_sid_coh( hBstr, hCPE->hStereoCng->mem_cohBand, hStereoDft->nbands, nb_bits, cohBand );
2561 : }
2562 :
2563 : #ifdef DEBUG_MODE_DFT
2564 : /*fprintf(pF, "Total bits: %d", (*nb_bits));*/
2565 : fprintf( pF, "\n" );
2566 : fprintf( ITD_values, "\n" );
2567 : fprintf( side_gain_values, "\n" );
2568 : fprintf( RPG_values, "\n" );
2569 : #endif
2570 :
2571 45135 : return;
2572 : }
2573 :
2574 :
2575 : /*-------------------------------------------------------------------------
2576 : * stereo_dft_enc_compute_prm()
2577 : *
2578 : * Compute stereo parameters: IPD and SIDE_GAIN
2579 : * SIDE_GAIN: Interchannel Level Difference
2580 : * IPD: Interchannel Phase Difference: angle(L)-angle(R) = acos(<L,R>/(|L|.|R|)) or atan2(Img(L.R*)/Re(L.R*))
2581 : *------------------------------------------------------------------------*/
2582 :
2583 59679 : static void stereo_dft_enc_compute_prm(
2584 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
2585 : float *DFT_L,
2586 : float *DFT_R,
2587 : int16_t k_offset,
2588 : int16_t flag_quant,
2589 : const int16_t sp_aud_decision0,
2590 : const int16_t vad_flag,
2591 : float *bin_nrgL,
2592 : float *bin_nrgR,
2593 : float *dot_prod_nrg_ratio )
2594 : {
2595 : int16_t b, i;
2596 : int16_t b2;
2597 : float *pDFT_L, *pDFT_R;
2598 : float sum_nrg_L, sum_nrg_R;
2599 : float dot_prod_real, dot_prod_img;
2600 : float sum_nrg_L2, sum_nrg_R2;
2601 : float dot_prod_real2, dot_prod_img2;
2602 : float *pPredGain;
2603 : float *pSideGain;
2604 : float sum_energy_L, sum_energy_R;
2605 : float g, c;
2606 : float abs_L_R;
2607 : float abs_L_R2;
2608 : float gain_IPD;
2609 : float sub_nrg_DMX[STEREO_DFT_BAND_MAX];
2610 : float sub_nrg_DMX2;
2611 : float sub_nrg_L[STEREO_DFT_BAND_MAX];
2612 : float sub_nrg_R[STEREO_DFT_BAND_MAX];
2613 : float diff_ipd;
2614 : float *pNrgL, *pNrgR;
2615 : float reg;
2616 : float *pgIpd, sum_dot_prod_real, sum_dot_prod_img;
2617 : float sum_past_nrgL, sum_past_nrgL2;
2618 : float sum_past_nrgR, sum_past_nrgR2;
2619 : float sum_past_dpr, sum_past_dpr2;
2620 : float sum_past_dpi, sum_past_dpi2;
2621 : float sum_past_dot_prod_abs, sum_past_dot_prod_abs2;
2622 : float sum_past_nrg_dmx;
2623 : int16_t pos;
2624 : float pIpd[STEREO_DFT_BAND_MAX];
2625 : float ipd_smooth[STEREO_DFT_BAND_MAX];
2626 : float ipd_mean_change;
2627 :
2628 : /*------------------------------------------------------------------*
2629 : * Initialization
2630 : *-----------------------------------------------------------------*/
2631 :
2632 59679 : sum_past_dot_prod_abs2 = 0.0f;
2633 59679 : pos = hStereoDft->nrg_past_pos;
2634 :
2635 59679 : set_f( sub_nrg_DMX, 0, STEREO_DFT_BAND_MAX );
2636 59679 : set_f( sub_nrg_L, 0, STEREO_DFT_BAND_MAX );
2637 59679 : set_f( sub_nrg_R, 0, STEREO_DFT_BAND_MAX );
2638 :
2639 59679 : pSideGain = hStereoDft->side_gain + k_offset * STEREO_DFT_BAND_MAX;
2640 59679 : pgIpd = hStereoDft->gipd + k_offset;
2641 59679 : pPredGain = hStereoDft->res_pred_gain + k_offset * STEREO_DFT_BAND_MAX;
2642 59679 : gain_IPD = EPSILON;
2643 59679 : sum_energy_L = EPSILON; /* Set the accumulations for the no IPD Calculation */
2644 59679 : sum_energy_R = EPSILON;
2645 59679 : sum_dot_prod_real = EPSILON;
2646 59679 : sum_dot_prod_img = EPSILON;
2647 59679 : sub_nrg_DMX2 = 0.f;
2648 : #ifdef DEBUG_MODE_DFT
2649 : sum_nrg_L = EPSILON;
2650 : sum_nrg_R = EPSILON;
2651 : #endif
2652 :
2653 : /*------------------------------------------------------------------*
2654 : * Band-wise processing
2655 : *-----------------------------------------------------------------*/
2656 :
2657 59679 : b2 = 0;
2658 607694 : for ( b = 0; b < hStereoDft->nbands; b++ )
2659 : {
2660 548015 : pPredGain[b] = 1.f;
2661 548015 : sum_nrg_L = EPSILON;
2662 548015 : sum_nrg_R = EPSILON;
2663 548015 : dot_prod_real = EPSILON;
2664 548015 : dot_prod_img = EPSILON;
2665 548015 : sum_past_nrgL = 0;
2666 548015 : sum_past_nrgR = 0;
2667 548015 : sum_past_dpr = 0;
2668 548015 : sum_past_dpi = 0;
2669 :
2670 1249282 : while ( hStereoDft->band_limits_dmx[b2] < hStereoDft->band_limits[b + 1] )
2671 : {
2672 701267 : pDFT_L = DFT_L;
2673 701267 : pDFT_R = DFT_R;
2674 701267 : pNrgL = bin_nrgL;
2675 701267 : pNrgR = bin_nrgR;
2676 :
2677 701267 : sum_nrg_L2 = EPSILON;
2678 701267 : sum_nrg_R2 = EPSILON;
2679 701267 : dot_prod_real2 = EPSILON;
2680 701267 : dot_prod_img2 = EPSILON;
2681 :
2682 38225908 : for ( i = hStereoDft->band_limits_dmx[b2]; i < hStereoDft->band_limits_dmx[b2 + 1]; i++ )
2683 : {
2684 37524641 : sum_nrg_L2 += pNrgL[i];
2685 37524641 : sum_nrg_R2 += pNrgR[i];
2686 :
2687 : /* compute dot product*/
2688 37524641 : dot_prod_real2 += pDFT_L[2 * i] * pDFT_R[2 * i] + pDFT_L[2 * i + 1] * pDFT_R[2 * i + 1];
2689 37524641 : dot_prod_img2 += pDFT_L[2 * i + 1] * pDFT_R[2 * i] - pDFT_L[2 * i] * pDFT_R[2 * i + 1];
2690 : }
2691 701267 : abs_L_R2 = sqrtf( dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2 );
2692 701267 : sub_nrg_DMX2 = sum_nrg_L2 + sum_nrg_R2 + 2 * abs_L_R2;
2693 :
2694 701267 : if ( b2 < hStereoDft->gipd_band_max )
2695 : {
2696 477432 : hStereoDft->dot_prod_real_smooth[b2] = 0.5f * hStereoDft->dot_prod_real_smooth[b2] + 0.5f * dot_prod_real2;
2697 477432 : hStereoDft->dot_prod_img_smooth[b2] = 0.5f * hStereoDft->dot_prod_img_smooth[b2] + 0.5f * dot_prod_img2;
2698 477432 : pIpd[b2] = (float) atan2f( hStereoDft->dot_prod_img_smooth[b2], hStereoDft->dot_prod_real_smooth[b2] );
2699 :
2700 477432 : ipd_smooth[b2] = stereo_dft_calc_mean_bipd( &pIpd[b2], hStereoDft->ipd_buf[b2] );
2701 :
2702 477432 : gain_IPD += ( sum_nrg_L2 + sum_nrg_R2 + 2 * dot_prod_real2 ) / sub_nrg_DMX2 / hStereoDft->gipd_band_max;
2703 : }
2704 :
2705 701267 : sum_past_nrgL2 = EPSILON;
2706 701267 : sum_past_nrgR2 = EPSILON;
2707 701267 : sum_past_dpr2 = EPSILON;
2708 701267 : sum_past_dpi2 = EPSILON;
2709 701267 : if ( ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_HIGH && b2 < STEREO_DFT_NRG_PAST_MAX_BAND ) ||
2710 403403 : ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW && b2 < 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) )
2711 : {
2712 510528 : hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_L2;
2713 510528 : hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_R2;
2714 510528 : hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_real2;
2715 510528 : hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_img2;
2716 :
2717 2042112 : for ( i = 0; i < STEREO_DFT_NRG_PAST_LEN; i++ )
2718 : {
2719 1531584 : sum_past_nrgL2 += hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2720 1531584 : sum_past_nrgR2 += hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2721 1531584 : sum_past_dpr2 += hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2722 1531584 : sum_past_dpi2 += hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + i];
2723 : }
2724 :
2725 510528 : if ( hStereoDft->attackPresent )
2726 : {
2727 : /* omit transient frames from past part of parameter estimation in following frames */
2728 15663 : int16_t prev_pos = ( pos + STEREO_DFT_NRG_PAST_LEN - 1 ) % STEREO_DFT_NRG_PAST_LEN;
2729 15663 : hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2730 15663 : hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
2731 15663 : 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];
2732 15663 : 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];
2733 : }
2734 :
2735 510528 : sum_past_dot_prod_abs2 = sqrtf( sum_past_dpr2 * sum_past_dpr2 + sum_past_dpi2 * sum_past_dpi2 );
2736 510528 : dot_prod_nrg_ratio[b2] = sum_past_dot_prod_abs2 / ( sum_past_nrgL2 + sum_past_nrgR2 + EPSILON );
2737 : }
2738 : else
2739 : {
2740 190739 : sum_past_nrgL2 += sum_nrg_L2;
2741 190739 : sum_past_nrgR2 += sum_nrg_R2;
2742 190739 : dot_prod_nrg_ratio[b2] = sqrtf( dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2 );
2743 190739 : if ( b2 == 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) /* hStereoDft->band_res[k_offset] == 2 */
2744 : {
2745 26583 : dot_prod_nrg_ratio[b2] /= ( sum_nrg_L2 + sum_nrg_R2 + EPSILON );
2746 : }
2747 : }
2748 701267 : sum_nrg_L += sum_nrg_L2;
2749 701267 : sum_nrg_R += sum_nrg_R2;
2750 701267 : dot_prod_real += dot_prod_real2;
2751 701267 : dot_prod_img += dot_prod_img2;
2752 :
2753 701267 : sum_past_nrgL += sum_past_nrgL2;
2754 701267 : sum_past_nrgR += sum_past_nrgR2;
2755 701267 : sum_past_dpr += sum_past_dpr2;
2756 701267 : sum_past_dpi += sum_past_dpi2;
2757 :
2758 701267 : b2++;
2759 : }
2760 548015 : sum_energy_L += sum_nrg_L; /* Energies of the individual Band for Left and Right */
2761 548015 : sum_energy_R += sum_nrg_R;
2762 548015 : sum_dot_prod_real += dot_prod_real;
2763 548015 : sum_dot_prod_img += dot_prod_img;
2764 :
2765 : /* compute side and residual gains over two frames */
2766 548015 : abs_L_R = sqrtf( dot_prod_real * dot_prod_real + dot_prod_img * dot_prod_img );
2767 :
2768 548015 : if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW && b < 4 )
2769 : {
2770 106332 : sum_past_dot_prod_abs = sqrtf( sum_past_dpr * sum_past_dpr + sum_past_dpi * sum_past_dpi );
2771 : }
2772 441683 : else if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_HIGH && b < 9 )
2773 : {
2774 297864 : sum_past_dot_prod_abs = sum_past_dot_prod_abs2;
2775 : }
2776 : else
2777 : {
2778 143819 : sum_past_dot_prod_abs = abs_L_R;
2779 : }
2780 :
2781 548015 : c = sqrtf( sum_past_nrgL / sum_past_nrgR );
2782 548015 : sum_past_nrg_dmx = sum_past_nrgL + sum_past_nrgR + 2 * sum_past_dot_prod_abs;
2783 548015 : sub_nrg_DMX[b] = sum_nrg_L + sum_nrg_R + 2 * abs_L_R;
2784 :
2785 548015 : sub_nrg_L[b] = sum_nrg_L;
2786 548015 : sub_nrg_R[b] = sum_nrg_R;
2787 :
2788 548015 : if ( ( hStereoDft->res_pred_mode[k_offset] && b >= hStereoDft->res_pred_band_min ) || ( b < hStereoDft->res_cod_band_max ) )
2789 : {
2790 523033 : g = ( sum_past_nrgL - sum_past_nrgR ) / ( sum_past_nrg_dmx );
2791 523033 : pSideGain[b] = g;
2792 : }
2793 : else
2794 : {
2795 24982 : g = 0.0f; /* to avoid compilation warning */
2796 24982 : pSideGain[b] = ( c - 1 ) / ( c + 1 );
2797 : }
2798 :
2799 548015 : if ( hStereoDft->res_pred_mode[k_offset] && b >= hStereoDft->res_pred_band_min && !( hStereoDft->attackPresent ) )
2800 : {
2801 : /*(1-g)^2*L*L' + (1+g)^2*R*R' - 2(1-g^2)*abs(L*R')*/
2802 409122 : pPredGain[b] = max( 0, ( ( 1 - g ) * sum_past_nrgL + ( 1 + g ) * sum_past_nrgR - 2 * sum_past_dot_prod_abs ) );
2803 :
2804 : /*Normalized with energy of DMX*/
2805 :
2806 : /*Regularized gain computation by adding a coherent low energy contribution->avoid singularity for very low energy signals */
2807 :
2808 409122 : reg = ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) * sqrtf( STEREO_DFT_N_32k_ENC );
2809 409122 : reg *= reg;
2810 :
2811 409122 : pPredGain[b] = sqrtf( pPredGain[b] / ( reg + sum_past_nrg_dmx ) );
2812 :
2813 409122 : if ( hStereoDft->hItd->deltaItd[k_offset] != 0 )
2814 : {
2815 : float gain_offset, conversion_factor;
2816 : int16_t dItd32;
2817 :
2818 : /* factor for converting deltaItd to 32kHz */
2819 145176 : conversion_factor = 1.f;
2820 145176 : if ( hStereoDft->NFFT == STEREO_DFT_N_16k_ENC )
2821 : {
2822 30035 : conversion_factor = 2.f;
2823 : }
2824 115141 : else if ( hStereoDft->NFFT == STEREO_DFT_N_MAX_ENC )
2825 : {
2826 52549 : conversion_factor = 2.f / 3;
2827 : }
2828 145176 : dItd32 = (int16_t) floorf( conversion_factor * hStereoDft->hItd->deltaItd[k_offset] + 0.5f );
2829 :
2830 145176 : gain_offset = stereo_dft_gain_offset( c, dItd32 );
2831 145176 : pPredGain[b] = max( 0, pPredGain[b] - gain_offset );
2832 : }
2833 :
2834 : /*Limiter for active speech*/
2835 409122 : if ( sp_aud_decision0 == 0 && vad_flag )
2836 : {
2837 : /*Avoid jump of residual prediction gain when ITD is changing*/
2838 231914 : if ( hStereoDft->hItd->deltaItd[k_offset] != hStereoDft->hItd->deltaItd[0] )
2839 : {
2840 21095 : pPredGain[b] = min( hStereoDft->res_pred_gain_f[b], pPredGain[b] );
2841 : }
2842 :
2843 : /*Limiter*/
2844 231914 : hStereoDft->res_pred_gain_f[b] = 0.9f * hStereoDft->res_pred_gain_f[b] + 0.1f * pPredGain[b];
2845 231914 : pPredGain[b] = min( 1.1f * hStereoDft->res_pred_gain_f[b], pPredGain[b] );
2846 : }
2847 : else
2848 : {
2849 177208 : hStereoDft->res_pred_gain_f[b] = pPredGain[b];
2850 : }
2851 : }
2852 : else
2853 : {
2854 138893 : pPredGain[b] = 0.f;
2855 : }
2856 :
2857 :
2858 548015 : if ( b2 == hStereoDft->gipd_band_max )
2859 : {
2860 59679 : ipd_mean_change = stereo_dft_calc_mean_ipd_change( pIpd, ipd_smooth, hStereoDft->gipd_band_max );
2861 59679 : hStereoDft->sum_dot_prod_real = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_real + hStereoDft->sfm * sum_dot_prod_real;
2862 59679 : hStereoDft->sum_dot_prod_img = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_img + hStereoDft->sfm * sum_dot_prod_img;
2863 :
2864 59679 : pgIpd[0] = (float) atan2f( hStereoDft->sum_dot_prod_img, hStereoDft->sum_dot_prod_real );
2865 :
2866 59679 : stereo_dft_gipd_stabilization( &pgIpd[0], hStereoDft->prev_gipd, ipd_mean_change );
2867 59679 : hStereoDft->prev_gipd = pgIpd[0];
2868 : }
2869 : }
2870 :
2871 59679 : hStereoDft->nrg_past_pos = ( pos + 1 ) % STEREO_DFT_NRG_PAST_LEN;
2872 :
2873 : #ifdef DEBUG_MODE_DFT
2874 : {
2875 : float tmp_f;
2876 : dbgwrite( pPredGain, sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_gainPred.pcm" );
2877 : dbgwrite( pSideGain, sizeof( float ), hStereoDft->nbands, 1, "./res/stereo_dft_gainSide.pcm" );
2878 :
2879 : for ( i = 0; i < hStereoDft->nbands; i++ )
2880 : {
2881 : float regularization;
2882 :
2883 : regularization = ( hStereoDft->band_limits[i + 1] - hStereoDft->band_limits[i] ) * sqrtf( hStereoDft->NFFT );
2884 : tmp_f = sub_nrg_DMX[i] / ( regularization * regularization );
2885 : dbgwrite( &tmp_f, sizeof( float ), 1, 1, "./res/stereo_dft_nrgDMX.pcm" );
2886 :
2887 : g = sqrtf( sum_nrg_L / sum_nrg_R );
2888 : tmp_f = ( g - 1 ) / ( g + 1 );
2889 : dbgwrite( &tmp_f, sizeof( float ), 1, 1, "./res/stereo_dft_gainILD.pcm" );
2890 : }
2891 : }
2892 : #endif
2893 :
2894 : /*------------------------------------------------------------------*
2895 : * Compute IPDs
2896 : *-----------------------------------------------------------------*/
2897 :
2898 : #ifdef DEBUG_MODE_DFT
2899 : stereo_dft_enc_get_nipd_flag( hStereoDft, pgIpd, sp_aud_decision0, gain_IPD );
2900 : #else
2901 59679 : stereo_dft_enc_get_nipd_flag( hStereoDft, sp_aud_decision0, gain_IPD );
2902 : #endif
2903 :
2904 : #ifdef DEBUG_MODE_DFT
2905 : hStereoDft->no_ipd_flag = ( hStereoDft->hConfig->gipd_mode == 0 ) ? 1 : hStereoDft->no_ipd_flag;
2906 : #endif
2907 :
2908 59679 : if ( flag_quant )
2909 : {
2910 59679 : if ( hStereoDft->no_ipd_flag == 0 )
2911 : {
2912 6038 : hStereoDft->sid_gipd = *pgIpd;
2913 6038 : stereo_dft_quantize_ipd( pgIpd, pgIpd, &( hStereoDft->gipd_index ), STEREO_DFT_GIPD_NBITS );
2914 : }
2915 : else
2916 : {
2917 53641 : pgIpd[0] = 0;
2918 : }
2919 : }
2920 59679 : diff_ipd = pgIpd[0] - pgIpd[-1];
2921 :
2922 59679 : if ( diff_ipd < -EVS_PI )
2923 : {
2924 1285 : pgIpd[0] += PI2;
2925 : }
2926 58394 : else if ( diff_ipd > EVS_PI )
2927 : {
2928 283 : pgIpd[0] -= PI2;
2929 : }
2930 :
2931 59679 : if ( !hStereoDft->attackPresent )
2932 : {
2933 57841 : if ( hStereoDft->wasTransient )
2934 : {
2935 1730 : pgIpd[0] = 0.8f * pgIpd[0] + 0.2f * pgIpd[-1];
2936 : }
2937 : else
2938 : {
2939 56111 : pgIpd[0] = 0.5f * pgIpd[0] + 0.5f * pgIpd[-1];
2940 : }
2941 : }
2942 :
2943 59679 : c = sqrtf( sum_energy_L / sum_energy_R );
2944 59679 : g = fabsf( ( c - 1 ) / ( c + 1 ) );
2945 59679 : if ( g > 0.8f )
2946 : {
2947 658 : g = max( 0.f, -10.f * g + 9.0f );
2948 5612 : for ( b = 0; b < hStereoDft->nbands; b++ )
2949 : {
2950 4954 : pPredGain[b] *= g;
2951 : }
2952 : }
2953 :
2954 59679 : if ( hStereoDft->hConfig->band_res == STEREO_DFT_BAND_RES_LOW )
2955 : {
2956 26583 : hStereoDft->reverb_flag = 1;
2957 : }
2958 : else
2959 : {
2960 33096 : stereo_dft_enc_get_reverb_flag( hStereoDft, pPredGain, sub_nrg_DMX, sub_nrg_L, sub_nrg_R, k_offset, bin_nrgL, bin_nrgR );
2961 : }
2962 :
2963 :
2964 : /*------------------------------------------------------------------*
2965 : * Compute Side gains
2966 : *-----------------------------------------------------------------*/
2967 :
2968 607694 : for ( b = 0; b < hStereoDft->nbands; b++ )
2969 : {
2970 548015 : hStereoDft->sidSideGain[b] = *( pSideGain + b );
2971 :
2972 : /* Quantization */
2973 548015 : if ( flag_quant )
2974 : {
2975 548015 : 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 );
2976 : }
2977 :
2978 :
2979 548015 : if ( !hStereoDft->attackPresent )
2980 : {
2981 531564 : if ( b < hStereoDft->res_cod_band_max )
2982 : {
2983 98165 : pSideGain[b] = dft_res_cod_alpha[b] * pSideGain[b] + ( 1 - dft_res_cod_alpha[b] ) * pSideGain[b - STEREO_DFT_BAND_MAX];
2984 : }
2985 : }
2986 : }
2987 :
2988 : /*------------------------------------------------------------------*
2989 : * simulate prediction of parameters at the decoder
2990 : *-----------------------------------------------------------------*/
2991 :
2992 59679 : if ( hStereoDft->reverb_flag )
2993 : {
2994 : int16_t ipred, bpred0, bpred1, max_dev, sum_abs_dev;
2995 :
2996 37654 : ipred = 0;
2997 37654 : max_dev = 0;
2998 37654 : sum_abs_dev = 0;
2999 :
3000 : /* parameters for bred0 <= b < bpred1 are estimated from parameters of
3001 : the remaining bands with ptrans0 <= b < btrans1. */
3002 37654 : bpred1 = ( hStereoDft->nbands > 10 ) ? STEREO_DFT_RES_PRED_BAND_MAX - 2 : hStereoDft->nbands;
3003 37654 : if ( hStereoDft->band_res[k_offset] == STEREO_DFT_BAND_RES_LOW )
3004 : {
3005 26583 : bpred1 = min( bpred1, 6 );
3006 : }
3007 37654 : bpred0 = bpred1 - STEREO_DFT_RES_PRED_BAND_MIN_CONST;
3008 :
3009 : /* get estimate (currently the maximal index) */
3010 188654 : for ( b = hStereoDft->res_pred_band_min; b < bpred0; b++ )
3011 : {
3012 151000 : ipred = max( ipred, hStereoDft->res_pred_index_EC[b] );
3013 : }
3014 :
3015 : /* check prediction error */
3016 150616 : for ( b = bpred0; b < bpred1; b++ )
3017 : {
3018 112962 : max_dev = (int16_t) max( max_dev, abs( ipred - hStereoDft->res_pred_index_EC[b] ) );
3019 112962 : sum_abs_dev += (int16_t) abs( ipred - hStereoDft->res_pred_index_EC[b] );
3020 : }
3021 :
3022 37654 : hStereoDft->reverb_flag = ( max_dev <= 1 && sum_abs_dev <= 2 );
3023 :
3024 37654 : if ( hStereoDft->reverb_flag && hStereoDft->nbands > 10 ) /*SWB and FB*/
3025 : {
3026 8730 : for ( b = STEREO_DFT_RES_PRED_BAND_MAX - 1; b >= STEREO_DFT_RES_PRED_BAND_MAX - 2; b-- )
3027 : {
3028 5820 : hStereoDft->res_pred_index_EC[b - STEREO_DFT_RES_PRED_BAND_MIN_CONST] = hStereoDft->res_pred_index_EC[b];
3029 : }
3030 : }
3031 : #ifdef DEBUG_MODE_DFT
3032 : if ( hStereoDft->reverb_flag )
3033 : {
3034 : dbgwrite( &ipred, sizeof( ipred ), 1, 1, "./res/stereo_dft_enc_ipred" );
3035 : }
3036 : #endif
3037 : }
3038 : #ifdef DEBUG_MODE_DFT
3039 : dbgwrite( &( hStereoDft->reverb_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_reverb_flag2.pcm" );
3040 : #endif
3041 :
3042 59679 : assert( hStereoDft->nbands <= 13 ); /* always use band_limits_erb4 and not band_limits_erb2 */
3043 :
3044 59679 : return;
3045 : }
3046 :
3047 :
3048 : /*---------------------------------------------------------------------*
3049 : * side_gain_mode_decision()
3050 : *
3051 : *
3052 : *---------------------------------------------------------------------*/
3053 :
3054 45135 : static void side_gain_mode_decision(
3055 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
3056 : int16_t encoded_ind_GR[],
3057 : const int16_t sp_aud_decision0, /* i : Speech/audio decision 0 */
3058 : const int32_t last_core_brate /* i : Last core bitrate */
3059 : )
3060 : {
3061 : int16_t try_diff, nb_diff, no_GR_ord, n_bits, i;
3062 :
3063 45135 : try_diff = sp_aud_decision0;
3064 45135 : if ( try_diff )
3065 : {
3066 11055 : if ( hStereoDft->side_gain_counter == STEREO_DFT_FEC_THRESHOLD )
3067 : {
3068 336 : try_diff = 0;
3069 336 : hStereoDft->side_gain_counter = 0;
3070 : }
3071 : }
3072 : else
3073 : {
3074 34080 : hStereoDft->side_gain_counter = 0;
3075 : }
3076 :
3077 : /* If last frame SID/NO_DATA do not use differential coding */
3078 45135 : if ( last_core_brate <= SID_2k40 )
3079 : {
3080 1412 : try_diff = 0;
3081 : }
3082 45135 : no_GR_ord = 3;
3083 90270 : hStereoDft->side_gain_flag_2 = adapt_GR_ief( hStereoDft->side_gain_index_EC, hStereoDft->side_gain_index_ECDiff, hStereoDft->side_gain_index_ECprevious,
3084 45135 : hStereoDft->nbands, NO_SYMB_GR_SIDE_G, &n_bits, encoded_ind_GR, dft_maps_sg, no_GR_ord, &nb_diff,
3085 45135 : hStereoDft->side_gain_counter, &hStereoDft->side_gain_bitdiff_lp, try_diff );
3086 :
3087 :
3088 471368 : for ( i = 0; i < hStereoDft->nbands; i++ )
3089 : {
3090 426233 : hStereoDft->side_gain_index_ECprevious[i] = hStereoDft->side_gain_index_EC[i];
3091 : }
3092 :
3093 45135 : if ( n_bits > ( hStereoDft->nbands * STEREO_DFT_SIDE_GAIN_NBITS - 1 ) )
3094 : {
3095 : /* use fixed rate */
3096 1059 : hStereoDft->side_gain_flag_1 = 3;
3097 1059 : hStereoDft->side_gain_counter = 0;
3098 : }
3099 : else
3100 : {
3101 44076 : if ( hStereoDft->side_gain_flag_2 >= no_GR_ord )
3102 : {
3103 9001 : hStereoDft->side_gain_flag_1 = 2;
3104 9001 : hStereoDft->side_gain_counter += 1;
3105 : }
3106 : else
3107 : {
3108 35075 : hStereoDft->side_gain_flag_1 = 0;
3109 35075 : hStereoDft->side_gain_counter = 0;
3110 : }
3111 : }
3112 :
3113 45135 : return;
3114 : }
3115 :
3116 :
3117 : /*---------------------------------------------------------------------*
3118 : * res_pred_gain_mode_decision()
3119 : *
3120 : *
3121 : *---------------------------------------------------------------------*/
3122 :
3123 45135 : static void res_pred_gain_mode_decision(
3124 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
3125 : int16_t encoded_ind_pred_GR[],
3126 : const int16_t k_offset, /* i : Parameter offset */
3127 : const int32_t last_core_brate /* i : Last core bitrate */
3128 : )
3129 : {
3130 : int16_t nb_diff, try_diff, no_GR_ord, i, n_bits;
3131 : int16_t nbands;
3132 :
3133 : /* Residual Prediction Gain */
3134 45135 : if ( hStereoDft->res_pred_mode[k_offset] )
3135 : {
3136 43690 : if ( hStereoDft->attackPresent == 0 )
3137 : {
3138 42086 : nbands = min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
3139 :
3140 42086 : if ( hStereoDft->reverb_flag )
3141 : {
3142 6717 : nbands -= STEREO_DFT_RES_PRED_BAND_MIN_CONST;
3143 : }
3144 :
3145 42086 : try_diff = 1;
3146 42086 : if ( hStereoDft->res_pred_counter == STEREO_DFT_FEC_THRESHOLD )
3147 : {
3148 1637 : try_diff = 0;
3149 1637 : hStereoDft->res_pred_counter = 0;
3150 : }
3151 :
3152 : /* If last frame SID/NO_DATA do not use differential coding */
3153 42086 : if ( last_core_brate <= SID_2k40 )
3154 : {
3155 290 : try_diff = 0;
3156 : }
3157 :
3158 42086 : no_GR_ord = 2;
3159 :
3160 42086 : 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 );
3161 :
3162 416795 : for ( i = 0; i < nbands; i++ )
3163 : {
3164 374709 : hStereoDft->res_pred_index_ECprevious[i] = hStereoDft->res_pred_index_EC[i];
3165 : }
3166 :
3167 70274 : for ( ; i < hStereoDft->nbands; i++ )
3168 : {
3169 28188 : hStereoDft->res_pred_index_ECprevious[i] = 0;
3170 : }
3171 :
3172 42086 : if ( n_bits > ( nbands - hStereoDft->res_pred_band_min ) * STEREO_DFT_RES_GAINS_BITS - 1 )
3173 : {
3174 3311 : hStereoDft->res_pred_flag_1 = 3;
3175 3311 : hStereoDft->res_pred_counter = 0;
3176 : }
3177 : else
3178 : {
3179 38775 : if ( hStereoDft->res_pred_flag_2 > 1 )
3180 : {
3181 : /* differential coding */
3182 30339 : hStereoDft->res_pred_flag_1 = 2;
3183 30339 : hStereoDft->res_pred_counter += 1;
3184 : }
3185 : else
3186 : {
3187 8436 : hStereoDft->res_pred_counter = 0;
3188 8436 : hStereoDft->res_pred_flag_1 = 0;
3189 : }
3190 : }
3191 : }
3192 : else
3193 : {
3194 1604 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
3195 : }
3196 : }
3197 : else
3198 : {
3199 1445 : set_s( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
3200 : }
3201 :
3202 45135 : return;
3203 : }
3204 :
3205 :
3206 : /*-------------------------------------------------------------------------
3207 : * stereo_dft_calc_mean_bipd()
3208 : *
3209 : * Calculate mean of previous bandwise IPD values
3210 : *------------------------------------------------------------------------*/
3211 :
3212 477432 : static float stereo_dft_calc_mean_bipd(
3213 : float *pIpd, /* i : current bandwise IPD */
3214 : float ipd_buf[STEREO_DFT_IPD_BUF_LEN] /* i/o: previous bandwise IPDs */
3215 : )
3216 : {
3217 : int16_t i;
3218 : float ipd_smooth;
3219 : float diff_to_last;
3220 :
3221 477432 : assert( *pIpd <= EVS_PI && *pIpd >= -EVS_PI );
3222 :
3223 477432 : ipd_smooth = 0.f;
3224 2864592 : for ( i = 0; i < STEREO_DFT_IPD_BUF_LEN; i++ )
3225 : {
3226 2387160 : if ( i == 0 )
3227 : {
3228 477432 : diff_to_last = ipd_buf[0];
3229 : }
3230 : else
3231 : {
3232 1909728 : diff_to_last = fabsf( ipd_buf[i] - ipd_smooth );
3233 : }
3234 2387160 : if ( diff_to_last > EVS_PI )
3235 : {
3236 52754 : if ( ipd_buf[i] > 0 )
3237 : {
3238 30154 : ipd_buf[i] -= 2 * EVS_PI;
3239 : }
3240 : else
3241 : {
3242 22600 : ipd_buf[i] += 2 * EVS_PI;
3243 : }
3244 : }
3245 2387160 : ipd_smooth = ( i / (float) ( i + 1 ) ) * ipd_smooth + ( 1 / (float) ( i + 1 ) ) * ipd_buf[i];
3246 2387160 : if ( ipd_smooth < -EVS_PI )
3247 : {
3248 18723 : ipd_smooth += 2 * EVS_PI;
3249 : }
3250 2368437 : else if ( ipd_smooth > EVS_PI )
3251 : {
3252 11185 : ipd_smooth -= 2 * EVS_PI;
3253 : }
3254 : }
3255 :
3256 2387160 : for ( i = 0; i < STEREO_DFT_IPD_BUF_LEN - 1; i++ )
3257 : {
3258 1909728 : ipd_buf[i] = ipd_buf[i + 1];
3259 : }
3260 477432 : ipd_buf[STEREO_DFT_IPD_BUF_LEN - 1] = *pIpd;
3261 :
3262 : #ifdef DEBUG_MODE_DFT
3263 : dbgwrite( pIpd, sizeof( float ), 1, 1, "res/stereo_dft_bipd.pcm" );
3264 : dbgwrite( &ipd_smooth, sizeof( float ), 1, 1, "res/stereo_dft_bipd_smooth.pcm" );
3265 : #endif
3266 :
3267 477432 : return ipd_smooth;
3268 : }
3269 :
3270 :
3271 : /*-------------------------------------------------------------------------
3272 : * stereo_dft_calc_mean_ipd_change()
3273 : *
3274 : * Calculate mean IPD change over all bands
3275 : *------------------------------------------------------------------------*/
3276 :
3277 59679 : static float stereo_dft_calc_mean_ipd_change(
3278 : float *pIpd, /* i : bandwise IPDs */
3279 : float *ipd_smooth, /* i : mean of previous bandwise IPDs */
3280 : int16_t gipd_band_max /* i : number of IPD bands */
3281 : )
3282 : {
3283 : int16_t b;
3284 : float ipd_mean_change;
3285 : float ipd_change[STEREO_DFT_BAND_MAX];
3286 :
3287 59679 : ipd_mean_change = 0.f;
3288 537111 : for ( b = 0; b < gipd_band_max; b++ )
3289 : {
3290 477432 : ipd_change[b] = fabsf( pIpd[b] - ipd_smooth[b] );
3291 477432 : if ( ipd_change[b] > EVS_PI )
3292 : {
3293 21574 : ipd_change[b] = 2 * EVS_PI - ipd_change[b];
3294 : }
3295 477432 : ipd_mean_change += ipd_change[b];
3296 : }
3297 59679 : ipd_mean_change /= gipd_band_max;
3298 :
3299 : #ifdef DEBUG_MODE_DFT
3300 : dbgwrite( ipd_change, sizeof( float ), gipd_band_max, 1, "res/stereo_dft_ipd_change.pcm" );
3301 : dbgwrite( &ipd_mean_change, sizeof( float ), 1, 1, "res/stereo_dft_ipd_mean_change.pcm" );
3302 : #endif
3303 :
3304 59679 : return ipd_mean_change;
3305 : }
3306 :
3307 :
3308 : /*-------------------------------------------------------------------------
3309 : * stereo_dft_gipd_stabilization()
3310 : *
3311 : * stabilize global IPD based on stability of bandwise IPDs
3312 : *------------------------------------------------------------------------*/
3313 :
3314 59679 : static void stereo_dft_gipd_stabilization(
3315 : float *pgIpd, /* i/o: global IPD to be stabilized */
3316 : float prev_gipd, /* i : previous global IPD */
3317 : float ipd_mean_change /* i : mean of previous bandwise IPDs */
3318 : )
3319 : {
3320 : float diff_gipd;
3321 :
3322 59679 : if ( ipd_mean_change < 0.3f )
3323 : {
3324 26505 : *pgIpd = prev_gipd;
3325 : }
3326 : else
3327 : {
3328 33174 : diff_gipd = fabsf( *pgIpd - prev_gipd );
3329 33174 : if ( diff_gipd > EVS_PI )
3330 : {
3331 1260 : diff_gipd = 2 * EVS_PI - diff_gipd;
3332 : }
3333 33174 : if ( diff_gipd > ipd_mean_change )
3334 : {
3335 5455 : if ( *pgIpd > prev_gipd )
3336 : {
3337 2584 : if ( *pgIpd - prev_gipd < EVS_PI )
3338 : {
3339 2193 : *pgIpd = prev_gipd + ipd_mean_change;
3340 : }
3341 : else
3342 : {
3343 391 : *pgIpd = prev_gipd - ipd_mean_change;
3344 391 : if ( *pgIpd < -EVS_PI )
3345 : {
3346 154 : *pgIpd += 2 * EVS_PI;
3347 : }
3348 : }
3349 : }
3350 : else
3351 : {
3352 2871 : if ( prev_gipd - *pgIpd < EVS_PI )
3353 : {
3354 2264 : *pgIpd = prev_gipd - ipd_mean_change;
3355 : }
3356 : else
3357 : {
3358 607 : *pgIpd = prev_gipd + ipd_mean_change;
3359 607 : if ( *pgIpd > EVS_PI )
3360 : {
3361 273 : *pgIpd -= 2 * EVS_PI;
3362 : }
3363 : }
3364 : }
3365 : }
3366 : }
3367 59679 : return;
3368 : }
3369 :
3370 :
3371 : /*-------------------------------------------------------------------------
3372 : * stereo_dft_enc_get_nipd_flag()
3373 : *
3374 : *
3375 : *------------------------------------------------------------------------*/
3376 :
3377 59679 : static void stereo_dft_enc_get_nipd_flag(
3378 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
3379 : #ifdef DEBUG_MODE_DFT
3380 : float *pgIpd,
3381 : #endif
3382 : const int16_t sp_aud_decision0,
3383 : const float gainIPD )
3384 : {
3385 59679 : hStereoDft->gainIPD_sm = 0.5f * hStereoDft->gainIPD_sm + 0.5f * gainIPD; /* to decide on use of no IPD */
3386 :
3387 59679 : hStereoDft->no_ipd_flag = 0; /* Set flag initially to zero - subband IPD */
3388 :
3389 59679 : if ( hStereoDft->gainIPD_sm >= 0.75f || ( hStereoDft->prev_no_ipd_flag && ( sp_aud_decision0 || hStereoDft->voicing_lt > 0.98f ) ) )
3390 : {
3391 52013 : hStereoDft->no_ipd_flag = 1; /* Set the flag */
3392 : }
3393 :
3394 : #ifdef DEBUG_MODE_DFT
3395 : {
3396 : int16_t tmp;
3397 : dbgwrite( &( hStereoDft->no_ipd_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_nipd_first.pcm" );
3398 : tmp = (int16_t) ( hStereoDft->gainIPD_sm * 100.f );
3399 : dbgwrite( &tmp, sizeof( int16_t ), 1, 640, "./res/stereo_dft_gipd_gain_IPD.pcm" );
3400 : dbgwrite( pgIpd, sizeof( float ), 1, 1, "./res/stereo_dft_gipd_IPD.pcm" );
3401 : }
3402 : #endif
3403 :
3404 : /* hangover between the group IPD and subband IPD */
3405 59679 : if ( hStereoDft->prev_no_ipd_flag != hStereoDft->no_ipd_flag && hStereoDft->no_ipd_cnt < 5 )
3406 : {
3407 6746 : hStereoDft->no_ipd_flag = hStereoDft->prev_no_ipd_flag;
3408 6746 : hStereoDft->no_ipd_cnt++;
3409 : }
3410 : else
3411 : {
3412 52933 : hStereoDft->no_ipd_cnt = 0;
3413 : }
3414 :
3415 59679 : hStereoDft->prev_no_ipd_flag = hStereoDft->no_ipd_flag; /* Save the no IPD flag for the next frame */
3416 :
3417 : #ifdef DEBUG_MODE_DFT
3418 : /*fprintf(pF2, "%d\n",hStereoDft->no_ipd_flag);*/
3419 : dbgwrite( &( hStereoDft->no_ipd_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_nipd_final.pcm" );
3420 : #endif
3421 :
3422 59679 : return;
3423 : }
3424 :
3425 :
3426 : /*---------------------------------------------------------------
3427 : * stereo_dft_enc_get_reverb_flag()
3428 : *
3429 : *
3430 : * ---------------------------------------------------------------*/
3431 :
3432 33096 : static void stereo_dft_enc_get_reverb_flag(
3433 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
3434 : float *pPredGain,
3435 : float *sub_nrg_DMX,
3436 : const float *sub_nrg_L,
3437 : const float *sub_nrg_R,
3438 : const int16_t k_offset,
3439 : const float *bin_nrgL,
3440 : const float *bin_nrgR )
3441 : {
3442 : int16_t i, b, b1, index_min, nbands;
3443 : float nrg_DMX_min;
3444 : float norm_r, norm_l, norm_dmx;
3445 : float diff_l_l, diff_r_l, diff_l_h, diff_r_h;
3446 : float ener_l, ener_r, ener_dmx;
3447 : float nrg_DMX_max_avrg, nrg_DMX_min_avrg;
3448 : float fac;
3449 :
3450 33096 : hStereoDft->reverb_flag = 0;
3451 33096 : if ( hStereoDft->res_pred_mode[k_offset] && hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
3452 : {
3453 12847 : diff_r_l = EPSILON;
3454 12847 : diff_l_l = EPSILON;
3455 12847 : diff_r_h = EPSILON;
3456 12847 : diff_l_h = EPSILON;
3457 :
3458 102776 : for ( b = 0; b <= min( hStereoDft->nbands, 6 ); b++ ) /* choose the subbands used for stereo filling */
3459 : {
3460 89929 : norm_dmx = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_DMX[b] );
3461 89929 : norm_l = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_L[b] );
3462 89929 : norm_r = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_R[b] );
3463 :
3464 1233312 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
3465 : {
3466 1143383 : ener_l = bin_nrgL[i];
3467 1143383 : ener_r = bin_nrgR[i];
3468 1143383 : ener_dmx = ( ener_l + ener_r + 2 * sqrtf( ener_l * ener_r ) ) * norm_dmx; /*approximation of nrg of DMX per line*/
3469 1143383 : ener_l *= norm_l;
3470 1143383 : ener_r *= norm_r;
3471 :
3472 1143383 : diff_l_l += fabsf( ener_l - ener_dmx );
3473 1143383 : diff_r_l += fabsf( ener_r - ener_dmx );
3474 : }
3475 : }
3476 12847 : if ( hStereoDft->nbands <= 10 )
3477 : {
3478 11724 : for ( ; b < min( hStereoDft->nbands, 10 ); b++ ) /* choose the subbands used for stereo filling */
3479 : {
3480 8793 : norm_dmx = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_DMX[b] );
3481 8793 : norm_l = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_L[b] );
3482 8793 : norm_r = ( ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) / sub_nrg_R[b] );
3483 :
3484 682923 : for ( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
3485 : {
3486 674130 : ener_l = bin_nrgL[i];
3487 674130 : ener_r = bin_nrgR[i];
3488 674130 : ener_dmx = ( ener_l + ener_r + 2 * sqrtf( ener_l * ener_r ) ) * norm_dmx; /*approximation of nrg of DMX per line*/
3489 674130 : ener_l *= norm_l;
3490 674130 : ener_r *= norm_r;
3491 :
3492 674130 : diff_l_h += fabsf( ener_l - ener_dmx );
3493 674130 : diff_r_h += fabsf( ener_r - ener_dmx );
3494 : }
3495 : }
3496 : }
3497 :
3498 162107 : for ( b = 0; b < hStereoDft->nbands; b++ ) /* choose the subbands used for stereo filling */
3499 : {
3500 149260 : sub_nrg_DMX[b] /= ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] );
3501 149260 : sub_nrg_DMX[b] = 0.6f * hStereoDft->pre_sub_nrg_DMX[b] + 0.4f * sub_nrg_DMX[b];
3502 149260 : hStereoDft->pre_sub_nrg_DMX[b] = sub_nrg_DMX[b];
3503 : }
3504 :
3505 : /* adaptively select the subbands to predict based on the energy */
3506 12847 : nbands = ( hStereoDft->nbands > 10 ) ? ( hStereoDft->nbands - 2 ) : hStereoDft->nbands;
3507 12847 : nrg_DMX_min_avrg = 0.0f;
3508 25694 : for ( b = 2; b < STEREO_DFT_RES_PRED_BAND_MIN_RED; b++ )
3509 : {
3510 12847 : nrg_DMX_min = sub_nrg_DMX[b];
3511 12847 : index_min = b;
3512 :
3513 116581 : for ( b1 = 2; b1 < nbands; b1++ )
3514 : {
3515 103734 : if ( nrg_DMX_min > sub_nrg_DMX[b1] )
3516 : {
3517 72481 : nrg_DMX_min = sub_nrg_DMX[b1];
3518 72481 : index_min = b1;
3519 : }
3520 : }
3521 :
3522 12847 : nrg_DMX_min_avrg += nrg_DMX_min;
3523 12847 : sub_nrg_DMX[index_min] = FLT_MAX;
3524 : }
3525 :
3526 12847 : nrg_DMX_max_avrg = 0.0f;
3527 116581 : for ( b = 2, b1 = STEREO_DFT_RES_PRED_BAND_MIN_RED; b < nbands; b++ )
3528 : {
3529 103734 : if ( sub_nrg_DMX[b] != FLT_MAX )
3530 : {
3531 90887 : nrg_DMX_max_avrg += sub_nrg_DMX[b];
3532 : }
3533 : }
3534 :
3535 12847 : if ( hStereoDft->nbands <= 10 ) /*WB*/
3536 : {
3537 2931 : if ( hStereoDft->res_pred_mode[0] == STEREO_DFT_RESPRED_OFF || hStereoDft->hConfig->res_cod_mode != STEREO_DFT_RES_COD_OFF )
3538 : {
3539 712 : hStereoDft->diff_l_h_sm = diff_l_h;
3540 712 : hStereoDft->diff_r_h_sm = diff_r_h;
3541 : }
3542 : else
3543 : {
3544 2219 : hStereoDft->diff_l_h_sm = 0.9f * hStereoDft->diff_l_h_sm + 0.1f * diff_l_h;
3545 2219 : hStereoDft->diff_r_h_sm = 0.9f * hStereoDft->diff_r_h_sm + 0.1f * diff_r_h;
3546 : }
3547 :
3548 2931 : if ( hStereoDft->diff_l_h_sm > 120.0f || hStereoDft->diff_r_h_sm > 120.0f )
3549 : {
3550 1996 : hStereoDft->reverb_flag = 1;
3551 : }
3552 : }
3553 : else /*SWB/FB*/
3554 : {
3555 9916 : if ( 3 * nrg_DMX_max_avrg > 64 * 5 * nrg_DMX_min_avrg )
3556 : {
3557 9075 : hStereoDft->reverb_flag = 1;
3558 : }
3559 : }
3560 :
3561 : /*Stereo Filling gain damping*/
3562 12847 : fac = ( ( diff_l_l > diff_r_l ) ? diff_r_l / diff_l_l : diff_l_l / diff_r_l );
3563 12847 : fac = fac > 0.25f ? 1.0f : 4.f * fac;
3564 12847 : fac = 0.98f * hStereoDft->prev_fac2 + 0.02f * fac;
3565 12847 : hStereoDft->prev_fac2 = fac;
3566 :
3567 162107 : for ( b = 0; b < hStereoDft->nbands; b++ )
3568 : {
3569 149260 : if ( b < 5 )
3570 : {
3571 64235 : pPredGain[b] *= max( 0.5f, fac );
3572 : }
3573 : else
3574 : {
3575 85025 : pPredGain[b] *= min( 1.0f, max( 0.75f, 0.5f + fac ) );
3576 : }
3577 : }
3578 : }
3579 :
3580 : #ifdef DEBUG_MODE_DFT
3581 : dbgwrite( &( hStereoDft->reverb_flag ), sizeof( int16_t ), 1, 640, "./res/stereo_dft_reverb_flag.pcm" );
3582 : #endif
3583 :
3584 33096 : return;
3585 : }
3586 :
3587 : /*---------------------------------------------------------------
3588 : * stereo_dft_gain_offset()
3589 : *
3590 : * c = gain between L and R, itd = itd in samples @ 32kHz
3591 : * ---------------------------------------------------------------*/
3592 :
3593 145176 : static float stereo_dft_gain_offset(
3594 : const float c,
3595 : const int16_t itd )
3596 : {
3597 : float wnt, go, alpha;
3598 : int16_t tau, k0;
3599 :
3600 145176 : tau = (int16_t) min( abs( itd ), 160 );
3601 : /* Wn_table contains every 8th sample of the window's cross-correlation
3602 : * function @ 32kHz from which the values are interpolated: */
3603 145176 : k0 = tau >> 3;
3604 145176 : alpha = ( tau & 7 ) / 8.f;
3605 145176 : wnt = ( 1 - alpha ) * Wn_table[k0] + alpha * Wn_table[k0 + 1];
3606 :
3607 145176 : go = sqrtf( 8 * c * c / ( ( 1 + c ) * ( 1 + c ) ) * ( 1 - wnt ) / ( 1 + c * c + 2 * c * wnt ) );
3608 :
3609 145176 : return go;
3610 : }
3611 :
3612 : /*---------------------------------------------------------------
3613 : * stereo_dft_enc_calculate_nrg_for_icbwe()
3614 : *
3615 : * calculate energy of downmix and left and right channel in the
3616 : * SHB region for later use in ICBWE
3617 : * ---------------------------------------------------------------*/
3618 :
3619 48124 : static void stereo_dft_enc_calculate_nrg_for_icbwe(
3620 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder DFT stereo handle */
3621 : const float *DMX, /* i : DFT Stereo downmix */
3622 : const int32_t input_Fs /* i : input sampling rate */
3623 : )
3624 : {
3625 : float *pDFT_L, *pDFT_R, bandResDft;
3626 : int16_t i, shbBins[3];
3627 :
3628 48124 : bandResDft = ( (float) input_Fs ) / hStereoDft->NFFT;
3629 48124 : shbBins[0] = (int16_t) ( 6400 / bandResDft );
3630 48124 : shbBins[1] = (int16_t) ( 10400 / bandResDft );
3631 48124 : shbBins[2] = (int16_t) ( 14400 / bandResDft );
3632 48124 : assert( shbBins[1] <= hStereoDft->NFFT / 2 );
3633 :
3634 48124 : set_f( hStereoDft->nrg_L, EPSILON, 2 );
3635 48124 : set_f( hStereoDft->nrg_R, EPSILON, 2 );
3636 48124 : set_f( hStereoDft->nrg_DMX, EPSILON, 2 );
3637 :
3638 48124 : pDFT_L = hStereoDft->DFT[0];
3639 48124 : pDFT_R = hStereoDft->DFT[1];
3640 :
3641 7747964 : for ( i = shbBins[0]; i < shbBins[1]; i++ )
3642 : {
3643 7699840 : hStereoDft->nrg_L[0] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
3644 7699840 : hStereoDft->nrg_R[0] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
3645 7699840 : hStereoDft->nrg_DMX[0] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
3646 : }
3647 7747964 : for ( ; i < shbBins[2]; i++ )
3648 : {
3649 7699840 : hStereoDft->nrg_L[1] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
3650 7699840 : hStereoDft->nrg_R[1] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
3651 7699840 : hStereoDft->nrg_DMX[1] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
3652 : }
3653 :
3654 48124 : return;
3655 : }
|
