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