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