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