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