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.q_inp
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_fx.h"
41 : #include "ivas_prot_fx.h"
42 : #include "ivas_cnst.h"
43 : #include "ivas_rom_com.h"
44 : #include "ivas_rom_com_fx.h"
45 : #include "ivas_rom_enc.h"
46 : #include "wmc_auto.h"
47 :
48 :
49 : /*-------------------------------------------------------------------*
50 : * Local constants
51 : *-------------------------------------------------------------------*/
52 :
53 : #define STEREO_DFT_NRG_PAST_MAX_BAND 9
54 : #define STEREO_DFT_NRG_PAST_MAX_BAND_LB 4
55 : #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 */
56 : #define ITD_VAD_E_BAND_N_INIT 200000
57 : #define ITD_SID_PREV_FRAMES 5
58 :
59 :
60 : /*-------------------------------------------------------------------------
61 : * Local function prototypes
62 : *------------------------------------------------------------------------*/
63 :
64 : static void stereo_dft_enc_open_fx( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, const Word32 input_Fs, const Word16 max_bwidth );
65 :
66 : static void stereo_dft_enc_compute_prm_fx(
67 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
68 : Word32 *DFT_L_fx, // Q(31-DFT_L_fx_e[])
69 : Word16 *DFT_L_fx_e,
70 : Word32 *DFT_R_fx, // Q(31-DFT_R_fx_e[])
71 : Word16 *DFT_R_fx_e,
72 : Word16 k_offset,
73 : Word16 flag_quant,
74 : const Word16 sp_aud_decision0,
75 : const Word16 vad_flag,
76 : Word32 *bin_nrgL_fx, // Q(31-bin_nrgL_fx_e[])
77 : Word16 *bin_nrgL_fx_e,
78 : Word32 *bin_nrgR_fx, // Q(31-bin_nrgR_fx_e[])
79 : Word16 *bin_nrgR_fx_e,
80 : Word32 *dot_prod_nrg_ratio_fx, // Q(31-dot_prod_nrg_ratio_fx_e[])
81 : Word16 *dot_prod_nrg_ratio_fx_e );
82 :
83 : static Word32 stereo_dft_calc_mean_bipd_fx( Word32 *pIpd, Word32 ipd_buf[STEREO_DFT_IPD_BUF_LEN] );
84 :
85 : static Word32 stereo_dft_calc_mean_ipd_change_fx(
86 : Word32 *pIpd, /* i : bandwise IPDs Q13 */
87 : Word32 *ipd_smooth, /* i : mean of previous bandwise IPDs Q13 */
88 : Word16 gipd_band_max /* i : number of IPD bands */
89 : );
90 :
91 : static void stereo_dft_gipd_stabilization_fx(
92 : Word32 *pgIpd, /* i/o: global IPD to be stabilized Q13 */
93 : Word32 prev_gipd, /* i : previous global IPD Q13 */
94 : Word32 ipd_mean_change /* i : mean of previous bandwise IPDs Q13 */
95 : );
96 :
97 : static void stereo_dft_enc_get_nipd_flag_fx( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, const Word16 sp_aud_decision0, const Word32 gainIPD );
98 :
99 : static void stereo_dft_enc_get_reverb_flag_fx( STEREO_DFT_ENC_DATA_HANDLE hStereoDft, Word32 *pPredGain, Word32 *sub_nrg_DMX, Word16 *sub_nrg_DMX_e, const Word32 *sub_nrg_L, const Word16 *sub_nrg_L_e, const Word32 *sub_nrg_R, const Word16 *sub_nrg_R_e, const Word16 k_offset, const Word32 *bin_nrgL, const Word16 *bin_nrgL_e, const Word32 *bin_nrgR, const Word16 *bin_nrgR_e );
100 :
101 : static Word32 stereo_dft_gain_offset_fx( const Word32 c, const Word16 c_e, const Word16 itd );
102 :
103 : static void side_gain_mode_decision_fx(
104 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
105 : Word16 encoded_ind_GR[],
106 : const Word16 sp_aud_decision0, /* i : Speech/audio decision 0 */
107 : const Word32 last_core_brate /* i : Last core bitrate */
108 : );
109 :
110 : static void res_pred_gain_mode_decision_fx(
111 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
112 : Word16 encoded_ind_pred_GR[],
113 : const Word16 k_offset, /* i : Parameter offset */
114 : const Word32 last_core_brate /* i : Last core bitrate */
115 : );
116 :
117 : static void stereo_dft_enc_calculate_nrg_for_icbwe_fx(
118 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder DFT stereo handle */
119 : const Word16 *DFT_L_e,
120 : const Word16 *DFT_R_e,
121 : const Word32 *DMX, /* i : DFT Stereo downmix Q(31-DMX_e[]) */
122 : const Word16 *DMX_e, /* i : DFT Stereo downmix */
123 : const Word32 input_Fs /* i : input sampling rate */
124 : );
125 :
126 : static void stereo_dft_enc_get_res_cod_mode_flag_fx(
127 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
128 : const Word32 res_nrg_all_curr,
129 : const Word16 res_nrg_all_curr_e,
130 : const Word32 dmx_nrg_all_curr,
131 : const Word16 dmx_nrg_all_curr_e,
132 : Word32 *res_dmx_ratio, // Q31
133 : Word32 *frame_nrg_ratio ); // Q28
134 :
135 : /*-------------------------------------------------------------------------
136 : * stereo_dft_quantize_res_gains()
137 : *
138 : * Joint quantization routine for residual gains
139 : *------------------------------------------------------------------------*/
140 556644 : void stereo_dft_quantize_res_gains_fx(
141 : const Word32 *g, // Q31
142 : const Word32 *r, // Q31
143 : Word32 *gq, // Q31
144 : Word32 *rq, // Q31
145 : Word16 *ig,
146 : Word16 *ir )
147 : {
148 : Word8 sign;
149 : Word16 min_ind, i;
150 : Word32 min_val, old_val, gg, rr;
151 : Word16 level, index;
152 : Word32 ild; // Q25
153 : Word32 L_tmp;
154 : Word16 L_tmp_e;
155 :
156 556644 : gg = *g;
157 556644 : move32();
158 :
159 556644 : IF( rq != NULL )
160 : {
161 547822 : rr = *r;
162 547822 : move32();
163 : }
164 : ELSE
165 : {
166 8822 : rr = 0;
167 8822 : move32();
168 : }
169 :
170 556644 : IF( gg < 0 )
171 : {
172 352477 : gg = L_negate( gg );
173 352477 : sign = -1;
174 352477 : move16();
175 : }
176 : ELSE
177 : {
178 204167 : sign = 1;
179 204167 : move16();
180 : }
181 :
182 :
183 : // gg = min(gg, 1 - EPSILON);
184 : // rr = min(rr, sqrtf(1 - gg * gg) - EPSILON);
185 556644 : L_tmp = L_sub( MAX_32, Mpy_32_32( gg, gg ) );
186 556644 : L_tmp_e = 0;
187 556644 : move16();
188 556644 : L_tmp = Sqrt32( L_tmp, &L_tmp_e );
189 556644 : L_tmp = L_shl( L_tmp, L_tmp_e ); // Q31
190 556644 : rr = L_min( rr, L_tmp );
191 :
192 : /* we calculate the ILD ... */
193 : // ild = 10.f * log10f(((1 + gg) * (1 + gg) + rr * rr) / ((1 - gg) * (1 - gg) + rr * rr));
194 556644 : ild = L_add( Mpy_32_32( L_add( ONE_IN_Q30, L_shr( gg, 1 ) ), L_add( ONE_IN_Q30, L_shr( gg, 1 ) ) ), L_shr_r( Mpy_32_32( rr, rr ), 2 ) ); // Q29
195 556644 : ild = BASOP_Util_Log10( ild, 2 ); // Q25
196 556644 : L_tmp = L_add( L_shr( Mpy_32_32( L_sub( MAX_32, gg ), L_sub( MAX_32, gg ) ), 1 ), L_shr( Mpy_32_32( rr, rr ), 1 ) ); // Q30
197 556644 : L_tmp = BASOP_Util_Log10( L_tmp, 1 ); // Q25
198 556644 : ild = L_sub( ild, L_tmp );
199 556644 : ild = W_extract_h( W_shl( W_mult0_32_32( 10, ild ), 32 ) );
200 :
201 : /* ... which is truncated to the range [0,50] ... */
202 : // ild = ild > 50 ? 50 : ild;
203 556644 : ild = L_min( 1677721600 /*50*/, ild );
204 :
205 : /* ... and determine the optimal ILD quantization ...*/
206 556644 : min_ind = 0;
207 556644 : move16();
208 : // old_val = fabsf(ild_q[0] - ild);
209 556644 : old_val = L_abs( L_sub( ild_q_Q25[0], ild ) );
210 :
211 1595935 : FOR( i = 1; i < 16; i++ )
212 : {
213 : // min_val = fabsf(ild_q[i] - ild);
214 1594475 : min_val = L_abs( L_sub( ild_q_Q25[i], ild ) );
215 1594475 : IF( LT_32( min_val, old_val ) )
216 : {
217 1039291 : min_ind = i;
218 1039291 : move16();
219 : }
220 : ELSE
221 : {
222 555184 : BREAK;
223 : }
224 1039291 : old_val = min_val;
225 1039291 : move32();
226 : }
227 :
228 : /* ... which determines the quantization level: */
229 556644 : level = min_ind;
230 556644 : move16();
231 :
232 : /* Now we look for the closest quantization point in the corresponding column of res_gain_energy_q*/
233 : // old_val = FLT_MAX;
234 556644 : old_val = MAX_32;
235 556644 : move32();
236 556644 : min_ind = 0;
237 556644 : move16();
238 556644 : index = -1;
239 556644 : move16();
240 5009796 : FOR( i = 0; i < 8; i++ )
241 : {
242 : // 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]);
243 4453152 : min_val = L_add_sat( Mpy_32_32( L_sub( gg, dft_res_gains_q_fx[8 * level + i][0] ), L_sub( gg, dft_res_gains_q_fx[8 * level + i][0] ) ), Mpy_32_32( L_sub( rr, dft_res_gains_q_fx[8 * level + i][1] ), L_sub( rr, dft_res_gains_q_fx[8 * level + i][1] ) ) ); // saturation is expected
244 :
245 : // min_ind = min_val < old_val ? i : min_ind;
246 : // old_val = min_val < old_val ? min_val : old_val;
247 4453152 : IF( LT_32( min_val, old_val ) )
248 : {
249 1981487 : min_ind = i;
250 1981487 : move16();
251 1981487 : old_val = min_val;
252 1981487 : move32();
253 : }
254 :
255 4453152 : index = min_ind;
256 4453152 : move16();
257 : }
258 :
259 : /* and here we are: */
260 556644 : IF( rq != NULL )
261 : {
262 : //*gq = dft_res_gains_q[8 * level + index][0] * sign;
263 547822 : *gq = W_extract_l( W_mult0_32_32( dft_res_gains_q_fx[8 * level + index][0], sign ) );
264 547822 : move32();
265 : //*rq = dft_res_gains_q[8 * level + index][1];
266 547822 : *rq = dft_res_gains_q_fx[8 * level + index][1];
267 547822 : move32();
268 :
269 547822 : *ir = index;
270 547822 : move16();
271 : }
272 : //*ig = sign < 0 ? 15 - level : 15 + level;
273 556644 : IF( sign < 0 )
274 : {
275 352477 : *ig = sub( 15, level );
276 352477 : move16();
277 : }
278 : ELSE
279 : {
280 204167 : *ig = add( 15, level );
281 204167 : move16();
282 : }
283 :
284 556644 : return;
285 : }
286 :
287 :
288 : /*-------------------------------------------------------------------------
289 : * stereo_dft_quantize_ipd()
290 : *
291 : * Quantize the IPD between [-PI, PI] on 3 or 4 bits
292 : *------------------------------------------------------------------------*/
293 6560 : static void stereo_dft_quantize_ipd_fx(
294 : const Word32 *in, // Q13
295 : Word32 *out, // Q13
296 : Word16 *ind,
297 : const Word16 bits )
298 : {
299 : Word16 max_ind;
300 : Word32 delta;
301 : Word16 tmp, tmp_e;
302 :
303 6560 : IF( EQ_16( bits, 2 ) ) /* New 2-bit phase quantization for the highest frequency band only */
304 : {
305 297 : delta = EVS_PI_FX / 2;
306 297 : move16();
307 297 : max_ind = 3;
308 297 : move16();
309 : }
310 6263 : ELSE IF( EQ_16( bits, 3 ) )
311 : {
312 0 : delta = EVS_PI_FX / 4;
313 0 : move16();
314 0 : max_ind = 7;
315 0 : move16();
316 : }
317 6263 : ELSE IF( EQ_16( bits, 4 ) )
318 : {
319 6263 : delta = EVS_PI_FX / 8;
320 6263 : move16();
321 6263 : max_ind = 15;
322 6263 : move16();
323 : }
324 : ELSE
325 : {
326 0 : delta = EVS_PI_FX / 4;
327 0 : move16();
328 0 : max_ind = 7;
329 0 : move16();
330 0 : assert( 0 );
331 : }
332 :
333 : //*ind = (int16_t)(((*in + EVS_PI) / delta) + 0.5f);
334 6560 : tmp = BASOP_Util_Divide3232_Scale( L_add( *in, EVS_PI_FX ), delta, &tmp_e );
335 6560 : *ind = shr_r( tmp, sub( 15, tmp_e ) ); // Q0
336 6560 : move16();
337 :
338 : /*modulo 2*PI*/
339 6560 : if ( EQ_16( *ind, add( max_ind, 1 ) ) )
340 : {
341 105 : *ind = 0;
342 105 : move16();
343 : }
344 :
345 : /*Sanity check since no saturation can normally happen*/
346 6560 : *ind = s_min( s_max( *ind, 0 ), max_ind );
347 6560 : move16();
348 :
349 6560 : *out = L_sub( L_mult0( *ind, extract_l( delta ) ), EVS_PI_FX ); // Q13
350 6560 : move32();
351 :
352 6560 : return;
353 : }
354 :
355 : /*-------------------------------------------------------------------------
356 : * stereo_dft_enc_create()
357 : *
358 : * Create DFT stereo handle
359 : *------------------------------------------------------------------------*/
360 :
361 881 : ivas_error stereo_dft_enc_create_fx(
362 : STEREO_DFT_ENC_DATA_HANDLE *hStereoDft, /* i/o: encoder DFT stereo handle */
363 : const Word32 input_Fs, /* i : input sampling rate */
364 : const Word16 max_bwidth /* i : maximum encoded bandwidth */
365 : )
366 : {
367 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft_loc;
368 : Word16 tmpS;
369 :
370 881 : IF( *hStereoDft != NULL )
371 : {
372 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: DFT Stereo memory already allocated\n" );
373 : }
374 :
375 881 : IF( ( hStereoDft_loc = (STEREO_DFT_ENC_DATA_HANDLE) malloc( sizeof( STEREO_DFT_ENC_DATA ) ) ) == NULL )
376 : {
377 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DFT Stereo\n" ) );
378 : }
379 :
380 881 : IF( ( hStereoDft_loc->hConfig = (STEREO_DFT_CONFIG_DATA_HANDLE) malloc( sizeof( STEREO_DFT_CONFIG_DATA ) ) ) == NULL )
381 : {
382 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for DFT Stereo Config\n" ) );
383 : }
384 :
385 881 : IF( ( hStereoDft_loc->hItd = (ITD_DATA_HANDLE) malloc( sizeof( ITD_DATA ) ) ) == NULL )
386 : {
387 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for ITD data\n" ) );
388 : }
389 :
390 881 : hStereoDft_loc->hConfig->force_mono_transmission = 0;
391 881 : move16();
392 :
393 881 : stereo_dft_config_fx( hStereoDft_loc->hConfig, IVAS_24k4, &tmpS, &tmpS );
394 :
395 881 : stereo_dft_enc_open_fx( hStereoDft_loc, input_Fs, max_bwidth );
396 :
397 881 : stereo_dft_hybrid_ITD_flag_fx( hStereoDft_loc->hConfig, input_Fs,
398 881 : hStereoDft_loc->hItd->hybrid_itd_max );
399 :
400 881 : *hStereoDft = hStereoDft_loc;
401 :
402 881 : return IVAS_ERR_OK;
403 : }
404 :
405 :
406 : /*-------------------------------------------------------------------------
407 : * stereo_dft_enc_open()
408 : *
409 : * Initialize DFT stereo handle
410 : *------------------------------------------------------------------------*/
411 :
412 881 : static void stereo_dft_enc_open_fx(
413 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder DFT stereo handle */
414 : const Word32 input_Fs, /* i : input sampling rate */
415 : const Word16 max_bwidth /* i : maximum encoded bandwidth */
416 : )
417 : {
418 : Word16 NFFT_inner;
419 : PWord16 win_p[STEREO_DFT_OVL_MAX];
420 : Word16 win[STEREO_DFT_OVL_MAX];
421 : Word32 L_tmp;
422 : Word16 tmp, tmp_e;
423 :
424 : /*Sizes*/
425 :
426 881 : hStereoDft->N = extract_l( Mpy_32_32( input_Fs, 42949673 /* STEREO_DFT_HOP_MAX_ENC / 48000 in Q31 */ ) );
427 881 : move16();
428 881 : assert( ( ( input_Fs / FRAMES_PER_SEC ) / hStereoDft->N ) == 1 );
429 :
430 : /*Init. DFT sizes*/
431 881 : hStereoDft->NFFT = extract_l( Mpy_32_32( input_Fs, 85899346 /* STEREO_DFT_N_MAX_ENC / 48000 in Q31 */ ) );
432 881 : move16();
433 881 : hStereoDft->dft_ovl = extract_l( Mpy_32_32( input_Fs, 18790482 /* STEREO_DFT_OVL_MAX / 48000 in Q31 */ ) );
434 881 : move16();
435 881 : mdct_window_sine_IVAS_updated( win_p, input_Fs, hStereoDft->dft_ovl, FULL_OVERLAP, IVAS_CPE_DFT ); // win_e = 15
436 170841 : FOR( Word16 i = 0; i < ( hStereoDft->dft_ovl / 2 ); i++ )
437 : {
438 169960 : win[hStereoDft->dft_ovl - 1 - i] = win_p[i].v.re;
439 169960 : move16();
440 169960 : win[i] = win_p[i].v.im;
441 169960 : move16();
442 : }
443 :
444 881 : L_tmp = L_shl( L_sub( hStereoDft->N, hStereoDft->dft_ovl ), Q15 ); /* Q15 */
445 881 : L_tmp = L_add( L_tmp, L_shl( sum16_32_fx( win, hStereoDft->dft_ovl ), 1 ) ); /* Q15 */
446 881 : tmp = BASOP_Util_Divide3232_Scale( L_tmp, hStereoDft->NFFT, &tmp_e );
447 881 : tmp_e = sub( tmp_e, 15 );
448 881 : hStereoDft->win_ana_energy_fx = shl( tmp, tmp_e ); /* Q15 */
449 881 : move16();
450 :
451 881 : set32_fx( hStereoDft->output_mem_dmx_32k_fx, 0, STEREO_DFT_OVL_32k );
452 :
453 881 : hStereoDft->dft_zp = extract_l( Mpy_32_32( input_Fs, 12079596 /* STEREO_DFT_ZP_MAX_ENC / 48000 in Q31 */ ) );
454 881 : move16();
455 :
456 881 : hStereoDft->dft_trigo_8k_fx = dft_trigo_32k_fx;
457 881 : hStereoDft->dft_trigo_12k8_fx = dft_trigo_12k8_fx;
458 881 : hStereoDft->dft_trigo_16k_fx = dft_trigo_32k_fx;
459 881 : hStereoDft->dft_trigo_32k_fx = dft_trigo_32k_fx;
460 :
461 881 : hStereoDft->win_ana_8k_fx = win_ana_8k_fx;
462 881 : hStereoDft->win_ana_12k8_fx = win_ana_12k8_fx;
463 881 : hStereoDft->win_ana_16k_fx = win_ana_16k_fx;
464 881 : hStereoDft->win_ana_32k_fx = win_ana_32k_fx;
465 :
466 881 : hStereoDft->win_8k_fx = win_syn_8k_fx;
467 881 : hStereoDft->win_12k8_fx = win_syn_12k8_fx;
468 881 : hStereoDft->win_16k_fx = win_syn_16k_fx;
469 881 : hStereoDft->win_32k_fx = win_syn_32k_fx;
470 :
471 881 : IF( EQ_32( input_Fs, 16000 ) )
472 : {
473 25 : hStereoDft->dft_trigo_fx = dft_trigo_32k_fx;
474 25 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
475 25 : move16();
476 25 : hStereoDft->win_ana_fx = win_ana_16k_fx;
477 25 : hStereoDft->win_fx = win_syn_16k_fx;
478 : }
479 856 : ELSE IF( EQ_32( input_Fs, 32000 ) )
480 : {
481 165 : hStereoDft->dft_trigo_fx = dft_trigo_32k_fx;
482 165 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
483 165 : move16();
484 165 : hStereoDft->win_ana_fx = win_ana_32k_fx;
485 165 : hStereoDft->win_fx = win_syn_32k_fx;
486 : }
487 : ELSE
488 : {
489 691 : assert( EQ_32( input_Fs, 48000 ) );
490 691 : hStereoDft->dft_trigo_fx = dft_trigo_48k_fx;
491 691 : hStereoDft->dft_trigo_step = STEREO_DFT_TRIGO_SRATE_48k_STEP;
492 691 : move16();
493 691 : hStereoDft->win_ana_fx = win_ana_48k_fx;
494 691 : hStereoDft->win_fx = win_syn_48k_fx;
495 : }
496 :
497 881 : hStereoDft->win_mdct_8k_fx = win_mdct_8k_fx;
498 :
499 : /*I/O Buffers*/
500 881 : set_zero_fx( hStereoDft->output_mem_dmx_fx, STEREO_DFT_OVL_MAX );
501 881 : set_zero_fx( hStereoDft->output_mem_dmx_12k8_fx, STEREO_DFT_OVL_12k8 );
502 881 : set_zero_fx( hStereoDft->output_mem_dmx_16k_fx, STEREO_DFT_OVL_16k );
503 881 : set_zero_fx( hStereoDft->output_mem_dmx_16k_shb_fx, STEREO_DFT_OVL_16k );
504 881 : set_zero_fx( hStereoDft->output_mem_res_8k_fx, STEREO_DFT_OVL_8k );
505 :
506 : /*Bands: find the number of bands, Nyquist freq. is not taken into account*/
507 : /* NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[max_bwidth] / L_FRAME48k; */
508 881 : NFFT_inner = imult1616( inner_frame_tbl[max_bwidth], STEREO_DFT_N_MAX_ENC / L_FRAME48k );
509 881 : hStereoDft->nbands = stereo_dft_band_config_fx( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
510 881 : hStereoDft->nbands_dmx = stereo_dft_band_config_fx( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
511 881 : move16();
512 881 : move16();
513 :
514 : /*Set configuration*/
515 881 : set16_fx( hStereoDft->band_res, hStereoDft->hConfig->band_res, STEREO_DFT_ENC_DFT_NB );
516 881 : test();
517 881 : IF( hStereoDft->hConfig->ada_wb_res_cod_mode && EQ_16( hStereoDft->NFFT, STEREO_DFT_N_16k_ENC ) )
518 : {
519 : /* residual coding is only applied for 16 kHz sampling rate */
520 0 : set16_fx( hStereoDft->res_cod_mode, hStereoDft->hConfig->ada_wb_res_cod_mode, STEREO_DFT_ENC_DFT_NB );
521 : }
522 : ELSE
523 : {
524 881 : set16_fx( hStereoDft->res_cod_mode, hStereoDft->hConfig->res_cod_mode, STEREO_DFT_ENC_DFT_NB );
525 : }
526 881 : set16_fx( hStereoDft->res_pred_mode, hStereoDft->hConfig->res_pred_mode, STEREO_DFT_ENC_DFT_NB );
527 :
528 : /* reset DFT stereo memories */
529 881 : stereo_dft_enc_reset_fx( hStereoDft );
530 :
531 881 : return;
532 : }
533 :
534 :
535 : /*-------------------------------------------------------------------------
536 : * stereo_dft_enc_reset()
537 : *
538 : * Reset DFT stereo memories
539 : *------------------------------------------------------------------------*/
540 :
541 1663 : void stereo_dft_enc_reset_fx(
542 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft /* i/o: encoder stereo handle */
543 : )
544 : {
545 : Word16 i;
546 : /*reset parameters*/
547 1663 : set_zero_fx( hStereoDft->side_gain_fx, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
548 1663 : set16_fx( hStereoDft->side_gain_index_EC, 15, STEREO_DFT_BAND_MAX );
549 1663 : set16_fx( hStereoDft->side_gain_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
550 1663 : set16_fx( hStereoDft->side_gain_index_ECprevious, 15, STEREO_DFT_BAND_MAX );
551 1663 : hStereoDft->side_gain_counter = 0;
552 1663 : move16();
553 1663 : hStereoDft->side_gain_bitdiff_lp_fx = STEREO_DFT_BITDIFF_INIT_FX;
554 1663 : move16();
555 1663 : hStereoDft->q_side_gain_bitdiff_lp = Q10;
556 1663 : move16();
557 1663 : set_zero_fx( hStereoDft->gipd_fx, STEREO_DFT_ENC_DFT_NB );
558 1663 : set_zero_fx( hStereoDft->dot_prod_real_smooth_fx, STEREO_DFT_BAND_MAX );
559 1663 : set16_zero_fx( hStereoDft->dot_prod_real_smooth_fx_e, STEREO_DFT_BAND_MAX );
560 1663 : set_zero_fx( hStereoDft->dot_prod_img_smooth_fx, STEREO_DFT_BAND_MAX );
561 1663 : set16_zero_fx( hStereoDft->dot_prod_img_smooth_fx_e, STEREO_DFT_BAND_MAX );
562 23282 : FOR( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
563 : {
564 21619 : set_zero_fx( hStereoDft->ipd_buf_fx[i], STEREO_DFT_IPD_BUF_LEN );
565 : }
566 1663 : hStereoDft->prev_gipd_fx = 0;
567 1663 : move32();
568 1663 : hStereoDft->gipd_index = 0;
569 1663 : move16();
570 1663 : set_zero_fx( hStereoDft->res_pred_gain_fx, STEREO_DFT_ENC_DFT_NB * STEREO_DFT_BAND_MAX );
571 1663 : set16_fx( hStereoDft->res_pred_index_EC, 0, STEREO_DFT_BAND_MAX );
572 1663 : set16_fx( hStereoDft->res_pred_index_ECDiff, 0, STEREO_DFT_BAND_MAX );
573 1663 : set16_fx( hStereoDft->res_pred_index_ECprevious, 0, STEREO_DFT_BAND_MAX );
574 1663 : hStereoDft->res_pred_counter = 0;
575 1663 : move16();
576 1663 : set_zero_fx( hStereoDft->past_nrgL_fx, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
577 1663 : set16_zero_fx( hStereoDft->past_nrgL_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
578 1663 : set_zero_fx( hStereoDft->past_nrgR_fx, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
579 1663 : set16_zero_fx( hStereoDft->past_nrgR_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
580 1663 : set_zero_fx( hStereoDft->past_dot_prod_real_fx, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
581 1663 : set16_zero_fx( hStereoDft->past_dot_prod_real_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
582 1663 : set_zero_fx( hStereoDft->past_dot_prod_imag_fx, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
583 1663 : set16_zero_fx( hStereoDft->past_dot_prod_imag_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX );
584 :
585 1663 : hStereoDft->nrg_past_pos = 0;
586 1663 : move16();
587 :
588 1663 : hStereoDft->res_dmx_ratio_lt_fx = MAX_32;
589 1663 : move32();
590 1663 : hStereoDft->hangover_cnt0 = 0;
591 1663 : move16();
592 1663 : hStereoDft->hangover_cnt1 = 0;
593 1663 : move16();
594 1663 : hStereoDft->dmx_res_all_prev_fx = 1;
595 1663 : move32();
596 1663 : hStereoDft->dmx_res_all_prev_fx_e = 31;
597 1663 : move16();
598 1663 : hStereoDft->last_res_cod_mode_modify_flag = 0;
599 1663 : move16();
600 1663 : hStereoDft->res_cod_sw_flag = 0;
601 1663 : move16();
602 1663 : hStereoDft->switch_fade_factor_fx = ONE_IN_Q14; // Q15/2
603 1663 : move16();
604 1663 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1] = STEREO_DFT_RES_COD_1kHz;
605 1663 : move16();
606 23282 : FOR( i = 0; i < STEREO_DFT_BAND_MAX; i++ )
607 : {
608 21619 : hStereoDft->res_cod_NRG_M_fx[i] = 0;
609 21619 : move32();
610 21619 : hStereoDft->res_cod_NRG_M_fx_e[i] = 0;
611 21619 : move16();
612 21619 : hStereoDft->res_cod_NRG_S_fx[i] = 0;
613 21619 : move32();
614 21619 : hStereoDft->res_cod_NRG_S_fx_e[i] = 0;
615 21619 : move16();
616 : }
617 1663 : hStereoDft->old_snr_fx = 0;
618 1663 : move32();
619 :
620 :
621 1663 : hStereoDft->reverb_flag = 0;
622 1663 : move16();
623 1663 : set_zero_fx( hStereoDft->pre_sub_nrg_DMX_fx, STEREO_DFT_BAND_MAX );
624 1663 : set16_zero_fx( hStereoDft->pre_sub_nrg_DMX_fx_e, STEREO_DFT_BAND_MAX );
625 1663 : hStereoDft->diff_l_h_sm_fx = 0;
626 1663 : move32();
627 1663 : hStereoDft->diff_l_h_sm_fx_e = 0;
628 1663 : move16();
629 1663 : hStereoDft->diff_r_h_sm_fx = 0;
630 1663 : move32();
631 1663 : hStereoDft->diff_r_h_sm_fx_e = 0;
632 1663 : move16();
633 1663 : hStereoDft->prev_fac2_fx = MAX_32;
634 1663 : move32();
635 :
636 1663 : set_zero_fx( hStereoDft->res_pred_gain_f_fx, STEREO_DFT_BAND_MAX );
637 :
638 : /*misc*/
639 1663 : hStereoDft->no_ipd_flag = 1; /* Initialization of the no IPD variables */
640 1663 : move16();
641 1663 : hStereoDft->prev_no_ipd_flag = 1;
642 1663 : move16();
643 1663 : hStereoDft->no_ipd_cnt = 0;
644 1663 : move16();
645 1663 : hStereoDft->no_ipd_cnt1 = 0;
646 1663 : move16();
647 1663 : hStereoDft->attackPresent = 0;
648 1663 : move16();
649 1663 : hStereoDft->wasTransient = 0;
650 1663 : move16();
651 1663 : hStereoDft->gainIPD_sm_fx = MAX_32;
652 1663 : move32();
653 :
654 :
655 1663 : hStereoDft->voicing_lt_fx = 0;
656 1663 : move32();
657 :
658 1663 : hStereoDft->flip_sign = 1;
659 1663 : move16();
660 :
661 1663 : hStereoDft->sfm_fx = 0;
662 1663 : move32();
663 1663 : hStereoDft->sum_dot_prod_real_fx = 0;
664 1663 : move32();
665 1663 : hStereoDft->sum_dot_prod_real_fx_e = 0;
666 1663 : move16();
667 1663 : hStereoDft->sum_dot_prod_img_fx = 0;
668 1663 : move32();
669 1663 : hStereoDft->sum_dot_prod_img_fx_e = 0;
670 1663 : move16();
671 :
672 : /*Coherence*/
673 1663 : set32_fx( hStereoDft->xspec_smooth_fx, MAX_32, STEREO_DFT_N_32k_ENC );
674 1663 : set16_fx( hStereoDft->xspec_smooth_fx_e, 0, STEREO_DFT_N_32k_ENC );
675 1663 : set32_fx( hStereoDft->Spd_L_smooth_fx, MAX_32, STEREO_DFT_N_32k_ENC / 2 );
676 1663 : hStereoDft->Spd_L_smooth_fx_e = 0;
677 1663 : move16();
678 1663 : set32_fx( hStereoDft->Spd_R_smooth_fx, MAX_32, STEREO_DFT_N_32k_ENC / 2 );
679 1663 : hStereoDft->Spd_R_smooth_fx_e = 0;
680 1663 : move16();
681 :
682 1663 : hStereoDft->currentNumUpdates = 0;
683 1663 : move16();
684 1663 : hStereoDft->expectedNumUpdates = FIXED_SID_RATE;
685 1663 : move16();
686 1663 : hStereoDft->resetFrames = 0;
687 1663 : move16();
688 1663 : hStereoDft->sid_gipd_fx = 0;
689 1663 : move32();
690 1663 : hStereoDft->prev_sid_gipd_fx = 0;
691 1663 : move32();
692 1663 : hStereoDft->prev_sid_no_ipd_flag = 1;
693 1663 : move16();
694 :
695 1663 : hStereoDft->coh_fade_counter = 0;
696 1663 : move16();
697 :
698 : /* Xtalk classifier */
699 1663 : hStereoDft->hItd->prev_m1_fx = 0;
700 1663 : move32();
701 1663 : hStereoDft->hItd->prev_m2_fx = 0;
702 1663 : move32();
703 1663 : hStereoDft->hItd->prev_itd1 = 0;
704 1663 : move16();
705 1663 : hStereoDft->hItd->prev_itd2 = 0;
706 1663 : move16();
707 :
708 1663 : hStereoDft->first_frm_flag = 1;
709 1663 : move16();
710 :
711 :
712 1663 : stereo_enc_itd_init_fx( hStereoDft->hItd );
713 :
714 1663 : return;
715 : }
716 :
717 :
718 : /*-------------------------------------------------------------------------
719 : * stereo_enc_itd_init()
720 : *
721 : * initialize ITD struct
722 : *------------------------------------------------------------------------*/
723 :
724 1814 : void stereo_enc_itd_init_fx(
725 : ITD_DATA_HANDLE hItd /* i/o: encoder ITD handle */
726 : )
727 : {
728 1814 : hItd->prev_itd = 0;
729 1814 : move16();
730 1814 : set32_fx( hItd->itd_fx, 0, STEREO_DFT_ENC_DFT_NB );
731 1814 : set32_fx( hItd->deltaItd_fx, 0, STEREO_DFT_ENC_DFT_NB );
732 1814 : set16_fx( hItd->td_itd, 0, STEREO_DFT_ENC_DFT_NB );
733 1814 : set16_fx( hItd->td_itd_32k, 0, STEREO_DFT_ENC_DFT_NB );
734 1814 : set16_fx( hItd->itd_index, 0, STEREO_DFT_ENC_DFT_NB );
735 1814 : set32_fx( hItd->xcorr_smooth_fx, 0, STEREO_DFT_N_32k_ENC );
736 1814 : set16_fx( hItd->xcorr_smooth_fx_e, 0, STEREO_DFT_N_32k_ENC );
737 1814 : hItd->lp_phat_peak_fx = 0;
738 1814 : move32();
739 1814 : hItd->itd_hangover = 0;
740 1814 : move16();
741 1814 : hItd->itd_cnt = 0;
742 1814 : move16();
743 1814 : hItd->prev_sum_nrg_L_lb_fx = 0;
744 1814 : move32();
745 1814 : hItd->prev_sum_nrg_L_lb_fx_e = 0;
746 1814 : move16();
747 1814 : set32_fx( hItd->prev_xcorr_lb_fx, 0, STEREO_DFT_XCORR_LB_MAX );
748 1814 : hItd->prev_xcorr_lb_fx_e = 0;
749 1814 : move16();
750 1814 : set32_fx( hItd->E_band_n_fx, ITD_VAD_E_BAND_N_INIT, STEREO_DFT_ITD_VAD_BAND_NUM );
751 1814 : set16_fx( hItd->E_band_n_exp, Q31, STEREO_DFT_ITD_VAD_BAND_NUM );
752 1814 : hItd->vad_frm_cnt = 0;
753 1814 : move16();
754 1814 : hItd->pre_vad = 0;
755 1814 : move16();
756 1814 : hItd->itd_nonzero_cnt = 0;
757 1814 : move16();
758 1814 : set32_fx( hItd->acorr_L_fx, 0, STEREO_DFT_BAND_MAX );
759 1814 : hItd->acorr_L_fx_e = 0;
760 1814 : move16();
761 1814 : set32_fx( hItd->acorr_R_fx, 0, STEREO_DFT_BAND_MAX );
762 1814 : hItd->acorr_R_fx_e = 0;
763 1814 : move16();
764 1814 : hItd->cohSNR_fx = 983040; /*Q16*/
765 1814 : move32();
766 1814 : hItd->itd_thres_fx = 0;
767 1814 : move32();
768 1814 : hItd->valid_itd_cnt = 0;
769 1814 : move16();
770 1814 : hItd->detected_itd_flag = 0;
771 1814 : move16();
772 1814 : hItd->itd_tracking = 0;
773 1814 : move16();
774 1814 : hItd->prev_max_fx = 0;
775 1814 : move32();
776 1814 : hItd->prev_index = 0;
777 1814 : move16();
778 1814 : hItd->prev_avg_max_fx = 0;
779 1814 : move32();
780 1814 : hItd->prev_avg_max_fx_e = 0;
781 1814 : move16();
782 1814 : hItd->currFlatness_fx = 0;
783 1814 : move16();
784 : /* Xtalk classifier */
785 1814 : hItd->prev_m1_fx = 0;
786 1814 : move32();
787 1814 : hItd->prev_m2_fx = 0;
788 1814 : move32();
789 1814 : hItd->prev_itd1 = 0;
790 1814 : move16();
791 1814 : hItd->prev_itd2 = 0;
792 1814 : move16();
793 1814 : hItd->hybrid_itd_max = 0;
794 1814 : move16();
795 1814 : return;
796 : }
797 :
798 :
799 : /*--------------------------------------------------------------------------
800 : * stereo_dft_enc_update()
801 : *
802 : * Update DFT stereo memories for new frame
803 : *--------------------------------------------------------------------------*/
804 :
805 59643 : void stereo_dft_enc_update_fx(
806 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
807 : const Word16 max_bwidth /* i : maximum encoded bandwidth */
808 : )
809 : {
810 : Word16 i, k_offset;
811 : Word16 NFFT_inner;
812 :
813 : /* Initialization */
814 59643 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
815 59643 : move32();
816 :
817 : /* Update the parameters and serial */
818 835002 : FOR( i = 0; i < ( k_offset * STEREO_DFT_BAND_MAX ); i++ )
819 : {
820 775359 : hStereoDft->side_gain_fx[i] = hStereoDft->side_gain_fx[STEREO_DFT_BAND_MAX + i];
821 775359 : move32();
822 775359 : hStereoDft->res_pred_gain_fx[i] = hStereoDft->res_pred_gain_fx[STEREO_DFT_BAND_MAX + i];
823 775359 : move32();
824 : }
825 :
826 119286 : FOR( i = 0; i < k_offset; i++ )
827 : {
828 59643 : hStereoDft->gipd_fx[i] = hStereoDft->gipd_fx[i + 1];
829 59643 : move32();
830 : }
831 :
832 : /*Update configurations*/
833 119286 : FOR( i = 0; i < k_offset; i++ )
834 : {
835 59643 : hStereoDft->band_res[i] = hStereoDft->band_res[i + 1];
836 59643 : move16();
837 59643 : hStereoDft->hItd->itd_fx[i] = hStereoDft->hItd->itd_fx[i + 1];
838 59643 : move32();
839 59643 : hStereoDft->res_cod_mode[i] = hStereoDft->res_cod_mode[i + 1];
840 59643 : move16();
841 59643 : hStereoDft->res_pred_mode[i] = hStereoDft->res_pred_mode[i + 1];
842 59643 : move16();
843 : }
844 :
845 : /*Set new configurations*/
846 59643 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
847 59643 : move16();
848 :
849 59643 : IF( hStereoDft->hConfig->ada_wb_res_cod_mode && EQ_16( hStereoDft->NFFT, STEREO_DFT_N_16k_ENC ) )
850 : {
851 2796 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->ada_wb_res_cod_mode;
852 2796 : move16();
853 : }
854 : ELSE
855 : {
856 56847 : hStereoDft->res_cod_mode[k_offset] = hStereoDft->hConfig->res_cod_mode;
857 56847 : move16();
858 : }
859 59643 : hStereoDft->res_pred_mode[k_offset] = hStereoDft->hConfig->res_pred_mode;
860 59643 : move16();
861 :
862 59643 : hStereoDft->last_res_cod_mode_modify_flag = hStereoDft->res_cod_sw_flag;
863 59643 : move16();
864 59643 : hStereoDft->res_cod_sw_flag = 0;
865 59643 : move16();
866 :
867 : /* update band limits in case of rate switching assuming max_bwidth as BWD output not yet know here */
868 59643 : NFFT_inner = shl( inner_frame_tbl[max_bwidth], 1 ) /* * STEREO_DFT_N_MAX_ENC / L_FRAME48k*/;
869 :
870 59643 : hStereoDft->nbands = stereo_dft_band_config_fx( hStereoDft->band_limits, hStereoDft->hConfig->band_res, NFFT_inner, ENC );
871 59643 : move16();
872 59643 : hStereoDft->nbands_dmx = stereo_dft_band_config_fx( hStereoDft->band_limits_dmx, 1, NFFT_inner, ENC );
873 59643 : move16();
874 :
875 : /*Compute main parameters*/
876 59643 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
877 59643 : move16();
878 59643 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
879 59643 : move16();
880 : // 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 ) );
881 59643 : Word32 tmp = L_shl( L_mult0( sub( hStereoDft->band_limits[hStereoDft->res_cod_band_max], 1 ), hStereoDft->N ), 1 );
882 : Word16 exp;
883 59643 : tmp = BASOP_Util_Divide3232_Scale_newton( tmp, hStereoDft->NFFT, &exp );
884 59643 : hStereoDft->res_cod_line_max = extract_l( L_shr( tmp, sub( 31, exp ) ) );
885 59643 : move16();
886 : // hStereoDft->res_cod_line_max = 8 * (hStereoDft->res_cod_line_max / 8);
887 59643 : hStereoDft->res_cod_line_max = shl( shr( hStereoDft->res_cod_line_max, 3 ), 3 );
888 59643 : move16();
889 59643 : hStereoDft->res_pred_band_min = s_max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
890 59643 : move16();
891 :
892 :
893 59643 : return;
894 : }
895 :
896 : /*-------------------------------------------------------------------------
897 : * stereo_dft_enc_destroy()
898 : *
899 : * destroy DFT stereo handle
900 : *-------------------------------------------------------------------------*/
901 :
902 881 : void stereo_dft_enc_destroy_fx(
903 : STEREO_DFT_ENC_DATA_HANDLE *hStereoDft /* i/o: encoder DFT stereo handle */
904 : )
905 : {
906 881 : IF( ( *hStereoDft )->hConfig != NULL )
907 : {
908 881 : free( ( *hStereoDft )->hConfig );
909 881 : ( *hStereoDft )->hConfig = NULL;
910 : }
911 :
912 881 : IF( ( *hStereoDft )->hItd != NULL )
913 : {
914 881 : free( ( *hStereoDft )->hItd );
915 881 : ( *hStereoDft )->hItd = NULL;
916 : }
917 :
918 881 : free( *hStereoDft );
919 881 : *hStereoDft = NULL;
920 :
921 881 : return;
922 : }
923 :
924 :
925 : /*-------------------------------------------------------------------------
926 : * stereo_dft_enc_analyze()
927 : *
928 : * DFT analysis on a 20ms frame
929 : *-------------------------------------------------------------------------*/
930 74333 : void stereo_dft_enc_analyze_fx(
931 : Encoder_State **sts, /* i/o: encoder state structure */
932 : const Word16 n_channels, /* i : number of input channels */
933 : const Word16 input_frame, /* i : input frame length */
934 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
935 : STEREO_MDCT_ENC_DATA_HANDLE hStereoMdct, /* i/o: encoder MDCT stereo handle */
936 : Word32 DFT[CPE_CHANNELS][STEREO_DFT_N_MAX_ENC], /* o : DFT buffers Q(31-DFT_e) */
937 : Word16 DFT_e[CPE_CHANNELS], /* o : DFT buffers */
938 : Word16 *input_mem[CPE_CHANNELS], /* i/o: input buffer memory Q(q_input_mem_ */
939 : Word16 *q_input_mem )
940 : {
941 : Word16 i, n;
942 : Word32 *pDFT_L, *pDFT_R;
943 : Word16 N, NFFT;
944 : Word16 dft_zp, dft_ovl;
945 : const Word16 *pWin;
946 : const Word16 *pTrigo;
947 : Word16 offset;
948 : Word16 *input[CPE_CHANNELS], *mem[CPE_CHANNELS];
949 : Word16 trigo_enc[STEREO_DFT_N_MAX_ENC / 2 + 1];
950 : Word16 trigo_step;
951 :
952 :
953 74333 : push_wmops( "DFT_analysis" );
954 :
955 : /*-----------------------------------------------------------------*
956 : * Initialization
957 : *-----------------------------------------------------------------*/
958 :
959 222999 : FOR( n = 0; n < n_channels; n++ )
960 : {
961 148666 : input[n] = sts[n]->input_fx;
962 148666 : mem[n] = input_mem[n];
963 : }
964 :
965 :
966 : /*-----------------------------------------------------------------*
967 : * DFT Analysis
968 : *-----------------------------------------------------------------*/
969 :
970 74333 : pDFT_L = DFT[0];
971 74333 : pDFT_R = DFT[1];
972 :
973 74333 : IF( hStereoDft != NULL )
974 : {
975 59643 : N = hStereoDft->N;
976 59643 : move16();
977 59643 : NFFT = hStereoDft->NFFT;
978 59643 : move16();
979 59643 : dft_zp = hStereoDft->dft_zp;
980 59643 : move16();
981 59643 : dft_ovl = hStereoDft->dft_ovl;
982 59643 : move16();
983 59643 : offset = negate( dft_ovl );
984 59643 : pWin = hStereoDft->win_ana_fx;
985 59643 : pTrigo = hStereoDft->dft_trigo_fx;
986 59643 : trigo_step = hStereoDft->dft_trigo_step;
987 59643 : move16();
988 : }
989 : ELSE
990 : {
991 14690 : N = hStereoMdct->hDft_ana->N;
992 14690 : move16();
993 14690 : NFFT = hStereoMdct->hDft_ana->NFFT;
994 14690 : move16();
995 14690 : dft_zp = hStereoMdct->hDft_ana->dft_zp;
996 14690 : move16();
997 14690 : dft_ovl = hStereoMdct->hDft_ana->dft_ovl;
998 14690 : move16();
999 14690 : offset = negate( dft_ovl );
1000 14690 : pWin = hStereoMdct->hDft_ana->win_ana_fx;
1001 14690 : pTrigo = hStereoMdct->hDft_ana->dft_trigo_fx;
1002 14690 : trigo_step = hStereoMdct->hDft_ana->dft_trigo_step;
1003 14690 : move16();
1004 : }
1005 :
1006 25103933 : FOR( i = 0; i < shr( NFFT, 2 ); i++ )
1007 : {
1008 25029600 : trigo_enc[i] = pTrigo[i * trigo_step];
1009 25029600 : move16();
1010 25029600 : trigo_enc[( ( NFFT / 2 ) - i )] = pTrigo[L_mult0( i, trigo_step )];
1011 25029600 : move16();
1012 : }
1013 74333 : trigo_enc[NFFT / 4] = pTrigo[( ( NFFT / 4 ) * trigo_step )];
1014 74333 : move16();
1015 :
1016 : /*Forwards FFT: L and R*/
1017 : /*zero padding*/
1018 14153483 : FOR( i = 0; i < dft_zp; i++ )
1019 : {
1020 14079150 : pDFT_L[i] = 0;
1021 14079150 : move32();
1022 14079150 : pDFT_L[( ( NFFT - 1 ) - i )] = 0;
1023 14079150 : move32();
1024 :
1025 14079150 : pDFT_R[i] = 0;
1026 14079150 : move32();
1027 14079150 : pDFT_R[( ( NFFT - 1 ) - i )] = 0;
1028 14079150 : move32();
1029 : }
1030 :
1031 222999 : FOR( n = 0; n < n_channels; n++ )
1032 : {
1033 148666 : Scale_sig( &mem[n][0], dft_ovl, sts[n]->q_inp - q_input_mem[n] ); // Q(sts[n]->q_inp)
1034 148666 : q_input_mem[n] = sts[n]->q_inp;
1035 148666 : move16();
1036 : }
1037 : /*overlapping parts*/
1038 21975233 : FOR( i = 0; i < dft_ovl; i++ )
1039 : {
1040 21900900 : pDFT_L[( dft_zp + i )] = L_mult0( mem[0][i], pWin[i] );
1041 21900900 : move32();
1042 21900900 : pDFT_L[( ( ( dft_zp + N ) + dft_ovl ) - 1 - i )] = L_mult0( input[0][offset + N + dft_ovl - 1 - i], pWin[i] );
1043 21900900 : move32();
1044 :
1045 21900900 : pDFT_R[dft_zp + i] = L_mult0( mem[1][i], pWin[i] );
1046 21900900 : move32();
1047 21900900 : pDFT_R[( ( dft_zp + N ) + dft_ovl ) - 1 - i] = L_mult0( input[1][offset + N + dft_ovl - 1 - i], pWin[i] );
1048 21900900 : move32();
1049 : }
1050 :
1051 : /*middle part*/
1052 28232633 : FOR( i = 0; i < N - dft_ovl; i++ )
1053 : {
1054 28158300 : pDFT_L[dft_zp + dft_ovl + i] = L_shr( L_deposit_h( input[0][offset + dft_ovl + i] ), 1 );
1055 28158300 : move32();
1056 :
1057 28158300 : pDFT_R[dft_zp + dft_ovl + i] = L_shr( L_deposit_h( input[1][offset + dft_ovl + i] ), 1 );
1058 28158300 : move32();
1059 : }
1060 74333 : DFT_e[0] = sub( 31, add( 15, sts[0]->q_inp ) );
1061 74333 : move16();
1062 74333 : DFT_e[1] = sub( 31, add( 15, sts[1]->q_inp ) );
1063 74333 : move16();
1064 :
1065 : Word16 q_shift, guarded_bits;
1066 74333 : guarded_bits = find_guarded_bits_fx( NFFT );
1067 :
1068 74333 : q_shift = sub( L_norm_arr( pDFT_L, NFFT ), guarded_bits );
1069 74333 : scale_sig32( pDFT_L, NFFT, q_shift );
1070 74333 : DFT_e[0] = sub( DFT_e[0], q_shift );
1071 74333 : move16();
1072 :
1073 74333 : q_shift = sub( L_norm_arr( pDFT_R, NFFT ), guarded_bits );
1074 74333 : scale_sig32( pDFT_R, NFFT, q_shift );
1075 74333 : DFT_e[1] = sub( DFT_e[1], q_shift );
1076 74333 : move16();
1077 :
1078 74333 : rfft_fx( pDFT_L, trigo_enc, NFFT, -1 );
1079 74333 : rfft_fx( pDFT_R, trigo_enc, NFFT, -1 );
1080 :
1081 : /* update pointers to overlap memory */
1082 222999 : FOR( n = 0; n < n_channels; n++ )
1083 : {
1084 148666 : mem[n] = &input[n][sub( N, dft_ovl )];
1085 : }
1086 74333 : test();
1087 74333 : test();
1088 74333 : IF( hStereoDft != NULL && hStereoDft->hConfig->hybrid_itd_flag && hStereoDft->hItd->td_itd[STEREO_DFT_OFFSET] )
1089 : {
1090 36384 : FOR( n = 0; n < n_channels; n++ )
1091 : {
1092 24256 : Scale_sig( hStereoDft->input_mem_itd_fx[n], dft_ovl, sub( sts[n]->q_inp, hStereoDft->q_input_mem_itd[n] ) ); // Q(sts[n]->q_inp)
1093 24256 : hStereoDft->q_input_mem_itd[n] = sts[n]->q_inp;
1094 24256 : move16();
1095 24256 : Copy( hStereoDft->input_mem_itd_fx[n], input_mem[n], dft_ovl );
1096 : }
1097 : }
1098 : ELSE
1099 : {
1100 186615 : FOR( n = 0; n < n_channels; n++ )
1101 : {
1102 124410 : Copy( input[n] + input_frame - dft_ovl, input_mem[n], dft_ovl );
1103 : }
1104 : }
1105 :
1106 74333 : pop_wmops();
1107 74333 : return;
1108 : }
1109 :
1110 : /*-------------------------------------------------------------------------
1111 : * stereo_dft_enc_synthesize()
1112 : *
1113 : * Inverse DFT on a 20ms frame
1114 : *-------------------------------------------------------------------------*/
1115 :
1116 224491 : Word32 stereo_dft_enc_synthesize_fx(
1117 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
1118 : // float *output, /* o : output synthesis */
1119 : Word32 *output_fx, /* o : output synthesis Q15 */
1120 : Word16 *output_start_index,
1121 : Word16 *output_end_index,
1122 : const Word16 chan, /* i : channel number */
1123 : const Word32 input_Fs, /* i : input sampling rate */
1124 : const Word32 output_sampling_rate, /* i : output sampling rate */
1125 : const Word16 L_frame, /* i : frame length at internal Fs */
1126 : Word16 *nrg_out_fx_e )
1127 : {
1128 : Word16 i, j, sign;
1129 : // float *pDFT_in;
1130 : Word32 *pDFT_in_fx;
1131 : Word16 DFT_in_fx_e;
1132 : Word16 offset, NFFT, N, ovl, zp;
1133 : Word16 temp_exp;
1134 : // float fac;
1135 : Word32 fac_fx;
1136 : // float *mem;
1137 : Word32 *mem_fx;
1138 : // const float *trigo, *win, *win_ana;
1139 : const Word16 *trigo_fx;
1140 : const Word32 *win_fx;
1141 : const Word16 *win_ana_fx;
1142 : // float tmp[STEREO_DFT_N_MAX_ENC];
1143 : Word32 tmp_fx[STEREO_DFT_N_MAX_ENC];
1144 : // float nrg;
1145 : Word32 nrg_fx;
1146 : Word16 nrg_fx_e;
1147 : // float trigo_enc[STEREO_DFT_N_MAX_ENC / 2 + 1];
1148 : Word16 trigo_enc_fx[STEREO_DFT_N_MAX_ENC / 2 + 1];
1149 : Word16 trigo_step;
1150 : Word16 scal_fac;
1151 :
1152 :
1153 : /*-----------------------------------------------------------------*
1154 : * Initialization
1155 : *-----------------------------------------------------------------*/
1156 :
1157 224491 : IF( L_frame > 0 )
1158 : {
1159 35633 : assert( ( output_sampling_rate == 16000 ) && "High-band generation only possible at 16kHz!" );
1160 : }
1161 224491 : nrg_fx = 0;
1162 224491 : move32();
1163 224491 : nrg_fx_e = 0;
1164 224491 : move16();
1165 :
1166 224491 : hStereoDft->icbweRefEner_fx = 0;
1167 224491 : move32();
1168 224491 : hStereoDft->icbweRefEner_fx_e = 0;
1169 224491 : move16();
1170 224491 : hStereoDft->lbEner_fx = 0;
1171 224491 : move32();
1172 224491 : hStereoDft->lbEner_fx_e = 0;
1173 224491 : move16();
1174 :
1175 224491 : IF( chan == 0 )
1176 : {
1177 204570 : pDFT_in_fx = hStereoDft->DFT_fx[0];
1178 204570 : DFT_in_fx_e = hStereoDft->DFT_fx_e[0];
1179 204570 : move16();
1180 : }
1181 : ELSE
1182 : {
1183 19921 : pDFT_in_fx = hStereoDft->DFT_fx[1];
1184 19921 : DFT_in_fx_e = hStereoDft->DFT_fx_e[1];
1185 19921 : move16();
1186 : }
1187 :
1188 224491 : IF( EQ_32( output_sampling_rate, input_Fs ) )
1189 : {
1190 59643 : assert( chan == 0 );
1191 :
1192 59643 : NFFT = hStereoDft->NFFT;
1193 59643 : move16();
1194 59643 : fac_fx = MAX_32;
1195 59643 : move32();
1196 59643 : N = hStereoDft->N;
1197 59643 : move16();
1198 59643 : ovl = hStereoDft->dft_ovl;
1199 59643 : move16();
1200 59643 : zp = hStereoDft->dft_zp;
1201 59643 : move16();
1202 59643 : trigo_fx = hStereoDft->dft_trigo_fx;
1203 59643 : trigo_step = hStereoDft->dft_trigo_step;
1204 59643 : move16();
1205 59643 : IF( L_frame > 0 )
1206 : {
1207 0 : mem_fx = hStereoDft->output_mem_dmx_16k_shb_fx;
1208 : }
1209 : ELSE
1210 : {
1211 59643 : mem_fx = hStereoDft->output_mem_dmx_fx;
1212 : }
1213 59643 : win_fx = hStereoDft->win_fx;
1214 59643 : win_ana_fx = hStereoDft->win_ana_fx;
1215 :
1216 59643 : push_wmops( "DFT_synth_fs" );
1217 : }
1218 164848 : ELSE IF( EQ_32( output_sampling_rate, INT_FS_12k8 ) )
1219 : {
1220 59643 : assert( chan == 0 );
1221 :
1222 59643 : NFFT = STEREO_DFT_N_12k8_ENC;
1223 59643 : move16();
1224 59643 : N = STEREO_DFT_HOP_12k8_ENC;
1225 59643 : move16();
1226 59643 : zp = STEREO_DFT_ZP_12k8_ENC;
1227 59643 : move16();
1228 : // fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1229 59643 : fac_fx = BASOP_Util_Divide3232_Scale_newton( NFFT, hStereoDft->NFFT, &temp_exp );
1230 59643 : fac_fx = L_shl( fac_fx, temp_exp );
1231 59643 : ovl = STEREO_DFT_OVL_12k8;
1232 59643 : move16();
1233 59643 : trigo_fx = hStereoDft->dft_trigo_12k8_fx;
1234 59643 : trigo_step = STEREO_DFT_TRIGO_SRATE_12k8_STEP;
1235 59643 : move16();
1236 59643 : mem_fx = hStereoDft->output_mem_dmx_12k8_fx;
1237 59643 : win_fx = hStereoDft->win_12k8_fx;
1238 59643 : win_ana_fx = hStereoDft->win_ana_12k8_fx;
1239 :
1240 59643 : push_wmops( "DFT_synth_12k8" );
1241 : }
1242 105205 : ELSE IF( EQ_32( output_sampling_rate, 16000 ) )
1243 : {
1244 83790 : assert( chan == 0 );
1245 :
1246 83790 : NFFT = STEREO_DFT_N_16k_ENC;
1247 83790 : move16();
1248 83790 : N = STEREO_DFT_HOP_16k_ENC;
1249 83790 : move16();
1250 83790 : zp = STEREO_DFT_ZP_16k_ENC;
1251 83790 : move16();
1252 : // fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1253 83790 : fac_fx = BASOP_Util_Divide3232_Scale_newton( NFFT, hStereoDft->NFFT, &temp_exp );
1254 83790 : fac_fx = L_shl( fac_fx, temp_exp );
1255 83790 : ovl = STEREO_DFT_OVL_16k;
1256 83790 : move16();
1257 83790 : trigo_fx = hStereoDft->dft_trigo_16k_fx;
1258 83790 : trigo_step = STEREO_DFT_TRIGO_SRATE_16k_STEP;
1259 83790 : move16();
1260 83790 : IF( L_frame > 0 )
1261 : {
1262 35633 : mem_fx = hStereoDft->output_mem_dmx_16k_shb_fx;
1263 :
1264 35633 : push_wmops( "DFT_synth_16k_shb" );
1265 : }
1266 : ELSE
1267 : {
1268 48157 : mem_fx = hStereoDft->output_mem_dmx_16k_fx;
1269 :
1270 48157 : push_wmops( "DFT_synth_16k" );
1271 : }
1272 83790 : win_fx = hStereoDft->win_16k_fx;
1273 83790 : win_ana_fx = hStereoDft->win_ana_16k_fx;
1274 : }
1275 21415 : ELSE IF( EQ_32( output_sampling_rate, 32000 ) )
1276 : {
1277 1494 : assert( chan == 0 );
1278 :
1279 1494 : NFFT = STEREO_DFT_N_32k_ENC;
1280 1494 : move16();
1281 1494 : N = STEREO_DFT_HOP_32k_ENC;
1282 1494 : move16();
1283 1494 : zp = STEREO_DFT_ZP_32k_ENC;
1284 1494 : move16();
1285 : // fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1286 1494 : fac_fx = BASOP_Util_Divide3232_Scale_newton( NFFT, hStereoDft->NFFT, &temp_exp );
1287 1494 : fac_fx = L_shl( fac_fx, temp_exp );
1288 1494 : ovl = STEREO_DFT_OVL_32k;
1289 1494 : move16();
1290 1494 : trigo_fx = hStereoDft->dft_trigo_32k_fx;
1291 1494 : trigo_step = STEREO_DFT_TRIGO_SRATE_32k_STEP;
1292 1494 : move16();
1293 1494 : mem_fx = hStereoDft->output_mem_dmx_32k_fx;
1294 1494 : win_fx = hStereoDft->win_32k_fx;
1295 1494 : win_ana_fx = hStereoDft->win_ana_32k_fx;
1296 :
1297 1494 : push_wmops( "DFT_synth_32k" );
1298 : }
1299 19921 : ELSE IF( EQ_32( output_sampling_rate, 8000 ) )
1300 : {
1301 19921 : assert( chan == 1 );
1302 :
1303 19921 : NFFT = STEREO_DFT_N_8k_ENC;
1304 19921 : move16();
1305 19921 : N = STEREO_DFT_HOP_8k_ENC;
1306 19921 : move16();
1307 19921 : zp = STEREO_DFT_ZP_8k_ENC;
1308 19921 : move16();
1309 : // fac = (float) ( NFFT ) / (float) ( hStereoDft->NFFT );
1310 19921 : fac_fx = BASOP_Util_Divide3232_Scale_newton( NFFT, hStereoDft->NFFT, &temp_exp );
1311 19921 : fac_fx = L_shl( fac_fx, temp_exp );
1312 19921 : ovl = STEREO_DFT_OVL_8k;
1313 19921 : move16();
1314 19921 : trigo_fx = hStereoDft->dft_trigo_8k_fx;
1315 19921 : trigo_step = STEREO_DFT_TRIGO_SRATE_8k_STEP;
1316 19921 : move16();
1317 19921 : mem_fx = hStereoDft->output_mem_res_8k_fx;
1318 19921 : win_fx = hStereoDft->win_8k_fx;
1319 19921 : win_ana_fx = hStereoDft->win_ana_8k_fx;
1320 :
1321 19921 : push_wmops( "DFT_synth_8k" );
1322 : }
1323 : ELSE
1324 : {
1325 0 : assert( 0 && "DFT stereo: sampling rate not supported!" );
1326 : NFFT = -1; /* to avoid compilation warning */
1327 : move16();
1328 : fac_fx = -1; /* to avoid compilation warning */
1329 : move32();
1330 : N = -1; /* to avoid compilation warning */
1331 : move16();
1332 : zp = -1; /* to avoid compilation warning */
1333 : move16();
1334 : win_fx = NULL; /* to avoid compilation warning */
1335 : trigo_fx = NULL; /* to avoid compilation warning */
1336 : trigo_step = -1; /* to avoid compilation warning */
1337 : move16();
1338 : ovl = -1; /* to avoid compilation warning */
1339 : move16();
1340 : mem_fx = NULL; /* to avoid compilation warning */
1341 : win_ana_fx = NULL; /* to avoid compilation warning */
1342 : }
1343 :
1344 224491 : offset = 0;
1345 224491 : move16();
1346 :
1347 43932955 : FOR( i = 0; i < NFFT / 4; i++ )
1348 : {
1349 43708464 : trigo_enc_fx[i] = trigo_fx[i * trigo_step];
1350 43708464 : move16();
1351 43708464 : trigo_enc_fx[( NFFT / 2 ) - i] = trigo_fx[i * trigo_step];
1352 43708464 : move16();
1353 : }
1354 224491 : trigo_enc_fx[NFFT / 4] = trigo_fx[( NFFT / 4 ) * trigo_step];
1355 224491 : move16();
1356 :
1357 : /*-----------------------------------------------------------------*
1358 : * Synthesizing & resampling
1359 : *-----------------------------------------------------------------*/
1360 :
1361 224491 : offset = negate( ovl );
1362 :
1363 224491 : test();
1364 224491 : IF( EQ_16( L_frame, L_FRAME ) || EQ_16( L_frame, L_FRAME16k ) )
1365 : {
1366 : // 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++ )
1367 11438193 : FOR( i = 320; i < 640; i++ )
1368 : {
1369 : // hStereoDft->icbweRefEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1370 11402560 : hStereoDft->icbweRefEner_fx = BASOP_Util_Add_Mant32Exp( hStereoDft->icbweRefEner_fx, hStereoDft->icbweRefEner_fx_e, L_add( L_shr( Mpy_32_32( pDFT_in_fx[2 * i], pDFT_in_fx[2 * i] ), 1 ), L_shr( Mpy_32_32( pDFT_in_fx[2 * i + 1], pDFT_in_fx[2 * i + 1] ), 1 ) ), add( shl( DFT_in_fx_e, 1 ), 1 ), &hStereoDft->icbweRefEner_fx_e );
1371 11402560 : move32();
1372 : }
1373 : // for ( i = 0; i < (int16_t) ( 200 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ) ); i++ )
1374 11438193 : FOR( i = 0; i < 320; i++ )
1375 : {
1376 : // hStereoDft->lbEner += pDFT_in[2 * i] * pDFT_in[2 * i] + pDFT_in[2 * i + 1] * pDFT_in[2 * i + 1];
1377 11402560 : hStereoDft->lbEner_fx = BASOP_Util_Add_Mant32Exp( hStereoDft->lbEner_fx, hStereoDft->lbEner_fx_e, L_add( L_shr( Mpy_32_32( pDFT_in_fx[2 * i], pDFT_in_fx[2 * i] ), 1 ), L_shr( Mpy_32_32( pDFT_in_fx[2 * i + 1], pDFT_in_fx[2 * i + 1] ), 1 ) ), add( shl( DFT_in_fx_e, 1 ), 1 ), &hStereoDft->lbEner_fx_e );
1378 11402560 : move32();
1379 : }
1380 35633 : hStereoDft->icbweRefEner_fx = Mpy_32_32( hStereoDft->icbweRefEner_fx, fac_fx );
1381 35633 : move32();
1382 35633 : hStereoDft->lbEner_fx = Mpy_32_32( hStereoDft->lbEner_fx, fac_fx );
1383 35633 : move32();
1384 : }
1385 :
1386 : /*Flip?*/
1387 224491 : set32_fx( tmp_fx, 0, STEREO_DFT_N_MAX_ENC );
1388 224491 : IF( EQ_16( L_frame, L_FRAME ) )
1389 : {
1390 : /* 6 to 14 kHz SHB target signal*/
1391 17213 : j = 2;
1392 17213 : move16();
1393 17213 : sign = hStereoDft->flip_sign;
1394 17213 : move16();
1395 :
1396 : // 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-- )
1397 5542586 : FOR( i = 560; i >= 240; i-- )
1398 : {
1399 : /* alternate sign between frames for even starting index */
1400 5525373 : tmp_fx[j++] = W_extract_l( W_mult0_32_32( sign, Mpy_32_32( pDFT_in_fx[2 * i], fac_fx ) ) );
1401 5525373 : tmp_fx[j++] = W_extract_l( W_mult0_32_32( negate( sign ), Mpy_32_32( pDFT_in_fx[2 * i + 1], fac_fx ) ) );
1402 5525373 : move32();
1403 5525373 : move32();
1404 : }
1405 17213 : scal_fac = sub( L_norm_arr( tmp_fx, STEREO_DFT_N_MAX_ENC ), 1 );
1406 17213 : scale_sig32( tmp_fx, STEREO_DFT_N_MAX_ENC, scal_fac ); // Q16
1407 17213 : DFT_in_fx_e = sub( DFT_in_fx_e, scal_fac );
1408 :
1409 17213 : hStereoDft->flip_sign = negate( sign );
1410 17213 : move16();
1411 :
1412 : // for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1413 2788506 : FOR( i = 0; i <= 160; i++ )
1414 : {
1415 2771293 : nrg_fx = BASOP_Util_Add_Mant32Exp( nrg_fx, nrg_fx_e, Mpy_32_32( tmp_fx[2 * i], tmp_fx[2 * i] ), shl( DFT_in_fx_e, 1 ), &nrg_fx_e );
1416 2771293 : nrg_fx = BASOP_Util_Add_Mant32Exp( nrg_fx, nrg_fx_e, Mpy_32_32( tmp_fx[2 * i + 1], tmp_fx[2 * i + 1] ), shl( DFT_in_fx_e, 1 ), &nrg_fx_e );
1417 : }
1418 : }
1419 207278 : ELSE IF( EQ_16( L_frame, L_FRAME16k ) )
1420 : {
1421 : /* 7.5 - 15.5 kHz SHB target signal*/
1422 18420 : j = 2;
1423 18420 : move16();
1424 : // 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-- )
1425 5912820 : FOR( i = 640 - 1; i >= 320; i-- )
1426 : {
1427 5894400 : tmp_fx[j++] = Mpy_32_32( pDFT_in_fx[2 * i], fac_fx );
1428 5894400 : tmp_fx[j++] = L_negate( Mpy_32_32( pDFT_in_fx[2 * i + 1], fac_fx ) );
1429 5894400 : move32();
1430 5894400 : move32();
1431 : }
1432 18420 : scal_fac = sub( L_norm_arr( tmp_fx, STEREO_DFT_N_MAX_ENC ), 1 );
1433 18420 : scale_sig32( tmp_fx, STEREO_DFT_N_MAX_ENC, scal_fac ); // Q16
1434 18420 : DFT_in_fx_e = sub( DFT_in_fx_e, scal_fac );
1435 :
1436 : // for ( i = 0; i <= (int16_t) 100 * ( (float) ( STEREO_DFT_N_NS_ENC ) / STEREO_DFT_N_NS ); i++ )
1437 2984040 : FOR( i = 0; i <= 160; i++ )
1438 : {
1439 2965620 : nrg_fx = BASOP_Util_Add_Mant32Exp( nrg_fx, nrg_fx_e, Mpy_32_32( tmp_fx[2 * i], tmp_fx[2 * i] ), shl( DFT_in_fx_e, 1 ), &nrg_fx_e );
1440 2965620 : nrg_fx = BASOP_Util_Add_Mant32Exp( nrg_fx, nrg_fx_e, Mpy_32_32( tmp_fx[2 * i + 1], tmp_fx[2 * i + 1] ), shl( DFT_in_fx_e, 1 ), &nrg_fx_e );
1441 : }
1442 : }
1443 188858 : ELSE IF( NE_32( fac_fx, MAX_32 ) )
1444 : {
1445 : /*Copy and scale*/
1446 129215 : tmp_fx[0] = Mpy_32_32( pDFT_in_fx[0], fac_fx );
1447 129215 : move32();
1448 129215 : tmp_fx[1] = 0;
1449 129215 : move32();
1450 69515521 : FOR( i = 2; i < NFFT; i++ )
1451 : {
1452 69386306 : tmp_fx[i] = Mpy_32_32( pDFT_in_fx[i], fac_fx );
1453 69386306 : move32();
1454 : }
1455 :
1456 129215 : IF( LT_32( fac_fx, MAX_32 ) )
1457 : {
1458 129215 : tmp_fx[1] = 0; /*Nyquist is set to 0*/
1459 129215 : tmp_fx[0] = 0; /*DC is set to 0*/
1460 129215 : move32();
1461 129215 : move32();
1462 : }
1463 129215 : scal_fac = sub( L_norm_arr( tmp_fx, STEREO_DFT_N_MAX_ENC ), 1 );
1464 129215 : scale_sig32( tmp_fx, STEREO_DFT_N_MAX_ENC, scal_fac ); // Q16
1465 129215 : DFT_in_fx_e = sub( DFT_in_fx_e, scal_fac );
1466 : }
1467 : ELSE
1468 : {
1469 82443643 : FOR( i = 0; i < NFFT; i++ )
1470 : {
1471 82384000 : tmp_fx[i] = pDFT_in_fx[i];
1472 82384000 : move32();
1473 : }
1474 59643 : scal_fac = sub( L_norm_arr( tmp_fx, STEREO_DFT_N_MAX_ENC ), 1 );
1475 59643 : scale_sig32( tmp_fx, STEREO_DFT_N_MAX_ENC, scal_fac ); // Q16
1476 59643 : DFT_in_fx_e = sub( DFT_in_fx_e, scal_fac );
1477 : }
1478 :
1479 : /*Reconstruct */
1480 : /*IFFT*/
1481 224491 : scal_fac = sub( 1, find_guarded_bits_fx( NFFT ) );
1482 224491 : scale_sig32( tmp_fx, NFFT, scal_fac ); // Q16
1483 224491 : rfft_fx( tmp_fx, trigo_enc_fx, NFFT, +1 );
1484 224491 : Scale_sig32( tmp_fx, NFFT, sub( sub( DFT_in_fx_e, scal_fac ), 16 ) ); // Q15
1485 :
1486 38469397 : FOR( i = 0; i < ovl; i++ )
1487 : {
1488 : // output[offset + i] = mem[i] + tmp[zp + i] * win[i];
1489 38244906 : output_fx[offset + i] = L_add_sat( mem_fx[i], Mpy_32_32( tmp_fx[zp + i], win_fx[i] ) ); // Q15
1490 38244906 : move32();
1491 : // mem[i] = tmp[zp + N + i] * win[ovl - 1 - i];
1492 38244906 : mem_fx[i] = Mpy_32_32( tmp_fx[zp + N + i], win_fx[ovl - 1 - i] ); // Q15
1493 38244906 : move32();
1494 : }
1495 :
1496 : /*Middle->Copy*/
1497 49396513 : FOR( i = 0; i < N - ovl; i++ )
1498 : {
1499 : // output_fx[offset + ovl + i] = tmp[zp + ovl + i];
1500 49172022 : output_fx[offset + ovl + i] = tmp_fx[zp + ovl + i]; // Q15
1501 49172022 : move32();
1502 : }
1503 :
1504 : /*-----------------------------------------------------------------*
1505 : * Lookahead: redress signal
1506 : *-----------------------------------------------------------------*/
1507 :
1508 38469397 : FOR( i = 0; i < ovl; i++ )
1509 : {
1510 38244906 : Word32 ifft_deviation = tmp_fx[zp + N + ovl]; // Q15
1511 38244906 : move32();
1512 : // output[offset + N + i] = ( tmp[zp + N + i] - ifft_deviation ) / win_ana[ovl - 1 - i] + ifft_deviation;
1513 : Word16 L_temp_e;
1514 38244906 : Word32 L_temp = BASOP_Util_Divide3232_Scale_newton( L_sub_sat( tmp_fx[zp + N + i], ifft_deviation ), L_deposit_h( win_ana_fx[ovl - 1 - i] ), &L_temp_e );
1515 38244906 : L_temp = L_shl_sat( L_temp, L_temp_e );
1516 38244906 : output_fx[offset + N + i] = L_add_sat( L_temp, ifft_deviation ); // Q15
1517 38244906 : move32();
1518 : }
1519 :
1520 224491 : *output_start_index = offset;
1521 224491 : move16();
1522 224491 : *output_end_index = add( add( offset, ovl ), N );
1523 224491 : move16();
1524 224491 : IF( nrg_out_fx_e )
1525 : {
1526 35633 : *nrg_out_fx_e = nrg_fx_e;
1527 35633 : move16();
1528 : }
1529 224491 : pop_wmops();
1530 224491 : return ( nrg_fx );
1531 : }
1532 :
1533 : /*-------------------------------------------------------------------------
1534 : * stereo_dft_enc_process()
1535 : *
1536 : * DFT-based stereo main processing function:
1537 : * 1) compute/encode stereo parameters
1538 : * 2) Mid/Side computation
1539 : *-------------------------------------------------------------------------*/
1540 59643 : void stereo_dft_enc_process_fx(
1541 : CPE_ENC_HANDLE hCPE, /* i/o: CPE encoder structure */
1542 : const Word16 vad_flag_dtx[], /* i : VAD dtx flags */
1543 : const Word16 vad_hover_flag[], /* i : VAD hangover flags */
1544 : const Word16 input_frame /* i : input frame length */
1545 : )
1546 : {
1547 : Word16 i, j, b;
1548 : Word32 *pDFT_L_fx, *pDFT_R_fx;
1549 : Word32 *pDFT_DMX;
1550 : Word32 *pDFT_RES;
1551 : Word16 k_offset;
1552 : Word32 *pgIpd;
1553 : Word32 *pSideGain;
1554 : Word16 c_fx /*Q15*/, alpha_fx /*Q13*/;
1555 : Word32 g_fx; // Q31
1556 : Word32 wL, wR;
1557 : Word16 wL_e, wR_e;
1558 : Word16 wS;
1559 : Word16 tmp_fx;
1560 : Word32 tmp_32fx;
1561 : Word16 s_fx /*Q15*/, c1_fx /*Q15*/, s1_fx /*Q15*/;
1562 : Word16 fac_att_fx; // Q15
1563 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft;
1564 : Word32 DFT_DMX[STEREO_DFT_N_MAX_ENC];
1565 : Word16 DFT_DMX_e[STEREO_DFT_N_MAX_ENC];
1566 : Word32 DFT_RES[STEREO_DFT_N_8k_ENC];
1567 : Word16 DFT_RES_e[STEREO_DFT_N_8k_ENC];
1568 : Word32 input_Fs;
1569 : Word32 bin_nrgL_fx[STEREO_DFT_N_MAX_ENC];
1570 : Word16 bin_nrgL_fx_e[STEREO_DFT_N_MAX_ENC];
1571 : Word32 bin_nrgR_fx[STEREO_DFT_N_MAX_ENC];
1572 : Word16 bin_nrgR_fx_e[STEREO_DFT_N_MAX_ENC];
1573 : Word32 *pNrgL, *pNrgR;
1574 : Word32 res_nrg_all_curr, dmx_nrg_all_curr;
1575 : Word16 res_nrg_all_curr_e, dmx_nrg_all_curr_e;
1576 : Word32 res_dmx_ratio /*Q31*/, frame_nrg_ratio /*Q28*/;
1577 : Word32 dot_prod_nrg_ratio_fx[STEREO_DFT_BAND_MAX]; /* contains only dot product for higher bands Q31 */
1578 : Word16 dot_prod_nrg_ratio_fx_e[STEREO_DFT_BAND_MAX]; /* contains only dot product for higher bands Q31 */
1579 : Word32 sum_nrg_L2, sum_nrg_R2, dot_prod_real2;
1580 : Word16 sum_nrg_L2_e, sum_nrg_R2_e, dot_prod_real2_e;
1581 : Word32 sum_nrg_Mid, sum_abs;
1582 : Word16 sum_nrg_Mid_e, sum_abs_e;
1583 : Word16 tmp_e;
1584 : Word16 DFT_L_e_tmp[STEREO_DFT_N_MAX_ENC], DFT_R_e_tmp[STEREO_DFT_N_MAX_ENC];
1585 : Word32 L_tmp1, L_tmp2, L_tmp3;
1586 : Word16 L_tmp1_e, L_tmp2_e, L_tmp3_e;
1587 :
1588 : /*------------------------------------------------------------------*
1589 : * Initialization
1590 : *-----------------------------------------------------------------*/
1591 :
1592 59643 : input_Fs = L_mult0( input_frame, FRAMES_PER_SEC );
1593 :
1594 59643 : hStereoDft = hCPE->hStereoDft;
1595 :
1596 59643 : wL = 0; /* avoid compilation warning */
1597 59643 : move32();
1598 59643 : wL_e = 0; /* avoid compilation warning */
1599 59643 : move16();
1600 59643 : wR = 0; /* avoid compilation warning */
1601 59643 : move32();
1602 59643 : wR_e = 0; /* avoid compilation warning */
1603 59643 : move16();
1604 :
1605 : /* Initialization */
1606 59643 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
1607 59643 : move16();
1608 :
1609 59643 : hStereoDft->gipd_band_max = dft_band_ipd[1][3];
1610 59643 : move16();
1611 59643 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->res_cod_mode[k_offset]];
1612 59643 : move16();
1613 : // 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 ) );
1614 59643 : tmp_32fx = L_shl( L_mult0( sub( hStereoDft->band_limits[hStereoDft->res_cod_band_max], 1 ), input_frame ), 1 );
1615 59643 : tmp_32fx = BASOP_Util_Divide3216_Scale( tmp_32fx, hStereoDft->NFFT, &tmp_e );
1616 59643 : hStereoDft->res_cod_line_max = extract_l( L_shr_r( tmp_32fx, sub( -1, tmp_e ) ) ); // 15 - (31 - 15 + tmp_e) = -1 - tmp_e
1617 59643 : move16();
1618 : // hStereoDft->res_cod_line_max = 8 * (hStereoDft->res_cod_line_max / 8);
1619 59643 : hStereoDft->res_cod_line_max = shl( shr( hStereoDft->res_cod_line_max, 3 ), 3 );
1620 59643 : move16();
1621 59643 : hStereoDft->res_pred_band_min = s_max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
1622 59643 : move16();
1623 :
1624 : // hStereoDft->voicing_lt = 0.75f * hStereoDft->voicing_lt + 0.25f * hCPE->hCoreCoder[0]->voicing[0];
1625 : // hStereoDft->voicing_lt = 0.75f * hStereoDft->voicing_lt + 0.25f * hCPE->hCoreCoder[0]->voicing[1];
1626 :
1627 59643 : hStereoDft->voicing_lt_fx = L_add( Mpy_32_16_1( hStereoDft->voicing_lt_fx, 24576 ), L_mult( 8192, hCPE->hCoreCoder[0]->voicing_fx[0] ) );
1628 59643 : move32();
1629 59643 : hStereoDft->voicing_lt_fx = L_add( Mpy_32_16_1( hStereoDft->voicing_lt_fx, 24576 ), L_mult( 8192, hCPE->hCoreCoder[0]->voicing_fx[1] ) );
1630 59643 : move32();
1631 :
1632 : /*------------------------------------------------------------------*
1633 : * Compute stereo parameters
1634 : *-----------------------------------------------------------------*/
1635 :
1636 : /*ITD in Frequency domain*/
1637 : // fac_att = 1.0f;
1638 59643 : fac_att_fx = MAX_16;
1639 59643 : move16();
1640 :
1641 59643 : pDFT_L_fx = hStereoDft->DFT_fx[0];
1642 59643 : pDFT_R_fx = hStereoDft->DFT_fx[1];
1643 82443643 : FOR( i = 0; i < hStereoDft->NFFT; i++ )
1644 : {
1645 82384000 : tmp_e = norm_l( hStereoDft->DFT_fx[0][i] );
1646 82384000 : pDFT_L_fx[i] = L_shl( hStereoDft->DFT_fx[0][i], tmp_e );
1647 82384000 : move32();
1648 82384000 : DFT_L_e_tmp[i] = sub( hStereoDft->DFT_fx_e[0], tmp_e );
1649 82384000 : move16();
1650 82384000 : tmp_e = norm_l( hStereoDft->DFT_fx[1][i] );
1651 82384000 : pDFT_R_fx[i] = L_shl( hStereoDft->DFT_fx[1][i], tmp_e );
1652 82384000 : move32();
1653 82384000 : DFT_R_e_tmp[i] = sub( hStereoDft->DFT_fx_e[1], tmp_e );
1654 82384000 : move16();
1655 : }
1656 :
1657 : {
1658 59643 : stereo_dft_enc_compute_itd_fx( hCPE, pDFT_L_fx, DFT_L_e_tmp, pDFT_R_fx, DFT_R_e_tmp, k_offset, input_frame, vad_flag_dtx, vad_hover_flag, bin_nrgL_fx, bin_nrgL_fx_e, bin_nrgR_fx, bin_nrgR_fx_e );
1659 :
1660 59643 : IF( EQ_16( hCPE->element_mode, IVAS_CPE_MDCT ) )
1661 : {
1662 0 : return;
1663 : }
1664 :
1665 59643 : test();
1666 59643 : IF( hStereoDft->hItd->deltaItd_fx[k_offset] != 0 && hStereoDft->hConfig->dmx_active )
1667 : {
1668 : /*time shift channels*/
1669 : // alpha = -2.0f * EVS_PI * hStereoDft->hItd->deltaItd[k_offset] / hStereoDft->NFFT;
1670 28564 : alpha_fx = BASOP_Util_Divide3216_Scale( hStereoDft->hItd->deltaItd_fx[k_offset], hStereoDft->NFFT, &tmp_e );
1671 28564 : alpha_fx = negate( shl_r( mult_r( EVS_PI_FX, alpha_fx ), add( tmp_e, 1 ) ) ); // Q13*Q15= Q13
1672 :
1673 : // c = 1.f; /*cos(0)*/
1674 28564 : c_fx = MAX_16; /*cos(0)*/
1675 28564 : move16();
1676 : // s = 0.f; /*sin(0)*/
1677 28564 : s_fx = 0; /*sin(0)*/
1678 28564 : move16();
1679 : // c1 = cosf( alpha );
1680 28564 : c1_fx = shl_sat( getCosWord16( alpha_fx ), 1 );
1681 : // s1 = sinf( alpha );
1682 28564 : s1_fx = getSinWord16( alpha_fx );
1683 :
1684 28564 : IF( alpha_fx >= 0 )
1685 : {
1686 21225 : c_fx = shr( c_fx, 1 );
1687 21225 : s_fx = shr( s_fx, 1 );
1688 15310720 : FOR( i = 1; i < hStereoDft->NFFT / 2; i++ )
1689 : {
1690 : // tmp = s * c1 + c * s1;
1691 15289495 : tmp_fx = add( mult_r( s_fx, c1_fx ), mult_r( c_fx, s1_fx ) );
1692 : // c = c * c1 - s * s1;
1693 15289495 : c_fx = sub( mult_r( c_fx, c1_fx ), mult_r( s_fx, s1_fx ) );
1694 15289495 : s_fx = tmp_fx;
1695 15289495 : move16();
1696 :
1697 : /*time shift of L*/
1698 : // tmp = pDFT_L[2 * i] * c - pDFT_L[2 * i + 1] * s;
1699 15289495 : tmp_32fx = BASOP_Util_Add_Mant32Exp( Mpy_32_16_1( pDFT_L_fx[2 * i], c_fx ), add( DFT_L_e_tmp[2 * i], 1 ), L_negate( Mpy_32_16_1( pDFT_L_fx[2 * i + 1], s_fx ) ), add( DFT_L_e_tmp[2 * i + 1], 1 ), &tmp_e );
1700 : // pDFT_L[2 * i + 1] = pDFT_L[2 * i] * s + pDFT_L[2 * i + 1] * c;
1701 15289495 : pDFT_L_fx[2 * i + 1] = BASOP_Util_Add_Mant32Exp( Mpy_32_16_1( pDFT_L_fx[2 * i], s_fx ), add( DFT_L_e_tmp[2 * i], 1 ), Mpy_32_16_1( pDFT_L_fx[2 * i + 1], c_fx ), add( DFT_L_e_tmp[2 * i + 1], 1 ), &DFT_L_e_tmp[2 * i + 1] );
1702 15289495 : move32();
1703 : // pDFT_L[2 * i] = tmp;
1704 15289495 : pDFT_L_fx[2 * i] = tmp_32fx;
1705 15289495 : move32();
1706 15289495 : DFT_L_e_tmp[2 * i] = tmp_e;
1707 15289495 : move16();
1708 : }
1709 : }
1710 : ELSE
1711 : {
1712 4764160 : FOR( i = 1; i < hStereoDft->NFFT / 2; i++ )
1713 : {
1714 : // tmp = s * c1 + c * s1;
1715 4756821 : tmp_fx = add_sat( mult_r( s_fx, c1_fx ), mult_r( c_fx, s1_fx ) ); // saturation expected
1716 : // c = c * c1 - s * s1;
1717 4756821 : c_fx = sub_sat( mult_r( c_fx, c1_fx ), mult_r( s_fx, s1_fx ) ); // saturation expected
1718 4756821 : s_fx = tmp_fx;
1719 4756821 : move16();
1720 :
1721 : /*time shift of R*/
1722 : // tmp = pDFT_R[2 * i] * c + pDFT_R[2 * i + 1] * s;
1723 4756821 : tmp_32fx = BASOP_Util_Add_Mant32Exp( Mpy_32_16_1( pDFT_R_fx[2 * i], c_fx ), DFT_R_e_tmp[2 * i], Mpy_32_16_1( pDFT_R_fx[2 * i + 1], s_fx ), DFT_R_e_tmp[2 * i + 1], &tmp_e );
1724 : // pDFT_R[2 * i + 1] = -pDFT_R[2 * i] * s + pDFT_R[2 * i + 1] * c;
1725 4756821 : pDFT_R_fx[2 * i + 1] = BASOP_Util_Add_Mant32Exp( L_negate( Mpy_32_16_1( pDFT_R_fx[2 * i], s_fx ) ), DFT_R_e_tmp[2 * i], Mpy_32_16_1( pDFT_R_fx[2 * i + 1], c_fx ), DFT_R_e_tmp[2 * i + 1], &DFT_R_e_tmp[2 * i + 1] );
1726 4756821 : move32();
1727 : // pDFT_R[2 * i] = tmp;
1728 4756821 : pDFT_R_fx[2 * i] = tmp_32fx;
1729 4756821 : move32();
1730 4756821 : DFT_R_e_tmp[2 * i] = tmp_e;
1731 4756821 : move16();
1732 : }
1733 : }
1734 :
1735 : // if ( fabsf( hStereoDft->hItd->deltaItd[k_offset] * 32000.f / input_Fs ) > 80.0f )
1736 28564 : tmp_32fx = L_abs( BASOP_Util_Divide3232_Scale_newton( hStereoDft->hItd->deltaItd_fx[k_offset], input_Fs, &tmp_e ) );
1737 28564 : tmp_e = add( tmp_e, 15 - 31 );
1738 28564 : IF( BASOP_Util_Cmp_Mant32Exp( tmp_32fx, tmp_e, 5368709 /* 80.0f / 32000.f in Q31 */, 0 ) > 0 )
1739 : {
1740 : // fac_att = min( 1.0f, max( 0.2f, 2.6f - 0.02f * fabsf( hStereoDft->hItd->deltaItd[1] ) * 32000.f / input_Fs ) );
1741 5968 : tmp_fx = BASOP_Util_Divide3232_Scale( L_abs( hStereoDft->hItd->deltaItd_fx[1] ), input_Fs, &tmp_e );
1742 5968 : tmp_e = add( tmp_e, 15 - 31 );
1743 5968 : tmp_32fx = L_sub( 85197 /*2.6f in Q15*/, L_shl( L_mult0( tmp_fx, 640 /*0.02f * 32000.f in Q0*/ ), tmp_e ) ); // Q15
1744 5968 : fac_att_fx = extract_l( L_min( MAX_16, L_max( 6554 /*0.2f in Q15*/, tmp_32fx ) ) ); // Q15
1745 : }
1746 : }
1747 :
1748 : /* compute remaining binwise energies for FB mode (ITD function only computes energies up to 16 kHz) */
1749 6755643 : FOR( i = STEREO_DFT_N_32k_ENC / 2; i < hStereoDft->NFFT / 2; i++ )
1750 : {
1751 : // bin_nrgL[i] = pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
1752 6696000 : bin_nrgL_fx[i] = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L_fx[2 * i], pDFT_L_fx[2 * i] ), shl( DFT_L_e_tmp[2 * i], 1 ), Mpy_32_32( pDFT_L_fx[2 * i + 1], pDFT_L_fx[2 * i + 1] ), shl( DFT_L_e_tmp[2 * i + 1], 1 ), &bin_nrgL_fx_e[i] );
1753 6696000 : move32();
1754 : // bin_nrgR[i] = pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
1755 6696000 : bin_nrgR_fx[i] = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_R_fx[2 * i], pDFT_R_fx[2 * i] ), shl( DFT_R_e_tmp[2 * i], 1 ), Mpy_32_32( pDFT_R_fx[2 * i + 1], pDFT_R_fx[2 * i + 1] ), shl( DFT_R_e_tmp[2 * i + 1], 1 ), &bin_nrgR_fx_e[i] );
1756 6696000 : move32();
1757 : }
1758 : }
1759 :
1760 : /* DFT stereo parameters */
1761 59643 : stereo_dft_enc_compute_prm_fx( hStereoDft, pDFT_L_fx, DFT_L_e_tmp, pDFT_R_fx, DFT_R_e_tmp, k_offset, 1, hCPE->hCoreCoder[0]->sp_aud_decision0, hCPE->hCoreCoder[0]->vad_flag, bin_nrgL_fx, bin_nrgL_fx_e, bin_nrgR_fx, bin_nrgR_fx_e, dot_prod_nrg_ratio_fx, dot_prod_nrg_ratio_fx_e );
1762 : // printf("\n%f ", (float)hStereoDft->res_pred_gain_fx[0] / 0x7fffffff);
1763 : // printf("\n%f ", (float)hStereoDft->sum_dot_prod_img_fx / powf(2, 31 - hStereoDft->sum_dot_prod_img_fx_e
1764 :
1765 59643 : IF( vad_flag_dtx[0] == 0 )
1766 : {
1767 10395 : test();
1768 10395 : IF( hCPE->hStereoCng->cng_counter == 0 && !hCPE->hStereoCng->first_SID_after_TD )
1769 : {
1770 128 : hStereoDft->sid_gipd_fx = hStereoDft->prev_sid_gipd_fx;
1771 128 : move32();
1772 128 : hStereoDft->no_ipd_flag = hStereoDft->prev_sid_no_ipd_flag;
1773 128 : move16();
1774 : }
1775 :
1776 10395 : IF( GT_16( hCPE->hStereoCng->cng_counter, ITD_SID_PREV_FRAMES ) )
1777 : {
1778 9310 : hStereoDft->prev_sid_gipd_fx = hStereoDft->sid_gipd_fx;
1779 9310 : move32();
1780 9310 : hStereoDft->prev_sid_no_ipd_flag = hStereoDft->no_ipd_flag;
1781 9310 : move16();
1782 : }
1783 : }
1784 :
1785 :
1786 : /*----------------------------------------------------------------*
1787 : * UNCLR classifier (detection of uncorrelated L and R channels)
1788 : *----------------------------------------------------------------*/
1789 :
1790 59643 : unclr_classifier_dft_fx( hCPE );
1791 :
1792 : /*------------------------------------------------------------------*
1793 : * Channel mapping: computation of DMX and RES
1794 : *-----------------------------------------------------------------*/
1795 :
1796 59643 : res_nrg_all_curr = EPSILON_FX_M;
1797 59643 : move32();
1798 59643 : res_nrg_all_curr_e = EPSILON_FX_E;
1799 59643 : move16();
1800 59643 : dmx_nrg_all_curr = EPSILON_FX_M;
1801 59643 : move32();
1802 59643 : dmx_nrg_all_curr_e = EPSILON_FX_E;
1803 59643 : move16();
1804 :
1805 59643 : pDFT_DMX = DFT_DMX;
1806 59643 : pDFT_RES = DFT_RES;
1807 59643 : pNrgL = bin_nrgL_fx;
1808 59643 : pNrgR = bin_nrgR_fx;
1809 :
1810 59643 : set_zero_fx( pDFT_DMX, STEREO_DFT_N_MAX_ENC );
1811 59643 : set16_zero_fx( DFT_DMX_e, STEREO_DFT_N_MAX_ENC );
1812 59643 : set_zero_fx( pDFT_RES, STEREO_DFT_N_8k_ENC );
1813 59643 : set16_zero_fx( DFT_RES_e, STEREO_DFT_N_8k_ENC );
1814 :
1815 59643 : pgIpd = hStereoDft->gipd_fx + k_offset;
1816 59643 : pSideGain = hStereoDft->side_gain_fx + k_offset * STEREO_DFT_BAND_MAX;
1817 :
1818 :
1819 59643 : IF( hStereoDft->hConfig->dmx_active )
1820 : {
1821 : /*Active DMX*/
1822 : // alpha = 0; /* to avoid compilation warning */
1823 59643 : alpha_fx = 0; /* to avoid compilation warning */
1824 59643 : move16();
1825 59643 : g_fx = MAX_32;
1826 59643 : move32();
1827 :
1828 : /*Apply active DMX*/
1829 59643 : pDFT_DMX[0] = 0;
1830 59643 : move32();
1831 59643 : DFT_DMX_e[0] = 0;
1832 59643 : move16();
1833 59643 : pDFT_RES[0] = 0;
1834 59643 : move32();
1835 59643 : DFT_RES_e[0] = 0;
1836 59643 : move16();
1837 760663 : FOR( b = 0; b < hStereoDft->nbands_dmx; b++ )
1838 : {
1839 701020 : g_fx = pSideGain[b];
1840 701020 : move32();
1841 :
1842 701020 : IF( pgIpd[0] != 0 )
1843 : {
1844 212837 : Word32 theta = pgIpd[0];
1845 214025 : WHILE( GT_32( theta, EVS_2PI_FX ) )
1846 : {
1847 1188 : theta = L_sub( theta, EVS_2PI_FX ); /* Q13 */
1848 : }
1849 227567 : WHILE( LT_32( theta, -EVS_2PI_FX ) )
1850 : {
1851 14730 : theta = L_add( theta, EVS_2PI_FX ); /* Q13 */
1852 : }
1853 :
1854 212837 : IF( GT_32( theta, MAX_16 ) )
1855 : {
1856 7536 : theta = L_sub( theta, EVS_2PI_FX ); /* Q13 */
1857 : }
1858 205301 : ELSE IF( LT_32( theta, MIN_16 ) )
1859 : {
1860 3666 : theta = L_add( theta, EVS_2PI_FX ); /* Q13 */
1861 : }
1862 :
1863 212837 : c_fx = shl_sat( getCosWord16( extract_l( theta ) ), 1 );
1864 212837 : s_fx = getSinWord16( extract_l( theta ) );
1865 :
1866 11328025 : FOR( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
1867 : {
1868 : /*rotate L*/
1869 : // tmp = pDFT_L[2 * i] * c + pDFT_L[2 * i + 1] * s;
1870 11115188 : tmp_32fx = BASOP_Util_Add_Mant32Exp( Mpy_32_16_1( pDFT_L_fx[2 * i], c_fx ), DFT_L_e_tmp[2 * i], Mpy_32_16_1( pDFT_L_fx[2 * i + 1], s_fx ), DFT_L_e_tmp[2 * i + 1], &tmp_e );
1871 : // pDFT_L[2 * i + 1] = pDFT_L[2 * i + 1] * c - pDFT_L[2 * i] * s;
1872 11115188 : pDFT_L_fx[2 * i + 1] = BASOP_Util_Add_Mant32Exp( Mpy_32_16_1( pDFT_L_fx[2 * i + 1], c_fx ), DFT_L_e_tmp[2 * i + 1], L_negate( Mpy_32_16_1( pDFT_L_fx[2 * i], s_fx ) ), DFT_L_e_tmp[2 * i], &DFT_L_e_tmp[2 * i + 1] );
1873 11115188 : move32();
1874 : // pDFT_L[2 * i] = tmp;
1875 11115188 : pDFT_L_fx[2 * i] = tmp_32fx;
1876 11115188 : move32();
1877 11115188 : DFT_L_e_tmp[2 * i] = tmp_e;
1878 11115188 : move16();
1879 : }
1880 : }
1881 :
1882 701020 : test();
1883 701020 : IF( LT_16( b, hStereoDft->res_cod_band_max ) && vad_flag_dtx[0] )
1884 : {
1885 :
1886 : /*Get the previous frame energy*/
1887 86870 : IF( hStereoDft->hConfig->ada_wb_res_cod_mode )
1888 : {
1889 : /*Calculate the energy of RES and DMX*/
1890 : /* 90% of old frame ... */
1891 : // dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.9f;
1892 86870 : dmx_nrg_all_curr = BASOP_Util_Add_Mant32Exp( dmx_nrg_all_curr, dmx_nrg_all_curr_e, Mpy_32_32( hStereoDft->res_cod_NRG_M_fx[b], 1932735283 /*0.9f*/ ), hStereoDft->res_cod_NRG_M_fx_e[b], &dmx_nrg_all_curr_e );
1893 : // res_nrg_all_curr += hStereoDft->res_cod_NRG_S[b] * 0.9f;
1894 86870 : res_nrg_all_curr = BASOP_Util_Add_Mant32Exp( res_nrg_all_curr, res_nrg_all_curr_e, Mpy_32_32( hStereoDft->res_cod_NRG_S_fx[b], 1932735283 /*0.9f*/ ), hStereoDft->res_cod_NRG_S_fx_e[b], &res_nrg_all_curr_e );
1895 : }
1896 86870 : hStereoDft->res_cod_NRG_M_fx[b] = EPSILON_FX_M;
1897 86870 : move32();
1898 86870 : hStereoDft->res_cod_NRG_M_fx_e[b] = EPSILON_FX_E;
1899 86870 : move16();
1900 86870 : hStereoDft->res_cod_NRG_S_fx[b] = EPSILON_FX_M;
1901 86870 : move32();
1902 86870 : hStereoDft->res_cod_NRG_S_fx_e[b] = EPSILON_FX_E;
1903 86870 : move16();
1904 :
1905 799204 : FOR( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
1906 : {
1907 : // pDFT_DMX[2 * i] = ( pDFT_L[2 * i] + pDFT_R[2 * i] ) * 0.5f;
1908 712334 : pDFT_DMX[2 * i] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i], DFT_L_e_tmp[2 * i], pDFT_R_fx[2 * i], DFT_R_e_tmp[2 * i], &DFT_DMX_e[2 * i] );
1909 712334 : move32();
1910 712334 : DFT_DMX_e[2 * i] = sub( DFT_DMX_e[2 * i], 1 ); // * 0.5f
1911 712334 : move16();
1912 : // pDFT_DMX[2 * i + 1] = ( pDFT_L[2 * i + 1] + pDFT_R[2 * i + 1] ) * 0.5f;
1913 712334 : pDFT_DMX[2 * i + 1] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i + 1], DFT_L_e_tmp[2 * i + 1], pDFT_R_fx[2 * i + 1], DFT_R_e_tmp[2 * i + 1], &DFT_DMX_e[2 * i + 1] );
1914 712334 : move32();
1915 712334 : DFT_DMX_e[2 * i + 1] = sub( DFT_DMX_e[2 * i + 1], 1 ); // * 0.5f
1916 712334 : move16();
1917 :
1918 : // pDFT_RES[2 * i] = ( pDFT_L[2 * i] - pDFT_R[2 * i] ) * 0.5f;
1919 712334 : pDFT_RES[2 * i] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i], DFT_L_e_tmp[2 * i], L_negate( pDFT_R_fx[2 * i] ), DFT_R_e_tmp[2 * i], &DFT_RES_e[2 * i] );
1920 712334 : move32();
1921 712334 : DFT_RES_e[2 * i] = sub( DFT_RES_e[2 * i], 1 ); // * 0.5f
1922 712334 : move16();
1923 : // pDFT_RES[2 * i + 1] = ( pDFT_L[2 * i + 1] - pDFT_R[2 * i + 1] ) * 0.5f;
1924 712334 : pDFT_RES[2 * i + 1] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i + 1], DFT_L_e_tmp[2 * i + 1], L_negate( pDFT_R_fx[2 * i + 1] ), DFT_R_e_tmp[2 * i + 1], &DFT_RES_e[2 * i + 1] );
1925 712334 : move32();
1926 712334 : DFT_RES_e[2 * i + 1] = sub( DFT_RES_e[2 * i + 1], 1 ); // * 0.5f
1927 712334 : move16();
1928 :
1929 : /*Prediction of RES with DMX*/
1930 : // pDFT_RES[2 * i] = pDFT_RES[2 * i] - g * pDFT_DMX[2 * i];
1931 712334 : pDFT_RES[2 * i] = BASOP_Util_Add_Mant32Exp( pDFT_RES[2 * i], DFT_RES_e[2 * i], L_negate( Mpy_32_32( g_fx, pDFT_DMX[2 * i] ) ), DFT_DMX_e[2 * i], &DFT_RES_e[2 * i] );
1932 712334 : move32();
1933 : // pDFT_RES[2 * i + 1] = pDFT_RES[2 * i + 1] - g * pDFT_DMX[2 * i + 1];
1934 712334 : pDFT_RES[2 * i + 1] = BASOP_Util_Add_Mant32Exp( pDFT_RES[2 * i + 1], DFT_RES_e[2 * i + 1], L_negate( Mpy_32_32( g_fx, pDFT_DMX[2 * i + 1] ) ), DFT_DMX_e[2 * i + 1], &DFT_RES_e[2 * i + 1] );
1935 712334 : move32();
1936 :
1937 : // pDFT_RES[2 * i] *= fac_att;
1938 712334 : pDFT_RES[2 * i] = Mpy_32_16_1( pDFT_RES[2 * i], fac_att_fx );
1939 712334 : move32();
1940 : // pDFT_RES[2 * i + 1] *= fac_att;
1941 712334 : pDFT_RES[2 * i + 1] = Mpy_32_16_1( pDFT_RES[2 * i + 1], fac_att_fx );
1942 712334 : move32();
1943 :
1944 : /*Energy of the DMX and RES*/
1945 : // hStereoDft->res_cod_NRG_M[b] += pDFT_DMX[2 * i] * pDFT_DMX[2 * i] + pDFT_DMX[2 * i + 1] * pDFT_DMX[2 * i + 1];
1946 712334 : tmp_32fx = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_DMX[2 * i], pDFT_DMX[2 * i] ), shl( DFT_DMX_e[2 * i], 1 ), Mpy_32_32( pDFT_DMX[2 * i + 1], pDFT_DMX[2 * i + 1] ), shl( DFT_DMX_e[2 * i + 1], 1 ), &tmp_e );
1947 712334 : hStereoDft->res_cod_NRG_M_fx[b] = BASOP_Util_Add_Mant32Exp( hStereoDft->res_cod_NRG_M_fx[b], hStereoDft->res_cod_NRG_M_fx_e[b], tmp_32fx, tmp_e, &hStereoDft->res_cod_NRG_M_fx_e[b] );
1948 712334 : move32();
1949 : // hStereoDft->res_cod_NRG_S[b] += pDFT_RES[2 * i] * pDFT_RES[2 * i] + pDFT_RES[2 * i + 1] * pDFT_RES[2 * i + 1];
1950 712334 : tmp_32fx = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_RES[2 * i], pDFT_RES[2 * i] ), shl( DFT_RES_e[2 * i], 1 ), Mpy_32_32( pDFT_RES[2 * i + 1], pDFT_RES[2 * i + 1] ), shl( DFT_RES_e[2 * i + 1], 1 ), &tmp_e );
1951 712334 : hStereoDft->res_cod_NRG_S_fx[b] = BASOP_Util_Add_Mant32Exp( hStereoDft->res_cod_NRG_S_fx[b], hStereoDft->res_cod_NRG_S_fx_e[b], tmp_32fx, tmp_e, &hStereoDft->res_cod_NRG_S_fx_e[b] );
1952 712334 : move32();
1953 : }
1954 :
1955 86870 : IF( hStereoDft->hConfig->ada_wb_res_cod_mode )
1956 : {
1957 : /*Calculate the energy of RES and DMX*/
1958 : /* ... + 10% of current frame. */
1959 : // dmx_nrg_all_curr += hStereoDft->res_cod_NRG_M[b] * 0.1f;
1960 86870 : dmx_nrg_all_curr = BASOP_Util_Add_Mant32Exp( dmx_nrg_all_curr, dmx_nrg_all_curr_e, Mpy_32_32( hStereoDft->res_cod_NRG_M_fx[b], 214748365 /*0.1f*/ ), hStereoDft->res_cod_NRG_M_fx_e[b], &dmx_nrg_all_curr_e );
1961 : // res_nrg_all_curr += hStereoDft->res_cod_NRG_S[b] * 0.1f;
1962 86870 : res_nrg_all_curr = BASOP_Util_Add_Mant32Exp( res_nrg_all_curr, res_nrg_all_curr_e, Mpy_32_32( hStereoDft->res_cod_NRG_S_fx[b], 214748365 /*0.1f*/ ), hStereoDft->res_cod_NRG_S_fx_e[b], &res_nrg_all_curr_e );
1963 : }
1964 : }
1965 : ELSE
1966 : {
1967 : Word16 upper_border;
1968 : Word16 triple_bin;
1969 : Word32 frac_dot_prod; /* fraction of dot product according to energy ratio of current bins and whole band */
1970 : Word16 frac_dot_prod_e; /* fraction of dot product according to energy ratio of current bins and whole band */
1971 : Word32 Sr, Si;
1972 : Word16 Sr_e, Si_e;
1973 : Word32 comb_nrgL, comb_nrgR;
1974 : Word16 comb_nrgL_e, comb_nrgR_e;
1975 :
1976 614150 : upper_border = s_min( STEREO_DFT_DMX_CROSSOVER, hStereoDft->band_limits_dmx[b + 1] );
1977 :
1978 614150 : triple_bin = 0;
1979 614150 : move16();
1980 :
1981 614150 : test();
1982 614150 : IF( GT_16( upper_border, hStereoDft->band_limits_dmx[b] ) && sub( upper_border, hStereoDft->band_limits_dmx[b] ) % 2 )
1983 : {
1984 : /* if odd number of bins in band, combine last 3 bins */
1985 186450 : triple_bin = 1;
1986 186450 : move16();
1987 186450 : upper_border = sub( upper_border, 3 );
1988 : }
1989 :
1990 6240823 : FOR( i = hStereoDft->band_limits_dmx[b]; i < upper_border; i += 2 )
1991 : {
1992 : // comb_nrgL = pNrgL[i] + pNrgL[i + 1];
1993 5626673 : comb_nrgL = BASOP_Util_Add_Mant32Exp( pNrgL[i], bin_nrgL_fx_e[i], pNrgL[i + 1], bin_nrgL_fx_e[i + 1], &comb_nrgL_e );
1994 : // comb_nrgR = pNrgR[i] + pNrgR[i + 1];
1995 5626673 : comb_nrgR = BASOP_Util_Add_Mant32Exp( pNrgR[i], bin_nrgR_fx_e[i], pNrgR[i + 1], bin_nrgR_fx_e[i + 1], &comb_nrgR_e );
1996 :
1997 : // 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] );
1998 5626673 : L_tmp1 = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i], DFT_L_e_tmp[2 * i], pDFT_R_fx[2 * i], DFT_R_e_tmp[2 * i], &L_tmp1_e );
1999 5626673 : L_tmp2 = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i + 2], DFT_L_e_tmp[2 * i + 2], pDFT_R_fx[2 * i + 2], DFT_R_e_tmp[2 * i + 2], &L_tmp2_e );
2000 5626673 : Sr = BASOP_Util_Add_Mant32Exp( Mpy_32_32( L_tmp1, L_tmp1 ), shl( L_tmp1_e, 1 ), Mpy_32_32( L_tmp2, L_tmp2 ), shl( L_tmp2_e, 1 ), &Sr_e );
2001 :
2002 : // 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] );
2003 5626673 : L_tmp1 = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i + 1], DFT_L_e_tmp[2 * i + 1], pDFT_R_fx[2 * i + 1], DFT_R_e_tmp[2 * i + 1], &L_tmp1_e );
2004 5626673 : L_tmp2 = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * i + 3], DFT_L_e_tmp[2 * i + 3], pDFT_R_fx[2 * i + 3], DFT_R_e_tmp[2 * i + 3], &L_tmp2_e );
2005 5626673 : Si = BASOP_Util_Add_Mant32Exp( Mpy_32_32( L_tmp1, L_tmp1 ), shl( L_tmp1_e, 1 ), Mpy_32_32( L_tmp2, L_tmp2 ), shl( L_tmp2_e, 1 ), &Si_e );
2006 :
2007 : // sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
2008 5626673 : L_tmp1 = comb_nrgL;
2009 5626673 : move32();
2010 5626673 : L_tmp1_e = comb_nrgL_e;
2011 5626673 : move16();
2012 5626673 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2013 5626673 : L_tmp2 = comb_nrgR;
2014 5626673 : move32();
2015 5626673 : L_tmp2_e = comb_nrgR_e;
2016 5626673 : move16();
2017 5626673 : L_tmp2 = Sqrt32( L_tmp2, &L_tmp2_e );
2018 5626673 : sum_abs = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, L_tmp2, L_tmp2_e, &sum_abs_e );
2019 5626673 : sum_abs = BASOP_Util_Add_Mant32Exp( sum_abs, sum_abs_e, EPSILON_FX_M, EPSILON_FX_E, &sum_abs_e );
2020 :
2021 : // frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
2022 5626673 : L_tmp1 = BASOP_Util_Add_Mant32Exp( comb_nrgL, comb_nrgL_e, comb_nrgR, comb_nrgR_e, &L_tmp1_e );
2023 5626673 : frac_dot_prod = Mpy_32_32( L_tmp1, dot_prod_nrg_ratio_fx[b] );
2024 5626673 : frac_dot_prod_e = add( L_tmp1_e, dot_prod_nrg_ratio_fx_e[b] );
2025 :
2026 : // wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
2027 5626673 : L_tmp1 = BASOP_Util_Add_Mant32Exp( L_tmp1, sub( L_tmp1_e, 1 ), frac_dot_prod, frac_dot_prod_e, &L_tmp1_e );
2028 5626673 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2029 5626673 : wR = BASOP_Util_Divide3232_Scale_newton( L_tmp1, sum_abs, &wR_e );
2030 5626673 : wR_e = add( wR_e, sub( L_tmp1_e, sum_abs_e ) );
2031 :
2032 : // wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
2033 5626673 : L_tmp1 = BASOP_Util_Add_Mant32Exp( Sr, Sr_e, Si, Si_e, &L_tmp1_e );
2034 5626673 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2035 5626673 : L_tmp2 = BASOP_Util_Divide3232_Scale_newton( L_tmp1, sum_abs, &L_tmp2_e );
2036 5626673 : L_tmp2_e = add( L_tmp2_e, sub( L_tmp1_e, sum_abs_e ) );
2037 5626673 : L_tmp2 = L_shl_sat( L_tmp2, L_tmp2_e ); // Q31 saturation expected
2038 5626673 : L_tmp1 = L_sub( MAX_32, L_tmp2 ); // Q31
2039 5626673 : L_tmp1 = Mpy_32_32( 1518500250 /*sqrtf(2.f) in Q30*/, L_tmp1 ); // Q30
2040 5626673 : wL = BASOP_Util_Add_Mant32Exp( wR, wR_e, L_tmp1, 1 /*Q30*/, &wL_e );
2041 :
2042 : /*DMX Mapping*/
2043 : // pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
2044 5626673 : pDFT_DMX[2 * i] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * i] ), add( wL_e, DFT_L_e_tmp[2 * i] ), Mpy_32_32( wR, pDFT_R_fx[2 * i] ), add( wR_e, DFT_R_e_tmp[2 * i] ), &DFT_DMX_e[2 * i] ), INV_SQRT_2_Q31 );
2045 5626673 : move32();
2046 : // pDFT_DMX[2 * i + 1] = ( wL * pDFT_L[2 * i + 1] + wR * pDFT_R[2 * i + 1] ) * INV_SQRT_2;
2047 5626673 : pDFT_DMX[2 * i + 1] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * i + 1] ), add( wL_e, DFT_L_e_tmp[2 * i + 1] ), Mpy_32_32( wR, pDFT_R_fx[2 * i + 1] ), add( wR_e, DFT_R_e_tmp[2 * i + 1] ), &DFT_DMX_e[2 * i + 1] ), INV_SQRT_2_Q31 );
2048 5626673 : move32();
2049 : // pDFT_DMX[2 * i + 2] = ( wL * pDFT_L[2 * i + 2] + wR * pDFT_R[2 * i + 2] ) * INV_SQRT_2;
2050 5626673 : pDFT_DMX[2 * i + 2] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * i + 2] ), add( wL_e, DFT_L_e_tmp[2 * i + 2] ), Mpy_32_32( wR, pDFT_R_fx[2 * i + 2] ), add( wR_e, DFT_R_e_tmp[2 * i + 2] ), &DFT_DMX_e[2 * i + 2] ), INV_SQRT_2_Q31 );
2051 5626673 : move32();
2052 : // pDFT_DMX[2 * i + 3] = ( wL * pDFT_L[2 * i + 3] + wR * pDFT_R[2 * i + 3] ) * INV_SQRT_2;
2053 5626673 : pDFT_DMX[2 * i + 3] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * i + 3] ), add( wL_e, DFT_L_e_tmp[2 * i + 3] ), Mpy_32_32( wR, pDFT_R_fx[2 * i + 3] ), add( wR_e, DFT_R_e_tmp[2 * i + 3] ), &DFT_DMX_e[2 * i + 3] ), INV_SQRT_2_Q31 );
2054 5626673 : move32();
2055 : }
2056 :
2057 614150 : IF( triple_bin )
2058 : {
2059 186450 : comb_nrgL = comb_nrgR = 0;
2060 186450 : move32();
2061 186450 : move32();
2062 186450 : comb_nrgL_e = comb_nrgR_e = 0;
2063 186450 : move16();
2064 186450 : move16();
2065 186450 : Sr = Si = 0;
2066 186450 : move32();
2067 186450 : move32();
2068 186450 : Sr_e = Si_e = 0;
2069 186450 : move16();
2070 186450 : move16();
2071 745800 : FOR( j = i; j < i + 3; j++ )
2072 : {
2073 : // comb_nrgL += pNrgL[j];
2074 559350 : comb_nrgL = BASOP_Util_Add_Mant32Exp( comb_nrgL, comb_nrgL_e, pNrgL[j], bin_nrgL_fx_e[j], &comb_nrgL_e );
2075 :
2076 : // comb_nrgR += pNrgR[j];
2077 559350 : comb_nrgR = BASOP_Util_Add_Mant32Exp( comb_nrgR, comb_nrgR_e, pNrgR[j], bin_nrgR_fx_e[j], &comb_nrgR_e );
2078 :
2079 : // Sr += ( pDFT_L[2 * j] + pDFT_R[2 * j] ) * ( pDFT_L[2 * j] + pDFT_R[2 * j] );
2080 559350 : L_tmp1 = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * j], DFT_L_e_tmp[2 * j], pDFT_R_fx[2 * j], DFT_R_e_tmp[2 * j], &L_tmp1_e );
2081 559350 : L_tmp1 = Mpy_32_32( L_tmp1, L_tmp1 );
2082 559350 : L_tmp1_e = shl( L_tmp1_e, 1 );
2083 559350 : Sr = BASOP_Util_Add_Mant32Exp( Sr, Sr_e, L_tmp1, L_tmp1_e, &Sr_e );
2084 :
2085 : // Si += ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] ) * ( pDFT_L[2 * j + 1] + pDFT_R[2 * j + 1] );
2086 559350 : L_tmp2 = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[2 * j + 1], DFT_L_e_tmp[2 * j + 1], pDFT_R_fx[2 * j + 1], DFT_R_e_tmp[2 * j + 1], &L_tmp2_e );
2087 559350 : L_tmp2 = Mpy_32_32( L_tmp2, L_tmp2 );
2088 559350 : L_tmp2_e = shl( L_tmp2_e, 1 );
2089 559350 : Si = BASOP_Util_Add_Mant32Exp( Si, Si_e, L_tmp2, L_tmp2_e, &Si_e );
2090 : }
2091 :
2092 : // sum_abs = sqrtf( comb_nrgL ) + sqrtf( comb_nrgR ) + EPSILON;
2093 186450 : L_tmp1 = comb_nrgL;
2094 186450 : move32();
2095 186450 : L_tmp1_e = comb_nrgL_e;
2096 186450 : move16();
2097 186450 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2098 186450 : L_tmp2 = comb_nrgR;
2099 186450 : move32();
2100 186450 : L_tmp2_e = comb_nrgR_e;
2101 186450 : move16();
2102 186450 : L_tmp2 = Sqrt32( L_tmp2, &L_tmp2_e );
2103 186450 : sum_abs = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, L_tmp2, L_tmp2_e, &sum_abs_e );
2104 186450 : sum_abs = BASOP_Util_Add_Mant32Exp( sum_abs, sum_abs_e, EPSILON_FX_M, EPSILON_FX_E, &sum_abs_e );
2105 :
2106 : // frac_dot_prod = ( comb_nrgL + comb_nrgR ) * dot_prod_nrg_ratio[b];
2107 186450 : L_tmp1 = BASOP_Util_Add_Mant32Exp( comb_nrgL, comb_nrgL_e, comb_nrgR, comb_nrgR_e, &L_tmp1_e );
2108 186450 : frac_dot_prod = Mpy_32_32( L_tmp1, dot_prod_nrg_ratio_fx[b] );
2109 186450 : frac_dot_prod_e = add( L_tmp1_e, dot_prod_nrg_ratio_fx_e[b] );
2110 :
2111 : // wR = sqrtf( 0.5f * ( comb_nrgL + comb_nrgR ) + frac_dot_prod ) / sum_abs;
2112 186450 : L_tmp1 = BASOP_Util_Add_Mant32Exp( L_tmp1, sub( L_tmp1_e, 1 ), frac_dot_prod, frac_dot_prod_e, &L_tmp1_e );
2113 186450 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2114 186450 : wR = BASOP_Util_Divide3232_Scale_newton( L_tmp1, sum_abs, &wR_e );
2115 186450 : wR_e = add( wR_e, sub( L_tmp1_e, sum_abs_e ) );
2116 :
2117 : // wL = wR + sqrtf( 2.f ) * ( 1.f - ( sqrtf( Sr + Si ) / sum_abs ) );
2118 186450 : L_tmp1 = BASOP_Util_Add_Mant32Exp( Sr, Sr_e, Si, Si_e, &L_tmp1_e );
2119 186450 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2120 186450 : L_tmp2 = BASOP_Util_Divide3232_Scale_newton( L_tmp1, sum_abs, &L_tmp2_e );
2121 186450 : L_tmp2_e = add( L_tmp2_e, sub( L_tmp1_e, sum_abs_e ) );
2122 186450 : L_tmp2 = L_shl_sat( L_tmp2, L_tmp2_e ); // Q31 saturation expected
2123 186450 : L_tmp1 = L_sub( MAX_32, L_tmp2 ); // Q31
2124 186450 : L_tmp1 = Mpy_32_32( 1518500250 /*sqrtf(2.f) in Q30*/, L_tmp1 ); // Q30
2125 186450 : wL = BASOP_Util_Add_Mant32Exp( wR, wR_e, L_tmp1, 1 /*Q30*/, &wL_e );
2126 :
2127 745800 : FOR( j = i; j < i + 3; j++ )
2128 : {
2129 : // pDFT_DMX[2 * j] = ( wL * pDFT_L[2 * j] + wR * pDFT_R[2 * j] ) * INV_SQRT_2;
2130 559350 : pDFT_DMX[2 * j] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * j] ), add( wL_e, DFT_L_e_tmp[2 * j] ), Mpy_32_32( wR, pDFT_R_fx[2 * j] ), add( wR_e, DFT_R_e_tmp[2 * j] ), &DFT_DMX_e[2 * j] ), INV_SQRT_2_Q31 );
2131 559350 : move32();
2132 : // pDFT_DMX[2 * j + 1] = ( wL * pDFT_L[2 * j + 1] + wR * pDFT_R[2 * j + 1] ) * INV_SQRT_2;
2133 559350 : pDFT_DMX[2 * j + 1] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * j + 1] ), add( wL_e, DFT_L_e_tmp[2 * j + 1] ), Mpy_32_32( wR, pDFT_R_fx[2 * j + 1] ), add( wR_e, DFT_R_e_tmp[2 * j + 1] ), &DFT_DMX_e[2 * j + 1] ), INV_SQRT_2_Q31 );
2134 559350 : move32();
2135 : }
2136 186450 : i = add( i, 3 );
2137 : }
2138 :
2139 614150 : IF( LT_16( i, hStereoDft->band_limits_dmx[b + 1] ) )
2140 : {
2141 164233 : sum_nrg_L2 = EPSILON_FX_M;
2142 164233 : move32();
2143 164233 : sum_nrg_L2_e = EPSILON_FX_E;
2144 164233 : move16();
2145 164233 : sum_nrg_R2 = EPSILON_FX_M;
2146 164233 : move32();
2147 164233 : sum_nrg_R2_e = EPSILON_FX_E;
2148 164233 : move16();
2149 164233 : dot_prod_real2 = EPSILON_FX_M;
2150 164233 : move32();
2151 164233 : dot_prod_real2_e = EPSILON_FX_E;
2152 164233 : move16();
2153 25177960 : FOR( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
2154 : {
2155 : // sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
2156 25013727 : L_tmp1 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L_fx[2 * j], pDFT_L_fx[2 * j] ), shl( DFT_L_e_tmp[2 * j], 1 ), Mpy_32_32( pDFT_L_fx[2 * j + 1], pDFT_L_fx[2 * j + 1] ), shl( DFT_L_e_tmp[2 * j + 1], 1 ), &L_tmp1_e );
2157 25013727 : sum_nrg_L2 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, L_tmp1, L_tmp1_e, &sum_nrg_L2_e );
2158 : // sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
2159 25013727 : L_tmp1 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_R_fx[2 * j], pDFT_R_fx[2 * j] ), shl( DFT_R_e_tmp[2 * j], 1 ), Mpy_32_32( pDFT_R_fx[2 * j + 1], pDFT_R_fx[2 * j + 1] ), shl( DFT_R_e_tmp[2 * j + 1], 1 ), &L_tmp1_e );
2160 25013727 : sum_nrg_R2 = BASOP_Util_Add_Mant32Exp( sum_nrg_R2, sum_nrg_R2_e, L_tmp1, L_tmp1_e, &sum_nrg_R2_e );
2161 : // dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
2162 25013727 : L_tmp1 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L_fx[2 * j], pDFT_R_fx[2 * j] ), add( DFT_L_e_tmp[2 * j], DFT_R_e_tmp[2 * j] ), Mpy_32_32( pDFT_L_fx[2 * j + 1], pDFT_R_fx[2 * j + 1] ), add( DFT_L_e_tmp[2 * j + 1], DFT_R_e_tmp[2 * j + 1] ), &L_tmp1_e );
2163 25013727 : dot_prod_real2 = BASOP_Util_Add_Mant32Exp( dot_prod_real2, dot_prod_real2_e, L_tmp1, L_tmp1_e, &dot_prod_real2_e );
2164 : }
2165 :
2166 : // sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
2167 164233 : L_tmp3 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, sum_nrg_R2, sum_nrg_R2_e, &L_tmp3_e );
2168 164233 : sum_nrg_Mid = BASOP_Util_Add_Mant32Exp( L_tmp3, L_tmp3_e, dot_prod_real2, add( dot_prod_real2_e, 1 ), &sum_nrg_Mid_e );
2169 164233 : IF( sum_nrg_Mid < 0 )
2170 : {
2171 0 : sum_nrg_Mid = 0;
2172 0 : move32();
2173 0 : sum_nrg_Mid_e = 0;
2174 0 : move16();
2175 : }
2176 :
2177 : // sum_abs = sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) + EPSILON;
2178 164233 : L_tmp1 = sum_nrg_L2;
2179 164233 : move32();
2180 164233 : L_tmp1_e = sum_nrg_L2_e;
2181 164233 : move16();
2182 164233 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2183 164233 : L_tmp2 = sum_nrg_R2;
2184 164233 : move32();
2185 164233 : L_tmp2_e = sum_nrg_R2_e;
2186 164233 : move16();
2187 164233 : L_tmp2 = Sqrt32( L_tmp2, &L_tmp2_e );
2188 164233 : sum_abs = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, L_tmp2, L_tmp2_e, &sum_abs_e );
2189 164233 : sum_abs = BASOP_Util_Add_Mant32Exp( sum_abs, sum_abs_e, EPSILON_FX_M, EPSILON_FX_E, &sum_abs_e );
2190 :
2191 : // wR = sqrtf( 0.5f * ( sum_nrg_L2 + sum_nrg_R2 ) + dot_prod_nrg_ratio[b] ) / sum_abs;
2192 164233 : L_tmp1 = BASOP_Util_Add_Mant32Exp( L_tmp3, sub( L_tmp3_e, 1 ), dot_prod_nrg_ratio_fx[b], dot_prod_nrg_ratio_fx_e[b], &L_tmp1_e );
2193 164233 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2194 164233 : wR = BASOP_Util_Divide3232_Scale_newton( L_tmp1, sum_abs, &wR_e );
2195 164233 : wR_e = add( wR_e, sub( L_tmp1_e, sum_abs_e ) );
2196 :
2197 : // wL = wR + sqrtf( 2.f ) * ( 1.f - sqrtf( sum_nrg_Mid ) / sum_abs );
2198 164233 : L_tmp1 = sum_nrg_Mid;
2199 164233 : move32();
2200 164233 : L_tmp1_e = sum_nrg_Mid_e;
2201 164233 : move16();
2202 164233 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
2203 164233 : L_tmp2 = BASOP_Util_Divide3232_Scale_newton( L_tmp1, sum_abs, &L_tmp2_e );
2204 164233 : L_tmp2_e = add( L_tmp2_e, sub( L_tmp1_e, sum_abs_e ) );
2205 164233 : L_tmp2 = L_shl_sat( L_tmp2, L_tmp2_e ); // Q31 saturation expected
2206 164233 : L_tmp1 = L_sub( MAX_32, L_tmp2 ); // Q31
2207 164233 : L_tmp1 = Mpy_32_32( 1518500250 /*sqrtf(2.f) in Q30*/, L_tmp1 ); // Q30
2208 164233 : wL = BASOP_Util_Add_Mant32Exp( wR, wR_e, L_tmp1, 1 /*Q30*/, &wL_e );
2209 : }
2210 :
2211 25627877 : FOR( ; i < hStereoDft->band_limits_dmx[b + 1]; i++ )
2212 : {
2213 : /*DMX Mapping*/
2214 : // pDFT_DMX[2 * i] = ( wL * pDFT_L[2 * i] + wR * pDFT_R[2 * i] ) * INV_SQRT_2;
2215 25013727 : pDFT_DMX[2 * i] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * i] ), add( wL_e, DFT_L_e_tmp[2 * i] ), Mpy_32_32( wR, pDFT_R_fx[2 * i] ), add( wR_e, DFT_R_e_tmp[2 * i] ), &DFT_DMX_e[2 * i] ), INV_SQRT_2_Q31 );
2216 25013727 : move32();
2217 : // pDFT_DMX[2 * i + 1] = ( wL * pDFT_L[2 * i + 1] + wR * pDFT_R[2 * i + 1] ) * INV_SQRT_2;
2218 25013727 : pDFT_DMX[2 * i + 1] = Mpy_32_32( BASOP_Util_Add_Mant32Exp( Mpy_32_32( wL, pDFT_L_fx[2 * i + 1] ), add( wL_e, DFT_L_e_tmp[2 * i + 1] ), Mpy_32_32( wR, pDFT_R_fx[2 * i + 1] ), add( wR_e, DFT_R_e_tmp[2 * i + 1] ), &DFT_DMX_e[2 * i + 1] ), INV_SQRT_2_Q31 );
2219 25013727 : move32();
2220 : }
2221 : }
2222 : }
2223 :
2224 3653243 : FOR( i = hStereoDft->band_limits_dmx[b]; i < hStereoDft->NFFT / 2; i++ )
2225 : {
2226 3593600 : pDFT_DMX[2 * i] = 0;
2227 3593600 : move32();
2228 3593600 : DFT_DMX_e[2 * i] = 0;
2229 3593600 : move16();
2230 3593600 : pDFT_DMX[2 * i + 1] = 0;
2231 3593600 : move32();
2232 3593600 : DFT_DMX_e[2 * i + 1] = 0;
2233 3593600 : move16();
2234 : }
2235 :
2236 : /*Nyquist Freq.*/
2237 59643 : IF( GE_16( hStereoDft->band_limits_dmx[b], shr( hStereoDft->NFFT, 1 ) ) )
2238 : {
2239 : // pDFT_DMX[1] = ( pDFT_L[1] + pDFT_R[1] ) * 0.5f;
2240 49452 : pDFT_DMX[1] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[1], DFT_L_e_tmp[1], pDFT_R_fx[1], DFT_R_e_tmp[1], &DFT_DMX_e[1] );
2241 49452 : move32();
2242 49452 : DFT_DMX_e[1] = sub( DFT_DMX_e[1], 1 );
2243 49452 : move16();
2244 : }
2245 : ELSE
2246 : {
2247 10191 : pDFT_DMX[1] = 0;
2248 10191 : move32();
2249 10191 : DFT_DMX_e[1] = 0;
2250 10191 : move16();
2251 : }
2252 :
2253 : /* DC component */
2254 : // pDFT_DMX[0] = ( pDFT_L[0] + pDFT_R[0] ) * 0.5f;
2255 59643 : pDFT_DMX[0] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[0], DFT_L_e_tmp[0], pDFT_R_fx[0], DFT_R_e_tmp[0], &DFT_DMX_e[0] );
2256 59643 : move32();
2257 59643 : DFT_DMX_e[0] = sub( DFT_DMX_e[0], 1 );
2258 59643 : move16();
2259 : }
2260 : ELSE
2261 : {
2262 : /*passive DMX*/
2263 0 : assert( hStereoDft->nbands == hStereoDft->nbands_dmx && "Don't use coarser stereo parameter resolution for residual coding bitrates!" );
2264 0 : FOR( i = 0; i < hStereoDft->band_limits[hStereoDft->res_cod_band_max]; i++ )
2265 : {
2266 : // pDFT_DMX[i] = ( pDFT_L[i] + pDFT_R[i] ) * 0.5f;
2267 0 : pDFT_DMX[i] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[i], DFT_L_e_tmp[i], pDFT_R_fx[i], DFT_R_e_tmp[i], &DFT_DMX_e[i] );
2268 0 : move32();
2269 0 : DFT_DMX_e[i] = sub( DFT_DMX_e[i], 1 );
2270 0 : move16();
2271 : // pDFT_RES[i] = ( pDFT_L[i] - pDFT_R[i] ) * 0.5f;
2272 0 : pDFT_RES[i] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[i], DFT_L_e_tmp[i], L_negate( pDFT_R_fx[i] ), DFT_R_e_tmp[i], &DFT_RES_e[i] );
2273 0 : move32();
2274 0 : DFT_RES_e[i] = sub( DFT_RES_e[i], 1 );
2275 0 : move16();
2276 : }
2277 0 : FOR( ; i < hStereoDft->NFFT; i++ )
2278 : {
2279 : // pDFT_DMX[i] = ( pDFT_L[i] + pDFT_R[i] ) * 0.5f;
2280 0 : pDFT_DMX[i] = BASOP_Util_Add_Mant32Exp( pDFT_L_fx[i], DFT_L_e_tmp[i], pDFT_R_fx[i], DFT_R_e_tmp[i], &DFT_DMX_e[i] );
2281 0 : move32();
2282 0 : DFT_DMX_e[i] = sub( DFT_DMX_e[i], 1 );
2283 0 : move16();
2284 : }
2285 : }
2286 :
2287 : /*------------------------------------------------------------------*
2288 : * Recalculate RES and DMX
2289 : *-----------------------------------------------------------------*/
2290 :
2291 59643 : test();
2292 59643 : IF( EQ_16( hStereoDft->NFFT, STEREO_DFT_N_16k_ENC ) && hStereoDft->hConfig->ada_wb_res_cod_mode )
2293 : {
2294 2796 : stereo_dft_enc_get_res_cod_mode_flag_fx( hStereoDft, res_nrg_all_curr, res_nrg_all_curr_e, dmx_nrg_all_curr, dmx_nrg_all_curr_e, &res_dmx_ratio, &frame_nrg_ratio );
2295 :
2296 2796 : IF( hStereoDft->res_cod_sw_flag )
2297 : {
2298 : Word16 res_cod_band_max;
2299 :
2300 59 : res_cod_band_max = dft_band_res_cod[hStereoDft->band_res[k_offset]][hStereoDft->hConfig->ada_wb_res_cod_mode];
2301 59 : move16();
2302 :
2303 : /* Recalculate RES and DMX */
2304 354 : FOR( b = 0; b < res_cod_band_max; b++ )
2305 : {
2306 295 : sum_nrg_L2 = EPSILON_FX_M;
2307 295 : move32();
2308 295 : sum_nrg_L2_e = EPSILON_FX_E;
2309 295 : move16();
2310 295 : sum_nrg_R2 = EPSILON_FX_M;
2311 295 : move32();
2312 295 : sum_nrg_R2_e = EPSILON_FX_E;
2313 295 : move16();
2314 295 : dot_prod_real2 = EPSILON_FX_M;
2315 295 : move32();
2316 295 : dot_prod_real2_e = EPSILON_FX_E;
2317 295 : move16();
2318 2714 : FOR( j = hStereoDft->band_limits_dmx[b]; j < hStereoDft->band_limits_dmx[b + 1]; j++ )
2319 : {
2320 : // sum_nrg_L2 += pDFT_L[2 * j] * pDFT_L[2 * j] + pDFT_L[2 * j + 1] * pDFT_L[2 * j + 1];
2321 2419 : L_tmp1 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L_fx[2 * j], pDFT_L_fx[2 * j] ), shl( DFT_L_e_tmp[2 * j], 1 ), Mpy_32_32( pDFT_L_fx[2 * j + 1], pDFT_L_fx[2 * j + 1] ), shl( DFT_L_e_tmp[2 * j + 1], 1 ), &L_tmp1_e );
2322 2419 : sum_nrg_L2 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, L_tmp1, L_tmp1_e, &sum_nrg_L2_e );
2323 :
2324 : // sum_nrg_R2 += pDFT_R[2 * j] * pDFT_R[2 * j] + pDFT_R[2 * j + 1] * pDFT_R[2 * j + 1];
2325 2419 : L_tmp2 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_R_fx[2 * j], pDFT_R_fx[2 * j] ), shl( DFT_R_e_tmp[2 * j], 1 ), Mpy_32_32( pDFT_R_fx[2 * j + 1], pDFT_R_fx[2 * j + 1] ), shl( DFT_R_e_tmp[2 * j + 1], 1 ), &L_tmp2_e );
2326 2419 : sum_nrg_R2 = BASOP_Util_Add_Mant32Exp( sum_nrg_R2, sum_nrg_R2_e, L_tmp2, L_tmp2_e, &sum_nrg_R2_e );
2327 :
2328 : // dot_prod_real2 += pDFT_L[2 * j] * pDFT_R[2 * j] + pDFT_L[2 * j + 1] * pDFT_R[2 * j + 1];
2329 2419 : L_tmp3 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L_fx[2 * j], pDFT_R_fx[2 * j] ), add( DFT_L_e_tmp[2 * j], DFT_R_e_tmp[2 * j] ), Mpy_32_32( pDFT_L_fx[2 * j + 1], pDFT_R_fx[2 * j + 1] ), add( DFT_L_e_tmp[2 * j + 1], DFT_R_e_tmp[2 * j + 1] ), &L_tmp3_e );
2330 2419 : dot_prod_real2 = BASOP_Util_Add_Mant32Exp( dot_prod_real2, dot_prod_real2_e, L_tmp3, L_tmp3_e, &dot_prod_real2_e );
2331 : }
2332 :
2333 : // sum_nrg_Mid = max( 0.f, sum_nrg_L2 + sum_nrg_R2 + 2.f * dot_prod_real2 );
2334 295 : L_tmp1 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, sum_nrg_R2, sum_nrg_R2_e, &L_tmp1_e );
2335 295 : sum_nrg_Mid = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, dot_prod_real2, add( dot_prod_real2_e, 1 ), &sum_nrg_Mid_e );
2336 295 : IF( sum_nrg_Mid < 0 )
2337 : {
2338 0 : sum_nrg_Mid = 0;
2339 0 : move32();
2340 0 : sum_nrg_Mid_e = 0;
2341 0 : move16();
2342 : }
2343 :
2344 : // wL = 0.5f * max( sqrtf( sum_nrg_L2 ) + sqrtf( sum_nrg_R2 ) - sqrtf( sum_nrg_Mid ), 0 ) * inv_sqrt( sum_nrg_L2 + EPSILON );
2345 295 : L_tmp1_e = sum_nrg_L2_e;
2346 295 : move16();
2347 295 : L_tmp1 = Sqrt32( sum_nrg_L2, &L_tmp1_e );
2348 295 : L_tmp2_e = sum_nrg_R2_e;
2349 295 : move16();
2350 295 : L_tmp2 = Sqrt32( sum_nrg_R2, &L_tmp2_e );
2351 295 : L_tmp3_e = sum_nrg_Mid_e;
2352 295 : move16();
2353 295 : L_tmp3 = Sqrt32( sum_nrg_Mid, &L_tmp3_e );
2354 295 : wL = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, L_tmp2, L_tmp2_e, &wL_e );
2355 295 : wL = BASOP_Util_Add_Mant32Exp( wL, wL_e, L_negate( L_tmp3 ), L_tmp3_e, &wL_e );
2356 295 : IF( wL < 0 )
2357 : {
2358 0 : wL = 0; // Q31
2359 0 : move32();
2360 : }
2361 : ELSE
2362 : {
2363 295 : L_tmp1 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, EPSILON_FX_M, EPSILON_FX_E, &L_tmp1_e );
2364 295 : L_tmp1 = ISqrt32( L_tmp1, &L_tmp1_e );
2365 295 : wL = Mpy_32_32( wL, L_tmp1 );
2366 295 : wL_e = sub( add( wL_e, L_tmp1_e ), 1 ); // *0.5f
2367 295 : wL = L_shl( wL, wL_e ); // Q31
2368 : }
2369 :
2370 295 : wS = MAX_16; // Q15
2371 295 : move16();
2372 :
2373 295 : IF( hStereoDft->res_cod_sw_flag )
2374 : {
2375 : // wL *= ( 1 - hStereoDft->switch_fade_factor );
2376 295 : wL = Mpy_32_16_1( wL, sub( MAX_16, hStereoDft->switch_fade_factor_fx ) ); // Q31
2377 : // wS = hStereoDft->switch_fade_factor;
2378 295 : wS = hStereoDft->switch_fade_factor_fx; // Q15
2379 295 : move16();
2380 : }
2381 :
2382 2714 : FOR( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ )
2383 : {
2384 : /*DMX Recalculation*/
2385 : // DFT_DMX[2 * i] += wL * pDFT_L[2 * i];
2386 2419 : DFT_DMX[2 * i] = BASOP_Util_Add_Mant32Exp( DFT_DMX[2 * i], DFT_DMX_e[2 * i], Mpy_32_32( pDFT_L_fx[2 * i], wL ), DFT_L_e_tmp[2 * i], &DFT_DMX_e[2 * i] );
2387 2419 : move32();
2388 : // DFT_DMX[2 * i + 1] += wL * pDFT_L[2 * i + 1];
2389 2419 : DFT_DMX[2 * i + 1] = BASOP_Util_Add_Mant32Exp( DFT_DMX[2 * i + 1], DFT_DMX_e[2 * i + 1], Mpy_32_32( pDFT_L_fx[2 * i + 1], wL ), DFT_L_e_tmp[2 * i + 1], &DFT_DMX_e[2 * i + 1] );
2390 2419 : move32();
2391 :
2392 : /*RES Recalculation*/
2393 : // DFT_RES[2 * i] *= wS;
2394 2419 : DFT_RES[2 * i] = Mpy_32_16_1( DFT_RES[2 * i], wS );
2395 2419 : move32();
2396 : // DFT_RES[2 * i + 1] *= wS;
2397 2419 : DFT_RES[2 * i + 1] = Mpy_32_16_1( DFT_RES[2 * i + 1], wS );
2398 2419 : move32();
2399 : }
2400 : }
2401 : }
2402 : }
2403 :
2404 59643 : IF( GE_32( input_Fs, 32000 ) )
2405 : {
2406 48157 : stereo_dft_enc_calculate_nrg_for_icbwe_fx( hStereoDft, DFT_L_e_tmp, DFT_R_e_tmp, DFT_DMX, DFT_DMX_e, input_Fs );
2407 : }
2408 :
2409 : // making exp common
2410 59643 : Word16 max_exp = MIN_16;
2411 59643 : move16();
2412 114574203 : FOR( i = 0; i < STEREO_DFT_N_MAX_ENC; i++ )
2413 : {
2414 114514560 : max_exp = s_max( max_exp, DFT_DMX_e[i] );
2415 : }
2416 114574203 : FOR( i = 0; i < STEREO_DFT_N_MAX_ENC; i++ )
2417 : {
2418 114514560 : DFT_DMX[i] = L_shr_r( DFT_DMX[i], sub( max_exp, DFT_DMX_e[i] ) ); // Q(31-max_exp)
2419 114514560 : move32();
2420 : }
2421 59643 : hStereoDft->DFT_fx_e[0] = max_exp;
2422 59643 : move16();
2423 :
2424 59643 : max_exp = MIN_16;
2425 59643 : move16();
2426 19145403 : FOR( i = 0; i < STEREO_DFT_N_8k_ENC; i++ )
2427 : {
2428 19085760 : max_exp = s_max( max_exp, DFT_RES_e[i] );
2429 : }
2430 19145403 : FOR( i = 0; i < STEREO_DFT_N_8k_ENC; i++ )
2431 : {
2432 19085760 : DFT_RES[i] = L_shr_r( DFT_RES[i], sub( max_exp, DFT_RES_e[i] ) ); // Q(31-max_exp)
2433 19085760 : move32();
2434 : }
2435 59643 : hStereoDft->DFT_fx_e[1] = max_exp;
2436 59643 : move16();
2437 :
2438 59643 : Copy32( DFT_DMX, hStereoDft->DFT_fx[0], STEREO_DFT_N_MAX_ENC );
2439 59643 : Copy32( DFT_RES, hStereoDft->DFT_fx[1], STEREO_DFT_N_8k_ENC );
2440 59643 : set_zero_fx( hStereoDft->DFT_fx[1] + STEREO_DFT_N_8k_ENC, STEREO_DFT_N_MAX_ENC - STEREO_DFT_N_8k_ENC );
2441 :
2442 59643 : return;
2443 : }
2444 : /*-------------------------------------------------------------------------
2445 : * stereo_dft_enc_get_res_cod_mode_flag()
2446 : *
2447 : * Get the residual signal coding flag
2448 : *-------------------------------------------------------------------------*/
2449 2796 : static void stereo_dft_enc_get_res_cod_mode_flag_fx(
2450 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
2451 : const Word32 res_nrg_all_curr, // Q(31-res_nrg_all_curr_e)
2452 : const Word16 res_nrg_all_curr_e,
2453 : const Word32 dmx_nrg_all_curr, // Q(31-dmx_nrg_all_curr_e)
2454 : const Word16 dmx_nrg_all_curr_e,
2455 : Word32 *res_dmx_ratio, // Q31
2456 : Word32 *frame_nrg_ratio ) // Q28
2457 : {
2458 : Word16 b, k_offset;
2459 : Word32 dmx_res_all, g /*Q31*/;
2460 : Word16 dmx_res_all_e;
2461 : Word16 fast_update_flag;
2462 : Word16 prev_res_cod_mode_flag, res_cod_mode_flag;
2463 : Word32 L_tmp1, L_tmp2;
2464 : Word16 L_tmp1_e, L_tmp2_e;
2465 :
2466 2796 : k_offset = STEREO_DFT_OFFSET; /*Add an offset at encoder*/
2467 2796 : move16();
2468 :
2469 : /*Calculate energy ratio between residual signal and downmix signal */
2470 2796 : *res_dmx_ratio = 0;
2471 2796 : move32();
2472 :
2473 16776 : FOR( b = 0; b < hStereoDft->res_cod_band_max; b++ )
2474 : {
2475 : // g = fabsf(hStereoDft->side_gain[(k_offset)*STEREO_DFT_BAND_MAX + b]);
2476 13980 : g = L_abs( hStereoDft->side_gain_fx[(k_offset) *STEREO_DFT_BAND_MAX + b] );
2477 : //*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);
2478 13980 : L_tmp1 = L_sub( MAX_32, g ); // Q31
2479 13980 : L_tmp2 = BASOP_Util_Add_Mant32Exp( hStereoDft->res_cod_NRG_S_fx[b], hStereoDft->res_cod_NRG_S_fx_e[b], Mpy_32_32( Mpy_32_32( L_tmp1, L_tmp1 ), hStereoDft->res_cod_NRG_M_fx[b] ), hStereoDft->res_cod_NRG_M_fx_e[b], &L_tmp2_e );
2480 13980 : L_tmp2 = BASOP_Util_Add_Mant32Exp( L_tmp2, L_tmp2_e, MAX_32, 0, &L_tmp2_e );
2481 13980 : L_tmp1 = BASOP_Util_Divide3232_Scale_newton( hStereoDft->res_cod_NRG_S_fx[b], L_tmp2, &L_tmp1_e );
2482 13980 : L_tmp1_e = add( L_tmp1_e, sub( hStereoDft->res_cod_NRG_S_fx_e[b], L_tmp2_e ) );
2483 13980 : L_tmp1 = L_shl( L_tmp1, L_tmp1_e ); // Q31
2484 13980 : *res_dmx_ratio = L_max( L_tmp1, *res_dmx_ratio );
2485 13980 : move32();
2486 : }
2487 : //*res_dmx_ratio = check_bounds(*res_dmx_ratio, 0, 1); /*should always be satisfied*/
2488 2796 : *res_dmx_ratio = check_bounds_l( *res_dmx_ratio, 0, MAX_32 ); /*should always be satisfied*/
2489 2796 : move32();
2490 :
2491 : /*Calculate the total energy of RES and DMX*/
2492 : // dmx_res_all = res_nrg_all_curr + dmx_nrg_all_curr;
2493 2796 : dmx_res_all = BASOP_Util_Add_Mant32Exp( res_nrg_all_curr, res_nrg_all_curr_e, dmx_nrg_all_curr, dmx_nrg_all_curr_e, &dmx_res_all_e );
2494 :
2495 : /*Calculate the energy ratio of the inter-frame */
2496 : //*frame_nrg_ratio = dmx_res_all / hStereoDft->dmx_res_all_prev;
2497 2796 : *frame_nrg_ratio = BASOP_Util_Divide3232_Scale_newton( dmx_res_all, hStereoDft->dmx_res_all_prev_fx, &L_tmp1_e );
2498 2796 : move32();
2499 2796 : L_tmp1_e = add( L_tmp1_e, sub( dmx_res_all_e, hStereoDft->dmx_res_all_prev_fx_e ) );
2500 2796 : *frame_nrg_ratio = L_shr_r_sat( *frame_nrg_ratio, sub( 3, L_tmp1_e ) ); // Q28
2501 2796 : move32();
2502 : //*frame_nrg_ratio = L_min(5.0f, max(0.2f, *frame_nrg_ratio));
2503 2796 : *frame_nrg_ratio = L_min( ( 5 << 28 ) /*5.0f*/, L_max( 53687091 /*0.2f*/, *frame_nrg_ratio ) ); // Q28
2504 2796 : move32();
2505 :
2506 : /* Get fast update flag */
2507 2796 : fast_update_flag = 0;
2508 2796 : move16();
2509 : // if ((*frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f) || (*frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f))
2510 2796 : test();
2511 2796 : test();
2512 2796 : test();
2513 2796 : if ( ( GT_32( *frame_nrg_ratio, 858993459 /*3.2f*/ ) && LT_32( *res_dmx_ratio, 214748365 /*0.1f*/ ) ) || ( LT_32( *frame_nrg_ratio, 56371446 /*0.21f */ ) && GT_32( *res_dmx_ratio, 858993459 /*0.4f*/ ) ) )
2514 : {
2515 59 : fast_update_flag = 1;
2516 59 : move16();
2517 : }
2518 :
2519 : /* Calculate long term energy ratio between residual signal and downmix signal */
2520 2796 : IF( fast_update_flag )
2521 : {
2522 : // hStereoDft->res_dmx_ratio_lt = *res_dmx_ratio * 0.2f + hStereoDft->res_dmx_ratio_lt * 0.8f;
2523 59 : hStereoDft->res_dmx_ratio_lt_fx = L_add( Mpy_32_32( *res_dmx_ratio, 429496730 /*0.2f*/ ), Mpy_32_32( hStereoDft->res_dmx_ratio_lt_fx, 1717986918 /*0.8f*/ ) );
2524 59 : move32();
2525 : }
2526 : ELSE
2527 : {
2528 : // hStereoDft->res_dmx_ratio_lt = *res_dmx_ratio * 0.05f + hStereoDft->res_dmx_ratio_lt * 0.95f;
2529 2737 : hStereoDft->res_dmx_ratio_lt_fx = L_add( Mpy_32_32( *res_dmx_ratio, 107374182 /*0.05f*/ ), Mpy_32_32( hStereoDft->res_dmx_ratio_lt_fx, 2040109466 /*0.95f*/ ) );
2530 2737 : move32();
2531 : }
2532 :
2533 : /*Get the residual signal coding initial flag */
2534 : // if (hStereoDft->res_dmx_ratio_lt > 0.01f)
2535 2796 : IF( GT_32( hStereoDft->res_dmx_ratio_lt_fx, 21474836 /*0.01f*/ ) )
2536 : {
2537 2796 : res_cod_mode_flag = 1;
2538 2796 : move16();
2539 : }
2540 : ELSE
2541 : {
2542 0 : res_cod_mode_flag = 0;
2543 0 : move16();
2544 : }
2545 :
2546 : /* Get the residual signal coding flag */
2547 2796 : IF( hStereoDft->first_frm_flag )
2548 : {
2549 9 : prev_res_cod_mode_flag = res_cod_mode_flag;
2550 9 : move16();
2551 9 : hStereoDft->first_frm_flag = 0;
2552 9 : move16();
2553 : }
2554 : ELSE
2555 : {
2556 2787 : prev_res_cod_mode_flag = hStereoDft->res_cod_mode[STEREO_DFT_OFFSET - 1];
2557 2787 : move16();
2558 : }
2559 2796 : IF( NE_16( res_cod_mode_flag, prev_res_cod_mode_flag ) )
2560 : {
2561 347 : IF( EQ_16( prev_res_cod_mode_flag, 1 ) )
2562 : {
2563 0 : test();
2564 0 : test();
2565 0 : IF( LT_16( hStereoDft->hangover_cnt0, 5 ) && hStereoDft->last_res_cod_mode_modify_flag == 0 && fast_update_flag == 0 )
2566 : {
2567 0 : res_cod_mode_flag = prev_res_cod_mode_flag;
2568 0 : move16();
2569 0 : hStereoDft->hangover_cnt0 = add( hStereoDft->hangover_cnt0, 1 );
2570 0 : move16();
2571 : }
2572 : ELSE
2573 : {
2574 : /* reset hangover */
2575 0 : hStereoDft->hangover_cnt0 = 0;
2576 0 : move16();
2577 : }
2578 : }
2579 : ELSE
2580 : {
2581 : // if (*frame_nrg_ratio > 2.5f || *frame_nrg_ratio < 0.21f)
2582 347 : test();
2583 347 : IF( GT_32( *frame_nrg_ratio, 671088640 /*2.5f*/ ) || LT_32( *frame_nrg_ratio, 56371446 /*0.21f*/ ) )
2584 : {
2585 : /* reset hangover */
2586 7 : hStereoDft->hangover_cnt1 = 0;
2587 7 : move16();
2588 : }
2589 : ELSE
2590 : {
2591 340 : IF( LT_16( hStereoDft->hangover_cnt1, 5 ) )
2592 : {
2593 288 : res_cod_mode_flag = prev_res_cod_mode_flag;
2594 288 : move16();
2595 288 : hStereoDft->hangover_cnt1 = add( hStereoDft->hangover_cnt1, 1 );
2596 288 : move16();
2597 : }
2598 : ELSE
2599 : {
2600 : /* reset hangover */
2601 52 : hStereoDft->hangover_cnt1 = 0;
2602 52 : move16();
2603 : }
2604 : }
2605 : }
2606 : }
2607 :
2608 : /* handle switching frames */
2609 2796 : test();
2610 2796 : IF( NE_16( res_cod_mode_flag, prev_res_cod_mode_flag ) && hStereoDft->last_res_cod_mode_modify_flag == 0 )
2611 : {
2612 59 : hStereoDft->res_cod_sw_flag = 1;
2613 59 : move16();
2614 :
2615 : /* Update switch_fade_factor */
2616 : // if (*frame_nrg_ratio > 3.2f && *res_dmx_ratio < 0.1f)
2617 59 : test();
2618 59 : test();
2619 59 : IF( GT_32( *frame_nrg_ratio, 858993459 /*3.2f*/ ) && LT_32( *res_dmx_ratio, 214748365 /*0.1f*/ ) )
2620 : {
2621 : // hStereoDft->switch_fade_factor = 0.75f;
2622 0 : hStereoDft->switch_fade_factor_fx = 24576; // 0.75f
2623 0 : move16();
2624 : }
2625 : // else if (*frame_nrg_ratio < 0.21f && *res_dmx_ratio > 0.4f)
2626 59 : ELSE IF( LT_32( *frame_nrg_ratio, 56371446 /*0.21f*/ ) && GT_32( *res_dmx_ratio, 858993459 /*0.4f*/ ) )
2627 : {
2628 : // hStereoDft->switch_fade_factor = 0.25f;
2629 0 : hStereoDft->switch_fade_factor_fx = 8192; // 0.25f
2630 0 : move16();
2631 : }
2632 : ELSE
2633 : {
2634 : // hStereoDft->switch_fade_factor = 0.5f;
2635 59 : hStereoDft->switch_fade_factor_fx = 16384; // 0.5f
2636 59 : move16();
2637 : }
2638 :
2639 59 : if ( res_cod_mode_flag == 0 )
2640 : {
2641 0 : res_cod_mode_flag = 1;
2642 0 : move16();
2643 : }
2644 : }
2645 :
2646 : /*update previous frame's total energy of RES and DMX */
2647 2796 : hStereoDft->dmx_res_all_prev_fx = dmx_res_all;
2648 2796 : move32();
2649 2796 : hStereoDft->dmx_res_all_prev_fx_e = dmx_res_all_e;
2650 2796 : move16();
2651 :
2652 : /* update residual coding mode */
2653 2796 : hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] = res_cod_mode_flag;
2654 2796 : move16();
2655 2796 : IF( !hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
2656 : {
2657 288 : hStereoDft->res_cod_band_max = 0;
2658 288 : move16();
2659 288 : hStereoDft->res_cod_line_max = 0;
2660 288 : move16();
2661 : }
2662 :
2663 : /*Update residual signal memory when switching from not coding residual signal to coding it*/
2664 2796 : test();
2665 2796 : IF( prev_res_cod_mode_flag == 0 && EQ_16( res_cod_mode_flag, 1 ) )
2666 : {
2667 59 : set_zero_fx( hStereoDft->output_mem_res_8k_fx, STEREO_DFT_OVL_8k );
2668 : }
2669 :
2670 2796 : return;
2671 : }
2672 : /*-------------------------------------------------------------------------
2673 : * stereo_dft_enc_res()
2674 : *
2675 : * Code the residual signal
2676 : *-------------------------------------------------------------------------*/
2677 :
2678 59115 : void stereo_dft_enc_res_fx(
2679 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder stereo handle */
2680 : const Word32 *input_8k, /* i : input buffer sampled at 8kHz Q15 */
2681 : BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
2682 : Word16 *nb_bits, /* o : number of bits written */
2683 : const Word16 max_bits )
2684 : {
2685 : Word16 i, b;
2686 : RangeUniEncState range_uni_enc_state;
2687 : ECSQ_instance ecsq_inst;
2688 : Word32 MDCT_RES[L_FRAME8k];
2689 : Word16 MDCT_RES_e;
2690 : Word16 win[L_FRAME8k + STEREO_DFT_OVL_8k]; // Q0
2691 : Word16 global_gain_index;
2692 : Word16 total_bit_count;
2693 : Word32 max_snr; // Q25
2694 : Word32 panning_gain, panning_gain_min;
2695 : Word32 res_cod_gain[10]; // Q25
2696 : Word32 in_phase_ratio;
2697 : Word16 in_phase_ratio_e;
2698 : Word32 L_tmp1, L_tmp2;
2699 : Word16 /*L_tmp1_e,*/ L_tmp2_e;
2700 59115 : assert( hStereoDft->res_cod_line_max <= L_FRAME8k );
2701 :
2702 59115 : IF( hStereoDft->res_cod_mode[STEREO_DFT_OFFSET] )
2703 : {
2704 : /* Windowing */
2705 : /* overlapping parts */
2706 : /*input_8k-=STEREO_DFT_OVL_8k;*/
2707 1235968 : FOR( i = 0; i < STEREO_DFT_OVL_8k; i++ )
2708 : {
2709 : // win[i] = input_8k[i] * hStereoDft->win_mdct_8k[i];
2710 1218560 : win[i] = extract_h( Mpy_32_32( input_8k[i], hStereoDft->win_mdct_8k_fx[i] /*Q31*/ ) );
2711 1218560 : move32();
2712 : // win[L_FRAME8k + i] = input_8k[L_FRAME8k + i] * hStereoDft->win_mdct_8k[STEREO_DFT_OVL_8k - 1 - i];
2713 1218560 : win[L_FRAME8k + i] = extract_h( Mpy_32_32( input_8k[L_FRAME8k + i], hStereoDft->win_mdct_8k_fx[STEREO_DFT_OVL_8k - 1 - i] /*Q31*/ ) );
2714 1218560 : move32();
2715 : }
2716 : /* middle part */
2717 1584128 : FOR( ; i < L_FRAME8k; i++ )
2718 : {
2719 1566720 : win[i] = extract_h( input_8k[i] );
2720 1566720 : move32();
2721 : }
2722 :
2723 : /* MDCT analysis */
2724 : // TCX_MDCT_flt( win, MDCT_RES, STEREO_DFT_OVL_8k, L_FRAME8k - STEREO_DFT_OVL_8k, STEREO_DFT_OVL_8k, IVAS_CPE_DFT );
2725 17408 : MDCT_RES_e = 17;
2726 17408 : move16();
2727 17408 : TCX_MDCT( win, MDCT_RES, &MDCT_RES_e, STEREO_DFT_OVL_8k, L_FRAME8k - STEREO_DFT_OVL_8k, STEREO_DFT_OVL_8k, IVAS_CPE_DFT );
2728 :
2729 : /*Compute the DMX to RES for each band*/
2730 17408 : max_snr = 0; /*minimum gain for residual coding -> no coding*/
2731 17408 : move32();
2732 104448 : FOR( b = 0; b < hStereoDft->res_cod_band_max; b++ )
2733 : {
2734 : /*Get side gain information and it is we*/
2735 87040 : panning_gain = hStereoDft->side_gain_fx[STEREO_DFT_OFFSET * STEREO_DFT_BAND_MAX + b];
2736 87040 : panning_gain_min = L_sub( MAX_32, L_abs( panning_gain ) );
2737 :
2738 : // 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 );
2739 87040 : L_tmp1 = Mpy_32_32( Mpy_32_32( panning_gain_min, panning_gain_min ), hStereoDft->res_cod_NRG_M_fx[b] );
2740 87040 : L_tmp2 = L_tmp1;
2741 87040 : L_tmp2_e = hStereoDft->res_cod_NRG_M_fx_e[b];
2742 87040 : L_tmp2 = BASOP_Util_Add_Mant32Exp( L_tmp2, L_tmp2_e, hStereoDft->res_cod_NRG_S_fx[b], hStereoDft->res_cod_NRG_S_fx_e[b], &L_tmp2_e );
2743 87040 : L_tmp2 = BASOP_Util_Add_Mant32Exp( L_tmp2, L_tmp2_e, MAX_32, 0, &L_tmp2_e );
2744 87040 : in_phase_ratio = BASOP_Util_Divide3232_Scale_newton( L_tmp1, L_tmp2, &in_phase_ratio_e );
2745 87040 : in_phase_ratio_e = add( in_phase_ratio_e, sub( hStereoDft->res_cod_NRG_M_fx_e[b], L_tmp2_e ) );
2746 87040 : in_phase_ratio = L_shl_sat( in_phase_ratio, in_phase_ratio_e ); // Q31 : bound from 0.0 to 1.0
2747 87040 : in_phase_ratio = L_max( 0, in_phase_ratio );
2748 : // in_phase_ratio = check_bounds(in_phase_ratio, 0, 1);
2749 :
2750 : // res_cod_gain[b] = in_phase_ratio * STEREO_DFT_RES_COD_SNR_MIN + ( 1 - in_phase_ratio ) * STEREO_DFT_RES_COD_SNR_MAX;
2751 87040 : res_cod_gain[b] = L_add( Mpy_32_32( in_phase_ratio, STEREO_DFT_RES_COD_SNR_MIN_Q25 ), Mpy_32_32( L_sub( MAX_32, in_phase_ratio ), STEREO_DFT_RES_COD_SNR_MAX_Q25 ) ); // Q25
2752 87040 : move32();
2753 :
2754 : /*get the maximum through bands*/
2755 87040 : if ( GT_32( res_cod_gain[b], max_snr ) )
2756 : {
2757 44361 : max_snr = res_cod_gain[b];
2758 44361 : move32();
2759 : }
2760 : }
2761 :
2762 : /*Smooth max_snr because of several perturbations in computation*/
2763 17408 : hStereoDft->old_snr_fx = L_add( Mpy_32_32( 429496730 /*0.2f*/, max_snr ), Mpy_32_32( 1717986918 /*0.8f*/, hStereoDft->old_snr_fx ) );
2764 17408 : move32();
2765 17408 : max_snr = hStereoDft->old_snr_fx;
2766 17408 : move32();
2767 :
2768 17408 : if ( LT_32( max_snr, STEREO_DFT_RES_COD_SNR_MIN_Q25 ) )
2769 : {
2770 544 : max_snr = STEREO_DFT_RES_COD_SNR_MIN_Q25;
2771 544 : move32();
2772 : }
2773 :
2774 17408 : push_wmops( "residual_encode" );
2775 : /* residual encoding */
2776 17408 : ECSQ_init_instance_fx( &ecsq_inst, 0 /*dummy index*/, &range_uni_enc_state );
2777 17408 : rc_uni_enc_init_fx( &range_uni_enc_state );
2778 :
2779 17408 : ecsq_inst.bit_count_estimate = 0;
2780 17408 : move32();
2781 17408 : ecsq_inst.config_index = sub( shl( hStereoDft->res_cod_mode[STEREO_DFT_OFFSET], 1 ), 1 );
2782 17408 : move16();
2783 :
2784 : /* 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 */
2785 17408 : ECSQ_encode_target_SNR_fx( &ecsq_inst, MDCT_RES, MDCT_RES_e, hStereoDft->res_cod_line_max, max_snr, max_bits - ( *nb_bits ) - STEREO_DFT_RES_GLOBAL_GAIN_BITS - 2 - 8, NULL, &global_gain_index );
2786 17408 : IF( NE_16( global_gain_index, ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO ) )
2787 : {
2788 16526 : total_bit_count = rc_uni_enc_finish_fx( &range_uni_enc_state );
2789 :
2790 16526 : IF( LE_16( total_bit_count, sub( sub( max_bits, *nb_bits ), STEREO_DFT_RES_GLOBAL_GAIN_BITS ) ) )
2791 : {
2792 : Word16 idx;
2793 : UWord8 *byte_buffer;
2794 :
2795 : /* Global gain */
2796 16526 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2797 16526 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2798 16526 : move16();
2799 :
2800 : /* Push arithmetic coded bits */
2801 16526 : byte_buffer = range_uni_enc_state.byte_buffer;
2802 303422 : FOR( idx = 0; idx < shr( total_bit_count, 3 ); ++idx )
2803 : {
2804 286896 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, byte_buffer[idx], 8 );
2805 : }
2806 16526 : IF( s_and( total_bit_count, 7 ) != 0 )
2807 : {
2808 : /* move the last 1 to 7 bits from the MSB position of the last byte to the LSB postion */
2809 14407 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_COD, shr( byte_buffer[idx], sub( 8, s_and( total_bit_count, 7 ) ) ), s_and( total_bit_count, 7 ) );
2810 : }
2811 16526 : ( *nb_bits ) = add( *nb_bits, total_bit_count );
2812 16526 : move16();
2813 : }
2814 : ELSE
2815 : {
2816 : /* Global gain -> 127*/
2817 0 : global_gain_index = ECSQ_GLOBAL_GAIN_INDEX_ALL_ZERO;
2818 0 : move16();
2819 0 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2820 0 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2821 0 : move16();
2822 : }
2823 : }
2824 : ELSE
2825 : {
2826 : /* Global gain -> 127*/
2827 882 : push_indice( hBstr, IND_STEREO_DFT_RESIDUAL_GLOBAL_GAIN, global_gain_index, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2828 882 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_RES_GLOBAL_GAIN_BITS );
2829 882 : move16();
2830 : }
2831 :
2832 17408 : pop_wmops();
2833 : }
2834 :
2835 :
2836 59115 : return;
2837 : }
2838 :
2839 : /*-------------------------------------------------------------------------
2840 : * stereo_dft_enc_write_BS()
2841 : *
2842 : * Write DFT stereo bitstream
2843 : *-------------------------------------------------------------------------*/
2844 53476 : void stereo_dft_enc_write_BS_fx(
2845 : CPE_ENC_HANDLE hCPE, /* i/o: CPE encoder structure */
2846 : Word16 *nb_bits /* o : number of bits written */
2847 : )
2848 : {
2849 : Word16 b, k_offset, itd, nb, nbands, sp_aud_decision0;
2850 : Word16 NFFT_inner, nbands_full;
2851 : Word16 no_GR_ord;
2852 : Word16 encoded_ind_GR[STEREO_DFT_BAND_MAX];
2853 : Word16 encoded_ind_pred_GR[STEREO_DFT_BAND_MAX];
2854 : Word16 sid_gIpd_index, sid_itd;
2855 : Word32 cohBand[STEREO_DFT_BAND_MAX / 2];
2856 : BSTR_ENC_HANDLE hBstr;
2857 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft;
2858 : Word32 core_brate;
2859 :
2860 : /*------------------------------------------------------------------*
2861 : * Initialization
2862 : *-----------------------------------------------------------------*/
2863 :
2864 53476 : hStereoDft = hCPE->hStereoDft;
2865 53476 : hBstr = hCPE->hMetaData;
2866 53476 : core_brate = hCPE->hCoreCoder[0]->core_brate;
2867 53476 : move32();
2868 :
2869 53476 : sp_aud_decision0 = 0;
2870 53476 : move16();
2871 53476 : if ( EQ_16( hCPE->last_element_mode, IVAS_CPE_DFT ) )
2872 : {
2873 53114 : sp_aud_decision0 = hCPE->hCoreCoder[0]->sp_aud_decision0;
2874 53114 : move16();
2875 : }
2876 :
2877 53476 : *nb_bits = 0;
2878 53476 : move16();
2879 53476 : k_offset = STEREO_DFT_OFFSET;
2880 53476 : move16();
2881 :
2882 53476 : nbands_full = hStereoDft->nbands;
2883 53476 : move16();
2884 :
2885 53476 : test();
2886 53476 : IF( ( core_brate == FRAME_NO_DATA ) || EQ_32( core_brate, SID_2k40 ) )
2887 : {
2888 9779 : NFFT_inner = s_min( STEREO_DFT_N_32k_ENC, STEREO_DFT_N_MAX_ENC * inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth] / L_FRAME48k );
2889 9779 : hStereoDft->band_res[k_offset] = hStereoDft->hConfig->band_res;
2890 9779 : move16();
2891 9779 : hStereoDft->res_pred_mode[k_offset] = 0;
2892 9779 : move16();
2893 9779 : hStereoDft->res_cod_mode[k_offset] = 0;
2894 9779 : move16();
2895 : }
2896 : ELSE
2897 : {
2898 : // NFFT_inner = STEREO_DFT_N_MAX_ENC * inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth] / L_FRAME48k;
2899 43697 : NFFT_inner = shl( inner_frame_tbl[hCPE->hCoreCoder[0]->bwidth], 1 );
2900 : }
2901 :
2902 : /* set number of bands according to bandwidth after BWD */
2903 53476 : hStereoDft->nbands = stereo_dft_band_config_fx( hStereoDft->band_limits, hStereoDft->band_res[k_offset], NFFT_inner, ENC );
2904 53476 : move16();
2905 :
2906 53476 : IF( core_brate == FRAME_NO_DATA )
2907 : {
2908 : /* No data frame */
2909 8330 : ( *nb_bits ) = 0;
2910 8330 : move16();
2911 8330 : return;
2912 : }
2913 :
2914 : /* attack present */
2915 : /* attackPresent not sent in inactive frames, receiver assumes = 0 */
2916 45146 : IF( NE_32( core_brate, SID_2k40 ) )
2917 : {
2918 43697 : push_indice( hBstr, IND_STEREO_DFT_ATTACK_PRESENT, hStereoDft->attackPresent, 1 );
2919 43697 : ( *nb_bits ) = add( *nb_bits, 1 );
2920 43697 : move16();
2921 : }
2922 :
2923 : /* Writing coding residual coding mode into bitstream */
2924 45146 : test();
2925 45146 : IF( hStereoDft->hConfig->ada_wb_res_cod_mode && EQ_16( hCPE->hCoreCoder[0]->bwidth, WB ) )
2926 : {
2927 3241 : push_indice( hBstr, IND_STEREO_DFT_RES_COD, hStereoDft->res_cod_mode[k_offset], 1 );
2928 3241 : ( *nb_bits ) = add( *nb_bits, 1 );
2929 3241 : move16();
2930 3241 : hStereoDft->res_cod_band_max = dft_band_res_cod[hStereoDft->hConfig->band_res][hStereoDft->res_cod_mode[k_offset]];
2931 3241 : move16();
2932 3241 : hStereoDft->res_pred_band_min = s_max( STEREO_DFT_RES_PRED_BAND_MIN, hStereoDft->res_cod_band_max );
2933 3241 : move16();
2934 : }
2935 :
2936 :
2937 45146 : if ( LT_16( nbands_full, hStereoDft->nbands ) )
2938 : {
2939 0 : hStereoDft->reverb_flag = 0;
2940 0 : move16();
2941 : }
2942 :
2943 : /* Side gains */
2944 45146 : hStereoDft->side_gain_flag_1 = 0; /* EC coding by default */
2945 45146 : move16();
2946 45146 : side_gain_mode_decision_fx( hStereoDft, encoded_ind_GR, sp_aud_decision0, hCPE->hCoreCoder[0]->last_core_brate );
2947 :
2948 : /* residual pred. gains */
2949 45146 : hStereoDft->res_pred_flag_1 = 0; /* EC coding by default */
2950 45146 : move16();
2951 :
2952 45146 : res_pred_gain_mode_decision_fx( hStereoDft, encoded_ind_pred_GR, k_offset, hCPE->hCoreCoder[0]->last_core_brate );
2953 :
2954 : /*------------------------------------------------------------------*
2955 : * write ITD indices
2956 : *-----------------------------------------------------------------*/
2957 :
2958 45146 : IF( NE_32( core_brate, SID_2k40 ) )
2959 : {
2960 43697 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, ( hStereoDft->hItd->itd_fx[k_offset] != 0 ), STEREO_DFT_ITD_MODE_NBITS );
2961 43697 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_ITD_MODE_NBITS ); /*ITD mode flag: 1bit*/
2962 43697 : move16();
2963 : }
2964 :
2965 45146 : IF( NE_32( core_brate, SID_2k40 ) )
2966 : {
2967 43697 : IF( hStereoDft->hItd->itd_fx[k_offset] )
2968 : {
2969 26040 : itd = hStereoDft->hItd->itd_index[k_offset];
2970 26040 : move16();
2971 26040 : IF( GT_16( itd, 255 ) )
2972 : {
2973 16778 : itd = sub( itd, 256 );
2974 :
2975 16778 : IF( LT_16( itd, 20 ) )
2976 : {
2977 9689 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2978 9689 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2979 9689 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2980 9689 : ( *nb_bits ) = add( *nb_bits, add( dft_len_itd[itd], 2 ) );
2981 9689 : move16();
2982 : }
2983 : ELSE
2984 : {
2985 7089 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 0, 1 ); /* don't use Huffman */
2986 7089 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
2987 7089 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS - 1 );
2988 7089 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_ITD_NBITS + 1 );
2989 7089 : move16();
2990 : }
2991 : }
2992 : ELSE
2993 : {
2994 9262 : IF( LT_16( itd, 20 ) )
2995 : {
2996 4003 : push_indice( hBstr, IND_STEREO_DFT_ITD_HUFF, 1, 1 ); /* use Huffman*/
2997 4003 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* positive */
2998 4003 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, dft_code_itd[itd], dft_len_itd[itd] );
2999 4003 : ( *nb_bits ) = add( *nb_bits, add( dft_len_itd[itd], 2 ) );
3000 4003 : move16();
3001 : }
3002 : ELSE
3003 : {
3004 : /* don't use Huffman and positive*/
3005 5259 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_ITD_NBITS + 1 );
3006 5259 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_ITD_NBITS + 1 );
3007 5259 : move16();
3008 : }
3009 : }
3010 : }
3011 : }
3012 :
3013 : #ifdef DEBUG_MODE_DFT_BITS
3014 : fprintf( ITD_bits, "%d ", *nb_bits );
3015 : #endif
3016 :
3017 : /*------------------------------------------------------------------*
3018 : * write Side gain indices
3019 : *-----------------------------------------------------------------*/
3020 :
3021 : /* Side Gain flag 1 */
3022 45146 : nb = 0;
3023 45146 : move16();
3024 45146 : IF( hStereoDft->side_gain_flag_1 > 0 )
3025 : {
3026 9985 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, 2 );
3027 9985 : nb = add( nb, 2 );
3028 : }
3029 : ELSE
3030 : {
3031 35161 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAIN_FLAG, hStereoDft->side_gain_flag_1, STEREO_DFT_FLAG_BITS );
3032 35161 : nb = add( nb, STEREO_DFT_FLAG_BITS );
3033 : }
3034 :
3035 45146 : no_GR_ord = 3;
3036 45146 : move16();
3037 :
3038 45146 : IF( hStereoDft->side_gain_flag_1 == 0 )
3039 : {
3040 35161 : nb = add( nb, write_bitstream_adapt_GR_fx( hBstr, IND_STEREO_DFT_SIDEGAINS, encoded_ind_GR, hStereoDft->nbands, hStereoDft->side_gain_flag_2, no_GR_ord ) );
3041 : }
3042 : ELSE{
3043 9985 : IF( EQ_16( hStereoDft->side_gain_flag_1, 2 ) ){
3044 8903 : nb = add( nb, write_bitstream_GR_fx( hBstr, IND_STEREO_DFT_SIDEGAINS, hStereoDft->side_gain_index_ECDiff, hStereoDft->nbands, hStereoDft->side_gain_flag_2 - no_GR_ord ) );
3045 : }
3046 : ELSE
3047 : {
3048 7338 : FOR( b = 0; b < hStereoDft->nbands; b++ )
3049 : {
3050 : /*ILD*/
3051 6256 : push_indice( hBstr, IND_STEREO_DFT_SIDEGAINS, hStereoDft->side_gain_index_EC[b], STEREO_DFT_SIDEGAIN_NBITS );
3052 6256 : nb = add( nb, STEREO_DFT_SIDEGAIN_NBITS );
3053 : }
3054 : }
3055 : }
3056 :
3057 : /* nb bits are used for side gain*/
3058 45146 : ( *nb_bits ) = add( *nb_bits, nb );
3059 45146 : move16();
3060 : #ifdef DEBUG_MODE_DFT_BITS
3061 : fprintf( SG_bits, "%d ", nb );
3062 : #endif
3063 45146 : nb = 0;
3064 45146 : move16();
3065 :
3066 45146 : IF( EQ_32( core_brate, SID_2k40 ) )
3067 : {
3068 1449 : stereo_dft_enc_sid_calc_coh_fx( hStereoDft, hCPE->hStereoCng->prev_cohBand_fx, &hCPE->hStereoCng->td_active, &hCPE->hStereoCng->first_SID, cohBand );
3069 :
3070 1449 : IF( LE_16( *nb_bits, ( ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS - STEREO_DFT_ITD_MODE_NBITS - STEREO_DFT_SID_ITD_NBITS - 1 ) ) )
3071 : {
3072 1449 : IF( NE_32( hStereoDft->hItd->itd_fx[k_offset], 0 ) )
3073 : {
3074 : /* Re-quantize ITD with lower resolution for Stereo CNG */
3075 44 : itd = hStereoDft->hItd->itd_index[k_offset];
3076 44 : move16();
3077 44 : if ( GT_16( itd, 255 ) )
3078 : {
3079 35 : itd = sub( itd, 256 );
3080 : }
3081 44 : itd = shr( itd, STEREO_DFT_SID_ITD_FAC );
3082 :
3083 44 : sid_itd = itd && 1;
3084 44 : move16();
3085 : }
3086 : ELSE
3087 : {
3088 1405 : sid_itd = 0;
3089 1405 : move16();
3090 : }
3091 :
3092 1449 : push_indice( hBstr, IND_STEREO_DFT_ITD_MODE, sid_itd, STEREO_DFT_ITD_MODE_NBITS );
3093 1449 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_ITD_MODE_NBITS ); /*ITD mode flag: 1bit*/
3094 1449 : move16();
3095 :
3096 1449 : IF( sid_itd )
3097 : {
3098 21 : itd = hStereoDft->hItd->itd_index[k_offset];
3099 21 : move16();
3100 21 : IF( GT_16( itd, 255 ) )
3101 : {
3102 12 : itd = sub( itd, 256 );
3103 12 : itd = shr( itd, STEREO_DFT_SID_ITD_FAC );
3104 :
3105 12 : if ( GT_16( itd, ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) ) )
3106 : {
3107 12 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
3108 12 : move16();
3109 : }
3110 :
3111 12 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 1, 1 ); /* negative */
3112 12 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
3113 12 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_SID_ITD_NBITS + 1 );
3114 12 : move16();
3115 : }
3116 : ELSE
3117 : {
3118 9 : itd = shr( itd, STEREO_DFT_SID_ITD_FAC );
3119 :
3120 9 : if ( GT_16( itd, ( ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1 ) ) )
3121 : {
3122 8 : itd = ( 1 << STEREO_DFT_SID_ITD_NBITS ) - 1;
3123 8 : move16();
3124 : }
3125 :
3126 9 : push_indice( hBstr, IND_STEREO_DFT_ITD_NEG, 0, 1 ); /* Positive */
3127 9 : push_indice( hBstr, IND_STEREO_DFT_ITD_COD, itd, STEREO_DFT_SID_ITD_NBITS );
3128 9 : ( *nb_bits ) = add( *nb_bits, STEREO_DFT_SID_ITD_NBITS + 1 );
3129 9 : move16();
3130 : }
3131 : }
3132 : }
3133 : }
3134 :
3135 : /*------------------------------------------------------------------*
3136 : * write IPD indices
3137 : *-----------------------------------------------------------------*/
3138 :
3139 45146 : IF( NE_32( core_brate, SID_2k40 ) )
3140 : {
3141 43697 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
3142 43697 : nb = add( nb, STEREO_DFT_FLAG_BITS ); /*IPD mode flag: 1bit*/
3143 :
3144 43697 : IF( hStereoDft->no_ipd_flag == 0 )
3145 : {
3146 4086 : push_indice( hBstr, IND_STEREO_DFT_GIPD, hStereoDft->gipd_index, STEREO_DFT_GIPD_NBITS );
3147 4086 : nb = add( nb, STEREO_DFT_GIPD_NBITS );
3148 : }
3149 : }
3150 1449 : ELSE IF( LE_16( *nb_bits, ( ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS - STEREO_DFT_FLAG_BITS - STEREO_DFT_SID_GIPD_NBITS ) ) )
3151 : {
3152 1449 : push_indice( hBstr, IND_STEREO_DFT_NO_IPD_FLAG, hStereoDft->no_ipd_flag, STEREO_DFT_FLAG_BITS );
3153 1449 : nb = add( nb, STEREO_DFT_FLAG_BITS ); /*IPD mode flag: 1bit*/
3154 :
3155 1449 : IF( hStereoDft->no_ipd_flag == 0 )
3156 : {
3157 297 : stereo_dft_quantize_ipd_fx( &hStereoDft->sid_gipd_fx, &hStereoDft->sid_gipd_fx, &sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
3158 297 : push_indice( hBstr, IND_STEREO_DFT_GIPD, sid_gIpd_index, STEREO_DFT_SID_GIPD_NBITS );
3159 297 : nb = add( nb, STEREO_DFT_SID_GIPD_NBITS );
3160 : }
3161 : }
3162 :
3163 :
3164 : #ifdef DEBUG_MODE_DFT_BITS
3165 : fprintf( IPD_bits, "%d ", nb );
3166 : #endif
3167 45146 : ( *nb_bits ) = add( *nb_bits, nb );
3168 :
3169 : /*----------------------------------------------------------------*
3170 : * Residual prediction
3171 : *----------------------------------------------------------------*/
3172 :
3173 45146 : nb = 0; /* bits for residual pred gains */
3174 45146 : move16();
3175 45146 : IF( hStereoDft->res_pred_mode[k_offset] )
3176 : {
3177 43697 : IF( hStereoDft->attackPresent == 0 )
3178 : {
3179 42102 : nbands = s_min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
3180 42102 : b = hStereoDft->res_pred_band_min;
3181 42102 : move16();
3182 :
3183 : /*Adaptive SF*/
3184 42102 : IF( hStereoDft->hConfig->res_cod_mode == STEREO_DFT_RES_COD_OFF )
3185 : {
3186 : /*read flag*/
3187 25298 : push_indice( hBstr, IND_STEREO_DFT_REVERB_MODE, hStereoDft->reverb_flag, STEREO_DFT_REVERB_MODE_NBITS );
3188 25298 : nb = add( nb, STEREO_DFT_REVERB_MODE_NBITS );
3189 25298 : IF( hStereoDft->reverb_flag )
3190 : {
3191 6818 : nbands = sub( nbands, STEREO_DFT_RES_PRED_BAND_MIN_CONST );
3192 : }
3193 : }
3194 :
3195 : /* Res Pred Gain flag 0 */
3196 42102 : IF( hStereoDft->res_pred_flag_1 > 0 )
3197 : {
3198 33693 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, 2 );
3199 33693 : nb = add( nb, 2 ); /*pred gain mode flag: 2 bits*/
3200 : }
3201 : ELSE
3202 : {
3203 8409 : push_indice( hBstr, IND_STEREO_DFT_RES_PRED_FLAG, hStereoDft->res_pred_flag_1, STEREO_DFT_FLAG_BITS );
3204 8409 : nb = add( nb, STEREO_DFT_FLAG_BITS ); /*pred gain mode flag: 1bit*/
3205 : }
3206 :
3207 42102 : no_GR_ord = 2;
3208 42102 : move16();
3209 42102 : IF( hStereoDft->res_pred_flag_1 == 0 )
3210 : {
3211 8409 : IF( EQ_16( encoded_ind_pred_GR[0], dft_maps_rpg[8 * NO_SYMB_GR_PRED_G] ) )
3212 : {
3213 975 : nb = add( nb, write_GR1_fx( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, encoded_ind_pred_GR, 1 ) );
3214 : }
3215 : ELSE
3216 : {
3217 7434 : nb = add( nb, write_bitstream_adapt_GR_fx( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, encoded_ind_pred_GR, nbands - hStereoDft->res_pred_band_min, hStereoDft->res_pred_flag_2, 2 ) );
3218 : }
3219 : }
3220 : ELSE
3221 : {
3222 33693 : IF( EQ_16( hStereoDft->res_pred_flag_1, 2 ) )
3223 : {
3224 30296 : nb = add( nb, write_bitstream_GR_fx( 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 ) );
3225 : }
3226 : ELSE
3227 : {
3228 23750 : FOR( b = hStereoDft->res_pred_band_min; b < nbands; b++ )
3229 : {
3230 20353 : push_indice( hBstr, IND_STEREO_DFT_PRED_GAIN_COD, hStereoDft->res_pred_index_EC[b], STEREO_DFT_RES_GAINS_BITS );
3231 20353 : nb = add( nb, STEREO_DFT_RES_GAINS_BITS );
3232 : }
3233 : }
3234 : }
3235 : }
3236 : ELSE
3237 : {
3238 1595 : set16_fx( hStereoDft->res_pred_index_ECprevious, 0, sub( hStereoDft->nbands, hStereoDft->res_pred_band_min ) );
3239 : }
3240 : }
3241 : ELSE
3242 : {
3243 1449 : set16_fx( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands - hStereoDft->res_pred_band_min );
3244 : }
3245 :
3246 45146 : ( *nb_bits ) = add( *nb_bits, nb );
3247 45146 : move16();
3248 :
3249 45146 : IF( EQ_32( core_brate, SID_2k40 ) )
3250 : {
3251 1449 : stereo_dft_enc_sid_coh_fx( hBstr, hCPE->hStereoCng->mem_cohBand_fx, hStereoDft->nbands, nb_bits, cohBand );
3252 : }
3253 :
3254 :
3255 45146 : return;
3256 : }
3257 :
3258 : /*-------------------------------------------------------------------------
3259 : * stereo_dft_enc_compute_prm()
3260 : *
3261 : * Compute stereo parameters: IPD and SIDE_GAIN
3262 : * SIDE_GAIN: Interchannel Level Difference
3263 : * IPD: Interchannel Phase Difference: angle(L)-angle(R) = acos(<L,R>/(|L|.|R|)) or atan2(Img(L.R*)/Re(L.R*))
3264 : *------------------------------------------------------------------------*/
3265 :
3266 59643 : static void stereo_dft_enc_compute_prm_fx(
3267 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
3268 : Word32 *DFT_L_fx, // Q(31-DFT_L_fx_e[])
3269 : Word16 *DFT_L_fx_e,
3270 : Word32 *DFT_R_fx, // Q(31-DFT_R_fx_e[])
3271 : Word16 *DFT_R_fx_e,
3272 : Word16 k_offset,
3273 : Word16 flag_quant,
3274 : const Word16 sp_aud_decision0,
3275 : const Word16 vad_flag,
3276 : Word32 *bin_nrgL_fx, // Q(31-bin_nrgL_fx_e[])
3277 : Word16 *bin_nrgL_fx_e,
3278 : Word32 *bin_nrgR_fx, // Q(31-bin_nrgR_fx_e[])
3279 : Word16 *bin_nrgR_fx_e,
3280 : Word32 *dot_prod_nrg_ratio_fx, // Q(31-dot_prod_nrg_ratio_fx_e[])
3281 : Word16 *dot_prod_nrg_ratio_fx_e )
3282 : {
3283 : Word16 b, i;
3284 : Word16 b2;
3285 : Word32 *pDFT_L, *pDFT_R;
3286 : // Word16 DFT_L_e, DFT_R_e;
3287 : Word32 sum_nrg_L, sum_nrg_R;
3288 : Word16 sum_nrg_L_e, sum_nrg_R_e;
3289 : Word32 dot_prod_real, dot_prod_img;
3290 : Word16 dot_prod_real_e, dot_prod_img_e;
3291 : Word32 sum_nrg_L2, sum_nrg_R2;
3292 : Word16 sum_nrg_L2_e, sum_nrg_R2_e;
3293 : Word32 dot_prod_real2, dot_prod_img2;
3294 : Word16 dot_prod_real2_e, dot_prod_img2_e;
3295 : Word32 *pPredGain;
3296 : Word32 *pSideGain;
3297 : Word32 sum_energy_L, sum_energy_R;
3298 : Word16 sum_energy_L_e, sum_energy_R_e;
3299 : Word32 g, c;
3300 : Word16 /*g,*/ c_e;
3301 : Word32 abs_L_R;
3302 : Word16 abs_L_R_e;
3303 : Word32 abs_L_R2;
3304 : Word16 abs_L_R2_e;
3305 : Word32 gain_IPD; // Q31
3306 : Word32 sub_nrg_DMX[STEREO_DFT_BAND_MAX];
3307 : Word16 sub_nrg_DMX_e[STEREO_DFT_BAND_MAX];
3308 : Word32 sub_nrg_DMX2;
3309 : Word16 sub_nrg_DMX2_e;
3310 : Word32 sub_nrg_L[STEREO_DFT_BAND_MAX];
3311 : Word16 sub_nrg_L_e[STEREO_DFT_BAND_MAX];
3312 : Word32 sub_nrg_R[STEREO_DFT_BAND_MAX];
3313 : Word16 sub_nrg_R_e[STEREO_DFT_BAND_MAX];
3314 : Word32 diff_ipd;
3315 : Word32 *pNrgL, *pNrgR;
3316 : Word16 *pNrgL_e, *pNrgR_e;
3317 : Word32 reg;
3318 : Word16 reg_e;
3319 : Word32 *pgIpd, sum_dot_prod_real, sum_dot_prod_img;
3320 : Word16 sum_dot_prod_real_e, sum_dot_prod_img_e;
3321 : Word32 sum_past_nrgL, sum_past_nrgL2;
3322 : Word16 sum_past_nrgL_e, sum_past_nrgL2_e;
3323 : Word32 sum_past_nrgR, sum_past_nrgR2;
3324 : Word16 sum_past_nrgR_e, sum_past_nrgR2_e;
3325 : Word32 sum_past_dpr, sum_past_dpr2;
3326 : Word16 sum_past_dpr_e, sum_past_dpr2_e;
3327 : Word32 sum_past_dpi, sum_past_dpi2;
3328 : Word16 sum_past_dpi_e, sum_past_dpi2_e;
3329 : Word32 sum_past_dot_prod_abs, sum_past_dot_prod_abs2;
3330 59643 : Word16 sum_past_dot_prod_abs_e, sum_past_dot_prod_abs2_e = 0;
3331 : Word32 sum_past_nrg_dmx;
3332 : Word16 sum_past_nrg_dmx_e;
3333 : Word16 pos;
3334 : Word32 pIpd[STEREO_DFT_BAND_MAX]; // Q13
3335 : Word32 ipd_smooth[STEREO_DFT_BAND_MAX]; // Q13
3336 : Word32 ipd_mean_change; // Q13
3337 :
3338 : Word32 L_tmp;
3339 : Word16 L_tmp_e;
3340 : Word32 L_tmp1;
3341 : Word16 L_tmp1_e;
3342 : Word32 L_tmp2;
3343 : Word16 L_tmp2_e;
3344 : Word64 W_tmp;
3345 : Word16 W_shift;
3346 59643 : move16();
3347 :
3348 : /*Word16 past_nrgL_fx_tmp_e[STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX];
3349 : Word16 past_nrgR_fx_tmp_e[STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX];
3350 : Word16 past_dot_prod_real_fx_tmp_e[STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX];
3351 : Word16 past_dot_prod_imag_fx_tmp_e[STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX];
3352 : set16_fx(past_nrgL_fx_tmp_e, hStereoDft->past_nrgL_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX);
3353 : set16_fx(past_nrgR_fx_tmp_e, hStereoDft->past_nrgR_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX);
3354 : set16_fx(past_dot_prod_real_fx_tmp_e, hStereoDft->past_dot_prod_real_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX);
3355 : set16_fx(past_dot_prod_imag_fx_tmp_e, hStereoDft->past_dot_prod_imag_fx_e, STEREO_DFT_NRG_PAST_LEN * STEREO_DFT_BAND_MAX);*/
3356 :
3357 : /*------------------------------------------------------------------*
3358 : * Initialization
3359 : *-----------------------------------------------------------------*/
3360 :
3361 59643 : sum_past_dot_prod_abs2 = 0;
3362 59643 : move16();
3363 59643 : pos = hStereoDft->nrg_past_pos;
3364 59643 : move16();
3365 :
3366 59643 : set32_fx( sub_nrg_DMX, 0, STEREO_DFT_BAND_MAX );
3367 59643 : set16_fx( sub_nrg_DMX_e, 0, STEREO_DFT_BAND_MAX );
3368 59643 : set32_fx( sub_nrg_L, 0, STEREO_DFT_BAND_MAX );
3369 59643 : set16_fx( sub_nrg_L_e, 0, STEREO_DFT_BAND_MAX );
3370 59643 : set32_fx( sub_nrg_R, 0, STEREO_DFT_BAND_MAX );
3371 59643 : set16_fx( sub_nrg_R_e, 0, STEREO_DFT_BAND_MAX );
3372 :
3373 59643 : pSideGain = hStereoDft->side_gain_fx + k_offset * STEREO_DFT_BAND_MAX; // Q31
3374 59643 : pgIpd = hStereoDft->gipd_fx + k_offset; // Q13
3375 59643 : pPredGain = hStereoDft->res_pred_gain_fx + k_offset * STEREO_DFT_BAND_MAX; // Q31
3376 : // gain_IPD = EPSILON;
3377 59643 : gain_IPD = 0;
3378 59643 : move32();
3379 59643 : sum_energy_L = EPSILON_FX_M; /* Set the accumulations for the no IPD Calculation */
3380 59643 : move32();
3381 59643 : sum_energy_L_e = EPSILON_FX_E; /* Set the accumulations for the no IPD Calculation */
3382 59643 : move16();
3383 59643 : sum_energy_R = EPSILON_FX_M;
3384 59643 : move32();
3385 59643 : sum_energy_R_e = EPSILON_FX_E;
3386 59643 : move16();
3387 59643 : sum_dot_prod_real = EPSILON_FX_M;
3388 59643 : move32();
3389 59643 : sum_dot_prod_real_e = EPSILON_FX_E;
3390 59643 : move16();
3391 59643 : sum_dot_prod_img = EPSILON_FX_M;
3392 59643 : move32();
3393 59643 : sum_dot_prod_img_e = EPSILON_FX_E;
3394 59643 : move16();
3395 59643 : sub_nrg_DMX2 = 0;
3396 59643 : move32();
3397 59643 : sub_nrg_DMX2_e = 0;
3398 59643 : move16();
3399 :
3400 : /*------------------------------------------------------------------*
3401 : * Band-wise processing
3402 : *-----------------------------------------------------------------*/
3403 :
3404 59643 : b2 = 0;
3405 59643 : move16();
3406 607465 : FOR( b = 0; b < hStereoDft->nbands; b++ )
3407 : {
3408 547822 : pPredGain[b] = MAX_32;
3409 547822 : move32();
3410 547822 : sum_nrg_L = EPSILON_FX_M;
3411 547822 : move32();
3412 547822 : sum_nrg_L_e = EPSILON_FX_E;
3413 547822 : move16();
3414 547822 : sum_nrg_R = EPSILON_FX_M;
3415 547822 : move32();
3416 547822 : sum_nrg_R_e = EPSILON_FX_E;
3417 547822 : move16();
3418 547822 : dot_prod_real = EPSILON_FX_M;
3419 547822 : move32();
3420 547822 : dot_prod_real_e = EPSILON_FX_E;
3421 547822 : move16();
3422 547822 : dot_prod_img = EPSILON_FX_M;
3423 547822 : move32();
3424 547822 : dot_prod_img_e = EPSILON_FX_E;
3425 547822 : move16();
3426 547822 : sum_past_nrgL = 0;
3427 547822 : move32();
3428 547822 : sum_past_nrgL_e = 0;
3429 547822 : move16();
3430 547822 : sum_past_nrgR = 0;
3431 547822 : move32();
3432 547822 : sum_past_nrgR_e = 0;
3433 547822 : move16();
3434 547822 : sum_past_dpr = 0;
3435 547822 : move32();
3436 547822 : sum_past_dpr_e = 0;
3437 547822 : move16();
3438 547822 : sum_past_dpi = 0;
3439 547822 : move32();
3440 547822 : sum_past_dpi_e = 0;
3441 547822 : move16();
3442 :
3443 1248842 : WHILE( hStereoDft->band_limits_dmx[b2] < hStereoDft->band_limits[b + 1] )
3444 : {
3445 701020 : pDFT_L = DFT_L_fx;
3446 : // DFT_L_e = hStereoDft->DFT_fx_e[0];
3447 701020 : pDFT_R = DFT_R_fx;
3448 : // DFT_R_e = hStereoDft->DFT_fx_e[1];
3449 701020 : pNrgL = bin_nrgL_fx;
3450 701020 : pNrgL_e = bin_nrgL_fx_e;
3451 701020 : pNrgR = bin_nrgR_fx;
3452 701020 : pNrgR_e = bin_nrgR_fx_e;
3453 :
3454 701020 : sum_nrg_L2 = EPSILON_FX_M;
3455 701020 : move32();
3456 701020 : sum_nrg_L2_e = EPSILON_FX_E;
3457 701020 : move16();
3458 701020 : sum_nrg_R2 = EPSILON_FX_M;
3459 701020 : move32();
3460 701020 : sum_nrg_R2_e = EPSILON_FX_E;
3461 701020 : move16();
3462 701020 : dot_prod_real2 = EPSILON_FX_M;
3463 701020 : move32();
3464 701020 : dot_prod_real2_e = EPSILON_FX_E;
3465 701020 : move16();
3466 701020 : dot_prod_img2 = EPSILON_FX_M;
3467 701020 : move32();
3468 701020 : dot_prod_img2_e = EPSILON_FX_E;
3469 701020 : move16();
3470 :
3471 38239777 : FOR( i = hStereoDft->band_limits_dmx[b2]; i < hStereoDft->band_limits_dmx[b2 + 1]; i++ )
3472 : {
3473 : // sum_nrg_L2 += pNrgL[i];
3474 37538757 : sum_nrg_L2 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, pNrgL[i], pNrgL_e[i], &sum_nrg_L2_e );
3475 : // sum_nrg_R2 += pNrgR[i];
3476 37538757 : sum_nrg_R2 = BASOP_Util_Add_Mant32Exp( sum_nrg_R2, sum_nrg_R2_e, pNrgR[i], pNrgR_e[i], &sum_nrg_R2_e );
3477 :
3478 : /* compute dot product*/
3479 : // dot_prod_real2 += pDFT_L[2 * i] * pDFT_R[2 * i] + pDFT_L[2 * i + 1] * pDFT_R[2 * i + 1];
3480 37538757 : L_tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L[2 * i], pDFT_R[2 * i] ), add( DFT_L_fx_e[2 * i], DFT_R_fx_e[2 * i] ), Mpy_32_32( pDFT_L[2 * i + 1], pDFT_R[2 * i + 1] ), add( DFT_L_fx_e[2 * i + 1], DFT_R_fx_e[2 * i + 1] ), &L_tmp_e );
3481 37538757 : dot_prod_real2 = BASOP_Util_Add_Mant32Exp( dot_prod_real2, dot_prod_real2_e, L_tmp, L_tmp_e, &dot_prod_real2_e );
3482 : // dot_prod_img2 += pDFT_L[2 * i + 1] * pDFT_R[2 * i] - pDFT_L[2 * i] * pDFT_R[2 * i + 1];
3483 37538757 : L_tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L[2 * i + 1], pDFT_R[2 * i] ), add( DFT_L_fx_e[2 * i + 1], DFT_R_fx_e[2 * i] ), L_negate( Mpy_32_32( pDFT_L[2 * i], pDFT_R[2 * i + 1] ) ), add( DFT_L_fx_e[2 * i], DFT_R_fx_e[2 * i + 1] ), &L_tmp_e );
3484 37538757 : dot_prod_img2 = BASOP_Util_Add_Mant32Exp( dot_prod_img2, dot_prod_img2_e, L_tmp, L_tmp_e, &dot_prod_img2_e );
3485 : }
3486 : // abs_L_R2 = sqrtf(dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2);
3487 701020 : abs_L_R2 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( dot_prod_real2, dot_prod_real2 ), shl( dot_prod_real2_e, 1 ), Mpy_32_32( dot_prod_img2, dot_prod_img2 ), shl( dot_prod_img2_e, 1 ), &abs_L_R2_e );
3488 701020 : abs_L_R2 = Sqrt32( abs_L_R2, &abs_L_R2_e );
3489 : // sub_nrg_DMX2 = sum_nrg_L2 + sum_nrg_R2 + 2 * abs_L_R2;
3490 701020 : L_tmp = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, sum_nrg_R2, sum_nrg_R2_e, &L_tmp_e );
3491 701020 : sub_nrg_DMX2 = BASOP_Util_Add_Mant32Exp( L_tmp, L_tmp_e, abs_L_R2, add( abs_L_R2_e, 1 ), &sub_nrg_DMX2_e );
3492 :
3493 701020 : IF( LT_16( b2, hStereoDft->gipd_band_max ) )
3494 : {
3495 : // hStereoDft->dot_prod_real_smooth[b2] = 0.5f * hStereoDft->dot_prod_real_smooth[b2] + 0.5f * dot_prod_real2;
3496 477144 : hStereoDft->dot_prod_real_smooth_fx[b2] = BASOP_Util_Add_Mant32Exp( hStereoDft->dot_prod_real_smooth_fx[b2], sub( hStereoDft->dot_prod_real_smooth_fx_e[b2], 1 ), dot_prod_real2, sub( dot_prod_real2_e, 1 ), &hStereoDft->dot_prod_real_smooth_fx_e[b2] );
3497 477144 : move32();
3498 : // hStereoDft->dot_prod_img_smooth[b2] = 0.5f * hStereoDft->dot_prod_img_smooth[b2] + 0.5f * dot_prod_img2;
3499 477144 : hStereoDft->dot_prod_img_smooth_fx[b2] = BASOP_Util_Add_Mant32Exp( hStereoDft->dot_prod_img_smooth_fx[b2], sub( hStereoDft->dot_prod_img_smooth_fx_e[b2], 1 ), dot_prod_img2, sub( dot_prod_img2_e, 1 ), &hStereoDft->dot_prod_img_smooth_fx_e[b2] );
3500 477144 : move32();
3501 : // pIpd[b2] = (float) atan2f( hStereoDft->dot_prod_img_smooth[b2], hStereoDft->dot_prod_real_smooth[b2] );
3502 477144 : pIpd[b2] = BASOP_util_atan2( hStereoDft->dot_prod_img_smooth_fx[b2], hStereoDft->dot_prod_real_smooth_fx[b2], sub( hStereoDft->dot_prod_img_smooth_fx_e[b2], hStereoDft->dot_prod_real_smooth_fx_e[b2] ) ); // Q13
3503 477144 : move32();
3504 :
3505 477144 : ipd_smooth[b2] = stereo_dft_calc_mean_bipd_fx( &pIpd[b2], hStereoDft->ipd_buf_fx[b2] );
3506 477144 : move32();
3507 :
3508 : // gain_IPD += ( sum_nrg_L2 + sum_nrg_R2 + 2 * dot_prod_real2 ) / sub_nrg_DMX2 / hStereoDft->gipd_band_max;
3509 477144 : L_tmp1 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, sum_nrg_R2, sum_nrg_R2_e, &L_tmp1_e );
3510 477144 : L_tmp1 = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, dot_prod_real2, add( dot_prod_real2_e, 1 ), &L_tmp1_e );
3511 477144 : W_tmp = W_mult_32_32( sub_nrg_DMX2, hStereoDft->gipd_band_max );
3512 477144 : W_shift = W_norm( W_tmp );
3513 477144 : L_tmp2 = W_extract_h( W_shl( W_tmp, W_shift ) );
3514 477144 : L_tmp2_e = sub( add( sub_nrg_DMX2_e, 31 ), W_shift );
3515 477144 : L_tmp = BASOP_Util_Divide3232_Scale_newton( L_tmp1, L_tmp2, &L_tmp_e );
3516 477144 : L_tmp_e = add( L_tmp_e, sub( L_tmp1_e, L_tmp2_e ) );
3517 477144 : L_tmp = L_shl( L_tmp, L_tmp_e ); // Q31hStereoDft->gainIPD_sm_fx = L_add( L_shr( hStereoDft->gainIPD_sm_fx, 1 ), L_
3518 477144 : gain_IPD = L_add_sat( gain_IPD, L_tmp ); // Q31: saturation expected
3519 : }
3520 :
3521 701020 : sum_past_nrgL2 = EPSILON_FX_M;
3522 701020 : move32();
3523 701020 : sum_past_nrgL2_e = EPSILON_FX_E;
3524 701020 : move16();
3525 701020 : sum_past_nrgR2 = EPSILON_FX_M;
3526 701020 : move32();
3527 701020 : sum_past_nrgR2_e = EPSILON_FX_E;
3528 701020 : move16();
3529 701020 : sum_past_dpr2 = EPSILON_FX_M;
3530 701020 : move32();
3531 701020 : sum_past_dpr2_e = EPSILON_FX_E;
3532 701020 : move16();
3533 701020 : sum_past_dpi2 = EPSILON_FX_M;
3534 701020 : move32();
3535 701020 : sum_past_dpi2_e = EPSILON_FX_E;
3536 701020 : move16();
3537 701020 : test();
3538 701020 : test();
3539 701020 : test();
3540 701020 : IF( ( EQ_16( hStereoDft->band_res[k_offset], STEREO_DFT_BAND_RES_HIGH ) && LT_16( b2, STEREO_DFT_NRG_PAST_MAX_BAND ) ) ||
3541 : ( EQ_16( hStereoDft->band_res[k_offset], STEREO_DFT_BAND_RES_LOW ) && LT_16( b2, 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) ) )
3542 : {
3543 510214 : hStereoDft->past_nrgL_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_L2;
3544 510214 : move32();
3545 510214 : hStereoDft->past_nrgL_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_L2_e;
3546 510214 : move16();
3547 510214 : hStereoDft->past_nrgR_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_R2;
3548 510214 : move32();
3549 510214 : hStereoDft->past_nrgR_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = sum_nrg_R2_e;
3550 510214 : move16();
3551 510214 : hStereoDft->past_dot_prod_real_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_real2;
3552 510214 : move32();
3553 510214 : hStereoDft->past_dot_prod_real_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_real2_e;
3554 510214 : move16();
3555 510214 : hStereoDft->past_dot_prod_imag_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_img2;
3556 510214 : move32();
3557 510214 : hStereoDft->past_dot_prod_imag_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = dot_prod_img2_e;
3558 510214 : move16();
3559 :
3560 2040856 : FOR( i = 0; i < STEREO_DFT_NRG_PAST_LEN; i++ )
3561 : {
3562 : // sum_past_nrgL2 += hStereoDft->past_nrgL[b2 * STEREO_DFT_NRG_PAST_LEN + i];
3563 1530642 : sum_past_nrgL2 = BASOP_Util_Add_Mant32Exp( sum_past_nrgL2, sum_past_nrgL2_e, hStereoDft->past_nrgL_fx[b2 * STEREO_DFT_NRG_PAST_LEN + i], hStereoDft->past_nrgL_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + i], &sum_past_nrgL2_e );
3564 : // sum_past_nrgR2 += hStereoDft->past_nrgR[b2 * STEREO_DFT_NRG_PAST_LEN + i];
3565 1530642 : sum_past_nrgR2 = BASOP_Util_Add_Mant32Exp( sum_past_nrgR2, sum_past_nrgR2_e, hStereoDft->past_nrgR_fx[b2 * STEREO_DFT_NRG_PAST_LEN + i], hStereoDft->past_nrgR_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + i], &sum_past_nrgR2_e );
3566 : // sum_past_dpr2 += hStereoDft->past_dot_prod_real[b2 * STEREO_DFT_NRG_PAST_LEN + i];
3567 1530642 : sum_past_dpr2 = BASOP_Util_Add_Mant32Exp( sum_past_dpr2, sum_past_dpr2_e, hStereoDft->past_dot_prod_real_fx[b2 * STEREO_DFT_NRG_PAST_LEN + i], hStereoDft->past_dot_prod_real_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + i], &sum_past_dpr2_e );
3568 : // sum_past_dpi2 += hStereoDft->past_dot_prod_imag[b2 * STEREO_DFT_NRG_PAST_LEN + i];
3569 1530642 : sum_past_dpi2 = BASOP_Util_Add_Mant32Exp( sum_past_dpi2, sum_past_dpi2_e, hStereoDft->past_dot_prod_imag_fx[b2 * STEREO_DFT_NRG_PAST_LEN + i], hStereoDft->past_dot_prod_imag_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + i], &sum_past_dpi2_e );
3570 : }
3571 :
3572 510214 : IF( hStereoDft->attackPresent )
3573 : {
3574 : /* omit transient frames from past part of parameter estimation in following frames */
3575 15692 : Word16 prev_pos = add( pos, STEREO_DFT_NRG_PAST_LEN - 1 ) % STEREO_DFT_NRG_PAST_LEN;
3576 15692 : hStereoDft->past_nrgL_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgL_fx[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3577 15692 : move32();
3578 15692 : hStereoDft->past_nrgL_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgL_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3579 15692 : move16();
3580 15692 : hStereoDft->past_nrgR_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgR_fx[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3581 15692 : move32();
3582 15692 : hStereoDft->past_nrgR_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_nrgR_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3583 15692 : move16();
3584 15692 : hStereoDft->past_dot_prod_real_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_dot_prod_real_fx[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3585 15692 : move32();
3586 15692 : hStereoDft->past_dot_prod_real_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_dot_prod_real_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3587 15692 : move16();
3588 15692 : hStereoDft->past_dot_prod_imag_fx[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_dot_prod_imag_fx[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3589 15692 : move32();
3590 15692 : hStereoDft->past_dot_prod_imag_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + pos] = hStereoDft->past_dot_prod_imag_fx_e[b2 * STEREO_DFT_NRG_PAST_LEN + prev_pos];
3591 15692 : move16();
3592 : }
3593 :
3594 : // sum_past_dot_prod_abs2 = sqrtf( sum_past_dpr2 * sum_past_dpr2 + sum_past_dpi2 * sum_past_dpi2 );
3595 510214 : sum_past_dot_prod_abs2 = BASOP_Util_Add_Mant32Exp( Mpy_32_32( sum_past_dpr2, sum_past_dpr2 ), shl( sum_past_dpr2_e, 1 ), Mpy_32_32( sum_past_dpi2, sum_past_dpi2 ), shl( sum_past_dpi2_e, 1 ), &sum_past_dot_prod_abs2_e );
3596 510214 : sum_past_dot_prod_abs2 = Sqrt32( sum_past_dot_prod_abs2, &sum_past_dot_prod_abs2_e );
3597 : // dot_prod_nrg_ratio[b2] = sum_past_dot_prod_abs2 / ( sum_past_nrgL2 + sum_past_nrgR2 + EPSILON );
3598 510214 : L_tmp2 = BASOP_Util_Add_Mant32Exp( sum_past_nrgL2, sum_past_nrgL2_e, sum_past_nrgR2, sum_past_nrgR2_e, &L_tmp2_e );
3599 510214 : L_tmp2 = BASOP_Util_Add_Mant32Exp( L_tmp2, L_tmp2_e, EPSILON_FX_M, EPSILON_FX_E, &L_tmp2_e );
3600 510214 : dot_prod_nrg_ratio_fx[b2] = BASOP_Util_Divide3232_Scale_newton( sum_past_dot_prod_abs2, L_tmp2, &L_tmp_e );
3601 510214 : move32();
3602 510214 : L_tmp_e = add( L_tmp_e, sub( sum_past_dot_prod_abs2_e, L_tmp2_e ) );
3603 510214 : dot_prod_nrg_ratio_fx[b2] = L_shl( dot_prod_nrg_ratio_fx[b2], L_tmp_e ); // Q31
3604 510214 : move32();
3605 510214 : dot_prod_nrg_ratio_fx_e[b2] = 0;
3606 510214 : move16();
3607 : // printf("\n%f\t", (float)dot_prod_nrg_ratio_fx[b2] / 0x7fffffff);
3608 : }
3609 : ELSE
3610 : {
3611 : // sum_past_nrgL2 += sum_nrg_L2;
3612 190806 : sum_past_nrgL2 = BASOP_Util_Add_Mant32Exp( sum_past_nrgL2, sum_past_nrgL2_e, sum_nrg_L2, sum_nrg_L2_e, &sum_past_nrgL2_e );
3613 : // sum_past_nrgR2 += sum_nrg_R2;
3614 190806 : sum_past_nrgR2 = BASOP_Util_Add_Mant32Exp( sum_past_nrgR2, sum_past_nrgR2_e, sum_nrg_R2, sum_nrg_R2_e, &sum_past_nrgR2_e );
3615 : // dot_prod_nrg_ratio[b2] = sqrtf( dot_prod_real2 * dot_prod_real2 + dot_prod_img2 * dot_prod_img2 );
3616 190806 : L_tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( dot_prod_real2, dot_prod_real2 ), shl( dot_prod_real2_e, 1 ), Mpy_32_32( dot_prod_img2, dot_prod_img2 ), shl( dot_prod_img2_e, 1 ), &L_tmp_e );
3617 190806 : L_tmp = Sqrt32( L_tmp, &L_tmp_e );
3618 190806 : dot_prod_nrg_ratio_fx[b2] = L_tmp;
3619 190806 : move32();
3620 190806 : dot_prod_nrg_ratio_fx_e[b2] = L_tmp_e;
3621 190806 : move16();
3622 190806 : IF( EQ_16( b2, 2 * STEREO_DFT_NRG_PAST_MAX_BAND_LB ) ) /* hStereoDft->band_res[k_offset] == 2 */
3623 : {
3624 : // dot_prod_nrg_ratio[b2] /= ( sum_nrg_L2 + sum_nrg_R2 + EPSILON );
3625 26573 : L_tmp2 = BASOP_Util_Add_Mant32Exp( sum_nrg_L2, sum_nrg_L2_e, sum_nrg_R2, sum_nrg_R2_e, &L_tmp2_e );
3626 26573 : L_tmp2 = BASOP_Util_Add_Mant32Exp( L_tmp2, L_tmp2_e, EPSILON_FX_M, EPSILON_FX_E, &L_tmp2_e );
3627 26573 : dot_prod_nrg_ratio_fx[b2] = BASOP_Util_Divide3232_Scale_newton( dot_prod_nrg_ratio_fx[b2], L_tmp2, &L_tmp_e );
3628 26573 : move32();
3629 26573 : L_tmp_e = add( L_tmp_e, sub( dot_prod_nrg_ratio_fx_e[b2], L_tmp2_e ) );
3630 26573 : dot_prod_nrg_ratio_fx[b2] = L_shl( dot_prod_nrg_ratio_fx[b2], L_tmp_e ); // Q31
3631 26573 : move32();
3632 26573 : dot_prod_nrg_ratio_fx_e[b2] = 0;
3633 26573 : move16();
3634 : }
3635 : }
3636 : // sum_nrg_L += sum_nrg_L2;
3637 701020 : sum_nrg_L = BASOP_Util_Add_Mant32Exp( sum_nrg_L, sum_nrg_L_e, sum_nrg_L2, sum_nrg_L2_e, &sum_nrg_L_e );
3638 : // sum_nrg_R += sum_nrg_R2;
3639 701020 : sum_nrg_R = BASOP_Util_Add_Mant32Exp( sum_nrg_R, sum_nrg_R_e, sum_nrg_R2, sum_nrg_R2_e, &sum_nrg_R_e );
3640 : // dot_prod_real += dot_prod_real2;
3641 701020 : dot_prod_real = BASOP_Util_Add_Mant32Exp( dot_prod_real, dot_prod_real_e, dot_prod_real2, dot_prod_real2_e, &dot_prod_real_e );
3642 : // dot_prod_img += dot_prod_img2;
3643 701020 : dot_prod_img = BASOP_Util_Add_Mant32Exp( dot_prod_img, dot_prod_img_e, dot_prod_img2, dot_prod_img2_e, &dot_prod_img_e );
3644 :
3645 : // sum_past_nrgL += sum_past_nrgL2;
3646 701020 : sum_past_nrgL = BASOP_Util_Add_Mant32Exp( sum_past_nrgL, sum_past_nrgL_e, sum_past_nrgL2, sum_past_nrgL2_e, &sum_past_nrgL_e );
3647 : // sum_past_nrgR += sum_past_nrgR2;
3648 701020 : sum_past_nrgR = BASOP_Util_Add_Mant32Exp( sum_past_nrgR, sum_past_nrgR_e, sum_past_nrgR2, sum_past_nrgR2_e, &sum_past_nrgR_e );
3649 : // sum_past_dpr += sum_past_dpr2;
3650 701020 : sum_past_dpr = BASOP_Util_Add_Mant32Exp( sum_past_dpr, sum_past_dpr_e, sum_past_dpr2, sum_past_dpr2_e, &sum_past_dpr_e );
3651 : // sum_past_dpi += sum_past_dpi2;
3652 701020 : sum_past_dpi = BASOP_Util_Add_Mant32Exp( sum_past_dpi, sum_past_dpi_e, sum_past_dpi2, sum_past_dpi2_e, &sum_past_dpi_e );
3653 :
3654 701020 : b2++;
3655 : }
3656 : // sum_energy_L += sum_nrg_L; /* Energies of the individual Band for Left and Right */
3657 547822 : sum_energy_L = BASOP_Util_Add_Mant32Exp( sum_energy_L, sum_energy_L_e, sum_nrg_L, sum_nrg_L_e, &sum_energy_L_e ); /* Energies of the individual Band for Left and Right */
3658 : // sum_energy_R += sum_nrg_R;
3659 547822 : sum_energy_R = BASOP_Util_Add_Mant32Exp( sum_energy_R, sum_energy_R_e, sum_nrg_R, sum_nrg_R_e, &sum_energy_R_e );
3660 : // sum_dot_prod_real += dot_prod_real;
3661 547822 : sum_dot_prod_real = BASOP_Util_Add_Mant32Exp( sum_dot_prod_real, sum_dot_prod_real_e, dot_prod_real, dot_prod_real_e, &sum_dot_prod_real_e );
3662 : // sum_dot_prod_img += dot_prod_img;
3663 547822 : sum_dot_prod_img = BASOP_Util_Add_Mant32Exp( sum_dot_prod_img, sum_dot_prod_img_e, dot_prod_img, dot_prod_img_e, &sum_dot_prod_img_e );
3664 :
3665 : /* compute side and residual gains over two frames */
3666 : // abs_L_R = sqrtf( dot_prod_real * dot_prod_real + dot_prod_img * dot_prod_img );
3667 547822 : abs_L_R = BASOP_Util_Add_Mant32Exp( Mpy_32_32( dot_prod_real, dot_prod_real ), shl( dot_prod_real_e, 1 ), Mpy_32_32( dot_prod_img, dot_prod_img ), shl( dot_prod_img_e, 1 ), &abs_L_R_e );
3668 547822 : abs_L_R = Sqrt32( abs_L_R, &abs_L_R_e );
3669 :
3670 547822 : test();
3671 547822 : test();
3672 547822 : IF( EQ_16( hStereoDft->band_res[k_offset], STEREO_DFT_BAND_RES_LOW ) && LT_16( b, 4 ) )
3673 : {
3674 : // sum_past_dot_prod_abs = sqrtf( sum_past_dpr * sum_past_dpr + sum_past_dpi * sum_past_dpi );
3675 106292 : sum_past_dot_prod_abs = BASOP_Util_Add_Mant32Exp( Mpy_32_32( sum_past_dpr, sum_past_dpr ), shl( sum_past_dpr_e, 1 ), Mpy_32_32( sum_past_dpi, sum_past_dpi ), shl( sum_past_dpi_e, 1 ), &sum_past_dot_prod_abs_e );
3676 106292 : sum_past_dot_prod_abs = Sqrt32( sum_past_dot_prod_abs, &sum_past_dot_prod_abs_e );
3677 : }
3678 441530 : ELSE IF( EQ_16( hStereoDft->band_res[k_offset], STEREO_DFT_BAND_RES_HIGH ) && LT_16( b, 9 ) )
3679 : {
3680 297630 : sum_past_dot_prod_abs = sum_past_dot_prod_abs2;
3681 297630 : move32();
3682 297630 : sum_past_dot_prod_abs_e = sum_past_dot_prod_abs2_e;
3683 297630 : move16();
3684 : }
3685 : ELSE
3686 : {
3687 143900 : sum_past_dot_prod_abs = abs_L_R;
3688 143900 : move32();
3689 143900 : sum_past_dot_prod_abs_e = abs_L_R_e;
3690 143900 : move16();
3691 : }
3692 :
3693 : // c = sqrtf( sum_past_nrgL / sum_past_nrgR );
3694 547822 : c = BASOP_Util_Divide3232_Scale_newton( sum_past_nrgL, sum_past_nrgR, &c_e );
3695 547822 : c_e = add( c_e, sub( sum_past_nrgL_e, sum_past_nrgR_e ) );
3696 547822 : c = Sqrt32( c, &c_e );
3697 : // sum_past_nrg_dmx = sum_past_nrgL + sum_past_nrgR + 2 * sum_past_dot_prod_abs;
3698 547822 : sum_past_nrg_dmx = BASOP_Util_Add_Mant32Exp( sum_past_nrgL, sum_past_nrgL_e, sum_past_nrgR, sum_past_nrgR_e, &sum_past_nrg_dmx_e );
3699 547822 : sum_past_nrg_dmx = BASOP_Util_Add_Mant32Exp( sum_past_nrg_dmx, sum_past_nrg_dmx_e, sum_past_dot_prod_abs, add( sum_past_dot_prod_abs_e, 1 ), &sum_past_nrg_dmx_e );
3700 : // sub_nrg_DMX[b] = sum_nrg_L + sum_nrg_R + 2 * abs_L_R;
3701 547822 : sub_nrg_DMX[b] = BASOP_Util_Add_Mant32Exp( sum_nrg_L, sum_nrg_L_e, sum_nrg_R, sum_nrg_R_e, &sub_nrg_DMX_e[b] );
3702 547822 : move32();
3703 547822 : sub_nrg_DMX[b] = BASOP_Util_Add_Mant32Exp( sub_nrg_DMX[b], sub_nrg_DMX_e[b], abs_L_R, add( abs_L_R_e, 1 ), &sub_nrg_DMX_e[b] );
3704 547822 : move32();
3705 :
3706 547822 : sub_nrg_L[b] = sum_nrg_L;
3707 547822 : move32();
3708 547822 : sub_nrg_L_e[b] = sum_nrg_L_e;
3709 547822 : move16();
3710 547822 : sub_nrg_R[b] = sum_nrg_R;
3711 547822 : move32();
3712 547822 : sub_nrg_R_e[b] = sum_nrg_R_e;
3713 547822 : move16();
3714 :
3715 547822 : test();
3716 547822 : test();
3717 547822 : IF( ( hStereoDft->res_pred_mode[k_offset] && GE_16( b, hStereoDft->res_pred_band_min ) ) || LT_16( b, hStereoDft->res_cod_band_max ) )
3718 : {
3719 : // g = ( sum_past_nrgL - sum_past_nrgR ) / ( sum_past_nrg_dmx );
3720 522840 : L_tmp1 = BASOP_Util_Add_Mant32Exp( sum_past_nrgL, sum_past_nrgL_e, L_negate( sum_past_nrgR ), sum_past_nrgR_e, &L_tmp1_e );
3721 522840 : L_tmp = BASOP_Util_Divide3232_Scale_newton( L_tmp1, sum_past_nrg_dmx, &L_tmp_e );
3722 522840 : L_tmp_e = add( L_tmp_e, sub( L_tmp1_e, sum_past_nrg_dmx_e ) );
3723 522840 : g = L_shl_sat( L_tmp, L_tmp_e ); // Q31 saturation expected
3724 522840 : pSideGain[b] = g;
3725 522840 : move32();
3726 : }
3727 : ELSE
3728 : {
3729 24982 : g = 0; /* to avoid compilation warning */
3730 24982 : move32();
3731 : // pSideGain[b] = ( c - 1 ) / ( c + 1 );
3732 24982 : L_tmp1 = BASOP_Util_Add_Mant32Exp( c, c_e, MIN_32, 0, &L_tmp1_e );
3733 24982 : L_tmp2 = BASOP_Util_Add_Mant32Exp( c, c_e, MAX_32, 0, &L_tmp2_e );
3734 24982 : L_tmp = BASOP_Util_Divide3232_Scale_newton( L_tmp1, L_tmp2, &L_tmp_e );
3735 24982 : L_tmp_e = add( L_tmp_e, sub( L_tmp1_e, L_tmp2_e ) );
3736 24982 : pSideGain[b] = L_shl_sat( L_tmp, L_tmp_e ); // Q31 saturation expected
3737 24982 : move32();
3738 : }
3739 :
3740 547822 : test();
3741 547822 : test();
3742 547822 : IF( hStereoDft->res_pred_mode[k_offset] && GE_16( b, hStereoDft->res_pred_band_min ) && !( hStereoDft->attackPresent ) )
3743 : {
3744 : /*(1-g)^2*L*L' + (1+g)^2*R*R' - 2(1-g^2)*abs(L*R')*/
3745 : // pPredGain[b] = max( 0, ( ( 1 - g ) * sum_past_nrgL + ( 1 + g ) * sum_past_nrgR - 2 * sum_past_dot_prod_abs ) );
3746 409101 : L_tmp1 = BASOP_Util_Add_Mant32Exp( MAX_32, 0, L_negate( g ), 0, &L_tmp1_e );
3747 409101 : L_tmp1 = Mpy_32_32( L_tmp1, sum_past_nrgL );
3748 409101 : L_tmp1_e = add( L_tmp1_e, sum_past_nrgL_e );
3749 409101 : L_tmp2 = BASOP_Util_Add_Mant32Exp( MAX_32, 0, g, 0, &L_tmp2_e );
3750 409101 : L_tmp2 = Mpy_32_32( L_tmp2, sum_past_nrgR );
3751 409101 : L_tmp2_e = add( L_tmp2_e, sum_past_nrgR_e );
3752 409101 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, L_tmp2, L_tmp2_e, &L_tmp_e );
3753 409101 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, L_tmp_e, L_negate( sum_past_dot_prod_abs ), add( sum_past_dot_prod_abs_e, 1 ), &L_tmp_e );
3754 409101 : IF( L_tmp < 0 )
3755 : {
3756 540 : L_tmp = 0;
3757 540 : move32();
3758 540 : L_tmp_e = 0;
3759 540 : move16();
3760 : }
3761 :
3762 : /*Normalized with energy of DMX*/
3763 :
3764 : /*Regularized gain computation by adding a coherent low energy contribution->avoid singularity for very low energy signals */
3765 :
3766 : // reg = ( hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b] ) * sqrtf( STEREO_DFT_N_32k_ENC );
3767 409101 : reg = L_mult0( sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), 18318 /* sqrtf( STEREO_DFT_N_32k_ENC ) in Q9 */ );
3768 409101 : reg_e = norm_l( reg );
3769 409101 : reg = L_shl( reg, reg_e );
3770 409101 : reg_e = sub( 22, reg_e );
3771 : // reg *= reg;
3772 409101 : reg = Mpy_32_32( reg, reg );
3773 409101 : reg_e = shl( reg_e, 1 );
3774 :
3775 : // pPredGain[b] = sqrtf( pPredGain[b] / ( reg + sum_past_nrg_dmx ) );
3776 409101 : L_tmp2 = BASOP_Util_Add_Mant32Exp( reg, reg_e, sum_past_nrg_dmx, sum_past_nrg_dmx_e, &L_tmp2_e );
3777 409101 : L_tmp1 = BASOP_Util_Divide3232_Scale_newton( L_tmp, L_tmp2, &L_tmp1_e );
3778 409101 : L_tmp1_e = add( L_tmp1_e, sub( L_tmp_e, L_tmp2_e ) );
3779 409101 : L_tmp1 = Sqrt32( L_tmp1, &L_tmp1_e );
3780 409101 : pPredGain[b] = L_shl( L_tmp1, L_tmp1_e ); // Q31
3781 409101 : move32();
3782 :
3783 409101 : IF( hStereoDft->hItd->deltaItd_fx[k_offset] != 0 )
3784 : {
3785 : Word32 gain_offset, conversion_factor /*Q30*/;
3786 : Word16 dItd32;
3787 :
3788 : /* factor for converting deltaItd to 32kHz */
3789 182855 : conversion_factor = ONE_IN_Q30 /*1.f*/;
3790 182855 : move32();
3791 182855 : IF( EQ_16( hStereoDft->NFFT, STEREO_DFT_N_16k_ENC ) )
3792 : {
3793 34450 : conversion_factor = MAX_32 /*2.f*/;
3794 34450 : move32();
3795 : }
3796 148405 : ELSE IF( EQ_16( hStereoDft->NFFT, STEREO_DFT_N_MAX_ENC ) )
3797 : {
3798 69040 : conversion_factor = 715827883 /*2.f / 3*/;
3799 69040 : move32();
3800 : }
3801 : // dItd32 = (int16_t) floorf( conversion_factor * hStereoDft->hItd->deltaItd[k_offset] + 0.5f );
3802 182855 : dItd32 = extract_l( L_shr_r( Mpy_32_32( conversion_factor, hStereoDft->hItd->deltaItd_fx[k_offset] ), Q15 ) ); // Q0
3803 :
3804 182855 : gain_offset = stereo_dft_gain_offset_fx( c, c_e, dItd32 ); // Q31
3805 182855 : pPredGain[b] = L_max( 0, L_sub( pPredGain[b], gain_offset ) );
3806 182855 : move32();
3807 : }
3808 :
3809 : /*Limiter for active speech*/
3810 409101 : test();
3811 409101 : IF( sp_aud_decision0 == 0 && vad_flag )
3812 : {
3813 : /*Avoid jump of residual prediction gain when ITD is changing*/
3814 233134 : IF( NE_32( hStereoDft->hItd->deltaItd_fx[k_offset], hStereoDft->hItd->deltaItd_fx[0] ) )
3815 : {
3816 20936 : pPredGain[b] = L_min( hStereoDft->res_pred_gain_f_fx[b], pPredGain[b] );
3817 20936 : move32();
3818 : }
3819 :
3820 : /*Limiter*/
3821 : // hStereoDft->res_pred_gain_f[b] = 0.9f * hStereoDft->res_pred_gain_f[b] + 0.1f * pPredGain[b];
3822 233134 : hStereoDft->res_pred_gain_f_fx[b] = L_add( Mpy_32_32( 1932735283 /* 0.9f in Q31*/, hStereoDft->res_pred_gain_f_fx[b] ), Mpy_32_32( 214748365 /* 0.1f in Q31*/, pPredGain[b] ) );
3823 233134 : move32();
3824 : // pPredGain[b] = min( 1.1f * hStereoDft->res_pred_gain_f[b], pPredGain[b] );
3825 233134 : pPredGain[b] = L_shl( L_min( Mpy_32_32( 1181116006 /*1.1f in Q30*/, hStereoDft->res_pred_gain_f_fx[b] ), L_shr( pPredGain[b], 1 ) ), 1 );
3826 233134 : move32();
3827 : }
3828 : ELSE
3829 : {
3830 175967 : hStereoDft->res_pred_gain_f_fx[b] = pPredGain[b];
3831 175967 : move32();
3832 : }
3833 : }
3834 : ELSE
3835 : {
3836 138721 : pPredGain[b] = 0;
3837 138721 : move32();
3838 : }
3839 :
3840 :
3841 547822 : IF( EQ_16( b2, hStereoDft->gipd_band_max ) )
3842 : {
3843 59643 : ipd_mean_change = stereo_dft_calc_mean_ipd_change_fx( pIpd, ipd_smooth, hStereoDft->gipd_band_max ); // Q13
3844 : // hStereoDft->sum_dot_prod_real = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_real + hStereoDft->sfm * sum_dot_prod_real;
3845 59643 : hStereoDft->sum_dot_prod_real_fx = BASOP_Util_Add_Mant32Exp( Mpy_32_32( L_sub( MAX_32, hStereoDft->sfm_fx ), hStereoDft->sum_dot_prod_real_fx ), hStereoDft->sum_dot_prod_real_fx_e,
3846 : Mpy_32_32( hStereoDft->sfm_fx, sum_dot_prod_real ), sum_dot_prod_real_e, &hStereoDft->sum_dot_prod_real_fx_e );
3847 59643 : move32();
3848 : // hStereoDft->sum_dot_prod_img = ( 1.f - hStereoDft->sfm ) * hStereoDft->sum_dot_prod_img + hStereoDft->sfm * sum_dot_prod_img;
3849 59643 : hStereoDft->sum_dot_prod_img_fx = BASOP_Util_Add_Mant32Exp( Mpy_32_32( L_sub( MAX_32, hStereoDft->sfm_fx ), hStereoDft->sum_dot_prod_img_fx ), hStereoDft->sum_dot_prod_img_fx_e,
3850 : Mpy_32_32( hStereoDft->sfm_fx, sum_dot_prod_img ), sum_dot_prod_img_e, &hStereoDft->sum_dot_prod_img_fx_e );
3851 59643 : move32();
3852 :
3853 : // pgIpd[0] = (float) atan2f( hStereoDft->sum_dot_prod_img, hStereoDft->sum_dot_prod_real );
3854 59643 : pgIpd[0] = BASOP_util_atan2( hStereoDft->sum_dot_prod_img_fx, hStereoDft->sum_dot_prod_real_fx, sub( hStereoDft->sum_dot_prod_img_fx_e, hStereoDft->sum_dot_prod_real_fx_e ) ); // Q13
3855 59643 : move32();
3856 :
3857 59643 : stereo_dft_gipd_stabilization_fx( &pgIpd[0], hStereoDft->prev_gipd_fx, ipd_mean_change );
3858 59643 : hStereoDft->prev_gipd_fx = pgIpd[0];
3859 59643 : move32();
3860 : }
3861 : }
3862 59643 : hStereoDft->nrg_past_pos = ( pos + 1 ) % STEREO_DFT_NRG_PAST_LEN;
3863 59643 : move16();
3864 :
3865 :
3866 : /*------------------------------------------------------------------*
3867 : * Compute IPDs
3868 : *-----------------------------------------------------------------*/
3869 :
3870 59643 : stereo_dft_enc_get_nipd_flag_fx( hStereoDft, sp_aud_decision0, gain_IPD );
3871 :
3872 59643 : IF( flag_quant )
3873 : {
3874 59643 : IF( hStereoDft->no_ipd_flag == 0 )
3875 : {
3876 6263 : hStereoDft->sid_gipd_fx = *pgIpd;
3877 6263 : move32();
3878 6263 : stereo_dft_quantize_ipd_fx( pgIpd, pgIpd, &( hStereoDft->gipd_index ), STEREO_DFT_GIPD_NBITS );
3879 : }
3880 : ELSE
3881 : {
3882 53380 : pgIpd[0] = 0;
3883 53380 : move32();
3884 : }
3885 : }
3886 59643 : diff_ipd = L_sub( pgIpd[0], pgIpd[-1] );
3887 :
3888 59643 : IF( LT_32( diff_ipd, -EVS_PI_FX ) )
3889 : {
3890 887 : pgIpd[0] = L_add( pgIpd[0], EVS_2PI_FX );
3891 887 : move32();
3892 : }
3893 58756 : ELSE IF( GT_32( diff_ipd, EVS_PI_FX ) )
3894 : {
3895 1573 : pgIpd[0] = L_sub( pgIpd[0], EVS_2PI_FX );
3896 1573 : move32();
3897 : }
3898 :
3899 59643 : IF( !hStereoDft->attackPresent )
3900 : {
3901 57801 : IF( hStereoDft->wasTransient )
3902 : {
3903 : // pgIpd[0] = 0.8f * pgIpd[0] + 0.2f * pgIpd[-1];
3904 1736 : pgIpd[0] = L_add( Mpy_32_32( 1717986918 /*0.8f in Q31*/, pgIpd[0] ), Mpy_32_32( 429496730 /*0.2f in Q31*/, pgIpd[-1] ) );
3905 1736 : move32();
3906 : }
3907 : ELSE
3908 : {
3909 : // pgIpd[0] = 0.5f * pgIpd[0] + 0.5f * pgIpd[-1];
3910 56065 : pgIpd[0] = L_add( L_shr( pgIpd[0], 1 ), L_shr( pgIpd[-1], 1 ) );
3911 56065 : move32();
3912 : }
3913 : }
3914 :
3915 : // c = sqrtf( sum_energy_L / sum_energy_R );
3916 59643 : c = BASOP_Util_Divide3232_Scale_newton( sum_energy_L, sum_energy_R, &c_e );
3917 59643 : c_e = add( c_e, sub( sum_energy_L_e, sum_energy_R_e ) );
3918 59643 : c = Sqrt32( c, &c_e );
3919 :
3920 : // g = fabsf( ( c - 1 ) / ( c + 1 ) );
3921 59643 : L_tmp1 = BASOP_Util_Add_Mant32Exp( c, c_e, MIN_32, 0, &L_tmp1_e );
3922 59643 : L_tmp2 = BASOP_Util_Add_Mant32Exp( c, c_e, MAX_32, 0, &L_tmp2_e );
3923 59643 : g = L_abs( BASOP_Util_Divide3232_Scale_newton( L_tmp1, L_tmp2, &L_tmp_e ) );
3924 59643 : L_tmp_e = add( L_tmp_e, sub( L_tmp1_e, L_tmp2_e ) );
3925 59643 : g = L_shl_sat( g, L_tmp_e ); // Q31 saturation expected
3926 59643 : IF( GT_32( g, 1717986918 /*0.8f in Q31*/ ) )
3927 : {
3928 : // g = max( 0.f, -10.f * g + 9.0f );
3929 651 : g = L_max( 0, L_sub( 1932735283 /*9.f/10.f in Q31*/, g ) );
3930 651 : W_tmp = W_mult0_32_32( g, 10 );
3931 651 : if ( GT_64( W_tmp, MAX_32 ) )
3932 : {
3933 0 : W_tmp = MAX_32;
3934 0 : move64();
3935 : }
3936 651 : g = W_extract_l( W_tmp ); // Q31
3937 5554 : FOR( b = 0; b < hStereoDft->nbands; b++ )
3938 : {
3939 : // pPredGain[b] *= g;
3940 4903 : pPredGain[b] = Mpy_32_32( pPredGain[b], g );
3941 4903 : move32();
3942 : }
3943 : }
3944 :
3945 59643 : IF( EQ_16( hStereoDft->hConfig->band_res, STEREO_DFT_BAND_RES_LOW ) )
3946 : {
3947 26573 : hStereoDft->reverb_flag = 1;
3948 26573 : move16();
3949 : }
3950 : ELSE
3951 : {
3952 33070 : stereo_dft_enc_get_reverb_flag_fx( hStereoDft, pPredGain, sub_nrg_DMX, sub_nrg_DMX_e, sub_nrg_L, sub_nrg_L_e, sub_nrg_R, sub_nrg_R_e, k_offset, bin_nrgL_fx, bin_nrgL_fx_e, bin_nrgR_fx, bin_nrgR_fx_e );
3953 : }
3954 :
3955 :
3956 : /*------------------------------------------------------------------*
3957 : * Compute Side gains
3958 : *-----------------------------------------------------------------*/
3959 :
3960 607465 : FOR( b = 0; b < hStereoDft->nbands; b++ )
3961 : {
3962 547822 : hStereoDft->sidSideGain_fx[b] = *( pSideGain + b );
3963 547822 : move32();
3964 :
3965 : /* Quantization */
3966 547822 : IF( flag_quant )
3967 : {
3968 547822 : stereo_dft_quantize_res_gains_fx( pSideGain + b, pPredGain + b, pSideGain + b, pPredGain + b, hStereoDft->side_gain_index_EC + b, hStereoDft->res_pred_index_EC + b );
3969 : }
3970 :
3971 :
3972 547822 : IF( !hStereoDft->attackPresent )
3973 : {
3974 531368 : IF( LT_16( b, hStereoDft->res_cod_band_max ) )
3975 : {
3976 : // pSideGain[b] = dft_res_cod_alpha[b] * pSideGain[b] + ( 1 - dft_res_cod_alpha[b] ) * pSideGain[b - STEREO_DFT_BAND_MAX];
3977 97990 : pSideGain[b] = L_add( Mpy_32_16_1( pSideGain[b], dft_res_cod_alpha_fx[b] ), Mpy_32_16_1( pSideGain[b - STEREO_DFT_BAND_MAX], sub( MAX_16, dft_res_cod_alpha_fx[b] ) ) );
3978 97990 : move32();
3979 : }
3980 : }
3981 : }
3982 :
3983 : /*------------------------------------------------------------------*
3984 : * simulate prediction of parameters at the decoder
3985 : *-----------------------------------------------------------------*/
3986 :
3987 59643 : IF( hStereoDft->reverb_flag )
3988 : {
3989 : Word16 ipred, bpred0, bpred1, max_dev, sum_abs_dev;
3990 :
3991 38593 : ipred = 0;
3992 38593 : move16();
3993 38593 : max_dev = 0;
3994 38593 : move16();
3995 38593 : sum_abs_dev = 0;
3996 38593 : move16();
3997 :
3998 : /* parameters for bred0 <= b < bpred1 are estimated from parameters of
3999 : the remaining bands with ptrans0 <= b < btrans1. */
4000 : // bpred1 = ( hStereoDft->nbands > 10 ) ? STEREO_DFT_RES_PRED_BAND_MAX - 2 : hStereoDft->nbands;
4001 38593 : IF( GT_16( hStereoDft->nbands, 10 ) )
4002 : {
4003 9070 : bpred1 = STEREO_DFT_RES_PRED_BAND_MAX - 2;
4004 9070 : move16();
4005 : }
4006 : ELSE
4007 : {
4008 29523 : bpred1 = hStereoDft->nbands;
4009 29523 : move16();
4010 : }
4011 :
4012 38593 : IF( EQ_16( hStereoDft->band_res[k_offset], STEREO_DFT_BAND_RES_LOW ) )
4013 : {
4014 26573 : bpred1 = s_min( bpred1, 6 );
4015 : }
4016 38593 : bpred0 = sub( bpred1, STEREO_DFT_RES_PRED_BAND_MIN_CONST );
4017 :
4018 : /* get estimate (currently the maximal index) */
4019 196212 : FOR( b = hStereoDft->res_pred_band_min; b < bpred0; b++ )
4020 : {
4021 157619 : ipred = s_max( ipred, hStereoDft->res_pred_index_EC[b] );
4022 : }
4023 :
4024 : /* check prediction error */
4025 154372 : FOR( b = bpred0; b < bpred1; b++ )
4026 : {
4027 115779 : max_dev = s_max( max_dev, abs_s( sub( ipred, hStereoDft->res_pred_index_EC[b] ) ) );
4028 115779 : sum_abs_dev = add( sum_abs_dev, abs_s( sub( ipred, hStereoDft->res_pred_index_EC[b] ) ) );
4029 : }
4030 :
4031 38593 : test();
4032 38593 : hStereoDft->reverb_flag = ( LE_16( max_dev, 1 ) && LE_16( sum_abs_dev, 2 ) );
4033 :
4034 38593 : test();
4035 38593 : IF( hStereoDft->reverb_flag && GT_16( hStereoDft->nbands, 10 ) ) /*SWB and FB*/
4036 : {
4037 8763 : FOR( b = STEREO_DFT_RES_PRED_BAND_MAX - 1; b >= STEREO_DFT_RES_PRED_BAND_MAX - 2; b-- )
4038 : {
4039 5842 : hStereoDft->res_pred_index_EC[b - STEREO_DFT_RES_PRED_BAND_MIN_CONST] = hStereoDft->res_pred_index_EC[b];
4040 5842 : move16();
4041 : }
4042 : }
4043 : }
4044 :
4045 59643 : assert( hStereoDft->nbands <= 13 ); /* always use band_limits_erb4 and not band_limits_erb2 */
4046 :
4047 59643 : return;
4048 : }
4049 :
4050 : /*---------------------------------------------------------------------*
4051 : * side_gain_mode_decision()
4052 : *
4053 : *
4054 : *---------------------------------------------------------------------*/
4055 45146 : static void side_gain_mode_decision_fx(
4056 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
4057 : Word16 encoded_ind_GR[],
4058 : const Word16 sp_aud_decision0, /* i : Speech/audio decision 0 */
4059 : const Word32 last_core_brate /* i : Last core bitrate */
4060 : )
4061 : {
4062 : Word16 try_diff, nb_diff, no_GR_ord, n_bits, i;
4063 :
4064 45146 : try_diff = sp_aud_decision0;
4065 45146 : move16();
4066 45146 : IF( try_diff )
4067 : {
4068 10886 : IF( EQ_16( hStereoDft->side_gain_counter, STEREO_DFT_FEC_THRESHOLD ) )
4069 : {
4070 344 : try_diff = 0;
4071 344 : move16();
4072 344 : hStereoDft->side_gain_counter = 0;
4073 344 : move16();
4074 : }
4075 : }
4076 : ELSE
4077 : {
4078 34260 : hStereoDft->side_gain_counter = 0;
4079 34260 : move16();
4080 : }
4081 :
4082 : /* If last frame SID/NO_DATA do not use differential coding */
4083 45146 : if ( LE_32( last_core_brate, SID_2k40 ) )
4084 : {
4085 1417 : try_diff = 0;
4086 1417 : move16();
4087 : }
4088 45146 : no_GR_ord = 3;
4089 45146 : move16();
4090 90292 : hStereoDft->side_gain_flag_2 = adapt_GR_ief_fx( hStereoDft->side_gain_index_EC, hStereoDft->side_gain_index_ECDiff, hStereoDft->side_gain_index_ECprevious,
4091 45146 : hStereoDft->nbands, NO_SYMB_GR_SIDE_G, &n_bits, encoded_ind_GR, dft_maps_sg, no_GR_ord, &nb_diff,
4092 45146 : hStereoDft->side_gain_counter, &hStereoDft->side_gain_bitdiff_lp_fx, &hStereoDft->q_side_gain_bitdiff_lp, try_diff );
4093 45146 : move16();
4094 :
4095 471827 : FOR( i = 0; i < hStereoDft->nbands; i++ )
4096 : {
4097 426681 : hStereoDft->side_gain_index_ECprevious[i] = hStereoDft->side_gain_index_EC[i];
4098 426681 : move16();
4099 : }
4100 :
4101 45146 : IF( GT_16( n_bits, sub( imult1616( hStereoDft->nbands, STEREO_DFT_SIDE_GAIN_NBITS ), 1 ) ) )
4102 : {
4103 : /* use fixed rate */
4104 1082 : hStereoDft->side_gain_flag_1 = 3;
4105 1082 : move16();
4106 1082 : hStereoDft->side_gain_counter = 0;
4107 1082 : move16();
4108 : }
4109 : ELSE
4110 : {
4111 44064 : IF( GE_32( hStereoDft->side_gain_flag_2, no_GR_ord ) )
4112 : {
4113 8903 : hStereoDft->side_gain_flag_1 = 2;
4114 8903 : move16();
4115 8903 : hStereoDft->side_gain_counter = add( hStereoDft->side_gain_counter, 1 );
4116 8903 : move16();
4117 : }
4118 : ELSE
4119 : {
4120 35161 : hStereoDft->side_gain_flag_1 = 0;
4121 35161 : move16();
4122 35161 : hStereoDft->side_gain_counter = 0;
4123 35161 : move16();
4124 : }
4125 : }
4126 :
4127 45146 : return;
4128 : }
4129 :
4130 : /*---------------------------------------------------------------------*
4131 : * res_pred_gain_mode_decision()
4132 : *
4133 : *
4134 : *---------------------------------------------------------------------*/
4135 :
4136 45146 : static void res_pred_gain_mode_decision_fx(
4137 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i : DFT stereo encoder handle */
4138 : Word16 encoded_ind_pred_GR[],
4139 : const Word16 k_offset, /* i : Parameter offset */
4140 : const Word32 last_core_brate /* i : Last core bitrate */
4141 : )
4142 : {
4143 : Word16 nb_diff, try_diff, no_GR_ord, i, n_bits;
4144 : Word16 nbands;
4145 :
4146 : /* Residual Prediction Gain */
4147 45146 : IF( hStereoDft->res_pred_mode[k_offset] )
4148 : {
4149 43697 : IF( hStereoDft->attackPresent == 0 )
4150 : {
4151 42102 : nbands = s_min( hStereoDft->nbands, STEREO_DFT_RES_PRED_BAND_MAX );
4152 :
4153 42102 : if ( hStereoDft->reverb_flag )
4154 : {
4155 6818 : nbands = sub( nbands, STEREO_DFT_RES_PRED_BAND_MIN_CONST );
4156 : }
4157 :
4158 42102 : try_diff = 1;
4159 42102 : move16();
4160 42102 : IF( EQ_16( hStereoDft->res_pred_counter, STEREO_DFT_FEC_THRESHOLD ) )
4161 : {
4162 1643 : try_diff = 0;
4163 1643 : move16();
4164 1643 : hStereoDft->res_pred_counter = 0;
4165 1643 : move16();
4166 : }
4167 :
4168 : /* If last frame SID/NO_DATA do not use differential coding */
4169 42102 : IF( LE_32( last_core_brate, SID_2k40 ) )
4170 : {
4171 307 : try_diff = 0;
4172 307 : move16();
4173 : }
4174 :
4175 42102 : no_GR_ord = 2;
4176 42102 : move16();
4177 :
4178 42102 : hStereoDft->res_pred_flag_2 = adapt_GR_rpg1_ief_fx( &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 );
4179 42102 : move16();
4180 :
4181 416949 : FOR( i = 0; i < nbands; i++ )
4182 : {
4183 374847 : hStereoDft->res_pred_index_ECprevious[i] = hStereoDft->res_pred_index_EC[i];
4184 374847 : move16();
4185 : }
4186 :
4187 70686 : FOR( ; i < hStereoDft->nbands; i++ )
4188 : {
4189 28584 : hStereoDft->res_pred_index_ECprevious[i] = 0;
4190 28584 : move16();
4191 : }
4192 :
4193 42102 : IF( GT_16( n_bits, sub( imult1616( sub( nbands, hStereoDft->res_pred_band_min ), STEREO_DFT_RES_GAINS_BITS ), 1 ) ) )
4194 : {
4195 3397 : hStereoDft->res_pred_flag_1 = 3;
4196 3397 : move16();
4197 3397 : hStereoDft->res_pred_counter = 0;
4198 3397 : move16();
4199 : }
4200 : ELSE
4201 : {
4202 38705 : IF( GT_16( hStereoDft->res_pred_flag_2, 1 ) )
4203 : {
4204 : /* differential coding */
4205 30296 : hStereoDft->res_pred_flag_1 = 2;
4206 30296 : move16();
4207 30296 : hStereoDft->res_pred_counter = add( hStereoDft->res_pred_counter, 1 );
4208 30296 : move16();
4209 : }
4210 : ELSE
4211 : {
4212 8409 : hStereoDft->res_pred_counter = 0;
4213 8409 : move16();
4214 8409 : hStereoDft->res_pred_flag_1 = 0;
4215 8409 : move16();
4216 : }
4217 : }
4218 : }
4219 : ELSE
4220 : {
4221 1595 : set16_fx( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
4222 : }
4223 : }
4224 : ELSE
4225 : {
4226 1449 : set16_fx( hStereoDft->res_pred_index_ECprevious, 0, hStereoDft->nbands );
4227 : }
4228 :
4229 45146 : return;
4230 : }
4231 :
4232 : /*-------------------------------------------------------------------------
4233 : * stereo_dft_calc_mean_bipd()
4234 : *
4235 : * Calculate mean of previous bandwise IPD values
4236 : *------------------------------------------------------------------------*/
4237 : static Word16 ipd_table1[STEREO_DFT_IPD_BUF_LEN] = { 0, 16384, 21845, 24576, 26214 }; //(i / (float)(i + 1))
4238 : static Word16 ipd_table2[STEREO_DFT_IPD_BUF_LEN] = { MAX_16, 16384, 10923, 8192, 6554 }; //(1 / (float)(i + 1))
4239 477144 : static Word32 stereo_dft_calc_mean_bipd_fx(
4240 : Word32 *pIpd, /* i : current bandwise IPD Q13 */
4241 : Word32 ipd_buf[STEREO_DFT_IPD_BUF_LEN] /* i/o: previous bandwise IPDs Q13 */
4242 : )
4243 : {
4244 : Word16 i;
4245 : Word32 ipd_smooth;
4246 : Word32 diff_to_last;
4247 :
4248 477144 : assert( *pIpd <= EVS_PI_FX && *pIpd >= -EVS_PI_FX );
4249 :
4250 477144 : ipd_smooth = 0;
4251 477144 : move16();
4252 2862864 : FOR( i = 0; i < STEREO_DFT_IPD_BUF_LEN; i++ )
4253 : {
4254 2385720 : IF( i == 0 )
4255 : {
4256 477144 : diff_to_last = ipd_buf[0];
4257 477144 : move32();
4258 : }
4259 : ELSE
4260 : {
4261 1908576 : diff_to_last = L_abs( L_sub( ipd_buf[i], ipd_smooth ) );
4262 : }
4263 2385720 : IF( GT_32( diff_to_last, EVS_PI_FX ) )
4264 : {
4265 52147 : IF( ipd_buf[i] > 0 )
4266 : {
4267 29830 : ipd_buf[i] = L_sub( ipd_buf[i], 2 * EVS_PI_FX );
4268 : }
4269 : ELSE
4270 : {
4271 22317 : ipd_buf[i] = L_add( ipd_buf[i], 2 * EVS_PI_FX );
4272 : }
4273 52147 : move32();
4274 : }
4275 : // ipd_smooth = (i / (float)(i + 1)) * ipd_smooth + (1 / (float)(i + 1)) * ipd_buf[i];
4276 2385720 : ipd_smooth = L_add( Mpy_32_16_1( ipd_smooth, ipd_table1[i] ), Mpy_32_16_1( ipd_buf[i], ipd_table2[i] ) ); // Q13
4277 2385720 : IF( LT_32( ipd_smooth, -EVS_PI_FX ) )
4278 : {
4279 18534 : ipd_smooth = L_add( ipd_smooth, 2 * EVS_PI_FX );
4280 : }
4281 2367186 : ELSE IF( GT_32( ipd_smooth, EVS_PI_FX ) )
4282 : {
4283 10937 : ipd_smooth = L_sub( ipd_smooth, 2 * EVS_PI_FX );
4284 : }
4285 : }
4286 :
4287 2385720 : FOR( i = 0; i < STEREO_DFT_IPD_BUF_LEN - 1; i++ )
4288 : {
4289 1908576 : ipd_buf[i] = ipd_buf[i + 1];
4290 1908576 : move32();
4291 : }
4292 477144 : ipd_buf[STEREO_DFT_IPD_BUF_LEN - 1] = *pIpd;
4293 477144 : move32();
4294 :
4295 :
4296 477144 : return ipd_smooth;
4297 : }
4298 :
4299 : /*-------------------------------------------------------------------------
4300 : * stereo_dft_calc_mean_ipd_change()
4301 : *
4302 : * Calculate mean IPD change over all bands
4303 : *------------------------------------------------------------------------*/
4304 59643 : static Word32 stereo_dft_calc_mean_ipd_change_fx(
4305 : Word32 *pIpd, /* i : bandwise IPDs Q13 */
4306 : Word32 *ipd_smooth, /* i : mean of previous bandwise IPDs Q13 */
4307 : Word16 gipd_band_max /* i : number of IPD bands */
4308 : )
4309 : {
4310 : Word16 b;
4311 : Word32 ipd_mean_change; // Q13
4312 : Word16 ipd_mean_change_e;
4313 : Word32 ipd_change[STEREO_DFT_BAND_MAX]; // Q13
4314 :
4315 59643 : ipd_mean_change = 0;
4316 59643 : move32();
4317 536787 : FOR( b = 0; b < gipd_band_max; b++ )
4318 : {
4319 477144 : ipd_change[b] = L_abs( L_sub( pIpd[b], ipd_smooth[b] ) );
4320 477144 : move32();
4321 477144 : IF( GT_32( ipd_change[b], EVS_PI_FX ) )
4322 : {
4323 21374 : ipd_change[b] = L_sub( 2 * EVS_PI_FX, ipd_change[b] );
4324 21374 : move32();
4325 : }
4326 477144 : ipd_mean_change = L_add( ipd_mean_change, ipd_change[b] );
4327 : }
4328 : // ipd_mean_change /= gipd_band_max;
4329 59643 : ipd_mean_change = BASOP_Util_Divide3232_Scale_newton( ipd_mean_change, gipd_band_max, &ipd_mean_change_e );
4330 59643 : ipd_mean_change_e = add( ipd_mean_change_e, 18 - 31 );
4331 59643 : ipd_mean_change = L_shr( ipd_mean_change, sub( 18, ipd_mean_change_e ) ); // Q13
4332 :
4333 59643 : return ipd_mean_change;
4334 : }
4335 :
4336 : /*-------------------------------------------------------------------------
4337 : * stereo_dft_gipd_stabilization()
4338 : *
4339 : * stabilize global IPD based on stability of bandwise IPDs
4340 : *------------------------------------------------------------------------*/
4341 59643 : static void stereo_dft_gipd_stabilization_fx(
4342 : Word32 *pgIpd, /* i/o: global IPD to be stabilized Q13 */
4343 : Word32 prev_gipd, /* i : previous global IPD Q13 */
4344 : Word32 ipd_mean_change /* i : mean of previous bandwise IPDs Q13 */
4345 : )
4346 : {
4347 : Word32 diff_gipd;
4348 :
4349 59643 : IF( LT_32( ipd_mean_change, 2458 /*0.3f in Q13*/ ) )
4350 : {
4351 26290 : *pgIpd = prev_gipd;
4352 26290 : move32();
4353 : }
4354 : ELSE
4355 : {
4356 33353 : diff_gipd = L_abs( L_sub( *pgIpd, prev_gipd ) );
4357 33353 : if ( GT_32( diff_gipd, EVS_PI_FX ) )
4358 : {
4359 1254 : diff_gipd = L_sub( 2 * EVS_PI_FX, diff_gipd );
4360 : }
4361 33353 : IF( GT_32( diff_gipd, ipd_mean_change ) )
4362 : {
4363 5445 : IF( GT_32( *pgIpd, prev_gipd ) )
4364 : {
4365 2595 : IF( LT_32( L_sub( *pgIpd, prev_gipd ), EVS_PI_FX ) )
4366 : {
4367 2169 : *pgIpd = L_add( prev_gipd, ipd_mean_change );
4368 2169 : move32();
4369 : }
4370 : ELSE
4371 : {
4372 426 : *pgIpd = L_sub( prev_gipd, ipd_mean_change );
4373 426 : move32();
4374 426 : if ( LT_32( *pgIpd, -EVS_PI_FX ) )
4375 : {
4376 150 : *pgIpd = L_add( *pgIpd, 2 * EVS_PI_FX );
4377 150 : move32();
4378 : }
4379 : }
4380 : }
4381 : ELSE
4382 : {
4383 2850 : IF( LT_32( L_sub( prev_gipd, *pgIpd ), EVS_PI_FX ) )
4384 : {
4385 2300 : *pgIpd = L_sub( prev_gipd, ipd_mean_change );
4386 2300 : move32();
4387 : }
4388 : ELSE
4389 : {
4390 550 : *pgIpd = L_add( prev_gipd, ipd_mean_change );
4391 550 : move32();
4392 550 : if ( GT_32( *pgIpd, EVS_PI_FX ) )
4393 : {
4394 243 : *pgIpd = L_sub( *pgIpd, 2 * EVS_PI_FX );
4395 243 : move32();
4396 : }
4397 : }
4398 : }
4399 : }
4400 : }
4401 59643 : return;
4402 : }
4403 :
4404 : /*-------------------------------------------------------------------------
4405 : * stereo_dft_enc_get_nipd_flag()
4406 : *
4407 : *
4408 : *------------------------------------------------------------------------*/
4409 59643 : static void stereo_dft_enc_get_nipd_flag_fx(
4410 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
4411 : const Word16 sp_aud_decision0,
4412 : const Word32 gainIPD )
4413 : {
4414 : // hStereoDft->gainIPD_sm = 0.5f * hStereoDft->gainIPD_sm + 0.5f * gainIPD; /* to decide on use of no IPD */
4415 59643 : hStereoDft->gainIPD_sm_fx = L_add( L_shr( hStereoDft->gainIPD_sm_fx, 1 ), L_shr( gainIPD, 1 ) ); /* to decide on use of no IPD */
4416 59643 : move32();
4417 :
4418 59643 : hStereoDft->no_ipd_flag = 0; /* Set flag initially to zero - subband IPD */
4419 59643 : move16();
4420 :
4421 : // if (hStereoDft->gainIPD_sm >= 0.75f || (hStereoDft->prev_no_ipd_flag && (sp_aud_decision0 || hStereoDft->voicing_lt > 0.98f)))
4422 59643 : test();
4423 59643 : test();
4424 59643 : test();
4425 59643 : if ( GE_32( hStereoDft->gainIPD_sm_fx, 1610612736 /*0.75f in Q31*/ ) || ( hStereoDft->prev_no_ipd_flag && ( sp_aud_decision0 || GT_32( hStereoDft->voicing_lt_fx, 2104533975 /*0.98f in Q31*/ ) ) ) )
4426 : {
4427 51870 : hStereoDft->no_ipd_flag = 1; /* Set the flag */
4428 51870 : move16();
4429 : }
4430 :
4431 :
4432 : /* hangover between the group IPD and subband IPD */
4433 59643 : test();
4434 59643 : IF( NE_16( hStereoDft->prev_no_ipd_flag, hStereoDft->no_ipd_flag ) && LT_16( hStereoDft->no_ipd_cnt, 5 ) )
4435 : {
4436 7056 : hStereoDft->no_ipd_flag = hStereoDft->prev_no_ipd_flag;
4437 7056 : move16();
4438 7056 : hStereoDft->no_ipd_cnt = add( hStereoDft->no_ipd_cnt, 1 );
4439 7056 : move16();
4440 : }
4441 : ELSE
4442 : {
4443 52587 : hStereoDft->no_ipd_cnt = 0;
4444 52587 : move16();
4445 : }
4446 :
4447 59643 : hStereoDft->prev_no_ipd_flag = hStereoDft->no_ipd_flag; /* Save the no IPD flag for the next frame */
4448 59643 : move16();
4449 :
4450 59643 : return;
4451 : }
4452 :
4453 : /*---------------------------------------------------------------
4454 : * stereo_dft_enc_get_reverb_flag()
4455 : *
4456 : *
4457 : * ---------------------------------------------------------------*/
4458 33070 : static void stereo_dft_enc_get_reverb_flag_fx(
4459 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft,
4460 : Word32 *pPredGain, // Q31
4461 : Word32 *sub_nrg_DMX, // Q(31-sub_nrg_DMX_e)
4462 : Word16 *sub_nrg_DMX_e,
4463 : const Word32 *sub_nrg_L, // Q(31-sub_nrg_L_e[])
4464 : const Word16 *sub_nrg_L_e,
4465 : const Word32 *sub_nrg_R, // Q(31-sub_nrg_R_e[])
4466 : const Word16 *sub_nrg_R_e,
4467 : const Word16 k_offset,
4468 : const Word32 *bin_nrgL, // Q(31-bin_nrgL_e[])
4469 : const Word16 *bin_nrgL_e,
4470 : const Word32 *bin_nrgR, // Q(31-bin_nrgR_e[])
4471 : const Word16 *bin_nrgR_e )
4472 : {
4473 : Word16 i, b, b1, index_min, nbands;
4474 : Word32 nrg_DMX_min;
4475 : Word16 nrg_DMX_min_e;
4476 : Word32 norm_r, norm_l, norm_dmx;
4477 : Word16 norm_r_e, norm_l_e, norm_dmx_e;
4478 : Word32 diff_l_l, diff_r_l, diff_l_h, diff_r_h;
4479 : Word16 diff_l_l_e, diff_r_l_e, diff_l_h_e, diff_r_h_e;
4480 : Word32 ener_l, ener_r, ener_dmx;
4481 : Word16 ener_l_e, ener_r_e, ener_dmx_e;
4482 : Word32 nrg_DMX_max_avrg, nrg_DMX_min_avrg;
4483 : Word16 nrg_DMX_max_avrg_e, nrg_DMX_min_avrg_e;
4484 : Word32 fac;
4485 : Word32 L_tmp;
4486 : Word16 L_tmp_e;
4487 :
4488 33070 : hStereoDft->reverb_flag = 0;
4489 33070 : move16();
4490 33070 : test();
4491 33070 : IF( hStereoDft->res_pred_mode[k_offset] && EQ_16( hStereoDft->hConfig->res_cod_mode, STEREO_DFT_RES_COD_OFF ) )
4492 : {
4493 12861 : diff_r_l = EPSILON_FX_M;
4494 12861 : move32();
4495 12861 : diff_r_l_e = EPSILON_FX_E;
4496 12861 : move16();
4497 12861 : diff_l_l = EPSILON_FX_M;
4498 12861 : move32();
4499 12861 : diff_l_l_e = EPSILON_FX_E;
4500 12861 : move16();
4501 12861 : diff_r_h = EPSILON_FX_M;
4502 12861 : move32();
4503 12861 : diff_r_h_e = EPSILON_FX_E;
4504 12861 : move16();
4505 12861 : diff_l_h = EPSILON_FX_M;
4506 12861 : move32();
4507 12861 : diff_l_h_e = EPSILON_FX_E;
4508 12861 : move16();
4509 :
4510 102888 : FOR( b = 0; b <= s_min( hStereoDft->nbands, 6 ); b++ ) /* choose the subbands used for stereo filling */
4511 : {
4512 : // norm_dmx = ((hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b]) / sub_nrg_DMX[b]);
4513 90027 : norm_dmx = BASOP_Util_Divide3232_Scale_newton( sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), sub_nrg_DMX[b], &norm_dmx_e );
4514 90027 : norm_dmx_e = add( norm_dmx_e, sub( 31, sub_nrg_DMX_e[b] ) );
4515 : // norm_l = ((hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b]) / sub_nrg_L[b]);
4516 90027 : norm_l = BASOP_Util_Divide3232_Scale_newton( sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), sub_nrg_L[b], &norm_l_e );
4517 90027 : norm_l_e = add( norm_l_e, sub( 31, sub_nrg_L_e[b] ) );
4518 : // norm_r = ((hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b]) / sub_nrg_R[b]);
4519 90027 : norm_r = BASOP_Util_Divide3232_Scale_newton( sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), sub_nrg_R[b], &norm_r_e );
4520 90027 : norm_r_e = add( norm_r_e, sub( 31, sub_nrg_R_e[b] ) );
4521 :
4522 1234656 : FOR( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
4523 : {
4524 1144629 : ener_l = bin_nrgL[i];
4525 1144629 : move32();
4526 1144629 : ener_l_e = bin_nrgL_e[i];
4527 1144629 : move16();
4528 1144629 : ener_r = bin_nrgR[i];
4529 1144629 : move32();
4530 1144629 : ener_r_e = bin_nrgR_e[i];
4531 1144629 : move16();
4532 : // ener_dmx = (ener_l + ener_r + 2 * sqrtf(ener_l * ener_r)) * norm_dmx; /*approximation of nrg of DMX per line*/
4533 1144629 : L_tmp = Mpy_32_32( ener_l, ener_r );
4534 1144629 : L_tmp_e = add( ener_l_e, ener_r_e );
4535 1144629 : L_tmp = Sqrt32( L_tmp, &L_tmp_e );
4536 1144629 : L_tmp = Mpy_32_32( L_tmp, norm_dmx );
4537 1144629 : L_tmp_e = add( add( L_tmp_e, norm_dmx_e ), 1 );
4538 1144629 : L_tmp = BASOP_Util_Add_Mant32Exp( ener_l, ener_l_e, L_tmp, L_tmp_e, &L_tmp_e );
4539 1144629 : L_tmp = BASOP_Util_Add_Mant32Exp( ener_r, ener_r_e, L_tmp, L_tmp_e, &L_tmp_e );
4540 1144629 : ener_dmx = L_tmp;
4541 1144629 : move32();
4542 1144629 : ener_dmx_e = L_tmp_e;
4543 1144629 : move16();
4544 :
4545 : // ener_l *= norm_l;
4546 1144629 : ener_l = Mpy_32_32( ener_l, norm_l );
4547 1144629 : ener_l_e = add( ener_l_e, norm_l_e );
4548 : // ener_r *= norm_r;
4549 1144629 : ener_r = Mpy_32_32( ener_r, norm_r );
4550 1144629 : ener_r_e = add( ener_r_e, norm_r_e );
4551 :
4552 : // diff_l_l += fabsf(ener_l - ener_dmx);
4553 1144629 : L_tmp = L_abs( BASOP_Util_Add_Mant32Exp( ener_l, ener_l_e, L_negate( ener_dmx ), ener_dmx_e, &L_tmp_e ) );
4554 1144629 : diff_l_l = BASOP_Util_Add_Mant32Exp( diff_l_l, diff_l_l_e, L_tmp, L_tmp_e, &diff_l_l_e );
4555 : // diff_r_l += fabsf(ener_r - ener_dmx);
4556 1144629 : L_tmp = L_abs( BASOP_Util_Add_Mant32Exp( ener_r, ener_r_e, L_negate( ener_dmx ), ener_dmx_e, &L_tmp_e ) );
4557 1144629 : diff_r_l = BASOP_Util_Add_Mant32Exp( diff_r_l, diff_r_l_e, L_tmp, L_tmp_e, &diff_r_l_e );
4558 : }
4559 : }
4560 12861 : IF( LE_16( hStereoDft->nbands, 10 ) )
4561 : {
4562 11800 : FOR( ; b < s_min( hStereoDft->nbands, 10 ); b++ ) /* choose the subbands used for stereo filling */
4563 : {
4564 : // norm_dmx = ((hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b]) / sub_nrg_DMX[b]);
4565 8850 : norm_dmx = BASOP_Util_Divide3232_Scale_newton( sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), sub_nrg_DMX[b], &norm_dmx_e );
4566 8850 : norm_dmx_e = add( norm_dmx_e, sub( 31, sub_nrg_DMX_e[b] ) );
4567 : // norm_l = ((hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b]) / sub_nrg_L[b]);
4568 8850 : norm_l = BASOP_Util_Divide3232_Scale_newton( sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), sub_nrg_L[b], &norm_l_e );
4569 8850 : norm_l_e = add( norm_l_e, sub( 31, sub_nrg_L_e[b] ) );
4570 : // norm_r = ((hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b]) / sub_nrg_R[b]);
4571 8850 : norm_r = BASOP_Util_Divide3232_Scale_newton( sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), sub_nrg_R[b], &norm_r_e );
4572 8850 : norm_r_e = add( norm_r_e, sub( 31, sub_nrg_R_e[b] ) );
4573 :
4574 687350 : FOR( i = hStereoDft->band_limits[b]; i < hStereoDft->band_limits[b + 1]; i++ ) /* normalization on each subbands */
4575 : {
4576 678500 : ener_l = bin_nrgL[i];
4577 678500 : move32();
4578 678500 : ener_l_e = bin_nrgL_e[i];
4579 678500 : move16();
4580 678500 : ener_r = bin_nrgR[i];
4581 678500 : move32();
4582 678500 : ener_r_e = bin_nrgR_e[i];
4583 678500 : move16();
4584 : // ener_dmx = (ener_l + ener_r + 2 * sqrtf(ener_l * ener_r)) * norm_dmx; /*approximation of nrg of DMX per line*/
4585 678500 : L_tmp = Mpy_32_32( ener_l, ener_r );
4586 678500 : L_tmp_e = add( ener_l_e, ener_r_e );
4587 678500 : L_tmp = Sqrt32( L_tmp, &L_tmp_e );
4588 678500 : L_tmp = Mpy_32_32( L_tmp, norm_dmx );
4589 678500 : L_tmp_e = add( add( L_tmp_e, norm_dmx_e ), 1 );
4590 678500 : L_tmp = BASOP_Util_Add_Mant32Exp( ener_l, ener_l_e, L_tmp, L_tmp_e, &L_tmp_e );
4591 678500 : L_tmp = BASOP_Util_Add_Mant32Exp( ener_r, ener_r_e, L_tmp, L_tmp_e, &L_tmp_e );
4592 678500 : ener_dmx = L_tmp;
4593 678500 : move32();
4594 678500 : ener_dmx_e = L_tmp_e;
4595 678500 : move16();
4596 :
4597 : // ener_l *= norm_l;
4598 678500 : ener_l = Mpy_32_32( ener_l, norm_l );
4599 678500 : ener_l_e = add( ener_l_e, norm_l_e );
4600 : // ener_r *= norm_r;
4601 678500 : ener_r = Mpy_32_32( ener_r, norm_r );
4602 678500 : ener_r_e = add( ener_r_e, norm_r_e );
4603 :
4604 : // diff_l_h += fabsf(ener_l - ener_dmx);
4605 678500 : L_tmp = L_abs( BASOP_Util_Add_Mant32Exp( ener_l, ener_l_e, L_negate( ener_dmx ), ener_dmx_e, &L_tmp_e ) );
4606 678500 : diff_l_h = BASOP_Util_Add_Mant32Exp( diff_l_h, diff_l_h_e, L_tmp, L_tmp_e, &diff_l_h_e );
4607 : // diff_r_h += fabsf(ener_r - ener_dmx);
4608 678500 : L_tmp = L_abs( BASOP_Util_Add_Mant32Exp( ener_r, ener_r_e, L_negate( ener_dmx ), ener_dmx_e, &L_tmp_e ) );
4609 678500 : diff_r_h = BASOP_Util_Add_Mant32Exp( diff_r_h, diff_r_h_e, L_tmp, L_tmp_e, &diff_r_h_e );
4610 : }
4611 : }
4612 : }
4613 :
4614 162251 : FOR( b = 0; b < hStereoDft->nbands; b++ ) /* choose the subbands used for stereo filling */
4615 : {
4616 : // sub_nrg_DMX[b] /= (hStereoDft->band_limits[b + 1] - hStereoDft->band_limits[b]);
4617 149390 : sub_nrg_DMX[b] = BASOP_Util_Divide3232_Scale_newton( sub_nrg_DMX[b], sub( hStereoDft->band_limits[b + 1], hStereoDft->band_limits[b] ), &L_tmp_e );
4618 149390 : move32();
4619 149390 : sub_nrg_DMX_e[b] = add( L_tmp_e, sub( sub_nrg_DMX_e[b], 31 ) );
4620 149390 : move16();
4621 : // sub_nrg_DMX[b] = 0.6f * hStereoDft->pre_sub_nrg_DMX[b] + 0.4f * sub_nrg_DMX[b];
4622 149390 : sub_nrg_DMX[b] = BASOP_Util_Add_Mant32Exp( Mpy_32_32( 1288490189 /*0.6f*/, hStereoDft->pre_sub_nrg_DMX_fx[b] ), hStereoDft->pre_sub_nrg_DMX_fx_e[b], Mpy_32_32( 858993459 /*0.4f*/, sub_nrg_DMX[b] ), sub_nrg_DMX_e[b], &sub_nrg_DMX_e[b] );
4623 149390 : move32();
4624 149390 : hStereoDft->pre_sub_nrg_DMX_fx[b] = sub_nrg_DMX[b];
4625 149390 : move32();
4626 149390 : hStereoDft->pre_sub_nrg_DMX_fx_e[b] = sub_nrg_DMX_e[b];
4627 149390 : move16();
4628 : }
4629 :
4630 : /* adaptively select the subbands to predict based on the energy */
4631 : // nbands = (hStereoDft->nbands > 10) ? (hStereoDft->nbands - 2) : hStereoDft->nbands;
4632 12861 : IF( GT_16( hStereoDft->nbands, 10 ) )
4633 : {
4634 9911 : nbands = sub( hStereoDft->nbands, 2 );
4635 : }
4636 : ELSE
4637 : {
4638 2950 : nbands = hStereoDft->nbands;
4639 2950 : move16();
4640 : }
4641 :
4642 12861 : nrg_DMX_min_avrg = 0;
4643 12861 : move32();
4644 12861 : nrg_DMX_min_avrg_e = 0;
4645 12861 : move16();
4646 25722 : FOR( b = 2; b < STEREO_DFT_RES_PRED_BAND_MIN_RED; b++ )
4647 : {
4648 12861 : nrg_DMX_min = sub_nrg_DMX[b];
4649 12861 : move32();
4650 12861 : nrg_DMX_min_e = sub_nrg_DMX_e[b];
4651 12861 : move16();
4652 12861 : index_min = b;
4653 12861 : move16();
4654 :
4655 116707 : FOR( b1 = 2; b1 < nbands; b1++ )
4656 : {
4657 : // if (nrg_DMX_min > sub_nrg_DMX[b1])
4658 103846 : IF( BASOP_Util_Cmp_Mant32Exp( nrg_DMX_min, nrg_DMX_min_e, sub_nrg_DMX[b1], sub_nrg_DMX_e[b1] ) > 0 )
4659 : {
4660 72616 : nrg_DMX_min = sub_nrg_DMX[b1];
4661 72616 : move32();
4662 72616 : nrg_DMX_min_e = sub_nrg_DMX_e[b1];
4663 72616 : move16();
4664 72616 : index_min = b1;
4665 72616 : move16();
4666 : }
4667 : }
4668 :
4669 : // nrg_DMX_min_avrg += nrg_DMX_min;
4670 12861 : nrg_DMX_min_avrg = BASOP_Util_Add_Mant32Exp( nrg_DMX_min_avrg, nrg_DMX_min_avrg_e, nrg_DMX_min, nrg_DMX_min_e, &nrg_DMX_min_avrg_e );
4671 : // sub_nrg_DMX[index_min] = FLT_MAX;
4672 12861 : sub_nrg_DMX[index_min] = MAX_32;
4673 12861 : move32();
4674 12861 : sub_nrg_DMX_e[index_min] = 128;
4675 12861 : move16();
4676 : }
4677 :
4678 12861 : nrg_DMX_max_avrg = 0;
4679 12861 : move32();
4680 12861 : nrg_DMX_max_avrg_e = 0;
4681 12861 : move16();
4682 116707 : FOR( ( b = 2, b1 = STEREO_DFT_RES_PRED_BAND_MIN_RED ); b < nbands; b++ )
4683 : {
4684 : // if (sub_nrg_DMX[b] != FLT_MAX)
4685 103846 : IF( BASOP_Util_Cmp_Mant32Exp( sub_nrg_DMX[b], sub_nrg_DMX_e[b], MAX_32, 128 ) != 0 )
4686 : {
4687 : // nrg_DMX_max_avrg += sub_nrg_DMX[b];
4688 90985 : nrg_DMX_max_avrg = BASOP_Util_Add_Mant32Exp( nrg_DMX_max_avrg, nrg_DMX_max_avrg_e, sub_nrg_DMX[b], sub_nrg_DMX_e[b], &nrg_DMX_max_avrg_e );
4689 : }
4690 : }
4691 :
4692 12861 : IF( LE_16( hStereoDft->nbands, 10 ) ) /*WB*/
4693 : {
4694 2950 : test();
4695 2950 : IF( EQ_16( hStereoDft->res_pred_mode[0], STEREO_DFT_RESPRED_OFF ) || NE_16( hStereoDft->hConfig->res_cod_mode, STEREO_DFT_RES_COD_OFF ) )
4696 : {
4697 710 : hStereoDft->diff_l_h_sm_fx = diff_l_h;
4698 710 : move32();
4699 710 : hStereoDft->diff_l_h_sm_fx_e = diff_l_h_e;
4700 710 : move16();
4701 710 : hStereoDft->diff_r_h_sm_fx = diff_r_h;
4702 710 : move32();
4703 710 : hStereoDft->diff_r_h_sm_fx_e = diff_r_h_e;
4704 710 : move16();
4705 : }
4706 : ELSE
4707 : {
4708 : // hStereoDft->diff_l_h_sm = 0.9f * hStereoDft->diff_l_h_sm + 0.1f * diff_l_h;
4709 2240 : hStereoDft->diff_l_h_sm_fx = BASOP_Util_Add_Mant32Exp( Mpy_32_32( 1932735283 /*0.9f*/, hStereoDft->diff_l_h_sm_fx ), hStereoDft->diff_l_h_sm_fx_e, Mpy_32_32( 214748365 /*0.1f*/, diff_l_h ), diff_l_h_e, &hStereoDft->diff_l_h_sm_fx_e );
4710 2240 : move32();
4711 : // hStereoDft->diff_r_h_sm = 0.9f * hStereoDft->diff_r_h_sm + 0.1f * diff_r_h;
4712 2240 : hStereoDft->diff_r_h_sm_fx = BASOP_Util_Add_Mant32Exp( Mpy_32_32( 1932735283 /*0.9f*/, hStereoDft->diff_r_h_sm_fx ), hStereoDft->diff_r_h_sm_fx_e, Mpy_32_32( 214748365 /*0.1f*/, diff_r_h ), diff_r_h_e, &hStereoDft->diff_r_h_sm_fx_e );
4713 2240 : move32();
4714 : }
4715 :
4716 : // if (hStereoDft->diff_l_h_sm > 120.0f || hStereoDft->diff_r_h_sm > 120.0f)
4717 2950 : test();
4718 2950 : if ( BASOP_Util_Cmp_Mant32Exp( hStereoDft->diff_l_h_sm_fx, hStereoDft->diff_l_h_sm_fx_e, 120, 31 ) > 0 || BASOP_Util_Cmp_Mant32Exp( hStereoDft->diff_r_h_sm_fx, hStereoDft->diff_r_h_sm_fx_e, 120, 31 ) > 0 )
4719 : {
4720 2950 : hStereoDft->reverb_flag = 1;
4721 2950 : move16();
4722 : }
4723 : }
4724 : ELSE /*SWB/FB*/
4725 : {
4726 : // if (3 * nrg_DMX_max_avrg > 64 * 5 * nrg_DMX_min_avrg)
4727 9911 : if ( BASOP_Util_Cmp_Mant32Exp( Mpy_32_32( 1288490189 /*3/5 in Q31*/, nrg_DMX_max_avrg ), nrg_DMX_max_avrg_e, nrg_DMX_min_avrg, add( nrg_DMX_min_avrg_e, 6 /* * 64 */ ) ) > 0 )
4728 : {
4729 9070 : hStereoDft->reverb_flag = 1;
4730 9070 : move16();
4731 : }
4732 : }
4733 :
4734 : /*Stereo Filling gain damping*/
4735 : // fac = ((diff_l_l > diff_r_l) ? diff_r_l / diff_l_l : diff_l_l / diff_r_l);
4736 12861 : IF( BASOP_Util_Cmp_Mant32Exp( diff_l_l, diff_l_l_e, diff_r_l, diff_r_l_e ) > 0 )
4737 : {
4738 1815 : fac = BASOP_Util_Divide3232_Scale_newton( diff_r_l, diff_l_l, &L_tmp_e );
4739 1815 : L_tmp_e = add( L_tmp_e, sub( diff_r_l_e, diff_l_l_e ) );
4740 : }
4741 : ELSE
4742 : {
4743 11046 : fac = BASOP_Util_Divide3232_Scale_newton( diff_l_l, diff_r_l, &L_tmp_e );
4744 11046 : L_tmp_e = add( L_tmp_e, sub( diff_l_l_e, diff_r_l_e ) );
4745 : }
4746 12861 : fac = L_shl_sat( fac, L_tmp_e ); // Q31
4747 : // fac = fac > 0.25f ? 1.0f : 4.f * fac;
4748 12861 : fac = L_shl_sat( fac, 2 );
4749 : // fac = 0.98f * hStereoDft->prev_fac2 + 0.02f * fac;
4750 12861 : fac = L_add( Mpy_32_32( 2104533975 /*0.98f*/, hStereoDft->prev_fac2_fx ), Mpy_32_32( 42949673 /*0.02f*/, fac ) );
4751 12861 : hStereoDft->prev_fac2_fx = fac;
4752 12861 : move32();
4753 :
4754 162251 : FOR( b = 0; b < hStereoDft->nbands; b++ )
4755 : {
4756 149390 : IF( LT_16( b, 5 ) )
4757 : {
4758 : // pPredGain[b] *= max(0.5f, fac);
4759 64305 : pPredGain[b] = Mpy_32_32( pPredGain[b], L_max( ONE_IN_Q30, fac ) );
4760 64305 : move32();
4761 : }
4762 : ELSE
4763 : {
4764 : // pPredGain[b] *= min(1.0f, max(0.75f, 0.5f + fac));
4765 85085 : pPredGain[b] = Mpy_32_32( pPredGain[b], L_max( 1610612736 /*0.75f*/, L_add_sat( ONE_IN_Q30, fac ) ) );
4766 85085 : move32();
4767 : }
4768 : }
4769 : }
4770 :
4771 :
4772 33070 : return;
4773 : }
4774 : /*---------------------------------------------------------------
4775 : * stereo_dft_gain_offset()
4776 : *
4777 : * c = gain between L and R, itd = itd in samples @ 32kHz
4778 : * ---------------------------------------------------------------*/
4779 182855 : static Word32 stereo_dft_gain_offset_fx(
4780 : const Word32 c, // Q(31-c_e)
4781 : const Word16 c_e,
4782 : const Word16 itd )
4783 : {
4784 : Word32 wnt, go, alpha;
4785 : Word16 alpha_e;
4786 : Word16 tau, k0;
4787 : Word32 L_tmp, L_tmp1, L_tmp2;
4788 : Word16 L_tmp_e, L_tmp1_e, L_tmp2_e;
4789 :
4790 182855 : tau = s_min( abs_s( itd ), 160 ); // Q0
4791 : /* Wn_table contains every 8th sample of the window's cross-correlation
4792 : * function @ 32kHz from which the values are interpolated: */
4793 182855 : k0 = shr( tau, 3 );
4794 : // alpha = s_and(tau, 7) / 8.f;
4795 182855 : alpha = BASOP_Util_Divide3232_Scale_newton( s_and( tau, 7 ), 8, &alpha_e );
4796 182855 : alpha = L_shl( alpha, alpha_e ); // Q31
4797 : // wnt = (1 - alpha) * Wn_table[k0] + alpha * Wn_table[k0 + 1];
4798 182855 : wnt = L_add( Mpy_32_32( L_sub( MAX_32, alpha ), Wn_table_fx[k0] ), Mpy_32_32( alpha, Wn_table_fx[k0 + 1] ) ); // Q31
4799 :
4800 : // go = sqrtf(8 * c * c / ((1 + c) * (1 + c)) * (1 - wnt) / (1 + c * c + 2 * c * wnt));
4801 182855 : L_tmp = Mpy_32_32( c, c );
4802 182855 : L_tmp_e = shl( c_e, 1 );
4803 182855 : L_tmp1 = BASOP_Util_Add_Mant32Exp( MAX_32, 0, c, c_e, &L_tmp1_e );
4804 182855 : L_tmp1 = Mpy_32_32( L_tmp1, L_tmp1 );
4805 182855 : L_tmp1_e = shl( L_tmp1_e, 1 );
4806 182855 : L_tmp2 = BASOP_Util_Divide3232_Scale_newton( L_tmp, L_tmp1, &L_tmp2_e );
4807 182855 : L_tmp2_e = add( add( L_tmp2_e, sub( L_tmp_e, L_tmp1_e ) ), 3 /*multiply by 8*/ );
4808 182855 : L_tmp2 = Mpy_32_32( L_tmp2, L_sub( MAX_32, wnt ) );
4809 182855 : L_tmp1 = BASOP_Util_Add_Mant32Exp( MAX_32, 0, L_tmp, L_tmp_e, &L_tmp1_e );
4810 182855 : L_tmp1 = BASOP_Util_Add_Mant32Exp( L_tmp1, L_tmp1_e, Mpy_32_32( c, wnt ), add( c_e, 1 ), &L_tmp1_e );
4811 182855 : L_tmp = BASOP_Util_Divide3232_Scale_newton( L_tmp2, L_tmp1, &L_tmp_e );
4812 182855 : L_tmp_e = add( L_tmp_e, sub( L_tmp2_e, L_tmp1_e ) );
4813 182855 : L_tmp = Sqrt32( L_tmp, &L_tmp_e );
4814 182855 : go = L_shl( L_tmp, L_tmp_e );
4815 :
4816 182855 : return go;
4817 : }
4818 :
4819 : /*---------------------------------------------------------------
4820 : * stereo_dft_enc_calculate_nrg_for_icbwe()
4821 : *
4822 : * calculate energy of downmix and left and right channel in the
4823 : * SHB region for later use in ICBWE
4824 : * ---------------------------------------------------------------*/
4825 48157 : static void stereo_dft_enc_calculate_nrg_for_icbwe_fx(
4826 : STEREO_DFT_ENC_DATA_HANDLE hStereoDft, /* i/o: encoder DFT stereo handle */
4827 : const Word16 *DFT_L_e,
4828 : const Word16 *DFT_R_e,
4829 : const Word32 *DMX, /* i : DFT Stereo downmix Q(31-DMX_e[]) */
4830 : const Word16 *DMX_e, /* i : DFT Stereo downmix */
4831 : const Word32 input_Fs /* i : input sampling rate */
4832 : )
4833 : {
4834 : Word32 *pDFT_L, *pDFT_R, bandResDft;
4835 : Word16 bandResDft_e;
4836 : Word16 i, shbBins[3];
4837 : Word16 tmp_e;
4838 : Word32 tmp;
4839 :
4840 : // bandResDft = ( (float) input_Fs ) / hStereoDft->NFFT;
4841 48157 : bandResDft = BASOP_Util_Divide3232_Scale_newton( input_Fs, hStereoDft->NFFT, &bandResDft_e );
4842 : // shbBins[0] = (int16_t) ( 6400 / bandResDft );
4843 48157 : shbBins[0] = BASOP_Util_Divide3232_Scale( 6400, bandResDft, &tmp_e );
4844 48157 : move16();
4845 48157 : tmp_e = add( tmp_e, sub( 31, bandResDft_e ) );
4846 48157 : shbBins[0] = shr( shbBins[0], sub( 15, tmp_e ) ); // Q0
4847 48157 : move16();
4848 :
4849 : // shbBins[1] = (int16_t) ( 10400 / bandResDft );
4850 48157 : shbBins[1] = BASOP_Util_Divide3232_Scale( 10400, bandResDft, &tmp_e );
4851 48157 : move16();
4852 48157 : tmp_e = add( tmp_e, sub( 31, bandResDft_e ) );
4853 48157 : shbBins[1] = shr( shbBins[1], sub( 15, tmp_e ) ); // Q0
4854 48157 : move16();
4855 :
4856 : // shbBins[2] = (int16_t) ( 14400 / bandResDft );
4857 48157 : shbBins[2] = BASOP_Util_Divide3232_Scale( 14400, bandResDft, &tmp_e );
4858 48157 : move16();
4859 48157 : tmp_e = add( tmp_e, sub( 31, bandResDft_e ) );
4860 48157 : shbBins[2] = shr( shbBins[2], sub( 15, tmp_e ) ); // Q0
4861 48157 : move16();
4862 :
4863 48157 : assert( shbBins[1] <= hStereoDft->NFFT / 2 );
4864 :
4865 48157 : set32_fx( hStereoDft->nrg_L_fx, EPSILON_FX_M, 2 );
4866 48157 : set16_fx( hStereoDft->nrg_L_fx_e, EPSILON_FX_E, 2 );
4867 48157 : set32_fx( hStereoDft->nrg_R_fx, EPSILON_FX_M, 2 );
4868 48157 : set16_fx( hStereoDft->nrg_R_fx_e, EPSILON_FX_E, 2 );
4869 48157 : set32_fx( hStereoDft->nrg_DMX_fx, EPSILON_FX_M, 2 );
4870 48157 : set16_fx( hStereoDft->nrg_DMX_fx_e, EPSILON_FX_E, 2 );
4871 :
4872 48157 : pDFT_L = hStereoDft->DFT_fx[0]; // Q(31-DFT_L_e[])
4873 48157 : pDFT_R = hStereoDft->DFT_fx[1]; // Q(31-DFT_R_e[])
4874 :
4875 7753277 : FOR( i = shbBins[0]; i < shbBins[1]; i++ )
4876 : {
4877 : // hStereoDft->nrg_L[0] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
4878 7705120 : tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L[2 * i], pDFT_L[2 * i] ), shl( DFT_L_e[2 * i], 1 ), Mpy_32_32( pDFT_L[2 * i + 1], pDFT_L[2 * i + 1] ), shl( DFT_L_e[2 * i + 1], 1 ), &tmp_e );
4879 7705120 : hStereoDft->nrg_L_fx[0] = BASOP_Util_Add_Mant32Exp( hStereoDft->nrg_L_fx[0], hStereoDft->nrg_L_fx_e[0], tmp, tmp_e, &hStereoDft->nrg_L_fx_e[0] );
4880 7705120 : move32();
4881 : // hStereoDft->nrg_R[0] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
4882 7705120 : tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_R[2 * i], pDFT_R[2 * i] ), shl( DFT_R_e[2 * i], 1 ), Mpy_32_32( pDFT_R[2 * i + 1], pDFT_R[2 * i + 1] ), shl( DFT_R_e[2 * i + 1], 1 ), &tmp_e );
4883 7705120 : hStereoDft->nrg_R_fx[0] = BASOP_Util_Add_Mant32Exp( hStereoDft->nrg_R_fx[0], hStereoDft->nrg_R_fx_e[0], tmp, tmp_e, &hStereoDft->nrg_R_fx_e[0] );
4884 7705120 : move32();
4885 : // hStereoDft->nrg_DMX[0] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
4886 7705120 : tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( DMX[2 * i], DMX[2 * i] ), shl( DMX_e[2 * i], 1 ), Mpy_32_32( DMX[2 * i + 1], DMX[2 * i + 1] ), shl( DMX_e[2 * i + 1], 1 ), &tmp_e );
4887 7705120 : hStereoDft->nrg_DMX_fx[0] = BASOP_Util_Add_Mant32Exp( hStereoDft->nrg_DMX_fx[0], hStereoDft->nrg_DMX_fx_e[0], tmp, tmp_e, &hStereoDft->nrg_DMX_fx_e[0] );
4888 7705120 : move32();
4889 : }
4890 7753277 : FOR( ; i < shbBins[2]; i++ )
4891 : {
4892 : // hStereoDft->nrg_L[1] += pDFT_L[2 * i] * pDFT_L[2 * i] + pDFT_L[2 * i + 1] * pDFT_L[2 * i + 1];
4893 7705120 : tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_L[2 * i], pDFT_L[2 * i] ), shl( DFT_L_e[2 * i], 1 ), Mpy_32_32( pDFT_L[2 * i + 1], pDFT_L[2 * i + 1] ), shl( DFT_L_e[2 * i + 1], 1 ), &tmp_e );
4894 7705120 : hStereoDft->nrg_L_fx[1] = BASOP_Util_Add_Mant32Exp( hStereoDft->nrg_L_fx[1], hStereoDft->nrg_L_fx_e[1], tmp, tmp_e, &hStereoDft->nrg_L_fx_e[1] );
4895 7705120 : move32();
4896 : // hStereoDft->nrg_R[1] += pDFT_R[2 * i] * pDFT_R[2 * i] + pDFT_R[2 * i + 1] * pDFT_R[2 * i + 1];
4897 7705120 : tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( pDFT_R[2 * i], pDFT_R[2 * i] ), shl( DFT_R_e[2 * i], 1 ), Mpy_32_32( pDFT_R[2 * i + 1], pDFT_R[2 * i + 1] ), shl( DFT_R_e[2 * i + 1], 1 ), &tmp_e );
4898 7705120 : hStereoDft->nrg_R_fx[1] = BASOP_Util_Add_Mant32Exp( hStereoDft->nrg_R_fx[1], hStereoDft->nrg_R_fx_e[1], tmp, tmp_e, &hStereoDft->nrg_R_fx_e[1] );
4899 7705120 : move32();
4900 : // hStereoDft->nrg_DMX[1] += DMX[2 * i] * DMX[2 * i] + DMX[2 * i + 1] * DMX[2 * i + 1];
4901 7705120 : tmp = BASOP_Util_Add_Mant32Exp( Mpy_32_32( DMX[2 * i], DMX[2 * i] ), shl( DMX_e[2 * i], 1 ), Mpy_32_32( DMX[2 * i + 1], DMX[2 * i + 1] ), shl( DMX_e[2 * i + 1], 1 ), &tmp_e );
4902 7705120 : hStereoDft->nrg_DMX_fx[1] = BASOP_Util_Add_Mant32Exp( hStereoDft->nrg_DMX_fx[1], hStereoDft->nrg_DMX_fx_e[1], tmp, tmp_e, &hStereoDft->nrg_DMX_fx_e[1] );
4903 7705120 : move32();
4904 : }
4905 :
4906 48157 : return;
4907 : }
|
