Line data Source code
1 : /*====================================================================================
2 : EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
3 : ====================================================================================*/
4 :
5 : #include <stdint.h>
6 : #include "options.h"
7 : #include "cnst.h" /* Common constants */
8 : #include "rom_com.h" /* Static table prototypes */
9 : #include "prot_fx.h"
10 : #include "basop_util.h"
11 : #include "ivas_prot_fx.h"
12 :
13 :
14 : /*-----------------------------------------------------------------*
15 : * Local constants
16 : *-----------------------------------------------------------------*/
17 :
18 : #define POW_EXC16k_WHTND 1.14e11f /* power of random excitation, length 320 samples, uniform distribution */
19 : #define POW_EXC16k_WHTND_FX_INV_SQRT 6360 // Q31
20 : #define POW_EXC16k_WHTND_FX_INV_SQRT_IN_Q49 1667313793 // Q49
21 : #define POW_EXC16k_WHTND_FX 178125000 // Q-6
22 : #define THR_ENV_ERROR_PLOSIVE 200.0f /* threshold for envelope error used in plosive detection */
23 : #define THR_ENV_ERROR_PLOSIVE_FX 200 /* threshold for envelope error used in plosive detection Q0 */
24 :
25 : /*-----------------------------------------------------------------*
26 : * Local function prototypes
27 : *-----------------------------------------------------------------*/
28 :
29 : static void create_random_vector_fx( Word16 output[], const Word16 length, Word16 seed[] );
30 : static void flip_spectrum_fx( const Word16 input[], Word16 output[], const Word16 length );
31 : static void Calc_st_filt_tbe( Word16 *apond2, Word16 *apond1, Word16 *parcor0, Word16 *sig_ltp_ptr, Word16 *mem_zero );
32 : static void Hilbert_transform_fx( Word32 tmp_R[], Word32 tmp_I[], Word32 *tmpi_R, Word32 *tmpi_I, const Word16 length, const Word16 HB_stage_id );
33 : static void Hilbert_transform_sp_fx( Word16 tmp_R[], Word16 tmp_I[], Word32 *tmpi_R, Word32 *tmpi_I, const Word16 length, const Word16 HB_stage_id );
34 : void Estimate_mix_factors_fx( const Word16 *shb_res, const Word16 Q_shb, const Word16 *exc16kWhtnd, const Word16 Q_bwe_exc, const Word16 *White_exc16k_frac, const Word16 Q_frac, const Word32 pow1, const Word16 Q_pow1, const Word32 pow22, const Word16 Q_pow22, Word16 *vf_modified, Word16 *vf_ind );
35 :
36 : /*-------------------------------------------------------------------*
37 : * swb_tbe_reset()
38 : *
39 : * Reset the SWB TBE encoder
40 : *-------------------------------------------------------------------*/
41 :
42 472457 : void swb_tbe_reset_fx(
43 : Word32 mem_csfilt[],
44 : Word16 mem_genSHBexc_filt_down_shb[],
45 : Word16 state_lpc_syn[],
46 : Word16 syn_overlap[],
47 : Word16 state_syn_shbexc[],
48 : Word16 *tbe_demph,
49 : Word16 *tbe_premph,
50 : Word16 mem_stp_swb[],
51 : Word16 *gain_prec_swb )
52 : {
53 472457 : set32_fx( mem_csfilt, 0, 2 );
54 472457 : set16_fx( mem_genSHBexc_filt_down_shb, 0, ( 2 * ALLPASSSECTIONS_STEEP + 1 ) );
55 472457 : set16_fx( state_lpc_syn, 0, LPC_SHB_ORDER );
56 :
57 472457 : set16_fx( syn_overlap, 0, L_SHB_LAHEAD );
58 472457 : set16_fx( state_syn_shbexc, 0, L_SHB_LAHEAD );
59 :
60 472457 : *tbe_demph = 0;
61 472457 : move16();
62 472457 : *tbe_premph = 0;
63 472457 : move16();
64 :
65 472457 : set16_fx( mem_stp_swb, 0, LPC_SHB_ORDER );
66 472457 : *gain_prec_swb = 16384;
67 472457 : move16(); /*Q14 = 1 */
68 :
69 472457 : return;
70 : }
71 :
72 :
73 : /*-------------------------------------------------------------------*
74 : * swb_tbe_reset_synth()
75 : *
76 : * Reset the extra parameters needed for synthesis of the SWB TBE output
77 : *-------------------------------------------------------------------*/
78 :
79 237898 : void swb_tbe_reset_synth_fx(
80 : Word32 genSHBsynth_Hilbert_Mem[],
81 : Word16 genSHBsynth_state_lsyn_filt_shb_local_fx[],
82 : Word32 genSHBsynth_state_lsyn_filt_shb_local_fx_32[] )
83 : {
84 :
85 237898 : set32_fx( genSHBsynth_Hilbert_Mem, 0, HILBERT_MEM_SIZE );
86 237898 : set16_fx( genSHBsynth_state_lsyn_filt_shb_local_fx, 0, 2 * ALLPASSSECTIONS_STEEP );
87 :
88 237898 : if ( genSHBsynth_state_lsyn_filt_shb_local_fx_32 != NULL )
89 : {
90 237898 : set32_fx( genSHBsynth_state_lsyn_filt_shb_local_fx_32, 0, 2 * ALLPASSSECTIONS_STEEP );
91 : }
92 :
93 237898 : return;
94 : }
95 :
96 :
97 : /*-------------------------------------------------------------------*
98 : * fb_tbe_reset_synth_fx()
99 : *
100 : * reset of FB TBE memories
101 : *-------------------------------------------------------------------*/
102 :
103 158745 : void fb_tbe_reset_synth_fx(
104 : Word32 fbbwe_hpf_mem_fx[][4],
105 : Word16 fbbwe_hpf_mem_fx_Q[],
106 : Word16 *prev_fbbwe_ratio_fx )
107 : {
108 158745 : set32_fx( fbbwe_hpf_mem_fx[0], 0, 4 );
109 158745 : set32_fx( fbbwe_hpf_mem_fx[1], 0, 4 );
110 158745 : set32_fx( fbbwe_hpf_mem_fx[2], 0, 4 );
111 158745 : set32_fx( fbbwe_hpf_mem_fx[3], 0, 4 );
112 158745 : set16_fx( fbbwe_hpf_mem_fx_Q, 0, 4 );
113 158745 : *prev_fbbwe_ratio_fx = 1;
114 158745 : move16(); /*should be set to 1.0f, scaling unknown */
115 :
116 158745 : return;
117 : }
118 :
119 :
120 : /*-------------------------------------------------------------------*
121 : * tbe_celp_exc_offset()
122 : *
123 : * Compute tbe bwe celp excitation offset
124 : *-------------------------------------------------------------------*/
125 :
126 1079711 : Word16 tbe_celp_exc_offset(
127 : const Word16 T0_fx, /* i : Integer pitch Q0 */
128 : const Word16 T0_frac_fx, /* i : Fractional part of the pitch Q1 */
129 : const Word16 L_frame /* i : frame lenght */
130 : )
131 : {
132 : Word16 offset_fx, tmp_fx, tmp1_fx, tmp2_fx, tmp_fac;
133 1079711 : tmp_fac = 320;
134 1079711 : move16(); /*2.5 in Q7*/
135 1079711 : if ( EQ_16( L_frame, L_FRAME16k ) )
136 : {
137 641203 : tmp_fac = 256;
138 641203 : move16(); /*2.0 in Q7*/
139 : }
140 1079711 : tmp_fx = extract_l( L_mult( T0_frac_fx, 32 ) ); /*Q8, 0.25 in Q7*/
141 1079711 : tmp_fx = add( 512, tmp_fx ); /*Q8; 2 in Q8*/
142 1079711 : tmp_fx = mult_r( tmp_fx, tmp_fac ); /*Q16->Q0; 2.5 in Q7 or 2.0 in Q7 */
143 :
144 1079711 : tmp1_fx = sub( T0_fx, 2 ); /*Q0*/
145 :
146 1079711 : tmp2_fx = shl( tmp1_fx, 1 ); /*Q0 */
147 :
148 1079711 : IF( EQ_16( L_frame, L_FRAME ) )
149 : {
150 438508 : tmp2_fx = add( shl( tmp1_fx, 1 ), shr( tmp1_fx, 1 ) ); /*Q0; (5/2 = 2 + 1/2)*/
151 : }
152 :
153 1079711 : offset_fx = add( tmp_fx, tmp2_fx ); /*Q0*/
154 :
155 1079711 : return offset_fx;
156 : }
157 :
158 : /*-------------------------------------------------------------------*
159 : * swb_tbe_celp_exc()
160 : *
161 : * Compute tbe bwe celp excitation
162 : *-------------------------------------------------------------------*/
163 11908 : void tbe_celp_exc(
164 : const Word16 L_frame_fx, /* i : Frame lenght */
165 : const Word16 i_subfr_fx, /* i : sub frame */
166 : const Word16 T0_fx, /* i : Integer pitch Q0 */
167 : const Word16 T0_frac_fx, /* i : Fractional part of the pitch Q1 */
168 : Word16 *error_fx, /* i/o: Error Q5 */
169 : Word16 *bwe_exc_fx /* i/o: bandwitdh extension signal */
170 : )
171 : {
172 : Word16 offset_fx, tmp_fx, i;
173 11908 : IF( EQ_16( L_frame_fx, L_FRAME ) )
174 : {
175 : /*offset = T0 * HIBND_ACB_L_FAC + (int) ((float) T0_frac * 0.25f * HIBND_ACB_L_FAC + 2 * HIBND_ACB_L_FAC + 0.5f) - 2 * HIBND_ACB_L_FAC;
176 : for (i=0; i<L_SUBFR * HIBND_ACB_L_FAC; i++)
177 : {
178 : bwe_exc[i + i_subfr * HIBND_ACB_L_FAC] = bwe_exc[i + i_subfr * HIBND_ACB_L_FAC - offset + (int) error];
179 : }
180 : error += (float) offset - (float) T0 * HIBND_ACB_L_FAC - 0.25f * HIBND_ACB_L_FAC * (float) T0_frac;*/
181 :
182 2668 : offset_fx = tbe_celp_exc_offset( T0_fx, T0_frac_fx, L_frame_fx );
183 2668 : IF( *error_fx > 0 )
184 : {
185 397 : tmp_fx = shr( *error_fx, 5 ); /*Q0*/
186 : }
187 : ELSE
188 : {
189 2271 : tmp_fx = negate( shr( abs_s( *error_fx ), 5 ) ); /*Q0*/
190 : }
191 :
192 429548 : FOR( i = 0; i < L_SUBFR * HIBND_ACB_L_FAC; i++ )
193 : {
194 426880 : bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC] = bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC - offset_fx + tmp_fx]; // Qx
195 426880 : move16();
196 : }
197 2668 : tmp_fx = extract_l( L_mult( T0_frac_fx, 1 ) ); /*Q3; 0.25 in Q2*/
198 2668 : tmp_fx = add( shl( T0_fx, 3 ), tmp_fx ); /*Q3*/
199 2668 : tmp_fx = extract_l( L_mult( tmp_fx, 5 ) ); /*Q5, 2.5 in Q1*/
200 2668 : tmp_fx = sub( shl( offset_fx, 5 ), tmp_fx ); /*Q5*/
201 2668 : *error_fx = add( *error_fx, tmp_fx ); /*Q5*/
202 2668 : move16();
203 : }
204 : ELSE
205 : {
206 : /* offset = T0*2.5 + (int) ((float) T0_frac * 0.25f*2.5 + 2*2.5 + 0.5f) - 2*2.5; - case above*/
207 : /* offset = T0*2 + (int) ((float) T0_frac * 0.25f*2 + 2*2 + 0.5f) - 2*2; - case here*/
208 :
209 : /*(int) ((float) T0_frac * 0.25f*2 + 2*2 + 0.5f)*/
210 9240 : offset_fx = tbe_celp_exc_offset( T0_fx, T0_frac_fx, L_frame_fx );
211 9240 : IF( *error_fx > 0 )
212 : {
213 4227 : tmp_fx = shr( *error_fx, 5 ); /*Q0*/
214 : }
215 : ELSE
216 : {
217 5013 : tmp_fx = negate( shr( abs_s( *error_fx ), 5 ) ); /*Q0*/
218 : }
219 :
220 1191960 : FOR( i = 0; i < L_SUBFR * 2; i++ )
221 : {
222 1182720 : bwe_exc_fx[i + i_subfr_fx * 2] = bwe_exc_fx[i + i_subfr_fx * 2 - offset_fx + tmp_fx]; // Qx
223 1182720 : move16();
224 : }
225 :
226 : /* error += (float) offset - (float) T0 * 2 - 0.5f * (float) T0_frac;*/
227 9240 : tmp_fx = extract_l( L_mult( T0_frac_fx, 2 ) ); /*Q3; 0.5 in Q2*/
228 9240 : tmp_fx = add( shl( T0_fx, 4 ), tmp_fx ); /* now tmp_fx = "T0_fx*2+ 0.5f*T0_frac_fx" in Q3*/
229 9240 : tmp_fx = shl( tmp_fx, 2 ); /*now above tmp_fx in Q5*/
230 9240 : tmp_fx = sub( shl( offset_fx, 5 ), tmp_fx ); /*move offset_fx to Q5, tmp_fx in Q5, ans tmp_fx in Q5*/
231 9240 : *error_fx = add( *error_fx, tmp_fx ); /*error_fx in Q5*/
232 9240 : move16();
233 : }
234 11908 : }
235 :
236 : /*-------------------------------------------------------------------*
237 : * swb_tbe_celp_exc_ivas()
238 : *
239 : * Compute tbe bwe celp excitation
240 : *-------------------------------------------------------------------*/
241 1025687 : void tbe_celp_exc_ivas(
242 : const Word16 element_mode, /* i : element mode */
243 : const Word16 idchan, /* i : channel ID */
244 : const Word16 L_frame_fx, /* i : Frame lenght */
245 : const Word16 L_subfr, /* i : subframe length */
246 : const Word16 i_subfr_fx, /* i : sub frame */
247 : const Word16 T0_fx, /* i : Integer pitch Q0 */
248 : const Word16 T0_frac_fx, /* i : Fractional part of the pitch Q1 */
249 : Word16 *error_fx, /* i/o: Error Q5 */
250 : Word16 *bwe_exc_fx, /* i/o: bandwitdh extension signal Qx */
251 : const Word16 tdm_LRTD_flag /* i : LRTD stereo mode flag */
252 : )
253 : {
254 : Word16 offset_fx, tmp_fx, i;
255 :
256 1025687 : test();
257 1025687 : test();
258 1025687 : IF( EQ_16( element_mode, IVAS_CPE_TD ) && EQ_16( idchan, 1 ) && !tdm_LRTD_flag )
259 : {
260 818 : return;
261 : }
262 :
263 1024869 : IF( EQ_16( L_frame_fx, L_FRAME ) )
264 : {
265 : /*offset = T0 * HIBND_ACB_L_FAC + (int) ((float) T0_frac * 0.25f * HIBND_ACB_L_FAC + 2 * HIBND_ACB_L_FAC + 0.5f) - 2 * HIBND_ACB_L_FAC;
266 : for (i=0; i<L_SUBFR * HIBND_ACB_L_FAC; i++)
267 : {
268 : bwe_exc[i + i_subfr * HIBND_ACB_L_FAC] = bwe_exc[i + i_subfr * HIBND_ACB_L_FAC - offset + (int) error];
269 : }
270 : error += (float) offset - (float) T0 * HIBND_ACB_L_FAC - 0.25f * HIBND_ACB_L_FAC * (float) T0_frac;*/
271 :
272 407464 : offset_fx = tbe_celp_exc_offset( T0_fx, T0_frac_fx, L_frame_fx );
273 407464 : IF( *error_fx > 0 )
274 : {
275 56103 : tmp_fx = shr( *error_fx, 5 ); /*Q0*/
276 : }
277 : ELSE
278 : {
279 351361 : tmp_fx = negate( shr( abs_s( *error_fx ), 5 ) ); /*Q0*/
280 : }
281 :
282 65601704 : FOR( i = 0; i < L_subfr * HIBND_ACB_L_FAC; i++ )
283 : {
284 65194240 : bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC] = bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC - offset_fx + tmp_fx];
285 65194240 : move16();
286 : }
287 407464 : tmp_fx = extract_l( L_mult( T0_frac_fx, 1 ) ); /*Q3; 0.25 in Q2*/
288 407464 : tmp_fx = add( shl( T0_fx, 3 ), tmp_fx ); /*Q3*/
289 407464 : tmp_fx = extract_l( L_mult( tmp_fx, 5 ) ); /*Q5, 2.5 in Q1*/
290 407464 : tmp_fx = sub( shl( offset_fx, 5 ), tmp_fx ); /*Q5*/
291 407464 : *error_fx = add( *error_fx, tmp_fx ); /*Q5*/
292 407464 : move16();
293 : }
294 : ELSE
295 : {
296 : /* offset = T0*2.5 + (int) ((float) T0_frac * 0.25f*2.5 + 2*2.5 + 0.5f) - 2*2.5; - case above*/
297 : /* offset = T0*2 + (int) ((float) T0_frac * 0.25f*2 + 2*2 + 0.5f) - 2*2; - case here*/
298 :
299 : /*(int) ((float) T0_frac * 0.25f*2 + 2*2 + 0.5f)*/
300 617405 : offset_fx = tbe_celp_exc_offset( T0_fx, T0_frac_fx, L_frame_fx );
301 617405 : IF( *error_fx > 0 )
302 : {
303 372695 : tmp_fx = shr( *error_fx, 5 ); /*Q0*/
304 : }
305 : ELSE
306 : {
307 244710 : tmp_fx = negate( shr( abs_s( *error_fx ), 5 ) ); /*Q0*/
308 : }
309 :
310 79645245 : FOR( i = 0; i < L_subfr * 2; i++ )
311 : {
312 79027840 : bwe_exc_fx[i + i_subfr_fx * 2] = bwe_exc_fx[i + i_subfr_fx * 2 - offset_fx + tmp_fx];
313 79027840 : move16();
314 : }
315 :
316 : /* error += (float) offset - (float) T0 * 2 - 0.5f * (float) T0_frac;*/
317 617405 : tmp_fx = extract_l( L_mult( T0_frac_fx, 2 ) ); /*Q3; 0.5 in Q2*/
318 617405 : tmp_fx = add( shl( T0_fx, 4 ), tmp_fx ); /* now tmp_fx = "T0_fx*2+ 0.5f*T0_frac_fx" in Q3*/
319 617405 : tmp_fx = shl( tmp_fx, 2 ); /*now above tmp_fx in Q5*/
320 617405 : tmp_fx = sub( shl( offset_fx, 5 ), tmp_fx ); /*move offset_fx to Q5, tmp_fx in Q5, ans tmp_fx in Q5*/
321 617405 : *error_fx = add( *error_fx, tmp_fx ); /*error_fx in Q5*/
322 617405 : move16();
323 : }
324 : }
325 :
326 : /*===========================================================================*/
327 : /* FUNCTION : flip_and_downmix_generic_fx() */
328 : /*---------------------------------------------------------------------------*/
329 : /* PURPOSE :flips the spectrum and downmixes the signals, lpf if needed*/
330 : /*---------------------------------------------------------------------------*/
331 : /* INPUT ARGUMENTS */
332 : /* _(Word16[]) input :input spectrum */
333 : /* _(Word16) length :length of spectra */
334 : /* _(Word16) ramp_flag :flag to indicate slow ramp need after switching */
335 : /* _(Word16[]) lpf_num :lpf numerator */
336 : /* _(Word16[]) lpf_den :lpf denominator */
337 : /*---------------------------------------------------------------------------*/
338 : /* OUTPUT ARGUMENTS : */
339 : /* _(Word16[])output : output spectrum */
340 : /*---------------------------------------------------------------------------*/
341 : /* INPUT/OUTPUT ARGUMENTS : */
342 : /* _(Word32[9])mem1 : memory */
343 : /* _(Word32[8])mem2 : memory */
344 : /* _(Word32[8])mem3 : memory */
345 : /* _(Word16) dm_frequency_inHz :Downmix frequency in Hz */
346 : /* _(Word16*) phase_state :Phase state in case frequency isn't */
347 : /* multiple of 50 Hz */
348 : /*---------------------------------------------------------------------------*/
349 : /* RETURN ARGUMENTS : */
350 : /* _ None */
351 : /*---------------------------------------------------------------------------*/
352 1635 : void flip_and_downmix_generic_fx(
353 : Word16 input[], /* i : input spectrum Qx*/
354 : Word16 output[], /* o : output spectrum Qx*/
355 : const Word16 length, /* i : length of spectra */
356 : Word32 mem1_ext[HILBERT_ORDER1], /* i/o: memory Qx+16*/
357 : Word32 mem2_ext[2 * HILBERT_ORDER2], /* i/o: memory Qx+16*/
358 : Word32 mem3_ext[2 * HILBERT_ORDER2], /* i/o: memory Qx+16*/
359 : Word16 *phase_state /* i/o: Phase state in case frequency isn't multiple of 50 Hz */
360 : )
361 : {
362 : Word16 i, j;
363 : Word16 tmp_16[L_FRAME32k + HILBERT_ORDER1];
364 : Word32 tmpi_R[L_FRAME32k];
365 : Word32 tmpi_I[L_FRAME32k];
366 : Word32 tmpi2_R[L_FRAME32k + HILBERT_ORDER2];
367 : Word32 tmpi2_I[L_FRAME32k + HILBERT_ORDER2];
368 : Word32 tmp_R[L_FRAME32k + HILBERT_ORDER2];
369 : Word32 tmp_I[L_FRAME32k + HILBERT_ORDER2];
370 :
371 : /*Word16 s_tmp[L_FRAME32k];*/
372 : /*Word16 factor;*/
373 : Word16 period;
374 1635 : Word16 local_negsin_table17[17] = { 0, -11793, -22005, -29268, -32609, -31580,
375 : -26319, -17530, -6393, 6393, 17530, 26319,
376 : 31580, 32609, 29268, 22005, 11793 }; /* Q15 */
377 1635 : Word16 local_cos_table17[17] = { 32767, 30571, 24279, 14732, 3212, -8739,
378 : -19519, -27683, -32137, -32137, -27683,
379 : -19519, -8739, 3212, 14732, 24279, 30571 }; /* Q15 */
380 : Word16 *local_negsin_table, *local_cos_table;
381 : Word32 L_tmp;
382 :
383 : /* 1850 Hz downmix */
384 1635 : period = 17;
385 1635 : move16();
386 1635 : local_negsin_table = local_negsin_table17;
387 1635 : local_cos_table = local_cos_table17;
388 :
389 :
390 524835 : FOR( i = 0; i < length; i = i + 2 )
391 : {
392 523200 : input[i] = negate( input[i] );
393 523200 : move16();
394 : }
395 :
396 1635 : Copy( input, tmp_16 + HILBERT_ORDER1, length );
397 :
398 : /*Copy32( mem1_ext, tmp_16, 5 ); */
399 9810 : FOR( i = 0; i < HILBERT_ORDER1; i++ )
400 : {
401 8175 : tmp_16[i] = extract_h( mem1_ext[i] ); /* mem1_ext (Qx+16) tmp16 (Qx) */
402 8175 : move16();
403 : }
404 :
405 : /* Hilber transform stage - 0 - single precision */
406 1635 : Hilbert_transform_sp_fx( tmp_16, /* i: Real component of HB */
407 : tmp_16, /* i: Imag component of HB */
408 : tmpi_R, /* o: Real component of HB */
409 : tmpi_I, /* o: Imag. component of HB */
410 : length, /* i: length of the spectra */
411 : 0 ); /* i: HB transform stage */
412 :
413 9810 : FOR( i = 0; i < HILBERT_ORDER1; i++ )
414 : {
415 8175 : mem1_ext[i] = L_deposit_h( tmp_16[i + length] ); /* mem1_ext (Qx+16) tmp16 (Qx) */
416 8175 : move32();
417 : }
418 :
419 1635 : Copy32( mem2_ext, tmpi2_R, HILBERT_ORDER2 );
420 1635 : Copy32( mem3_ext, tmpi2_I, HILBERT_ORDER2 );
421 :
422 : /* Hilber transform stage - 1 */
423 1635 : Hilbert_transform_fx( tmpi_R, /* i: Real component of HB */
424 : tmpi_I, /* i: Imag component of HB */
425 : tmpi2_R, /* o: Real component of HB */
426 : tmpi2_I, /* o: Imag. component of HB */
427 : length, /* i: length of the spectra */
428 : 1 ); /* i: HB transform stage */
429 :
430 1635 : Copy32( mem2_ext + HILBERT_ORDER2, tmp_R, HILBERT_ORDER2 );
431 1635 : Copy32( mem3_ext + HILBERT_ORDER2, tmp_I, HILBERT_ORDER2 );
432 :
433 : /* Hilber transform stage - 2 */
434 1635 : Hilbert_transform_fx( tmpi2_R, /* i: Real component of HB */
435 : tmpi2_I, /* i: Imag component of HB */
436 : tmpi_R, /* o: Real component of HB */
437 : tmpi_I, /* o: Imag. component of HB */
438 : length, /* i: length of the spectra */
439 : 2 ); /* i: HB transform stage */
440 :
441 1635 : Copy32( tmpi2_R + length, mem2_ext, HILBERT_ORDER2 );
442 1635 : Copy32( tmpi2_I + length, mem3_ext, HILBERT_ORDER2 );
443 :
444 : /* Hilber transform stage - 3 */
445 1635 : Hilbert_transform_fx( tmpi_R, /* i: Real component of HB */
446 : tmpi_I, /* i: Imag component of HB */
447 : tmp_R, /* o: Real component of HB */
448 : tmp_I, /* o: Imag. component of HB */
449 : length, /* i: length of the spectra */
450 : 3 ); /* i: HB transform stage */
451 :
452 1635 : Copy32( tmp_R + length, mem2_ext + HILBERT_ORDER2, HILBERT_ORDER2 );
453 1635 : Copy32( tmp_I + length, mem3_ext + HILBERT_ORDER2, HILBERT_ORDER2 );
454 :
455 1635 : if ( GE_16( *phase_state, period ) )
456 : {
457 0 : *phase_state = 0;
458 0 : move16();
459 : }
460 :
461 1635 : i = 0;
462 1635 : move16();
463 1635 : j = *phase_state;
464 1635 : move16();
465 :
466 64740 : WHILE( i < length )
467 : {
468 1109505 : WHILE( ( j < period ) && ( i < length ) )
469 : {
470 1046400 : L_tmp = Mult_32_16( tmp_R[i + 4], local_cos_table[j] ); /*//Qx+16 */
471 1046400 : L_tmp = Madd_32_16( L_tmp, tmp_I[i + 4], local_negsin_table[j] ); /*Qx+16 */
472 1046400 : output[i] = round_fx( L_tmp ); /*Qx */
473 1046400 : move16();
474 1046400 : i++;
475 1046400 : j++;
476 : }
477 :
478 63105 : if ( GE_16( j, period ) )
479 : {
480 61560 : j = 0;
481 61560 : move16();
482 : }
483 : }
484 :
485 1635 : *phase_state = j;
486 1635 : move16();
487 :
488 1635 : return;
489 : }
490 :
491 :
492 51219 : void flip_and_downmix_generic_fx32(
493 : Word32 input[], /* i : input spectrum Qx*/
494 : Word32 output[], /* o : output spectrum Qx*/
495 : const Word16 length, /* i : length of spectra */
496 : Word32 mem1_ext[HILBERT_ORDER1], /* i/o: memory Qx*/
497 : Word32 mem2_ext[2 * HILBERT_ORDER2], /* i/o: memory Qx*/
498 : Word32 mem3_ext[2 * HILBERT_ORDER2], /* i/o: memory Qx*/
499 : Word16 *phase_state /* i/o: Phase state in case frequency isn't multiple of 50 Hz */
500 : )
501 : {
502 : Word16 i, j;
503 : Word32 tmp[L_FRAME32k + HILBERT_ORDER1];
504 : Word32 tmpi_R[L_FRAME32k];
505 : Word32 tmpi_I[L_FRAME32k];
506 : Word32 tmpi2_R[L_FRAME32k + HILBERT_ORDER2];
507 : Word32 tmpi2_I[L_FRAME32k + HILBERT_ORDER2];
508 : Word32 tmp_R[L_FRAME32k + HILBERT_ORDER2];
509 : Word32 tmp_I[L_FRAME32k + HILBERT_ORDER2];
510 :
511 : /*Word16 s_tmp[L_FRAME32k];*/
512 : /*Word16 factor;*/
513 : Word16 period;
514 51219 : Word16 local_negsin_table17[17] = { 0, -11793, -22005, -29268, -32609, -31580,
515 : -26319, -17530, -6393, 6393, 17530, 26319,
516 : 31580, 32609, 29268, 22005, 11793 }; /* Q15 */
517 51219 : Word16 local_cos_table17[17] = { 32767, 30571, 24279, 14732, 3212, -8739,
518 : -19519, -27683, -32137, -32137, -27683,
519 : -19519, -8739, 3212, 14732, 24279, 30571 }; /* Q15 */
520 : Word16 *local_negsin_table, *local_cos_table;
521 : Word32 L_tmp;
522 :
523 : /* 1850 Hz downmix */
524 51219 : period = 17;
525 51219 : move16();
526 51219 : local_negsin_table = local_negsin_table17;
527 51219 : local_cos_table = local_cos_table17;
528 :
529 :
530 15838299 : FOR( i = 0; i < length; i = i + 2 )
531 : {
532 15787080 : input[i] = L_negate( input[i] );
533 15787080 : move16();
534 : }
535 :
536 51219 : Copy32( input, tmp + HILBERT_ORDER1, length );
537 51219 : Copy32( mem1_ext, tmp, HILBERT_ORDER1 );
538 :
539 : /* Hilber transform stage - 0 - single precision */
540 51219 : Hilbert_transform_fx( tmp, /* i: Real component of HB */
541 : tmp, /* i: Imag component of HB */
542 : tmpi_R, /* o: Real component of HB */
543 : tmpi_I, /* o: Imag. component of HB */
544 : length, /* i: length of the spectra */
545 : 0 ); /* i: HB transform stage */
546 :
547 :
548 51219 : Copy32( mem2_ext, tmpi2_R, HILBERT_ORDER2 );
549 51219 : Copy32( mem3_ext, tmpi2_I, HILBERT_ORDER2 );
550 :
551 : /* Hilber transform stage - 1 */
552 51219 : Hilbert_transform_fx( tmpi_R, /* i: Real component of HB */
553 : tmpi_I, /* i: Imag component of HB */
554 : tmpi2_R, /* o: Real component of HB */
555 : tmpi2_I, /* o: Imag. component of HB */
556 : length, /* i: length of the spectra */
557 : 1 ); /* i: HB transform stage */
558 51219 : Copy32( tmp + length, mem1_ext, HILBERT_ORDER1 );
559 51219 : Copy32( mem2_ext + HILBERT_ORDER2, tmp_R, HILBERT_ORDER2 );
560 51219 : Copy32( mem3_ext + HILBERT_ORDER2, tmp_I, HILBERT_ORDER2 );
561 :
562 : /* Hilber transform stage - 2 */
563 51219 : Hilbert_transform_fx( tmpi2_R, /* i: Real component of HB */
564 : tmpi2_I, /* i: Imag component of HB */
565 : tmpi_R, /* o: Real component of HB */
566 : tmpi_I, /* o: Imag. component of HB */
567 : length, /* i: length of the spectra */
568 : 2 ); /* i: HB transform stage */
569 :
570 51219 : Copy32( tmpi2_R + length, mem2_ext, HILBERT_ORDER2 );
571 51219 : Copy32( tmpi2_I + length, mem3_ext, HILBERT_ORDER2 );
572 :
573 : /* Hilber transform stage - 3 */
574 51219 : Hilbert_transform_fx( tmpi_R, /* i: Real component of HB */
575 : tmpi_I, /* i: Imag component of HB */
576 : tmp_R, /* o: Real component of HB */
577 : tmp_I, /* o: Imag. component of HB */
578 : length, /* i: length of the spectra */
579 : 3 ); /* i: HB transform stage */
580 :
581 51219 : Copy32( tmp_R + length, mem2_ext + HILBERT_ORDER2, HILBERT_ORDER2 );
582 51219 : Copy32( tmp_I + length, mem3_ext + HILBERT_ORDER2, HILBERT_ORDER2 );
583 :
584 51219 : if ( GE_16( *phase_state, period ) )
585 : {
586 0 : *phase_state = 0;
587 0 : move16();
588 : }
589 :
590 51219 : i = 0;
591 51219 : move16();
592 51219 : j = *phase_state;
593 51219 : move16();
594 :
595 1956186 : WHILE( LT_16( i, length ) )
596 : {
597 33479127 : WHILE( ( j < period ) && ( i < length ) )
598 : {
599 31574160 : test();
600 31574160 : L_tmp = Mult_32_16( tmp_R[i + 4], local_cos_table[j] ); /*//Qx+16 */
601 31574160 : L_tmp = Madd_32_16( L_tmp, tmp_I[i + 4], local_negsin_table[j] ); /*Qx+16 */
602 31574160 : output[i] = L_tmp; /*Qx */
603 31574160 : move32();
604 31574160 : i++;
605 31574160 : j++;
606 : }
607 :
608 1904967 : if ( GE_16( j, period ) )
609 : {
610 1856684 : j = 0;
611 1856684 : move16();
612 : }
613 : }
614 :
615 51219 : *phase_state = j;
616 51219 : move16();
617 51219 : return;
618 : }
619 :
620 : /*----------------------------------------------
621 : * Hilbert transform - Double precision
622 : *------------------------------------------------*/
623 209781 : static void Hilbert_transform_fx(
624 : Word32 tmp_R[], /* i: Real component of HB */
625 : Word32 tmp_I[], /* i: Real component of HB */
626 : Word32 tmpi_R[], /* o: Real component of HB */
627 : Word32 tmpi_I[], /* o: Imag. component of HB */
628 : const Word16 length, /* i: input length */
629 : const Word16 HB_stage_id /* i: HB transform stage */
630 : )
631 : {
632 : Word16 i, hb_filter_stage, offset;
633 : Word32 L_tmp;
634 :
635 209781 : hb_filter_stage = shl( HB_stage_id, 1 );
636 209781 : offset = 0;
637 209781 : move16();
638 209781 : if ( HB_stage_id == 0 )
639 : {
640 51219 : offset = 1;
641 51219 : move16();
642 : }
643 :
644 209781 : test();
645 209781 : test();
646 209781 : IF( HB_stage_id == 0 || EQ_16( HB_stage_id, 2 ) )
647 : {
648 64298793 : FOR( i = 0; i < length; i++ )
649 : {
650 64194720 : L_tmp = Mult_32_16( tmp_R[i + 4], Hilbert_coeffs_fx[hb_filter_stage][0 + offset] ); /*Qx+15 */
651 64194720 : L_tmp = Madd_32_16( L_tmp, tmp_R[i + 2], Hilbert_coeffs_fx[hb_filter_stage][2 + offset] ); /*Qx+15 */
652 64194720 : L_tmp = Madd_32_16( L_tmp, tmp_R[i], Hilbert_coeffs_fx[hb_filter_stage][4 + offset] ); /*Qx+15 */
653 64194720 : tmpi_R[i] = L_shl( L_tmp, 1 );
654 64194720 : move32(); /*Qx+16 */
655 :
656 64194720 : L_tmp = Mult_32_16( tmp_I[i + 4 + offset], Hilbert_coeffs_fx[hb_filter_stage + 1][0] ); /*Qx+15 */
657 64194720 : L_tmp = Madd_32_16( L_tmp, tmp_I[i + 2 + offset], Hilbert_coeffs_fx[hb_filter_stage + 1][2] ); /*Qx+15 */
658 64194720 : L_tmp = Madd_32_16( L_tmp, tmp_I[i + offset], Hilbert_coeffs_fx[hb_filter_stage + 1][4] ); /*Qx+15 */
659 64194720 : tmpi_I[i] = L_shl( L_tmp, 1 );
660 64194720 : move32(); /*Qx+16 */
661 : }
662 : }
663 105708 : ELSE IF( EQ_16( HB_stage_id, 1 ) || EQ_16( HB_stage_id, 3 ) )
664 : {
665 65346828 : FOR( i = 0; i < length; i++ )
666 : {
667 :
668 65241120 : L_tmp = Mult_32_16( tmpi_R[i + 2], Hilbert_coeffs_fx[hb_filter_stage][2] ); /*Qx+15 */
669 65241120 : L_tmp = Madd_32_16( L_tmp, tmpi_R[i], Hilbert_coeffs_fx[hb_filter_stage][4] ); /*Qx+15 */
670 65241120 : tmpi_R[i + 4] = L_sub( tmp_R[i], L_shl( L_tmp, 1 ) );
671 65241120 : move32(); /*Qx+16 */
672 :
673 65241120 : L_tmp = Mult_32_16( tmpi_I[i + 2], Hilbert_coeffs_fx[hb_filter_stage + 1][2] ); /*Qx+15 */
674 65241120 : L_tmp = Madd_32_16( L_tmp, tmpi_I[i], Hilbert_coeffs_fx[hb_filter_stage + 1][4] ); /*Qx+15 */
675 65241120 : tmpi_I[i + 4] = L_sub( tmp_I[i], L_shl( L_tmp, 1 ) );
676 65241120 : move32(); /*Qx+16 */
677 : }
678 : }
679 209781 : }
680 :
681 :
682 : /*----------------------------------------------
683 : * Hilbert transform - Single precision Stage 0
684 : *------------------------------------------------*/
685 1635 : static void Hilbert_transform_sp_fx(
686 : Word16 tmp_R[], /* i: Real component of HB */
687 : Word16 tmp_I[], /* i: Real component of HB */
688 : Word32 tmpi_R[], /* o: Real component of HB */
689 : Word32 tmpi_I[], /* o: Imag. component of HB */
690 : const Word16 length, /* i: input length */
691 : const Word16 HB_stage_id /* i: HB transform stage */
692 : )
693 : {
694 : Word16 i, hb_filter_stage, offset;
695 : Word32 L_tmp;
696 :
697 1635 : hb_filter_stage = shl( HB_stage_id, 1 );
698 1635 : offset = 0;
699 1635 : move16();
700 1635 : if ( HB_stage_id == 0 )
701 : {
702 1635 : offset = 1;
703 1635 : move16();
704 : }
705 :
706 : /* Hilbert single precision stage 0 */
707 1048035 : FOR( i = 0; i < length; i++ )
708 : {
709 1046400 : L_tmp = L_mult( tmp_R[i + 4], Hilbert_coeffs_fx[hb_filter_stage][0 + offset] ); /*Qx */
710 1046400 : L_tmp = L_mac( L_tmp, tmp_R[i + 2], Hilbert_coeffs_fx[hb_filter_stage][2 + offset] ); /*Qx */
711 1046400 : L_tmp = L_mac( L_tmp, tmp_R[i], Hilbert_coeffs_fx[hb_filter_stage][4 + offset] ); /*Qx */
712 1046400 : tmpi_R[i] = L_shl( L_tmp, 1 );
713 1046400 : move32(); /*Qx+16 */
714 :
715 1046400 : L_tmp = L_mult( tmp_I[i + 4 + offset], Hilbert_coeffs_fx[hb_filter_stage + 1][0] ); /*Qx */
716 1046400 : L_tmp = L_mac( L_tmp, tmp_I[i + 2 + offset], Hilbert_coeffs_fx[hb_filter_stage + 1][2] ); /*Qx */
717 1046400 : L_tmp = L_mac( L_tmp, tmp_I[i + offset], Hilbert_coeffs_fx[hb_filter_stage + 1][4] ); /*Qx */
718 1046400 : tmpi_I[i] = L_shl( L_tmp, 1 );
719 1046400 : move32(); /*Qx+16 */
720 : }
721 :
722 1635 : return;
723 : }
724 :
725 :
726 : /*----------------------------------------------
727 : * flip_spectrum_fx
728 : *----------------------------------------------*/
729 91623 : void flip_spectrum_fx(
730 : const Word16 input[], /* i : input spectrum */
731 : Word16 output[], /* o : output spectrum */
732 : const Word16 length /* i : vector length */
733 : )
734 : {
735 : Word16 i;
736 :
737 14751303 : FOR( i = 0; i < length; i = i + 2 )
738 : {
739 14659680 : output[i] = negate( input[i] );
740 14659680 : move16();
741 14659680 : output[i + 1] = input[i + 1];
742 14659680 : move16();
743 : }
744 :
745 91623 : return;
746 : }
747 :
748 :
749 : /*----------------------------------------------------------------------------
750 : * calc_rc0_h
751 : *
752 : * computes 1st parcor from composed filter impulse response
753 : *---------------------------------------------------------------------------*/
754 1094933 : void Calc_rc0_h(
755 : Word16 *h, /* i : impulse response of composed filter */
756 : Word16 *rc0 /* o : 1st parcor */
757 : )
758 : {
759 : Word32 L_acc;
760 : Word16 *ptrs;
761 : Word16 acf0, acf1;
762 : Word16 temp, sh_acf;
763 : Word16 i;
764 :
765 : /* computation of the autocorrelation function acf */
766 1094933 : L_acc = L_mult( h[0], h[0] );
767 21898660 : FOR( i = 1; i < LONG_H_ST; i++ )
768 : {
769 20803727 : L_acc = L_mac( L_acc, h[i], h[i] );
770 : }
771 1094933 : sh_acf = norm_l( L_acc );
772 1094933 : L_acc = L_shl( L_acc, sh_acf );
773 1094933 : acf0 = extract_h( L_acc );
774 :
775 1094933 : ptrs = h;
776 :
777 1094933 : temp = *ptrs++;
778 1094933 : move16();
779 1094933 : L_acc = L_mult( temp, *ptrs );
780 20803727 : FOR( i = 1; i < LONG_H_ST - 1; i++ )
781 : {
782 19708794 : temp = *ptrs++;
783 19708794 : move16();
784 19708794 : L_acc = L_mac( L_acc, temp, *ptrs );
785 : }
786 1094933 : L_acc = L_shl( L_acc, sh_acf );
787 1094933 : acf1 = extract_h( L_acc );
788 :
789 : /* Compute 1st parcor */
790 1094933 : IF( acf0 == 0 )
791 : {
792 0 : *rc0 = 0;
793 0 : move16();
794 0 : return;
795 : }
796 :
797 1094933 : IF( LT_16( acf0, abs_s( acf1 ) ) )
798 : {
799 0 : *rc0 = 0;
800 0 : move16();
801 0 : return;
802 : }
803 1094933 : *rc0 = div_s( abs_s( acf1 ), acf0 );
804 1094933 : move16();
805 1094933 : IF( acf1 > 0 )
806 : {
807 333072 : *rc0 = negate( *rc0 );
808 333072 : move16();
809 : }
810 : }
811 :
812 445680 : void Calc_rc0_h_ivas_enc_fx(
813 : Word16 *h, /* i : impulse response of composed filter */
814 : Word16 *rc0 /* o : 1st parcor */
815 : )
816 : {
817 : Word32 L_acc;
818 : Word16 *ptrs;
819 : Word16 acf0, acf1;
820 : Word16 temp, sh_acf, tmp2;
821 : Word16 i;
822 :
823 : /* computation of the autocorrelation function acf */
824 445680 : L_acc = L_mult( h[0], h[0] );
825 8913600 : FOR( i = 1; i < LONG_H_ST; i++ )
826 : {
827 8467920 : tmp2 = shr( h[i], 2 );
828 8467920 : L_acc = L_mac( L_acc, tmp2, tmp2 );
829 : }
830 445680 : sh_acf = norm_l( L_acc );
831 445680 : L_acc = L_shl( L_acc, sh_acf );
832 445680 : acf0 = extract_h( L_acc );
833 :
834 445680 : ptrs = h;
835 :
836 445680 : temp = *ptrs++;
837 445680 : move16();
838 445680 : L_acc = L_mult( temp, *ptrs );
839 8467920 : FOR( i = 1; i < LONG_H_ST - 1; i++ )
840 : {
841 8022240 : temp = shr( *ptrs++, 2 );
842 8022240 : move16();
843 8022240 : L_acc = L_mac( L_acc, temp, shr( *ptrs, 2 ) );
844 : }
845 445680 : L_acc = L_shl( L_acc, sh_acf );
846 445680 : acf1 = extract_h( L_acc );
847 :
848 : /* Compute 1st parcor */
849 445680 : IF( acf0 == 0 )
850 : {
851 0 : *rc0 = 0;
852 0 : move16();
853 0 : return;
854 : }
855 :
856 445680 : IF( LT_16( acf0, abs_s( acf1 ) ) )
857 : {
858 0 : *rc0 = 0;
859 0 : move16();
860 0 : return;
861 : }
862 445680 : *rc0 = div_s( abs_s( acf1 ), acf0 );
863 445680 : move16();
864 445680 : IF( acf1 > 0 )
865 : {
866 72096 : *rc0 = negate( *rc0 );
867 72096 : move16();
868 : }
869 : }
870 :
871 10824 : static void Calc_st_filt_tbe(
872 : Word16 *apond2, /* i : coefficients of numerator */
873 : Word16 *apond1, /* i : coefficients of denominator */
874 : Word16 *parcor0, /* o : 1st parcor calcul. on composed filter */
875 : Word16 *sig_ltp_ptr, /* i/o: i of 1/A(gamma1) : scaled by 1/g0 */
876 : Word16 *mem_zero /* i : All zero memory */
877 : )
878 : {
879 : Word32 L_g0;
880 :
881 : Word16 h[LONG_H_ST];
882 :
883 : Word16 g0, temp;
884 : Word16 i;
885 10824 : temp = sub( 2, norm_s( apond2[0] ) );
886 : /* compute i.r. of composed filter apond2 / apond1 */
887 10824 : Syn_filt_s( temp, apond1, LPC_SHB_ORDER, apond2, h, LONG_H_ST, mem_zero, 0 );
888 : /* compute 1st parcor */
889 10824 : Calc_rc0_h( h, parcor0 );
890 :
891 : /* compute g0 */
892 10824 : L_g0 = L_mult0( 1, abs_s( h[0] ) );
893 216480 : FOR( i = 1; i < LONG_H_ST; i++ )
894 : {
895 205656 : L_g0 = L_mac0( L_g0, 1, abs_s( h[i] ) );
896 : }
897 10824 : g0 = extract_h( L_shl( L_g0, 14 ) );
898 :
899 : /* Scale signal i of 1/A(gamma1) */
900 10824 : IF( GT_16( g0, 1024 ) )
901 : {
902 10824 : temp = div_s( 1024, g0 ); /* temp = 2**15 / gain0 */
903 876744 : FOR( i = 0; i < L_SUBFR16k; i++ )
904 : {
905 865920 : sig_ltp_ptr[i] = mult_r( sig_ltp_ptr[i], temp );
906 865920 : move16();
907 : }
908 : }
909 10824 : }
910 :
911 445680 : static void Calc_st_filt_tbe_ivas_enc_fx(
912 : Word16 *apond2, /* i : coefficients of numerator */
913 : Word16 *apond1, /* i : coefficients of denominator */
914 : Word16 *parcor0, /* o : 1st parcor calcul. on composed filter */
915 : Word16 *sig_ltp_ptr, /* i/o: i of 1/A(gamma1) : scaled by 1/g0 */
916 : Word16 *mem_zero /* i : All zero memory */
917 : )
918 : {
919 : Word32 L_g0;
920 :
921 : Word16 h[LONG_H_ST];
922 :
923 : Word16 g0, temp;
924 : Word16 i;
925 445680 : temp = sub( 2, norm_s( apond2[0] ) );
926 : /* compute i.r. of composed filter apond2 / apond1 */
927 445680 : syn_filt_fx( temp, apond1, LPC_SHB_ORDER, apond2, h, LONG_H_ST, mem_zero, 0 );
928 : /* compute 1st parcor */
929 445680 : Calc_rc0_h_ivas_enc_fx( h, parcor0 );
930 :
931 : /* compute g0 */
932 445680 : L_g0 = L_mult0( 1, abs_s( h[0] ) );
933 8913600 : FOR( i = 1; i < LONG_H_ST; i++ )
934 : {
935 8467920 : L_g0 = L_mac0( L_g0, 1, abs_s( h[i] ) );
936 : }
937 445680 : g0 = extract_h( L_shl( L_g0, 14 ) );
938 :
939 : /* Scale signal i of 1/A(gamma1) */
940 445680 : IF( GT_16( g0, 1024 ) )
941 : {
942 445680 : temp = div_s( 1024, g0 ); /* temp = 2**15 / gain0 */
943 36100080 : FOR( i = 0; i < L_SUBFR16k; i++ )
944 : {
945 35654400 : sig_ltp_ptr[i] = mult_r( sig_ltp_ptr[i], temp );
946 35654400 : move16();
947 : }
948 : }
949 445680 : }
950 :
951 402228 : static void Calc_st_filt_tbe_ivas_dec_fx(
952 : Word16 *apond2, /* i : coefficients of numerator */
953 : Word16 *apond1, /* i : coefficients of denominator */
954 : Word16 *parcor0, /* o : 1st parcor calcul. on composed filter */
955 : Word16 *sig_ltp_ptr, /* i/o: i of 1/A(gamma1) : scaled by 1/g0 */
956 : Word16 *mem_zero /* i : All zero memory */
957 : )
958 : {
959 : Word32 L_g0;
960 :
961 : Word16 h[LONG_H_ST];
962 :
963 : Word16 g0, temp;
964 : Word16 i;
965 402228 : temp = sub( 2, norm_s( apond2[0] ) );
966 : /* compute i.r. of composed filter apond2 / apond1 */
967 402228 : Syn_filt_s( temp, apond1, LPC_SHB_ORDER, apond2, h, LONG_H_ST, mem_zero, 0 );
968 : /* compute 1st parcor */
969 402228 : Calc_rc0_h( h, parcor0 );
970 :
971 : /* compute g0 */
972 402228 : L_g0 = L_mult0( 1, abs_s( h[0] ) );
973 8044560 : FOR( i = 1; i < LONG_H_ST; i++ )
974 : {
975 7642332 : L_g0 = L_mac0( L_g0, 1, abs_s( h[i] ) );
976 : }
977 402228 : g0 = extract_h( L_shl( L_g0, 14 ) );
978 :
979 : /* Scale signal i of 1/A(gamma1) */
980 402228 : IF( GT_16( g0, 1024 ) )
981 : {
982 402228 : temp = div_s( 1024, g0 ); /* temp = 2**15 / gain0 */
983 32580468 : FOR( i = 0; i < L_SUBFR16k; i++ )
984 : {
985 32178240 : sig_ltp_ptr[i] = mult_r( sig_ltp_ptr[i], temp );
986 32178240 : move16();
987 : }
988 : }
989 402228 : }
990 :
991 858732 : static void filt_mu_fx(
992 : const Word16 *sig_in, /* i : signal (beginning at sample -1) */
993 : Word16 *sig_out, /* o : output signal */
994 : const Word16 parcor0, /* i : parcor0 (mu = parcor0 * gamma3) */
995 : Word16 SubFrameLength /* i : the length of subframe */
996 : )
997 : {
998 : Word16 n;
999 : Word16 mu, ga, temp;
1000 : const Word16 *ptrs;
1001 : Word16 tmp, exp;
1002 : #ifndef ISSUE_1836_replace_overflow_libcom
1003 : Flag Overflow = 0;
1004 : move32();
1005 : #endif
1006 :
1007 858732 : IF( EQ_16( SubFrameLength, L_SUBFR ) )
1008 : {
1009 0 : IF( parcor0 > 0 )
1010 : {
1011 0 : mu = mult_r( parcor0, GAMMA3_PLUS_FX );
1012 : }
1013 : ELSE
1014 : {
1015 0 : mu = mult_r( parcor0, GAMMA3_MINUS_FX );
1016 : }
1017 : }
1018 : ELSE
1019 : {
1020 858732 : IF( parcor0 > 0 )
1021 : {
1022 720012 : mu = mult_r( parcor0, GAMMA3_PLUS_WB_FX );
1023 : }
1024 : ELSE
1025 : {
1026 138720 : mu = mult_r( parcor0, GAMMA3_MINUS_WB_FX );
1027 : }
1028 : }
1029 :
1030 858732 : tmp = abs_s( mu );
1031 858732 : tmp = sub( 32767, tmp );
1032 858732 : exp = norm_s( tmp );
1033 858732 : tmp = div_s( shl( 1, sub( 14, exp ) ), tmp ); /*(14 - exp) */
1034 858732 : ga = shl_sat( tmp, exp ); /*Q14 */
1035 :
1036 :
1037 : /* ga = (float) 1. / ((float) 1. - (float) fabs (mu)); */
1038 :
1039 858732 : ptrs = sig_in; /* points on sig_in(-1) */
1040 :
1041 69557292 : FOR( n = 0; n < SubFrameLength; n++ )
1042 : {
1043 68698560 : temp = mult_r( mu, ( *ptrs++ ) );
1044 68698560 : temp = add_sat( temp, *ptrs ); /*Q12 */
1045 : #ifdef ISSUE_1836_replace_overflow_libcom
1046 68698560 : sig_out[n] = shl_sat( mult_r( ga, temp ), 1 );
1047 : #else
1048 : sig_out[n] = shl_o( mult_r( ga, temp ), 1, &Overflow );
1049 : #endif
1050 68698560 : move16(); /*Q12 */
1051 : }
1052 :
1053 858732 : return;
1054 : }
1055 :
1056 858732 : static void scale_st_swb(
1057 : const Word16 *sig_in_fx, /* i : postfilter i signal */
1058 : Word16 *sig_out_fx, /* i/o: postfilter o signal */
1059 : Word16 *gain_prec_fx, /* i/o: last value of gain for subframe */
1060 : Word16 SubFrameLength )
1061 : {
1062 : Word16 i;
1063 : Word16 agc_fac1_para_fx;
1064 : Word16 agc_fac_para_fx;
1065 : Word32 L_acc, L_temp;
1066 : Word16 g0_fx, gain_fx;
1067 : Word16 scal_in, scal_out;
1068 : Word16 s_g_in, s_g_out, sh_g0, temp;
1069 :
1070 :
1071 858732 : IF( EQ_16( SubFrameLength, L_SUBFR ) )
1072 : {
1073 0 : agc_fac1_para_fx = AGC_FAC1_FX;
1074 0 : move16();
1075 0 : agc_fac_para_fx = AGC_FAC_FX;
1076 0 : move16();
1077 : }
1078 : ELSE /*IF( SubFrameLength == L_SUBFR16k ) */
1079 : {
1080 858732 : agc_fac1_para_fx = AGC_FAC1_WB_FX;
1081 858732 : move16();
1082 858732 : agc_fac_para_fx = AGC_FAC_WB_FX;
1083 858732 : move16();
1084 : }
1085 :
1086 : /* compute input gain */
1087 858732 : L_acc = L_mult0( 1, abs_s( sig_in_fx[0] ) ); /*0 +Q_bwe_exc-1 */
1088 68698560 : FOR( i = 1; i < SubFrameLength; i++ )
1089 : {
1090 67839828 : L_acc = L_mac0( L_acc, 1, abs_s( sig_in_fx[i] ) ); /*Q_bwe_exc-1 */
1091 : }
1092 :
1093 858732 : g0_fx = 0;
1094 858732 : move16();
1095 858732 : IF( L_acc != 0L )
1096 : {
1097 857866 : scal_in = norm_l( L_acc );
1098 857866 : L_acc = L_shl( L_acc, scal_in );
1099 857866 : s_g_in = extract_h( L_acc ); /* normalized */
1100 :
1101 : /* Compute o gain */
1102 857866 : L_acc = L_mult0( 1, abs_s( sig_out_fx[0] ) );
1103 68629280 : FOR( i = 1; i < SubFrameLength; i++ )
1104 : {
1105 67771414 : L_acc = L_mac0( L_acc, 1, abs_s( sig_out_fx[i] ) );
1106 : }
1107 857866 : IF( L_acc == 0L )
1108 : {
1109 0 : *gain_prec_fx = 0;
1110 0 : move16();
1111 :
1112 0 : return;
1113 : }
1114 :
1115 857866 : scal_out = norm_l( L_acc );
1116 857866 : L_acc = L_shl( L_acc, scal_out );
1117 857866 : s_g_out = extract_h( L_acc ); /* normalized */
1118 :
1119 :
1120 857866 : sh_g0 = add( scal_in, 1 );
1121 857866 : sh_g0 = sub( sh_g0, scal_out ); /* scal_in - scal_out + 1 */
1122 857866 : IF( LT_16( s_g_in, s_g_out ) )
1123 : {
1124 160052 : g0_fx = div_s( s_g_in, s_g_out ); /* s_g_in/s_g_out in Q15 */
1125 : }
1126 : ELSE
1127 : {
1128 697814 : temp = sub( s_g_in, s_g_out ); /* sufficient since normalized */
1129 697814 : g0_fx = shr( div_s( temp, s_g_out ), 1 );
1130 697814 : g0_fx = add( g0_fx, (Word16) 0x4000 ); /* s_g_in/s_g_out in Q14 */
1131 697814 : sh_g0 = sub( sh_g0, 1 );
1132 : }
1133 : /* L_gain_in/L_gain_out in Q14 */
1134 : /* overflows if L_gain_in > 2 * L_gain_out */
1135 857866 : g0_fx = shr_sat( g0_fx, sh_g0 ); /* sh_g0 may be >0, <0, or =0 */ // Need to verify?
1136 :
1137 857866 : g0_fx = mult_r( g0_fx, agc_fac1_para_fx ); /* L_gain_in/L_gain_out * AGC_FAC1_FX */
1138 : }
1139 : /* compute gain(n) = AGC_FAC gain(n-1) + (1-AGC_FAC)gain_in/gain_out */
1140 : /* sig_out(n) = gain(n) sig_out(n) */
1141 858732 : gain_fx = *gain_prec_fx;
1142 858732 : move16(); /*14 */
1143 69557292 : FOR( i = 0; i < SubFrameLength; i++ )
1144 : {
1145 68698560 : temp = mult_r( agc_fac_para_fx, gain_fx ); /*15 +14 -15 =14 */
1146 68698560 : gain_fx = add( temp, g0_fx ); /* in Q14 */
1147 68698560 : L_temp = L_mult( gain_fx, sig_out_fx[i] ); /*14 + Q_bwe_exc-1 +1 = 14 + Q_bwe_exc */
1148 68698560 : L_temp = L_shl_sat( L_temp, 1 ); /*14 + Q_bwe_exc +1 */
1149 68698560 : sig_out_fx[i] = round_fx_sat( L_temp ); /*Q_bwe_exc +15 -16 = Q_bwe_exc-1 */
1150 68698560 : move16();
1151 : }
1152 858732 : *gain_prec_fx = gain_fx;
1153 858732 : move16();
1154 :
1155 858732 : return;
1156 : }
1157 :
1158 10824 : void PostShortTerm_fx(
1159 : Word16 *sig_in, /* i : input signal (pointer to current subframe */
1160 : Word16 *lpccoeff, /* i : LPC coefficients for current subframe */
1161 : Word16 *sig_out, /* o : postfiltered output */
1162 : Word16 *mem_stp, /* i/o: postfilter memory*/
1163 : Word16 *ptr_mem_stp, /* i/o: pointer to postfilter memory*/
1164 : Word16 *ptr_gain_prec, /* i/o: for gain adjustment*/
1165 : Word16 *mem_zero, /* i/o: null memory to compute h_st*/
1166 : const Word16 formant_fac_fx /* i : Strength of post-filter*/
1167 : )
1168 : {
1169 : Word16 apond1_fx[LPC_SHB_ORDER + 1]; /* denominator coeff.*/
1170 : Word16 apond2_fx[LONG_H_ST]; /* numerator coeff. */
1171 : Word16 sig_ltp_fx[L_SUBFR16k + 1]; /* residual signal */
1172 : /*Word16 lpccoeff_fx[LPC_SHB_ORDER+1];//Q12 */
1173 : Word16 g1_fx, g2_fx, parcor0_fx; /*Q15 */
1174 : Word16 tmp;
1175 :
1176 10824 : parcor0_fx = 0;
1177 10824 : move16();
1178 10824 : set16_fx( apond1_fx, 0, LPC_SHB_ORDER + 1 );
1179 10824 : set16_fx( apond2_fx, 0, LONG_H_ST );
1180 10824 : set16_fx( sig_ltp_fx, 0, L_SUBFR16k + 1 );
1181 :
1182 : /* Obtain post-filter weights */
1183 10824 : tmp = extract_h( L_mult( GAMMA_SHARP_FX, formant_fac_fx ) ); /*Q15 */
1184 10824 : g1_fx = add( GAMMA0_FX, tmp ); /*Q15 */
1185 10824 : g2_fx = sub( GAMMA0_FX, tmp ); /*Q15 */
1186 :
1187 : /* Compute weighted LPC coefficients */
1188 10824 : weight_a_fx( lpccoeff, apond1_fx, g1_fx, LPC_SHB_ORDER );
1189 10824 : weight_a_fx( lpccoeff, apond2_fx, g2_fx, LPC_SHB_ORDER );
1190 : /* o: apond1_fx, apond2_fx in Q12 */
1191 :
1192 : /* Compute A(gamma2) residual */
1193 10824 : Residu3_10_fx( apond2_fx, sig_in, sig_ltp_fx + 1, L_SUBFR16k, 0 );
1194 : /* o: sig_ltp_fx in Q_bwe_exc */
1195 :
1196 : /* Save last output of 1/A(gamma1) */
1197 10824 : sig_ltp_fx[0] = *ptr_mem_stp;
1198 10824 : move16();
1199 :
1200 : /* Control short term pst filter gain and compute parcor0 */
1201 10824 : Calc_st_filt_tbe( apond2_fx, apond1_fx, &parcor0_fx, sig_ltp_fx + 1, mem_zero );
1202 : /* o: parcor0 in Q15 */
1203 : /* i/o: sig_ltp_fx in Q_bwe_exc */
1204 :
1205 : /* 1/A(gamma1) filtering, mem_stp is updated */
1206 10824 : Syn_filt_s( 0, apond1_fx, LPC_SHB_ORDER, sig_ltp_fx + 1, sig_ltp_fx + 1, L_SUBFR16k, mem_stp, 1 );
1207 :
1208 : /* (1 + mu z-1) tilt filtering */
1209 10824 : filt_mu_fx( sig_ltp_fx, sig_out, parcor0_fx, L_SUBFR16k );
1210 : /* o: sig_out in Q_bwe_exc */
1211 :
1212 : /* gain control */
1213 10824 : scale_st_swb( sig_in, sig_out, ptr_gain_prec, L_SUBFR16k );
1214 :
1215 10824 : return;
1216 : }
1217 :
1218 445680 : void PostShortTerm_ivas_enc_fx(
1219 : Word16 *sig_in, /* i : input signal (pointer to current subframe */
1220 : Word16 *lpccoeff, /* i : LPC coefficients for current subframe */
1221 : Word16 *sig_out, /* o : postfiltered output */
1222 : Word16 *mem_stp, /* i/o: postfilter memory*/
1223 : Word16 *ptr_mem_stp, /* i/o: pointer to postfilter memory*/
1224 : Word16 *ptr_gain_prec, /* i/o: for gain adjustment*/
1225 : Word16 *mem_zero, /* i/o: null memory to compute h_st*/
1226 : const Word16 formant_fac_fx /* i : Strength of post-filter*/
1227 : )
1228 : {
1229 : Word16 apond1_fx[LPC_SHB_ORDER + 1]; /* denominator coeff.*/
1230 : Word16 apond2_fx[LONG_H_ST]; /* numerator coeff. */
1231 : Word16 sig_ltp_fx[L_SUBFR16k + 1]; /* residual signal */
1232 : /*Word16 lpccoeff_fx[LPC_SHB_ORDER+1];//Q12 */
1233 : Word16 g1_fx, g2_fx, parcor0_fx; /*Q15 */
1234 : Word16 tmp;
1235 :
1236 445680 : parcor0_fx = 0;
1237 445680 : move16();
1238 445680 : set16_fx( apond1_fx, 0, LPC_SHB_ORDER + 1 );
1239 445680 : set16_fx( apond2_fx, 0, LONG_H_ST );
1240 445680 : set16_fx( sig_ltp_fx, 0, L_SUBFR16k + 1 );
1241 :
1242 : /* Obtain post-filter weights */
1243 445680 : tmp = extract_h( L_mult( GAMMA_SHARP_FX, formant_fac_fx ) ); /*Q15 */
1244 445680 : g1_fx = add( GAMMA0_FX, tmp ); /*Q15 */
1245 445680 : g2_fx = sub( GAMMA0_FX, tmp ); /*Q15 */
1246 :
1247 : /* Compute weighted LPC coefficients */
1248 445680 : weight_a_fx( lpccoeff, apond1_fx, g1_fx, LPC_SHB_ORDER );
1249 445680 : weight_a_fx( lpccoeff, apond2_fx, g2_fx, LPC_SHB_ORDER );
1250 : /* o: apond1_fx, apond2_fx in Q12 */
1251 :
1252 : /* Compute A(gamma2) residual */
1253 445680 : Residu3_10_fx( apond2_fx, sig_in, sig_ltp_fx + 1, L_SUBFR16k, 0 );
1254 : /* o: sig_ltp_fx in Q_bwe_exc */
1255 :
1256 : /* Save last output of 1/A(gamma1) */
1257 445680 : sig_ltp_fx[0] = *ptr_mem_stp;
1258 445680 : move16();
1259 :
1260 : /* Control short term pst filter gain and compute parcor0 */
1261 445680 : Calc_st_filt_tbe_ivas_enc_fx( apond2_fx, apond1_fx, &parcor0_fx, sig_ltp_fx + 1, mem_zero );
1262 : /* o: parcor0 in Q15 */
1263 : /* i/o: sig_ltp_fx in Q_bwe_exc */
1264 :
1265 : /* 1/A(gamma1) filtering, mem_stp is updated */
1266 445680 : syn_filt_fx( 0, apond1_fx, LPC_SHB_ORDER, sig_ltp_fx + 1, sig_ltp_fx + 1, L_SUBFR16k, mem_stp, 1 );
1267 :
1268 : /* (1 + mu z-1) tilt filtering */
1269 445680 : filt_mu_fx( sig_ltp_fx, sig_out, parcor0_fx, L_SUBFR16k );
1270 : /* o: sig_out in Q_bwe_exc */
1271 :
1272 : /* gain control */
1273 445680 : scale_st_swb( sig_in, sig_out, ptr_gain_prec, L_SUBFR16k );
1274 :
1275 445680 : return;
1276 : }
1277 :
1278 402228 : void PostShortTerm_ivas_dec_fx(
1279 : Word16 *sig_in, /* i : input signal (pointer to current subframe */
1280 : Word16 *lpccoeff, /* i : LPC coefficients for current subframe */
1281 : Word16 *sig_out, /* o : postfiltered output */
1282 : Word16 *mem_stp, /* i/o: postfilter memory*/
1283 : Word16 *ptr_mem_stp, /* i/o: pointer to postfilter memory*/
1284 : Word16 *ptr_gain_prec, /* i/o: for gain adjustment*/
1285 : Word16 *mem_zero, /* i/o: null memory to compute h_st*/
1286 : const Word16 formant_fac_fx /* i : Strength of post-filter*/
1287 : )
1288 : {
1289 : Word16 apond1_fx[LPC_SHB_ORDER + 1]; /* denominator coeff.*/
1290 : Word16 apond2_fx[LONG_H_ST]; /* numerator coeff. */
1291 : Word16 sig_ltp_fx[L_SUBFR16k + 1]; /* residual signal */
1292 : /*Word16 lpccoeff_fx[LPC_SHB_ORDER+1];//Q12 */
1293 : Word16 g1_fx, g2_fx, parcor0_fx; /*Q15 */
1294 : Word16 tmp;
1295 :
1296 402228 : parcor0_fx = 0;
1297 402228 : move16();
1298 402228 : set16_fx( apond1_fx, 0, LPC_SHB_ORDER + 1 );
1299 402228 : set16_fx( apond2_fx, 0, LONG_H_ST );
1300 402228 : set16_fx( sig_ltp_fx, 0, L_SUBFR16k + 1 );
1301 :
1302 : /* Obtain post-filter weights */
1303 402228 : tmp = extract_h( L_mult( GAMMA_SHARP_FX, formant_fac_fx ) ); /*Q15 */
1304 402228 : g1_fx = add( GAMMA0_FX, tmp ); /*Q15 */
1305 402228 : g2_fx = sub( GAMMA0_FX, tmp ); /*Q15 */
1306 :
1307 : /* Compute weighted LPC coefficients */
1308 402228 : weight_a_fx( lpccoeff, apond1_fx, g1_fx, LPC_SHB_ORDER );
1309 402228 : weight_a_fx( lpccoeff, apond2_fx, g2_fx, LPC_SHB_ORDER );
1310 : /* o: apond1_fx, apond2_fx in Q12 */
1311 :
1312 : /* Compute A(gamma2) residual */
1313 402228 : Residu3_10_fx( apond2_fx, sig_in, sig_ltp_fx + 1, L_SUBFR16k, 0 );
1314 : /* o: sig_ltp_fx in Q_bwe_exc */
1315 :
1316 : /* Save last output of 1/A(gamma1) */
1317 402228 : sig_ltp_fx[0] = *ptr_mem_stp;
1318 402228 : move16();
1319 :
1320 : /* Control short term pst filter gain and compute parcor0 */
1321 402228 : Calc_st_filt_tbe_ivas_dec_fx( apond2_fx, apond1_fx, &parcor0_fx, sig_ltp_fx + 1, mem_zero );
1322 : /* o: parcor0 in Q15 */
1323 : /* i/o: sig_ltp_fx in Q_bwe_exc */
1324 :
1325 : /* 1/A(gamma1) filtering, mem_stp is updated */
1326 402228 : Syn_filt_s( 0, apond1_fx, LPC_SHB_ORDER, sig_ltp_fx + 1, sig_ltp_fx + 1, L_SUBFR16k, mem_stp, 1 );
1327 :
1328 : /* (1 + mu z-1) tilt filtering */
1329 402228 : filt_mu_fx( sig_ltp_fx, sig_out, parcor0_fx, L_SUBFR16k );
1330 : /* o: sig_out in Q_bwe_exc */
1331 :
1332 : /* gain control */
1333 402228 : scale_st_swb( sig_in, sig_out, ptr_gain_prec, L_SUBFR16k );
1334 :
1335 402228 : return;
1336 : }
1337 :
1338 57612 : void flip_spectrum_and_decimby4_fx(
1339 : const Word16 input[], /* i : input spectrum Q_inp */
1340 : Word16 output[], /* o : output spectrum Q_inp */
1341 : const Word16 length, /* i : vector length */
1342 : Word16 mem1[], /* i/o : memory Q_inp */
1343 : Word16 mem2[], /* i/o : memory Q_inp */
1344 : const Word16 ramp_flag /*i: flag to trigger slow ramp-up of output following change of core (HQ to ACELP or 12k8 to 16k ACELP) */
1345 : )
1346 : {
1347 : Word16 i;
1348 : Word16 factor, tmp[L_FRAME16k / 2];
1349 : Word16 tmp1, tmp2;
1350 : Word16 input_change[L_FRAME16k];
1351 :
1352 57612 : IF( ramp_flag )
1353 : {
1354 595 : factor = div_s( 4, length ); /* Q15 */
1355 24395 : FOR( i = 0; i < length / 4; i += 2 )
1356 : {
1357 23800 : tmp1 = extract_l( L_mult0( i, factor ) ); /* Q15 */
1358 23800 : tmp2 = extract_l( L_mult0( add( i, 1 ), factor ) ); /*Q15 */
1359 23800 : input_change[i] = negate( mult_r( input[i], tmp1 ) );
1360 23800 : move16();
1361 23800 : input_change[i + 1] = mult_r( input[i + 1], tmp2 );
1362 23800 : move16();
1363 : }
1364 : }
1365 : ELSE
1366 : {
1367 57017 : i = 0;
1368 57017 : move16();
1369 : }
1370 :
1371 6384678 : FOR( ; i < length; i = i + 2 )
1372 : {
1373 6327066 : input_change[i] = negate( input[i] );
1374 6327066 : move16();
1375 6327066 : input_change[i + 1] = input[i + 1];
1376 6327066 : move16();
1377 : }
1378 :
1379 57612 : Decimate_allpass_steep_fx( input_change, mem1, length, tmp );
1380 57612 : Decimate_allpass_steep_fx( tmp, mem2, shr( length, 1 ), output );
1381 :
1382 57612 : return;
1383 : }
1384 :
1385 :
1386 : /*==========================================================================*/
1387 : /* FUNCTION : void GenShapedWBExcitation_fx () */
1388 : /*--------------------------------------------------------------------------*/
1389 : /* PURPOSE : Synthesize spectrally shaped highband excitation signal for the wideband */
1390 : /*--------------------------------------------------------------------------*/
1391 : /* INPUT ARGUMENTS : */
1392 : /* _Word16 *lpc_shb i : lpc coefficients Q12 */
1393 : /* _Word16 coder_type i : coding type */
1394 : /* _Word16 *bwe_exc_extended i : bwidth extended exciatation Q_bwe_exc*/
1395 : /* _Word16 Q_bwe_exc i : Q format */
1396 : /* _Word16 voice_factors[] i : voicing factor Q15 */
1397 : /*--------------------------------------------------------------------------*/
1398 : /* OUTPUT ARGUMENTS : */
1399 : /* _Word16 *excSHB o : synthesized shaped shb exctiation Q_bwe_exc*/
1400 : /* _Word16 *exc4kWhtnd o : whitened synthesized shb excitation Q_bwe_exc*/
1401 : /*--------------------------------------------------------------------------*/
1402 : /* INPUT/OUTPUT ARGUMENTS : */
1403 : /* _Word32 *mem_csfilt i/o : memory Q_bwe_exc+16*/
1404 : /* _Word16 *mem_genSHBexc_filt_down1 i/o : memory Q_bwe_exc */
1405 : /* _Word16 *mem_genSHBexc_filt_down2 i/o : memory Q_bwe_exc */
1406 : /* _Word16 *mem_genSHBexc_filt_down3 i/o : memory Q_bwe_exc */
1407 : /* _Word16 *state_lpc_syn i/o : memory Q_bwe_exc */
1408 : /* _Word16 bwe_seed[] i/o : random number generator seed */
1409 : /*--------------------------------------------------------------------------*/
1410 : /* RETURN ARGUMENTS : */
1411 : /* _ None */
1412 : /*--------------------------------------------------------------------------*/
1413 : /* CALLED FROM : */
1414 : /*==========================================================================*/
1415 :
1416 14814 : void GenShapedWBExcitation_ivas_fx(
1417 : Word16 *excSHB, /* o : synthesized shaped shb exctiation Q_bwe_exc*/
1418 : const Word16 *lpc_shb, /* i : lpc coefficients Q12*/
1419 : Word16 *exc4kWhtnd, /* o : whitened synthesized shb excitation Q_bwe_exc*/
1420 : Word32 *mem_csfilt, /* i/o : memory Q_bwe_exc+16*/
1421 : Word16 *mem_genSHBexc_filt_down1, /* i/o : memory Q_bwe_exc*/
1422 : Word16 *mem_genSHBexc_filt_down2, /* i/o : memory Q_bwe_exc*/
1423 : Word16 *mem_genSHBexc_filt_down3, /* i/o : memory Q_bwe_exc*/
1424 : Word16 *state_lpc_syn, /* i/o : memory Q_bwe_exc*/
1425 : const Word16 coder_type, /* i : coding type */
1426 : const Word16 *bwe_exc_extended, /* i : bwidth extended exciatation Q_bwe_exc*/
1427 : const Word16 Q_bwe_exc,
1428 : Word16 bwe_seed[], /* i/o : random number generator seed */
1429 : const Word16 voice_factors[], /* i : voicing factor Q15*/
1430 : const Word16 uv_flag, /* i : unvoiced flag */
1431 : const Word16 igf_flag )
1432 : {
1433 : Word16 i, j, k;
1434 : Word16 wht_fil_mem[LPC_WHTN_ORDER_WB];
1435 : Word16 lpc_whtn[LPC_WHTN_ORDER_WB + 1];
1436 : Word16 R_h[LPC_WHTN_ORDER_WB + 2], R_l[LPC_WHTN_ORDER_WB + 2];
1437 : Word16 Q_R;
1438 : Word16 excTmp[L_FRAME16k];
1439 : Word16 excTmp2[L_FRAME16k / 4];
1440 : Word16 excTmp2_frac[L_FRAME16k / 4];
1441 : Word16 exc4k[L_FRAME16k / 4];
1442 : Word16 exc4k_frac[L_FRAME16k / 4];
1443 : Word32 exc4k_32[L_FRAME16k / 4];
1444 : Word32 pow1, pow22;
1445 : Word16 scale;
1446 : Word32 excNoisyEnv[L_FRAME16k / 4];
1447 14814 : Word16 csfilt_num2[1] = { 1638 }; /* Q15*/
1448 14814 : Word16 neg_csfilt_den2[2] = { -32768, 31457 }; /* Q15 */
1449 : Word32 L_tmp, Ltemp1, Ltemp2;
1450 : Word16 temp1, temp2, exp;
1451 : Word32 Lmax;
1452 : Word16 max_val, n1, n2, sc;
1453 : Word32 LepsP[LPC_WHTN_ORDER_WB + 1];
1454 : Word16 tmp_vfac;
1455 : Word16 avg_voice_fac;
1456 : #ifndef ISSUE_1836_replace_overflow_libcom
1457 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
1458 : Flag Overflow = 0;
1459 : move16();
1460 : #endif
1461 : #endif
1462 :
1463 : /*0.25f*sum_f(voice_factors, NB_SUBFR)*/
1464 14814 : L_tmp = L_mult( voice_factors[0], 8192 /* 0.25 in Q15 */ );
1465 59256 : FOR( i = 1; i < NB_SUBFR; i++ )
1466 : {
1467 44442 : L_tmp = L_mac( L_tmp, voice_factors[i], 8192 /* 0.25 in Q15 */ );
1468 : }
1469 14814 : avg_voice_fac = round_fx( L_tmp );
1470 :
1471 14814 : test();
1472 14814 : test();
1473 14814 : test();
1474 14814 : test();
1475 14814 : IF( igf_flag != 0 && ( EQ_16( coder_type, VOICED ) || GT_16( avg_voice_fac, 11469 /* 0.35 in Q15 */ ) ) ) /*Q15 -> 0.35f*/
1476 : {
1477 0 : csfilt_num2[0] = 6554;
1478 0 : move16(); /*Q15 -> 0.2f*/
1479 0 : neg_csfilt_den2[1] = 26214;
1480 0 : move16(); /*Q15 -> 0.8f*/
1481 : }
1482 14814 : ELSE IF( igf_flag != 0 && ( EQ_16( coder_type, UNVOICED ) || LT_16( avg_voice_fac, 6654 /* 0.2 in Q15*/ ) ) ) /*Q15 -> 0.2f*/
1483 : {
1484 0 : csfilt_num2[0] = 328;
1485 0 : move16(); /*Q15 -> 0.01f*/
1486 0 : neg_csfilt_den2[1] = 32440;
1487 0 : move16(); /*Q15 -> 0.99f*/
1488 : }
1489 14814 : set16_fx( wht_fil_mem, 0, LPC_WHTN_ORDER_WB );
1490 14814 : Decimate_allpass_steep_fx( bwe_exc_extended, mem_genSHBexc_filt_down1, L_FRAME32k, excTmp );
1491 14814 : flip_spectrum_and_decimby4_fx( excTmp, exc4k, L_FRAME16k, mem_genSHBexc_filt_down2, mem_genSHBexc_filt_down3, 0 );
1492 :
1493 14814 : IF( uv_flag )
1494 : {
1495 868 : create_random_vector_fx( exc4kWhtnd, L_FRAME16k / 4, bwe_seed );
1496 868 : IF( LT_16( Q_bwe_exc, 5 ) )
1497 : {
1498 :
1499 70308 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1500 : {
1501 69440 : exc4kWhtnd[i] = shl_r( exc4kWhtnd[i], sub( Q_bwe_exc, 5 ) ); /*Q(Q_bwe_exc)/Q5(if Q_bwe_exc > 5) */
1502 69440 : move16();
1503 : }
1504 : }
1505 : }
1506 : ELSE
1507 : {
1508 13946 : autocorr_fx( exc4k, LPC_WHTN_ORDER_WB + 1, R_h, R_l, &Q_R,
1509 : L_FRAME16k / 4, win_flatten_4k_fx, 0, 1 );
1510 :
1511 : /* Ensure R[0] isn't zero when entering Levinson Durbin */
1512 13946 : R_l[0] = s_max( R_l[0], 1 );
1513 13946 : move16();
1514 41838 : FOR( i = 1; i <= LPC_WHTN_ORDER_WB; i++ )
1515 : {
1516 27892 : L_tmp = Mpy_32( R_h[i], R_l[i], wac_h[i - 1], wac_l[i - 1] );
1517 27892 : L_Extract( L_tmp, &R_h[i], &R_l[i] );
1518 : }
1519 :
1520 13946 : E_LPC_lev_dur( R_h, R_l, lpc_whtn, LepsP, LPC_WHTN_ORDER_WB, NULL );
1521 :
1522 13946 : Copy_Scale_sig( lpc_whtn, lpc_whtn, LPC_WHTN_ORDER_WB + 1, sub( norm_s( lpc_whtn[0] ), 2 ) );
1523 :
1524 13946 : fir_fx( exc4k, lpc_whtn, exc4kWhtnd, wht_fil_mem, L_FRAME16k / 4,
1525 : LPC_WHTN_ORDER_WB, 0, 3 );
1526 :
1527 : /* Ensure pow1 is greater than zero when computing normalization */
1528 13946 : max_val = 0;
1529 13946 : move16();
1530 1129626 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1531 : {
1532 1115680 : excTmp2[i] = abs_s( exc4kWhtnd[i] );
1533 1115680 : move16(); /* Q_bwe_exc */
1534 1115680 : max_val = s_max( max_val, excTmp2[i] );
1535 1115680 : move16();
1536 : }
1537 :
1538 13946 : IF( max_val == 0 )
1539 : {
1540 0 : pow1 = 1;
1541 0 : move16();
1542 0 : n1 = 0;
1543 0 : move16();
1544 : }
1545 : ELSE
1546 : {
1547 13946 : n1 = norm_s( max_val );
1548 1129626 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1549 : {
1550 : #ifdef ISSUE_1836_replace_overflow_libcom
1551 1115680 : excTmp2_frac[i] = shl( excTmp2[i], n1 ); // Q_bwe_exc + n1 // saturation not possible
1552 : #else
1553 : excTmp2_frac[i] = shl_o( excTmp2[i], n1, &Overflow ); // Q_bwe_exc + n1
1554 : #endif
1555 1115680 : move16(); /* Q14 */
1556 : }
1557 13946 : n1 = sub( sub( 14, n1 ), Q_bwe_exc );
1558 13946 : pow1 = 1;
1559 13946 : move32();
1560 : #ifdef ISSUE_1836_replace_overflow_libcom
1561 1129626 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1562 : {
1563 1115680 : L_tmp = L_mult( excTmp2_frac[i], excTmp2_frac[i] ); /* Q29 */ // saturation not possible: excTmp2_frac[i] < MIN_16
1564 1115680 : pow1 = L_add_sat( pow1, L_shr( L_tmp, 10 ) ); /* Q22 */
1565 : }
1566 : #else
1567 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1568 : {
1569 : L_tmp = L_mult_o( excTmp2_frac[i], excTmp2_frac[i], &Overflow ); /* Q29 */
1570 : pow1 = L_add_o( pow1, L_shr( L_tmp, 10 ), &Overflow ); /* Q22 */
1571 : }
1572 : #endif
1573 : }
1574 :
1575 1129626 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1576 : {
1577 : #ifdef ISSUE_1836_replace_overflow_libcom
1578 1115680 : excNoisyEnv[i] = L_add_sat( *mem_csfilt, L_mult( csfilt_num2[0], excTmp2[i] ) ); // L_mult: sat not poosible, excTmp2 > 0
1579 : #else
1580 : excNoisyEnv[i] = L_add_o( *mem_csfilt, L_mult_o( csfilt_num2[0], excTmp2[i], &Overflow ), &Overflow );
1581 : #endif
1582 1115680 : move32(); /* Q_bwe_exc+16 */
1583 1115680 : *mem_csfilt = Mult_32_16( excNoisyEnv[i], neg_csfilt_den2[1] );
1584 1115680 : move32(); /* Q_bwe_exc+16 */
1585 : }
1586 :
1587 13946 : create_random_vector_fx( exc4k, L_FRAME16k / 4, bwe_seed );
1588 :
1589 : /* Ensure pow22 is greater than zero when computing normalization */
1590 13946 : Lmax = 0;
1591 1129626 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1592 : {
1593 1115680 : exc4k_32[i] = Mult_32_16( excNoisyEnv[i], exc4k[i] );
1594 1115680 : move32(); /* Q_bwe_exc+6 */
1595 1115680 : Lmax = L_max( Lmax, L_abs( exc4k_32[i] ) );
1596 : }
1597 :
1598 13946 : IF( Lmax == 0 )
1599 : {
1600 0 : pow22 = 1;
1601 0 : move16();
1602 0 : n2 = 0;
1603 0 : move16();
1604 0 : set16_fx( exc4k_frac, 0, L_FRAME16k / 4 );
1605 : }
1606 : ELSE
1607 : {
1608 13946 : n2 = norm_l( Lmax );
1609 1129626 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1610 : {
1611 : #ifdef ISSUE_1836_replace_overflow_libcom
1612 1115680 : exc4k_frac[i] = extract_h( L_shl( exc4k_32[i], n2 ) ); /* Q(14-n2) */
1613 : #else
1614 : exc4k_frac[i] = extract_h( L_shl_o( exc4k_32[i], n2, &Overflow ) ); /* Q(14-n2) */
1615 : #endif
1616 1115680 : move16();
1617 : }
1618 13946 : n2 = 30 - n2 - ( Q_bwe_exc + 6 );
1619 13946 : pow22 = 1;
1620 13946 : move32();
1621 1129626 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1622 : {
1623 : #ifdef ISSUE_1836_replace_overflow_libcom
1624 1115680 : L_tmp = L_mult_sat( exc4k_frac[i], exc4k_frac[i] ); /* Q29 */
1625 1115680 : pow22 = L_add( pow22, L_shr( L_tmp, 10 ) ); /* Q22 */
1626 : #else
1627 : L_tmp = L_mult_o( exc4k_frac[i], exc4k_frac[i], &Overflow ); /* Q29 */
1628 : pow22 = L_add_o( pow22, L_shr( L_tmp, 10 ), &Overflow ); /* Q22 */
1629 : #endif
1630 : }
1631 : }
1632 :
1633 13946 : test();
1634 13946 : test();
1635 13946 : IF( EQ_16( coder_type, UNVOICED ) || ( igf_flag != 0 && LT_16( avg_voice_fac, 6654 /* 0.2 in Q15 */ ) ) )
1636 : {
1637 383 : L_tmp = root_a_over_b_fx( pow1, sub( 19, shl( n1, 1 ) ), pow22, sub( 19, shl( n2, 1 ) ), &exp );
1638 : #ifdef ISSUE_1836_replace_overflow_libcom
1639 383 : scale = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /*Q15 */
1640 : #else
1641 : scale = round_fx_o( L_shl_o( L_tmp, exp, &Overflow ), &Overflow ); /*Q15 */
1642 : #endif
1643 383 : sc = sub( add( n2, Q_bwe_exc ), 14 );
1644 31023 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1645 : {
1646 : #ifdef ISSUE_1836_replace_overflow_libcom
1647 30640 : exc4kWhtnd[i] = round_fx_sat( L_shl_sat( L_mult_sat( exc4k_frac[i], scale ), sc ) ); /* Q_bwe_exc+n2-10+16+ Q_bwe_exc + n2 -14 -16 = //Q_bwe_exc */
1648 : #else
1649 : exc4kWhtnd[i] = round_fx_o( L_shl_o( L_mult_o( exc4k_frac[i], scale, &Overflow ), sc, &Overflow ), &Overflow ); /* Q_bwe_exc+n2-10+16+ Q_bwe_exc + n2 -14 -16 = //Q_bwe_exc */
1650 : #endif
1651 30640 : move16();
1652 : }
1653 : }
1654 : ELSE
1655 : {
1656 13563 : sc = sub( add( n2, Q_bwe_exc ), 14 ); /* Q_bwe_exc+n2-14*/
1657 :
1658 13563 : k = 0;
1659 67815 : FOR( i = 0; i < 4; i++ )
1660 : {
1661 54252 : test();
1662 54252 : IF( igf_flag != 0 && EQ_16( coder_type, VOICED ) )
1663 : {
1664 : /*tmp_vfac = 2*voice_factors[i];
1665 : tmp_vfac = min(1, tmp_vfac);*/
1666 : #ifdef ISSUE_1836_replace_overflow_libcom
1667 0 : tmp_vfac = shl_sat( voice_factors[i], 1 );
1668 : #else
1669 : tmp_vfac = shl_o( voice_factors[i], 1, &Overflow );
1670 : #endif
1671 : }
1672 : ELSE
1673 : {
1674 54252 : tmp_vfac = voice_factors[i];
1675 54252 : move16();
1676 : }
1677 :
1678 54252 : Ltemp1 = root_a_fx( L_deposit_h( tmp_vfac ), 31, &exp );
1679 : #ifdef ISSUE_1836_replace_overflow_libcom
1680 54252 : temp1 = round_fx_sat( L_shl_sat( Ltemp1, exp ) ); /* Q15 */
1681 54252 : L_tmp = Mult_32_16( pow1, sub( 32767, tmp_vfac ) ); /* Q22*/
1682 54252 : Ltemp2 = root_a_over_b_fx( L_tmp, sub( 19, shl( n1, 1 ) ), pow22, sub( 19, shl( n2, 1 ) ), &exp );
1683 54252 : temp2 = round_fx_sat( L_shl_sat( Ltemp2, exp ) ); /* Q15 */
1684 1139292 : FOR( j = 0; j < L_FRAME16k / 16; j++ )
1685 : {
1686 1085040 : L_tmp = L_mult_sat( temp1, exc4kWhtnd[k] ); /* Q(16+Q_bwe_exc) */
1687 1085040 : L_tmp = L_add_sat( L_tmp, L_shl_sat( L_mult_sat( temp2, exc4k_frac[k] ), sc ) ); /* Q(16+Q_bwe_exc) */
1688 1085040 : exc4kWhtnd[k] = round_fx_sat( L_tmp ); /* Q_bwe_exc */
1689 1085040 : move16();
1690 1085040 : k++;
1691 : }
1692 : #else
1693 : temp1 = round_fx_o( L_shl_o( Ltemp1, exp, &Overflow ), &Overflow ); /* Q15 */
1694 : L_tmp = Mult_32_16( pow1, sub( 32767, tmp_vfac ) ); /* Q22*/
1695 : Ltemp2 = root_a_over_b_fx( L_tmp, sub( 19, shl( n1, 1 ) ), pow22, sub( 19, shl( n2, 1 ) ), &exp );
1696 : temp2 = round_fx_o( L_shl_o( Ltemp2, exp, &Overflow ), &Overflow ); /* Q15 */
1697 : FOR( j = 0; j < L_FRAME16k / 16; j++ )
1698 : {
1699 : L_tmp = L_mult_o( temp1, exc4kWhtnd[k], &Overflow ); /* Q(16+Q_bwe_exc) */
1700 : L_tmp = L_add_o( L_tmp, L_shl_o( L_mult_o( temp2, exc4k_frac[k], &Overflow ), sc, &Overflow ), &Overflow ); /* Q(16+Q_bwe_exc) */
1701 : exc4kWhtnd[k] = round_fx_o( L_tmp, &Overflow ); /* Q_bwe_exc */
1702 : move16();
1703 : k++;
1704 : }
1705 : #endif
1706 : }
1707 : }
1708 : }
1709 :
1710 14814 : Scale_sig( state_lpc_syn, LPC_SHB_ORDER, -Q2 ); /* Q(Q_bwe_exc) -> Q(Q_bwe_exc - 2) */
1711 :
1712 14814 : Syn_filt_s( Q2, lpc_shb, LPC_SHB_ORDER_WB, exc4kWhtnd, excSHB, L_FRAME16k / 4, state_lpc_syn, 1 );
1713 :
1714 14814 : Scale_sig( state_lpc_syn, LPC_SHB_ORDER, Q2 ); /* Q(Q_bwe_exc - 2) -> Q(Q_bwe_exc) */
1715 14814 : Scale_sig( excSHB, L_FRAME16k / 4, Q2 ); /* Q(Q_bwe_exc - 2) -> Q(Q_bwe_exc) */
1716 :
1717 14814 : return;
1718 : }
1719 :
1720 0 : void GenShapedWBExcitation_fx(
1721 : Word16 *excSHB, /* o : synthesized shaped shb exctiation Q(Q_bwe_exc) */
1722 : const Word16 *lpc_shb, /* i : lpc coefficients Q12 */
1723 : Word16 *exc4kWhtnd, /* o : whitened synthesized shb excitation Q(Q_bwe_exc) */
1724 : Word32 *mem_csfilt, /* i/o : memory Q(Q_bwe_exc+16) */
1725 : Word16 *mem_genSHBexc_filt_down1, /* i/o : memory Q(Q_bwe_exc) */
1726 : Word16 *mem_genSHBexc_filt_down2, /* i/o : memory Q(Q_bwe_exc) */
1727 : Word16 *mem_genSHBexc_filt_down3, /* i/o : memory Q(Q_bwe_exc) */
1728 : Word16 *state_lpc_syn, /* i/o : memory Q(Q_bwe_exc) */
1729 : const Word16 coder_type, /* i : coding type */
1730 : const Word16 *bwe_exc_extended, /* i : bwidth extended exciatation Q(Q_bwe_exc) */
1731 : const Word16 Q_bwe_exc, /* i : Q for memories */
1732 : Word16 bwe_seed[], /* i/o : random number generator seed */
1733 : const Word16 voice_factors[], /* i : voicing factor Q15 */
1734 : const Word16 uv_flag, /* i : unvoiced flag */
1735 : const Word16 igf_flag )
1736 : {
1737 : Word16 i, j, k;
1738 : Word16 wht_fil_mem[LPC_WHTN_ORDER_WB];
1739 : Word16 lpc_whtn[LPC_WHTN_ORDER_WB + 1];
1740 : Word16 R_h[LPC_WHTN_ORDER_WB + 2], R_l[LPC_WHTN_ORDER_WB + 2];
1741 : Word16 Q_R;
1742 : Word16 excTmp[L_FRAME16k];
1743 : Word16 excTmp2[L_FRAME16k / 4];
1744 : Word16 excTmp2_frac[L_FRAME16k / 4];
1745 : Word16 exc4k[L_FRAME16k / 4];
1746 : Word16 exc4k_frac[L_FRAME16k / 4];
1747 : Word32 exc4k_32[L_FRAME16k / 4];
1748 : Word32 pow1, pow22;
1749 : Word16 scale;
1750 : Word32 excNoisyEnv[L_FRAME16k / 4];
1751 0 : Word16 csfilt_num2[1] = { 1638 }; /* Q15*/
1752 0 : Word16 neg_csfilt_den2[2] = { -32768, 31457 }; /* Q15 */
1753 : Word32 L_tmp, Ltemp1, Ltemp2;
1754 : Word16 temp1, temp2, exp;
1755 : Word32 Lmax;
1756 : Word16 max_val, n1, n2, sc;
1757 : Word32 LepsP[LPC_WHTN_ORDER_WB + 1];
1758 : Word16 tmp_vfac;
1759 : Word16 avg_voice_fac;
1760 : #ifndef ISSUE_1836_replace_overflow_libcom
1761 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
1762 : Flag Overflow = 0;
1763 : move32();
1764 : #endif
1765 : #endif
1766 0 : move16();
1767 0 : move16();
1768 0 : move16();
1769 :
1770 : /*0.25f*sum_f(voice_factors, NB_SUBFR)*/
1771 0 : L_tmp = L_mult( voice_factors[0], 8192 /*0.25 in Q15 */ );
1772 0 : FOR( i = 1; i < NB_SUBFR; i++ )
1773 : {
1774 0 : L_tmp = L_mac( L_tmp, voice_factors[i], 8192 /*0.25 in Q15 */ );
1775 : }
1776 0 : avg_voice_fac = round_fx( L_tmp );
1777 :
1778 0 : test();
1779 0 : test();
1780 0 : test();
1781 0 : test();
1782 0 : IF( igf_flag != 0 && ( EQ_16( coder_type, VOICED ) || GT_16( avg_voice_fac, 11469 /* 0.35 in Q15 */ ) ) ) /*Q15 -> 0.35f*/
1783 : {
1784 0 : csfilt_num2[0] = 6554;
1785 0 : move16(); /*Q15 -> 0.2f*/
1786 0 : neg_csfilt_den2[1] = 26214;
1787 0 : move16(); /*Q15 -> 0.8f*/
1788 : }
1789 0 : ELSE IF( igf_flag != 0 && ( EQ_16( coder_type, UNVOICED ) || LT_16( avg_voice_fac, 6654 /* 0.2 in Q15 */ ) ) ) /*Q15 -> 0.2f*/
1790 : {
1791 0 : csfilt_num2[0] = 328;
1792 0 : move16(); /*Q15 -> 0.01f*/
1793 0 : neg_csfilt_den2[1] = 32440;
1794 0 : move16(); /*Q15 -> 0.99f*/
1795 : }
1796 0 : set16_fx( wht_fil_mem, 0, LPC_WHTN_ORDER_WB );
1797 0 : Decimate_allpass_steep_fx( bwe_exc_extended, mem_genSHBexc_filt_down1, L_FRAME32k, excTmp );
1798 0 : flip_spectrum_and_decimby4_fx( excTmp, exc4k, L_FRAME16k, mem_genSHBexc_filt_down2, mem_genSHBexc_filt_down3, 0 );
1799 :
1800 0 : IF( uv_flag )
1801 : {
1802 0 : create_random_vector_fx( exc4kWhtnd, L_FRAME16k / 4, bwe_seed );
1803 0 : IF( LT_16( Q_bwe_exc, 5 ) )
1804 : {
1805 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1806 : {
1807 0 : exc4kWhtnd[i] = shl_r( exc4kWhtnd[i], sub( Q_bwe_exc, 5 ) ); /*Q(Q_bwe_exc)/Q5(if Q_bwe_exc > 5) */
1808 0 : move16();
1809 : }
1810 : }
1811 : }
1812 : ELSE
1813 : {
1814 0 : autocorr_fx( exc4k, LPC_WHTN_ORDER_WB + 1, R_h, R_l, &Q_R,
1815 : L_FRAME16k / 4, win_flatten_4k_fx, 0, 1 );
1816 :
1817 : /* Ensure R[0] isn't zero when entering Levinson Durbin */
1818 0 : R_l[0] = s_max( R_l[0], 1 );
1819 0 : move16();
1820 0 : FOR( i = 1; i <= LPC_WHTN_ORDER_WB; i++ )
1821 : {
1822 0 : L_tmp = Mpy_32( R_h[i], R_l[i], wac_h[i - 1], wac_l[i - 1] );
1823 0 : L_Extract( L_tmp, &R_h[i], &R_l[i] );
1824 : }
1825 :
1826 0 : E_LPC_lev_dur( R_h, R_l, lpc_whtn, LepsP, LPC_WHTN_ORDER_WB, NULL );
1827 :
1828 0 : Copy_Scale_sig( lpc_whtn, lpc_whtn, LPC_WHTN_ORDER_WB + 1, sub( norm_s( lpc_whtn[0] ), 2 ) );
1829 :
1830 0 : fir_fx( exc4k, lpc_whtn, exc4kWhtnd, wht_fil_mem, L_FRAME16k / 4,
1831 : LPC_WHTN_ORDER_WB, 0, 3 );
1832 :
1833 : /* Ensure pow1 is greater than zero when computing normalization */
1834 0 : max_val = 0;
1835 0 : move16();
1836 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1837 : {
1838 0 : excTmp2[i] = abs_s( exc4kWhtnd[i] );
1839 0 : move16(); /* Q_bwe_exc */
1840 0 : max_val = s_max( max_val, excTmp2[i] );
1841 0 : move16();
1842 : }
1843 :
1844 0 : IF( max_val == 0 )
1845 : {
1846 0 : pow1 = 1;
1847 0 : move16();
1848 0 : n1 = 0;
1849 0 : move16();
1850 : }
1851 : ELSE
1852 : {
1853 0 : n1 = norm_s( max_val );
1854 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1855 : {
1856 : #ifdef ISSUE_1836_replace_overflow_libcom
1857 0 : excTmp2_frac[i] = shl( excTmp2[i], n1 );
1858 : #else
1859 : excTmp2_frac[i] = shl_o( excTmp2[i], n1, &Overflow );
1860 : #endif
1861 0 : move16(); /* Q14 */
1862 : }
1863 0 : n1 = sub( sub( 14, n1 ), Q_bwe_exc );
1864 0 : pow1 = 1;
1865 0 : move32();
1866 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1867 : {
1868 : #ifdef ISSUE_1836_replace_overflow_libcom
1869 0 : L_tmp = L_mult_sat( excTmp2_frac[i], excTmp2_frac[i] ); /* Q29 */
1870 0 : pow1 = L_add_sat( pow1, L_shr( L_tmp, 7 ) ); /* Q22 */
1871 : #else
1872 : L_tmp = L_mult_o( excTmp2_frac[i], excTmp2_frac[i], &Overflow ); /* Q29 */
1873 : pow1 = L_add_o( pow1, L_shr( L_tmp, 7 ), &Overflow ); /* Q22 */
1874 : #endif
1875 : }
1876 : }
1877 :
1878 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1879 : {
1880 : #ifdef ISSUE_1836_replace_overflow_libcom
1881 0 : excNoisyEnv[i] = L_add_sat( *mem_csfilt, L_mult( csfilt_num2[0], excTmp2[i] ) );
1882 : #else
1883 : excNoisyEnv[i] = L_add_o( *mem_csfilt, L_mult_o( csfilt_num2[0], excTmp2[i], &Overflow ), &Overflow );
1884 : #endif
1885 0 : move32(); /* Q_bwe_exc+16 */
1886 0 : *mem_csfilt = Mpy_32_16_1( excNoisyEnv[i], neg_csfilt_den2[1] );
1887 0 : move32(); /* Q_bwe_exc+16 */
1888 : }
1889 :
1890 0 : create_random_vector_fx( exc4k, L_FRAME16k / 4, bwe_seed );
1891 :
1892 : /* Ensure pow22 is greater than zero when computing normalization */
1893 0 : Lmax = 0;
1894 0 : move32();
1895 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1896 : {
1897 0 : exc4k_32[i] = Mpy_32_16_1( excNoisyEnv[i], exc4k[i] );
1898 0 : move32(); /* Q_bwe_exc+6 */
1899 0 : Lmax = L_max( Lmax, L_abs( exc4k_32[i] ) );
1900 : }
1901 :
1902 0 : IF( Lmax == 0 )
1903 : {
1904 0 : pow22 = 1;
1905 0 : move16();
1906 0 : n2 = 0;
1907 0 : move16();
1908 0 : set16_fx( exc4k_frac, 0, L_FRAME16k / 4 );
1909 : }
1910 : ELSE
1911 : {
1912 0 : n2 = norm_l( Lmax );
1913 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1914 : {
1915 : #ifdef ISSUE_1836_replace_overflow_libcom
1916 0 : exc4k_frac[i] = extract_h( L_shl( exc4k_32[i], n2 ) ); /* Q(14-n2) */
1917 : #else
1918 : exc4k_frac[i] = extract_h( L_shl_o( exc4k_32[i], n2, &Overflow ) ); /* Q(14-n2) */
1919 : #endif
1920 0 : move16();
1921 : }
1922 0 : n2 = sub( sub( 30, n2 ), add( Q_bwe_exc, 6 ) );
1923 0 : pow22 = 1;
1924 0 : move32();
1925 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1926 : {
1927 : #ifdef ISSUE_1836_replace_overflow_libcom
1928 0 : L_tmp = L_mult_sat( exc4k_frac[i], exc4k_frac[i] ); /* Q29 */
1929 0 : pow22 = L_add( pow22, L_shr( L_tmp, 7 ) ); /* Q22 */
1930 : #else
1931 : L_tmp = L_mult_o( exc4k_frac[i], exc4k_frac[i], &Overflow ); /* Q29 */
1932 : pow22 = L_add_o( pow22, L_shr( L_tmp, 7 ), &Overflow ); /* Q22 */
1933 : #endif
1934 : }
1935 : }
1936 :
1937 0 : test();
1938 0 : test();
1939 0 : IF( EQ_16( coder_type, UNVOICED ) || ( igf_flag != 0 && LT_16( avg_voice_fac, 6654 /*0.2 in Q15 */ ) ) )
1940 : {
1941 0 : L_tmp = root_a_over_b_fx( pow1, sub( 22, shl( n1, 1 ) ), pow22, sub( 22, shl( n2, 1 ) ), &exp );
1942 : #ifdef ISSUE_1836_replace_overflow_libcom
1943 0 : scale = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /*Q15 */
1944 0 : sc = sub( add( n2, Q_bwe_exc ), 14 );
1945 0 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1946 : {
1947 0 : exc4kWhtnd[i] = round_fx_sat( L_shl_sat( L_mult_sat( exc4k_frac[i], scale ), sc ) ); /* Q_bwe_exc+n2-10+16+ Q_bwe_exc + n2 -14 -16 = //Q_bwe_exc */
1948 0 : move16();
1949 : }
1950 : #else
1951 : scale = round_fx_o( L_shl_o( L_tmp, exp, &Overflow ), &Overflow ); /*Q15 */
1952 : sc = sub( add( n2, Q_bwe_exc ), 14 );
1953 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
1954 : {
1955 : exc4kWhtnd[i] = round_fx_o( L_shl_o( L_mult_o( exc4k_frac[i], scale, &Overflow ), sc, &Overflow ), &Overflow ); /* Q_bwe_exc+n2-10+16+ Q_bwe_exc + n2 -14 -16 = //Q_bwe_exc */
1956 : move16();
1957 : }
1958 : #endif
1959 : }
1960 : ELSE
1961 : {
1962 0 : sc = sub( add( n2, Q_bwe_exc ), 14 ); /* Q_bwe_exc+n2-14*/
1963 :
1964 0 : k = 0;
1965 0 : move16();
1966 0 : FOR( i = 0; i < 4; i++ )
1967 : {
1968 0 : test();
1969 0 : IF( igf_flag != 0 && EQ_16( coder_type, VOICED ) )
1970 : {
1971 : /*tmp_vfac = 2*voice_factors[i];
1972 : tmp_vfac = min(1, tmp_vfac);*/
1973 : #ifdef ISSUE_1836_replace_overflow_libcom
1974 0 : tmp_vfac = shl_sat( voice_factors[i], 1 );
1975 : #else
1976 : tmp_vfac = shl_o( voice_factors[i], 1, &Overflow );
1977 : #endif
1978 : }
1979 : ELSE
1980 : {
1981 0 : tmp_vfac = voice_factors[i];
1982 0 : move16();
1983 : }
1984 :
1985 0 : Ltemp1 = root_a_fx( L_deposit_h( tmp_vfac ), 31, &exp );
1986 : #ifdef ISSUE_1836_replace_overflow_libcom
1987 0 : temp1 = round_fx_sat( L_shl_sat( Ltemp1, exp ) ); /* Q15 */
1988 0 : L_tmp = Mpy_32_16_1( pow1, sub( 32767, tmp_vfac ) ); /* Q22*/
1989 0 : Ltemp2 = root_a_over_b_fx( L_tmp, sub( 22, shl( n1, 1 ) ), pow22, sub( 22, shl( n2, 1 ) ), &exp );
1990 0 : temp2 = round_fx_sat( L_shl_sat( Ltemp2, exp ) ); /* Q15 */
1991 0 : FOR( j = 0; j < L_FRAME16k / 16; j++ )
1992 : {
1993 0 : L_tmp = L_mult_sat( temp1, exc4kWhtnd[k] ); /* Q(16+Q_bwe_exc) */
1994 0 : L_tmp = L_add_sat( L_tmp, L_shl_sat( L_mult_sat( temp2, exc4k_frac[k] ), sc ) ); /* Q(16+Q_bwe_exc) */
1995 0 : exc4kWhtnd[k] = round_fx_sat( L_tmp ); /* Q_bwe_exc */
1996 0 : move16();
1997 0 : k = add( k, 1 );
1998 : }
1999 : #else
2000 : temp1 = round_fx_o( L_shl_o( Ltemp1, exp, &Overflow ), &Overflow ); /* Q15 */
2001 : L_tmp = Mpy_32_16_1( pow1, sub( 32767, tmp_vfac ) ); /* Q22*/
2002 : Ltemp2 = root_a_over_b_fx( L_tmp, sub( 22, shl( n1, 1 ) ), pow22, sub( 22, shl( n2, 1 ) ), &exp );
2003 : temp2 = round_fx_o( L_shl_o( Ltemp2, exp, &Overflow ), &Overflow ); /* Q15 */
2004 : FOR( j = 0; j < L_FRAME16k / 16; j++ )
2005 : {
2006 : L_tmp = L_mult_o( temp1, exc4kWhtnd[k], &Overflow ); /* Q(16+Q_bwe_exc) */
2007 : L_tmp = L_add_o( L_tmp, L_shl_o( L_mult_o( temp2, exc4k_frac[k], &Overflow ), sc, &Overflow ), &Overflow ); /* Q(16+Q_bwe_exc) */
2008 : exc4kWhtnd[k] = round_fx_o( L_tmp, &Overflow ); /* Q_bwe_exc */
2009 : move16();
2010 : k = add( k, 1 );
2011 : }
2012 : #endif
2013 : }
2014 : }
2015 : }
2016 :
2017 0 : Syn_filt_s( 0, lpc_shb, LPC_SHB_ORDER_WB, exc4kWhtnd, excSHB, L_FRAME16k / 4, state_lpc_syn, 1 );
2018 :
2019 :
2020 0 : return;
2021 : }
2022 :
2023 : /*-------------------------------------------------------------------*
2024 : * GenWBSynth()
2025 : *
2026 : * Generate 16 KHz sampled highband component from synthesized highband
2027 : *-------------------------------------------------------------------*/
2028 :
2029 7134 : void GenWBSynth_fx(
2030 : const Word16 *input_synspeech, /* i : input synthesized speech Qx*/
2031 : Word16 *shb_syn_speech_16k, /* o : output highband compnent Qx*/
2032 : Word16 *state_lsyn_filt_shb1, /* i/o: memory Qx*/
2033 : Word16 *state_lsyn_filt_shb2 /* i/o: memory Qx*/
2034 : )
2035 : {
2036 : Word16 speech_buf_16k1[L_FRAME16k], speech_buf_16k2[L_FRAME16k];
2037 : Word16 i, maxm, nor;
2038 : Word16 input_synspeech_temp[L_FRAME16k / 4];
2039 :
2040 7134 : maxm = 0;
2041 7134 : move16();
2042 577854 : FOR( i = 0; i < L_FRAME16k / 4; i++ )
2043 : {
2044 570720 : maxm = s_max( maxm, abs_s( input_synspeech[i] ) );
2045 : }
2046 49938 : FOR( i = 0; i < 2 * ALLPASSSECTIONS_STEEP; i++ )
2047 : {
2048 42804 : maxm = s_max( maxm, abs_s( state_lsyn_filt_shb1[i] ) );
2049 : }
2050 49938 : FOR( i = 0; i < 2 * ALLPASSSECTIONS_STEEP; i++ )
2051 : {
2052 42804 : maxm = s_max( maxm, abs_s( state_lsyn_filt_shb2[i] ) );
2053 : }
2054 :
2055 7134 : nor = s_max( sub( norm_s( maxm ), 3 ), 0 ); /* Headroom = 3 */
2056 7134 : IF( maxm == 0 )
2057 85 : nor = 15;
2058 7134 : move16();
2059 :
2060 7134 : Copy_Scale_sig( input_synspeech, input_synspeech_temp, L_FRAME16k / 4, nor );
2061 7134 : Scale_sig( state_lsyn_filt_shb1, 2 * ALLPASSSECTIONS_STEEP, nor );
2062 7134 : Scale_sig( state_lsyn_filt_shb2, 2 * ALLPASSSECTIONS_STEEP, nor );
2063 7134 : Interpolate_allpass_steep_fx( input_synspeech_temp, state_lsyn_filt_shb1, L_FRAME16k / 4, speech_buf_16k1 );
2064 7134 : Interpolate_allpass_steep_fx( speech_buf_16k1, state_lsyn_filt_shb2, L_FRAME16k / 2, speech_buf_16k2 );
2065 7134 : flip_spectrum_fx( speech_buf_16k2, shb_syn_speech_16k, L_FRAME16k );
2066 :
2067 7134 : Scale_sig( shb_syn_speech_16k, L_FRAME16k, negate( nor ) );
2068 7134 : Scale_sig( state_lsyn_filt_shb1, 2 * ALLPASSSECTIONS_STEEP, negate( nor ) );
2069 7134 : Scale_sig( state_lsyn_filt_shb2, 2 * ALLPASSSECTIONS_STEEP, negate( nor ) );
2070 :
2071 7134 : return;
2072 : }
2073 :
2074 :
2075 12843 : void find_td_envelope_fx(
2076 : const Word16 inp[], /* i : input signal Qx */
2077 : const Word16 len, /* i : length of the input signal */
2078 : const Word16 len_h, /* i : length of the MA filter */
2079 : Word16 mem_h[], /* i/o: memory of the MA filter, length len_h/2 Qx */
2080 : Word16 out[] /* o : td envelope of the input signal Qx */
2081 : )
2082 : {
2083 : Word16 k, K;
2084 : Word16 buf_in[L_FRAME16k + MAX_LEN_MA_FILTER], *p_in, *p_out, *p_prev, w;
2085 : Word16 tmp1, tmp2;
2086 :
2087 12843 : assert( len > 0 && len <= L_FRAME16k );
2088 :
2089 : // len_h is 20 at all calling locations
2090 12843 : K = 10; /* length of FIR filter memory = half of the total filter length */
2091 12843 : move16();
2092 12843 : w = 1639; /* 1 / 20 in Q15 */ /* MA filtering coefficient */
2093 12843 : move16();
2094 :
2095 : /* copy filter memory to the input buffer */
2096 12843 : IF( mem_h != NULL )
2097 : {
2098 4281 : Copy( mem_h, buf_in, K );
2099 : }
2100 : ELSE
2101 : {
2102 : /* no memory available, use the first len_h/2 samples as memory */
2103 8562 : p_in = buf_in;
2104 94182 : FOR( k = 0; k < K; k++ )
2105 : {
2106 85620 : *p_in++ = mult_r( abs_s( inp[k] ), w ); /* Qx */
2107 85620 : move16();
2108 : }
2109 : }
2110 :
2111 : /* take the absolute value of the input signal and copy it to the input buffer */
2112 : /* multiply each value by 1 / filter length */
2113 12843 : p_in = &buf_in[K];
2114 4122603 : FOR( k = 0; k < len; k++ )
2115 : {
2116 4109760 : *p_in++ = mult_r( abs_s( inp[k] ), w ); /* Qx */
2117 4109760 : move16();
2118 : }
2119 :
2120 : /* update filter memory from the end of the input buffer */
2121 12843 : IF( mem_h != NULL )
2122 : {
2123 4281 : Copy( &buf_in[len], mem_h, K );
2124 : }
2125 :
2126 : /* do MA filtering */
2127 12843 : out[0] = sum16_fx( buf_in, len_h );
2128 12843 : move16();
2129 12843 : p_out = &buf_in[0]; /* pointer to leaving sample */
2130 12843 : p_in = &buf_in[len_h]; /* pointer to entering sample*/
2131 3981330 : FOR( k = 1; k < len - K; k++ )
2132 : {
2133 3968487 : tmp1 = *p_out++;
2134 3968487 : move16();
2135 3968487 : tmp2 = *p_in++;
2136 3968487 : move16();
2137 3968487 : out[k] = add( sub( out[k - 1], tmp1 ), tmp2 ); /* Qx */
2138 3968487 : move16();
2139 : }
2140 :
2141 : /* use IIR filtering to extrapolate the last K samples */
2142 12843 : p_in = &buf_in[len - K];
2143 12843 : p_out = &out[len - K];
2144 12843 : p_prev = p_out - 1;
2145 141273 : FOR( k = 0; k < K; k++ )
2146 : {
2147 128430 : tmp1 = *p_in++;
2148 128430 : move16();
2149 128430 : tmp2 = *p_prev++;
2150 128430 : move16();
2151 128430 : *p_out++ = add( mult_r( 1638 /* 0.05f in Q15 */, ( tmp1 ) ), mult_r( 31130 /* 0.95f in Q15 */, ( tmp2 ) ) );
2152 128430 : move16();
2153 : }
2154 :
2155 12843 : return;
2156 : }
2157 :
2158 :
2159 : /*======================================================================================*/
2160 : /* FUNCTION : void GenShapedSHBExcitation_fx () */
2161 : /*--------------------------------------------------------------------------------------*/
2162 : /* PURPOSE : Synthesize spectrally shaped highband excitation signal */
2163 : /*--------------------------------------------------------------------------------------*/
2164 : /* INPUT ARGUMENTS : */
2165 : /* _(Word16) coder_type : coding type Q_bwe_exc */
2166 : /* _(Word16) bwidth : input signal bwidth Q0 */
2167 : /* _(Word16*) bwe_exc_extended :bwidth extended exciatation Q_bwe_exc */
2168 : /* _(Word16[]) voice_factors :voicing factors Q15 */
2169 : /* _(Word16*) lpc_shb :lpc coefficients Q12 */
2170 : /* _(Word16*) Q_bwe_exc :Q Format of bwe_exc_extended */
2171 : /* _(Word16) L_frame : Frame length - determines whether 12.8 or 16kHz core */
2172 : /* _(Word16) last_L_frame : last L_frame */
2173 : /*--------------------------------------------------------------------------------------*/
2174 : /* OUTPUT ARGUMENTS : */
2175 : /* _(Word16*)excSHB :synthesized shaped shb excitation Q_bwe_exc */
2176 : /* _(Word16*)White_exc16k :white excitation for the Fullband extension Q_bwe_exc */
2177 : /* _(Word16*)slope :slope +ve (high freq > low freq), -ve or neutral Q12 */
2178 : /*--------------------------------------------------------------------------------------*/
2179 : /* INPUT/OUTPUT ARGUMENTS : */
2180 : /* _(Word16*)mem_csfilt :memory */
2181 : /* _(Word16*)mem_genSHBexc_filt_down_shb :memory */
2182 : /* _(Word16*)state_lpc_syn :memory */
2183 : /* _(Word16[]) bwe_seed :random number generator seed */
2184 : /* _(Word16[]) lpf_14k_mem :memory */
2185 : /* _(Word32[])Hilbert_Mem :memory */
2186 : /*--------------------------------------------------------------------------------------*/
2187 : /* RETURN ARGUMENTS : */
2188 : /* _ None */
2189 : /*--------------------------------------------------------------------------------------*/
2190 : /* CALLED FROM : RX */
2191 : /*======================================================================================*/
2192 2706 : void GenShapedSHBExcitation_fx(
2193 : Word16 *excSHB, /* o : synthesized shaped shb excitation Q_bwe_exc*/
2194 : const Word16 *lpc_shb, /* i : lpc coefficients Q12*/
2195 : Word16 *White_exc16k_FB, /* o : white excitation for the Fullband extension Q_bwe_exc */
2196 : Word32 *mem_csfilt, /* i/o: memory */
2197 : Word16 *mem_genSHBexc_filt_down_shb, /* i/o: memory */
2198 : Word16 *state_lpc_syn, /* i/o: memory */
2199 : const Word16 coder_type, /* i : coding type */
2200 : const Word16 *bwe_exc_extended, /* i : bwidth extended excitation */
2201 : Word16 bwe_seed[], /* i/o: random number generator seed */
2202 : Word16 voice_factors[], /* i : voicing factor*/
2203 : const Word16 extl, /* i : extension layer */
2204 : Word16 *tbe_demph, /* i/o: de-emphasis memory */
2205 : Word16 *tbe_premph, /* i/o: pre-emphasis memory */
2206 : Word16 *lpc_shb_sf, /* i: LP coefficients */
2207 : const Word32 shb_ener_sf_32, /* i: input shb ener, Q31 */
2208 : Word16 *shb_res_gshape, /* i: input res gain shape, Q14 */
2209 : Word16 *shb_res,
2210 : Word16 *vf_ind,
2211 : const Word16 formant_fac, /* i : Formant sharpening factor [0..1] */
2212 : Word16 fb_state_lpc_syn[], /* i/o: memory */
2213 : Word16 *fb_tbe_demph, /* i/o: fb de-emphasis memory */
2214 : Word16 *Q_bwe_exc,
2215 : Word16 *Q_bwe_exc_fb,
2216 : const Word16 Q_shb,
2217 : Word16 n_mem2, /* i : n_mem2 scale factor to adjust 24.4/32kbps memories */
2218 : Word16 prev_Q_bwe_syn, /* i : st_fx->prev_Q_bwe_syn */
2219 : const Word32 bitrate,
2220 : const Word16 prev_bfi )
2221 : {
2222 : Word16 i, j, k;
2223 : Word16 wht_fil_mem[LPC_WHTN_ORDER];
2224 : Word16 lpc_whtn[LPC_WHTN_ORDER + 1];
2225 : Word16 R_h[LPC_WHTN_ORDER + 2]; /* Autocorrelations of windowed speech MSB */
2226 : Word16 R_l[LPC_WHTN_ORDER + 2]; /* Autocorrelations of windowed speech LSB */
2227 : Word16 Q_R;
2228 : Word32 LepsP[LPC_WHTN_ORDER + 1];
2229 : Word16 exc32k[L_FRAME32k], exc16k[L_FRAME16k];
2230 : Word32 pow1, pow22;
2231 : Word16 scale, temp1, temp2;
2232 :
2233 : Word16 excTmp2[L_FRAME16k];
2234 : Word16 *White_exc16k;
2235 : Word16 excNoisyEnv[L_FRAME16k];
2236 2706 : Word16 csfilt_num2[1] = { 6554 }; /*0.2 in Q15 */
2237 2706 : move16();
2238 2706 : Word16 neg_csfilt_den2[2] = { -32767, 26214 }; /* {1.0f, -0.8f} */
2239 2706 : move16();
2240 2706 : move16();
2241 : Word16 varEnvShape;
2242 2706 : Word16 fb_deemph_fac = 15729; /*0.48f in Q15 */
2243 2706 : move16();
2244 : Word16 exc16kWhtnd[L_FRAME16k];
2245 :
2246 : Word32 L_tmp;
2247 : Word16 vf_tmp;
2248 : Word16 tmp, exp, tmp2;
2249 : Word16 voiceFacEst[NB_SUBFR16k];
2250 : Word16 zero_mem[LPC_SHB_ORDER];
2251 : Word32 syn_shb_ener_sf[4];
2252 : Word16 tempSHB[80];
2253 : Word16 Q_pow1, Q_pow22;
2254 :
2255 : Word32 L_tmp2, L_tmp3, L_tmp4;
2256 : Word16 temp;
2257 :
2258 : Word16 White_exc16k_FB_temp[L_FRAME16k];
2259 : Word32 White_exc16k_32[L_FRAME16k];
2260 : Word16 Q_temp;
2261 : Word16 prev_Q_bwe_exc_fb;
2262 :
2263 2706 : set16_fx( zero_mem, 0, LPC_SHB_ORDER );
2264 2706 : set16_fx( wht_fil_mem, 0, LPC_WHTN_ORDER );
2265 :
2266 868626 : FOR( i = 0; i < L_FRAME32k; i = i + 2 )
2267 : {
2268 865920 : exc32k[i] = negate( bwe_exc_extended[i] );
2269 865920 : move16();
2270 865920 : exc32k[i + 1] = bwe_exc_extended[i + 1];
2271 865920 : move16();
2272 : }
2273 :
2274 : /* Decimate by 2 */
2275 2706 : Decimate_allpass_steep_fx( exc32k, mem_genSHBexc_filt_down_shb, 2 * L_FRAME16k, exc16k );
2276 : /* i: exc32k in Q_bwe_exc */
2277 : /* o: exc16k in Q_bwe_exc */
2278 :
2279 2706 : autocorr_fx( exc16k, LPC_WHTN_ORDER + 1, R_h, R_l, &Q_R, L_FRAME16k, win_flatten_fx, 0, 1 );
2280 : /* Ensure R[0] isn't zero when entering Levinson Durbin */
2281 2706 : R_l[0] = s_max( R_l[0], 1 );
2282 2706 : move16();
2283 13530 : FOR( i = 1; i <= LPC_WHTN_ORDER; i++ )
2284 : {
2285 10824 : L_tmp = Mpy_32( R_h[i], R_l[i], wac_h[i - 1], wac_l[i - 1] );
2286 10824 : L_Extract( L_tmp, &R_h[i], &R_l[i] );
2287 : }
2288 2706 : E_LPC_lev_dur( R_h, R_l, lpc_whtn, LepsP, LPC_WHTN_ORDER, NULL );
2289 2706 : Copy_Scale_sig( lpc_whtn, lpc_whtn, LPC_WHTN_ORDER + 1, sub( norm_s( lpc_whtn[0] ), 2 ) );
2290 2706 : fir_fx( exc16k, lpc_whtn, exc16kWhtnd, wht_fil_mem, L_FRAME16k, LPC_WHTN_ORDER, 0, 3 );
2291 :
2292 : /* i: exc16k in Q_bwe_exc */
2293 : /* o: exc16kWhtnd in Q_bwe_exc */
2294 2706 : IF( GE_32( bitrate, ACELP_24k40 ) )
2295 : {
2296 1224 : temp2 = 0;
2297 1224 : move16();
2298 6120 : FOR( j = 0; j < 4; j++ )
2299 : {
2300 4896 : temp1 = shb_res_gshape[j];
2301 4896 : move16();
2302 396576 : FOR( i = 0; i < 80; i++ )
2303 : {
2304 391680 : exc16kWhtnd[temp2 + i] = round_fx( L_shl( L_mult( exc16kWhtnd[temp2 + i], temp1 ), 1 ) );
2305 391680 : move16();
2306 : /* exc16kWhtnd in Q_bwe_exc, shb_res_gshape in Q14 */
2307 : }
2308 4896 : temp2 = add( temp2, 80 );
2309 : }
2310 : }
2311 :
2312 : /* Estimate pow1 associated with Low band nonlinear extended excitation */
2313 : /* pow1=0.00001f */
2314 2706 : tmp = sub( shl( *Q_bwe_exc, 1 ), 31 );
2315 2706 : pow1 = L_shl_sat( 21475l /*0.00001f Q31*/, tmp ); /* 0.00001f in 2*(Q_bwe_exc) */
2316 868626 : FOR( k = 0; k < L_FRAME16k; k++ )
2317 : {
2318 : /*excTmp2[k ] = (float)(fabs(exc16kWhtnd[k]));*/
2319 865920 : excTmp2[k] = abs_s( exc16kWhtnd[k] );
2320 865920 : move16();
2321 :
2322 : /* pow1 += exc16kWhtnd[k] * exc16kWhtnd[k]; */
2323 865920 : pow1 = L_mac0_sat( pow1, exc16kWhtnd[k], exc16kWhtnd[k] ); /* 2*Q_bwe_exc */
2324 : }
2325 2706 : Q_pow1 = shl( *Q_bwe_exc, 1 );
2326 :
2327 2706 : test();
2328 2706 : IF( ( LE_32( bitrate, ACELP_13k20 ) ) && ( GE_32( bitrate, ACELP_7k20 ) ) )
2329 : {
2330 : /* varEnvShape = mean_fx(voice_factors, 4); */
2331 : /* unroll the loop */
2332 1482 : L_tmp = L_mult( voice_factors[0], 8192 );
2333 1482 : L_tmp = L_mac( L_tmp, voice_factors[1], 8192 );
2334 1482 : L_tmp = L_mac( L_tmp, voice_factors[2], 8192 );
2335 1482 : varEnvShape = mac_r( L_tmp, voice_factors[3], 8192 ); /* varEnvShape in Q15 */
2336 : }
2337 : ELSE /* 16k core */
2338 : {
2339 : /* varEnvShape = mean_fx(voice_factors, 5); */
2340 : /* unroll the loop */
2341 1224 : L_tmp = L_mult( voice_factors[0], 6554 );
2342 1224 : L_tmp = L_mac( L_tmp, voice_factors[1], 6554 );
2343 1224 : L_tmp = L_mac( L_tmp, voice_factors[2], 6554 );
2344 1224 : L_tmp = L_mac( L_tmp, voice_factors[3], 6554 );
2345 1224 : varEnvShape = mac_r( L_tmp, voice_factors[4], 6554 ); /* varEnvShape in Q15 */
2346 : }
2347 :
2348 2706 : IF( EQ_16( extl, FB_TBE ) )
2349 : {
2350 : /*pow(varEnvShape,3) */
2351 0 : tmp = mult_r( varEnvShape, varEnvShape );
2352 0 : tmp = mult_r( tmp, varEnvShape );
2353 :
2354 : /* max_val((0.68f - (float)pow(varEnvShape, 3)), 0.48f); */
2355 0 : fb_deemph_fac = sub( 22282 /*0.68f Q15*/, tmp );
2356 0 : fb_deemph_fac = s_max( fb_deemph_fac, 15729 /*0.48f Q15*/ );
2357 : }
2358 :
2359 : /*varEnvShape = 1.09875f - 0.49875f * varEnvShape; */
2360 2706 : varEnvShape = msu_r( 1179773824l /*0.549375f Q31*/, 8172 /*0.249375f Q15*/, varEnvShape );
2361 :
2362 : /*varEnvShape = min( max_val(varEnvShape, 0.6f), 0.999f); */
2363 2706 : varEnvShape = s_max( varEnvShape, 9830 /*0.3f Q15*/ );
2364 2706 : varEnvShape = s_min( varEnvShape, 16368 /*0.4995f Q15*/ );
2365 2706 : varEnvShape = shl( varEnvShape, 1 );
2366 2706 : csfilt_num2[0] = sub( MAX_16, varEnvShape );
2367 2706 : move16();
2368 2706 : neg_csfilt_den2[1] = varEnvShape;
2369 2706 : move16();
2370 :
2371 2706 : test();
2372 2706 : test();
2373 2706 : test();
2374 2706 : IF( *mem_csfilt == 0 && ( ( EQ_32( bitrate, ACELP_9k60 ) ) || ( EQ_32( bitrate, ACELP_16k40 ) ) || ( EQ_32( bitrate, ACELP_24k40 ) ) ) )
2375 : {
2376 : /* pre-init smoothing filter to avoid energy drop outs */
2377 58 : L_tmp = L_mult( excTmp2[0], 1638 );
2378 1160 : FOR( i = 1; i < L_SUBFR16k / 4; i++ )
2379 : {
2380 1102 : L_tmp = L_mac( L_tmp, excTmp2[i], 1638 ); /*1638 = 1/20 in Q15*/
2381 : }
2382 : /*L_tmp = sum(excTmp2, L_SUBFR16k/4)*(1/20) where L_SUBFR16k/4 =20 */
2383 :
2384 : /* don't apply for FB in case the FB start-frame was potentially lost - White_exc16k is very sensitive to enery mismatch between enc - dec */
2385 : /* rather stick to the more conservative approach, to avoid potential clippings */
2386 58 : test();
2387 58 : IF( !( prev_bfi && EQ_16( extl, FB_TBE ) ) )
2388 : {
2389 : /* use weak smoothing for 1st frame after switching to make filter recover more quickly */
2390 58 : varEnvShape = 26214 /*0.8f Q15*/;
2391 58 : move16();
2392 58 : csfilt_num2[0] = sub( MAX_16, varEnvShape );
2393 58 : move16();
2394 58 : neg_csfilt_den2[1] = varEnvShape;
2395 58 : move16();
2396 : }
2397 :
2398 58 : *mem_csfilt = Mult_32_16( L_tmp, varEnvShape );
2399 58 : move32();
2400 : }
2401 : {
2402 : /* Track the low band envelope */
2403 2706 : L_tmp = *mem_csfilt;
2404 2706 : move32();
2405 868626 : FOR( i = 0; i < L_FRAME16k; i++ )
2406 : {
2407 865920 : excNoisyEnv[i] = mac_r( L_tmp, csfilt_num2[0], excTmp2[i] );
2408 865920 : move16();
2409 : /* excNoisyEnv : Q_bwe_exc,
2410 : *mem_csfilt: Q_bwe_exc+16, excTmp2: Q_bwe_exc, csfilt_num2[0] Q15 */
2411 865920 : L_tmp = L_mult( excNoisyEnv[i], neg_csfilt_den2[1] ); /* Q_bwe_exc+16 */
2412 : }
2413 2706 : *mem_csfilt = L_tmp;
2414 2706 : move32();
2415 : }
2416 : {
2417 : /* create a random excitation - Reuse exc16k memory */
2418 2706 : White_exc16k = exc16k;
2419 2706 : create_random_vector_fx( White_exc16k, L_FRAME, bwe_seed );
2420 2706 : create_random_vector_fx( White_exc16k + L_FRAME, L_FRAME16k - L_FRAME, bwe_seed );
2421 :
2422 2706 : L_tmp = L_deposit_l( 0 );
2423 2706 : tmp = add( *Q_bwe_exc, 1 );
2424 868626 : FOR( k = 0; k < L_FRAME16k; k++ )
2425 : {
2426 865920 : L_tmp4 = L_shl_sat( L_deposit_l( White_exc16k[k] ), tmp );
2427 865920 : if ( excNoisyEnv[k] != 0 )
2428 : {
2429 863970 : L_tmp4 = L_mult( excNoisyEnv[k], White_exc16k[k] ); /* (Q_bwe_exc) +5 +1*/
2430 : }
2431 865920 : White_exc16k_32[k] = L_tmp4;
2432 865920 : move32();
2433 865920 : L_tmp = L_max( L_tmp, L_abs( White_exc16k_32[k] ) );
2434 : }
2435 2706 : Q_temp = norm_l( L_tmp );
2436 2706 : if ( L_tmp == 0 )
2437 : {
2438 0 : Q_temp = 31;
2439 0 : move16();
2440 : }
2441 : /*Copy_Scale_sig( White_exc16k, White_exc16k, L_FRAME16k, sub(NOISE_QFAC, 5) );)*/
2442 : /* White_exc16k in Q6 */
2443 :
2444 : /* calculate pow22 */
2445 : /* pow22=0.00001f */
2446 2706 : tmp = sub( shl( sub( *Q_bwe_exc, NOISE_QADJ ), 1 ), 31 );
2447 2706 : pow22 = L_shl( 21475l /*0.00001f Q31*/, tmp ); /* 0.00001f in 2*(Q_bwe_exc-NOISE_QADJ) */
2448 2706 : tmp = sub( NOISE_QFAC, 5 );
2449 868626 : FOR( k = 0; k < L_FRAME16k; k++ )
2450 : {
2451 : /* White_exc16k[k] *= excNoisyEnv[k]; */
2452 865920 : White_exc16k[k] = mult_r( excNoisyEnv[k], shl( White_exc16k[k], tmp ) );
2453 865920 : move16();
2454 : /* i: excNoisyEnv in (Q_bwe_exc) */
2455 : /* i: White_exc16k in Q6 */
2456 : /* o: White_exc16k in (Q_bwe_exc-NOISE_QADJ) */
2457 : /* pow22 += White_exc16k[k] * White_exc16k[k]; */
2458 865920 : pow22 = L_mac0_sat( pow22, White_exc16k[k], White_exc16k[k] ); /* 2*(Q_bwe_exc-NOISE_QADJ)*/
2459 : }
2460 : /*Q_pow22 = sub( shl(*Q_bwe_exc,1), 18 );*/
2461 2706 : Q_pow22 = shl( sub( *Q_bwe_exc, NOISE_QADJ ), 1 );
2462 : }
2463 :
2464 2706 : IF( GE_32( bitrate, ACELP_24k40 ) )
2465 : {
2466 1224 : IF( EQ_16( *vf_ind, 20 ) ) /* encoder side */
2467 : {
2468 : {
2469 612 : Estimate_mix_factors_fx( shb_res, Q_shb, exc16kWhtnd, *Q_bwe_exc, White_exc16k,
2470 612 : ( *Q_bwe_exc - NOISE_QADJ ), pow1, Q_pow1, pow22, Q_pow22, voiceFacEst, vf_ind );
2471 612 : tmp = voiceFacEst[0];
2472 612 : move16();
2473 612 : tmp2 = MAX_16;
2474 612 : move16();
2475 612 : if ( LE_16( tmp, 22938 /*0.7f Q15*/ ) )
2476 : {
2477 589 : tmp2 = 26214 /*0.8f Q15*/;
2478 589 : move16();
2479 : }
2480 : }
2481 : }
2482 : ELSE /* decoder side */
2483 : {
2484 : { /* *vf_ind is an integer scale by 0.125f*/
2485 612 : tmp = shl( *vf_ind, ( 15 - 3 ) );
2486 612 : tmp2 = MAX_16;
2487 612 : move16();
2488 612 : if ( LE_16( tmp, 22938 /*0.7f Q15*/ ) )
2489 : {
2490 589 : tmp2 = 26214 /*0.8f Q15*/;
2491 589 : move16();
2492 : }
2493 : }
2494 : }
2495 : {
2496 1224 : voice_factors[0] = mult_r( voice_factors[0], tmp2 );
2497 1224 : move16();
2498 1224 : voice_factors[1] = mult_r( voice_factors[1], tmp2 );
2499 1224 : move16();
2500 1224 : voice_factors[2] = mult_r( voice_factors[2], tmp2 );
2501 1224 : move16();
2502 1224 : voice_factors[3] = mult_r( voice_factors[3], tmp2 );
2503 1224 : move16();
2504 1224 : voice_factors[4] = mult_r( voice_factors[4], tmp2 );
2505 1224 : move16();
2506 : }
2507 : }
2508 :
2509 2706 : tmp = sub( Q_temp, 3 );
2510 868626 : FOR( k = 0; k < L_FRAME16k; k++ )
2511 : {
2512 865920 : White_exc16k_FB[k] = round_fx( L_shl( White_exc16k_32[k], tmp ) ); /* Q_bwe_exc +5 +1 +Q_temp -16 -3 */
2513 : }
2514 2706 : prev_Q_bwe_exc_fb = *Q_bwe_exc_fb;
2515 2706 : move16();
2516 2706 : *Q_bwe_exc_fb = sub( add( *Q_bwe_exc, Q_temp ), 13 );
2517 2706 : move16();
2518 2706 : deemph_fx( White_exc16k, PREEMPH_FAC, L_FRAME16k, tbe_demph );
2519 : /* i/o: White_exc16k (Q_bwe_exc-NOISE_QADJ) */
2520 : /* i: tbe_demph (Q_bwe_exc-NOISE_QADJ) */
2521 : {
2522 2706 : IF( EQ_16( coder_type, UNVOICED ) )
2523 : {
2524 54 : L_tmp = root_a_over_b_fx( pow1, Q_pow1, pow22, Q_pow22, &exp );
2525 54 : scale = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /*Q15 */
2526 17334 : FOR( k = 0; k < L_FRAME16k; k++ )
2527 : {
2528 : /* White_exc16k: (Q_bwe_exc-NOISE_QADJ), scale: Q15 */
2529 17280 : L_tmp = L_mult( White_exc16k[k], scale );
2530 : /* L_tmp: (Q_bwe_exc-NOISE_QADJ) + 15 + 1 */
2531 17280 : exc16kWhtnd[k] = round_fx( L_shl( L_tmp, NOISE_QADJ ) );
2532 17280 : move16();
2533 : /* exc16kWhtnd: Q_bwe_exc */
2534 : }
2535 54 : PREEMPH_FX( exc16kWhtnd, PREEMPH_FAC, L_FRAME16k, tbe_premph );
2536 : /* i/o: exc16kWhtnd (Q_bwe_exc) */
2537 : /* i/o: tbe_premph (Q_bwe_exc) */
2538 : }
2539 : ELSE
2540 : {
2541 : Word16 nbSubFr, lSubFr;
2542 : Word16 tempQ15;
2543 : Word32 tempQ31;
2544 : /*nbSubFr = ( bitrate < ACELP_24k40 )? NB_SUBFR : NB_SUBFR16k;*/
2545 2652 : nbSubFr = NB_SUBFR16k;
2546 2652 : lSubFr = ( L_FRAME16k / NB_SUBFR16k );
2547 2652 : IF( LT_32( bitrate, ACELP_24k40 ) )
2548 : {
2549 1482 : nbSubFr = NB_SUBFR;
2550 1482 : move16();
2551 1482 : lSubFr = ( L_FRAME16k / NB_SUBFR );
2552 1482 : move16();
2553 : }
2554 2652 : k = 0;
2555 14430 : FOR( i = 0; i < nbSubFr; i++ )
2556 : {
2557 11778 : test();
2558 11778 : IF( EQ_16( coder_type, VOICED ) && ( LT_32( bitrate, ACELP_24k40 ) ) )
2559 : {
2560 1696 : exp = 0;
2561 1696 : move16();
2562 1696 : tempQ15 = Sqrt16( voice_factors[i], &exp ); /* Q15 */
2563 1696 : temp = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
2564 1696 : exp = 0;
2565 1696 : move16();
2566 1696 : tempQ15 = Sqrt16( temp, &exp ); /* Q15 */
2567 1696 : temp1 = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
2568 :
2569 : /*temp2 = root_a_over_b_fx( pow1 * (1.0f - temp), pow22 ); */
2570 1696 : temp = sub( MAX_16, temp );
2571 1696 : tempQ31 = Mult_32_16( pow1, temp );
2572 1696 : L_tmp = root_a_over_b_fx( tempQ31, Q_pow1, pow22, Q_pow22, &exp );
2573 1696 : temp2 = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /* Q15 whiteEnvShapedExc scale factor */
2574 : }
2575 : ELSE
2576 : {
2577 : /* Adjust noise mixing for formant sharpening filter */
2578 10082 : tempQ15 = mult_r( SWB_NOISE_MIX_FAC_FX, formant_fac );
2579 : /* vf_tmp = voice_factors[i] * (1.0f - vf_tmp); */
2580 10082 : vf_tmp = sub( MAX_16, tempQ15 );
2581 10082 : vf_tmp = mult_r( voice_factors[i], vf_tmp );
2582 :
2583 10082 : exp = 0;
2584 10082 : move16();
2585 10082 : tempQ15 = Sqrt16( vf_tmp, &exp ); /* Q15 */
2586 10082 : temp1 = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
2587 :
2588 : /*temp2 = root_a_over_b(pow1 * (1.0f - vf_tmp), pow22); */
2589 10082 : temp = sub( MAX_16, vf_tmp );
2590 10082 : tempQ31 = Mult_32_16( pow1, temp );
2591 10082 : L_tmp = root_a_over_b_fx( tempQ31, Q_pow1, pow22, Q_pow22, &exp );
2592 10082 : temp2 = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /* Q15 whiteEnvShapedExc scale factor */
2593 : }
2594 :
2595 860418 : FOR( j = 0; j < lSubFr; j++ )
2596 : {
2597 : /*exc16kWhtnd[k+j] = temp1 * exc16kWhtnd[k+j] + temp2 * White_exc16k[k+j]; */
2598 848640 : L_tmp = L_mult( temp2, White_exc16k[k + j] ); /* 16+(Q_bwe_exc-NOISE_QADJ)*/
2599 848640 : L_tmp = L_shl_sat( L_tmp, NOISE_QADJ ); /* 16+(Q_bwe_exc) */
2600 848640 : exc16kWhtnd[k + j] = mac_r_sat( L_tmp, temp1, exc16kWhtnd[k + j] );
2601 848640 : move16();
2602 : /* Q_bwe_exc */
2603 : }
2604 11778 : k = add( k, lSubFr );
2605 :
2606 : /* estimate the pre-emph factor */
2607 11778 : tempQ15 = sub( MAX_16, voice_factors[i] );
2608 11778 : exp = 0;
2609 11778 : move16();
2610 11778 : temp = Sqrt16( tempQ15, &exp );
2611 11778 : temp = shl( temp, exp - 1 );
2612 :
2613 11778 : temp2 = add( temp, shl( temp1, -1 ) ); /* shift right by 1 to avoid overflow */
2614 11778 : temp = div_s( temp, temp2 ); /* Q15 */
2615 11778 : temp = mult_r( PREEMPH_FAC, temp );
2616 :
2617 11778 : PREEMPH_FX( &exc16kWhtnd[i * lSubFr], temp, lSubFr, tbe_premph );
2618 : /* exc16kWhtnd: Q_bwe_exc;
2619 : tbe_premph: Q_bwe_exc*/
2620 : }
2621 : }
2622 : }
2623 :
2624 2706 : IF( LT_32( bitrate, ACELP_24k40 ) )
2625 : {
2626 1482 : Syn_filt_s( 0, lpc_shb, LPC_SHB_ORDER, exc16kWhtnd, excSHB, L_FRAME16k, state_lpc_syn, 1 );
2627 : /* i: exc16kWhtnd in Q_bwe_exc */
2628 : /* o: excSHB in Q_bwe_exc */
2629 : }
2630 : ELSE
2631 : {
2632 1224 : set16_fx( zero_mem, 0, LPC_SHB_ORDER );
2633 :
2634 1224 : Syn_filt_s( 0, lpc_shb_sf, LPC_SHB_ORDER, exc16kWhtnd, tempSHB, 80, zero_mem, 1 );
2635 1224 : syn_shb_ener_sf[0] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
2636 1224 : move32();
2637 :
2638 1224 : Syn_filt_s( 0, lpc_shb_sf + ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 80, tempSHB, 80, zero_mem, 1 );
2639 1224 : syn_shb_ener_sf[1] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
2640 1224 : move32();
2641 :
2642 1224 : Syn_filt_s( 0, lpc_shb_sf + 2 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 160, tempSHB, 80, zero_mem, 1 );
2643 1224 : syn_shb_ener_sf[2] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
2644 1224 : move32();
2645 :
2646 1224 : Syn_filt_s( 0, lpc_shb_sf + 3 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 240, tempSHB, 80, zero_mem, 1 );
2647 1224 : syn_shb_ener_sf[3] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
2648 1224 : move32();
2649 :
2650 : /* i: exc16kWhtnd in Q_bwe_exc */
2651 : /* o: tempSHB in Q_bwe_exc */
2652 : /* o: syn_shb_ener_sf in (2*Q_bwe_exc+1) */
2653 1224 : IF( LE_32( bitrate, ACELP_32k ) )
2654 : {
2655 1224 : L_tmp = sum32_fx( syn_shb_ener_sf, 4 );
2656 :
2657 : /* find root_a(tempSHB[0]) = root_a_over_b(shb_ener_sf[0]), L_tmp) */
2658 1224 : tmp = shl( Q_shb, 1 );
2659 1224 : tmp2 = add( shl( *Q_bwe_exc, 1 ), 1 );
2660 1224 : L_tmp2 = root_a_over_b_fx( shb_ener_sf_32, tmp, L_tmp, tmp2, &exp ); /* L_tmp2 in (Q31-exp) */
2661 :
2662 1224 : *Q_bwe_exc = sub( *Q_bwe_exc, exp );
2663 1224 : move16(); /* compensate for the exp shift */
2664 1224 : tmp2 = add( prev_Q_bwe_syn, n_mem2 );
2665 1224 : IF( GT_16( *Q_bwe_exc, tmp2 ) )
2666 : {
2667 2 : L_tmp2 = L_shl( L_tmp2, sub( tmp2, *Q_bwe_exc ) );
2668 2 : *Q_bwe_exc = tmp2;
2669 2 : move16();
2670 : }
2671 392904 : FOR( i = 0; i < L_FRAME16k; i++ )
2672 : {
2673 391680 : L_tmp3 = Mult_32_16( L_tmp2, exc16kWhtnd[i] ); /* *Q_bwe_exc + (31-exp) - 15 */
2674 391680 : exc16kWhtnd[i] = round_fx( L_tmp3 ); /* *Q_bwe_exc - exp */
2675 391680 : move16();
2676 : }
2677 : }
2678 : /* i: L_tmp2 in (Q31-exp) */
2679 : /* i: exc16kWhtnd in Q_bwe_exc */
2680 : /* o: exc16kWhtnd in Q_bwe_exc: (Q_bwe_exc-exp) */
2681 :
2682 : /* Rescale the past memories: LP synth and SHB look ahead buffers */
2683 1224 : tmp = sub( *Q_bwe_exc, prev_Q_bwe_syn );
2684 13464 : FOR( i = 0; i < LPC_SHB_ORDER; i++ )
2685 : {
2686 12240 : state_lpc_syn[i] = shl( state_lpc_syn[i], tmp );
2687 12240 : move16();
2688 : }
2689 25704 : FOR( i = -L_SHB_LAHEAD; i < 0; i++ )
2690 : {
2691 24480 : excSHB[i] = shl( excSHB[i], tmp );
2692 24480 : move16();
2693 : }
2694 : /* Do mem_stp_swb_fx scaling before PostShortTerm_fx */
2695 :
2696 1224 : Syn_filt_s( 0, lpc_shb_sf, LPC_SHB_ORDER, exc16kWhtnd, excSHB, 80, state_lpc_syn, 1 );
2697 1224 : Syn_filt_s( 0, lpc_shb_sf + ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 80, excSHB + 80, 80, state_lpc_syn, 1 );
2698 1224 : Syn_filt_s( 0, lpc_shb_sf + 2 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 160, excSHB + 160, 80, state_lpc_syn, 1 );
2699 1224 : Syn_filt_s( 0, lpc_shb_sf + 3 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 240, excSHB + 240, 80, state_lpc_syn, 1 );
2700 : /* i: exc16kWhtnd in (Q_bwe_exc) */
2701 : /* o: excSHB in (Q_bwe_exc) */
2702 : }
2703 :
2704 2706 : IF( EQ_16( extl, FB_TBE ) )
2705 : {
2706 0 : tmp = sub( add( *Q_bwe_exc_fb, 20 ), prev_Q_bwe_exc_fb );
2707 0 : Scale_sig( fb_state_lpc_syn, LPC_SHB_ORDER, tmp );
2708 0 : Scale_sig( fb_tbe_demph, 1, tmp );
2709 0 : Syn_filt_s( 0, lpc_shb, LPC_SHB_ORDER, White_exc16k_FB, White_exc16k_FB_temp, L_FRAME16k, fb_state_lpc_syn, 1 );
2710 : /* i: White_exc16k_FB in (14-n2) */
2711 : /* o: White_exc16k_FB_temp in (14-n2) */
2712 :
2713 0 : FOR( i = 0; i < 10; i++ )
2714 : {
2715 0 : FOR( j = 0; j < 32; ++j )
2716 : {
2717 0 : White_exc16k_FB_temp[i * 32 + j] = mult_r( White_exc16k_FB_temp[i * 32 + j], cos_fb_exc_fx[j] );
2718 0 : move16();
2719 : }
2720 : }
2721 :
2722 0 : *Q_bwe_exc_fb = add( *Q_bwe_exc_fb, 20 );
2723 0 : move16(); /**Q_bwe_exc_fb +35 +1 -16*/
2724 0 : flip_spectrum_fx( White_exc16k_FB_temp, White_exc16k_FB, L_FRAME16k );
2725 :
2726 0 : deemph_fx( White_exc16k_FB, fb_deemph_fac, L_FRAME16k, fb_tbe_demph );
2727 : }
2728 : ELSE
2729 : {
2730 2706 : set16_fx( White_exc16k_FB, 0, L_FRAME16k );
2731 : }
2732 :
2733 2706 : return;
2734 : }
2735 :
2736 115701 : void GenShapedSHBExcitation_ivas_enc_fx(
2737 : Word16 *excSHB, /* o : synthesized shaped shb excitation Q_bwe_exc*/
2738 : const Word16 *lpc_shb, /* i : lpc coefficients Q12*/
2739 : Word16 *White_exc16k_FB, /* o : white excitation for the Fullband extension Q_bwe_exc_fb */
2740 : Word32 *mem_csfilt, /* i/o: memory */
2741 : Word16 *mem_genSHBexc_filt_down_shb, /* i/o: memory */
2742 : Word16 *state_lpc_syn, /* i/o: memory */
2743 : const Word16 coder_type, /* i : coding type */
2744 : const Word16 *bwe_exc_extended, /* i : bwidth extended excitation */
2745 : Word16 bwe_seed[], /* i/o: random number generator seed */
2746 : Word16 voice_factors[], /* i : voicing factor*/
2747 : const Word16 extl, /* i : extension layer */
2748 : Word16 *tbe_demph, /* i/o: de-emphasis memory */
2749 : Word16 *tbe_premph, /* i/o: pre-emphasis memory */
2750 : Word16 *lpc_shb_sf, /* i: LP coefficients */
2751 : const Word32 shb_ener_sf_32, /* i: input shb ener, Q31 */
2752 : Word16 *shb_res_gshape, /* i: input res gain shape, Q14 */
2753 : Word16 *shb_res,
2754 : Word16 *vf_ind,
2755 : const Word16 formant_fac, /* i : Formant sharpening factor [0..1] */
2756 : Word16 fb_state_lpc_syn[], /* i/o: memory */
2757 : Word16 *fb_tbe_demph, /* i/o: fb de-emphasis memory */
2758 : Word16 *Q_bwe_exc,
2759 : Word16 *Q_bwe_exc_fb,
2760 : const Word16 Q_shb,
2761 : Word16 n_mem2, /* i : n_mem2 scale factor to adjust 24.4/32kbps memories */
2762 : Word16 prev_Q_bwe_syn, /* i : st_fx->prev_Q_bwe_syn */
2763 : const Word32 bitrate,
2764 : const Word16 prev_bfi,
2765 : const Word16 element_mode, /* i : element mode */
2766 : const Word16 flag_ACELP16k, /* i : ACELP@16kHz flag */
2767 : Word16 *nlExc16k, /* i/o: NL exc for IC-BWE */
2768 : Word16 *nlExc16k_e, /* i/o: exp of nlExc16k */
2769 : Word16 *mixExc16k, /* i/o: exc spreading for IC-BWE */
2770 : Word16 *mixExc16k_e, /* i/o: exp of mixExc16k_fx */
2771 : const Word32 extl_brate, /* i : extension layer bitarte */
2772 : const Word16 MSFlag, /* i : Multi Source flag */
2773 : Word16 EnvSHBres_4k[], /* i/o: TD envelope of the SHB residual signal */
2774 : Word16 Q_EnvSHBres_4k,
2775 : Word32 *prev_pow_exc16kWhtnd, /* i/o: power of the LB excitation signal in the previous frame */
2776 : Word16 *prev_mix_factor, /* i/o: mixing factor in the previous frame */
2777 : Word16 *Env_error, /* o : error in SHB residual envelope modelling*/
2778 : Word16 Env_error_part[] /* o : per-segment error in SHB residual envelope modelling */
2779 : )
2780 : {
2781 : Word16 i, j, k;
2782 : Word16 wht_fil_mem[LPC_WHTN_ORDER];
2783 : Word16 lpc_whtn[LPC_WHTN_ORDER + 1];
2784 : Word16 R_h[LPC_WHTN_ORDER + 2]; /* Autocorrelations of windowed speech MSB */
2785 : Word16 R_l[LPC_WHTN_ORDER + 2]; /* Autocorrelations of windowed speech LSB */
2786 : Word16 Q_R;
2787 : Word32 LepsP[LPC_WHTN_ORDER + 1];
2788 : Word16 exc32k[L_FRAME32k], exc16k[L_FRAME16k];
2789 : Word32 pow1, pow22;
2790 : Word16 scale, temp1, temp2, temp3;
2791 :
2792 : Word16 excTmp2[L_FRAME16k];
2793 : Word16 *White_exc16k;
2794 : Word16 Q_White_exc16k;
2795 : Word16 excNoisyEnv[L_FRAME16k];
2796 115701 : Word16 csfilt_num2[1] = { 6554 }; /*0.2 in Q15 */
2797 115701 : move16();
2798 115701 : Word16 neg_csfilt_den2[2] = { -32767, 26214 }; /* {1.0f, -0.8f} */
2799 115701 : move16();
2800 115701 : move16();
2801 : Word16 varEnvShape;
2802 115701 : Word16 fb_deemph_fac = 15729; /*0.48f in Q15 */
2803 : Word16 exc16kWhtnd[L_FRAME16k];
2804 :
2805 : Word32 L_tmp;
2806 : Word16 vf_tmp;
2807 115701 : Word16 tmp, exp, tmp2 = 0;
2808 115701 : move16();
2809 : Word16 voiceFacEst[NB_SUBFR16k];
2810 : Word16 zero_mem[LPC_SHB_ORDER];
2811 : Word32 syn_shb_ener_sf[4];
2812 : Word16 syn_shb_ener_sf_q[4];
2813 : Word16 tempSHB[80];
2814 : Word16 Q_pow1, Q_pow22;
2815 :
2816 : Word32 L_tmp2, L_tmp3, L_tmp4;
2817 : Word16 temp;
2818 :
2819 : Word16 White_exc16k_FB_temp[L_FRAME16k];
2820 : Word32 White_exc16k_32[L_FRAME16k];
2821 : Word16 White_exc16k_tmp[L_FRAME16k];
2822 : Word16 prev_Q_bwe_exc_fb;
2823 :
2824 : Word16 alpha, step, mem_csfilt_left, mem_csfilt_right, excNoisyEnvLeft[L_FRAME16k], excNoisyEnvRight[L_FRAME16k];
2825 : Word16 cbsize;
2826 : Word16 mix_factor, old_fact, new_fact, fact, old_scale, new_scale, step_scale;
2827 : Word32 c0, c1, c2, c3, c4, c5, den;
2828 : Word16 g1, g2, g, g1_e, g2_e, g_e, den_e, shift, tmp_e, tmp1_e;
2829 : Word16 EnvWhiteExc16k[L_FRAME16k], EnvExc16kWhtnd[L_FRAME16k];
2830 115701 : Word16 EnvWhiteExc16k_4k[L_FRAME4k] = { 0 }, EnvExc16kWhtnd_4k[L_FRAME4k] = { 0 };
2831 : Word16 flag_plosive;
2832 : Word16 delta;
2833 : Word32 c0_part[NUM_SHB_SUBGAINS], c1_part[NUM_SHB_SUBGAINS], c2_part[NUM_SHB_SUBGAINS], c3_part[NUM_SHB_SUBGAINS], c4_part[NUM_SHB_SUBGAINS], c5_part[NUM_SHB_SUBGAINS];
2834 : Word64 W_tmp;
2835 :
2836 115701 : mix_factor = 0; /* Q15 */
2837 115701 : move16();
2838 :
2839 115701 : set16_fx( zero_mem, 0, LPC_SHB_ORDER );
2840 115701 : set16_fx( wht_fil_mem, 0, LPC_WHTN_ORDER );
2841 37140021 : FOR( i = 0; i < L_FRAME32k; i = i + 2 )
2842 : {
2843 37024320 : exc32k[i] = negate( bwe_exc_extended[i] ); // Q_bwe_exc
2844 37024320 : move16();
2845 37024320 : exc32k[i + 1] = bwe_exc_extended[i + 1]; // Q_bwe_exc
2846 37024320 : move16();
2847 : }
2848 :
2849 : /* Decimate by 2 */
2850 115701 : Decimate_allpass_steep_fx( exc32k, mem_genSHBexc_filt_down_shb, 2 * L_FRAME16k, exc16k ); // Q_bwe_exc
2851 : /* i: exc32k in Q_bwe_exc */
2852 : /* o: exc16k in Q_bwe_exc */
2853 :
2854 115701 : autocorr_fx( exc16k, LPC_WHTN_ORDER + 1, R_h, R_l, &Q_R, L_FRAME16k, win_flatten_fx, 0, 1 ); // Q_R
2855 : /* Ensure R[0] isn't zero when entering Levinson Durbin */
2856 115701 : R_l[0] = s_max( R_l[0], 1 );
2857 115701 : move16();
2858 578505 : FOR( i = 1; i <= LPC_WHTN_ORDER; i++ )
2859 : {
2860 462804 : L_tmp = Mpy_32( R_h[i], R_l[i], wac_h[i - 1], wac_l[i - 1] );
2861 462804 : L_Extract( L_tmp, &R_h[i], &R_l[i] ); // Q_R
2862 : }
2863 115701 : E_LPC_lev_dur( R_h, R_l, lpc_whtn, LepsP, LPC_WHTN_ORDER, NULL );
2864 115701 : Copy_Scale_sig( lpc_whtn, lpc_whtn, LPC_WHTN_ORDER + 1, sub( norm_s( lpc_whtn[0] ), 2 ) ); // Q12
2865 115701 : fir_fx( exc16k, lpc_whtn, exc16kWhtnd, wht_fil_mem, L_FRAME16k, LPC_WHTN_ORDER, 0, 3 ); // Q_bwe_exc
2866 :
2867 : /* i: exc16k in Q_bwe_exc */
2868 : /* o: exc16kWhtnd in Q_bwe_exc */
2869 :
2870 115701 : IF( GE_32( extl_brate, SWB_TBE_2k8 ) )
2871 : {
2872 25039 : temp2 = 0;
2873 25039 : move16();
2874 125195 : FOR( j = 0; j < 4; j++ )
2875 : {
2876 100156 : temp1 = shb_res_gshape[j];
2877 100156 : move16();
2878 8112636 : FOR( i = 0; i < 80; i++ )
2879 : {
2880 8012480 : exc16kWhtnd[temp2 + i] = round_fx( L_shl( L_mult( exc16kWhtnd[temp2 + i], temp1 ), 1 ) ); // Q_bwe_exc
2881 8012480 : move16();
2882 : /* exc16kWhtnd in Q_bwe_exc, shb_res_gshape in Q14 */
2883 : }
2884 100156 : temp2 = add( temp2, 80 );
2885 : }
2886 : }
2887 :
2888 : /* Estimate pow1 associated with Low band nonlinear extended excitation */
2889 : /* pow1=0.00001f */
2890 115701 : tmp = sub( shl( *Q_bwe_exc, 1 ), 31 );
2891 115701 : W_tmp = W_shl( 21475 /*0.00001f Q31*/, tmp ); /* 0.00001f in 2*(Q_bwe_exc) */
2892 37140021 : FOR( k = 0; k < L_FRAME16k; k++ )
2893 : {
2894 : /*excTmp2[k ] = (float)(fabs(exc16kWhtnd[k]));*/
2895 37024320 : excTmp2[k] = abs_s( exc16kWhtnd[k] );
2896 37024320 : move16();
2897 :
2898 : /* pow1 += exc16kWhtnd[k] * exc16kWhtnd[k]; */
2899 37024320 : W_tmp = W_mac_16_16( W_tmp, exc16kWhtnd[k], exc16kWhtnd[k] ); // 2*Q_bwe_exc+1
2900 : }
2901 115701 : exp = W_norm( W_tmp );
2902 115701 : pow1 = W_extract_h( W_shl( W_tmp, exp ) ); // 2*Q_bwe_exc+1+exp-32 = // tmp+exp
2903 115701 : Q_pow1 = add( tmp, exp );
2904 :
2905 115701 : IF( flag_ACELP16k == 0 )
2906 : {
2907 : /* varEnvShape = mean_fx(voice_factors, 4); */
2908 : /* unroll the loop */
2909 55971 : L_tmp = L_mult( voice_factors[0], 8192 /*0.25 in Q15 */ );
2910 55971 : L_tmp = L_mac( L_tmp, voice_factors[1], 8192 /*0.25 in Q15 */ );
2911 55971 : L_tmp = L_mac( L_tmp, voice_factors[2], 8192 /*0.25 in Q15 */ );
2912 55971 : varEnvShape = mac_r( L_tmp, voice_factors[3], 8192 /*0.25 in Q15 */ ); /* varEnvShape in Q15 */
2913 : }
2914 : ELSE /* 16k core */
2915 : {
2916 : /* varEnvShape = mean_fx(voice_factors, 5); */
2917 : /* unroll the loop */
2918 59730 : L_tmp = L_mult( voice_factors[0], 6554 /*0.2 in Q15 */ );
2919 59730 : L_tmp = L_mac( L_tmp, voice_factors[1], 6554 /*0.2 in Q15 */ );
2920 59730 : L_tmp = L_mac( L_tmp, voice_factors[2], 6554 /*0.2 in Q15 */ );
2921 59730 : L_tmp = L_mac( L_tmp, voice_factors[3], 6554 /*0.2 in Q15 */ );
2922 59730 : varEnvShape = mac_r( L_tmp, voice_factors[4], 6554 /*0.2 in Q15 */ ); /* varEnvShape in Q15 */
2923 : }
2924 :
2925 115701 : IF( EQ_16( extl, FB_TBE ) )
2926 : {
2927 : /*pow(varEnvShape,3) */
2928 43820 : tmp = mult_r( varEnvShape, varEnvShape );
2929 43820 : tmp = mult_r( tmp, varEnvShape );
2930 :
2931 : /* max_val((0.68f - (float)pow(varEnvShape, 3)), 0.48f); */
2932 43820 : fb_deemph_fac = sub( 22282 /*0.68f Q15*/, tmp );
2933 43820 : fb_deemph_fac = s_max( fb_deemph_fac, 15729 /*0.48f Q15*/ );
2934 : }
2935 :
2936 : /*varEnvShape = 1.09875f - 0.49875f * varEnvShape; */
2937 115701 : varEnvShape = msu_r( 1179773824l /*0.549375f Q31*/, 8172 /*0.249375f Q15*/, varEnvShape );
2938 :
2939 : /*varEnvShape = min( max_val(varEnvShape, 0.6f), 0.999f); */
2940 115701 : varEnvShape = s_max( varEnvShape, 9830 /*0.3f Q15*/ );
2941 115701 : varEnvShape = s_min( varEnvShape, 16368 /*0.4995f Q15*/ );
2942 115701 : varEnvShape = shl( varEnvShape, 1 );
2943 115701 : csfilt_num2[0] = sub( MAX_16, varEnvShape ); // Q15
2944 115701 : move16();
2945 115701 : neg_csfilt_den2[1] = varEnvShape; // Q15
2946 115701 : move16();
2947 :
2948 115701 : test();
2949 115701 : test();
2950 115701 : test();
2951 115701 : test();
2952 115701 : IF( EQ_16( element_mode, EVS_MONO ) && *mem_csfilt == 0 && ( ( EQ_32( bitrate, ACELP_9k60 ) ) || ( EQ_32( bitrate, ACELP_16k40 ) ) || ( EQ_32( bitrate, ACELP_24k40 ) ) ) )
2953 : {
2954 : /* pre-init smoothing filter to avoid energy drop outs */
2955 0 : L_tmp = L_mult( excTmp2[0], 1638 );
2956 0 : FOR( i = 1; i < L_SUBFR16k / 4; i++ )
2957 : {
2958 0 : L_tmp = L_mac( L_tmp, excTmp2[i], 1638 ); /*1638 = 1/20 in Q15*/
2959 : }
2960 : /*L_tmp = sum(excTmp2, L_SUBFR16k/4)*(1/20) where L_SUBFR16k/4 =20 */
2961 :
2962 : /* don't apply for FB in case the FB start-frame was potentially lost - White_exc16k is very sensitive to enery mismatch between enc - dec */
2963 : /* rather stick to the more conservative approach, to avoid potential clippings */
2964 0 : test();
2965 0 : IF( !( prev_bfi && EQ_16( extl, FB_TBE ) ) )
2966 : {
2967 : /* use weak smoothing for 1st frame after switching to make filter recover more quickly */
2968 0 : varEnvShape = 26214 /*0.8f Q15*/;
2969 0 : move16();
2970 0 : csfilt_num2[0] = sub( MAX_16, varEnvShape );
2971 0 : move16();
2972 0 : neg_csfilt_den2[1] = varEnvShape;
2973 0 : move16();
2974 : }
2975 :
2976 0 : *mem_csfilt = Mult_32_16( L_tmp, varEnvShape );
2977 0 : move32();
2978 : }
2979 :
2980 115701 : IF( MSFlag > 0 )
2981 : {
2982 : // varEnvShape = 0.995f;
2983 5718 : varEnvShape = 32604;
2984 5718 : move16();
2985 5718 : csfilt_num2[0] = 32768 - varEnvShape;
2986 : // csfilt_num2[0] = sub( 32767, varEnvShape );
2987 5718 : move16();
2988 5718 : neg_csfilt_den2[1] = varEnvShape;
2989 5718 : move16();
2990 : }
2991 :
2992 115701 : White_exc16k = exc16k;
2993 115701 : Word16 Q_excTmp2 = add( getScaleFactor16( excTmp2, L_FRAME16k ), *Q_bwe_exc );
2994 115701 : IF( *mem_csfilt )
2995 : {
2996 77917 : Q_excTmp2 = s_min( Q_excTmp2, sub( add( norm_l( *mem_csfilt ), *Q_bwe_exc ), 1 ) );
2997 : }
2998 115701 : test();
2999 : /* Track the low band envelope */
3000 115701 : IF( EQ_16( element_mode, IVAS_CPE_TD ) || EQ_16( element_mode, IVAS_CPE_DFT ) )
3001 : {
3002 30026 : test();
3003 30026 : IF( NE_32( extl_brate, SWB_TBE_1k10 ) && NE_32( extl_brate, SWB_TBE_1k75 ) )
3004 : {
3005 25745 : mem_csfilt_left = 0;
3006 25745 : mem_csfilt_right = 0;
3007 25745 : move16();
3008 25745 : move16();
3009 8264145 : FOR( k = 0; k < L_FRAME16k; k++ )
3010 : {
3011 : // excNoisyEnvLeft[k] = mem_csfilt_left + csfilt_num2[0] * excTmp2[k];
3012 8238400 : excNoisyEnvLeft[k] = add( mem_csfilt_left, mult_r( csfilt_num2[0], shl( excTmp2[k], sub( Q_excTmp2, *Q_bwe_exc ) ) ) ); // Q_excTmp2
3013 8238400 : move16();
3014 : // mem_csfilt_left = -csfilt_den2[1] * excNoisyEnvLeft[k];
3015 8238400 : mem_csfilt_left = mult_r( neg_csfilt_den2[1], excNoisyEnvLeft[k] ); // Q_excTmp2
3016 : // excNoisyEnvRight[L_FRAME16k - k - 1] = mem_csfilt_right + csfilt_num2[0] * excTmp2[L_FRAME16k - k - 1];
3017 8238400 : excNoisyEnvRight[L_FRAME16k - k - 1] = add( mem_csfilt_right, mult_r( csfilt_num2[0], shl( excTmp2[L_FRAME16k - k - 1], sub( Q_excTmp2, *Q_bwe_exc ) ) ) ); // Q_excTmp2
3018 8238400 : move16();
3019 : // mem_csfilt_right = -csfilt_den2[1] * excNoisyEnvRight[L_FRAME16k - k - 1];
3020 8238400 : mem_csfilt_right = mult_r( neg_csfilt_den2[1], excNoisyEnvRight[L_FRAME16k - k - 1] ); // Q_excTmp2
3021 : }
3022 :
3023 25745 : alpha = 0;
3024 25745 : move16();
3025 : // step = 1.0f / L_FRAME16k;
3026 25745 : step = 102; // Q15
3027 25745 : move16();
3028 8264145 : FOR( k = 0; k < L_FRAME16k; k++ )
3029 : {
3030 : // excNoisyEnv[k] = alpha * excNoisyEnvLeft[k] + (1 - alpha) * excNoisyEnvRight[k];
3031 8238400 : excNoisyEnv[k] = add( mult_r( alpha, excNoisyEnvLeft[k] ), mult_r( sub( 32767, alpha ), excNoisyEnvRight[k] ) ); // Q_excTmp2
3032 8238400 : move16();
3033 8238400 : alpha = add( alpha, step );
3034 : }
3035 : }
3036 : }
3037 : ELSE
3038 : {
3039 : /* Track the low band envelope */
3040 85675 : L_tmp = L_shl( *mem_csfilt, sub( Q_excTmp2, *Q_bwe_exc ) );
3041 85675 : move32();
3042 27501675 : FOR( i = 0; i < L_FRAME16k; i++ )
3043 : {
3044 27416000 : excNoisyEnv[i] = mac_r( L_tmp, csfilt_num2[0], shl( excTmp2[i], sub( Q_excTmp2, *Q_bwe_exc ) ) );
3045 27416000 : move16();
3046 : /* Work-around to avoid 0s for very small value*/
3047 27416000 : test();
3048 27416000 : test();
3049 27416000 : test();
3050 27416000 : test();
3051 27416000 : if ( excNoisyEnv[i] == 0 && ( L_tmp != 0 || ( csfilt_num2[0] != 0 && excTmp2[i] != 0 ) ) )
3052 : {
3053 5657 : excNoisyEnv[i] = 1;
3054 5657 : move16();
3055 : }
3056 : /* excNoisyEnv : Q_excTmp2,
3057 : *mem_csfilt: Q_excTmp2+16, excTmp2: Q_excTmp2, csfilt_num2[0] Q_excTmp2 */
3058 27416000 : L_tmp = L_mult( excNoisyEnv[i], neg_csfilt_den2[1] ); /* Q_excTmp2 + 16 */
3059 : }
3060 85675 : *mem_csfilt = L_shr( L_tmp, sub( Q_excTmp2, *Q_bwe_exc ) );
3061 85675 : move32();
3062 : }
3063 :
3064 115701 : test();
3065 115701 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
3066 4281 : {
3067 : /* generate gaussian (white) excitation */
3068 1374201 : FOR( k = 0; k < L_FRAME16k; k++ )
3069 : {
3070 1369920 : White_exc16k[k] = own_random( &bwe_seed[0] ); // Q0
3071 1369920 : move16();
3072 : }
3073 :
3074 : /* normalize the amplitude of the gaussian excitation to that of the LB exc. */
3075 4281 : Word32 pow22_inv = POW_EXC16k_WHTND_FX_INV_SQRT; // Q31
3076 4281 : move32();
3077 4281 : move32();
3078 4281 : pow22 = POW_EXC16k_WHTND_FX;
3079 4281 : Q_pow22 = -6;
3080 4281 : move16();
3081 : // v_multc(White_exc16k, (float)sqrt(pow1 / pow22), White_exc16k, L_FRAME16k);
3082 4281 : Word16 pow1_exp = sub( Q31, Q_pow1 );
3083 4281 : Word32 temp_pow = Sqrt32( pow1, &pow1_exp );
3084 4281 : temp_pow = L_shl( Mpy_32_32( temp_pow, pow22_inv ), pow1_exp );
3085 : /*Word16 out_exp;
3086 : Word32 temp_pow1 = root_a_over_b_fx(pow1, Q_pow1, pow22, Q_pow22, &out_exp);
3087 : temp_pow1 = L_shl(temp_pow1, out_exp);*/
3088 : // v_multc_fixed_16_16(White_exc16k, round_fx(temp_pow), White_exc16k, L_FRAME16k);
3089 4281 : L_tmp = 0;
3090 4281 : move32();
3091 4281 : Q_White_exc16k = add( getScaleFactor16( White_exc16k, L_FRAME16k ), norm_l( temp_pow ) );
3092 1374201 : FOR( k = 0; k < L_FRAME16k; k++ )
3093 : {
3094 1369920 : White_exc16k_32[k] = Mpy_32_16_1( temp_pow, White_exc16k[k] ); // Q31 + Q0 - Q15 = Q16
3095 1369920 : move32();
3096 1369920 : White_exc16k[k] = round_fx( L_shl( White_exc16k_32[k], Q_White_exc16k ) ); // Q16 + Q_White_exc16k - Q16 = Q_White_exc16k
3097 1369920 : move16();
3098 1369920 : L_tmp = L_max( L_tmp, L_abs( White_exc16k_32[k] ) );
3099 : }
3100 : }
3101 : ELSE
3102 : {
3103 : /* create a random excitation - Reuse exc16k memory */
3104 111420 : create_random_vector_fx( White_exc16k, L_FRAME, bwe_seed ); // Q5
3105 111420 : create_random_vector_fx( White_exc16k + L_FRAME, L_FRAME16k - L_FRAME, bwe_seed ); // Q5
3106 :
3107 111420 : L_tmp = L_deposit_l( 0 );
3108 111420 : tmp = add( *Q_bwe_exc, 1 );
3109 35765820 : FOR( k = 0; k < L_FRAME16k; k++ )
3110 : {
3111 35654400 : L_tmp4 = L_mult( excNoisyEnv[k], White_exc16k[k] ); /* (Q_excTmp2) +5 +1*/
3112 35654400 : White_exc16k_32[k] = L_tmp4; /* (Q_excTmp2) +5 +1*/
3113 35654400 : move32();
3114 35654400 : L_tmp = L_max( L_tmp, L_abs( White_exc16k_32[k] ) );
3115 : }
3116 : /*Copy_Scale_sig( White_exc16k, White_exc16k, L_FRAME16k, sub(NOISE_QFAC, 5) );)*/
3117 : /* White_exc16k in Q6 */
3118 :
3119 : /* calculate pow22 */
3120 : /* pow22=0.00001f */
3121 111420 : tmp = sub( shl( sub( *Q_bwe_exc, NOISE_QADJ ), 1 ), 31 );
3122 111420 : W_tmp = W_shl( 21475l /*0.00001f Q31*/, tmp ); /* 0.00001f in 2*(*Q_bwe_exc-NOISE_QADJ) */
3123 111420 : Q_White_exc16k = getScaleFactor32( White_exc16k_32, L_FRAME16k );
3124 35765820 : FOR( k = 0; k < L_FRAME16k; k++ )
3125 : {
3126 : /* White_exc16k[k] *= excNoisyEnv[k]; */
3127 35654400 : White_exc16k[k] = extract_h( L_shl( White_exc16k_32[k], Q_White_exc16k ) ); // Q_excTmp2 + 6 + Q_White_exc16k - 16 ==> Q_excTmp2 + Q_White_exc16k - 10
3128 35654400 : move16();
3129 : /* i: excNoisyEnv in (Q_excTmp2) */
3130 : /* i: White_exc16k in Q6 */
3131 : /* o: White_exc16k in (Q_bwe_exc-NOISE_QADJ) */
3132 :
3133 : /* pow22 += White_exc16k[k] * White_exc16k[k]; */
3134 35654400 : W_tmp = W_mac0_16_16( W_tmp, White_exc16k[k], White_exc16k[k] ); /* 2*(Q_excTmp2 + Q_White_exc16k - 10)*/
3135 : }
3136 111420 : Q_pow22 = W_norm( W_tmp );
3137 111420 : pow22 = W_extract_h( W_shl( W_tmp, Q_pow22 ) ); // 2*(Q_excTmp2 + Q_White_exc16k - 10)+Q_pow22-32
3138 111420 : Q_pow22 = sub( add( Q_pow22, shl( sub( add( Q_White_exc16k, Q_excTmp2 ), 10 ), 1 ) ), 32 );
3139 111420 : Q_White_exc16k = add( Q_White_exc16k, sub( Q_excTmp2, 10 ) );
3140 : }
3141 :
3142 115701 : flag_plosive = 0;
3143 115701 : move16();
3144 115701 : test();
3145 115701 : test();
3146 115701 : test();
3147 115701 : IF( GE_32( extl_brate, SWB_TBE_2k8 ) || EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
3148 : {
3149 29320 : IF( EQ_16( *vf_ind, 20 ) ) /* encoder side */
3150 : {
3151 29320 : test();
3152 29320 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
3153 : {
3154 1374201 : FOR( k = 0; k < L_FRAME16k; k++ )
3155 : {
3156 1369920 : White_exc16k_tmp[k] = shl( White_exc16k[k], sub( *Q_bwe_exc, Q_White_exc16k ) );
3157 1369920 : move16();
3158 : }
3159 :
3160 : /* calculate TD envelopes of exc16kWhtnd and White_exc16k */
3161 4281 : find_td_envelope_fx( White_exc16k_tmp, L_FRAME16k, 20, NULL, EnvWhiteExc16k ); /* Q_bwe_exc */
3162 4281 : find_td_envelope_fx( exc16kWhtnd, L_FRAME16k, 20, NULL, EnvExc16kWhtnd ); /* Q_bwe_exc */
3163 :
3164 346761 : FOR( k = 0; k < L_FRAME4k; k++ )
3165 : {
3166 342480 : EnvWhiteExc16k_4k[k] = EnvWhiteExc16k[4 * k]; /* Q_bwe_exc */
3167 342480 : move16();
3168 342480 : EnvExc16kWhtnd_4k[k] = EnvExc16kWhtnd[4 * k]; /* Q_bwe_exc */
3169 342480 : move16();
3170 : }
3171 :
3172 : /* calculate the optimal mix factor */
3173 4281 : c0 = c1 = c2 = c3 = c4 = c5 = 0; /* Q0 */
3174 4281 : move32();
3175 4281 : move32();
3176 4281 : move32();
3177 4281 : move32();
3178 4281 : move32();
3179 4281 : move32();
3180 :
3181 4281 : temp1 = add( shl( *Q_bwe_exc, 1 ), 1 );
3182 4281 : temp2 = add( add( Q_EnvSHBres_4k, *Q_bwe_exc ), 1 );
3183 4281 : temp3 = add( shl( Q_EnvSHBres_4k, 1 ), 1 );
3184 21405 : FOR( i = 0; i < NUM_SHB_SUBGAINS; i++ )
3185 : {
3186 : // c0_part[i] = sum2_f( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
3187 17124 : c0_part[i] = L_shr( sum2_fx( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), temp1 ); /* Q0 */
3188 17124 : move32();
3189 : // c1_part[i] = -2.0f * dotp( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
3190 17124 : c1_part[i] = L_shr( L_negate( Dot_product( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ) ), sub( temp2, 1 ) ); /* Q0 */
3191 17124 : move32();
3192 : // c2_part[i] = sum2_f( &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
3193 17124 : c2_part[i] = L_shr( sum2_fx( &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), temp1 ); /* Q0 */
3194 17124 : move32();
3195 : // c3_part[i] = -2.0f * dotp( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
3196 17124 : c3_part[i] = L_shr( L_negate( Dot_product( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ) ), sub( temp2, 1 ) ); /* Q0 */
3197 17124 : move32();
3198 : // c4_part[i] = 2.0f * dotp( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
3199 17124 : c4_part[i] = L_shr( Dot_product( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), sub( temp1, 1 ) ); /* Q0 */
3200 17124 : move32();
3201 : // c5_part[i] = sum2_f( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
3202 17124 : c5_part[i] = L_shr( sum2_fx( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), temp3 ); /* Q0 */
3203 17124 : move32();
3204 :
3205 17124 : c0 = L_add( c0, c0_part[i] );
3206 17124 : c1 = L_add( c1, c1_part[i] );
3207 17124 : c2 = L_add( c2, c2_part[i] );
3208 17124 : c3 = L_add( c3, c3_part[i] );
3209 17124 : c4 = L_add( c4, c4_part[i] );
3210 17124 : c5 = L_add( c5, c5_part[i] );
3211 : }
3212 :
3213 : // den = 4.0f * c0 * c2 - c4 * c4;
3214 4281 : W_tmp = W_sub( W_shl( W_mult0_32_32( c0, c2 ), 2 ), W_mult0_32_32( c4, c4 ) );
3215 4281 : den_e = 63;
3216 4281 : move16();
3217 4281 : shift = W_norm( W_tmp );
3218 4281 : den = W_extract_h( W_shl( W_tmp, shift ) );
3219 4281 : den_e = sub( den_e, shift );
3220 :
3221 4281 : IF( den == 0 )
3222 : {
3223 281 : den = 1;
3224 281 : move32();
3225 281 : den_e = 31;
3226 281 : move16();
3227 : }
3228 :
3229 : // g1 = ( c3 * c4 - 2 * c1 * c2 ) / den;
3230 4281 : W_tmp = W_sub( W_mult0_32_32( c3, c4 ), W_shl( W_mult0_32_32( c1, c2 ), 1 ) );
3231 4281 : g1_e = 63;
3232 4281 : move16();
3233 4281 : shift = W_norm( W_tmp );
3234 4281 : L_tmp = W_extract_h( W_shl( W_tmp, shift ) );
3235 4281 : g1_e = sub( g1_e, shift );
3236 :
3237 4281 : g1 = BASOP_Util_Divide3232_Scale( L_tmp, den, &tmp_e );
3238 4281 : g1_e = sub( add( tmp_e, g1_e ), den_e );
3239 :
3240 : // g2 = ( c1 * c4 - 2 * c0 * c3 ) / den;
3241 4281 : W_tmp = W_sub( W_mult0_32_32( c1, c4 ), W_shl( W_mult0_32_32( c0, c3 ), 1 ) );
3242 4281 : g2_e = 63;
3243 4281 : move16();
3244 4281 : shift = W_norm( W_tmp );
3245 4281 : L_tmp = W_extract_h( W_shl( W_tmp, shift ) );
3246 4281 : g2_e = sub( g2_e, shift );
3247 :
3248 4281 : g2 = BASOP_Util_Divide3232_Scale( L_tmp, den, &tmp_e );
3249 4281 : g2_e = sub( add( tmp_e, g2_e ), den_e );
3250 :
3251 : // *Env_error = 0.0f;
3252 4281 : *Env_error = 0;
3253 4281 : move16();
3254 4281 : flag_plosive = 0;
3255 4281 : move16();
3256 21405 : FOR( i = 0; i < NUM_SHB_SUBGAINS; i++ )
3257 : {
3258 : // Env_error_part[i] = c5_part[i] + g1 * g1 * c0_part[i] + g1 * c1_part[i] + g2 * g2 * c2_part[i] + g2 * c3_part[i] + g1 * g2 * c4_part[i];
3259 17124 : L_tmp = BASOP_Util_Add_Mant32Exp( c5_part[i], 31, Mpy_32_32( L_mult( g1, g1 ), c0_part[i] ), add( shl( g1_e, 1 ), 31 ), &tmp_e );
3260 17124 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_16_1( c1_part[i], g1 ), add( 31, g1_e ), &tmp_e );
3261 17124 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_32( L_mult( g2, g2 ), c2_part[i] ), add( shl( g2_e, 1 ), 31 ), &tmp_e );
3262 17124 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_16_1( c3_part[i], g2 ), add( 31, g2_e ), &tmp_e );
3263 17124 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_32( L_mult( g1, g2 ), c4_part[i] ), add( add( g1_e, g2_e ), 31 ), &tmp_e );
3264 :
3265 : // Env_error_part[i] = L_shr( L_tmp, 31 - tmp_e ); // Check Exponent
3266 17124 : Env_error_part[i] = extract_h( L_shr_sat( L_tmp, sub( Q15, tmp_e ) ) ); /* Q0 */
3267 17124 : move16();
3268 :
3269 : // *Env_error += Env_error_part[i];
3270 17124 : *Env_error = add_sat( *Env_error, Env_error_part[i] ); /* Q0 */
3271 17124 : move16();
3272 :
3273 17124 : if ( GT_16( Env_error_part[i], THR_ENV_ERROR_PLOSIVE_FX ) ) // Check which Q
3274 : {
3275 : /* envelope error is too high -> likely a plosive */
3276 43 : flag_plosive = 1;
3277 43 : move16();
3278 : }
3279 : }
3280 :
3281 4281 : IF( flag_plosive )
3282 : {
3283 : /* plosive detected -> set the mixing factor to 0 */
3284 39 : *vf_ind = 0;
3285 39 : move16();
3286 39 : mix_factor = 0;
3287 39 : move16();
3288 : }
3289 : ELSE
3290 : {
3291 : /* normalize gain */
3292 : // g = g2 / ( g1 + g2 );
3293 4242 : tmp1_e = BASOP_Util_Add_MantExp( g1, g1_e, g2, g2_e, &tmp );
3294 4242 : IF( tmp == 0 )
3295 : {
3296 327 : tmp = 1;
3297 327 : move16();
3298 327 : tmp1_e = 15;
3299 327 : move16();
3300 : }
3301 4242 : g = BASOP_Util_Divide1616_Scale( g2, tmp, &tmp_e );
3302 4242 : g_e = sub( add( tmp_e, g2_e ), tmp1_e );
3303 :
3304 : /* quantization of the mixing factor */
3305 4242 : cbsize = 1 << NUM_BITS_SHB_VF;
3306 4242 : move16();
3307 : // delta = 1.0f / ( cbsize - 1 );
3308 4242 : delta = 2341; /* Q14 */
3309 4242 : move16();
3310 : // if ( g > 1.0f )
3311 4242 : IF( BASOP_Util_Cmp_Mant32Exp( g, add( 16, g_e ), ONE_IN_Q31, 0 ) > 0 )
3312 : {
3313 : // g = 1.0f;
3314 812 : g = MAX16B; /* Q15 */
3315 812 : move16();
3316 812 : g_e = 0;
3317 812 : move16();
3318 : }
3319 : // else if ( g < shl( delta, ( 15 - g_e ) - 14 ) )
3320 3430 : ELSE IF( BASOP_Util_Cmp_Mant32Exp( g, add( 16, g_e ), delta, 17 ) < 0 )
3321 : {
3322 : /* prevent low gains to be quantized to 0 as this is reserved for plosives */
3323 : // g = delta;
3324 702 : g = shl( delta, 1 ); /* Q15 */
3325 702 : g_e = 0;
3326 702 : move16();
3327 : }
3328 :
3329 4242 : g = shl_sat( g, g_e ); /* Q15 */
3330 :
3331 4242 : *vf_ind = usquant_fx( g, &mix_factor, 0, delta, cbsize );
3332 4242 : move16();
3333 : }
3334 : }
3335 : ELSE
3336 : {
3337 25039 : Estimate_mix_factors_fx( shb_res, Q_shb, exc16kWhtnd, *Q_bwe_exc, White_exc16k,
3338 : Q_White_exc16k, pow1, Q_pow1, pow22, Q_pow22, voiceFacEst, vf_ind );
3339 25039 : tmp = voiceFacEst[0];
3340 25039 : tmp2 = MAX_16;
3341 25039 : move16();
3342 25039 : move16();
3343 25039 : if ( LE_16( tmp, 22938 /*0.7f Q15*/ ) )
3344 : {
3345 24648 : tmp2 = 26214 /*0.8f Q15*/;
3346 24648 : move16();
3347 : }
3348 : }
3349 : }
3350 : ELSE /* decoder side */
3351 : {
3352 0 : test();
3353 0 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
3354 : {
3355 0 : IF( *vf_ind == 0 )
3356 : {
3357 : // mix_factor = 0.0f;
3358 0 : mix_factor = 0;
3359 0 : move16();
3360 0 : flag_plosive = 1;
3361 0 : move16();
3362 : }
3363 : ELSE
3364 : {
3365 : // mix_factor = usdequant(*vf_ind, 0.0f, 1.0f / ((1 << NUM_BITS_SHB_VF) - 1));
3366 0 : mix_factor = usdequant_fx( *vf_ind, 0, 2341 );
3367 : }
3368 : }
3369 : ELSE
3370 : {
3371 : /* *vf_ind is an integer scale by 0.125f*/
3372 0 : tmp = shl( *vf_ind, ( 15 - 3 ) );
3373 0 : tmp2 = MAX_16;
3374 0 : move16();
3375 0 : IF( LE_16( tmp, 22938 /*0.7f Q15*/ ) )
3376 : {
3377 0 : tmp2 = 26214 /*0.8f Q15*/;
3378 0 : move16();
3379 : }
3380 : }
3381 : }
3382 :
3383 29320 : test();
3384 29320 : IF( NE_32( extl_brate, SWB_TBE_1k10 ) && NE_32( extl_brate, SWB_TBE_1k75 ) )
3385 : {
3386 25039 : voice_factors[0] = mult_r( voice_factors[0], tmp2 );
3387 25039 : move16();
3388 25039 : voice_factors[1] = mult_r( voice_factors[1], tmp2 );
3389 25039 : move16();
3390 25039 : voice_factors[2] = mult_r( voice_factors[2], tmp2 );
3391 25039 : move16();
3392 25039 : voice_factors[3] = mult_r( voice_factors[3], tmp2 );
3393 25039 : move16();
3394 25039 : voice_factors[4] = mult_r( voice_factors[4], tmp2 );
3395 25039 : move16();
3396 : }
3397 : }
3398 :
3399 115701 : test();
3400 115701 : IF( GE_16( element_mode, IVAS_CPE_DFT ) && nlExc16k != NULL )
3401 : {
3402 : /* save buffers for IC-BWE */
3403 : // mvr2r(exc16kWhtnd, nlExc16k, L_FRAME16k);
3404 24318 : Copy( exc16kWhtnd, nlExc16k, L_FRAME16k ); // Q_bwe_exc
3405 24318 : *nlExc16k_e = sub( 15, *Q_bwe_exc );
3406 24318 : move16();
3407 :
3408 : // v_multc(White_exc16k, (float)sqrt(pow1 / pow22), mixExc16k, L_FRAME16k);
3409 24318 : L_tmp = root_a_over_b_fx( pow1, Q_pow1, pow22, Q_pow22, &exp );
3410 24318 : Word16 temp_fac = round_fx_sat( L_tmp ); // Q15-exp
3411 :
3412 7806078 : FOR( k = 0; k < L_FRAME16k; k++ )
3413 : {
3414 7781760 : mixExc16k[k] = mult_r( White_exc16k[k], temp_fac ); // Q_White_exc16k+15-exp-15 = Q_White_exc16k-exp
3415 7781760 : move16();
3416 : }
3417 24318 : *mixExc16k_e = sub( 15, sub( Q_White_exc16k, exp ) );
3418 24318 : move16();
3419 : }
3420 :
3421 115701 : Copy( White_exc16k, White_exc16k_FB, L_FRAME16k ); // Q_White_exc16k
3422 115701 : prev_Q_bwe_exc_fb = *Q_bwe_exc_fb;
3423 115701 : *Q_bwe_exc_fb = Q_White_exc16k;
3424 115701 : move16();
3425 115701 : move16();
3426 :
3427 115701 : scale_sig( White_exc16k, L_FRAME16k, -1 /* guard bit to prevent saturation in deemph*/ );
3428 115701 : Q_White_exc16k = sub( Q_White_exc16k, 1 );
3429 :
3430 115701 : Word16 tbe_demph_fx = shl_sat( *tbe_demph, sub( Q_White_exc16k, *Q_bwe_exc ) ); // Q_White_exc16k
3431 :
3432 115701 : deemph_fx( White_exc16k, PREEMPH_FAC, L_FRAME16k, &tbe_demph_fx );
3433 : /* i/o: White_exc16k (Q_White_exc16k) */
3434 : /* i: tbe_demph_fx (Q_White_exc16k) */
3435 115701 : *tbe_demph = shr_sat( tbe_demph_fx, sub( Q_White_exc16k, *Q_bwe_exc ) );
3436 115701 : move16();
3437 :
3438 115701 : test();
3439 115701 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
3440 : {
3441 4281 : IF( !flag_plosive ) /* use only LB excitation in case of plosives */
3442 : {
3443 : /* re-scale gaussian excitation at the beginning to gradually move from old energy to new energy */
3444 : /* old_scale = (float) sqrt( *prev_pow_exc16kWhtnd / pow1 ); */
3445 4242 : old_scale = round_fx_sat( root_a_over_b_fx( *prev_pow_exc16kWhtnd, 0, pow1, Q_pow1, &exp ) ); // exp
3446 4242 : old_scale = shl( old_scale, s_min( 0, exp ) ); // limit Q factor to 15
3447 4242 : exp = s_max( 0, exp );
3448 :
3449 : // new_scale = 1.0f;
3450 4242 : new_scale = shr( 32767, exp ); // exp
3451 :
3452 : // step_scale = (new_scale - old_scale) / (L_FRAME16k / 2);
3453 4242 : step_scale = mult_r( sub( new_scale, old_scale ), 205 ); // exp
3454 4242 : scale = old_scale; // exp
3455 4242 : move16();
3456 :
3457 : /* interpolate between the old and the new value of the mixing factor */
3458 4242 : old_fact = *prev_mix_factor; // Q15
3459 4242 : new_fact = mix_factor; // Q15
3460 4242 : move16();
3461 4242 : move16();
3462 :
3463 : // step = (new_fact - old_fact) / (L_FRAME16k / 2);
3464 4242 : step = mult_r( sub( new_fact, old_fact ), 205 ); // Q15
3465 4242 : fact = old_fact; // Q15
3466 4242 : move16();
3467 :
3468 4242 : shift = add( exp, sub( *Q_bwe_exc, Q_White_exc16k ) );
3469 :
3470 : /* mixing of LB and gaussian excitation in the first half of the frame */
3471 682962 : FOR( k = 0; k < L_FRAME16k / 2; k++ )
3472 : {
3473 : /* exc16kWhtnd[k] = (float)fact * (White_exc16k[k] * scale) + (float)(1 - fact) * exc16kWhtnd[k]; */
3474 678720 : L_tmp = L_shl_sat( L_mult( fact, mult_r( White_exc16k[k], scale ) ), shift ); // Q_bwe_exc+16
3475 678720 : exc16kWhtnd[k] = mac_r_sat( L_tmp, sub( 32767, fact ), exc16kWhtnd[k] ); // Q_bwe_exc
3476 678720 : move16();
3477 :
3478 678720 : fact = add_sat( fact, step ); // Q15
3479 678720 : scale = add_sat( scale, step_scale ); // exp
3480 : }
3481 :
3482 4242 : shift = sub( *Q_bwe_exc, Q_White_exc16k );
3483 : /* mixing of LB and gaussian excitation in the second half of the frame */
3484 682962 : FOR( ; k < L_FRAME16k; k++ )
3485 : {
3486 : // exc16kWhtnd[k] = (float)new_fact * White_exc16k[k] + (float)(1 - new_fact) * exc16kWhtnd[k];
3487 678720 : L_tmp = L_shl_sat( L_mult( new_fact, White_exc16k[k] ), shift ); // Q_bwe_exc+16
3488 678720 : exc16kWhtnd[k] = mac_r( L_tmp, sub( 32767, new_fact ), exc16kWhtnd[k] ); // Q_bwe_exc
3489 678720 : move16();
3490 : }
3491 : }
3492 : // preemph(exc16kWhtnd, PREEMPH_FAC, L_FRAME16k, tbe_premph);
3493 4281 : PREEMPH_FX( exc16kWhtnd, PREEMPH_FAC, L_FRAME16k, tbe_premph ); // Q_bwe_exc
3494 : }
3495 : ELSE
3496 : {
3497 111420 : test();
3498 111420 : IF( EQ_16( coder_type, UNVOICED ) || EQ_16( MSFlag, 1 ) )
3499 : {
3500 7264 : scale = 0;
3501 7264 : move16();
3502 :
3503 7264 : test();
3504 7264 : IF( pow1 != 0 && pow22 != 0 )
3505 : {
3506 7264 : L_tmp = root_a_over_b_fx( pow1, Q_pow1, pow22, Q_pow22, &exp );
3507 7264 : scale = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /*Q15 */
3508 : }
3509 :
3510 2331744 : FOR( k = 0; k < L_FRAME16k; k++ )
3511 : {
3512 2324480 : exc16kWhtnd[k] = mult_r_sat( White_exc16k[k], scale ); // Q_White_exc16k
3513 2324480 : move16();
3514 : }
3515 :
3516 7264 : Scale_sig( exc16kWhtnd, L_FRAME16k, sub( *Q_bwe_exc, Q_White_exc16k ) ); // Q_bwe_exc
3517 :
3518 7264 : PREEMPH_FX( exc16kWhtnd, PREEMPH_FAC, L_FRAME16k, tbe_premph ); // Q_bwe_exc
3519 : /* i/o: exc16kWhtnd (Q_bwe_exc) */
3520 : /* i/o: tbe_premph (Q_bwe_exc) */
3521 : }
3522 : ELSE
3523 : {
3524 : Word16 nbSubFr, lSubFr;
3525 : Word16 tempQ15;
3526 : Word32 tempQ31;
3527 104156 : nbSubFr = NB_SUBFR16k;
3528 104156 : lSubFr = ( L_FRAME16k / NB_SUBFR16k );
3529 104156 : move16();
3530 104156 : move16();
3531 104156 : IF( LT_32( extl_brate, SWB_TBE_2k8 ) )
3532 : {
3533 79117 : nbSubFr = NB_SUBFR;
3534 79117 : move16();
3535 79117 : lSubFr = ( L_FRAME16k / NB_SUBFR );
3536 79117 : move16();
3537 : }
3538 104156 : k = 0;
3539 104156 : move16();
3540 545819 : FOR( i = 0; i < nbSubFr; i++ )
3541 : {
3542 441663 : test();
3543 441663 : IF( EQ_16( coder_type, VOICED ) && ( LT_32( extl_brate, SWB_TBE_2k8 ) ) )
3544 : {
3545 28388 : exp = 0;
3546 28388 : move16();
3547 28388 : tempQ15 = Sqrt16( voice_factors[i], &exp ); /* Q15 */
3548 28388 : temp = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
3549 28388 : exp = 0;
3550 28388 : move16();
3551 28388 : tempQ15 = Sqrt16( temp, &exp ); /* Q15 */
3552 28388 : temp1 = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
3553 :
3554 : /*temp2 = root_a_over_b_fx( pow1 * (1.0f - temp), pow22 ); */
3555 28388 : temp = sub( MAX_16, temp );
3556 28388 : tempQ31 = Mult_32_16( pow1, temp );
3557 28388 : L_tmp = root_a_over_b_fx( tempQ31, Q_pow1, pow22, Q_pow22, &exp );
3558 28388 : temp2 = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /* Q15 whiteEnvShapedExc scale factor */
3559 : }
3560 : ELSE
3561 : {
3562 : /* Adjust noise mixing for formant sharpening filter */
3563 413275 : tempQ15 = mult_r( SWB_NOISE_MIX_FAC_FX, formant_fac );
3564 : /* vf_tmp = voice_factors[i] * (1.0f - vf_tmp); */
3565 413275 : vf_tmp = sub( MAX_16, tempQ15 );
3566 413275 : vf_tmp = mult( voice_factors[i], vf_tmp );
3567 :
3568 413275 : exp = 0;
3569 413275 : move16();
3570 413275 : tempQ15 = Sqrt16( vf_tmp, &exp ); /* Q15 */
3571 413275 : temp1 = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
3572 :
3573 : /*temp2 = root_a_over_b(pow1 * (1.0f - vf_tmp), pow22); */
3574 413275 : temp = sub( MAX_16, vf_tmp );
3575 413275 : tempQ31 = Mult_32_16( pow1, temp );
3576 413275 : L_tmp = root_a_over_b_fx( tempQ31, Q_pow1, pow22, Q_pow22, &exp );
3577 413275 : temp2 = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /* Q15 whiteEnvShapedExc scale factor */
3578 : }
3579 :
3580 441663 : shift = sub( *Q_bwe_exc, Q_White_exc16k );
3581 33771583 : FOR( j = 0; j < lSubFr; j++ )
3582 : {
3583 : /*exc16kWhtnd[k+j] = temp1 * exc16kWhtnd[k+j] + temp2 * White_exc16k[k+j]; */
3584 33329920 : L_tmp = L_shl_sat( L_mult( temp2, White_exc16k[k + j] ), shift ); // 16+(Q_bwe_exc)
3585 33329920 : exc16kWhtnd[k + j] = mac_r_sat( L_tmp, temp1, exc16kWhtnd[k + j] ); // Q_bwe_exc
3586 33329920 : move16();
3587 : }
3588 441663 : k = add( k, lSubFr );
3589 :
3590 : /* estimate the pre-emph factor */
3591 441663 : tempQ15 = sub( MAX_16, voice_factors[i] );
3592 441663 : exp = 0;
3593 441663 : move16();
3594 441663 : temp = Sqrt16( tempQ15, &exp );
3595 441663 : temp = shl( temp, sub( exp, 1 ) );
3596 :
3597 441663 : temp2 = add( temp, shl( temp1, -1 ) ); /* shift right by 1 to avoid overflow */
3598 441663 : temp = div_s( temp, temp2 ); /* Q15 */
3599 441663 : temp = mult_r( PREEMPH_FAC, temp );
3600 :
3601 441663 : PREEMPH_FX( &exc16kWhtnd[i * lSubFr], temp, lSubFr, tbe_premph ); // Q_bwe_exc
3602 : /* exc16kWhtnd: Q_bwe_exc;
3603 : tbe_premph: Q_bwe_exc*/
3604 : }
3605 : }
3606 : }
3607 :
3608 115701 : IF( LT_32( extl_brate, SWB_TBE_2k8 ) )
3609 : {
3610 90662 : syn_filt_fx( 0, lpc_shb, LPC_SHB_ORDER, exc16kWhtnd, excSHB, L_FRAME16k, state_lpc_syn, 1 );
3611 : /* i: exc16kWhtnd in Q_bwe_exc */
3612 : /* o: excSHB in Q_bwe_exc */
3613 : }
3614 : ELSE
3615 : {
3616 25039 : set16_fx( zero_mem, 0, LPC_SHB_ORDER );
3617 :
3618 25039 : syn_filt_fx( 0, lpc_shb_sf, LPC_SHB_ORDER, exc16kWhtnd, tempSHB, 80, zero_mem, 1 );
3619 25039 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
3620 25039 : Scale_sig( tempSHB, 80, tmp );
3621 25039 : syn_shb_ener_sf[0] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
3622 25039 : move32();
3623 25039 : syn_shb_ener_sf_q[0] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
3624 25039 : move16();
3625 :
3626 25039 : syn_filt_fx( 0, lpc_shb_sf + ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 80, tempSHB, 80, zero_mem, 1 );
3627 25039 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
3628 25039 : Scale_sig( tempSHB, 80, tmp );
3629 25039 : syn_shb_ener_sf[1] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
3630 25039 : move32();
3631 25039 : syn_shb_ener_sf_q[1] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
3632 25039 : move16();
3633 :
3634 25039 : syn_filt_fx( 0, lpc_shb_sf + 2 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 160, tempSHB, 80, zero_mem, 1 );
3635 25039 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
3636 25039 : Scale_sig( tempSHB, 80, tmp );
3637 25039 : syn_shb_ener_sf[2] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
3638 25039 : move32();
3639 25039 : syn_shb_ener_sf_q[2] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
3640 25039 : move16();
3641 :
3642 25039 : syn_filt_fx( 0, lpc_shb_sf + 3 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 240, tempSHB, 80, zero_mem, 1 );
3643 25039 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
3644 25039 : Scale_sig( tempSHB, 80, tmp );
3645 25039 : syn_shb_ener_sf[3] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
3646 25039 : move32();
3647 25039 : syn_shb_ener_sf_q[3] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
3648 25039 : move16();
3649 :
3650 25039 : tmp2 = s_min( s_min( syn_shb_ener_sf_q[0], syn_shb_ener_sf_q[1] ), s_min( syn_shb_ener_sf_q[3], syn_shb_ener_sf_q[2] ) );
3651 25039 : syn_shb_ener_sf[0] = L_shl( syn_shb_ener_sf[0], sub( tmp2, syn_shb_ener_sf_q[0] ) );
3652 25039 : move32();
3653 25039 : syn_shb_ener_sf[1] = L_shl( syn_shb_ener_sf[1], sub( tmp2, syn_shb_ener_sf_q[1] ) );
3654 25039 : move32();
3655 25039 : syn_shb_ener_sf[2] = L_shl( syn_shb_ener_sf[2], sub( tmp2, syn_shb_ener_sf_q[2] ) );
3656 25039 : move32();
3657 25039 : syn_shb_ener_sf[3] = L_shl( syn_shb_ener_sf[3], sub( tmp2, syn_shb_ener_sf_q[3] ) );
3658 25039 : move32();
3659 :
3660 : /* i: exc16kWhtnd in Q_bwe_exc */
3661 : /* o: tempSHB in Q_bwe_exc */
3662 : /* o: syn_shb_ener_sf in tmp2 */
3663 25039 : IF( LE_32( bitrate, MAX_ACELP_BRATE ) )
3664 : {
3665 25039 : L_tmp = sum32_fx( syn_shb_ener_sf, 4 );
3666 :
3667 : /* find root_a(tempSHB[0]) = root_a_over_b(shb_ener_sf[0]), L_tmp) */
3668 25039 : tmp = shl( Q_shb, 1 );
3669 25039 : L_tmp2 = root_a_over_b_fx( shb_ener_sf_32, tmp, L_tmp, tmp2, &exp ); /* L_tmp2 in (Q31-exp) */
3670 :
3671 25039 : *Q_bwe_exc = sub( *Q_bwe_exc, exp );
3672 25039 : move16(); /* compensate for the exp shift */
3673 25039 : tmp2 = add( prev_Q_bwe_syn, n_mem2 );
3674 25039 : IF( GT_16( *Q_bwe_exc, tmp2 ) )
3675 : {
3676 0 : L_tmp2 = L_shl( L_tmp2, sub( tmp2, *Q_bwe_exc ) );
3677 0 : *Q_bwe_exc = tmp2;
3678 0 : move16();
3679 : }
3680 8037519 : FOR( i = 0; i < L_FRAME16k; i++ )
3681 : {
3682 8012480 : L_tmp3 = Mult_32_16( L_tmp2, exc16kWhtnd[i] ); /* *Q_bwe_exc + (31-exp) - 15 */
3683 8012480 : exc16kWhtnd[i] = round_fx( L_tmp3 ); /* *Q_bwe_exc - exp */
3684 8012480 : move16();
3685 : }
3686 : }
3687 : /* i: L_tmp2 in (Q31-exp) */
3688 : /* i: exc16kWhtnd in Q_bwe_exc */
3689 : /* o: exc16kWhtnd in Q_bwe_exc: (Q_bwe_exc-exp) */
3690 :
3691 : /* Rescale the past memories: LP synth and SHB look ahead buffers */
3692 25039 : tmp = sub( *Q_bwe_exc, prev_Q_bwe_syn );
3693 275429 : FOR( i = 0; i < LPC_SHB_ORDER; i++ )
3694 : {
3695 250390 : state_lpc_syn[i] = shl_sat( state_lpc_syn[i], tmp );
3696 250390 : move16();
3697 : }
3698 525819 : FOR( i = -L_SHB_LAHEAD; i < 0; i++ )
3699 : {
3700 500780 : excSHB[i] = shl_sat( excSHB[i], tmp );
3701 500780 : move16();
3702 : }
3703 : /* Do mem_stp_swb_fx scaling before PostShortTerm_fx */
3704 :
3705 25039 : syn_filt_fx( 0, lpc_shb_sf, LPC_SHB_ORDER, exc16kWhtnd, excSHB, 80, state_lpc_syn, 1 );
3706 25039 : syn_filt_fx( 0, lpc_shb_sf + ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 80, excSHB + 80, 80, state_lpc_syn, 1 );
3707 25039 : syn_filt_fx( 0, lpc_shb_sf + 2 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 160, excSHB + 160, 80, state_lpc_syn, 1 );
3708 25039 : syn_filt_fx( 0, lpc_shb_sf + 3 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 240, excSHB + 240, 80, state_lpc_syn, 1 );
3709 : /* i: exc16kWhtnd in (Q_bwe_exc) */
3710 : /* o: excSHB in (Q_bwe_exc) */
3711 : }
3712 :
3713 115701 : IF( EQ_16( extl, FB_TBE ) )
3714 : {
3715 43820 : tmp = sub( add( *Q_bwe_exc_fb, 20 ), prev_Q_bwe_exc_fb );
3716 43820 : Scale_sig( fb_state_lpc_syn, LPC_SHB_ORDER, tmp );
3717 43820 : Scale_sig( fb_tbe_demph, 1, tmp );
3718 43820 : syn_filt_fx( 0, lpc_shb, LPC_SHB_ORDER, White_exc16k_FB, White_exc16k_FB_temp, L_FRAME16k, fb_state_lpc_syn, 1 );
3719 : /* i: White_exc16k_FB in (Q_bwe_exc_fb) */
3720 : /* o: White_exc16k_FB_temp in (Q_bwe_exc_fb) */
3721 :
3722 482020 : FOR( i = 0; i < 10; i++ )
3723 : {
3724 14460600 : FOR( j = 0; j < 32; ++j )
3725 : {
3726 14022400 : White_exc16k_FB_temp[i * 32 + j] = mult_r_sat( White_exc16k_FB_temp[i * 32 + j], cos_fb_exc_fx[j] );
3727 14022400 : move16();
3728 : }
3729 : }
3730 :
3731 43820 : *Q_bwe_exc_fb = add( *Q_bwe_exc_fb, 20 );
3732 43820 : move16(); /**Q_bwe_exc_fb +35 +1 -16*/
3733 43820 : flip_spectrum_fx( White_exc16k_FB_temp, White_exc16k_FB, L_FRAME16k );
3734 :
3735 43820 : deemph_fx( White_exc16k_FB, fb_deemph_fac, L_FRAME16k, fb_tbe_demph );
3736 : }
3737 : ELSE
3738 : {
3739 71881 : set16_fx( White_exc16k_FB, 0, L_FRAME16k );
3740 : }
3741 :
3742 115701 : *prev_pow_exc16kWhtnd = L_shr_sat( pow1, Q_pow1 ); // power goes above MAX_32
3743 115701 : *prev_mix_factor = mix_factor;
3744 115701 : move32();
3745 115701 : move16();
3746 :
3747 115701 : return;
3748 : }
3749 :
3750 104728 : void GenShapedSHBExcitation_ivas_dec_fx(
3751 : Word16 *excSHB, /* o : synthesized shaped shb excitation Q_bwe_exc*/
3752 : const Word16 *lpc_shb, /* i : lpc coefficients Q12*/
3753 : Word16 *White_exc16k_FB, /* o : white excitation for the Fullband extension Q_bwe_exc */
3754 : Word32 *mem_csfilt, /* i/o: memory */
3755 : Word16 *mem_genSHBexc_filt_down_shb, /* i/o: memory */
3756 : Word16 *state_lpc_syn, /* i/o: memory */
3757 : const Word16 coder_type, /* i : coding type */
3758 : const Word16 *bwe_exc_extended, /* i : bwidth extended excitation */
3759 : Word16 bwe_seed[], /* i/o: random number generator seed */
3760 : Word16 voice_factors[], /* i : voicing factor*/
3761 : const Word16 extl, /* i : extension layer */
3762 : Word16 *tbe_demph, /* i/o: de-emphasis memory */
3763 : Word16 *tbe_premph, /* i/o: pre-emphasis memory */
3764 : Word16 *lpc_shb_sf, /* i: LP coefficients */
3765 : const Word32 shb_ener_sf_32, /* i: input shb ener, Q31 */
3766 : Word16 *shb_res_gshape, /* i: input res gain shape, Q14 */
3767 : Word16 *shb_res,
3768 : Word16 *vf_ind,
3769 : const Word16 formant_fac, /* i : Formant sharpening factor [0..1] */
3770 : Word16 fb_state_lpc_syn[], /* i/o: memory */
3771 : Word16 *fb_tbe_demph, /* i/o: fb de-emphasis memory */
3772 : Word16 *Q_bwe_exc,
3773 : Word16 *Q_bwe_exc_fb,
3774 : const Word16 Q_shb,
3775 : Word16 n_mem2, /* i : n_mem2 scale factor to adjust 24.4/32kbps memories */
3776 : Word16 prev_Q_bwe_syn, /* i : st_fx->prev_Q_bwe_syn */
3777 : const Word32 bitrate, /* i : bitrate */
3778 : const Word16 prev_bfi, /* i : previous frame was concealed */
3779 : const Word16 element_mode, /* i : element mode */
3780 : const Word16 flag_ACELP16k, /* i : ACELP@16kHz flag */
3781 : Word16 *nlExc16k, /* i/o: NL exc for IC-BWE */
3782 : Word16 *mixExc16k, /* i/o: exc spreading for IC-BWE */
3783 : const Word32 extl_brate, /* i : extension layer bitarte */
3784 : const Word16 MSFlag, /* i : Multi Source flag */
3785 : Word16 EnvSHBres_4k[], /* i/o: TD envelope of the SHB residual signal */
3786 : Word32 *prev_pow_exc16kWhtnd, /* i/o: power of the LB excitation signal in the previous frame */
3787 : Word16 *prev_mix_factor, /* i/o: mixing factor in the previous frame */
3788 : Word16 *Env_error, /* o : error in SHB residual envelope modelling Q0 */
3789 : Word16 Env_error_part[] /* o : per-segment error in SHB residual envelope modelling Q0 */
3790 : )
3791 : {
3792 : Word16 i, j, k;
3793 : Word16 wht_fil_mem[LPC_WHTN_ORDER];
3794 : Word16 lpc_whtn[LPC_WHTN_ORDER + 1];
3795 : Word16 R_h[LPC_WHTN_ORDER + 2]; /* Autocorrelations of windowed speech MSB */
3796 : Word16 R_l[LPC_WHTN_ORDER + 2]; /* Autocorrelations of windowed speech LSB */
3797 : Word16 Q_R;
3798 : Word32 LepsP[LPC_WHTN_ORDER + 1];
3799 : Word16 exc32k[L_FRAME32k], exc16k[L_FRAME16k];
3800 : Word32 pow1, pow22;
3801 : Word16 scale, temp1, temp2, temp3;
3802 : Word16 Q_White_exc16k;
3803 : Word16 excTmp2[L_FRAME16k];
3804 : Word16 *White_exc16k;
3805 : Word16 excNoisyEnv[L_FRAME16k];
3806 104728 : Word16 csfilt_num2[1] = { 6554 }; /*0.2 in Q15 */
3807 104728 : move16();
3808 104728 : Word16 neg_csfilt_den2[2] = { -32767, 26214 }; /* {1.0f, -0.8f} */
3809 104728 : move16();
3810 104728 : move16();
3811 : Word16 varEnvShape;
3812 104728 : Word16 fb_deemph_fac = 15729; /*0.48f in Q15 */
3813 : Word16 exc16kWhtnd[L_FRAME16k];
3814 :
3815 : Word32 L_tmp;
3816 : Word16 vf_tmp;
3817 104728 : Word16 tmp, exp, tmp2 = 0;
3818 104728 : move16();
3819 : Word16 voiceFacEst[NB_SUBFR16k];
3820 : Word16 zero_mem[LPC_SHB_ORDER];
3821 : Word32 syn_shb_ener_sf[4];
3822 : Word16 syn_shb_ener_sf_q[4];
3823 : Word16 tempSHB[80];
3824 : Word16 Q_pow1, Q_pow22;
3825 :
3826 : Word32 L_tmp2, L_tmp3, L_tmp4;
3827 : Word16 temp;
3828 :
3829 : Word16 White_exc16k_FB_temp[L_FRAME16k];
3830 : Word32 White_exc16k_32[L_FRAME16k];
3831 : Word16 White_exc16k_tmp[L_FRAME16k];
3832 : Word16 Q_temp;
3833 : Word16 prev_Q_bwe_exc_fb, Q_exc16kWhtnd;
3834 : Word16 chk1;
3835 : Word32 chk2;
3836 104728 : chk1 = 0;
3837 104728 : chk2 = 0;
3838 104728 : move16();
3839 104728 : move32();
3840 :
3841 : Word16 alpha, step, mem_csfilt_left, mem_csfilt_right, excNoisyEnvLeft[L_FRAME16k], excNoisyEnvRight[L_FRAME16k];
3842 : Word16 cbsize;
3843 : Word16 mix_factor, old_fact, new_fact, fact, old_scale, new_scale, step_scale;
3844 : Word32 c0, c1, c2, c3, c4, c5, den;
3845 : Word16 g1, g2, g, g1_e, g2_e, g_e, den_e, shift, tmp_e, tmp1_e;
3846 : Word16 EnvWhiteExc16k[L_FRAME16k], EnvExc16kWhtnd[L_FRAME16k];
3847 104728 : Word16 EnvWhiteExc16k_4k[L_FRAME4k] = { 0 }, EnvExc16kWhtnd_4k[L_FRAME4k] = { 0 };
3848 : Word16 flag_plosive;
3849 : Word16 delta;
3850 : Word32 c0_part[NUM_SHB_SUBGAINS], c1_part[NUM_SHB_SUBGAINS], c2_part[NUM_SHB_SUBGAINS], c3_part[NUM_SHB_SUBGAINS], c4_part[NUM_SHB_SUBGAINS], c5_part[NUM_SHB_SUBGAINS];
3851 : Word64 W_tmp;
3852 :
3853 104728 : mix_factor = 0; /* Q15 */
3854 104728 : move16();
3855 :
3856 104728 : set16_fx( zero_mem, 0, LPC_SHB_ORDER );
3857 104728 : set16_fx( wht_fil_mem, 0, LPC_WHTN_ORDER );
3858 33617688 : FOR( i = 0; i < L_FRAME32k; i = i + 2 )
3859 : {
3860 33512960 : exc32k[i] = negate( bwe_exc_extended[i] ); // Q_bwe_exc
3861 33512960 : move16();
3862 33512960 : exc32k[i + 1] = bwe_exc_extended[i + 1]; // Q_bwe_exc
3863 33512960 : move16();
3864 : }
3865 :
3866 : /* Decimate by 2 */
3867 104728 : Decimate_allpass_steep_fx( exc32k, mem_genSHBexc_filt_down_shb, 2 * L_FRAME16k, exc16k ); // Q_bwe_exc
3868 : /* i: exc32k in Q_bwe_exc */
3869 : /* o: exc16k in Q_bwe_exc */
3870 :
3871 104728 : autocorr_fx( exc16k, LPC_WHTN_ORDER + 1, R_h, R_l, &Q_R, L_FRAME16k, win_flatten_fx, 0, 1 ); // Q_R
3872 : /* Ensure R[0] isn't zero when entering Levinson Durbin */
3873 104728 : R_l[0] = s_max( R_l[0], 1 );
3874 104728 : move16();
3875 523640 : FOR( i = 1; i <= LPC_WHTN_ORDER; i++ )
3876 : {
3877 418912 : L_tmp = Mpy_32( R_h[i], R_l[i], wac_h[i - 1], wac_l[i - 1] );
3878 418912 : L_Extract( L_tmp, &R_h[i], &R_l[i] ); // Q_R
3879 : }
3880 104728 : E_LPC_lev_dur( R_h, R_l, lpc_whtn, LepsP, LPC_WHTN_ORDER, NULL );
3881 104728 : Copy_Scale_sig( lpc_whtn, lpc_whtn, LPC_WHTN_ORDER + 1, sub( norm_s( lpc_whtn[0] ), 2 ) ); // Q12
3882 104728 : fir_fx( exc16k, lpc_whtn, exc16kWhtnd, wht_fil_mem, L_FRAME16k, LPC_WHTN_ORDER, 0, 3 ); // Q_bwe_exc
3883 :
3884 : /* i: exc16k in Q_bwe_exc */
3885 : /* o: exc16kWhtnd in Q_bwe_exc */
3886 :
3887 104728 : IF( GE_32( extl_brate, SWB_TBE_2k8 ) )
3888 : {
3889 22740 : temp2 = 0;
3890 22740 : move16();
3891 113700 : FOR( j = 0; j < 4; j++ )
3892 : {
3893 90960 : temp1 = shb_res_gshape[j];
3894 90960 : move16();
3895 7367760 : FOR( i = 0; i < 80; i++ )
3896 : {
3897 7276800 : exc16kWhtnd[temp2 + i] = round_fx( L_shl( L_mult( exc16kWhtnd[temp2 + i], temp1 ), 1 ) ); // Q_bwe_exc
3898 7276800 : move16();
3899 : /* exc16kWhtnd in Q_bwe_exc, shb_res_gshape in Q14 */
3900 : }
3901 90960 : temp2 = add( temp2, 80 );
3902 : }
3903 : }
3904 :
3905 : /* Estimate pow1 associated with Low band nonlinear extended excitation */
3906 : /* pow1=0.00001f */
3907 104728 : tmp = sub( shl( *Q_bwe_exc, 1 ), 31 );
3908 104728 : pow1 = L_shl_sat( 21475l /*0.00001f Q31*/, tmp ); /* 0.00001f in 2*(Q_bwe_exc) */
3909 33617688 : FOR( k = 0; k < L_FRAME16k; k++ )
3910 : {
3911 : /*excTmp2[k ] = (float)(fabs(exc16kWhtnd[k]));*/
3912 33512960 : excTmp2[k] = abs_s( exc16kWhtnd[k] );
3913 33512960 : move16();
3914 33512960 : chk1 = s_or( chk1, exc16kWhtnd[k] );
3915 :
3916 : /* pow1 += exc16kWhtnd[k] * exc16kWhtnd[k]; */
3917 33512960 : pow1 = L_mac0_sat( pow1, exc16kWhtnd[k], exc16kWhtnd[k] ); /* 2*Q_bwe_exc */
3918 : }
3919 104728 : Q_pow1 = shl( *Q_bwe_exc, 1 );
3920 :
3921 104728 : test();
3922 :
3923 104728 : IF( flag_ACELP16k == 0 )
3924 : {
3925 : /* varEnvShape = mean_fx(voice_factors, 4); */
3926 : /* unroll the loop */
3927 49209 : L_tmp = L_mult( voice_factors[0], 8192 /*0.25 in Q15 */ );
3928 49209 : L_tmp = L_mac( L_tmp, voice_factors[1], 8192 /*0.25 in Q15 */ );
3929 49209 : L_tmp = L_mac( L_tmp, voice_factors[2], 8192 /*0.25 in Q15 */ );
3930 49209 : varEnvShape = mac_r( L_tmp, voice_factors[3], 8192 /*0.25 in Q15 */ ); /* varEnvShape in Q15 */
3931 : }
3932 : ELSE /* 16k core */
3933 : {
3934 : /* varEnvShape = mean_fx(voice_factors, 5); */
3935 : /* unroll the loop */
3936 55519 : L_tmp = L_mult( voice_factors[0], 6554 /*0.2 in Q15 */ );
3937 55519 : L_tmp = L_mac( L_tmp, voice_factors[1], 6554 /*0.2 in Q15 */ );
3938 55519 : L_tmp = L_mac( L_tmp, voice_factors[2], 6554 /*0.2 in Q15 */ );
3939 55519 : L_tmp = L_mac( L_tmp, voice_factors[3], 6554 /*0.2 in Q15 */ );
3940 55519 : varEnvShape = mac_r( L_tmp, voice_factors[4], 6554 /*0.2 in Q15 */ ); /* varEnvShape in Q15 */
3941 : }
3942 :
3943 104728 : IF( EQ_16( extl, FB_TBE ) )
3944 : {
3945 : /*pow(varEnvShape,3) */
3946 40669 : tmp = mult_r( varEnvShape, varEnvShape );
3947 40669 : tmp = mult_r( tmp, varEnvShape );
3948 :
3949 : /* max_val((0.68f - (float)pow(varEnvShape, 3)), 0.48f); */
3950 40669 : fb_deemph_fac = sub( 22282 /*0.68f Q15*/, tmp );
3951 40669 : fb_deemph_fac = s_max( fb_deemph_fac, 15729 /*0.48f Q15*/ );
3952 : }
3953 :
3954 : /*varEnvShape = 1.09875f - 0.49875f * varEnvShape; */
3955 104728 : varEnvShape = msu_r( 1179773824l /*0.549375f Q31*/, 8172 /*0.249375f Q15*/, varEnvShape );
3956 :
3957 : /*varEnvShape = min( max_val(varEnvShape, 0.6f), 0.999f); */
3958 104728 : varEnvShape = s_max( varEnvShape, 9830 /*0.3f Q15*/ );
3959 104728 : varEnvShape = s_min( varEnvShape, 16368 /*0.4995f Q15*/ );
3960 104728 : varEnvShape = shl( varEnvShape, 1 );
3961 104728 : csfilt_num2[0] = sub( MAX_16, varEnvShape ); // Q15
3962 104728 : move16();
3963 104728 : neg_csfilt_den2[1] = varEnvShape; // Q15
3964 104728 : move16();
3965 :
3966 104728 : test();
3967 104728 : test();
3968 104728 : test();
3969 :
3970 104728 : IF( EQ_16( element_mode, EVS_MONO ) && *mem_csfilt == 0 && ( ( EQ_32( bitrate, ACELP_9k60 ) ) || ( EQ_32( bitrate, ACELP_16k40 ) ) || ( EQ_32( bitrate, ACELP_24k40 ) ) ) )
3971 : {
3972 : /* pre-init smoothing filter to avoid energy drop outs */
3973 0 : L_tmp = L_mult( excTmp2[0], 1638 );
3974 0 : FOR( i = 1; i < L_SUBFR16k / 4; i++ )
3975 : {
3976 0 : L_tmp = L_mac( L_tmp, excTmp2[i], 1638 ); /*1638 = 1/20 in Q15*/
3977 : }
3978 : /*L_tmp = sum(excTmp2, L_SUBFR16k/4)*(1/20) where L_SUBFR16k/4 =20 */
3979 :
3980 : /* don't apply for FB in case the FB start-frame was potentially lost - White_exc16k is very sensitive to enery mismatch between enc - dec */
3981 : /* rather stick to the more conservative approach, to avoid potential clippings */
3982 0 : test();
3983 0 : IF( !( prev_bfi && EQ_16( extl, FB_TBE ) ) )
3984 : {
3985 : /* use weak smoothing for 1st frame after switching to make filter recover more quickly */
3986 0 : varEnvShape = 26214 /*0.8f Q15*/;
3987 0 : move16();
3988 0 : csfilt_num2[0] = sub( MAX_16, varEnvShape );
3989 0 : move16();
3990 0 : neg_csfilt_den2[1] = varEnvShape;
3991 0 : move16();
3992 : }
3993 :
3994 0 : *mem_csfilt = Mult_32_16( L_tmp, varEnvShape );
3995 0 : move32();
3996 : }
3997 :
3998 104728 : IF( MSFlag > 0 )
3999 : {
4000 : // varEnvShape = 0.995f;
4001 5328 : varEnvShape = 32604;
4002 5328 : move16();
4003 5328 : csfilt_num2[0] = 32768 - varEnvShape;
4004 : // csfilt_num2[0] = sub( 32767, varEnvShape );
4005 5328 : move16();
4006 5328 : neg_csfilt_den2[1] = varEnvShape;
4007 5328 : move16();
4008 : }
4009 :
4010 104728 : White_exc16k = exc16k;
4011 104728 : move16();
4012 104728 : Word16 Q_excTmp2 = add( getScaleFactor16( excTmp2, L_FRAME16k ), *Q_bwe_exc );
4013 104728 : IF( *mem_csfilt )
4014 : {
4015 69064 : Q_excTmp2 = s_min( Q_excTmp2, sub( add( norm_l( *mem_csfilt ), *Q_bwe_exc ), 1 ) );
4016 : }
4017 104728 : test();
4018 : /* Track the low band envelope */
4019 104728 : IF( EQ_16( element_mode, IVAS_CPE_TD ) || EQ_16( element_mode, IVAS_CPE_DFT ) )
4020 : {
4021 28451 : test();
4022 28451 : IF( NE_32( extl_brate, SWB_TBE_1k10 ) && NE_32( extl_brate, SWB_TBE_1k75 ) )
4023 : {
4024 24280 : mem_csfilt_left = 0;
4025 24280 : mem_csfilt_right = 0;
4026 24280 : move16();
4027 24280 : move16();
4028 7793880 : FOR( k = 0; k < L_FRAME16k; k++ )
4029 : {
4030 : // excNoisyEnvLeft[k] = mem_csfilt_left + csfilt_num2[0] * excTmp2[k];
4031 7769600 : excNoisyEnvLeft[k] = add( mem_csfilt_left, mult_r( csfilt_num2[0], shl( excTmp2[k], sub( Q_excTmp2, *Q_bwe_exc ) ) ) ); // Q_excTmp2
4032 7769600 : move16();
4033 : // mem_csfilt_left = -csfilt_den2[1] * excNoisyEnvLeft[k];
4034 7769600 : mem_csfilt_left = mult_r( neg_csfilt_den2[1], excNoisyEnvLeft[k] ); // Q_excTmp2
4035 : // excNoisyEnvRight[L_FRAME16k - k - 1] = mem_csfilt_right + csfilt_num2[0] * excTmp2[L_FRAME16k - k - 1];
4036 7769600 : excNoisyEnvRight[L_FRAME16k - k - 1] = add( mem_csfilt_right, mult_r( csfilt_num2[0], shl( excTmp2[L_FRAME16k - k - 1], sub( Q_excTmp2, *Q_bwe_exc ) ) ) ); // Q_excTmp2
4037 7769600 : move16();
4038 : // mem_csfilt_right = -csfilt_den2[1] * excNoisyEnvRight[L_FRAME16k - k - 1];
4039 7769600 : mem_csfilt_right = mult_r( neg_csfilt_den2[1], excNoisyEnvRight[L_FRAME16k - k - 1] ); // Q_excTmp2
4040 : }
4041 :
4042 24280 : alpha = 0;
4043 24280 : move16();
4044 : // step = 1.0f / L_FRAME16k;
4045 24280 : step = 102; // Q15
4046 24280 : move16();
4047 7793880 : FOR( k = 0; k < L_FRAME16k; k++ )
4048 : {
4049 : // excNoisyEnv[k] = alpha * excNoisyEnvLeft[k] + (1 - alpha) * excNoisyEnvRight[k];
4050 7769600 : excNoisyEnv[k] = add( mult_r( alpha, excNoisyEnvLeft[k] ), mult_r( sub( 32767, alpha ), excNoisyEnvRight[k] ) ); // Q_excTmp2
4051 7769600 : move16();
4052 7769600 : alpha = add( alpha, step );
4053 : }
4054 : }
4055 : }
4056 : ELSE
4057 :
4058 : {
4059 : /* Track the low band envelope */
4060 76277 : L_tmp = L_shl( *mem_csfilt, sub( Q_excTmp2, *Q_bwe_exc ) );
4061 76277 : move32();
4062 24484917 : FOR( i = 0; i < L_FRAME16k; i++ )
4063 : {
4064 24408640 : excNoisyEnv[i] = mac_r( L_tmp, csfilt_num2[0], shl( excTmp2[i], sub( Q_excTmp2, *Q_bwe_exc ) ) );
4065 24408640 : move16();
4066 : /* Work-around to avoid 0s for very small value*/
4067 24408640 : test();
4068 24408640 : test();
4069 24408640 : test();
4070 24408640 : test();
4071 24408640 : if ( excNoisyEnv[i] == 0 && ( L_tmp != 0 || ( csfilt_num2[0] != 0 && excTmp2[i] != 0 ) ) )
4072 : {
4073 5237 : excNoisyEnv[i] = 1;
4074 5237 : move16();
4075 : }
4076 : /* excNoisyEnv : Q_excTmp2,
4077 : *mem_csfilt: Q_excTmp2+16, excTmp2: Q_excTmp2, csfilt_num2[0] Q_excTmp2 */
4078 24408640 : L_tmp = L_mult( excNoisyEnv[i], neg_csfilt_den2[1] ); /* Q_excTmp2 + 16 */
4079 : }
4080 76277 : *mem_csfilt = L_shr( L_tmp, sub( Q_excTmp2, *Q_bwe_exc ) );
4081 76277 : move32();
4082 : }
4083 104728 : test();
4084 104728 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
4085 4171 : {
4086 : /* generate gaussian (white) excitation */
4087 1338891 : FOR( k = 0; k < L_FRAME16k; k++ )
4088 : {
4089 1334720 : White_exc16k[k] = own_random( &bwe_seed[0] );
4090 1334720 : move16();
4091 : }
4092 :
4093 : /* normalize the amplitude of the gaussian excitation to that of the LB exc. */
4094 4171 : Word32 pow22_inv = POW_EXC16k_WHTND_FX_INV_SQRT_IN_Q49;
4095 4171 : move32();
4096 4171 : move32();
4097 4171 : pow22 = POW_EXC16k_WHTND_FX;
4098 4171 : Q_pow22 = -6;
4099 4171 : move16();
4100 : // v_multc(White_exc16k, (float)sqrt(pow1 / pow22), White_exc16k, L_FRAME16k);
4101 4171 : Word16 pow1_exp = sub( Q31, Q_pow1 );
4102 4171 : Word32 temp_pow = Sqrt32( pow1, &pow1_exp );
4103 4171 : temp_pow = Mpy_32_32( temp_pow, pow22_inv );
4104 : /*Word16 out_exp;
4105 : Word32 temp_pow1 = root_a_over_b_fx(pow1, Q_pow1, pow22, Q_pow22, &out_exp);
4106 : temp_pow1 = L_shl(temp_pow1, out_exp);*/
4107 : // v_multc_fixed_16_16(White_exc16k, round_fx(temp_pow), White_exc16k, L_FRAME16k);
4108 4171 : L_tmp = 0;
4109 4171 : move32();
4110 4171 : shift = getScaleFactor16( White_exc16k, L_FRAME16k );
4111 1338891 : FOR( k = 0; k < L_FRAME16k; k++ )
4112 : {
4113 1334720 : White_exc16k_32[k] = Mpy_32_16_1( temp_pow, White_exc16k[k] );
4114 1334720 : move32();
4115 1334720 : White_exc16k[k] = round_fx( L_shl( White_exc16k_32[k], shift ) ); // Q_White_exc16k
4116 1334720 : move16();
4117 1334720 : L_tmp = L_max( L_tmp, L_abs( White_exc16k_32[k] ) );
4118 : }
4119 4171 : Q_White_exc16k = add( shift, sub( 49 - 31, pow1_exp ) );
4120 4171 : Q_temp = norm_l( L_tmp );
4121 4171 : IF( L_tmp == 0 )
4122 : {
4123 0 : Q_temp = 31;
4124 0 : move16();
4125 : }
4126 : }
4127 : ELSE
4128 : {
4129 : /* create a random excitation - Reuse exc16k memory */
4130 100557 : White_exc16k = exc16k;
4131 100557 : move16();
4132 100557 : create_random_vector_fx( White_exc16k, L_FRAME, bwe_seed ); // Q5
4133 100557 : create_random_vector_fx( White_exc16k + L_FRAME, L_FRAME16k - L_FRAME, bwe_seed ); // Q5
4134 :
4135 100557 : L_tmp = L_deposit_l( 0 );
4136 100557 : tmp = add( *Q_bwe_exc, 1 );
4137 32278797 : FOR( k = 0; k < L_FRAME16k; k++ )
4138 : {
4139 32178240 : L_tmp4 = L_mult( excNoisyEnv[k], White_exc16k[k] ); /* (Q_excTmp2) +5 +1*/
4140 32178240 : White_exc16k_32[k] = L_tmp4; /* (Q_excTmp2) +5 +1*/
4141 32178240 : move32();
4142 32178240 : L_tmp = L_max( L_tmp, L_abs( White_exc16k_32[k] ) );
4143 : }
4144 100557 : Q_temp = norm_l( L_tmp );
4145 100557 : IF( L_tmp == 0 )
4146 : {
4147 22 : Q_temp = 31;
4148 22 : move16();
4149 : }
4150 : /*Copy_Scale_sig( White_exc16k, White_exc16k, L_FRAME16k, sub(NOISE_QFAC, 5) );)*/
4151 : /* White_exc16k in Q6 */
4152 :
4153 : /* calculate pow22 */
4154 : /* pow22=0.00001f */
4155 100557 : tmp = sub( shl( sub( *Q_bwe_exc, NOISE_QADJ ), 1 ), 31 );
4156 100557 : Word64 sum = W_shl( 21475l /*0.00001f Q31*/, tmp ); /* 0.00001f in 2*(*Q_bwe_exc-NOISE_QADJ) */
4157 100557 : Q_White_exc16k = getScaleFactor32( White_exc16k_32, L_FRAME16k );
4158 32278797 : FOR( k = 0; k < L_FRAME16k; k++ )
4159 : {
4160 :
4161 32178240 : White_exc16k[k] = extract_h( L_shl( White_exc16k_32[k], Q_White_exc16k ) ); // Q_excTmp2 + 6 + Q_White_exc16k - 16 ==> Q_excTmp2 + Q_White_exc16k - 10
4162 32178240 : chk2 = L_or( chk2, White_exc16k_32[k] );
4163 : /* i: excNoisyEnv in (Q_excTmp2) */
4164 : /* i: White_exc16k in Q6 */
4165 : /* o: White_exc16k in (Q_White_exc16k) */
4166 : /* pow22 += White_exc16k[k] * White_exc16k[k]; */
4167 32178240 : sum = W_mac0_16_16( sum, White_exc16k[k], White_exc16k[k] ); /* 2*(Q_excTmp2 + Q_White_exc16k - 10)*/
4168 32178240 : move16();
4169 : }
4170 100557 : Q_pow22 = W_norm( sum );
4171 100557 : pow22 = W_extract_h( W_shl( sum, Q_pow22 ) ); // 2*(Q_excTmp2 + Q_White_exc16k - 10)+Q_pow22-32
4172 100557 : Q_pow22 = sub( add( Q_pow22, shl( sub( add( Q_White_exc16k, Q_excTmp2 ), 10 ), 1 ) ), 32 );
4173 100557 : Q_White_exc16k = add( Q_White_exc16k, sub( Q_excTmp2, 10 ) );
4174 : }
4175 :
4176 104728 : flag_plosive = 0;
4177 104728 : move16();
4178 104728 : test();
4179 104728 : test();
4180 104728 : test();
4181 104728 : IF( GE_32( extl_brate, SWB_TBE_2k8 ) || EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
4182 : {
4183 26911 : IF( EQ_16( *vf_ind, 20 ) ) /* encoder side */
4184 : {
4185 0 : test();
4186 0 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
4187 : {
4188 0 : FOR( k = 0; k < L_FRAME16k; k++ )
4189 : {
4190 0 : White_exc16k_tmp[k] = round_fx( L_shl( White_exc16k_32[k], *Q_bwe_exc ) );
4191 0 : move16();
4192 : }
4193 :
4194 : /* calculate TD envelopes of exc16kWhtnd and White_exc16k */
4195 0 : find_td_envelope_fx( White_exc16k_tmp, L_FRAME16k, 20, NULL, EnvWhiteExc16k ); /* Q_bwe_exc */
4196 0 : find_td_envelope_fx( exc16kWhtnd, L_FRAME16k, 20, NULL, EnvExc16kWhtnd ); /* Q_bwe_exc */
4197 :
4198 0 : FOR( k = 0; k < L_FRAME4k; k++ )
4199 : {
4200 0 : EnvWhiteExc16k_4k[k] = EnvWhiteExc16k[4 * k]; /* Q_bwe_exc */
4201 0 : move16();
4202 0 : EnvExc16kWhtnd_4k[k] = EnvExc16kWhtnd[4 * k]; /* Q_bwe_exc */
4203 0 : move16();
4204 : }
4205 :
4206 : /* calculate the optimal mix factor */
4207 0 : c0 = c1 = c2 = c3 = c4 = c5 = 0; /* Q0 */
4208 0 : move32();
4209 0 : move32();
4210 0 : move32();
4211 0 : move32();
4212 0 : move32();
4213 0 : move32();
4214 :
4215 0 : temp1 = add( shl( *Q_bwe_exc, 1 ), 1 );
4216 0 : temp2 = add( add( Q_shb, *Q_bwe_exc ), 1 );
4217 0 : temp3 = add( shl( Q_shb, 1 ), 1 );
4218 0 : FOR( i = 0; i < NUM_SHB_SUBGAINS; i++ )
4219 : {
4220 : // c0_part[i] = sum2_f( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
4221 0 : c0_part[i] = L_shr( sum2_fx( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), temp1 ); /* Q0 */
4222 0 : move32();
4223 : // c1_part[i] = -2.0f * dotp( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
4224 0 : c1_part[i] = L_shr( L_negate( Dot_product( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ) ), sub( temp2, 1 ) ); /* Q0 */
4225 0 : move32();
4226 : // c2_part[i] = sum2_f( &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
4227 0 : c2_part[i] = L_shr( sum2_fx( &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), temp1 ); /* Q0 */
4228 0 : move32();
4229 : // c3_part[i] = -2.0f * dotp( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
4230 0 : c3_part[i] = L_shr( L_negate( Dot_product( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ) ), sub( temp2, 1 ) ); /* Q0 */
4231 0 : move32();
4232 : // c4_part[i] = 2.0f * dotp( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
4233 0 : c4_part[i] = L_shr( Dot_product( &EnvExc16kWhtnd_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], &EnvWhiteExc16k_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), sub( temp1, 1 ) ); /* Q0 */
4234 0 : move32();
4235 : // c5_part[i] = sum2_f( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS );
4236 0 : c5_part[i] = L_shr( sum2_fx( &EnvSHBres_4k[i * L_FRAME4k / NUM_SHB_SUBGAINS], L_FRAME4k / NUM_SHB_SUBGAINS ), temp3 ); /* Q0 */
4237 0 : move32();
4238 :
4239 0 : c0 = L_add( c0, c0_part[i] );
4240 0 : c1 = L_add( c1, c1_part[i] );
4241 0 : c2 = L_add( c2, c2_part[i] );
4242 0 : c3 = L_add( c3, c3_part[i] );
4243 0 : c4 = L_add( c4, c4_part[i] );
4244 0 : c5 = L_add( c5, c5_part[i] );
4245 : }
4246 :
4247 : // den = 4.0f * c0 * c2 - c4 * c4;
4248 0 : W_tmp = W_sub( W_shl( W_mult0_32_32( c0, c2 ), 2 ), W_mult0_32_32( c4, c4 ) );
4249 0 : den_e = 63;
4250 0 : move16();
4251 0 : shift = W_norm( W_tmp );
4252 0 : den = W_extract_h( W_shl( W_tmp, shift ) );
4253 0 : den_e = sub( den_e, shift );
4254 :
4255 0 : IF( den == 0 )
4256 : {
4257 0 : den = 1;
4258 0 : move32();
4259 0 : den_e = 31;
4260 0 : move16();
4261 : }
4262 :
4263 : // g1 = ( c3 * c4 - 2 * c1 * c2 ) / den;
4264 0 : W_tmp = W_sub( W_mult0_32_32( c3, c4 ), W_shl( W_mult0_32_32( c1, c2 ), 1 ) );
4265 0 : g1_e = 63;
4266 0 : move16();
4267 0 : shift = W_norm( W_tmp );
4268 0 : L_tmp = W_extract_h( W_shl( W_tmp, shift ) );
4269 0 : g1_e = sub( g1_e, shift );
4270 :
4271 0 : g1 = BASOP_Util_Divide3232_Scale( L_tmp, den, &tmp_e );
4272 0 : g1_e = sub( add( tmp_e, g1_e ), den_e );
4273 :
4274 : // g2 = ( c1 * c4 - 2 * c0 * c3 ) / den;
4275 0 : W_tmp = W_sub( W_mult0_32_32( c1, c4 ), W_shl( W_mult0_32_32( c0, c3 ), 1 ) );
4276 0 : g2_e = 63;
4277 0 : move16();
4278 0 : shift = W_norm( W_tmp );
4279 0 : L_tmp = W_extract_h( W_shl( W_tmp, shift ) );
4280 0 : g2_e = sub( g2_e, shift );
4281 :
4282 0 : g2 = BASOP_Util_Divide3232_Scale( L_tmp, den, &tmp_e );
4283 0 : g2_e = sub( add( tmp_e, g2_e ), den_e );
4284 :
4285 : // *Env_error = 0.0f;
4286 0 : *Env_error = 0;
4287 0 : move16();
4288 0 : flag_plosive = 0;
4289 0 : move16();
4290 0 : FOR( i = 0; i < NUM_SHB_SUBGAINS; i++ )
4291 : {
4292 : // Env_error_part[i] = c5_part[i] + g1 * g1 * c0_part[i] + g1 * c1_part[i] + g2 * g2 * c2_part[i] + g2 * c3_part[i] + g1 * g2 * c4_part[i];
4293 0 : L_tmp = BASOP_Util_Add_Mant32Exp( c5_part[i], 31, Mpy_32_32( L_mult( g1, g1 ), c0_part[i] ), add( shl( g1_e, 1 ), 31 ), &tmp_e );
4294 0 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_16_1( c1_part[i], g1 ), add( 31, g1_e ), &tmp_e );
4295 0 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_32( L_mult( g2, g2 ), c2_part[i] ), add( shl( g2_e, 1 ), 31 ), &tmp_e );
4296 0 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_16_1( c3_part[i], g2 ), add( 31, g2_e ), &tmp_e );
4297 0 : L_tmp = BASOP_Util_Add_Mant32Exp( L_tmp, tmp_e, Mpy_32_32( L_mult( g1, g2 ), c4_part[i] ), add( add( g1_e, g2_e ), 31 ), &tmp_e );
4298 :
4299 : // Env_error_part[i] = L_shr( L_tmp, 31 - tmp_e ); // Check Exponent
4300 0 : Env_error_part[i] = extract_h( L_shr_sat( L_tmp, sub( Q15, tmp_e ) ) ); /* Q0 */
4301 0 : move16();
4302 :
4303 : // *Env_error += Env_error_part[i];
4304 0 : *Env_error = add_sat( *Env_error, Env_error_part[i] ); /* Q0 */
4305 0 : move16();
4306 :
4307 0 : if ( GT_16( Env_error_part[i], THR_ENV_ERROR_PLOSIVE_FX ) ) // Check which Q
4308 : {
4309 : /* envelope error is too high -> likely a plosive */
4310 0 : flag_plosive = 1;
4311 0 : move16();
4312 : }
4313 : }
4314 :
4315 0 : IF( flag_plosive )
4316 : {
4317 : /* plosive detected -> set the mixing factor to 0 */
4318 0 : *vf_ind = 0;
4319 0 : move16();
4320 0 : mix_factor = 0;
4321 0 : move16();
4322 : }
4323 : ELSE
4324 : {
4325 : /* normalize gain */
4326 : // g = g2 / ( g1 + g2 );
4327 0 : tmp1_e = BASOP_Util_Add_MantExp( g1, g1_e, g2, g2_e, &tmp );
4328 0 : IF( tmp == 0 )
4329 : {
4330 0 : tmp = 1;
4331 0 : move16();
4332 0 : tmp1_e = 15;
4333 0 : move16();
4334 : }
4335 0 : g = BASOP_Util_Divide1616_Scale( g2, tmp, &tmp_e );
4336 0 : g_e = sub( add( tmp_e, g2_e ), tmp1_e );
4337 :
4338 : /* quantization of the mixing factor */
4339 0 : cbsize = 1 << NUM_BITS_SHB_VF;
4340 0 : move16();
4341 : // delta = 1.0f / ( cbsize - 1 );
4342 0 : delta = 2341; /* Q14 */
4343 0 : move16();
4344 : // if ( g > 1.0f )
4345 0 : IF( BASOP_Util_Cmp_Mant32Exp( g, add( 16, g_e ), ONE_IN_Q31, 0 ) > 0 )
4346 : {
4347 : // g = 1.0f;
4348 0 : g = MAX16B; /* Q15 */
4349 : }
4350 : // else if ( g < shl( delta, ( 15 - g_e ) - 14 ) )
4351 0 : ELSE IF( BASOP_Util_Cmp_Mant32Exp( g, add( 16, g_e ), delta, 17 ) < 0 )
4352 : {
4353 : /* prevent low gains to be quantized to 0 as this is reserved for plosives */
4354 : // g = delta;
4355 0 : g = shl( delta, 1 ); /* Q15 */
4356 : }
4357 :
4358 0 : *vf_ind = usquant_fx( g, &mix_factor, 0, delta, cbsize );
4359 0 : move16();
4360 : }
4361 : }
4362 : ELSE
4363 : {
4364 0 : Estimate_mix_factors_fx( shb_res, Q_shb, exc16kWhtnd, *Q_bwe_exc, White_exc16k,
4365 0 : ( *Q_bwe_exc - NOISE_QADJ ), pow1, Q_pow1, pow22, Q_pow22, voiceFacEst, vf_ind );
4366 0 : tmp = voiceFacEst[0];
4367 0 : tmp2 = MAX_16;
4368 0 : move16();
4369 0 : move16();
4370 0 : if ( LE_16( tmp, 22938 /*0.7f Q15*/ ) )
4371 : {
4372 0 : tmp2 = 26214 /*0.8f Q15*/;
4373 0 : move16();
4374 : }
4375 : }
4376 : }
4377 : ELSE /* decoder side */
4378 : {
4379 26911 : test();
4380 26911 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
4381 : {
4382 4171 : IF( *vf_ind == 0 )
4383 : {
4384 : // mix_factor = 0.0f;
4385 38 : mix_factor = 0;
4386 38 : move16();
4387 38 : flag_plosive = 1;
4388 38 : move16();
4389 : }
4390 : ELSE
4391 : {
4392 : // mix_factor = usdequant(*vf_ind, 0.0f, 1.0f / ((1 << NUM_BITS_SHB_VF) - 1));
4393 4133 : mix_factor = usdequant_fx( *vf_ind, 0, 2341 );
4394 : }
4395 : }
4396 : ELSE
4397 : {
4398 : /* *vf_ind is an integer scale by 0.125f*/
4399 22740 : tmp = shl( *vf_ind, ( 15 - 3 ) );
4400 22740 : tmp2 = MAX_16;
4401 22740 : move16();
4402 22740 : IF( LE_16( tmp, 22938 /*0.7f Q15*/ ) )
4403 : {
4404 22387 : tmp2 = 26214 /*0.8f Q15*/;
4405 22387 : move16();
4406 : }
4407 : }
4408 : }
4409 26911 : test();
4410 26911 : IF( NE_32( extl_brate, SWB_TBE_1k10 ) && NE_32( extl_brate, SWB_TBE_1k75 ) )
4411 : {
4412 22740 : voice_factors[0] = mult_r( voice_factors[0], tmp2 );
4413 22740 : move16();
4414 22740 : voice_factors[1] = mult_r( voice_factors[1], tmp2 );
4415 22740 : move16();
4416 22740 : voice_factors[2] = mult_r( voice_factors[2], tmp2 );
4417 22740 : move16();
4418 22740 : voice_factors[3] = mult_r( voice_factors[3], tmp2 );
4419 22740 : move16();
4420 22740 : voice_factors[4] = mult_r( voice_factors[4], tmp2 );
4421 22740 : move16();
4422 : }
4423 : }
4424 104728 : test();
4425 104728 : IF( GE_16( element_mode, IVAS_CPE_DFT ) && nlExc16k != NULL )
4426 : {
4427 : /* save buffers for IC-BWE */
4428 : // mvr2r(exc16kWhtnd, nlExc16k, L_FRAME16k);
4429 16532 : Copy( exc16kWhtnd, nlExc16k, L_FRAME16k );
4430 : // v_multc(White_exc16k, (float)sqrt(pow1 / pow22), mixExc16k, L_FRAME16k);
4431 : /*Word16 temp_fac = divide3232(L_shr(pow1, Q_pow1), pow22);
4432 : Word16 temp_fac_exp = 0;
4433 : temp_fac = Sqrt16(temp_fac, &temp_fac_exp);*/
4434 16532 : L_tmp = root_a_over_b_fx( pow1, Q_pow1, pow22, Q_pow22, &exp );
4435 16532 : Word16 temp_fac = round_fx_sat( L_shl_sat( L_tmp, exp ) ); // Q15
4436 16532 : shift = sub( sub( *Q_bwe_exc, NOISE_QADJ ), Q_White_exc16k );
4437 : // v_multc_fixed_16_16(White_exc16k,shr(temp_fac, temp_fac_exp) , mixExc16k, L_FRAME16k);
4438 5306772 : FOR( k = 0; k < L_FRAME16k; k++ )
4439 : {
4440 5290240 : mixExc16k[k] = mult_r( shl_sat( White_exc16k[k], shift ), temp_fac );
4441 5290240 : move16();
4442 : }
4443 : }
4444 :
4445 104728 : tmp = sub( Q_temp, 3 );
4446 33617688 : FOR( k = 0; k < L_FRAME16k; k++ )
4447 : {
4448 33512960 : White_exc16k_FB[k] = White_exc16k[k]; /* Q_White_exc16k */
4449 : }
4450 104728 : prev_Q_bwe_exc_fb = *Q_bwe_exc_fb;
4451 104728 : move16();
4452 104728 : *Q_bwe_exc_fb = Q_White_exc16k;
4453 104728 : move16();
4454 104728 : *tbe_demph = shl_sat( *tbe_demph, sub( Q_White_exc16k, sub( *Q_bwe_exc, NOISE_QADJ ) ) );
4455 104728 : deemph_fx( White_exc16k, PREEMPH_FAC, L_FRAME16k, tbe_demph );
4456 104728 : *tbe_demph = shl_sat( *tbe_demph, sub( sub( *Q_bwe_exc, NOISE_QADJ ), Q_White_exc16k ) );
4457 :
4458 104728 : Q_exc16kWhtnd = getScaleFactor16( exc16kWhtnd, L_FRAME16k );
4459 104728 : Q_exc16kWhtnd = add( Q_exc16kWhtnd, *Q_bwe_exc );
4460 :
4461 104728 : shift = getScaleFactor16( White_exc16k, L_FRAME16k );
4462 :
4463 104728 : shift = s_min( Q_exc16kWhtnd, add( shift, Q_White_exc16k ) );
4464 104728 : scale_sig( exc16kWhtnd, L_FRAME16k, sub( shift, *Q_bwe_exc ) );
4465 104728 : scale_sig( White_exc16k, L_FRAME16k, sub( shift, Q_White_exc16k ) );
4466 :
4467 104728 : Q_exc16kWhtnd = Q_White_exc16k = shift;
4468 104728 : move16();
4469 104728 : move16();
4470 104728 : *tbe_premph = shl_sat( *tbe_premph, sub( Q_White_exc16k, sub( *Q_bwe_exc, NOISE_QADJ ) ) );
4471 104728 : move16();
4472 104728 : test();
4473 104728 : IF( EQ_32( extl_brate, SWB_TBE_1k10 ) || EQ_32( extl_brate, SWB_TBE_1k75 ) )
4474 : {
4475 4171 : IF( !flag_plosive ) /* use only LB excitation in case of plosives */
4476 : {
4477 : /* re-scale gaussian excitation at the beginning to gradually move from old energy to new energy */
4478 : // old_scale = (float)sqrt(*prev_pow_exc16kWhtnd / pow1);
4479 : // old_scale = divide3232(*prev_pow_exc16kWhtnd, pow1); // exp = Q15 - (Q_pow1)
4480 : // Word16 old_scale_exp = Q15 - (Q_pow1);
4481 : // old_scale = Sqrt16(old_scale, &old_scale_exp);
4482 : // old_scale = shl(old_scale, old_scale_exp); //Q15
4483 4133 : L_tmp = root_a_over_b_fx( *prev_pow_exc16kWhtnd, 0, pow1, Q_pow1, &exp );
4484 4133 : old_scale = round_fx_sat( L_shl_sat( L_tmp, exp ) ); // Q15
4485 : // new_scale = 1.0f;
4486 4133 : new_scale = 32767;
4487 4133 : move16();
4488 : // step_scale = (new_scale - old_scale) / (L_FRAME16k / 2);
4489 4133 : step_scale = mult_r( sub( new_scale, old_scale ), 205 );
4490 4133 : scale = old_scale;
4491 4133 : move16();
4492 : /* interpolate between the old and the new value of the mixing factor */
4493 4133 : old_fact = *prev_mix_factor;
4494 4133 : move16();
4495 4133 : new_fact = mix_factor;
4496 4133 : move16();
4497 : // step = (new_fact - old_fact) / (L_FRAME16k / 2);
4498 4133 : step = mult_r( sub( new_fact, old_fact ), 205 );
4499 4133 : fact = old_fact;
4500 4133 : move16();
4501 : /* mixing of LB and gaussian excitation in the first half of the frame */
4502 665413 : FOR( k = 0; k < L_FRAME16k / 2; k++ )
4503 : {
4504 661280 : exc16kWhtnd[k] = mac_r( L_mult( fact, mult_r( White_exc16k[k], scale ) ),
4505 661280 : sub( 32767, fact ), exc16kWhtnd[k] ); // Q_exc16kWhtnd
4506 661280 : move16();
4507 661280 : fact = add_sat( fact, step );
4508 661280 : scale = add_sat( scale, step_scale );
4509 : }
4510 :
4511 : /* mixing of LB and gaussian excitation in the second half of the frame */
4512 665413 : FOR( ; k < L_FRAME16k; k++ )
4513 : {
4514 661280 : exc16kWhtnd[k] = mac_r( L_mult( new_fact, White_exc16k[k] ),
4515 661280 : sub( 32767, new_fact ), exc16kWhtnd[k] ); // Q_exc16kWhtnd
4516 661280 : move16();
4517 : }
4518 : }
4519 : // preemph(exc16kWhtnd, PREEMPH_FAC, L_FRAME16k, tbe_premph);
4520 4171 : PREEMPH_FX( exc16kWhtnd, PREEMPH_FAC, L_FRAME16k, tbe_premph );
4521 : }
4522 : ELSE
4523 : {
4524 100557 : test();
4525 100557 : IF( EQ_16( coder_type, UNVOICED ) || EQ_16( MSFlag, 1 ) )
4526 : {
4527 6298 : L_tmp = root_a_over_b_fx( pow1, Q_pow1, pow22, Q_pow22, &exp );
4528 6298 : test();
4529 6298 : if ( chk1 == 0 && chk2 == 0 )
4530 : {
4531 0 : L_tmp = 0;
4532 0 : move32();
4533 : }
4534 6298 : scale = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /*Q15 */
4535 2021658 : FOR( k = 0; k < L_FRAME16k; k++ )
4536 : {
4537 2015360 : exc16kWhtnd[k] = mult_r_sat( White_exc16k[k], scale );
4538 2015360 : move16();
4539 : }
4540 6298 : PREEMPH_FX( exc16kWhtnd, PREEMPH_FAC, L_FRAME16k, tbe_premph );
4541 : /* i/o: exc16kWhtnd (Q_exc16kWhtnd) */
4542 : /* i/o: tbe_premph (Q_exc16kWhtnd) */
4543 : }
4544 : ELSE
4545 : {
4546 : Word16 nbSubFr, lSubFr;
4547 : Word16 tempQ15;
4548 : Word32 tempQ31;
4549 94259 : nbSubFr = NB_SUBFR16k;
4550 94259 : lSubFr = ( L_FRAME16k / NB_SUBFR16k );
4551 94259 : move16();
4552 94259 : move16();
4553 94259 : IF( LT_32( extl_brate, SWB_TBE_2k8 ) )
4554 : {
4555 71530 : nbSubFr = NB_SUBFR;
4556 71530 : move16();
4557 71530 : lSubFr = ( L_FRAME16k / NB_SUBFR );
4558 71530 : move16();
4559 : }
4560 94259 : k = 0;
4561 94259 : move16();
4562 494024 : FOR( i = 0; i < nbSubFr; i++ )
4563 : {
4564 399765 : test();
4565 399765 : IF( EQ_16( coder_type, VOICED ) && ( LT_32( extl_brate, SWB_TBE_2k8 ) ) )
4566 : {
4567 23240 : exp = 0;
4568 23240 : move16();
4569 23240 : tempQ15 = Sqrt16( voice_factors[i], &exp ); /* Q15 */
4570 23240 : temp = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
4571 23240 : exp = 0;
4572 23240 : move16();
4573 23240 : tempQ15 = Sqrt16( temp, &exp ); /* Q15 */
4574 23240 : temp1 = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
4575 :
4576 : /*temp2 = root_a_over_b_fx( pow1 * (1.0f - temp), pow22 ); */
4577 23240 : temp = sub( MAX_16, temp );
4578 23240 : tempQ31 = Mult_32_16( pow1, temp );
4579 23240 : L_tmp = root_a_over_b_fx( tempQ31, Q_pow1, pow22, Q_pow22, &exp );
4580 23240 : temp2 = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /* Q15 whiteEnvShapedExc scale factor */
4581 : }
4582 : ELSE
4583 : {
4584 : /* Adjust noise mixing for formant sharpening filter */
4585 376525 : tempQ15 = mult_r( SWB_NOISE_MIX_FAC_FX, formant_fac );
4586 : /* vf_tmp = voice_factors[i] * (1.0f - vf_tmp); */
4587 376525 : vf_tmp = sub( MAX_16, tempQ15 );
4588 376525 : vf_tmp = mult( voice_factors[i], vf_tmp );
4589 :
4590 376525 : exp = 0;
4591 376525 : move16();
4592 376525 : tempQ15 = Sqrt16( vf_tmp, &exp ); /* Q15 */
4593 376525 : temp1 = shl( tempQ15, exp ); /* Q15 exc16kWhtnd scale factor */
4594 :
4595 : /*temp2 = root_a_over_b(pow1 * (1.0f - vf_tmp), pow22); */
4596 376525 : temp = sub( MAX_16, vf_tmp );
4597 376525 : tempQ31 = Mult_32_16( pow1, temp );
4598 376525 : L_tmp = root_a_over_b_fx( tempQ31, Q_pow1, pow22, Q_pow22, &exp );
4599 376525 : temp2 = round_fx_sat( L_shl_sat( L_tmp, exp ) ); /* Q15 whiteEnvShapedExc scale factor */
4600 : }
4601 :
4602 30562645 : FOR( j = 0; j < lSubFr; j++ )
4603 : {
4604 : /*exc16kWhtnd[k+j] = temp1 * exc16kWhtnd[k+j] + temp2 * White_exc16k[k+j]; */
4605 30162880 : L_tmp = L_mult( temp2, White_exc16k[k + j] );
4606 30162880 : exc16kWhtnd[k + j] = mac_r_sat( L_tmp, temp1, exc16kWhtnd[k + j] );
4607 30162880 : move16();
4608 : /* Q_exc16kWhtnd */
4609 : }
4610 399765 : k = add( k, lSubFr );
4611 :
4612 : /* estimate the pre-emph factor */
4613 399765 : tempQ15 = sub( MAX_16, voice_factors[i] );
4614 399765 : exp = 0;
4615 399765 : move16();
4616 399765 : temp = Sqrt16( tempQ15, &exp );
4617 399765 : temp = shl( temp, sub( exp, 1 ) );
4618 :
4619 399765 : temp2 = add( temp, shl( temp1, -1 ) ); /* shift right by 1 to avoid overflow */
4620 399765 : temp = div_s( temp, temp2 ); /* Q15 */
4621 399765 : temp = mult_r( PREEMPH_FAC, temp );
4622 399765 : PREEMPH_FX( &exc16kWhtnd[i * lSubFr], temp, lSubFr, tbe_premph );
4623 : /* exc16kWhtnd: Q_exc16kWhtnd;
4624 : tbe_premph: Q_exc16kWhtnd*/
4625 : }
4626 : }
4627 : }
4628 104728 : *tbe_premph = shl_sat( *tbe_premph, sub( sub( *Q_bwe_exc, NOISE_QADJ ), Q_White_exc16k ) );
4629 104728 : move16();
4630 104728 : Scale_sig( White_exc16k, L_FRAME16k, sub( sub( *Q_bwe_exc, NOISE_QADJ ), Q_White_exc16k ) );
4631 104728 : Scale_sig( exc16kWhtnd, L_FRAME16k, sub( *Q_bwe_exc, Q_White_exc16k ) );
4632 :
4633 104728 : IF( LT_32( extl_brate, SWB_TBE_2k8 ) )
4634 : {
4635 81988 : Syn_filt_s( 0, lpc_shb, LPC_SHB_ORDER, exc16kWhtnd, excSHB, L_FRAME16k, state_lpc_syn, 1 );
4636 : /* i: exc16kWhtnd in Q_bwe_exc */
4637 : /* o: excSHB in Q_bwe_exc */
4638 : }
4639 : ELSE
4640 : {
4641 22740 : set16_fx( zero_mem, 0, LPC_SHB_ORDER );
4642 :
4643 22740 : Syn_filt_s( 0, lpc_shb_sf, LPC_SHB_ORDER, exc16kWhtnd, tempSHB, 80, zero_mem, 1 );
4644 22740 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
4645 22740 : Scale_sig( tempSHB, 80, tmp );
4646 22740 : syn_shb_ener_sf[0] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
4647 22740 : move32();
4648 22740 : syn_shb_ener_sf_q[0] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
4649 22740 : move16();
4650 :
4651 22740 : Syn_filt_s( 0, lpc_shb_sf + ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 80, tempSHB, 80, zero_mem, 1 );
4652 22740 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
4653 22740 : Scale_sig( tempSHB, 80, tmp );
4654 22740 : syn_shb_ener_sf[1] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
4655 22740 : move32();
4656 22740 : syn_shb_ener_sf_q[1] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
4657 22740 : move16();
4658 :
4659 22740 : Syn_filt_s( 0, lpc_shb_sf + 2 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 160, tempSHB, 80, zero_mem, 1 );
4660 22740 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
4661 22740 : Scale_sig( tempSHB, 80, tmp );
4662 22740 : syn_shb_ener_sf[2] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
4663 22740 : move32();
4664 22740 : syn_shb_ener_sf_q[2] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
4665 22740 : move16();
4666 :
4667 22740 : Syn_filt_s( 0, lpc_shb_sf + 3 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 240, tempSHB, 80, zero_mem, 1 );
4668 22740 : tmp = sub( getScaleFactor16( tempSHB, 80 ), 2 );
4669 22740 : Scale_sig( tempSHB, 80, tmp );
4670 22740 : syn_shb_ener_sf[3] = L_shr( sum2_fx( tempSHB, 80 ), 3 );
4671 22740 : move32();
4672 22740 : syn_shb_ener_sf_q[3] = add( shl( add( *Q_bwe_exc, tmp ), 1 ), 1 );
4673 22740 : move16();
4674 :
4675 22740 : tmp2 = s_min( s_min( syn_shb_ener_sf_q[0], syn_shb_ener_sf_q[1] ), s_min( syn_shb_ener_sf_q[3], syn_shb_ener_sf_q[2] ) );
4676 22740 : syn_shb_ener_sf[0] = L_shl( syn_shb_ener_sf[0], sub( tmp2, syn_shb_ener_sf_q[0] ) );
4677 22740 : move32();
4678 22740 : syn_shb_ener_sf[1] = L_shl( syn_shb_ener_sf[1], sub( tmp2, syn_shb_ener_sf_q[1] ) );
4679 22740 : move32();
4680 22740 : syn_shb_ener_sf[2] = L_shl( syn_shb_ener_sf[2], sub( tmp2, syn_shb_ener_sf_q[2] ) );
4681 22740 : move32();
4682 22740 : syn_shb_ener_sf[3] = L_shl( syn_shb_ener_sf[3], sub( tmp2, syn_shb_ener_sf_q[3] ) );
4683 22740 : move32();
4684 :
4685 : /* i: exc16kWhtnd in Q_bwe_exc */
4686 : /* o: tempSHB in Q_bwe_exc */
4687 : /* o: syn_shb_ener_sf in tmp2 */
4688 22740 : IF( LE_32( bitrate, MAX_ACELP_BRATE ) )
4689 : {
4690 22740 : L_tmp = sum32_fx( syn_shb_ener_sf, 4 );
4691 :
4692 : /* find root_a(tempSHB[0]) = root_a_over_b(shb_ener_sf[0]), L_tmp) */
4693 22740 : tmp = shl( Q_shb, 1 );
4694 22740 : L_tmp2 = root_a_over_b_fx( shb_ener_sf_32, tmp, L_tmp, tmp2, &exp ); /* L_tmp2 in (Q31-exp) */
4695 :
4696 22740 : *Q_bwe_exc = sub( *Q_bwe_exc, exp );
4697 22740 : move16(); /* compensate for the exp shift */
4698 22740 : tmp2 = add( prev_Q_bwe_syn, n_mem2 );
4699 22740 : IF( GT_16( *Q_bwe_exc, tmp2 ) )
4700 : {
4701 0 : L_tmp2 = L_shl( L_tmp2, sub( tmp2, *Q_bwe_exc ) );
4702 0 : *Q_bwe_exc = tmp2;
4703 0 : move16();
4704 : }
4705 7299540 : FOR( i = 0; i < L_FRAME16k; i++ )
4706 : {
4707 7276800 : L_tmp3 = Mult_32_16( L_tmp2, exc16kWhtnd[i] ); /* *Q_bwe_exc + (31-exp) - 15 */
4708 7276800 : exc16kWhtnd[i] = round_fx( L_tmp3 ); /* *Q_bwe_exc - exp */
4709 7276800 : move16();
4710 : }
4711 : }
4712 : /* i: L_tmp2 in (Q31-exp) */
4713 : /* i: exc16kWhtnd in Q_bwe_exc */
4714 : /* o: exc16kWhtnd in Q_bwe_exc: (Q_bwe_exc-exp) */
4715 :
4716 : /* Rescale the past memories: LP synth and SHB look ahead buffers */
4717 22740 : tmp = sub( *Q_bwe_exc, prev_Q_bwe_syn );
4718 250140 : FOR( i = 0; i < LPC_SHB_ORDER; i++ )
4719 : {
4720 227400 : state_lpc_syn[i] = shl_sat( state_lpc_syn[i], tmp );
4721 227400 : move16();
4722 : }
4723 477540 : FOR( i = -L_SHB_LAHEAD; i < 0; i++ )
4724 : {
4725 454800 : excSHB[i] = shl_sat( excSHB[i], tmp );
4726 454800 : move16();
4727 : }
4728 : /* Do mem_stp_swb_fx scaling before PostShortTerm_fx */
4729 :
4730 22740 : Syn_filt_s( 0, lpc_shb_sf, LPC_SHB_ORDER, exc16kWhtnd, excSHB, 80, state_lpc_syn, 1 );
4731 22740 : Syn_filt_s( 0, lpc_shb_sf + ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 80, excSHB + 80, 80, state_lpc_syn, 1 );
4732 22740 : Syn_filt_s( 0, lpc_shb_sf + 2 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 160, excSHB + 160, 80, state_lpc_syn, 1 );
4733 22740 : Syn_filt_s( 0, lpc_shb_sf + 3 * ( LPC_SHB_ORDER + 1 ), LPC_SHB_ORDER, exc16kWhtnd + 240, excSHB + 240, 80, state_lpc_syn, 1 );
4734 : /* i: exc16kWhtnd in (Q_bwe_exc) */
4735 : /* o: excSHB in (Q_bwe_exc) */
4736 : }
4737 :
4738 104728 : IF( EQ_16( extl, FB_TBE ) )
4739 : {
4740 40669 : tmp = sub( add( *Q_bwe_exc_fb, 20 ), prev_Q_bwe_exc_fb );
4741 40669 : Scale_sig( fb_state_lpc_syn, LPC_SHB_ORDER, tmp );
4742 40669 : Scale_sig( fb_tbe_demph, 1, tmp );
4743 40669 : Syn_filt_s( 0, lpc_shb, LPC_SHB_ORDER, White_exc16k_FB, White_exc16k_FB_temp, L_FRAME16k, fb_state_lpc_syn, 1 );
4744 : /* i: White_exc16k_FB in (14-n2) */
4745 : /* o: White_exc16k_FB_temp in (14-n2) */
4746 :
4747 447359 : FOR( i = 0; i < 10; i++ )
4748 : {
4749 13420770 : FOR( j = 0; j < 32; ++j )
4750 : {
4751 13014080 : White_exc16k_FB_temp[i * 32 + j] = mult_r_sat( White_exc16k_FB_temp[i * 32 + j], cos_fb_exc_fx[j] );
4752 13014080 : move16();
4753 : }
4754 : }
4755 :
4756 40669 : *Q_bwe_exc_fb = add( *Q_bwe_exc_fb, 20 );
4757 40669 : move16(); /**Q_bwe_exc_fb +35 +1 -16*/
4758 40669 : flip_spectrum_fx( White_exc16k_FB_temp, White_exc16k_FB, L_FRAME16k );
4759 :
4760 40669 : deemph_fx( White_exc16k_FB, fb_deemph_fac, L_FRAME16k, fb_tbe_demph );
4761 : }
4762 : ELSE
4763 : {
4764 64059 : set16_fx( White_exc16k_FB, 0, L_FRAME16k );
4765 : }
4766 :
4767 104728 : *prev_pow_exc16kWhtnd = L_shr_sat( pow1, Q_pow1 ); // power goes above MAX_32
4768 104728 : *prev_mix_factor = mix_factor;
4769 104728 : return;
4770 : }
4771 :
4772 : /*====================================================================================*/
4773 : /* FUNCTION : void GenSHBSynth_fx() */
4774 : /*------------------------------------------------------------------------------------*/
4775 : /* PURPOSE :Generate 32 KHz sampled highband component from synthesized highband*/
4776 : /*------------------------------------------------------------------------------------*/
4777 : /* INPUT ARGUMENTS */
4778 : /* _(Word16*)input_synspeech :input synthesized speech */
4779 : /* _(Word16) L_frame :ACELP frame length */
4780 : /*------------------------------------------------------------------------------------*/
4781 : /* OUTPUT ARGUMENTS : */
4782 : /* _(Word16*)shb_syn_speech_32k : output highband component */
4783 : /*------------------------------------------------------------------------------------*/
4784 : /* INPUT/OUTPUT ARGUMENTS : */
4785 : /* _(Word16[]) allpass_mem : memory */
4786 : /* _(Word32[]) Hilbert_Mem : memory */
4787 : /*------------------------------------------------------------------------------------*/
4788 : /* RETURN ARGUMENTS : */
4789 : /* _ None */
4790 : /*------------------------------------------------------------------------------------*/
4791 :
4792 3185 : void GenSHBSynth_fx(
4793 : const Word16 *input_synspeech, /* i : input synthesized speech */
4794 : Word16 *shb_syn_speech_32k, /* o : output highband component */
4795 : Word32 Hilbert_Mem[], /* i/o: memory */
4796 : Word16 allpass_mem[], /* i/o: memory */
4797 : const Word16 L_frame, /* i : ACELP frame length */
4798 : Word16 *syn_dm_phase )
4799 : {
4800 : Word16 i, speech_buf_32k[L_FRAME32k];
4801 : Word16 maxm, nor, nor32, shift;
4802 : Word16 input_synspeech_temp[L_FRAME16k];
4803 : Word32 maxm32;
4804 :
4805 :
4806 3185 : maxm = 0;
4807 3185 : move16();
4808 3185 : maxm32 = L_deposit_l( 0 );
4809 1022385 : FOR( i = 0; i < L_FRAME16k; i++ )
4810 1019200 : maxm = s_max( maxm, abs_s( input_synspeech[i] ) );
4811 22295 : FOR( i = 0; i < 2 * ALLPASSSECTIONS_STEEP; i++ )
4812 19110 : maxm = s_max( maxm, abs_s( allpass_mem[i] ) );
4813 70070 : FOR( i = 0; i < HILBERT_MEM_SIZE; i++ )
4814 66885 : maxm32 = L_max( maxm32, L_abs( Hilbert_Mem[i] ) );
4815 3185 : nor = sub( norm_s( maxm ), 3 );
4816 3185 : nor32 = sub( norm_l( maxm32 ), 3 );
4817 3185 : if ( maxm == 0 )
4818 : {
4819 0 : nor = 15;
4820 0 : move16();
4821 : }
4822 3185 : if ( maxm32 == 0 )
4823 : {
4824 2449 : nor32 = 31;
4825 2449 : move16();
4826 : }
4827 3185 : shift = s_min( nor, nor32 );
4828 :
4829 3185 : Copy_Scale_sig( input_synspeech, input_synspeech_temp, L_FRAME16k, shift );
4830 3185 : Scale_sig( allpass_mem, 2 * ALLPASSSECTIONS_STEEP, shift );
4831 3185 : Scale_sig32( Hilbert_Mem, HILBERT_MEM_SIZE, shift );
4832 3185 : Interpolate_allpass_steep_fx( input_synspeech_temp, allpass_mem, L_FRAME16k, speech_buf_32k );
4833 : /*modify_Fs_fx( input_synspeech, L_FRAME16k, 16000, speech_buf_32k, 32000, allpass_mem, 0);*/
4834 3185 : IF( EQ_16( L_frame, L_FRAME ) )
4835 : {
4836 : /* 12.8 k core flipping and downmixing */
4837 1635 : flip_and_downmix_generic_fx( speech_buf_32k, shb_syn_speech_32k, L_FRAME32k,
4838 : Hilbert_Mem,
4839 : Hilbert_Mem + HILBERT_ORDER1,
4840 : Hilbert_Mem + ( HILBERT_ORDER1 + 2 * HILBERT_ORDER2 ),
4841 : syn_dm_phase );
4842 : }
4843 : ELSE
4844 : {
4845 : /* 16 k core flipping and no downmixing */
4846 497550 : FOR( i = 0; i < L_FRAME32k; i = i + 2 )
4847 : {
4848 496000 : shb_syn_speech_32k[i] = negate( speech_buf_32k[i] );
4849 496000 : move16();
4850 496000 : shb_syn_speech_32k[i + 1] = speech_buf_32k[i + 1];
4851 496000 : move16();
4852 : }
4853 : }
4854 :
4855 3185 : Scale_sig( shb_syn_speech_32k, L_FRAME32k, negate( shift ) );
4856 3185 : Scale_sig( allpass_mem, 2 * ALLPASSSECTIONS_STEEP, negate( shift ) );
4857 3185 : Scale_sig32( Hilbert_Mem, HILBERT_MEM_SIZE, negate( shift ) );
4858 :
4859 3185 : return;
4860 : }
4861 :
4862 :
4863 : /* IVAS 32-bit variant */
4864 113466 : void GenSHBSynth_fx32(
4865 : const Word32 *input_synspeech, /* i : input synthesized speech Qx*/
4866 : Word32 *shb_syn_speech_32k, /* o : output highband component Qx*/
4867 : Word32 Hilbert_Mem[], /* i/o: memory Qx*/
4868 : Word32 state_lsyn_filt_shb_local[], /* i/o: memory Qx*/
4869 : const Word16 L_frame, /* i : ACELP frame length */
4870 : Word16 *syn_dm_phase )
4871 : {
4872 : Word32 speech_buf_32k[L_FRAME32k];
4873 : Word16 i;
4874 :
4875 113466 : Word16 shift = 0;
4876 : Word32 maxm32, input_synspeech_temp[L_FRAME16k];
4877 113466 : move16();
4878 :
4879 : /* find the maximum value and derive the shift to improve precision of the Hilber filter */
4880 113466 : maxm32 = L_deposit_l( 0 );
4881 36422586 : FOR( i = 0; i < L_FRAME16k; i++ )
4882 : {
4883 36309120 : maxm32 = L_max( maxm32, L_abs( input_synspeech[i] ) );
4884 : }
4885 :
4886 794262 : FOR( i = 0; i < 2 * ALLPASSSECTIONS_STEEP; i++ )
4887 : {
4888 680796 : maxm32 = L_max( maxm32, L_abs( state_lsyn_filt_shb_local[i] ) );
4889 : }
4890 :
4891 2496252 : FOR( i = 0; i < HILBERT_MEM_SIZE; i++ )
4892 : {
4893 2382786 : maxm32 = L_max( maxm32, L_abs( Hilbert_Mem[i] ) );
4894 : }
4895 :
4896 113466 : IF( maxm32 != 0 )
4897 : {
4898 113417 : shift = sub( norm_l( maxm32 ), 3 );
4899 :
4900 113417 : Copy_Scale_sig32( input_synspeech, input_synspeech_temp, L_FRAME16k, shift );
4901 113417 : Scale_sig32( state_lsyn_filt_shb_local, 2 * ALLPASSSECTIONS_STEEP, shift );
4902 113417 : Scale_sig32( Hilbert_Mem, HILBERT_MEM_SIZE, shift );
4903 : }
4904 : ELSE
4905 : {
4906 49 : Copy32( input_synspeech, input_synspeech_temp, L_FRAME16k );
4907 : }
4908 :
4909 113466 : Interpolate_allpass_steep_fx32( input_synspeech_temp, state_lsyn_filt_shb_local, L_FRAME16k, speech_buf_32k );
4910 :
4911 113466 : IF( EQ_16( L_frame, L_FRAME ) )
4912 : {
4913 49209 : flip_and_downmix_generic_fx32( speech_buf_32k, shb_syn_speech_32k, L_FRAME32k, Hilbert_Mem, Hilbert_Mem + HILBERT_ORDER1, Hilbert_Mem + ( HILBERT_ORDER1 + 2 * HILBERT_ORDER2 ), syn_dm_phase );
4914 : }
4915 : ELSE
4916 : {
4917 41188737 : FOR( i = 0; i < L_FRAME32k; i++ )
4918 : {
4919 : // shb_syn_speech_32k[i] = ( ( i % 2 ) == 0 ) ? ( -speech_buf_32k[i] ) : ( speech_buf_32k[i] );
4920 41124480 : IF( i % 2 == 0 )
4921 : {
4922 20562240 : shb_syn_speech_32k[i] = L_negate( speech_buf_32k[i] ); // Qx
4923 : }
4924 : ELSE
4925 : {
4926 20562240 : shb_syn_speech_32k[i] = speech_buf_32k[i]; // Qx
4927 : }
4928 41124480 : move32();
4929 : }
4930 : }
4931 :
4932 113466 : IF( maxm32 != 0 )
4933 : {
4934 113417 : Scale_sig32( shb_syn_speech_32k, L_FRAME32k, negate( shift ) );
4935 113417 : Scale_sig32( state_lsyn_filt_shb_local, 2 * ALLPASSSECTIONS_STEEP, negate( shift ) );
4936 113417 : Scale_sig32( Hilbert_Mem, HILBERT_MEM_SIZE, negate( shift ) );
4937 : }
4938 :
4939 113466 : return;
4940 : }
4941 :
4942 :
4943 : /*==============================================================================*/
4944 : /* FUNCTION : void ScaleShapedSHB_fx() */
4945 : /*------------------------------------------------------------------------------*/
4946 : /* PURPOSE : */
4947 : /*------------------------------------------------------------------------------*/
4948 : /* INPUT ARGUMENTS : */
4949 : /* _(Word16) length : SHB overlap length */
4950 : /* _(Word16*) subgain : subframe gain Q15 */
4951 : /* _(Word32) frame_gain : frame gain Q18 */
4952 : /* _(Word16*) win : window Q15 */
4953 : /* _(Word16*) subwin : subframes window Q15 */
4954 : /* _(Word16) Q_bwe_exc : Q format */
4955 : /*------------------------------------------------------------------------------*/
4956 : /* OUTPUT ARGUMENTS : */
4957 : /* _(Word16) Qx : Q factor of output */
4958 : /*------------------------------------------------------------------------------*/
4959 : /* INPUT/OUTPUT ARGUMENTS : */
4960 : /* _(Word16*) synSHB : synthesized shb signal input Q_bwe_exc / output Qx */
4961 : /* _(Word16*) overlap : buffer for overlap-add Q_bwe_exc /output Qx */
4962 : /*------------------------------------------------------------------------------*/
4963 : /* RETURN ARGUMENTS : */
4964 : /* _ None */
4965 : /*------------------------------------------------------------------------------*/
4966 : /* CALLED FROM : RX */
4967 : /*==============================================================================*/
4968 :
4969 113761 : void ScaleShapedSHB_fx(
4970 : const Word16 length, /* i : SHB overlap length */
4971 : Word16 *synSHB, /* i/o : synthesized shb signal Q(Q_bwe_exc)/Q(Qx) */
4972 : Word16 *overlap, /* i/o : buffer for overlap-add Q(Q_bwe_exc)/Q(Qx) */
4973 : const Word16 *subgain, /* i : subframe gain Q15 */
4974 : const Word32 frame_gain, /* i : frame gain Q18 */
4975 : const Word16 *win, /* i : window Q15 */
4976 : const Word16 *subwin, /* i : subframes window Q15 */
4977 : Word16 *Q_bwe_exc,
4978 : Word16 *Qx, /* o : newly computed Q factor for synSHB */
4979 : Word16 n_mem3,
4980 : Word16 prev_Q_bwe_syn2 )
4981 : {
4982 : const Word16 *skip;
4983 : Word16 i, j, k, l_shb_lahead, l_frame, l_frame_tmp;
4984 : Word16 join_length, num_join;
4985 : Word32 mod_syn[L_FRAME16k + L_SHB_LAHEAD];
4986 : Word16 sum_gain;
4987 : Word32 L_tmp;
4988 : Word16 tmpQ15;
4989 : Word16 Q_gFr_norm, gain_frame_Q16;
4990 : Word32 L_tmp2;
4991 : Word16 temp1, temp2;
4992 :
4993 : /* Init */
4994 113761 : set32_fx( mod_syn, 0, L_FRAME16k + L_SHB_LAHEAD );
4995 :
4996 : /* apply gain for each subframe, and store noise output signal using overlap-add */
4997 113761 : IF( EQ_16( length, SHB_OVERLAP_LEN / 2 ) )
4998 : {
4999 : /* WB Gain shape and gain frame application with overlap */
5000 7680 : skip = skip_bands_WB_TBE;
5001 7680 : l_frame = L_FRAME16k / 4;
5002 7680 : move16();
5003 7680 : l_shb_lahead = L_SHB_LAHEAD / 4;
5004 7680 : move16();
5005 :
5006 7680 : sum_gain = 0;
5007 7680 : move16();
5008 46080 : FOR( k = 0; k < length / 2; k++ )
5009 : {
5010 38400 : sum_gain = mult_r( subwin[2 * k + 2], subgain[0] ); /* Q15 */
5011 38400 : mod_syn[skip[0] + k] = L_mult( sum_gain, synSHB[skip[0] + k] ); /* Q_bwe_exc + 16 */
5012 38400 : move32();
5013 38400 : mod_syn[skip[0] + k + length / 2] = L_mult( subgain[0], synSHB[skip[0] + k + length / 2] ); /* Q_bwe_exc + 16 */
5014 38400 : move32();
5015 : }
5016 61440 : FOR( i = 1; i < NUM_SHB_SUBFR / 2; i++ )
5017 : {
5018 591360 : FOR( k = 0; k < length; k++ )
5019 : {
5020 : /* one bit headroom here, otherwise messes up the gain shape application */
5021 : /* keep it as L_mult0 */
5022 537600 : L_tmp = L_mult0( subwin[k + 1], subgain[i] ); /* Q30 */
5023 537600 : sum_gain = round_fx( L_mac0( L_tmp, subwin[length - k - 1], subgain[i - 1] ) ); /* Q14 */
5024 537600 : mod_syn[skip[i] + k] = L_shl( L_mult( sum_gain, synSHB[skip[i] + k] ), 1 ); /* Q_bwe_exc + 16 */
5025 537600 : move32();
5026 : }
5027 : }
5028 46080 : FOR( k = 0; k < length / 2; k++ )
5029 : {
5030 38400 : sum_gain = mult_r( subwin[length - 2 * k - 2], subgain[i - 1] ); /* Q15 */
5031 38400 : mod_syn[skip[i] + k] = L_mult( sum_gain, synSHB[skip[i] + k] ); /* Q_bwe_exc + 16 */
5032 38400 : move32();
5033 : }
5034 : }
5035 : ELSE
5036 : {
5037 : /* SWB Gain shape and gain frame application with overlap */
5038 106081 : l_frame = L_FRAME16k;
5039 106081 : move16();
5040 106081 : l_shb_lahead = L_SHB_LAHEAD;
5041 106081 : move16();
5042 106081 : skip = skip_bands_SWB_TBE;
5043 :
5044 106081 : num_join = NUM_SHB_SUBFR / NUM_SHB_SUBGAINS;
5045 106081 : move16();
5046 106081 : join_length = i_mult2( num_join, length );
5047 106081 : j = 0;
5048 106081 : move16();
5049 2227701 : FOR( k = 0; k < length; k++ )
5050 : {
5051 2121620 : sum_gain = mult_r( subwin[k + 1], subgain[0] ); /* Q15 */
5052 2121620 : mod_syn[j] = L_mult( synSHB[j], sum_gain );
5053 2121620 : move32(); /* Q_bwe_exc + 16 */
5054 2121620 : j = add( j, 1 );
5055 : }
5056 :
5057 424324 : FOR( i = 0; i < NUM_SHB_SUBGAINS - 1; i++ )
5058 : {
5059 19412823 : FOR( k = 0; k < join_length - length; k++ )
5060 : {
5061 19094580 : mod_syn[j] = L_mult( synSHB[j], subgain[i * num_join] );
5062 19094580 : move32(); /* Q_bwe_exc + 16 */
5063 19094580 : j = add( j, 1 );
5064 : }
5065 :
5066 6683103 : FOR( k = 0; k < length; k++ )
5067 : {
5068 : /* one bit headroom here, otherwise messes up the gain shape application */
5069 : /* keep it as L_mult0 */
5070 6364860 : L_tmp = L_mult0( subwin[k + 1], subgain[( i + 1 ) * num_join] ); /* Q30 */
5071 6364860 : sum_gain = round_fx( L_mac0( L_tmp, subwin[length - k - 1], subgain[i * num_join] ) ); /*Q14 */
5072 6364860 : mod_syn[j] = L_shl( L_mult( sum_gain, synSHB[j] ), 1 );
5073 6364860 : move32(); /* Q_bwe_exc + 16 */
5074 6364860 : j = add( j, 1 );
5075 : }
5076 : }
5077 6470941 : FOR( k = 0; k < join_length - length; k++ )
5078 : {
5079 6364860 : mod_syn[j] = L_mult( synSHB[j], subgain[( NUM_SHB_SUBGAINS - 1 ) * num_join] );
5080 6364860 : move32(); /* Q_bwe_exc + 16 */
5081 6364860 : j = add( j, 1 );
5082 : }
5083 2227701 : FOR( k = 0; k < length; k++ )
5084 : {
5085 2121620 : sum_gain = mult_r( subwin[length - k - 1], subgain[( NUM_SHB_SUBGAINS - 1 ) * num_join] ); /* Q15 */
5086 2121620 : mod_syn[j] = L_mult( synSHB[j], sum_gain );
5087 2121620 : move32(); /* Q_bwe_exc + 16 */
5088 2121620 : j = add( j, 1 );
5089 : }
5090 : }
5091 :
5092 :
5093 113761 : Q_gFr_norm = norm_l( frame_gain );
5094 113761 : if ( frame_gain == 0 )
5095 : {
5096 0 : Q_gFr_norm = 31;
5097 0 : move16();
5098 : }
5099 113761 : Q_gFr_norm = sub( Q_gFr_norm, 1 ); /* give some headroom */
5100 :
5101 113761 : gain_frame_Q16 = round_fx( L_shl( frame_gain, Q_gFr_norm ) ); /* Q = 18 + Q_gFr_norm - 16
5102 : = (Q_gFr_norm + 2) */
5103 :
5104 113761 : *Q_bwe_exc = add( *Q_bwe_exc, Q_gFr_norm ); /* compensate for the exp shift */
5105 113761 : move16();
5106 113761 : *Q_bwe_exc = sub( *Q_bwe_exc, 13 ); /* Keep Q-fac at => (Q_bwe_exc + Q_gFr_norm - 13) */
5107 113761 : move16();
5108 :
5109 : /* check for headroom of previous buff memories: overlap, Hilbert, and interp all-pass mem */
5110 113761 : tmpQ15 = add( prev_Q_bwe_syn2, n_mem3 );
5111 113761 : if ( GT_16( *Q_bwe_exc, tmpQ15 ) )
5112 : {
5113 3756 : *Q_bwe_exc = tmpQ15;
5114 3756 : move16();
5115 : }
5116 :
5117 113761 : *Qx = *Q_bwe_exc;
5118 113761 : move16();
5119 : /* rescale the overlap memory */
5120 2388981 : FOR( i = 0; i < L_SHB_LAHEAD; i++ )
5121 : {
5122 2275220 : temp2 = 1;
5123 2275220 : move16();
5124 2275220 : if ( overlap[i] < 0 )
5125 : {
5126 825814 : temp2 = -1;
5127 825814 : move16();
5128 : }
5129 2275220 : temp1 = abs_s( overlap[i] );
5130 2275220 : temp1 = shl( temp1, sub( *Q_bwe_exc, prev_Q_bwe_syn2 ) );
5131 2275220 : overlap[i] = i_mult( temp1, temp2 );
5132 2275220 : move16(); /* Q_bwe_exc + Q_gFr_norm - 13 */
5133 : }
5134 :
5135 2273781 : FOR( i = 0; i < l_shb_lahead; i++ )
5136 : {
5137 2160020 : L_tmp = Mpy_32_16_1( mod_syn[i], gain_frame_Q16 ); /* Q_bwe_exc + 16 + Q_gFr_norm + 2 - 15 */
5138 2160020 : L_tmp2 = Mpy_32_16_1( L_tmp, win[i] ); /* (Q_bwe_exc + 16 + Q_gFr_norm + 2 - 15) + 15 + (1-16) */
5139 2160020 : synSHB[i] = mac_r( L_tmp2, overlap[i], MAX_16 );
5140 2160020 : move16(); /* Q_bwe_exc + Q_gFr_norm - 13 */
5141 2160020 : synSHB[i + l_shb_lahead] = round_fx( L_tmp ); /* Q_bwe_exc + Q_gFr_norm - 13 */
5142 2160020 : move16();
5143 : }
5144 :
5145 32514061 : FOR( ; i < l_frame; i++ )
5146 : {
5147 32400300 : L_tmp = Mpy_32_16_1( mod_syn[i], gain_frame_Q16 ); /* Q_bwe_exc + 16 + Q_gFr_norm + 2 - 15 */
5148 32400300 : synSHB[i] = round_fx( L_tmp ); /* Q_bwe_exc + Q_gFr_norm - 13 */
5149 32400300 : move16();
5150 : }
5151 :
5152 113761 : l_frame_tmp = add( l_frame, l_shb_lahead );
5153 2273781 : FOR( ; i < l_frame_tmp; i++ )
5154 : {
5155 2160020 : L_tmp = Mpy_32_16_1( mod_syn[i], gain_frame_Q16 ); /* Q_bwe_exc + 16 + Q_gFr_norm + 2 - 15 */
5156 2160020 : L_tmp = Mpy_32_16_1( L_tmp, win[l_frame + l_shb_lahead - 1 - i] ); /* (Q_bwe_exc + 16 + Q_gFr_norm + 2 - 15) + 15 + (1-16) */
5157 2160020 : overlap[i - l_frame] = round_fx( L_tmp ); /* Q_bwe_exc + Q_gFr_norm - 13 */
5158 2160020 : move16();
5159 : }
5160 :
5161 113761 : return;
5162 : }
5163 :
5164 :
5165 : /* IVAS 32-bit variant */
5166 8738 : void ScaleShapedSHB_fx32(
5167 : const Word16 length, /* i : SHB overlap length */
5168 : Word32 *synSHB_fx, /* i/o: synthesized shb signal Q_inp/Q_new */
5169 : Word32 *overlap_fx, /* i/o: buffer for overlap-add Q_inp/Q_new */
5170 : const Word16 *subgain_fx, /* i : subframe gain Q15 */
5171 : const Word32 frame_gain_fx, /* i : frame gain Q18*/
5172 : const Word16 *win_fx, /* i : window Q15 */
5173 : const Word16 *subwin_fx, /* i : subframes window Q15 */
5174 : Word16 *Q_inp,
5175 : Word16 *Q_new )
5176 : {
5177 : const Word16 *skip;
5178 : Word16 i, j, k, l_shb_lahead, l_frame;
5179 : Word16 join_length, num_join;
5180 : Word32 mod_syn_fx[L_FRAME16k + L_SHB_LAHEAD], L_tmp;
5181 : Word16 sum_gain_fx;
5182 :
5183 : /* initilaization */
5184 8738 : l_frame = L_FRAME16k;
5185 8738 : l_shb_lahead = L_SHB_LAHEAD;
5186 8738 : move16();
5187 8738 : move16();
5188 8738 : skip = skip_bands_SWB_TBE;
5189 :
5190 8738 : IF( EQ_16( length, SHB_OVERLAP_LEN / 2 ) )
5191 : {
5192 0 : skip = skip_bands_WB_TBE;
5193 0 : l_frame = L_FRAME16k / 4;
5194 0 : l_shb_lahead = L_SHB_LAHEAD / 4;
5195 0 : move16();
5196 0 : move16();
5197 : }
5198 :
5199 : /* apply gain for each subframe, and store noise output signal using overlap-add */
5200 8738 : set32_fx( mod_syn_fx, 0, l_frame + l_shb_lahead );
5201 :
5202 8738 : IF( EQ_16( length, SHB_OVERLAP_LEN / 2 ) )
5203 : {
5204 0 : sum_gain_fx = 0;
5205 0 : move16();
5206 0 : FOR( k = 0; k < shr( length, 1 ); k++ )
5207 : {
5208 0 : sum_gain_fx = mult_r( subwin_fx[2 * k + 2], subgain_fx[0] );
5209 0 : mod_syn_fx[skip[0] + k] = Mpy_32_16_1( synSHB_fx[skip[0] + k], sum_gain_fx );
5210 0 : move32(); // Qx
5211 0 : mod_syn_fx[skip[0] + k + length / 2] = Mpy_32_16_1( synSHB_fx[skip[0] + k + length / 2], subgain_fx[0] ); // Qx
5212 0 : move32();
5213 : }
5214 0 : FOR( i = 1; i < NUM_SHB_SUBFR / 2; i++ )
5215 : {
5216 0 : FOR( k = 0; k < length; k++ )
5217 : {
5218 0 : L_tmp = L_mult0( subwin_fx[k + 1], subgain_fx[i] );
5219 0 : sum_gain_fx = round_fx( L_mac0( L_tmp, subwin_fx[length - k - 1], subgain_fx[i - 1] ) );
5220 0 : mod_syn_fx[skip[i] + k] = L_shl( Mpy_32_16_1( synSHB_fx[skip[i] + k], sum_gain_fx ), 1 ); // Qx
5221 0 : move32();
5222 : }
5223 : }
5224 0 : FOR( k = 0; k < shr( length, 1 ); k++ )
5225 : {
5226 0 : sum_gain_fx = mult_r( subwin_fx[length - k * 2 - 2], subgain_fx[i - 1] );
5227 0 : mod_syn_fx[skip[i] + k] = Mpy_32_16_1( synSHB_fx[skip[i] + k], sum_gain_fx ); // Qx
5228 0 : move32();
5229 : }
5230 : }
5231 : ELSE
5232 : {
5233 8738 : num_join = NUM_SHB_SUBFR / NUM_SHB_SUBGAINS;
5234 8738 : join_length = i_mult( num_join, length );
5235 8738 : j = 0;
5236 8738 : move16();
5237 8738 : move16();
5238 183498 : FOR( k = 0; k < length; k++ )
5239 : {
5240 174760 : mod_syn_fx[j] = Mpy_32_16_1( synSHB_fx[j], mult_r( subwin_fx[k + 1], subgain_fx[0] ) ); // Qx
5241 174760 : move32();
5242 174760 : j = add( j, 1 );
5243 : }
5244 34952 : FOR( i = 0; i < NUM_SHB_SUBGAINS - 1; i++ )
5245 : {
5246 1599054 : FOR( k = 0; k < join_length - length; k++ )
5247 : {
5248 1572840 : mod_syn_fx[j] = Mpy_32_16_1( synSHB_fx[j], subgain_fx[i * num_join] ); // Qx
5249 1572840 : move32();
5250 1572840 : j = add( j, 1 );
5251 : }
5252 :
5253 550494 : FOR( k = 0; k < length; k++ )
5254 : {
5255 524280 : L_tmp = L_mult0( subwin_fx[length - k - 1], subgain_fx[i * num_join] );
5256 524280 : mod_syn_fx[j] = L_shl( Mpy_32_16_1( synSHB_fx[j], round_fx( L_mac0( L_tmp, subwin_fx[k + 1], subgain_fx[( i + 1 ) * num_join] ) ) ), 1 ); // Qx
5257 524280 : move32();
5258 524280 : j = add( j, 1 );
5259 : }
5260 : }
5261 533018 : FOR( k = 0; k < join_length - length; k++ )
5262 : {
5263 524280 : mod_syn_fx[j] = Mpy_32_16_1( synSHB_fx[j], subgain_fx[( NUM_SHB_SUBGAINS - 1 ) * num_join] ); // Qx
5264 524280 : move32();
5265 524280 : j = add( j, 1 );
5266 : }
5267 183498 : FOR( k = 0; k < length; k++ )
5268 : {
5269 174760 : mod_syn_fx[j] = Mpy_32_16_1( synSHB_fx[j], mult_r( subwin_fx[length - k - 1], subgain_fx[( NUM_SHB_SUBGAINS - 1 ) * num_join] ) ); // Qx
5270 174760 : move32();
5271 174760 : j = add( j, 1 );
5272 : }
5273 : }
5274 :
5275 8738 : Word16 norm_shift = norm_l( frame_gain_fx );
5276 8738 : if ( frame_gain_fx == 0 )
5277 : {
5278 0 : norm_shift = 31;
5279 0 : move16();
5280 : }
5281 :
5282 8738 : norm_shift = s_min( norm_shift, 14 );
5283 8738 : norm_shift = sub( norm_shift, 1 );
5284 :
5285 8738 : *Q_new = add( *Q_inp, sub( norm_shift, 13 ) ); // Q_new = Q_inp + min(norm_shift,14) - 14;
5286 8738 : move16();
5287 183498 : FOR( i = 0; i < L_SHB_LAHEAD; i++ )
5288 : {
5289 174760 : overlap_fx[i] = L_shl( overlap_fx[i], sub( *Q_new, *Q_inp ) );
5290 174760 : move32();
5291 : }
5292 :
5293 183498 : FOR( i = 0; i < l_shb_lahead; i++ )
5294 : {
5295 174760 : synSHB_fx[i] = Mpy_32_32( mod_syn_fx[i], Mpy_32_16_1( L_shl( frame_gain_fx, norm_shift ), win_fx[i] ) ); // Q_new
5296 174760 : synSHB_fx[i] = L_add( synSHB_fx[i], overlap_fx[i] );
5297 174760 : synSHB_fx[i + l_shb_lahead] = Mpy_32_32( mod_syn_fx[i], L_shl( frame_gain_fx, norm_shift ) ); // Q_new
5298 174760 : move32();
5299 174760 : move32();
5300 174760 : move32();
5301 : }
5302 :
5303 2630138 : FOR( ; i < l_frame; i++ )
5304 : {
5305 2621400 : synSHB_fx[i] = Mpy_32_32( mod_syn_fx[i], L_shl( frame_gain_fx, norm_shift ) ); // Q_new
5306 2621400 : move32();
5307 : }
5308 :
5309 183498 : FOR( ; i < l_frame + l_shb_lahead; i++ )
5310 : {
5311 174760 : synSHB_fx[i] = L_shl( synSHB_fx[i], sub( *Q_new, *Q_inp ) );
5312 174760 : overlap_fx[i - l_frame] = Mpy_32_32( mod_syn_fx[i], Mpy_32_16_1( L_shl( frame_gain_fx, norm_shift ), win_fx[l_frame + l_shb_lahead - 1 - i] ) ); // Q_new
5313 174760 : move32();
5314 174760 : move32();
5315 : }
5316 :
5317 8738 : *Q_inp = *Q_new;
5318 8738 : move16();
5319 8738 : return;
5320 : }
5321 :
5322 :
5323 : /*-------------------------------------------------------------------*
5324 : * ScaleShapedWB()
5325 : *
5326 : *
5327 : *-------------------------------------------------------------------*/
5328 :
5329 7134 : void ScaleShapedWB_fx(
5330 : const Word16 length, /* i : SHB overlap length */
5331 : Word16 *synSHB, /* i/o : synthesized shb signal Q_bwe_exc/Qx */
5332 : Word16 *overlap, /* i/o : buffer for overlap-add Q_bwe_exc/Qx */
5333 : const Word16 *subgain, /* i : subframe gain Q15*/
5334 : const Word32 frame_gain, /* i : frame gain Q18 */
5335 : const Word16 *win, /* i : window Q15*/
5336 : const Word16 *subwin, /* i : subframes window Q15*/
5337 : const Word16 Q_bwe_exc,
5338 : Word16 L_frame, /* i : Frame length - determines whether 12.8 or 16kHz core in-use */
5339 : Word16 dynQ, /* i : indicate whether output is dynamic Q, or Q0 */
5340 : Word16 *Qx, /* o : newly computed Q factor for synSHB */
5341 : Word16 prev_Qx, /* i : prev_Qx for memory scaling */
5342 : Word32 *Hilbert_Mem /* i : Hilbert memory used for computing Qx */
5343 : )
5344 : {
5345 : const Word16 *skip;
5346 : Word16 i, j, k, l_shb_lahead, l_frame, l_frame_tmp;
5347 : Word16 join_length, num_join;
5348 : Word32 mod_syn[L_FRAME16k + L_SHB_LAHEAD];
5349 : Word16 sum_gain;
5350 : Word32 L_tmp;
5351 : Word16 max_val, abs_sig, sc1, sc2, shift, max_headroom, min_shift, max_shift, max_shift2;
5352 : /* Init */
5353 7134 : set32_fx( mod_syn, 0, L_FRAME16k + L_SHB_LAHEAD );
5354 :
5355 : /* apply gain for each subframe, and store noise output signal using overlap-add */
5356 7134 : IF( EQ_16( length, SHB_OVERLAP_LEN / 2 ) )
5357 : {
5358 : /* WB Gain shape and gain frame application with overlap */
5359 7134 : skip = skip_bands_WB_TBE;
5360 7134 : move16();
5361 7134 : l_frame = L_FRAME16k / 4;
5362 7134 : move16();
5363 7134 : l_shb_lahead = L_SHB_LAHEAD / 4;
5364 7134 : move16();
5365 :
5366 7134 : sum_gain = 0;
5367 7134 : move16();
5368 42804 : FOR( k = 0; k < length / 2; k++ )
5369 : {
5370 35670 : sum_gain = mult_r( subwin[2 * k + 2], subgain[0] ); /* Q15 */
5371 35670 : mod_syn[skip[0] + k] = L_mult( sum_gain, synSHB[skip[0] + k] );
5372 35670 : move32(); /* Q_bwe_exc + 16 */
5373 35670 : mod_syn[skip[0] + k + length / 2] = L_mult( subgain[0], synSHB[skip[0] + k + length / 2] );
5374 35670 : move32(); /* Q_bwe_exc + 16 */
5375 : }
5376 57072 : FOR( i = 1; i < NUM_SHB_SUBFR / 2; i++ )
5377 : {
5378 549318 : FOR( k = 0; k < length; k++ )
5379 : {
5380 499380 : L_tmp = L_mult0( subwin[k + 1], subgain[i] ); /* Q30 */
5381 499380 : sum_gain = round_fx( L_mac0( L_tmp, subwin[length - k - 1], subgain[i - 1] ) ); /* Q14 */
5382 499380 : mod_syn[skip[i] + k] = L_shl( L_mult( sum_gain, synSHB[skip[i] + k] ), 1 );
5383 499380 : move32(); /* Q_bwe_exc + 16 */
5384 : }
5385 : }
5386 42804 : FOR( k = 0; k < length / 2; k++ )
5387 : {
5388 35670 : sum_gain = mult_r( subwin[length - 2 * k - 2], subgain[i - 1] ); /* Q15 */
5389 35670 : mod_syn[skip[i] + k] = L_mult( sum_gain, synSHB[skip[i] + k] );
5390 35670 : move32(); /* Q_bwe_exc + 16 */
5391 : }
5392 : }
5393 : ELSE
5394 : {
5395 : /* SWB Gain shape and gain frame application with overlap */
5396 0 : l_frame = L_FRAME16k;
5397 0 : move16();
5398 0 : l_shb_lahead = L_SHB_LAHEAD;
5399 0 : move16();
5400 0 : skip = skip_bands_SWB_TBE;
5401 0 : move16();
5402 :
5403 0 : num_join = NUM_SHB_SUBFR / NUM_SHB_SUBGAINS;
5404 0 : move16();
5405 0 : join_length = i_mult2( num_join, length );
5406 0 : j = 0; /* ptr*/
5407 0 : move16();
5408 0 : FOR( k = 0; k < length; k++ )
5409 : {
5410 0 : sum_gain = mult_r( subwin[k + 1], subgain[0] ); /* Q15 */
5411 0 : mod_syn[j] = L_mult( synSHB[j], sum_gain );
5412 0 : move32(); /* Q_bwe_exc + 16 */
5413 0 : j++;
5414 : }
5415 :
5416 0 : FOR( i = 0; i < NUM_SHB_SUBGAINS - 1; i++ )
5417 : {
5418 0 : FOR( k = 0; k < join_length - length; k++ )
5419 : {
5420 0 : mod_syn[j] = L_mult( synSHB[j], subgain[i * num_join] );
5421 0 : move32(); /* Q_bwe_exc + 16 */
5422 0 : j++;
5423 : }
5424 :
5425 0 : FOR( k = 0; k < length; k++ )
5426 : {
5427 0 : L_tmp = L_mult0( subwin[k + 1], subgain[i_mult2( ( i + 1 ), num_join )] ); /* Q30 */
5428 0 : sum_gain = round_fx( L_mac0( L_tmp, subwin[length - k - 1], subgain[i * num_join] ) ); /*Q14 */
5429 0 : mod_syn[j] = L_shl( L_mult( sum_gain, synSHB[j] ), 1 );
5430 0 : move32(); /* Q_bwe_exc + 16 */
5431 0 : j++;
5432 : }
5433 : }
5434 0 : FOR( k = 0; k < join_length - length; k++ )
5435 : {
5436 0 : mod_syn[j] = L_mult( synSHB[j], subgain[( NUM_SHB_SUBGAINS - 1 ) * num_join] );
5437 0 : move32(); /* Q_bwe_exc + 16 */
5438 0 : j++;
5439 : }
5440 0 : FOR( k = 0; k < length; k++ )
5441 : {
5442 0 : sum_gain = mult_r( subwin[length - k - 1], subgain[( NUM_SHB_SUBGAINS - 1 ) * num_join] ); /* Q15 */
5443 0 : mod_syn[j] = L_mult( synSHB[j], sum_gain );
5444 0 : move32(); /* Q_bwe_exc + 16 */
5445 0 : j++;
5446 : }
5447 : }
5448 :
5449 :
5450 7134 : max_val = 0;
5451 7134 : move16();
5452 613524 : FOR( i = 0; i < l_frame + l_shb_lahead; i++ )
5453 : {
5454 606390 : abs_sig = abs_s( round_fx( mod_syn[i] ) );
5455 606390 : if ( GT_16( abs_sig, max_val ) )
5456 : {
5457 52125 : max_val = abs_sig;
5458 52125 : move16();
5459 : }
5460 : }
5461 :
5462 156948 : FOR( i = 0; i < HILBERT_MEM_SIZE; i++ )
5463 : {
5464 149814 : abs_sig = abs_s( round_fx( Hilbert_Mem[i] ) );
5465 149814 : if ( GT_16( abs_sig, max_val ) )
5466 : {
5467 0 : max_val = abs_sig;
5468 0 : move16();
5469 : }
5470 : }
5471 :
5472 7134 : sc1 = norm_s( max_val ); /* max_val headroom in mod_syn[] */
5473 7134 : sc2 = norm_s( round_fx( frame_gain ) ); /* headroom in GainFrame */
5474 :
5475 7134 : IF( dynQ == 0 )
5476 : {
5477 7134 : shift = sub( 13, Q_bwe_exc ); /* earlier = (10 - Q_bwe_exc) but we changed GainFrame Q21 to Q18 */
5478 7134 : *Qx = 0;
5479 7134 : move16();
5480 : }
5481 0 : ELSE IF( EQ_16( L_frame, L_FRAME ) ) /* 12.8k core */
5482 : {
5483 0 : max_headroom = sub( add( sc1, sc2 ), 4 ); /* Max headroom after multiplying = sc1 + sc2 -3 (keep 3 bit extra headroom) */
5484 : /* 12.8k core needs extra headroom than 16k core */
5485 : /* otherwise Hilbert transform inside flip_and_downmix have saturation, causes ringing in output */
5486 :
5487 : /* Qx = (Q_bwe_exc+3) + shift - 16 */
5488 : /* make sure 14 > Qx > 2 */
5489 0 : min_shift = sub( 2, sub( add( Q_bwe_exc, 3 ), 16 ) );
5490 0 : max_shift = sub( 13, sub( add( Q_bwe_exc, 3 ), 16 ) );
5491 0 : max_shift2 = s_min( max_shift, max_headroom ); /* avoid shifting more than the available max_val headroom to avoid overflow */
5492 :
5493 0 : shift = s_min( min_shift, max_shift2 );
5494 0 : *Qx = sub( add( add( Q_bwe_exc, 3 ), shift ), 16 );
5495 0 : move16();
5496 : }
5497 : ELSE /* 16k core */
5498 : {
5499 0 : max_headroom = sub( add( sc1, sc2 ), 1 ); /* Max headroom after multiplying = sc1 + sc2 -1 (keep 1 bit extra headroom) */
5500 :
5501 : /* Qx = (Q_bwe_exc+3) + shift - 16 */
5502 : /* make sure 14 > Qx > 3 */
5503 0 : min_shift = sub( 3, sub( add( Q_bwe_exc, 3 ), 16 ) );
5504 0 : move16();
5505 0 : max_shift = sub( 13, sub( add( Q_bwe_exc, 3 ), 16 ) );
5506 0 : move16();
5507 0 : max_shift2 = s_min( max_shift, max_headroom ); /* avoid shifting more than the available max_val headroom to avoid overflow */
5508 :
5509 0 : shift = s_min( min_shift, max_shift2 );
5510 0 : *Qx = sub( add( add( Q_bwe_exc, 3 ), shift ), 16 );
5511 0 : move16();
5512 : }
5513 :
5514 : /* bring memory st_fx->syn_overlap_fx[] = overlap[i] to new Q = Qx to prepare for addition */
5515 42804 : FOR( i = 0; i < l_shb_lahead; i++ )
5516 : {
5517 35670 : overlap[i] = shl( overlap[i], sub( *Qx, prev_Qx ) );
5518 35670 : move16();
5519 : }
5520 :
5521 42804 : FOR( i = 0; i < l_shb_lahead; i++ )
5522 : {
5523 : /* mod_syn in (16+Q_bwe_exc), frame_gain in Q18 */
5524 35670 : L_tmp = Mult_32_32( mod_syn[i], frame_gain ); /* L_tmp in (Q_bwe_exc+3) */
5525 35670 : synSHB[i] = round_fx_sat( L_shl_sat( Mult_32_16( L_tmp, win[i] ), shift ) ); /* Qx */
5526 35670 : move16();
5527 35670 : synSHB[i] = add_sat( synSHB[i], overlap[i] );
5528 35670 : move16(); /* Qx */
5529 35670 : synSHB[i + l_shb_lahead] = round_fx_sat( L_shl_sat( L_tmp, shift ) ); /* Qx */
5530 35670 : move16();
5531 : }
5532 :
5533 542184 : FOR( ; i < l_frame; i++ )
5534 : {
5535 535050 : L_tmp = Mult_32_32( mod_syn[i], frame_gain ); /* L_tmp in (Q_bwe_exc+3) */
5536 535050 : synSHB[i] = round_fx_sat( L_shl_sat( L_tmp, shift ) ); /* Qx; */
5537 535050 : move16();
5538 : }
5539 :
5540 7134 : l_frame_tmp = add( l_frame, l_shb_lahead );
5541 42804 : FOR( ; i < l_frame_tmp; i++ )
5542 : {
5543 35670 : L_tmp = Mult_32_32( mod_syn[i], frame_gain ); /* (Q_bwe_exc+3) */
5544 35670 : overlap[i - l_frame] = round_fx_sat( L_shl_sat( Mult_32_16( L_tmp, win[l_frame + l_shb_lahead - 1 - i] ), shift ) ); /* Qx */
5545 35670 : move16();
5546 : }
5547 :
5548 7134 : return;
5549 : }
5550 :
5551 : /*-------------------------------------------------------------------*
5552 : * non_linearity()
5553 : *
5554 : * Apply a non linearity to the SHB excitation
5555 : * -------------------------------------------------------------------*/
5556 :
5557 8140 : static Word32 non_linearity_scaled_copy(
5558 : const Word16 input[],
5559 : Word16 j,
5560 : const Word16 length,
5561 : Word32 output[],
5562 : Word32 prev_scale,
5563 : const Word16 scale_step,
5564 : const Word16 en_abs )
5565 : {
5566 : Word16 i;
5567 : Word32 L_tmp;
5568 :
5569 :
5570 8140 : IF( en_abs )
5571 : {
5572 0 : FOR( i = 0; i < j; i++ )
5573 : {
5574 0 : L_tmp = L_mult_sat( input[i], input[i] ); /* 2*Q_inp+1 */
5575 0 : L_tmp = Mult_32_32( L_tmp, prev_scale ); /* 2*Q_inp */
5576 0 : output[i] = L_tmp;
5577 0 : move32();
5578 :
5579 0 : L_tmp = Mult_32_16( prev_scale, scale_step ); /* Q29 */
5580 0 : prev_scale = L_shl( L_tmp, 1 ); /* Q30 */
5581 : }
5582 0 : FOR( ; i < length; i++ )
5583 : {
5584 0 : L_tmp = L_mult_sat( input[i], input[i] ); /* 2*Q_inp+1 */
5585 0 : L_tmp = Mult_32_32( L_tmp, prev_scale ); /* 2*Q_inp */
5586 0 : output[i] = L_tmp;
5587 0 : move32();
5588 : }
5589 : }
5590 : ELSE
5591 : {
5592 1217286 : FOR( i = 0; i < j; i++ )
5593 : {
5594 1209146 : L_tmp = L_mult_sat( input[i], input[i] ); /* 2*Q_inp+1 */
5595 1209146 : L_tmp = Mult_32_32( L_tmp, prev_scale ); /* 2*Q_inp */
5596 :
5597 1209146 : if ( input[i] < 0 )
5598 : {
5599 606516 : L_tmp = L_negate( L_tmp );
5600 : }
5601 1209146 : output[i] = L_tmp;
5602 1209146 : move32();
5603 :
5604 1209146 : L_tmp = Mult_32_16( prev_scale, scale_step ); /* Q29 */
5605 1209146 : prev_scale = L_shl( L_tmp, 1 ); /* Q30 */
5606 : }
5607 :
5608 1403794 : FOR( ; i < length; i++ )
5609 : {
5610 1395654 : L_tmp = L_mult_sat( input[i], input[i] ); /* 2*Q_inp+1 */
5611 1395654 : L_tmp = Mult_32_32( L_tmp, prev_scale ); /* 2*Q_inp */
5612 :
5613 1395654 : if ( input[i] < 0 )
5614 : {
5615 683075 : L_tmp = L_negate( L_tmp );
5616 : }
5617 1395654 : output[i] = L_tmp;
5618 1395654 : move32();
5619 : }
5620 : }
5621 8140 : return prev_scale;
5622 : }
5623 :
5624 :
5625 : /*-------------------------------------------------------------------*
5626 : * non_linearity()
5627 : *
5628 : * Apply a non linearity to the SHB excitation
5629 : * -------------------------------------------------------------------*/
5630 :
5631 652556 : static Word32 non_linearity_scaled_copy_ivas(
5632 : const Word16 input[],
5633 : Word16 j,
5634 : const Word16 length,
5635 : Word32 output[],
5636 : Word32 prev_scale,
5637 : const Word16 scale_step,
5638 : const Word16 en_abs )
5639 : {
5640 : Word16 i;
5641 : Word32 L_tmp;
5642 :
5643 :
5644 652556 : IF( en_abs )
5645 : {
5646 0 : FOR( i = 0; i < j; i++ )
5647 : {
5648 0 : L_tmp = L_mult( input[i], input[i] ); /* 2*Q_inp+1 */
5649 0 : L_tmp = Mult_32_32( L_tmp, prev_scale ); /* 2*Q_inp */
5650 :
5651 0 : test();
5652 0 : test();
5653 0 : if ( input[i] != 0 && prev_scale != 0 && L_tmp == 0 )
5654 : {
5655 : /* NOTE: this is done to avoid the product to become zero for small non-zero input */
5656 0 : L_tmp = 1;
5657 0 : move16();
5658 : }
5659 :
5660 0 : output[i] = L_tmp;
5661 0 : move32();
5662 :
5663 0 : L_tmp = Mult_32_16( prev_scale, scale_step ); /* Q29 */
5664 0 : prev_scale = L_shl( L_tmp, 1 ); /* Q30 */
5665 : }
5666 0 : FOR( ; i < length; i++ )
5667 : {
5668 : /* L_tmp = (input[i] * input[i]) * prev_scale;*/
5669 0 : L_tmp = Mpy_32_16_1( Mpy_32_16_1( prev_scale, input[i] ), input[i] ); /* 2*Q_inp */
5670 :
5671 0 : test();
5672 0 : test();
5673 0 : if ( input[i] != 0 && prev_scale != 0 && L_tmp == 0 )
5674 : {
5675 : /* NOTE: this is done to avoid the product to become zero for small non-zero input */
5676 0 : L_tmp = 1;
5677 0 : move16();
5678 : }
5679 0 : output[i] = L_tmp;
5680 0 : move32();
5681 : }
5682 : }
5683 : ELSE
5684 : {
5685 96361729 : FOR( i = 0; i < j; i++ )
5686 : {
5687 95709173 : L_tmp = L_mult( input[i], input[i] ); /* 2*Q_inp+1 */
5688 95709173 : L_tmp = Mult_32_32( L_tmp, prev_scale ); /* 2*Q_inp */
5689 :
5690 95709173 : test();
5691 95709173 : test();
5692 95709173 : if ( input[i] != 0 && prev_scale != 0 && L_tmp == 0 )
5693 : {
5694 : /* NOTE: this is done to avoid the product to become zero for small non-zero input */
5695 12104489 : L_tmp = 1;
5696 12104489 : move16();
5697 : }
5698 :
5699 95709173 : if ( input[i] < 0 )
5700 : {
5701 47742798 : L_tmp = L_negate( L_tmp );
5702 : }
5703 95709173 : output[i] = L_tmp;
5704 95709173 : move32();
5705 :
5706 95709173 : L_tmp = Mult_32_16( prev_scale, scale_step ); /* Q29 */
5707 95709173 : prev_scale = L_shl( L_tmp, 1 ); /* Q30 */
5708 : }
5709 :
5710 113761303 : FOR( ; i < length; i++ )
5711 : {
5712 113108747 : L_tmp = L_mult_sat( input[i], input[i] ); /* 2*Q_inp+1 */
5713 113108747 : L_tmp = Mult_32_32( L_tmp, prev_scale ); /* 2*Q_inp */
5714 113108747 : test();
5715 113108747 : test();
5716 113108747 : if ( input[i] != 0 && prev_scale != 0 && L_tmp == 0 )
5717 : {
5718 : /* NOTE: this is done to avoid the product to become zero for small non-zero input */
5719 12665821 : L_tmp = 1;
5720 12665821 : move16();
5721 : }
5722 :
5723 113108747 : if ( input[i] < 0 )
5724 : {
5725 50882874 : L_tmp = L_negate( L_tmp );
5726 : }
5727 113108747 : output[i] = L_tmp;
5728 113108747 : move32();
5729 : }
5730 : }
5731 652556 : return prev_scale;
5732 : }
5733 :
5734 :
5735 : /*==========================================================================*/
5736 : /* FUNCTION : void non_linearity() */
5737 : /*--------------------------------------------------------------------------*/
5738 : /* PURPOSE : Apply a non linearity to the SHB excitation */
5739 : /*--------------------------------------------------------------------------*/
5740 : /* INPUT ARGUMENTS : */
5741 : /* Word16 input[] i : input signal Q_inp */
5742 : /* Word16 length i : input length */
5743 : /*--------------------------------------------------------------------------*/
5744 : /* OUTPUT ARGUMENTS : */
5745 : /* Word32 output[] o : output signal 2*Q_inp */
5746 : /*--------------------------------------------------------------------------*/
5747 : /* INPUT/OUTPUT ARGUMENTS : */
5748 : /* Word32 *prev_scale i/o: memory Q30 */
5749 : /*--------------------------------------------------------------------------*/
5750 : /* RETURN ARGUMENTS : */
5751 : /* _ None */
5752 : /*--------------------------------------------------------------------------*/
5753 : /* CALLED FROM : */
5754 : /*==========================================================================*/
5755 :
5756 4070 : void non_linearity_fx(
5757 : const Word16 input[], /* i : input signal Q_inp */
5758 : Word32 output[], /* o : output signal 2*Q_inp */
5759 : const Word16 length, /* i : input length */
5760 : Word32 *pPrevScale, /* i/o: memory Q30 */
5761 : Word16 Q_inp,
5762 : Word16 coder_type, /* i : Coder Type */
5763 : Word16 *voice_factors, /* i : Voice Factors */
5764 : const Word16 L_frame /* i : ACELP frame length */
5765 :
5766 : )
5767 : {
5768 : Word16 i, j;
5769 4070 : Word16 max_val = 0;
5770 4070 : move16();
5771 : Word32 scale;
5772 : Word16 scale_step;
5773 : Word16 exp, tmp;
5774 : Word16 e_tmp, f_tmp;
5775 : Word16 frac;
5776 : Word32 L_tmp;
5777 : Word32 L_tmp1;
5778 :
5779 4070 : Word16 en_abs = 0;
5780 4070 : Word16 v_fac = 0;
5781 4070 : move16();
5782 4070 : move16();
5783 : Word16 ths;
5784 : Word16 nframes;
5785 : Word32 prev_scale;
5786 : Word16 length_half;
5787 : #ifndef ISSUE_1836_replace_overflow_libcom
5788 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
5789 : Flag Overflow = 0;
5790 : move32();
5791 : #endif
5792 : #endif
5793 :
5794 :
5795 4070 : IF( EQ_16( L_frame, L_FRAME16k ) )
5796 : {
5797 2572 : nframes = 5;
5798 2572 : move16();
5799 2572 : ths = 17817;
5800 2572 : move16(); /* 0.87*5 in Q12 */
5801 : }
5802 : ELSE
5803 : {
5804 1498 : nframes = 4;
5805 1498 : move16();
5806 1498 : ths = 15400;
5807 1498 : move16(); /* 0.94*4 in Q12 */
5808 : }
5809 :
5810 :
5811 22922 : FOR( i = 0; i < nframes; i++ )
5812 : {
5813 18852 : v_fac = add( v_fac, shr( voice_factors[i], 3 ) ); /* Q12 */
5814 : }
5815 :
5816 4070 : test();
5817 4070 : if ( EQ_16( coder_type, VOICED ) && GT_16( v_fac, ths ) )
5818 : {
5819 0 : en_abs = 1;
5820 0 : move16();
5821 : }
5822 :
5823 4070 : length_half = shr( length, 1 );
5824 4070 : prev_scale = *pPrevScale;
5825 4070 : move32();
5826 :
5827 :
5828 : /* Delay Alignment in FX is done inside swb_tbe_enc_fx() */
5829 :
5830 1306470 : FOR( i = j = 0; i < length_half; i++ )
5831 : {
5832 1302400 : tmp = abs_s( input[i] );
5833 1302400 : if ( GT_16( tmp, max_val ) )
5834 : {
5835 29101 : j = i;
5836 29101 : move16();
5837 : }
5838 1302400 : max_val = s_max( max_val, tmp );
5839 : }
5840 :
5841 :
5842 4070 : IF( GT_16( max_val, shl( 1, Q_inp ) ) )
5843 : {
5844 4070 : exp = norm_s( max_val );
5845 4070 : tmp = div_s( shl( 1, sub( 14, exp ) ), max_val ); /* Q(29-exp-Q_inp) */
5846 4070 : scale = L_shl( L_mult( 21955, tmp ), add( exp, sub( Q_inp, 14 ) ) ); /* Q31 */
5847 : }
5848 : ELSE
5849 : {
5850 0 : scale = 1438814044;
5851 0 : move32(); /* Q31; 0.67 in Q31 */
5852 : }
5853 :
5854 4070 : test();
5855 4070 : IF( prev_scale <= 0 || GT_32( Mult_32_16( prev_scale, 32 ), scale ) )
5856 : {
5857 130 : scale_step = 16384;
5858 130 : move16(); /* Q14 */
5859 130 : prev_scale = L_shr( scale, 1 ); /* Q30 */
5860 : }
5861 : ELSE
5862 : {
5863 :
5864 : /* Computing log2(scale) */
5865 3940 : IF( j == 0 )
5866 : {
5867 40 : scale_step = 32767;
5868 40 : move16();
5869 : }
5870 : ELSE
5871 : {
5872 3900 : e_tmp = norm_l( scale );
5873 3900 : f_tmp = Log2_norm_lc( L_shl( scale, e_tmp ) );
5874 3900 : e_tmp = sub( -1, e_tmp );
5875 3900 : L_tmp = Mpy_32_16( e_tmp, f_tmp, MAX_16 ); /* Q16 */
5876 :
5877 : /* Computing log2(prev_scale) */
5878 3900 : e_tmp = norm_l( prev_scale );
5879 3900 : f_tmp = Log2_norm_lc( L_shl( prev_scale, e_tmp ) );
5880 3900 : e_tmp = negate( e_tmp );
5881 3900 : L_tmp1 = Mpy_32_16( e_tmp, f_tmp, MAX_16 ); /* Q16 */
5882 :
5883 : /* log2(scale / prev_scale) = log2(scale) - log2(prev_scale) */
5884 3900 : L_tmp = L_sub( L_tmp, L_tmp1 ); /* Q16 */
5885 :
5886 : /* Computing 1/j */
5887 3900 : exp = norm_s( j );
5888 3900 : tmp = div_s( shl( 1, sub( 14, exp ) ), j ); /* Q(29-exp) */
5889 :
5890 : /* (log2(scale / prev_scale))/length */
5891 : #ifdef ISSUE_1836_replace_overflow_libcom
5892 3900 : L_tmp = L_shl_sat( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ) ); /* Q(16+29-exp+1-16+exp-14)->Q16 */
5893 : #else
5894 : L_tmp = L_shl_o( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ), &Overflow ); /* Q(16+29-exp+1-16+exp-14)->Q16 */
5895 : #endif
5896 :
5897 3900 : frac = L_Extract_lc( L_tmp, &exp ); /* Extract exponent of L_tmp */
5898 :
5899 3900 : tmp = extract_l( Pow2( 14, frac ) );
5900 : #ifdef ISSUE_1836_replace_overflow_libcom
5901 3900 : scale_step = shl_sat( tmp, exp ); /* Q14 */
5902 : #else
5903 : scale_step = shl_o( tmp, exp, &Overflow ); /* Q14 */
5904 : #endif
5905 : }
5906 : }
5907 :
5908 4070 : prev_scale = non_linearity_scaled_copy( input, j, length_half, output, prev_scale, scale_step, en_abs );
5909 :
5910 4070 : max_val = 0;
5911 4070 : move16();
5912 4070 : j = shr( length, 1 );
5913 1306470 : FOR( i = length_half; i < length; i++ )
5914 : {
5915 1302400 : tmp = abs_s( input[i] );
5916 1302400 : if ( GT_16( tmp, max_val ) )
5917 : {
5918 28976 : j = i;
5919 28976 : move16();
5920 : }
5921 1302400 : max_val = s_max( max_val, tmp );
5922 : }
5923 :
5924 4070 : IF( GT_16( max_val, shl( 1, Q_inp ) ) )
5925 : {
5926 4070 : exp = norm_s( max_val );
5927 4070 : tmp = div_s( shl( 1, sub( 14, exp ) ), max_val ); /* Q(29-exp-Q_inp) */
5928 : #ifdef ISSUE_1836_replace_overflow_libcom
5929 4070 : scale = L_shl_sat( L_mult( 21955 /* 0.67 in Q15 */, tmp ), add( exp, sub( Q_inp, 14 ) ) ); /* Q31 */
5930 : #else
5931 : scale = L_shl_o( L_mult( 21955 /* 0.67 in Q15 */, tmp ), add( exp, sub( Q_inp, 14 ) ), &Overflow ); /* Q31 */
5932 : #endif
5933 : }
5934 : ELSE
5935 : {
5936 0 : scale = 1438814044;
5937 0 : move32(); /* Q31; 0.67 in Q31 */
5938 : }
5939 :
5940 4070 : test();
5941 4070 : IF( prev_scale <= 0 || GT_32( Mult_32_16( prev_scale, 32 ), scale ) )
5942 : {
5943 0 : scale_step = 16384;
5944 0 : move16(); /*Q14 */
5945 0 : prev_scale = L_shr( scale, 1 ); /*Q30 */
5946 : }
5947 : ELSE
5948 : {
5949 : /*scale_step = (float) exp(1.0f / (float) (j - length/2) * (float) log(scale / prev_scale)); */
5950 : /* Computing log2(scale) */
5951 4070 : IF( EQ_16( j, length_half ) )
5952 : {
5953 62 : scale_step = 32767;
5954 62 : move16(); /*Q14 */
5955 : }
5956 : ELSE
5957 : {
5958 4008 : e_tmp = norm_l( scale );
5959 4008 : f_tmp = Log2_norm_lc( L_shl( scale, e_tmp ) );
5960 4008 : e_tmp = sub( -e_tmp, 1 );
5961 4008 : L_tmp = Mpy_32_16( e_tmp, f_tmp, 32767 ); /* Q16 */
5962 :
5963 : /* Computing log2(prev_scale) */
5964 4008 : e_tmp = norm_l( prev_scale );
5965 4008 : f_tmp = Log2_norm_lc( L_shl( prev_scale, e_tmp ) );
5966 4008 : e_tmp = negate( e_tmp );
5967 4008 : L_tmp1 = Mpy_32_16( e_tmp, f_tmp, 32767 ); /* Q16 */
5968 :
5969 : /* log2(scale / prev_scale) = log2(scale) - log2(prev_scale) */
5970 4008 : L_tmp = L_sub( L_tmp, L_tmp1 ); /* Q16 */
5971 :
5972 : /* Computing 1/(j - length/2) */
5973 :
5974 4008 : tmp = sub( j, length_half );
5975 4008 : exp = norm_s( tmp );
5976 :
5977 :
5978 4008 : tmp = div_s( shl( 1, sub( 14, exp ) ), tmp ); /* Q(29-exp) */
5979 :
5980 : /* (log2(scale / prev_scale))/length */
5981 : #ifdef ISSUE_1836_replace_overflow_libcom
5982 4008 : L_tmp = L_shl_sat( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ) ); /*Q(16+29-exp+1-16+exp-14)->Q16 */
5983 : #else
5984 : L_tmp = L_shl_o( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ), &Overflow ); /*Q(16+29-exp+1-16+exp-14)->Q16 */
5985 : #endif
5986 :
5987 4008 : frac = L_Extract_lc( L_tmp, &exp ); /* Extract exponent of L_tmp */
5988 :
5989 4008 : tmp = extract_l( Pow2( 14, frac ) );
5990 : #ifdef ISSUE_1836_replace_overflow_libcom
5991 4008 : scale_step = shl_sat( tmp, exp ); /*Q14 */
5992 : #else
5993 : scale_step = shl_o( tmp, exp, &Overflow ); /*Q14 */
5994 : #endif
5995 : }
5996 : }
5997 :
5998 4070 : prev_scale = non_linearity_scaled_copy( input + length_half, sub( j, length_half ), sub( length, length_half ), output + length_half, prev_scale, scale_step, en_abs );
5999 :
6000 4070 : *pPrevScale = prev_scale;
6001 4070 : move32();
6002 :
6003 : /* Delay Alignment in FX is done inside swb_tbe_enc_fx() */
6004 :
6005 4070 : return;
6006 : }
6007 :
6008 :
6009 : /*==========================================================================*/
6010 : /* FUNCTION : void non_linearity_ivas_fx() */
6011 : /*--------------------------------------------------------------------------*/
6012 : /* PURPOSE : Apply a non linearity to the SHB excitation */
6013 : /*--------------------------------------------------------------------------*/
6014 : /* INPUT ARGUMENTS : */
6015 : /* Word16 input[] i : input signal Q_inp */
6016 : /* Word16 length i : input length */
6017 : /*--------------------------------------------------------------------------*/
6018 : /* OUTPUT ARGUMENTS : */
6019 : /* Word32 output[] o : output signal 2*Q_inp */
6020 : /*--------------------------------------------------------------------------*/
6021 : /* INPUT/OUTPUT ARGUMENTS : */
6022 : /* Word32 *prev_scale i/o: memory Q30 */
6023 : /*--------------------------------------------------------------------------*/
6024 : /* RETURN ARGUMENTS : */
6025 : /* _ None */
6026 : /*--------------------------------------------------------------------------*/
6027 : /* CALLED FROM : */
6028 : /*==========================================================================*/
6029 :
6030 326278 : void non_linearity_ivas_fx(
6031 : const Word16 input[], /* i : input signal Q_inp */
6032 : Word32 output[], /* o : output signal 2*Q_inp */
6033 : const Word16 length, /* i : input length */
6034 : Word32 *pPrevScale, /* i/o: memory Q30 */
6035 : Word16 Q_inp,
6036 : Word16 coder_type, /* i : Coder Type */
6037 : Word16 *voice_factors, /* i : Voice Factors */
6038 : const Word16 L_frame /* i : ACELP frame length */
6039 :
6040 : )
6041 : {
6042 : Word16 i, j;
6043 326278 : Word16 max_val = 0;
6044 326278 : move16();
6045 : Word32 scale;
6046 : Word16 scale_step;
6047 : Word16 exp, tmp;
6048 : Word16 e_tmp, f_tmp;
6049 : Word16 frac;
6050 : Word32 L_tmp;
6051 : Word32 L_tmp1;
6052 :
6053 326278 : Word16 en_abs = 0;
6054 326278 : Word16 v_fac = 0;
6055 326278 : move16();
6056 326278 : move16();
6057 : Word16 ths;
6058 : Word16 nframes;
6059 : Word32 prev_scale;
6060 : Word16 length_half;
6061 : #ifndef ISSUE_1836_replace_overflow_libcom
6062 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
6063 : Flag Overflow = 0;
6064 : move32();
6065 : #endif
6066 : #endif
6067 : #ifdef NONBE_1328_FIX_NON_LINEARITY
6068 : Word16 sc_factor;
6069 : #endif
6070 :
6071 326278 : IF( EQ_16( L_frame, L_FRAME16k ) )
6072 : {
6073 154983 : nframes = 5;
6074 154983 : move16();
6075 154983 : ths = 17817;
6076 154983 : move16(); /* 0.87*5 in Q12 */
6077 : }
6078 : ELSE
6079 : {
6080 171295 : nframes = 4;
6081 171295 : move16();
6082 171295 : ths = 15400;
6083 171295 : move16(); /* 0.94*4 in Q12 */
6084 : }
6085 :
6086 :
6087 1786373 : FOR( i = 0; i < nframes; i++ )
6088 : {
6089 1460095 : v_fac = add( v_fac, shr( voice_factors[i], 3 ) ); /* Q12 */
6090 : }
6091 :
6092 326278 : test();
6093 326278 : if ( EQ_16( coder_type, VOICED ) && GT_16( v_fac, ths ) )
6094 : {
6095 0 : en_abs = 1;
6096 0 : move16();
6097 : }
6098 :
6099 326278 : length_half = shr( length, 1 );
6100 326278 : prev_scale = *pPrevScale;
6101 326278 : move32();
6102 :
6103 :
6104 : /* Delay Alignment in FX is done inside swb_tbe_enc_fx() */
6105 :
6106 104735238 : FOR( i = j = 0; i < length_half; i++ )
6107 : {
6108 104408960 : tmp = abs_s( input[i] );
6109 104408960 : if ( GT_16( tmp, max_val ) )
6110 : {
6111 2294514 : j = i;
6112 2294514 : move16();
6113 : }
6114 104408960 : max_val = s_max( max_val, tmp );
6115 : }
6116 :
6117 :
6118 326278 : IF( GT_16( max_val, shl_sat( 1, Q_inp ) ) )
6119 : {
6120 307282 : exp = norm_s( max_val );
6121 307282 : tmp = div_s( shl( 1, sub( 14, exp ) ), max_val ); /* Q(29-exp-Q_inp) */
6122 307282 : scale = L_shl( L_mult( 21955, tmp ), add( exp, sub( Q_inp, 14 ) ) ); /* Q31 */
6123 : }
6124 : ELSE
6125 : {
6126 18996 : scale = 1438814044;
6127 18996 : move32(); /* Q31; 0.67 in Q31 */
6128 : }
6129 :
6130 : #ifdef NONBE_1328_FIX_NON_LINEARITY
6131 : #ifdef FIX_2000_NON_LINEARITY_OVERSHOOT
6132 326278 : sc_factor = s_max( sub( 13, norm_s( add( j, 1 ) ) ), 0 ); /* Adapt the scaling factor allowed depending of max position */
6133 326278 : sc_factor = s_max( sc_factor, 1 ); /* Note: The sc_factor is the log2 of the sc_factor in the float code to simplify condition below */
6134 : #else
6135 : /* sc_factor = 32; */ /* Here we divide prev_scale, so 32 == 2 << (15-10) 1024.0 corresponds to 10 bits and 32 to 5 bits */
6136 : /* if ( element_mode > EVS_MONO ) */ /* element mode is not needed because the function is duplicated for IVAS */
6137 : sc_factor = shl_sat( 1, sub( 16, max( 13 - norm_s( add( j, 1 ) ), 0 ) ) ); /* Adapt the scaling factor allowed depending of max position */
6138 : sc_factor = s_max( s_min( sc_factor, 16384 ), 2 * 32 ); /* note: The thresholding is purposely different between float and BASOP implementations. */
6139 : #endif
6140 326278 : test();
6141 : #ifdef FIX_2000_NON_LINEARITY_OVERSHOOT
6142 326278 : IF( prev_scale <= 0 || GT_32( L_shr( prev_scale, sub( sc_factor, 1 ) /*Q30 -> Q31*/ ), scale /*Q31*/ ) ) /* Since the sc_factor is the log2 of sc_factor in float, we apply it using L_shr */
6143 : #else
6144 : IF( prev_scale <= 0 || GT_32( Mult_32_16( prev_scale, sc_factor ) /*Q30 -> Q31*/, scale /*Q31*/ ) )
6145 : #endif
6146 : #else
6147 : test();
6148 : IF( prev_scale <= 0 || GT_32( Mult_32_16( prev_scale, 64 ) /*Q30 -> Q31*/, scale /*Q31*/ ) )
6149 : #endif
6150 : {
6151 49871 : scale_step = 16384;
6152 49871 : move16(); /* Q14 */
6153 49871 : prev_scale = L_shr( scale, 1 ); /* Q30 */
6154 : }
6155 : ELSE
6156 : {
6157 :
6158 : /* Computing log2(scale) */
6159 276407 : IF( j == 0 )
6160 : {
6161 17958 : scale_step = 32767;
6162 17958 : move16();
6163 : }
6164 : ELSE
6165 : {
6166 258449 : e_tmp = norm_l( scale );
6167 258449 : f_tmp = Log2_norm_lc( L_shl( scale, e_tmp ) );
6168 258449 : e_tmp = sub( -1, e_tmp );
6169 258449 : L_tmp = Mpy_32_16( e_tmp, f_tmp, 32767 ); /* Q16 */
6170 :
6171 : /* Computing log2(prev_scale) */
6172 258449 : e_tmp = norm_l( prev_scale );
6173 258449 : f_tmp = Log2_norm_lc( L_shl( prev_scale, e_tmp ) );
6174 258449 : e_tmp = negate( e_tmp );
6175 258449 : L_tmp1 = Mpy_32_16( e_tmp, f_tmp, 32767 ); /* Q16 */
6176 :
6177 : /* log2(scale / prev_scale) = log2(scale) - log2(prev_scale) */
6178 258449 : L_tmp = L_sub( L_tmp, L_tmp1 ); /* Q16 */
6179 :
6180 : /* Computing 1/j */
6181 258449 : exp = norm_s( j );
6182 258449 : tmp = div_s( shl( 1, sub( 14, exp ) ), j ); /* Q(29-exp) */
6183 :
6184 : /* (log2(scale / prev_scale))/length */
6185 : #ifdef ISSUE_1836_replace_overflow_libcom
6186 258449 : L_tmp = L_shl_sat( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ) ); /* Q(16+29-exp+1-16+exp-14)->Q16 */
6187 : #else
6188 : L_tmp = L_shl_o( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ), &Overflow ); /* Q(16+29-exp+1-16+exp-14)->Q16 */
6189 : #endif
6190 :
6191 258449 : frac = L_Extract_lc( L_tmp, &exp ); /* Extract exponent of L_tmp */
6192 :
6193 258449 : tmp = extract_l( Pow2( 14, frac ) );
6194 : #ifdef ISSUE_1836_replace_overflow_libcom
6195 258449 : scale_step = shl_sat( tmp, exp ); /* Q14 */
6196 : #else
6197 : scale_step = shl_o( tmp, exp, &Overflow ); /* Q14 */
6198 : #endif
6199 : }
6200 : }
6201 :
6202 326278 : prev_scale = non_linearity_scaled_copy_ivas( input, j, length_half, output, prev_scale, scale_step, en_abs );
6203 :
6204 326278 : max_val = 0;
6205 326278 : move16();
6206 326278 : j = shr( length, 1 );
6207 104735238 : FOR( i = length_half; i < length; i++ )
6208 : {
6209 104408960 : tmp = abs_s( input[i] );
6210 104408960 : if ( GT_16( tmp, max_val ) )
6211 : {
6212 2307112 : j = i;
6213 2307112 : move16();
6214 : }
6215 104408960 : max_val = s_max( max_val, tmp );
6216 : }
6217 :
6218 326278 : IF( GT_16( max_val, shl_sat( 1, Q_inp ) ) )
6219 : {
6220 306975 : exp = norm_s( max_val );
6221 306975 : tmp = div_s( shl( 1, sub( 14, exp ) ), max_val ); /* Q(29-exp-Q_inp) */
6222 : #ifdef ISSUE_1836_replace_overflow_libcom
6223 306975 : scale = L_shl_sat( L_mult( 21955, tmp ), add( exp, sub( Q_inp, 14 ) ) ); /* Q31 */
6224 : #else
6225 : scale = L_shl_o( L_mult( 21955, tmp ), add( exp, sub( Q_inp, 14 ) ), &Overflow ); /* Q31 */
6226 : #endif
6227 : }
6228 : ELSE
6229 : {
6230 19303 : scale = 1438814044;
6231 19303 : move32(); /* Q31; 0.67 in Q31 */
6232 : }
6233 :
6234 : #ifdef NONBE_1328_FIX_NON_LINEARITY
6235 : #ifdef FIX_2000_NON_LINEARITY_OVERSHOOT
6236 : /* if ( element_mode > EVS_MONO ) */ /* element mode is not needed because the function is duplicated for IVAS */
6237 326278 : sc_factor = s_max( sub( 12, norm_s( add( sub( j, length_half ), 1 ) ) ), 0 ); /* allowed intra frame jump is smaller */
6238 326278 : sc_factor = s_max( sc_factor, 1 ); /* Note: The sc_factor is the log2 of the sc_factor in the float code to simplify condition below */
6239 : #else
6240 : /* sc_factor = 32; */ /* Here we divide prev_scale, so 32 == 2 << (15-10) 1024.0 corresponds to 10 bits and 32 to 5 bits */
6241 : /* if ( element_mode > EVS_MONO ) */ /* element mode is not needed because the function is duplicated for IVAS */
6242 : sc_factor = shl_sat( 1, sub( 16, max( 12 - norm_s( add( j, 1 ) ), 0 ) ) ); /* Adapt the scaling factor allowed depending of max position */
6243 : sc_factor = s_max( s_min( sc_factor, 16384 ), 2 * 32 ); /* note: The thresholding is purposely different between float and BASOP implementations. */
6244 : #endif
6245 :
6246 326278 : test();
6247 : #ifdef FIX_2000_NON_LINEARITY_OVERSHOOT
6248 326278 : IF( prev_scale <= 0 || GT_32( L_shr( prev_scale, sub( sc_factor, 1 ) /*Q30 -> Q31*/ ), scale /*Q31*/ ) ) /* Since the sc_factor is the log2 of sc_factor in float, we apply it using L_shr */
6249 : #else
6250 : IF( prev_scale <= 0 || GT_32( Mult_32_16( prev_scale, sc_factor ) /*Q30 -> Q31*/, scale /*Q31*/ ) )
6251 : #endif
6252 : #else
6253 : IF( prev_scale <= 0 || GT_32( Mult_32_16( prev_scale, 64 ), scale ) )
6254 : #endif
6255 : {
6256 457 : scale_step = 16384;
6257 457 : move16(); /*Q14 */
6258 457 : prev_scale = L_shr( scale, 1 ); /*Q30 */
6259 : }
6260 : ELSE
6261 : {
6262 : /*scale_step = (float) exp(1.0f / (float) (j - length/2) * (float) log(scale / prev_scale)); */
6263 : /* Computing log2(scale) */
6264 325821 : IF( EQ_16( j, length_half ) )
6265 : {
6266 20459 : scale_step = 32767;
6267 20459 : move16(); /*Q14 */
6268 : }
6269 : ELSE
6270 : {
6271 305362 : e_tmp = norm_l( scale );
6272 305362 : f_tmp = Log2_norm_lc( L_shl( scale, e_tmp ) );
6273 305362 : e_tmp = sub( -e_tmp, 1 );
6274 305362 : L_tmp = Mpy_32_16( e_tmp, f_tmp, 32767 ); /* Q16 */
6275 :
6276 : /* Computing log2(prev_scale) */
6277 305362 : e_tmp = norm_l( prev_scale );
6278 305362 : f_tmp = Log2_norm_lc( L_shl( prev_scale, e_tmp ) );
6279 305362 : e_tmp = negate( e_tmp );
6280 305362 : L_tmp1 = Mpy_32_16( e_tmp, f_tmp, 32767 ); /* Q16 */
6281 :
6282 : /* log2(scale / prev_scale) = log2(scale) - log2(prev_scale) */
6283 305362 : L_tmp = L_sub( L_tmp, L_tmp1 ); /* Q16 */
6284 :
6285 : /* Computing 1/(j - length/2) */
6286 :
6287 305362 : tmp = sub( j, length_half );
6288 305362 : exp = norm_s( tmp );
6289 :
6290 :
6291 305362 : tmp = div_s( shl( 1, sub( 14, exp ) ), tmp ); /* Q(29-exp) */
6292 :
6293 : /* (log2(scale / prev_scale))/length */
6294 : #ifdef ISSUE_1836_replace_overflow_libcom
6295 305362 : L_tmp = L_shl_sat( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ) ); /*Q(16+29-exp+1-16+exp-14)->Q16 */
6296 : #else
6297 : L_tmp = L_shl_o( Mult_32_16( L_tmp, tmp ), sub( exp, 14 ), &Overflow ); /*Q(16+29-exp+1-16+exp-14)->Q16 */
6298 : #endif
6299 :
6300 305362 : frac = L_Extract_lc( L_tmp, &exp ); /* Extract exponent of L_tmp */
6301 :
6302 305362 : tmp = extract_l( Pow2( 14, frac ) );
6303 : #ifdef ISSUE_1836_replace_overflow_libcom
6304 305362 : scale_step = shl_sat( tmp, exp ); /*Q14 */
6305 : #else
6306 : scale_step = shl_o( tmp, exp, &Overflow ); /*Q14 */
6307 : #endif
6308 : }
6309 : }
6310 :
6311 326278 : prev_scale = non_linearity_scaled_copy_ivas( input + length_half, sub( j, length_half ), sub( length, length_half ), output + length_half, prev_scale, scale_step, en_abs );
6312 :
6313 326278 : *pPrevScale = prev_scale;
6314 326278 : move32();
6315 :
6316 : /* Delay Alignment in FX is done inside swb_tbe_enc_fx() */
6317 :
6318 326278 : return;
6319 : }
6320 :
6321 :
6322 : /*-------------------------------------------------------------------*
6323 : * create_random_vector()
6324 : *
6325 : * creates random number vector
6326 : * Note: the abs(max_val) value coming out of create_random_vector should
6327 : * fit into the precision of Q6.
6328 : * -------------------------------------------------------------------*/
6329 :
6330 444180 : void create_random_vector_fx(
6331 : Word16 output[], /* o : output random vector Q5*/
6332 : const Word16 length, /* i : length of random vector */
6333 : Word16 seed[] /* i/o: start seed */
6334 : )
6335 : {
6336 : Word16 i, j, k;
6337 : Word16 scale1, scale2;
6338 : Word32 L_tmp;
6339 :
6340 444180 : L_tmp = L_abs( Mult_32_16( 2144047674, Random( &seed[0] ) ) ); /*Q23 */
6341 444180 : j = extract_l( L_shr( L_tmp, 23 ) );
6342 444180 : j = s_and( j, 0xff );
6343 :
6344 444180 : L_tmp = L_abs( Mult_32_16( 2144047674, Random( &seed[1] ) ) ); /*Q23 */
6345 444180 : k = extract_l( L_shr( L_tmp, 23 ) );
6346 444180 : k = s_and( k, 0xff );
6347 :
6348 445689 : WHILE( EQ_16( k, j ) )
6349 : {
6350 1509 : L_tmp = L_abs( Mult_32_16( 2144047674, Random( &seed[1] ) ) ); /*Q23 */
6351 1509 : k = extract_l( L_shr( L_tmp, 23 ) );
6352 1509 : k = s_and( k, 0xff );
6353 : }
6354 :
6355 444180 : scale1 = 18021;
6356 444180 : move16(); /* 200.00f * 0.35f/0.1243f; */
6357 444180 : if ( Random( &seed[0] ) < 0 )
6358 : {
6359 221079 : scale1 = -18021;
6360 221079 : move16(); /*Q5 */ /* -200.00f * 0.35f/0.1243f; */
6361 : }
6362 :
6363 444180 : scale2 = 7208;
6364 444180 : move16(); /* 80.00f * 0.35f/0.1243f; */
6365 444180 : if ( Random( &seed[1] ) < 0 )
6366 : {
6367 230203 : scale2 = -7208;
6368 230203 : move16(); /*Q5 */ /* -80.00f * 0.35f/0.1243f; */
6369 : }
6370 :
6371 70327860 : FOR( i = 0; i < length; i++ )
6372 : {
6373 69883680 : j = s_and( j, 0xff );
6374 69883680 : k = s_and( k, 0xff );
6375 69883680 : output[i] = round_fx( L_add( L_mult( scale1, gaus_dico_swb_fx[j] ), L_mult( scale2, gaus_dico_swb_fx[k] ) ) ); /*Q5 */
6376 69883680 : move16();
6377 69883680 : j++;
6378 69883680 : k++;
6379 : }
6380 :
6381 444180 : return;
6382 : }
6383 :
6384 :
6385 : /*======================================================================================*/
6386 : /* FUNCTION : interp_code_5over2_fx() */
6387 : /*--------------------------------------------------------------------------------------*/
6388 : /* PURPOSE : Used to interpolate the excitation from the core sample rate */
6389 : /* of 12.8 kHz to 32 kHz. */
6390 : /* Simple linear interpolator - No need FOR precision here. */
6391 : /*--------------------------------------------------------------------------------------*/
6392 : /* INPUT ARGUMENTS : */
6393 : /* _ (Word16[]) inp_code_fx : input vector (Q12) */
6394 : /* _ (Word16) inp_length : length of input vector */
6395 : /*--------------------------------------------------------------------------------------*/
6396 : /* OUTPUT ARGUMENTS : */
6397 : /* _ (Word16[]) interp_code_fx : output vector (Q12) */
6398 : /*--------------------------------------------------------------------------------------*/
6399 : /* INPUT/OUTPUT ARGUMENTS : */
6400 : /* _ None */
6401 : /*--------------------------------------------------------------------------------------*/
6402 :
6403 : /* _ None */
6404 : /*--------------------------------------------------------------------------------------*/
6405 : /* RETURN ARGUMENTS : */
6406 : /* _ None */
6407 : /*======================================================================================*/
6408 :
6409 533672 : void interp_code_5over2_fx(
6410 : const Word16 inp_code_fx[], /* i : input vector Qx*/
6411 : Word16 interp_code_fx[], /* o : output vector Qx*/
6412 : const Word16 inp_length /* i : length of input vector */
6413 : )
6414 : {
6415 : Word16 i, kk, kkp1, i_len2;
6416 : Word32 Ltemp;
6417 533672 : Word16 factor_i_fx[5] = { 6554, 19661, 32767, 19661, 6554 };
6418 533672 : move16();
6419 533672 : move16();
6420 533672 : move16();
6421 533672 : move16();
6422 533672 : move16();
6423 533672 : move16();
6424 533672 : Word16 factor_j_fx[5] = { 26214, 13107, 0, 13107, 26214 };
6425 533672 : move16();
6426 533672 : move16();
6427 533672 : move16();
6428 533672 : move16();
6429 533672 : move16();
6430 533672 : interp_code_fx[0] = inp_code_fx[0];
6431 533672 : move16(); /* Qx */
6432 :
6433 533672 : Ltemp = L_mult( inp_code_fx[0], factor_i_fx[3] ); /* Q(16+x) */
6434 533672 : Ltemp = L_mac( Ltemp, inp_code_fx[1], factor_j_fx[3] ); /* Q(16+x) */
6435 533672 : interp_code_fx[1] = round_fx( Ltemp ); /*Qx */
6436 533672 : move16();
6437 533672 : Ltemp = L_mult( inp_code_fx[0], factor_i_fx[4] ); /*Q(16+x) */
6438 533672 : Ltemp = L_mac( Ltemp, inp_code_fx[1], factor_j_fx[4] ); /*Q(16+x) */
6439 533672 : interp_code_fx[2] = round_fx( Ltemp ); /* Qx */
6440 533672 : move16();
6441 533672 : kk = 1;
6442 533672 : move16();
6443 533672 : kkp1 = 2;
6444 533672 : move16();
6445 533672 : i = 3;
6446 533672 : move16();
6447 : /*i_len2 = ( inp_length - 2 ) * HIBND_ACB_L_FAC; */ /*HIBND_ACB_L_FAC == 5/2 */
6448 533672 : i_len2 = sub( inp_length, 2 );
6449 533672 : i_len2 = shr( add( shl( i_len2, 2 ), i_len2 ), 1 ); /* rounding below during shr makes it non BE*/
6450 :
6451 20829184 : FOR( ; i < i_len2; i += 5 )
6452 : {
6453 20295512 : Ltemp = L_mult( inp_code_fx[kk], factor_j_fx[0] ); /*Q(16+x) */
6454 20295512 : Ltemp = L_mac( Ltemp, inp_code_fx[kkp1], factor_i_fx[0] ); /*Q(16+x) */
6455 20295512 : interp_code_fx[i] = round_fx( Ltemp ); /*Qx */
6456 20295512 : move16();
6457 20295512 : Ltemp = L_mult( inp_code_fx[kk], factor_j_fx[1] ); /*Q(16+x) */
6458 20295512 : Ltemp = L_mac( Ltemp, inp_code_fx[kkp1], factor_i_fx[1] ); /*Q(16+x) */
6459 20295512 : interp_code_fx[i + 1] = round_fx( Ltemp ); /*Qx */
6460 20295512 : move16();
6461 20295512 : Ltemp = L_mult( inp_code_fx[kkp1], factor_i_fx[2] ); /*Q(16+x) */
6462 20295512 : interp_code_fx[i + 2] = round_fx( Ltemp ); /*Qx */
6463 20295512 : move16();
6464 20295512 : kk++;
6465 20295512 : kkp1++;
6466 :
6467 20295512 : Ltemp = L_mult( inp_code_fx[kk], factor_i_fx[3] ); /*Q(16+x) */
6468 20295512 : Ltemp = L_mac( Ltemp, inp_code_fx[kkp1], factor_j_fx[3] ); /*Q(16+x) */
6469 20295512 : interp_code_fx[i + 3] = round_fx( Ltemp ); /*Qx */
6470 20295512 : move16();
6471 20295512 : Ltemp = L_mult( inp_code_fx[kk], factor_i_fx[4] ); /*Q(16+x) */
6472 20295512 : Ltemp = L_mac( Ltemp, inp_code_fx[kkp1], factor_j_fx[4] ); /*Q(16+x) */
6473 20295512 : interp_code_fx[i + 4] = round_fx( Ltemp ); /*Qx */
6474 20295512 : move16();
6475 20295512 : kk++;
6476 20295512 : kkp1++;
6477 : }
6478 :
6479 533672 : Ltemp = L_mult( inp_code_fx[kk], factor_j_fx[0] ); /*Q(16+x) */
6480 533672 : interp_code_fx[i] = round_fx( Ltemp ); /*Qx */
6481 533672 : move16();
6482 533672 : Ltemp = L_mult( inp_code_fx[kk], factor_j_fx[1] ); /*Q(16+x) */
6483 533672 : interp_code_fx[i + 1] = round_fx( Ltemp ); /*Qx */
6484 533672 : move16();
6485 533672 : return;
6486 : }
6487 :
6488 :
6489 : /*======================================================================================*/
6490 : /* FUNCTION : interp_code_4over2_fx() */
6491 : /*--------------------------------------------------------------------------------------*/
6492 : /* PURPOSE : Used to interpolate the excitation from the core sample rate */
6493 : /* of 16 kHz to 32 kHz. */
6494 : /* Simple linear interpolator - No need for precision here. */
6495 : /*--------------------------------------------------------------------------------------*/
6496 : /* INPUT ARGUMENTS : */
6497 : /* _ (Word16[]) inp_code_fx : input vector (Qx) */
6498 : /* _ (Word16) inp_length : length of input vector */
6499 : /*--------------------------------------------------------------------------------------*/
6500 : /* OUTPUT ARGUMENTS : */
6501 : /* _ (Word16[]) interp_code_fx : output vector (Qx) */
6502 : /*--------------------------------------------------------------------------------------*/
6503 : /* INPUT/OUTPUT ARGUMENTS : */
6504 : /* _ None */
6505 : /*--------------------------------------------------------------------------------------*/
6506 :
6507 : /* _ None */
6508 : /*--------------------------------------------------------------------------------------*/
6509 : /* RETURN ARGUMENTS : */
6510 : /* _ None */
6511 : /*======================================================================================*/
6512 :
6513 727302 : void interp_code_4over2_fx(
6514 : const Word16 inp_code_fx[], /* i : input vector Qx*/
6515 : Word16 interp_code_fx[], /* o : output vector Qx*/
6516 : const Word16 inp_length /* i : length of input vector */
6517 : )
6518 : {
6519 : Word16 i, j;
6520 727302 : j = 0;
6521 727302 : move16();
6522 51981952 : FOR( i = 0; i < inp_length - 1; i++ )
6523 : {
6524 51254650 : interp_code_fx[j] = inp_code_fx[i];
6525 51254650 : move16(); /*Qx */
6526 51254650 : interp_code_fx[j + 1] = add( shr( inp_code_fx[i], 1 ), shr( inp_code_fx[i + 1], 1 ) );
6527 51254650 : move16();
6528 51254650 : move16(); /*Qx */
6529 51254650 : j = add( j, 2 );
6530 : }
6531 :
6532 727302 : interp_code_fx[j] = inp_code_fx[i];
6533 727302 : move16();
6534 727302 : interp_code_fx[j + 1] = shr( inp_code_fx[i], 1 );
6535 727302 : move16(); /*Qx */
6536 :
6537 727302 : return;
6538 : }
6539 :
6540 :
6541 : /*-------------------------------------------------------------------*
6542 : * wb_tbe_extras_reset_synth()
6543 : *
6544 : * Reset the extra parameters only required for WB TBE synthesis
6545 : *-------------------------------------------------------------------*/
6546 :
6547 10620 : void wb_tbe_extras_reset_synth_fx(
6548 : Word16 state_lsyn_filt_shb[],
6549 : Word16 state_lsyn_filt_dwn_shb[],
6550 : Word16 state_32and48k_WB_upsample[],
6551 : Word16 state_resamp_HB[] )
6552 : {
6553 10620 : set16_fx( state_lsyn_filt_shb, 0, 2 * ALLPASSSECTIONS_STEEP );
6554 10620 : set16_fx( state_lsyn_filt_dwn_shb, 0, 2 * ALLPASSSECTIONS_STEEP );
6555 10620 : set16_fx( state_32and48k_WB_upsample, 0, 2 * ALLPASSSECTIONS_STEEP );
6556 10620 : set16_fx( state_resamp_HB, 0, INTERP_3_1_MEM_LEN );
6557 :
6558 10620 : return;
6559 : }
6560 :
6561 : /*-------------------------------------------------------------------*
6562 : * elliptic_bpf_48k_generic()
6563 : *
6564 : * 18th-order elliptic bandpass filter at 14.0 to 20 kHz sampled at 48 kHz
6565 : * Implemented as 3 fourth order sections cascaded.
6566 : *-------------------------------------------------------------------*/
6567 :
6568 78953 : void elliptic_bpf_48k_generic_fx(
6569 : const int16_t element_mode,
6570 : Word16 IsUpsampled3,
6571 : Word16 input_fx[], /* i : input signal Q_input_fx*/
6572 : Word16 *Q_input_fx,
6573 : Word16 output_fx[], /* o : output signal memory_fx_Q */
6574 : Word32 memory_fx2[][4], /* i/o: 4 arrays of 4 for memory */
6575 : Word16 memory_fx_Q[],
6576 : const Word16 full_band_bpf_fx[][5] /* i : filter coefficients b0,b1,b2,a0,a1,a2 Q13 */
6577 : )
6578 : {
6579 : Word16 i, j;
6580 : Word16 memory_fx0, Q_temp, Q_temp2;
6581 : Word32 L_tmp_buffer[L_FRAME48k + 4], L_tmp2_buffer[L_FRAME48k + 4], L_output_buffer[L_FRAME48k + 4], L_tmpX;
6582 : Word32 L_tmpMax;
6583 : Word64 W_tmpX;
6584 : Word64 W_tmpY;
6585 :
6586 78953 : Word32 *L_tmp = &L_tmp_buffer[4];
6587 78953 : Word32 *L_tmp2 = &L_tmp2_buffer[4];
6588 78953 : Word32 *L_output = &L_output_buffer[4];
6589 :
6590 394765 : FOR( i = 0; i < 4; i++ )
6591 : {
6592 315812 : memory_fx0 = extract_l( memory_fx2[0][i] );
6593 315812 : input_fx[i - 4] = shl_sat( memory_fx0, sub( *Q_input_fx, memory_fx_Q[0] ) );
6594 315812 : L_tmp[i - 4] = L_shl_sat( memory_fx2[1][i], sub( add( *Q_input_fx, 11 ), memory_fx_Q[1] ) );
6595 315812 : L_tmp2[i - 4] = L_shl_sat( memory_fx2[2][i], sub( add( *Q_input_fx, 6 ), memory_fx_Q[2] ) );
6596 : // memory2_fx[3][i] = L_shl_sat( memory_fx2[3][i], sub( add( *Q_input_fx, 1 ), memory_fx_Q[3] ) );
6597 315812 : move32();
6598 315812 : move32();
6599 315812 : move32();
6600 315812 : move32();
6601 315812 : move32();
6602 : }
6603 :
6604 78953 : L_tmpMax = L_add( 0, 0 );
6605 78953 : IF( !IsUpsampled3 )
6606 : {
6607 43820 : IF( element_mode )
6608 : {
6609 42111020 : FOR( i = 0; i < L_FRAME48k; i++ )
6610 : {
6611 : /*duplicate this into unrolled loopsections in IsUpsampled3-path and dont forget to delete 0-set-input[1,2,4,5,7,8...]*/
6612 42067200 : W_tmpX = W_mac_16_16( 0, input_fx[i - 4], full_band_bpf_fx[0][4] );
6613 42067200 : W_tmpX = W_mac_16_16( W_tmpX, input_fx[i - 3], full_band_bpf_fx[0][3] );
6614 42067200 : W_tmpY = W_msu_32_16( 0, L_tmp[i - 1], full_band_bpf_fx[3][1] );
6615 42067200 : W_tmpX = W_mac_16_16( W_tmpX, input_fx[i - 2], full_band_bpf_fx[0][2] );
6616 42067200 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 2], full_band_bpf_fx[3][2] );
6617 42067200 : W_tmpX = W_mac_16_16( W_tmpX, input_fx[i - 1], full_band_bpf_fx[0][1] );
6618 42067200 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 3], full_band_bpf_fx[3][3] );
6619 42067200 : W_tmpX = W_mac_16_16( W_tmpX, input_fx[i], full_band_bpf_fx[0][0] );
6620 42067200 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 4], full_band_bpf_fx[3][4] );
6621 42067200 : L_tmp[i] = W_sat_l( W_shr( W_add( W_tmpX, W_shl( W_tmpY, 2 - 16 + 3 ) ), 3 ) ); /*Q_input_fx + 11*/
6622 42067200 : move32();
6623 : }
6624 : }
6625 : ELSE
6626 : {
6627 0 : FOR( i = 0; i < L_FRAME48k; i++ )
6628 : {
6629 0 : L_tmpX = L_shr( L_mult( input_fx[i - 4], full_band_bpf_fx[0][4] ), 3 ); /*Q_input_fx + 13 + 1 - 3*/
6630 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i - 3], full_band_bpf_fx[0][3] ), 3 ), L_tmpX ); /*Q_input_fx + 13 + 1 - 3*/
6631 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 1], full_band_bpf_fx[3][1] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6632 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i - 2], full_band_bpf_fx[0][2] ), 3 ), L_tmpX ); /*Q_input_fx + 13 + 1 - 3*/
6633 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 2], full_band_bpf_fx[3][2] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6634 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i - 1], full_band_bpf_fx[0][1] ), 3 ), L_tmpX ); /*Q_input_fx + 13 + 1 - 3*/
6635 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 3], full_band_bpf_fx[3][3] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6636 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i], full_band_bpf_fx[0][0] ), 3 ), L_tmpX ); /*Q_input_fx + 13 + 1 - 3*/
6637 0 : L_tmp[i] = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 4], full_band_bpf_fx[3][4] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6638 0 : move32();
6639 : }
6640 : }
6641 : } /*IsUpsampled3*/
6642 : ELSE
6643 : {
6644 35133 : IF( element_mode )
6645 : {
6646 11277693 : FOR( i = 0; i < L_FRAME48k; )
6647 : {
6648 11242560 : W_tmpX = W_mac_16_16( 0, input_fx[i - 3], full_band_bpf_fx[0][3] );
6649 11242560 : W_tmpY = W_msu_32_16( 0, L_tmp[i - 1], full_band_bpf_fx[3][1] );
6650 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 2], full_band_bpf_fx[3][2] );
6651 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 3], full_band_bpf_fx[3][3] );
6652 11242560 : W_tmpX = W_mac_16_16( W_tmpX, input_fx[i], full_band_bpf_fx[0][0] );
6653 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 4], full_band_bpf_fx[3][4] );
6654 11242560 : L_tmp[i] = W_sat_l( W_shr( W_add( W_tmpX, W_shl( W_tmpY, 2 - 16 + 3 ) ), 3 ) ); /*Q_input_fx + 11*/
6655 11242560 : move32();
6656 11242560 : i++;
6657 :
6658 11242560 : W_tmpX = W_mac_16_16( 0, input_fx[i - 4], full_band_bpf_fx[0][4] );
6659 11242560 : W_tmpY = W_msu_32_16( 0, L_tmp[i - 1], full_band_bpf_fx[3][1] );
6660 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 2], full_band_bpf_fx[3][2] );
6661 11242560 : W_tmpX = W_mac_16_16( W_tmpX, input_fx[i - 1], full_band_bpf_fx[0][1] );
6662 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 3], full_band_bpf_fx[3][3] );
6663 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 4], full_band_bpf_fx[3][4] );
6664 11242560 : L_tmp[i] = W_sat_l( W_shr( W_add( W_tmpX, W_shl( W_tmpY, 2 - 16 + 3 ) ), 3 ) ); /*Q_input_fx + 11*/
6665 11242560 : move32();
6666 11242560 : i++;
6667 :
6668 11242560 : W_tmpY = W_msu_32_16( 0, L_tmp[i - 1], full_band_bpf_fx[3][1] );
6669 11242560 : W_tmpX = W_mac_16_16( 0, input_fx[i - 2], full_band_bpf_fx[0][2] );
6670 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 2], full_band_bpf_fx[3][2] );
6671 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 3], full_band_bpf_fx[3][3] );
6672 11242560 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp[i - 4], full_band_bpf_fx[3][4] );
6673 11242560 : L_tmp[i] = W_sat_l( W_shr( W_add( W_tmpX, W_shl( W_tmpY, 2 - 16 + 3 ) ), 3 ) ); /*Q_input_fx + 11*/
6674 11242560 : move32();
6675 11242560 : i++;
6676 : }
6677 : }
6678 : ELSE
6679 : {
6680 0 : FOR( i = 0; i < L_FRAME48k; )
6681 : {
6682 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i - 3], full_band_bpf_fx[0][3] ), 3 ), 0 ); /*Q_input_fx + 13 + 1 - 3*/
6683 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 1], full_band_bpf_fx[3][1] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6684 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 2], full_band_bpf_fx[3][2] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6685 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 3], full_band_bpf_fx[3][3] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6686 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i], full_band_bpf_fx[0][0] ), 3 ), L_tmpX ); /*Q_input_fx + 13 + 1 - 3*/
6687 0 : L_tmp[i] = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 4], full_band_bpf_fx[3][4] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6688 0 : move32();
6689 0 : i++;
6690 :
6691 0 : L_tmpX = L_shr( L_mult( input_fx[i - 4], full_band_bpf_fx[0][4] ), 3 ); /*Q_input_fx + 13 + 1 - 3*/
6692 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 1], full_band_bpf_fx[3][1] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6693 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 2], full_band_bpf_fx[3][2] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6694 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i - 1], full_band_bpf_fx[0][1] ), 3 ), L_tmpX ); /*Q_input_fx + 13 + 1 - 3*/
6695 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 3], full_band_bpf_fx[3][3] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6696 0 : L_tmp[i] = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 4], full_band_bpf_fx[3][4] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6697 0 : move32();
6698 0 : i++;
6699 :
6700 0 : L_tmpX = L_sub_sat( 0, L_shl_sat( Mult_32_16( L_tmp[i - 1], full_band_bpf_fx[3][1] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6701 0 : L_tmpX = L_add_sat( L_shr( L_mult( input_fx[i - 2], full_band_bpf_fx[0][2] ), 3 ), L_tmpX ); /*Q_input_fx + 13 + 1 - 3*/
6702 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 2], full_band_bpf_fx[3][2] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6703 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 3], full_band_bpf_fx[3][3] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6704 0 : L_tmp[i] = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp[i - 4], full_band_bpf_fx[3][4] ), 2 ) ); /*Q_input_fx + 11 + 13 -15 +2*/
6705 0 : move32();
6706 0 : i++;
6707 : }
6708 : }
6709 :
6710 : } /*IsUpsampled3*/
6711 :
6712 :
6713 78953 : memory_fx2[0][0] = input_fx[L_FRAME48k - 4];
6714 78953 : memory_fx2[0][1] = input_fx[L_FRAME48k - 3];
6715 78953 : memory_fx2[0][2] = input_fx[L_FRAME48k - 2];
6716 78953 : memory_fx2[0][3] = input_fx[L_FRAME48k - 1];
6717 78953 : move32();
6718 78953 : move32();
6719 78953 : move32();
6720 78953 : move32();
6721 78953 : move32();
6722 :
6723 78953 : L_tmpMax = L_add( 0, 0 );
6724 78953 : IF( element_mode )
6725 : {
6726 75873833 : FOR( i = 0; i < L_FRAME48k; i++ )
6727 : {
6728 75794880 : W_tmpX = W_mac_32_16( 0, L_tmp[i - 4], full_band_bpf_fx[1][4] );
6729 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp[i - 3], full_band_bpf_fx[1][3] );
6730 75794880 : W_tmpY = W_msu_32_16( 0, L_tmp2[i - 1], full_band_bpf_fx[4][1] );
6731 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp[i - 2], full_band_bpf_fx[1][2] );
6732 75794880 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp2[i - 2], full_band_bpf_fx[4][2] );
6733 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp[i - 1], full_band_bpf_fx[1][1] );
6734 75794880 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp2[i - 3], full_band_bpf_fx[4][3] );
6735 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp[i], full_band_bpf_fx[1][0] );
6736 75794880 : W_tmpY = W_msu_32_16( W_tmpY, L_tmp2[i - 4], full_band_bpf_fx[4][4] );
6737 75794880 : L_tmp2[i] = W_sat_l( W_shr( W_add( W_tmpX, W_shl( W_tmpY, 2 - 16 + 3 + 16 ) ), 3 + 16 ) );
6738 75794880 : move32();
6739 75794880 : L_tmpMax = L_max( L_tmpMax, L_abs( L_tmp2[i] ) );
6740 : }
6741 : }
6742 : ELSE
6743 : {
6744 0 : FOR( i = 0; i < L_FRAME48k; i++ )
6745 : {
6746 0 : L_tmpX = L_shr( Mult_32_16( L_tmp[i - 4], full_band_bpf_fx[1][4] ), 3 ); /*Q_input_fx + 11 + 13 - 15 -3*/
6747 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp[i - 3], full_band_bpf_fx[1][3] ), 3 ), L_tmpX ); /*Q_input_fx + 11 + 13 - 15 -3*/
6748 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp2[i - 1], full_band_bpf_fx[4][1] ), 2 ) ); /*Q_input_fx + 6 +13 -15 +2 */
6749 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp[i - 2], full_band_bpf_fx[1][2] ), 3 ), L_tmpX ); /*Q_input_fx + 11 + 13 - 15 -3*/
6750 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp2[i - 2], full_band_bpf_fx[4][2] ), 2 ) ); /*Q_input_fx + 6 +13 -15 +2 */
6751 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp[i - 1], full_band_bpf_fx[1][1] ), 3 ), L_tmpX ); /*Q_input_fx + 11 + 13 - 15 -3*/
6752 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp2[i - 3], full_band_bpf_fx[4][3] ), 2 ) ); /*Q_input_fx + 6 +13 -15 +2 */
6753 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp[i], full_band_bpf_fx[1][0] ), 3 ), L_tmpX ); /*Q_input_fx + 11 + 13 - 15 -3*/
6754 0 : L_tmp2[i] = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_tmp2[i - 4], full_band_bpf_fx[4][4] ), 2 ) ); /*Q_input_fx + 6 +13 -15 +2 */
6755 0 : move32();
6756 0 : L_tmpMax = L_max( L_tmpMax, L_abs( L_tmp2[i] ) );
6757 : }
6758 : }
6759 :
6760 :
6761 78953 : Q_temp = norm_l( L_tmpMax );
6762 78953 : Q_temp = sub( Q_temp, 4 );
6763 78953 : Scale_sig32( L_tmp2, 960, Q_temp );
6764 :
6765 78953 : memory_fx2[1][0] = L_tmp[L_FRAME48k - 4];
6766 78953 : memory_fx2[1][1] = L_tmp[L_FRAME48k - 3];
6767 78953 : memory_fx2[1][2] = L_tmp[L_FRAME48k - 2];
6768 78953 : memory_fx2[1][3] = L_tmp[L_FRAME48k - 1];
6769 78953 : move32();
6770 78953 : move32();
6771 78953 : move32();
6772 78953 : move32();
6773 78953 : move32();
6774 394765 : FOR( j = 0; j < 4; j++ )
6775 : {
6776 315812 : L_tmp2[j - 4] = L_shl_sat( memory_fx2[2][j], sub( add( add( *Q_input_fx, 6 ), Q_temp ), memory_fx_Q[2] ) );
6777 315812 : L_output[j - 4] = L_shl_sat( memory_fx2[3][j], sub( add( add( *Q_input_fx, 1 ), Q_temp ), memory_fx_Q[3] ) );
6778 315812 : move32();
6779 315812 : move32();
6780 315812 : move32();
6781 : }
6782 78953 : L_tmpMax = L_add( 0, 0 );
6783 78953 : IF( element_mode )
6784 : {
6785 75873833 : FOR( i = 0; i < L_FRAME48k; i++ )
6786 : {
6787 75794880 : W_tmpX = W_mac_32_16( 0, L_tmp2[i - 4], full_band_bpf_fx[2][4] );
6788 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp2[i - 3], full_band_bpf_fx[2][3] );
6789 75794880 : W_tmpY = W_msu_32_16( 0, L_output[i - 1], full_band_bpf_fx[5][1] );
6790 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp2[i - 2], full_band_bpf_fx[2][2] );
6791 75794880 : W_tmpY = W_msu_32_16( W_tmpY, L_output[i - 2], full_band_bpf_fx[5][2] );
6792 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp2[i - 1], full_band_bpf_fx[2][1] );
6793 75794880 : W_tmpY = W_msu_32_16( W_tmpY, L_output[i - 3], full_band_bpf_fx[5][3] );
6794 75794880 : W_tmpX = W_mac_32_16( W_tmpX, L_tmp2[i], full_band_bpf_fx[2][0] );
6795 75794880 : W_tmpY = W_msu_32_16( W_tmpY, L_output[i - 4], full_band_bpf_fx[5][4] );
6796 75794880 : L_output[i] = W_sat_l( W_shr( W_add( W_tmpX, W_shl( W_tmpY, 2 - 16 + 3 + 16 ) ), 3 + 16 ) );
6797 75794880 : move32();
6798 75794880 : L_tmpMax = L_max( L_tmpMax, L_abs( L_output[i] ) );
6799 : }
6800 : }
6801 : ELSE
6802 : {
6803 0 : FOR( i = 0; i < L_FRAME48k; i++ )
6804 : {
6805 0 : L_tmpX = L_shr( Mult_32_16( L_tmp2[i - 4], full_band_bpf_fx[2][4] ), 3 ); /*Q_input_fx + 6 +Q_temp+13 -15 -3 */
6806 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp2[i - 3], full_band_bpf_fx[2][3] ), 3 ), L_tmpX ); /*Q_input_fx + 6 +Q_temp +13 -15 -3*/
6807 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_output[i - 1], full_band_bpf_fx[5][1] ), 2 ) ); /*Q_input_fx + 1 +Q_temp+13 -15 + 2*/
6808 :
6809 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp2[i - 2], full_band_bpf_fx[2][2] ), 3 ), L_tmpX ); /*Q_input_fx + 6 +Q_temp+13 -15 -3*/
6810 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_output[i - 2], full_band_bpf_fx[5][2] ), 2 ) ); /*Q_input_fx + 1 +Q_temp+13 -15 + 2*/
6811 :
6812 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp2[i - 1], full_band_bpf_fx[2][1] ), 3 ), L_tmpX ); /*Q_input_fx + 6 +Q_temp +13 -15 -3*/
6813 0 : L_tmpX = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_output[i - 3], full_band_bpf_fx[5][3] ), 2 ) ); /*Q_input_fx + 1 +Q_temp+13 -15 + 2*/
6814 :
6815 0 : L_tmpX = L_add_sat( L_shr( Mult_32_16( L_tmp2[i], full_band_bpf_fx[2][0] ), 3 ), L_tmpX ); /*Q_input_fx + 6 +Q_temp +13 -15 -3*/
6816 0 : L_output[i] = L_sub_sat( L_tmpX, L_shl_sat( Mult_32_16( L_output[i - 4], full_band_bpf_fx[5][4] ), 2 ) ); /*Q_input_fx + 1 +Q_temp+13 -15 + 2*/
6817 0 : move32();
6818 0 : L_tmpMax = L_max( L_tmpMax, L_abs( L_output[i] ) );
6819 : }
6820 : }
6821 :
6822 :
6823 78953 : memory_fx2[2][0] = L_tmp2[L_FRAME48k - 4];
6824 78953 : memory_fx2[2][1] = L_tmp2[L_FRAME48k - 3];
6825 78953 : memory_fx2[2][2] = L_tmp2[L_FRAME48k - 2];
6826 78953 : memory_fx2[2][3] = L_tmp2[L_FRAME48k - 1];
6827 78953 : memory_fx2[3][0] = L_output[L_FRAME48k - 4];
6828 78953 : memory_fx2[3][1] = L_output[L_FRAME48k - 3];
6829 78953 : memory_fx2[3][2] = L_output[L_FRAME48k - 2];
6830 78953 : memory_fx2[3][3] = L_output[L_FRAME48k - 1];
6831 78953 : move32();
6832 78953 : move32();
6833 78953 : move32();
6834 78953 : move32();
6835 78953 : move32();
6836 78953 : move32();
6837 78953 : move32();
6838 78953 : move32();
6839 78953 : move32();
6840 78953 : memory_fx_Q[0] = *Q_input_fx;
6841 78953 : memory_fx_Q[1] = add( *Q_input_fx, 11 );
6842 78953 : memory_fx_Q[2] = add( add( *Q_input_fx, 6 ), Q_temp );
6843 78953 : memory_fx_Q[3] = add( add( *Q_input_fx, 1 ), Q_temp );
6844 78953 : move16();
6845 78953 : move16();
6846 78953 : move16();
6847 78953 : move16();
6848 78953 : Q_temp2 = norm_l( L_tmpMax );
6849 78953 : Scale_sig32( L_output, 960, Q_temp2 );
6850 75873833 : FOR( i = 0; i < 960; i++ )
6851 : {
6852 75794880 : output_fx[i] = extract_h( L_output[i] );
6853 75794880 : move16();
6854 : }
6855 78953 : *Q_input_fx = sub( add( add( *Q_input_fx, Q_temp ), Q_temp2 ), 15 );
6856 78953 : move16(); /* BASOP_NOGLOB */
6857 :
6858 78953 : return;
6859 : }
6860 : /*-------------------------------------------------------------------*
6861 : * synthesise_fb_high_band()
6862 : *
6863 : * Creates the highband output for full band - 14.0 to 20 kHz
6864 : * Using the energy shaped white excitation signal from the SWB BWE.
6865 : * The excitation signal input is sampled at 16kHz and so is upsampled
6866 : * to 48 kHz first.
6867 : * Uses a complementary split filter to code the two regions from
6868 : * 14kHz to 16kHz and 16 kHz to 20 kHz.
6869 : * One of 16 tilt filters is also applied afterwards to further
6870 : * refine the spectral shape of the fullband signal.
6871 : * The tilt is specified in dB per kHz. N.B. Only negative values are
6872 : * accomodated.
6873 : *-------------------------------------------------------------------*/
6874 :
6875 35133 : void synthesise_fb_high_band_fx(
6876 : const Word16 excitation_in[], /* i : full band excitation */
6877 : Word16 Q_fb_exc,
6878 : Word16 output[], /* o : high band speech - 14.0 to 20 kHz */
6879 : const Word32 fb_exc_energy, /* i : full band excitation energy */
6880 : const Word16 ratio, /* i : energy ratio */
6881 : const Word16 L_frame, /* i : ACELP frame length */
6882 : const Word16 bfi, /* i : fec flag */
6883 : Word16 *prev_fbbwe_ratio, /* o : previous frame energy for FEC */
6884 : Word32 bpf_memory[][4], /* i/o: memory for elliptic bpf 48k */
6885 : Word16 bpf_memory_Q[],
6886 : Word16 Qout,
6887 : int16_t element_mode )
6888 : {
6889 : Word16 i, j;
6890 : Word16 excitation_in_interp3_buffer[L_FRAME48k + 4];
6891 35133 : Word16 *excitation_in_interp3 = &excitation_in_interp3_buffer[0] + 4;
6892 : Word16 tmp[L_FRAME48k];
6893 : Word32 temp1;
6894 : Word32 ratio2;
6895 : Word32 L_tmp;
6896 : Word16 tmp3, tmp1, tmp2, exp, exp2, exp_tmp;
6897 :
6898 : /* Interpolate the white energy shaped gaussian excitation from 16 kHz to 48 kHz with zeros */
6899 35133 : j = 0;
6900 : /* white excitation from DC to 8 kHz resampled to produce DC to 24 kHz excitation. */
6901 11277693 : FOR( i = 0; i < L_FRAME48k; i += 3 )
6902 : {
6903 11242560 : excitation_in_interp3[i] = mult( excitation_in[j], 24576 ); /* Q(Q_fb_exc+13-15 = Q_fb_exc-2) */
6904 11242560 : move16();
6905 11242560 : excitation_in_interp3[i + 1] = 0;
6906 11242560 : move16();
6907 11242560 : excitation_in_interp3[i + 2] = 0;
6908 11242560 : move16();
6909 11242560 : j++;
6910 : }
6911 35133 : exp_tmp = sub( Q_fb_exc, 2 );
6912 :
6913 35133 : IF( EQ_16( L_frame, L_FRAME16k ) )
6914 : {
6915 : /* for 16kHz ACELP core */
6916 27510 : elliptic_bpf_48k_generic_fx(
6917 : element_mode,
6918 : 1, // IsUpsampled3
6919 : excitation_in_interp3, &exp_tmp, tmp, bpf_memory, bpf_memory_Q, full_band_bpf_3_fx
6920 :
6921 : );
6922 : }
6923 : ELSE
6924 : {
6925 : /* for 12.8kHz ACELP core */
6926 7623 : elliptic_bpf_48k_generic_fx(
6927 : element_mode,
6928 : 1, // IsUpsampled3
6929 : excitation_in_interp3, &exp_tmp, tmp, bpf_memory, bpf_memory_Q, full_band_bpf_1_fx );
6930 : }
6931 : /* temp1 = sum2_f( tmp, L_FRAME48k ) + 0.001f */
6932 35133 : temp1 = sum2_fx_mod( tmp, L_FRAME48k );
6933 :
6934 35133 : L_tmp = L_max( 1, fb_exc_energy ); /*Q(2*Q_fb_exc + 1)*/
6935 35133 : exp = norm_l( L_tmp );
6936 35133 : tmp3 = extract_h( L_shl( L_tmp, exp ) );
6937 35133 : tmp1 = sub( add( Q_fb_exc, Q_fb_exc ), 8 ); /* 1-9*/
6938 35133 : exp = sub( sub( 31, tmp1 ), exp );
6939 :
6940 35133 : IF( element_mode != EVS_MONO )
6941 : {
6942 : Word16 sft, t_Q;
6943 35133 : Word64 P_ONE = 33; /* 0.001f in Q15 */
6944 35133 : move64();
6945 : Word64 W_temp;
6946 :
6947 35133 : t_Q = sub( shl( exp_tmp, 1 ), 8 );
6948 35133 : P_ONE = W_shl( P_ONE, s_min( 63, sub( t_Q, 15 ) ) );
6949 :
6950 35133 : W_temp = W_add( P_ONE, temp1 );
6951 :
6952 35133 : sft = W_norm( W_temp );
6953 35133 : W_temp = W_shl( W_temp, sft );
6954 :
6955 35133 : temp1 = W_extract_h( W_temp );
6956 35133 : t_Q = sub( add( t_Q, sft ), 32 );
6957 :
6958 35133 : tmp2 = extract_h( temp1 );
6959 35133 : exp2 = sub( 31, t_Q );
6960 : }
6961 : ELSE
6962 : {
6963 0 : exp2 = norm_l( temp1 );
6964 0 : tmp2 = extract_h( L_shl( temp1, exp2 ) );
6965 0 : exp2 = sub( sub( 31, sub( shl( exp_tmp, 1 ), 8 ) ), exp2 ); /* in Q15 (temp1 in Q9)*/
6966 : }
6967 :
6968 35133 : exp = sub( exp2, exp ); /* Denormalize and substract */
6969 35133 : IF( GT_16( tmp2, tmp3 ) )
6970 : {
6971 15771 : tmp2 = shr( tmp2, 1 );
6972 15771 : exp = add( exp, 1 );
6973 : }
6974 35133 : IF( 0 != tmp3 )
6975 : {
6976 35133 : tmp3 = div_s( tmp2, tmp3 );
6977 35133 : L_tmp = L_deposit_h( tmp3 );
6978 35133 : L_tmp = Isqrt_lc( L_tmp, &exp ); /*Q(31-exp)*/
6979 35133 : ratio2 = Mult_32_16( L_tmp, ratio ); /*Q(31-exp+0-15 = 16-exp)*/
6980 : }
6981 : ELSE
6982 : {
6983 0 : ratio2 = 0;
6984 : }
6985 :
6986 35133 : IF( !bfi )
6987 : {
6988 34385 : *prev_fbbwe_ratio = ratio;
6989 34385 : move16();
6990 : }
6991 : ELSE
6992 : {
6993 : /**prev_fbbwe_ratio = ratio*0.5f;*/
6994 748 : *prev_fbbwe_ratio = shr( ratio, 1 );
6995 748 : move16();
6996 : }
6997 35133 : tmp3 = add( sub( Qout, add( sub( 1, exp ), exp_tmp ) ), 16 ); /*Qout - (1 -exp +exp_tmp) + 16 */
6998 33762813 : FOR( i = 0; i < L_FRAME48k; i++ )
6999 : {
7000 33727680 : L_tmp = Mult_32_16( ratio2, tmp[i] ); /* Q(16-exp+exp_tmp-15 = 1-exp+exp_tmp) */
7001 33727680 : IF( L_tmp < 0 )
7002 : {
7003 16658203 : output[i] = negate( extract_h( L_shl_sat( L_negate( L_tmp ), tmp3 ) ) ); /*Qout*/
7004 16658203 : move16();
7005 : }
7006 : ELSE
7007 : {
7008 17069477 : output[i] = extract_h( L_shl_sat( L_tmp, tmp3 ) ); /*Qout*/
7009 17069477 : move16();
7010 : }
7011 : }
7012 35133 : return;
7013 : }
7014 :
7015 : /*-------------------------------------------------------------------*
7016 : * Estimate_mix_factors_fx() *
7017 : * *
7018 : * Estimate mix factors for SHB excitation generation *
7019 : *-------------------------------------------------------------------*/
7020 25651 : void Estimate_mix_factors_fx(
7021 : const Word16 *shb_res, /* i : SHB LP residual in Q = Q_shb */
7022 : const Word16 Q_shb,
7023 : const Word16 *exc16kWhtnd, /* i : SHB transformed low band excitation Q_bwe_exc */
7024 : const Word16 Q_bwe_exc,
7025 : const Word16 *White_exc16k_frac, /* i : Modulated envelope shaped white noise Q_frac */
7026 : const Word16 Q_frac,
7027 : const Word32 pow1, /* i : SHB exc. power for normalization in Q_pow1 */
7028 : const Word16 Q_pow1,
7029 : const Word32 pow22, /* i : White noise excitation for normalization in Q_pow22 */
7030 : const Word16 Q_pow22,
7031 : Word16 *vf_modified, /* o : Estimated voice factors */
7032 : Word16 *vf_ind /* o : voice factors VQ index */
7033 : )
7034 : {
7035 : Word16 shb_res_local[L_FRAME16k], WN_exc_local[L_FRAME16k];
7036 : Word32 pow3, temp_p1_p2, temp_p1_p3;
7037 : Word16 temp_numer1[L_FRAME16k], temp_numer2[L_FRAME16k];
7038 : Word16 i, length;
7039 : Word16 exp1, exp2, expa, expb, fraca, fracb, scale, num_flag, den_flag;
7040 : Word16 tmp, tmp1, sc1, sc2;
7041 : Word32 L_tmp1, L_tmp2;
7042 : #ifndef ISSUE_1836_replace_overflow_libcom
7043 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
7044 : Flag Overflow = 0;
7045 : move32();
7046 : #endif
7047 : #endif
7048 :
7049 25651 : Copy( shb_res, shb_res_local, L_FRAME16k );
7050 25651 : Copy( White_exc16k_frac, WN_exc_local, L_FRAME16k );
7051 : /* WN_exc_local in (Q_frac) */
7052 :
7053 25651 : pow3 = Dot_product( shb_res_local, shb_res_local, L_FRAME16k ); /* (2*Q_shb+1) */
7054 :
7055 25651 : pow3 = L_add( pow3, L_shl( 21475l /*0.00001f in Q31*/, 2 * Q_shb + 1 - 31 ) ); /* (2*Q_shb+1) */
7056 25651 : if ( pow3 == 0 )
7057 : {
7058 0 : pow3 = 1;
7059 0 : move32();
7060 : }
7061 :
7062 : /* temp_p1_p2 = (float)sqrt(pow1/pow2); */
7063 25651 : temp_p1_p2 = root_a_over_b_fx( pow1, Q_pow1, pow22, Q_pow22, &exp1 ); /* temp_p1_p3 in (Q31+exp1) */
7064 :
7065 : /* temp_p1_p3 = (float)sqrt(pow1/pow3); */
7066 25651 : temp_p1_p3 = root_a_over_b_fx( pow1, Q_pow1, pow3, ( 2 * Q_shb + 1 ), &exp2 ); /* temp_p1_p3 in (Q31+exp2) */
7067 :
7068 :
7069 25651 : sc1 = sub( Q_bwe_exc, sub( Q_frac, exp1 ) );
7070 25651 : sc2 = sub( Q_bwe_exc, sub( Q_shb, exp2 ) );
7071 8233971 : FOR( i = 0; i < L_FRAME16k; i++ )
7072 : {
7073 8208320 : L_tmp1 = Mult_32_16( temp_p1_p2, WN_exc_local[i] ); /* (Q_frac - exp1) +16 */
7074 8208320 : WN_exc_local[i] = round_fx( L_tmp1 );
7075 8208320 : move16();
7076 8208320 : L_tmp2 = Mult_32_16( temp_p1_p3, shb_res_local[i] ); /* (Q_shb - exp2) +16 */
7077 8208320 : shb_res_local[i] = round_fx( L_tmp2 );
7078 8208320 : move16();
7079 : /* temp_numer1[i] = sub(shb_res_local[i], WN_exc_local[i]); */
7080 8208320 : temp_numer1[i] = round_fx_sat( L_sub_sat( L_shl_sat( L_tmp2, sc2 ), L_shl_sat( L_tmp1, sc1 ) ) );
7081 8208320 : move16();
7082 : /* (Q_bwe_exc) */
7083 :
7084 : /* temp_numer2[i] = sub(exc16kWhtnd[i], WN_exc_local[i]); */
7085 8208320 : temp_numer2[i] = sub_sat( exc16kWhtnd[i], round_fx_sat( L_shl_sat( L_tmp1, sc1 ) ) );
7086 8208320 : move16();
7087 : /* (Q_bwe_exc) */
7088 : }
7089 :
7090 :
7091 25651 : length = L_FRAME16k;
7092 25651 : move16();
7093 25651 : temp_p1_p2 = Dot_product( temp_numer1, temp_numer2, length ); /* 2*(Q_bwe_exc)+1 */
7094 25651 : temp_p1_p3 = Dot_product( temp_numer2, temp_numer2, length ); /* 2*(Q_bwe_exc)+1 */
7095 :
7096 : /* vf_modified[i] = min( max_val( (temp_p1_p2 / temp_p1_p3), 0.1f), 0.99f); */
7097 : /* tmp = (temp_p1_p2 / temp_p1_p3); */
7098 25651 : IF( temp_p1_p3 > 0 )
7099 : {
7100 25651 : expa = norm_l( temp_p1_p3 );
7101 25651 : fraca = extract_h( L_shl( temp_p1_p3, expa ) );
7102 25651 : expa = sub( 30, expa );
7103 :
7104 25651 : expb = norm_l( temp_p1_p2 );
7105 : #ifdef ISSUE_1836_replace_overflow_libcom
7106 25651 : fracb = round_fx_sat( L_shl( temp_p1_p2, expb ) );
7107 : #else
7108 : fracb = round_fx_o( L_shl_o( temp_p1_p2, expb, &Overflow ), &Overflow );
7109 : #endif
7110 25651 : expb = sub( 30, expb );
7111 :
7112 25651 : num_flag = 0;
7113 25651 : move16();
7114 25651 : IF( fraca < 0 )
7115 : {
7116 0 : num_flag = 1;
7117 0 : move16();
7118 0 : fraca = negate( fraca );
7119 : }
7120 :
7121 25651 : den_flag = 0;
7122 25651 : move16();
7123 25651 : IF( fracb < 0 )
7124 : {
7125 0 : den_flag = 1;
7126 0 : move16();
7127 0 : fracb = negate( fracb );
7128 : }
7129 :
7130 25651 : scale = shr( sub( fraca, fracb ), 15 );
7131 25651 : fracb = shl( fracb, scale );
7132 25651 : expb = sub( expb, scale );
7133 :
7134 25651 : tmp = div_s( fracb, fraca );
7135 25651 : exp1 = sub( expb, expa );
7136 25651 : tmp = shl_sat( tmp, exp1 );
7137 25651 : if ( NE_16( num_flag, den_flag ) )
7138 : {
7139 0 : tmp = negate( tmp );
7140 : }
7141 : }
7142 : ELSE
7143 : {
7144 0 : tmp = 0;
7145 0 : move16();
7146 : }
7147 :
7148 25651 : vf_modified[0] = s_min( s_max( tmp, 3277 /* 0.1f in Q15*/ ), 32440 /* 0.99f in Q15 */ );
7149 25651 : move16();
7150 :
7151 25651 : *vf_ind = usquant_fx( vf_modified[0], &tmp1, 4096 /* 0.125 in Q15 */, 2048 /* 0.125 in Q14 */, shl( 1, NUM_BITS_SHB_VF ) );
7152 25651 : move16();
7153 :
7154 25651 : vf_modified[0] = tmp1;
7155 25651 : move16();
7156 25651 : vf_modified[1] = tmp1;
7157 25651 : move16();
7158 25651 : vf_modified[2] = tmp1;
7159 25651 : move16();
7160 25651 : vf_modified[3] = tmp1;
7161 25651 : move16();
7162 25651 : vf_modified[4] = tmp1;
7163 25651 : move16();
7164 :
7165 : /* vf_modified in Q15 */
7166 :
7167 25651 : return;
7168 : }
7169 :
7170 : /*======================================================================================*/
7171 : /* FUNCTION : prep_tbe_exc_fx() */
7172 : /*--------------------------------------------------------------------------------------*/
7173 : /* PURPOSE : Prepare TBE excitation */
7174 : /*--------------------------------------------------------------------------------------*/
7175 : /* INPUT ARGUMENTS : */
7176 : /* _ (Word16) L_frame_fx : length of the frame */
7177 : /* _ (Word16) i_subfr_fx : subframe index */
7178 : /* _ (Word16) gain_pit_fx : Pitch gain (14) */
7179 : /* _ (Word32) gain_code_fx : algebraic codebook gain (Q(16+Q_exc)) */
7180 : /* _ (Word16*[]) code_fx : algebraic excitation (Q9) */
7181 : /* _ (Word16) voice_fac_fx : voicing factor (Q15) */
7182 : /* _ (Word16) gain_preQ_fx : prequantizer excitation gain */
7183 : /* _ (Word16[]) code_preQ_fx : prequantizer excitation */
7184 : /*--------------------------------------------------------------------------------------*/
7185 : /* OUTPUT ARGUMENTS : */
7186 : /* _ (Word16*[]) voice_factors_fx : TBE voicing factor (Q15) */
7187 : /*--------------------------------------------------------------------------------------*/
7188 : /* INPUT/OUTPUT ARGUMENTS : */
7189 : /* _ (Word16[]) bwe_exc_fx : excitation for TBE (Q_exc) */
7190 : /*--------------------------------------------------------------------------------------*/
7191 : /* _ None */
7192 : /*--------------------------------------------------------------------------------------*/
7193 : /* RETURN ARGUMENTS : */
7194 : /* _ None */
7195 : /*======================================================================================*/
7196 :
7197 1160579 : void prep_tbe_exc_fx(
7198 : const Word16 L_frame_fx, /* i : length of the frame */
7199 : const Word16 L_subfr, /* i : subframe length */
7200 : const Word16 i_subfr_fx, /* i : subframe index */
7201 : const Word16 gain_pit_fx, /* i : Pitch gain Q14*/
7202 : const Word32 gain_code_fx, /* i : algebraic codebook gain 16+Q_exc*/
7203 : const Word16 code_fx[], /* i : algebraic excitation Q9*/
7204 : const Word16 voice_fac_fx, /* i : voicing factor Q15*/
7205 : Word16 *voice_factors_fx, /* o : TBE voicing factor Q15*/
7206 : Word16 bwe_exc_fx[], /* i/o: excitation for TBE Q_exc*/
7207 : const Word16 gain_preQ_fx, /* i : prequantizer excitation gain */
7208 : const Word16 code_preQ_fx[], /* i : prequantizer excitation */
7209 : #ifdef FIX_2010_PREP_TBE_EXC
7210 : const Word16 Q_code_preQ, /* i : Q, prequantizer excitation */
7211 : #endif
7212 : const Word16 Q_exc, /* i : Excitation, bwe_exc Q-factor */
7213 : const Word16 T0, /* i : integer pitch variables Q0 */
7214 : const Word16 T0_frac, /* i : Fractional pitch variables Q0*/
7215 : const Word16 coder_type, /* i : coding type */
7216 : const Word32 core_brate, /* i : core bitrate */
7217 : const Word16 element_mode, /* i : element mode */
7218 : const Word16 idchan, /* i : channel ID */
7219 : const Word16 flag_TD_BWE, /* i : flag indicating whether hTD_BWE exists */
7220 : const Word16 tdm_LRTD_flag /* i : LRTD stereo mode flag */
7221 :
7222 : )
7223 : {
7224 : Word16 i;
7225 : Word16 tmp_code_fx[2 * L_SUBFR * HIBND_ACB_L_FAC];
7226 : Word16 tmp_code_preInt_fx[L_SUBFR];
7227 1160579 : Word16 gain_code16 = 0;
7228 1160579 : move16();
7229 : Word16 tmp /*, tmp1, tmp2*/;
7230 : /*Word16 random_code[L_SUBFR * HIBND_ACB_L_FAC];*/
7231 : Word16 pitch;
7232 :
7233 : Word32 L_tmp, Ltemp1, Ltemp2;
7234 : Word32 tempQ31;
7235 : Word16 tempQ15;
7236 : #ifndef ISSUE_1836_replace_overflow_libcom
7237 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
7238 : Flag Overflow = 0;
7239 : move32();
7240 : #endif
7241 : #endif
7242 :
7243 : /**voice_factors = VF_0th_PARAM + VF_1st_PARAM * voice_fac + VF_2nd_PARAM * voice_fac * voice_fac;
7244 : = VF_0th_PARAM + voice_fac * (VF_1st_PARAM + VF_2nd_PARAM * voice_fac )
7245 : *voice_factors = min( max_val(0.0f, *voice_factors), 1.0f); */
7246 1160579 : tempQ31 = L_deposit_h( VF_1st_PARAM_FX );
7247 1160579 : tempQ15 = mac_r( tempQ31, VF_2nd_PARAM_FX, voice_fac_fx );
7248 1160579 : tempQ31 = L_deposit_h( VF_0th_PARAM_FX );
7249 1160579 : *voice_factors_fx = mac_r( tempQ31, voice_fac_fx, tempQ15 );
7250 1160579 : move16();
7251 :
7252 1160579 : tmp = MAX_16;
7253 1160579 : move16();
7254 :
7255 : #ifdef ISSUE_1836_replace_overflow_libcom
7256 1160579 : pitch = shl_sat( add( shl_sat( T0, 2 ), T0_frac ), 5 ); /* Q7 */
7257 : #else
7258 : pitch = shl_o( add( shl_o( T0, 2, &Overflow ), T0_frac ), 5, &Overflow ); /* Q7 */
7259 : #endif
7260 :
7261 1160579 : test();
7262 1160579 : test();
7263 1160579 : IF( ( ( EQ_16( coder_type, VOICED ) ) || ( GT_16( pitch, 14784 ) ) ) && ( GT_32( core_brate, ACELP_8k00 ) ) )
7264 : {
7265 354978 : tmp = MAX_16;
7266 354978 : move16();
7267 354978 : *voice_factors_fx = mult_r( *voice_factors_fx, tmp );
7268 354978 : move16();
7269 : }
7270 :
7271 1160579 : *voice_factors_fx = s_min( s_max( *voice_factors_fx, 0 ), MAX_16 );
7272 1160579 : move16();
7273 :
7274 1160579 : test();
7275 1160579 : test();
7276 1160579 : IF( EQ_16( element_mode, IVAS_CPE_TD ) && EQ_16( idchan, 1 ) && !tdm_LRTD_flag )
7277 : {
7278 828 : test();
7279 828 : IF( flag_TD_BWE && i_subfr_fx == 0 )
7280 : {
7281 0 : set16_fx( bwe_exc_fx, 0, L_FRAME32k );
7282 : }
7283 828 : return;
7284 : }
7285 :
7286 1159751 : IF( EQ_16( L_frame_fx, L_FRAME ) )
7287 : {
7288 466916 : interp_code_5over2_fx( code_fx, tmp_code_fx, L_subfr ); /* code: Q9, tmp_code: Q9 */
7289 : #ifdef ISSUE_1836_replace_overflow_libcom
7290 466916 : gain_code16 = round_fx_sat( L_shl_sat( gain_code_fx, Q_exc ) ); /*Q_exc */
7291 75173476 : FOR( i = 0; i < L_subfr * HIBND_ACB_L_FAC; i++ )
7292 : {
7293 74706560 : L_tmp = L_mult( gain_code16, tmp_code_fx[i] ); /* Q9 + Q_exc + 1*/
7294 74706560 : L_tmp = L_shl_sat( L_tmp, 5 ); /* Q9 + Q_exc + Q6*/
7295 74706560 : L_tmp = L_mac_sat( L_tmp, gain_pit_fx, bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC] ); /*Q15+Q_exc */
7296 74706560 : L_tmp = L_shl_sat( L_tmp, 1 ); /*16+Q_exc */ /* saturation can occur here */
7297 74706560 : bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC] = round_fx_sat( L_tmp ); /*Q_exc */
7298 74706560 : move16();
7299 : }
7300 : #else
7301 : gain_code16 = round_fx_o( L_shl_o( gain_code_fx, Q_exc, &Overflow ), &Overflow ); /*Q_exc */
7302 : FOR( i = 0; i < L_subfr * HIBND_ACB_L_FAC; i++ )
7303 : {
7304 : L_tmp = L_mult( gain_code16, tmp_code_fx[i] ); /* Q9 + Q_exc + 1*/
7305 : L_tmp = L_shl_o( L_tmp, 5, &Overflow ); /* Q9 + Q_exc + Q6*/
7306 : L_tmp = L_mac_o( L_tmp, gain_pit_fx, bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC], &Overflow ); /*Q15+Q_exc */
7307 : L_tmp = L_shl_o( L_tmp, 1, &Overflow ); /*16+Q_exc */ /* saturation can occur here */
7308 : bwe_exc_fx[i + i_subfr_fx * HIBND_ACB_L_FAC] = round_fx_o( L_tmp, &Overflow ); /*Q_exc */
7309 : move16();
7310 : }
7311 : #endif
7312 : }
7313 : ELSE
7314 : {
7315 692835 : Word16 shift = 4;
7316 : #ifdef FIX_2010_PREP_TBE_EXC
7317 : /* multrus 2025-09-15
7318 : TODO:
7319 : - leave shift = 4, since this is legacy code from EVS;
7320 : - check with vaillancourt, whether we really have a different scaling of code_preQ_fx[] for IVAS
7321 : - if the different scalings are confirmed, this condition could be simplified
7322 : */
7323 692835 : IF( NE_16( element_mode, EVS_MONO ) )
7324 : {
7325 : /* shift of 4 assumes code_preQ_fx[] in Q10 - this is however not always given */
7326 679975 : shift = add( 2 + 1 - 1, Q_code_preQ ); /* gain_preQ_fx in Q2, code_preQ_fx[] in Q_code_preQ, 1 additional left-shift by L_mult() - factor of 2 (from "2 * gain_preQ * code_preQ[i]") */
7327 679975 : shift = sub( 16, shift );
7328 : }
7329 : #endif
7330 692835 : move16();
7331 692835 : IF( gain_preQ_fx != 0 )
7332 : {
7333 8882835 : FOR( i = 0; i < L_subfr; i++ )
7334 : {
7335 : /*code in the encoder is Q9 and there is no <<1 with Mult_32_16 Q16 * Q9 -> Q9 */
7336 8746176 : Ltemp1 = Mult_32_16( gain_code_fx, code_fx[i] ); /* Q16 + Q9 + 1 - 16 = Q10 */
7337 : #ifdef FIX_2010_PREP_TBE_EXC
7338 8746176 : Ltemp2 = L_mult( gain_preQ_fx, code_preQ_fx[i] ); /* Q2 + Q_code_preQ */
7339 : #else
7340 : Ltemp2 = L_mult( gain_preQ_fx, code_preQ_fx[i] ); /*Q2 * Q10 -> Q12 */
7341 : #endif
7342 :
7343 : #ifdef ISSUE_1836_replace_overflow_libcom
7344 8746176 : Ltemp1 = L_shl_sat( Ltemp1, add( Q_exc, 6 ) /*Q_exc+16-19*/ ); /*Q_exc+16 */
7345 8746176 : Ltemp2 = L_shl_sat( Ltemp2, add( Q_exc, shift ) /*Q_exc+ 2 + 6 (or) 10 - 13*/ ); /*Q_exc+16 */
7346 :
7347 8746176 : tmp_code_preInt_fx[i] = round_fx_sat( L_add_sat( Ltemp1, Ltemp2 ) ); /* Q_exc */
7348 : #else
7349 : Ltemp1 = L_shl_o( Ltemp1, add( Q_exc, 6 ) /*Q_exc+16-19*/, &Overflow ); /*Q_exc+16 */
7350 : Ltemp2 = L_shl_o( Ltemp2, add( Q_exc, shift ) /*Q_exc+ 2 + 6 (or) 10 - 13*/, &Overflow ); /*Q_exc+16 */
7351 :
7352 : tmp_code_preInt_fx[i] = round_fx_o( L_add_o( Ltemp1, Ltemp2, &Overflow ), &Overflow ); /* Q_exc */
7353 : #endif
7354 8746176 : move16();
7355 : }
7356 : }
7357 : ELSE
7358 : {
7359 36151440 : FOR( i = 0; i < L_subfr; i++ )
7360 : {
7361 : /*code in the encoder is Q9 and there is no <<1 with Mult_32_16 Q16 * Q9 -> Q9 */
7362 35595264 : Ltemp1 = Mult_32_16( gain_code_fx, code_fx[i] ); /* Q16 + Q9 + 1 - 16 = Q10 */
7363 : #ifdef ISSUE_1836_replace_overflow_libcom
7364 35595264 : Ltemp1 = L_shl_sat( Ltemp1, add( Q_exc, 6 ) /*Q_exc+16-19*/ ); /*Q_exc+16 */
7365 35595264 : tmp_code_preInt_fx[i] = round_fx_sat( Ltemp1 ); /* Q_exc */
7366 : #else
7367 : Ltemp1 = L_shl_o( Ltemp1, add( Q_exc, 6 ) /*Q_exc+16-19*/, &Overflow ); /*Q_exc+16 */
7368 : tmp_code_preInt_fx[i] = round_fx_o( Ltemp1, &Overflow ); /* Q_exc */
7369 : #endif
7370 35595264 : move16();
7371 : }
7372 : }
7373 :
7374 692835 : interp_code_4over2_fx( tmp_code_preInt_fx, tmp_code_fx, L_subfr ); /* o: tmp_code in Q_exc */
7375 89375715 : FOR( i = 0; i < shl( L_subfr, 1 ); i++ )
7376 : {
7377 : #ifdef ISSUE_1836_replace_overflow_libcom
7378 88682880 : L_tmp = L_mult( gain_pit_fx, bwe_exc_fx[i + ( i_subfr_fx << 1 )] ); /*Q14+Q_exc+1 */
7379 88682880 : tmp = round_fx_sat( L_shl_sat( L_tmp, 1 /* (Q_exc+16)-(14+Q_exc+1)*/ ) ); /* tmp in Q_exc */
7380 88682880 : bwe_exc_fx[i + ( i_subfr_fx << 1 )] = add_sat( tmp, tmp_code_fx[i] ); /*Q_exc */
7381 : #else
7382 : L_tmp = L_mult( gain_pit_fx, bwe_exc_fx[i + shl( i_subfr_fx, 1 )] ); /*Q14+Q_exc+1 */
7383 : tmp = round_fx_o( L_shl_o( L_tmp, 1 /* (Q_exc+16)-(14+Q_exc+1)*/, &Overflow ), &Overflow ); /* tmp in Q_exc */
7384 : bwe_exc_fx[i + shl( i_subfr_fx, 1 )] = add_o( tmp, tmp_code_fx[i], &Overflow ); /*Q_exc */
7385 : #endif
7386 88682880 : move16();
7387 : }
7388 : }
7389 :
7390 1159751 : return;
7391 : }
7392 :
7393 :
7394 : /*=============================================================================*/
7395 : /* FUNCTION : void swb_formant_fac_fx ( ) */
7396 : /*------------------------------------------------------------------------------*/
7397 : /* PURPOSE : * Find strength of adaptive formant postfilter using tilt */
7398 : /* of the high band. The 2nd lpc coefficient is used as a tilt approximation. */
7399 : /*------------------------------------------------------------------------------*/
7400 : /* INPUT ARGUMENTS : */
7401 : /* const Word16 lpc_shb2 : 2nd HB LPC coefficient Q12 */
7402 : /*------------------------------------------------------------------------------*/
7403 : /*INPUT/OUTPUT ARGUMENTS : */
7404 : /* Word16 *tilt_mem Q12 */
7405 : /* OUTPUT ARGUMENTS : */
7406 : /*------------------------------------------------------------------------------*/
7407 : /* RETURN ARGUMENTS : */
7408 : /* formant_fac :Formant filter strength [0,1] Q15 */
7409 : /*------------------------------------------------------------------------------*/
7410 : /* CALLED FROM : */
7411 : /*==============================================================================*/
7412 :
7413 : /*! r: Formant filter strength [0,1] */
7414 223135 : Word16 swb_formant_fac_fx(
7415 : const Word16 lpc_shb2, /* Q12 i : 2nd HB LPC coefficient */
7416 : Word16 *tilt_mem /* i/o: Tilt smoothing memory (Q12) */
7417 : )
7418 : {
7419 : Word16 formant_fac;
7420 : Word16 tmp;
7421 : #ifndef ISSUE_1836_replace_overflow_libcom
7422 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
7423 : Flag Overflow = 0;
7424 : #endif
7425 : #endif
7426 :
7427 : /* Smoothen tilt value */
7428 : /* tmp = 0.5f * (float)fabs(lpc_shb2) + 0.5f * *tilt_mem; */
7429 223135 : tmp = mult_r( 16384, abs_s( lpc_shb2 ) );
7430 223135 : tmp = add( tmp, mult_r( 16384, *tilt_mem ) ); /* Q12 */
7431 223135 : *tilt_mem = tmp;
7432 223135 : move16(); /*Q12 */
7433 : /* Map to PF strength */
7434 : /* formant_fac = (tmp - SWB_TILT_LOW)*SWB_TILT_DELTA; */
7435 223135 : tmp = sub( tmp, SWB_TILT_LOW_FX ); /* Q12 */
7436 223135 : formant_fac = mult_r( tmp, SWB_TILT_DELTA_FX ); /* Q12 */
7437 :
7438 223135 : IF( GT_16( formant_fac, 4096 /* 1 in Q12 */ ) )
7439 : {
7440 147 : formant_fac = 4096; /* 1 in Q12 */
7441 147 : move16();
7442 : }
7443 222988 : ELSE IF( formant_fac < 0 )
7444 : {
7445 197540 : formant_fac = 0;
7446 197540 : move16();
7447 : }
7448 : /* now formant_fac in Q12 */
7449 :
7450 : /* formant_fac = 1.0f - 0.5f*formant_fac */
7451 223135 : tmp = mult_r( 16384, formant_fac ); /* 0.5 in Q15 */
7452 : #ifdef ISSUE_1836_replace_overflow_libcom
7453 223135 : formant_fac = shl_sat( sub( 4096 /* 1 in Q12 */, tmp ), 3 );
7454 : #else
7455 : formant_fac = shl_o( sub( 4096 /* 1 in Q12 */, tmp ), 3, &Overflow );
7456 : #endif
7457 223135 : return formant_fac; /*Q15 */
7458 : }
7459 :
7460 :
7461 : /*-------------------------------------------------------------------*
7462 : * wb_tbe_extras_reset_fx()
7463 : *
7464 : *
7465 : *-------------------------------------------------------------------*/
7466 :
7467 22108 : void wb_tbe_extras_reset_fx(
7468 : Word16 mem_genSHBexc_filt_down_wb2[],
7469 : Word16 mem_genSHBexc_filt_down_wb3[] )
7470 : {
7471 22108 : set16_fx( mem_genSHBexc_filt_down_wb2, 0, 2 * ALLPASSSECTIONS_STEEP + 1 );
7472 22108 : set16_fx( mem_genSHBexc_filt_down_wb3, 0, 2 * ALLPASSSECTIONS_STEEP + 1 );
7473 :
7474 22108 : return;
7475 : }
7476 :
7477 : /*-------------------------------------------------------------------*
7478 : * get_tbe_bits() *
7479 : * *
7480 : * Determine TBE bit consumption per frame from bitrate *
7481 : *-------------------------------------------------------------------*/
7482 :
7483 2448 : Word16 get_tbe_bits_fx(
7484 : const Word32 total_brate, /* o : TBE bit consumption per frame */
7485 : const Word16 bwidth, /* i : overall bitrate */
7486 : const Word16 rf_mode /* i : bandwidht mode */
7487 : )
7488 : {
7489 2448 : Word16 i, bits = 0;
7490 :
7491 2448 : IF( EQ_16( rf_mode, 1 ) )
7492 : {
7493 : /* TBE bits for core, primary frame */
7494 0 : test();
7495 0 : test();
7496 0 : IF( ( EQ_16( bwidth, WB ) ) && ( EQ_32( total_brate, ACELP_13k20 ) ) )
7497 : {
7498 : /* Gain frame: 4, Gain shapes: 0, and LSFs: 2 */
7499 0 : bits = NUM_BITS_SHB_FrameGain_LBR_WB + NUM_BITS_LBR_WB_LSF;
7500 0 : move16();
7501 : }
7502 0 : ELSE IF( ( EQ_16( bwidth, SWB ) ) && ( EQ_32( total_brate, ACELP_13k20 ) ) )
7503 : {
7504 : /* Gain frame: 5, Gain shapes: 5, and lowrate LSFs: 8 */
7505 0 : bits = NUM_BITS_SHB_FRAMEGAIN + NUM_BITS_SHB_SUBGAINS + 8;
7506 0 : move16();
7507 : }
7508 : }
7509 : ELSE
7510 : {
7511 2448 : test();
7512 2448 : test();
7513 2448 : IF( ( EQ_16( bwidth, WB ) ) && ( EQ_32( total_brate, ACELP_9k60 ) ) )
7514 : {
7515 0 : bits = NUM_BITS_LBR_WB_LSF + NUM_BITS_SHB_FrameGain_LBR_WB;
7516 0 : move16();
7517 : }
7518 2448 : ELSE IF( ( EQ_16( bwidth, SWB ) ) || ( EQ_16( bwidth, FB ) ) )
7519 : {
7520 2448 : test();
7521 2448 : IF( EQ_32( total_brate, ACELP_9k60 ) )
7522 : {
7523 0 : bits = NUM_BITS_SHB_FRAMEGAIN + NUM_BITS_SHB_SUBGAINS + 8;
7524 0 : move16();
7525 : }
7526 2448 : ELSE IF( ( GE_32( total_brate, ACELP_13k20 ) ) && ( LE_32( total_brate, ACELP_32k ) ) )
7527 : {
7528 2448 : bits = NUM_BITS_SHB_SUBGAINS + NUM_BITS_SHB_FRAMEGAIN + NUM_LSF_GRID_BITS + MIRROR_POINT_BITS;
7529 2448 : move16();
7530 :
7531 14688 : FOR( i = 0; i < NUM_Q_LSF; i++ )
7532 : {
7533 12240 : bits = add( bits, lsf_q_num_bits[i] );
7534 : }
7535 : }
7536 :
7537 2448 : if ( GE_32( total_brate, ACELP_24k40 ) )
7538 : {
7539 2448 : bits = add( bits, NUM_BITS_SHB_ENER_SF + NUM_BITS_SHB_VF + NUM_BITS_SHB_RES_GS * NB_SUBFR16k );
7540 : }
7541 :
7542 2448 : test();
7543 2448 : test();
7544 2448 : if ( EQ_16( bwidth, SWB ) && ( EQ_32( total_brate, ACELP_16k40 ) || EQ_32( total_brate, ACELP_24k40 ) ) )
7545 : {
7546 2448 : bits = add( bits, BITS_TEC + BITS_TFA );
7547 : }
7548 :
7549 2448 : if ( EQ_16( bwidth, FB ) )
7550 : {
7551 : /* full band slope */
7552 0 : bits = add( bits, 4 );
7553 : }
7554 : }
7555 : }
7556 :
7557 2448 : return bits;
7558 : }
|
