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 <math.h>
7 : #include "options.h" /* Compilation switches */
8 : #include "cnst.h" /* Common constants */
9 : #include "prot_fx.h"
10 : #include "rom_com.h" /* Static table prototypes */
11 : #include <assert.h>
12 : #include "rom_enc.h" /* prototypes */
13 : #include "basop_util.h"
14 : #include "ivas_prot_fx.h"
15 : #include "wmc_auto.h"
16 :
17 :
18 : /*-----------------------------------------------------------------*
19 : * Local functions
20 : *-----------------------------------------------------------------*/
21 :
22 :
23 : /*==============================================================================*/
24 : /* FUNCTION : modify_Fs_fx ( ) */
25 : /*------------------------------------------------------------------------------*/
26 : /* PURPOSE : Modify sampling freq by interpolation */
27 : /*------------------------------------------------------------------------------*/
28 : /* INPUT ARGUMENTS : */
29 : /* const Word16 sigIn_fx[] signal to decimate Q_syn2-1 */
30 : /* const Word16 lg length of input */
31 : /* const Word16 fin frequency of input Q0 */
32 : /* const Word16 fout frequency of output Q0 */
33 : /*------------------------------------------------------------------------------*/
34 : /* OUTPUT ARGUMENTS : */
35 : /* Word16 sigOut_fx[] decimated signal Q_syn2-1 */
36 : /*------------------------------------------------------------------------------*/
37 : /* INPUT/OUTPUT ARGUMENTS : */
38 : /* Word16 mem_fx[] filter memory Q_syn2-1 */
39 : /*------------------------------------------------------------------------------*/
40 : /* RETURN ARGUMENTS : */
41 : /* _ None. */
42 : /*------------------------------------------------------------------------------*/
43 : /* CALLED FROM : TX/RX */
44 : /*==============================================================================*/
45 :
46 302 : Word16 modify_Fs_ivas_fx( /* o : length of output Q0 */
47 : const Word16 sigIn_fx[], /* i : signal to decimate Q0 */
48 : Word16 lg, /* i : length of input Q0 */
49 : const Word32 fin, /* i : frequency of input Q0 */
50 : Word16 sigOut_fx[], /* o : decimated signal Q0 */
51 : const Word32 fout, /* i : frequency of output Q0 */
52 : Word16 mem_fx[], /* i/o: filter memory Q0 */
53 : const Word16 nblp, /* i : flag indicating if NB low-pass is applied */
54 : Word16 *Q_new_inp, /*scaling added on sigOut_fx */
55 : Word16 *mem_decim_size /*i: size modified for mem_fx*/
56 : )
57 : {
58 : Word16 i;
59 :
60 : Word16 lg_out, fac_num, fac_den, filt_len, frac, temp_n, mem_len;
61 : Word16 num_den;
62 : Word16 datastep, fracstep;
63 : Word16 *sigIn_ptr, *sigPtr;
64 : Word16 signal_tab_fx[3 * L_FILT_MAX + L_FRAME48k], *signal_fx, *signal_ana_fx; /* 3* as 2* for memory and 1* for future prediction */
65 : Word16 A_fx[M + 1], r_fx_h[M + 1], r_fx_l[M + 1];
66 : Word16 mem_len_ana;
67 : Word16 plus_sample_in;
68 : Word16 j;
69 : Word16 mu_preemph_fx;
70 : Word16 mem_preemph_fx;
71 : Word16 Q_r;
72 : Word16 mem_lev_fx[18];
73 : Word32 t0, t1, t2, L_tmp; /* temporary variables */
74 : Word32 LepsP[M + 1];
75 302 : Word16 flag_low_order = 0;
76 302 : move16();
77 : Word16 filt_len_tmp;
78 : #ifndef ISSUE_1836_replace_overflow_libcom
79 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
80 : Flag Overflow = 0;
81 : move32();
82 : #endif
83 : #endif
84 : const Resampling_cfg *cfg_ptr_fx;
85 :
86 : /*-------------------------------------------------------------------*
87 : * Find the resampling configuration
88 : *-------------------------------------------------------------------*/
89 302 : *Q_new_inp = 0;
90 302 : move16();
91 : /* check if fin and fout are the same */
92 302 : IF( EQ_32( fin, fout ) )
93 : {
94 : /* just copy the signal_fx and quit */
95 0 : Copy( sigIn_fx, sigOut_fx, lg );
96 0 : *mem_decim_size = 0;
97 0 : *Q_new_inp = 0;
98 0 : move16();
99 0 : move16();
100 0 : return lg;
101 : }
102 : ELSE
103 : {
104 : /* find the resampling configuration in the lookup table */
105 302 : cfg_ptr_fx = &resampling_cfg_tbl[0];
106 6342 : WHILE( ( cfg_ptr_fx->fin_fx != 0 ) && !( EQ_32( cfg_ptr_fx->fin_fx, fin ) && EQ_32( cfg_ptr_fx->fout_fx, fout ) ) )
107 : {
108 6040 : test();
109 6040 : test();
110 6040 : cfg_ptr_fx++;
111 : }
112 :
113 :
114 : /* find config with NB 4kHz low-pass */
115 302 : test();
116 302 : test();
117 302 : IF( nblp && ( GT_32( fin, 8000 ) ) && ( EQ_32( fout, 12800 ) ) )
118 : {
119 0 : flag_low_order = 1;
120 0 : move16();
121 0 : cfg_ptr_fx++;
122 0 : WHILE( ( cfg_ptr_fx->fin_fx != 0 ) && !( ( EQ_32( cfg_ptr_fx->fin_fx, fin ) ) && ( EQ_32( cfg_ptr_fx->fout_fx, fout ) ) ) )
123 : {
124 0 : test();
125 0 : test();
126 0 : cfg_ptr_fx++;
127 : }
128 : }
129 :
130 : /*-------------------------------------------------------------------*
131 : * Retrieve and/or calculate the resampling parameters
132 : *-------------------------------------------------------------------*/
133 302 : fac_num = cfg_ptr_fx->fac_num_fx;
134 302 : move16(); /*Q0*/
135 302 : fac_den = cfg_ptr_fx->fac_den_fx;
136 302 : move16();
137 :
138 302 : lg_out = idiv1616( i_mult2( lg, fac_num ), fac_den );
139 302 : filt_len = cfg_ptr_fx->filt_len_fx;
140 302 : move16();
141 302 : plus_sample_in = 0;
142 302 : move16(); /*default, regular delay*/
143 302 : frac = 0;
144 302 : move16();
145 :
146 302 : test();
147 302 : IF( ( EQ_32( fin, 8000 ) ) && ( EQ_32( fout, 12800 ) ) )
148 : {
149 0 : plus_sample_in = 7;
150 0 : move16();
151 0 : frac = 4;
152 0 : move16();
153 : }
154 :
155 302 : mem_len = shl( filt_len, 1 );
156 302 : *mem_decim_size = mem_len;
157 302 : move16();
158 302 : signal_fx = signal_tab_fx + 2 * L_FILT_MAX + sub( L_FRAME48k, add( mem_len, lg ) );
159 302 : signal_ana_fx = signal_fx;
160 302 : mem_len_ana = mem_len;
161 302 : move16();
162 : }
163 :
164 :
165 : /*-------------------------------------------------------------------*
166 : * Resample
167 : *-------------------------------------------------------------------*/
168 : /* append filter memory */
169 302 : Copy( mem_fx, signal_fx, mem_len );
170 :
171 302 : sigPtr = signal_fx + mem_len;
172 302 : Copy( sigIn_fx, sigPtr, lg );
173 :
174 302 : IF( plus_sample_in > 0 )
175 : {
176 0 : autocorr_fx( signal_ana_fx + mem_len_ana + lg - LEN_WIN_SSS, 1, r_fx_h, r_fx_l, &Q_r, LEN_WIN_SSS, wind_sss_fx, 0, 0 );
177 :
178 :
179 0 : t1 = L_Comp( r_fx_h[1], r_fx_l[1] ); /* R[1] in Q31 */
180 0 : t2 = L_abs( t1 ); /* abs R[1] */
181 0 : t0 = L_deposit_l( 0 );
182 0 : IF( r_fx_h[0] != 0 )
183 : {
184 0 : t0 = Div_32( t2, r_fx_h[0], r_fx_l[0] ); /* R[1]/R[0] in Q31 */
185 : }
186 0 : if ( t1 < 0 )
187 : {
188 0 : t0 = L_negate( t0 ); /* R[1]/R[0] */
189 : }
190 :
191 :
192 0 : mu_preemph_fx = extract_h( t0 ); /*r_fx[1] / r_fx[0]; */
193 0 : mem_preemph_fx = signal_ana_fx[mem_len_ana + lg - LEN_WIN_SSS - 1];
194 0 : move16();
195 0 : PREEMPH_FX( signal_ana_fx + mem_len_ana + lg - LEN_WIN_SSS, mu_preemph_fx, LEN_WIN_SSS, &mem_preemph_fx );
196 :
197 :
198 : /* Autocorrelations */
199 0 : autocorr_fx( signal_ana_fx + mem_len_ana + lg - LEN_WIN_SSS, M, r_fx_h, r_fx_l, &Q_r,
200 : LEN_WIN_SSS, wind_sss_fx, 0, 0 );
201 :
202 : /* Lag windowing */
203 0 : lag_wind( r_fx_h, r_fx_l, M, fin, LAGW_STRONG );
204 :
205 : /* Levinson-Durbin */
206 0 : set16_fx( mem_lev_fx, 0, 18 );
207 0 : E_LPC_lev_dur( r_fx_h, r_fx_l, A_fx, LepsP, M, NULL );
208 :
209 0 : Copy_Scale_sig( A_fx, A_fx, M + 1, sub( norm_s( A_fx[0] ), 2 ) );
210 :
211 0 : FOR( i = 0; i < plus_sample_in; i++ )
212 : {
213 0 : sigPtr = signal_fx + add( lg, add( mem_len, i ) );
214 0 : L_tmp = syn_kern_16( 0, A_fx, sigPtr );
215 0 : L_tmp = L_shl_sat( L_tmp, 3 );
216 0 : *sigPtr = round_fx_sat( L_tmp ); /* AZ ringing padding */
217 0 : move16();
218 : }
219 0 : mem_preemph_fx = signal_fx[mem_len + lg - LEN_WIN_SSS - 1];
220 0 : move16();
221 0 : deemph_fx( signal_fx + mem_len + lg - LEN_WIN_SSS, mu_preemph_fx, LEN_WIN_SSS + plus_sample_in, &mem_preemph_fx );
222 : }
223 : /* interpolation */
224 :
225 302 : datastep = shr( div_s( shl( fac_den, 7 ), shl( fac_num, 10 ) ), 12 );
226 : /* equivalent to 'datastep = fac_den % fac_num' */
227 302 : temp_n = i_mult2( datastep, fac_num ); /*Q0*/
228 302 : fracstep = sub( fac_den, temp_n );
229 :
230 302 : sigIn_ptr = signal_fx + add( filt_len, plus_sample_in );
231 :
232 302 : filt_len_tmp = filt_len;
233 302 : move16();
234 302 : IF( flag_low_order )
235 : {
236 0 : filt_len_tmp = shr( add( filt_len, 1 ), 1 );
237 : }
238 :
239 302 : Word16 norm_cfg_ptr = norm_s( sub( cfg_ptr_fx->filter_fx[0], 1 ) );
240 308342 : FOR( i = 0; i < lg_out; i++ )
241 : {
242 308040 : sigOut_fx[i] = round_fx_sat( Interpol_lc_fx( sigIn_ptr, cfg_ptr_fx->filter_fx, frac, fac_num, filt_len_tmp ) );
243 308040 : move16();
244 308040 : frac = add( frac, fracstep );
245 :
246 308040 : j = sub( fac_num, frac );
247 308040 : if ( j < 0 )
248 : {
249 9966 : frac = sub( frac, fac_num );
250 : }
251 308040 : sigIn_ptr += add( lshr( j, 15 ), datastep );
252 : }
253 302 : *Q_new_inp = negate( norm_cfg_ptr );
254 302 : move16();
255 : /* rescaling */
256 302 : test();
257 :
258 302 : IF( EQ_32( ( GT_16( fac_num, fac_den ) ), ( ( cfg_ptr_fx->flags_fx & RS_INV_FAC ) != 0 ) ) )
259 : {
260 0 : IF( LT_16( fac_num, fac_den ) )
261 : {
262 0 : num_den = div_s( fac_num, fac_den ); /*Q15*/
263 0 : test();
264 0 : IF( GT_32( fin, 16000 ) && EQ_16( lg_out, 512 ) )
265 : {
266 :
267 0 : FOR( i = 0; i < lg_out; i++ )
268 : {
269 0 : sigOut_fx[i] = round_fx( L_shl( L_mult( sigOut_fx[i], num_den ), 1 ) ); /*Q0*/
270 0 : move16();
271 : }
272 0 : *Q_new_inp = add( *Q_new_inp, 1 );
273 0 : move16();
274 : }
275 : ELSE
276 : {
277 0 : test();
278 0 : test();
279 0 : test();
280 0 : IF( GT_32( fin, 16000 ) && ( EQ_16( lg_out, L_FRAME ) || EQ_16( lg_out, L_FRAME16k ) || EQ_16( lg_out, 512 ) ) )
281 : {
282 : #ifdef ISSUE_1836_replace_overflow_libcom
283 0 : num_den = shl_sat( num_den, 1 );
284 : #else
285 : num_den = shl_o( num_den, 1, &Overflow );
286 : #endif
287 0 : *Q_new_inp = add( *Q_new_inp, 1 );
288 0 : move16();
289 : }
290 0 : FOR( i = 0; i < lg_out; i++ )
291 : {
292 0 : sigOut_fx[i] = mult_r( sigOut_fx[i], num_den ); /*Q0*/
293 0 : move16();
294 : }
295 : }
296 : }
297 : ELSE
298 : {
299 0 : IF( EQ_16( fac_num, 8 ) )
300 : {
301 0 : num_den = 26214;
302 0 : move16();
303 0 : FOR( i = 0; i < lg_out; i++ )
304 : {
305 0 : sigOut_fx[i] = mult_r( sigOut_fx[i], num_den ); /*Q-1*/
306 0 : move16();
307 : }
308 : }
309 : ELSE
310 : {
311 0 : num_den = div_s( sub( fac_num, fac_den ), fac_den ); /*Q15*/
312 0 : FOR( i = 0; i < lg_out; i++ )
313 : {
314 0 : sigOut_fx[i] = round_fx( L_mac( L_deposit_h( sigOut_fx[i] ), sigOut_fx[i], num_den ) ); /*Q0*/
315 0 : move16();
316 : }
317 0 : *Q_new_inp = add( *Q_new_inp, 1 );
318 0 : move16();
319 : }
320 : }
321 : }
322 302 : ELSE IF( ( LT_16( fac_num, fac_den ) ) && ( ( cfg_ptr_fx->flags_fx & RS_INV_FAC ) != 0 ) )
323 : {
324 0 : FOR( i = 0; i < lg_out; i++ )
325 : {
326 0 : sigOut_fx[i] = mult_r( sigOut_fx[i], 16384 );
327 0 : move16(); /*Q-1*/
328 : }
329 : }
330 : /* update the filter memory */
331 302 : sigPtr = signal_fx + lg;
332 302 : Copy( sigPtr, mem_fx, mem_len );
333 :
334 302 : return lg_out;
335 : }
336 :
337 1300 : Word16 modify_Fs_fx( /* o : length of output Q0 */
338 : const Word16 sigIn_fx[], /* i : signal to decimate Q0 */
339 : Word16 lg, /* i : length of input Q0 */
340 : const Word32 fin, /* i : frequency of input Q0 */
341 : Word16 sigOut_fx[], /* o : decimated signal Q0 */
342 : const Word32 fout, /* i : frequency of output Q0 */
343 : Word16 mem_fx[], /* i/o: filter memory Q0 */
344 : const Word16 nblp /* i : flag indicating if NB low-pass is applied */
345 : )
346 : {
347 : Word16 i;
348 :
349 : Word16 lg_out, fac_num, fac_den, filt_len, frac, temp_n, mem_len;
350 : Word16 num_den;
351 : Word16 datastep, fracstep;
352 : Word16 *sigIn_ptr, *sigPtr;
353 : Word16 signal_tab_fx[3 * L_FILT_MAX + L_FRAME48k], *signal_fx, *signal_ana_fx; /* 3* as 2* for memory and 1* for future prediction */
354 : Word16 A_fx[M + 1], r_fx_h[M + 1], r_fx_l[M + 1];
355 : Word16 mem_len_ana;
356 : Word16 plus_sample_in;
357 : Word16 j;
358 : Word16 mu_preemph_fx;
359 : Word16 mem_preemph_fx;
360 : Word16 Q_r;
361 : Word16 mem_lev_fx[18];
362 : Word32 t0, t1, t2, L_tmp; /* temporary variables */
363 : Word32 LepsP[M + 1];
364 1300 : Word16 flag_low_order = 0;
365 1300 : move16();
366 : Word16 filt_len_tmp;
367 : #ifndef ISSUE_1836_replace_overflow_libcom
368 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
369 : Flag Overflow = 0;
370 : move32();
371 : #endif
372 : #endif
373 : const Resampling_cfg *cfg_ptr_fx;
374 :
375 : /*-------------------------------------------------------------------*
376 : * Find the resampling configuration
377 : *-------------------------------------------------------------------*/
378 :
379 : /* check if fin and fout are the same */
380 1300 : IF( EQ_32( fin, fout ) )
381 : {
382 : /* just copy the signal_fx and quit */
383 0 : Copy( sigIn_fx, sigOut_fx, lg );
384 :
385 0 : return lg;
386 : }
387 : ELSE
388 : {
389 : /* find the resampling configuration in the lookup table */
390 1300 : cfg_ptr_fx = &resampling_cfg_tbl[0];
391 7150 : WHILE( ( cfg_ptr_fx->fin_fx != 0 ) && !( EQ_32( cfg_ptr_fx->fin_fx, fin ) && EQ_32( cfg_ptr_fx->fout_fx, fout ) ) )
392 : {
393 5850 : test();
394 5850 : test();
395 5850 : cfg_ptr_fx++;
396 : }
397 :
398 :
399 : /* find config with NB 4kHz low-pass */
400 1300 : test();
401 1300 : test();
402 1300 : IF( nblp && ( GT_32( fin, 8000 ) ) && ( EQ_32( fout, 12800 ) ) )
403 : {
404 0 : flag_low_order = 1;
405 0 : move16();
406 0 : cfg_ptr_fx++;
407 0 : WHILE( ( cfg_ptr_fx->fin_fx != 0 ) && !( ( EQ_32( cfg_ptr_fx->fin_fx, fin ) ) && ( EQ_32( cfg_ptr_fx->fout_fx, fout ) ) ) )
408 : {
409 0 : test();
410 0 : test();
411 0 : cfg_ptr_fx++;
412 : }
413 : }
414 :
415 : /*-------------------------------------------------------------------*
416 : * Retrieve and/or calculate the resampling parameters
417 : *-------------------------------------------------------------------*/
418 1300 : fac_num = cfg_ptr_fx->fac_num_fx;
419 1300 : move16(); /*Q0*/
420 1300 : fac_den = cfg_ptr_fx->fac_den_fx;
421 1300 : move16();
422 :
423 1300 : IF( GE_16( lg, L_FRAME ) )
424 : {
425 1300 : lg_out = cfg_ptr_fx->lg_out;
426 1300 : move16();
427 : }
428 : ELSE
429 : {
430 0 : lg_out = idiv1616( i_mult2( lg, fac_num ), fac_den );
431 : }
432 1300 : filt_len = cfg_ptr_fx->filt_len_fx;
433 1300 : move16();
434 1300 : plus_sample_in = 0;
435 1300 : move16(); /*default, regular delay*/
436 1300 : frac = 0;
437 1300 : move16();
438 :
439 1300 : test();
440 1300 : IF( ( EQ_32( fin, 8000 ) ) && ( EQ_32( fout, 12800 ) ) )
441 : {
442 0 : plus_sample_in = 7;
443 0 : move16();
444 0 : frac = 4;
445 0 : move16();
446 : }
447 :
448 1300 : mem_len = shl( filt_len, 1 );
449 1300 : signal_fx = signal_tab_fx + 2 * L_FILT_MAX + sub( L_FRAME48k, add( mem_len, lg ) );
450 1300 : signal_ana_fx = signal_fx;
451 1300 : mem_len_ana = mem_len;
452 1300 : move16();
453 : }
454 :
455 :
456 : /*-------------------------------------------------------------------*
457 : * Resample
458 : *-------------------------------------------------------------------*/
459 : /* append filter memory */
460 1300 : Copy( mem_fx, signal_fx, mem_len );
461 :
462 1300 : sigPtr = signal_fx + mem_len;
463 1300 : Copy( sigIn_fx, sigPtr, lg );
464 :
465 1300 : IF( plus_sample_in > 0 )
466 : {
467 0 : autocorr_fx( signal_ana_fx + sub( add( mem_len_ana, lg ), LEN_WIN_SSS ), 1, r_fx_h, r_fx_l, &Q_r, LEN_WIN_SSS, wind_sss_fx, 0, 0 );
468 :
469 :
470 0 : t1 = L_Comp( r_fx_h[1], r_fx_l[1] ); /* R[1] in Q31 */
471 0 : t2 = L_abs( t1 ); /* abs R[1] */
472 0 : t0 = L_deposit_l( 0 );
473 0 : IF( r_fx_h[0] != 0 )
474 : {
475 0 : t0 = Div_32( t2, r_fx_h[0], r_fx_l[0] ); /* R[1]/R[0] in Q31 */
476 : }
477 0 : if ( t1 < 0 )
478 : {
479 0 : t0 = L_negate( t0 ); /* R[1]/R[0] */
480 : }
481 :
482 :
483 0 : mu_preemph_fx = extract_h( t0 ); /*r_fx[1] / r_fx[0]; */
484 0 : mem_preemph_fx = signal_ana_fx[mem_len_ana + lg - LEN_WIN_SSS - 1];
485 0 : move16();
486 0 : PREEMPH_FX( signal_ana_fx + sub( add( mem_len_ana, lg ), LEN_WIN_SSS ), mu_preemph_fx, LEN_WIN_SSS, &mem_preemph_fx );
487 :
488 :
489 : /* Autocorrelations */
490 0 : autocorr_fx( signal_ana_fx + sub( add( mem_len_ana, lg ), LEN_WIN_SSS ), M, r_fx_h, r_fx_l, &Q_r,
491 : LEN_WIN_SSS, wind_sss_fx, 0, 0 );
492 :
493 : /* Lag windowing */
494 0 : lag_wind( r_fx_h, r_fx_l, M, fin, LAGW_STRONG );
495 :
496 : /* Levinson-Durbin */
497 0 : set16_fx( mem_lev_fx, 0, 18 );
498 0 : E_LPC_lev_dur( r_fx_h, r_fx_l, A_fx, LepsP, M, NULL );
499 :
500 0 : Copy_Scale_sig( A_fx, A_fx, M + 1, sub( norm_s( A_fx[0] ), 2 ) );
501 :
502 0 : FOR( i = 0; i < plus_sample_in; i++ )
503 : {
504 0 : sigPtr = signal_fx + add( add( lg, mem_len ), i );
505 0 : move16(); /*+i*/
506 0 : L_tmp = syn_kern_16( 0, A_fx, sigPtr );
507 0 : L_tmp = L_shl_sat( L_tmp, 3 );
508 0 : *sigPtr = round_fx_sat( L_tmp ); /* AZ ringing padding */
509 : }
510 0 : mem_preemph_fx = signal_fx[mem_len + lg - LEN_WIN_SSS - 1];
511 0 : move16();
512 0 : deemph_fx( signal_fx + sub( add( mem_len, lg ), LEN_WIN_SSS ), mu_preemph_fx, add( LEN_WIN_SSS, plus_sample_in ), &mem_preemph_fx );
513 : }
514 : /* interpolation */
515 :
516 1300 : datastep = shr( div_s( shl( fac_den, 8 ), shl( fac_num, 11 ) ), 12 );
517 : /* equivalent to 'datastep = fac_den % fac_num' */
518 1300 : temp_n = i_mult2( datastep, fac_num ); /*Q0*/
519 1300 : fracstep = sub( fac_den, temp_n );
520 :
521 1300 : sigIn_ptr = signal_fx + add( filt_len, plus_sample_in );
522 :
523 1300 : filt_len_tmp = filt_len;
524 1300 : move16();
525 1300 : IF( flag_low_order )
526 : {
527 0 : filt_len_tmp = shr( add( filt_len, 1 ), 1 );
528 : }
529 :
530 375700 : FOR( i = 0; i < lg_out; i++ )
531 : {
532 374400 : sigOut_fx[i] = round_fx_sat( Interpol_lc_fx( sigIn_ptr, cfg_ptr_fx->filter_fx, frac, fac_num, filt_len_tmp ) );
533 374400 : move16();
534 374400 : frac = add( frac, fracstep );
535 :
536 374400 : j = sub( fac_num, frac );
537 374400 : if ( j < 0 )
538 : {
539 206700 : frac = sub( frac, fac_num );
540 : }
541 374400 : sigIn_ptr += add( lshr( j, 15 ), datastep );
542 : }
543 : /* rescaling */
544 1300 : test();
545 :
546 1300 : IF( EQ_32( ( GT_16( fac_num, fac_den ) ), ( ( cfg_ptr_fx->flags_fx & RS_INV_FAC ) != 0 ) ) )
547 : {
548 650 : IF( LT_16( fac_num, fac_den ) )
549 : {
550 650 : num_den = div_s( fac_num, fac_den ); /*Q15*/
551 650 : test();
552 650 : IF( GT_32( fin, 16000 ) && EQ_16( lg_out, 512 ) )
553 : {
554 :
555 0 : FOR( i = 0; i < lg_out; i++ )
556 : {
557 0 : sigOut_fx[i] = round_fx( L_shl( L_mult( sigOut_fx[i], num_den ), 1 ) ); /*Q0*/
558 : }
559 : }
560 : ELSE
561 : {
562 650 : test();
563 650 : test();
564 650 : test();
565 650 : if ( GT_32( fin, 16000 ) && ( EQ_16( lg_out, L_FRAME ) || EQ_16( lg_out, L_FRAME16k ) || EQ_16( lg_out, 512 ) ) )
566 : {
567 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
568 : #ifdef ISSUE_1836_replace_overflow_libcom
569 0 : num_den = shl_sat( num_den, 1 );
570 : #else
571 : num_den = shl_o( num_den, 1, &Overflow );
572 : #endif
573 : #else
574 : num_den = shl( num_den, 1 );
575 : #endif
576 : }
577 167050 : FOR( i = 0; i < lg_out; i++ )
578 : {
579 166400 : sigOut_fx[i] = mult_r( sigOut_fx[i], num_den ); /*Q0*/
580 166400 : move16();
581 : }
582 : }
583 : }
584 : ELSE
585 : {
586 0 : IF( EQ_16( fac_num, 8 ) )
587 : {
588 0 : num_den = 26214;
589 0 : FOR( i = 0; i < lg_out; i++ )
590 : {
591 0 : sigOut_fx[i] = mult_r( sigOut_fx[i], num_den ); /*Q-1*/
592 0 : move16();
593 : }
594 : }
595 : ELSE
596 : {
597 0 : num_den = div_s( sub( fac_num, fac_den ), fac_den ); /*Q15*/
598 0 : FOR( i = 0; i < lg_out; i++ )
599 : {
600 0 : sigOut_fx[i] = round_fx( L_mac( L_deposit_h( sigOut_fx[i] ), sigOut_fx[i], num_den ) ); /*Q0*/
601 : }
602 : }
603 : }
604 : }
605 650 : ELSE IF( ( LT_16( fac_num, fac_den ) ) && ( ( cfg_ptr_fx->flags_fx & RS_INV_FAC ) != 0 ) )
606 : {
607 0 : FOR( i = 0; i < lg_out; i++ )
608 : {
609 0 : sigOut_fx[i] = mult_r( sigOut_fx[i], 16384 );
610 0 : move16(); /*Q-1*/
611 : }
612 : }
613 : /* update the filter memory */
614 1300 : sigPtr = signal_fx + lg;
615 1300 : Copy( sigPtr, mem_fx, mem_len );
616 :
617 1300 : return lg_out;
618 : }
619 :
620 : /*-------------------------------------------------------------------*
621 : * modify_Fs_intcub3m_sup()
622 : *
623 : *
624 : *-------------------------------------------------------------------*/
625 :
626 25 : Word16 modify_Fs_intcub3m_sup_fx( /* o : length of output */
627 : const Word16 sigIn[], /* i : signal to decimate with memory of 2 samples (indexes -2 & -1) */
628 : const Word16 lg, /* i : length of input (suppose that lg is such that lg_out is integer, ex multiple of 5 in case of 16kHz to 12.8 kHz) */
629 : const Word32 fin, /* i : frequency of input */
630 : Word16 sigOut[], /* o : decimated signal */
631 : const Word32 fout, /* i : frequency of output */
632 : Word16 *delayout /* o : delay of output */
633 : )
634 : {
635 : Word16 i, k, i1, i2, k1, k2, k3, kk, cind;
636 : Word16 lg_out, fk1, k2d, k3d;
637 : Word16 cc[4][4];
638 25 : const Word16( *cu )[3] = 0;
639 : Word16 *sigin_sr, *sigOutptr, *cptr;
640 : const Word16 *uptr, *ctptr;
641 : Word16 *sigin_sr_tab;
642 : Word16 lim, inc, lim2, lim3;
643 : Word32 vv32;
644 : #define QSR 2 /* right shift to avoid overflow, 2 is OK */
645 :
646 25 : k = 0;
647 25 : move16(); /* to avoid compilation warnings */
648 25 : inc = 0;
649 25 : move16(); /* to avoid compilation warnings */
650 :
651 : /*-------------------------------------------------------------------*
652 : * Find the resampling configuration
653 : *-------------------------------------------------------------------*/
654 :
655 : /* check if fin and fout are the same */
656 25 : IF( EQ_32( fin, fout ) )
657 : {
658 : /* just copy the signal_fx and quit */
659 0 : Copy( sigIn, sigOut, lg );
660 0 : *delayout = 0;
661 0 : move16();
662 :
663 0 : return lg;
664 : }
665 : ELSE
666 : {
667 25 : sigin_sr_tab = (Word16 *) calloc( lg + 2, sizeof( *sigin_sr ) ); /*shift right*/
668 25 : sigin_sr = sigin_sr_tab + 2;
669 555 : FOR( i = -2; i < lg; i++ )
670 : {
671 530 : sigin_sr[i] = shr( sigIn[i], QSR );
672 530 : move16(); /* shift right : Q0 -> Q(-QSR) */
673 : }
674 :
675 : /* length of the interpolated signal */
676 : /*lg_out = (short)(lg * fout / fin); */
677 :
678 : /* cc[x][3]*s*s*s + cc[x][2]*s*s + cc[x][1]*s + cc[x][0]; indexes relatives of s : -1 0 1 2 */
679 : /* d : cc[x][0] = s[0] */
680 : /* b : cc[x][2] =(s[-1]+s[1])/2-s[0] */
681 : /* a : cc[x][3] = (s[-1]+s[2]-s[0]-s[1]-4*cc[x][2]) / 6 */
682 : /* c : cc[x][1] = s[1]-s[0]-cc[x][3]-cc[x][2] */
683 :
684 : /* coef inits using memory (indexes < 0) */
685 : /* cc[2][] : indexes -2 -1 0 1 */
686 25 : cptr = &( cc[2][0] );
687 25 : cptr[0] = mult_r( sigin_sr[-1], 10923 );
688 25 : move16(); /* sigIn[-1]/3 */
689 25 : cptr[2] = sub( shr( add( sigin_sr[-2], sigin_sr[0] ), 1 ), sigin_sr[-1] );
690 25 : move16(); /* (sigIn[-2]+sigIn[0])/2-sigIn[-1]; */
691 25 : cptr[3] = sub( mult_r( sub( add( sigin_sr[-2], sigin_sr[1] ), add( sigin_sr[-1], sigin_sr[0] ) ), 5461 ), mult_r( cptr[2], 21845 ) );
692 25 : move16(); /*(sigIn[-2]+sigIn[1]-sigIn[-1]-sigIn[0]) / 6 - 4/6*cc[2][2]);*/
693 25 : cptr[1] = sub( sub( sigin_sr[0], sigin_sr[-1] ), add( cptr[3], cptr[2] ) );
694 25 : move16();
695 :
696 : /* cc[3][] : indexes -1 0 1 2 */
697 25 : cptr = &( cc[3][0] );
698 25 : cptr[0] = mult_r( sigin_sr[0], 10923 );
699 25 : move16(); /* sigIn[-1]/3 */
700 25 : cptr[2] = sub( shr( add( sigin_sr[-1], sigin_sr[1] ), 1 ), sigin_sr[0] );
701 25 : move16(); /* (sigIn[-1]+sigIn[1])/2-sigIn[0]; */
702 25 : cptr[3] = sub( mult_r( sub( add( sigin_sr[-1], sigin_sr[2] ), add( sigin_sr[0], sigin_sr[1] ) ), 5461 ), mult_r( cptr[2], 21845 ) );
703 25 : move16(); /*(sigIn[-2]+sigIn[1]-sigIn[-1]-sigIn[0]) / 6 - 4/6*cc[2][2]);*/
704 25 : cptr[1] = sub( sub( sigin_sr[1], sigin_sr[0] ), add( cptr[3], cptr[2] ) );
705 25 : move16();
706 :
707 25 : sigOutptr = sigOut;
708 25 : cind = -1;
709 25 : move16();
710 25 : move16(); /* for the move */
711 25 : IF( EQ_32( fin, 12800 ) )
712 : {
713 5 : if ( EQ_32( fout, 8000 ) )
714 : {
715 0 : cind = 0;
716 0 : move16();
717 : }
718 5 : if ( EQ_32( fout, 16000 ) )
719 : {
720 0 : cind = 1;
721 0 : move16();
722 : }
723 5 : if ( EQ_32( fout, 32000 ) )
724 : {
725 5 : cind = 2;
726 5 : move16();
727 : }
728 5 : if ( EQ_32( fout, 48000 ) )
729 : {
730 0 : cind = 3;
731 0 : move16();
732 : }
733 : }
734 25 : IF( EQ_32( fin, 16000 ) )
735 : {
736 20 : if ( EQ_32( fout, 12800 ) )
737 : {
738 0 : cind = 4;
739 0 : move16();
740 : }
741 20 : if ( EQ_32( fout, 32000 ) )
742 : {
743 0 : cind = 5;
744 0 : move16();
745 : }
746 20 : if ( EQ_32( fout, 48000 ) )
747 : {
748 20 : cind = 6;
749 20 : move16();
750 : }
751 : }
752 25 : ctptr = &( ct2_fx[cind][0] );
753 25 : lg_out = mult_r( shl( lg, 2 ), ctptr[13] );
754 25 : *delayout = ctptr[9];
755 25 : move16();
756 :
757 25 : if ( EQ_16( ctptr[12], 15 ) )
758 : {
759 25 : cu = cu15_fx;
760 25 : move16(); /*pointer*/
761 : }
762 :
763 25 : if ( EQ_16( ctptr[12], 4 ) )
764 : {
765 0 : cu = cu4_fx;
766 0 : move16(); /*pointer*/
767 : }
768 :
769 25 : k2d = sub( ctptr[12], 1 ); /* shift of index in cu with respect to the next sample (ex 1.25 -> 0.25 ) */
770 25 : fk1 = shl( k2d, 1 );
771 25 : k3d = sub( fk1, 1 ); /* to compurte index in cu with respect to the last sample with - sign (ex 1.25 -> -0.75 ) */
772 :
773 25 : kk = 0;
774 25 : move16();
775 25 : i = 0;
776 25 : move16();
777 :
778 25 : lim = sub( lg, ctptr[11] );
779 25 : lim2 = sub( lg, 3 );
780 25 : lim3 = ctptr[10];
781 25 : move16();
782 400 : WHILE( LT_16( i, lim2 ) )
783 : {
784 375 : if ( GE_16( i, lim ) )
785 : {
786 25 : lim3 = sub( ctptr[11], 3 ); /* last, incomplete period*/
787 : }
788 375 : *sigOutptr++ = sigIn[i];
789 375 : move16();
790 780 : FOR( k = 0; k < lim3; k++ )
791 : {
792 405 : cptr = &( cc[kk][0] );
793 405 : cptr[0] = mult_r( sigin_sr[i + 1], 10923 );
794 405 : move16(); /* sigIn[-1]/3 */
795 405 : cptr[2] = sub( shr( add( sigin_sr[i], sigin_sr[i + 2] ), 1 ), sigin_sr[i + 1] );
796 405 : move16(); /* (sigIn[-1]+sigIn[1])/2-sigIn[0]; */
797 405 : cptr[3] = sub( mult_r( sub( add( sigin_sr[i], sigin_sr[i + 3] ), add( sigin_sr[i + 1], sigin_sr[i + 2] ) ), 5461 ), mult_r( cptr[2], 21845 ) );
798 405 : move16(); /*(sigIn[-1]+sigIn[1]-sigIn[0]-sigIn[1]) / 6 - 4/6*cc[3][2]);*/
799 405 : cptr[1] = sub( sub( sigin_sr[i + 2], sigin_sr[i + 1] ), add( cptr[3], cptr[2] ) );
800 405 : move16();
801 405 : i = add( i, 1 );
802 :
803 405 : i2 = sub( kk, 2 );
804 405 : i1 = sub( kk, 1 );
805 405 : if ( i1 < 0 )
806 : {
807 120 : i1 = add( i1, 4 );
808 : }
809 :
810 405 : if ( i2 < 0 )
811 : {
812 215 : i2 = add( i2, 4 );
813 : }
814 405 : inc = ctptr[8];
815 405 : move16();
816 1215 : FOR( k1 = ctptr[k]; k1 < fk1; k1 += inc )
817 : {
818 810 : k2 = sub( k1, k2d );
819 810 : k3 = sub( k3d, k1 );
820 810 : cptr = &( cc[i2][0] );
821 810 : uptr = &( cu[k1][0] );
822 810 : vv32 = L_mult( 8192, *cptr++ );
823 810 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
824 810 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
825 810 : vv32 = L_mac( vv32, *uptr++, *cptr++ ); /* Q13*Q(-QSR) -> Q(13-QSR+1) 32 bits*/
826 810 : cptr = &( cc[i1][0] );
827 810 : uptr = &( cu[k2][0] );
828 810 : vv32 = L_mac( vv32, 8192, *cptr++ );
829 810 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
830 810 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
831 810 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
832 810 : cptr = &( cc[kk][0] );
833 810 : uptr = &( cu[k3][0] );
834 810 : vv32 = L_mac( vv32, 8192, *cptr++ );
835 810 : vv32 = L_msu( vv32, *uptr++, *cptr++ );
836 810 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
837 810 : vv32 = L_msu( vv32, *uptr++, *cptr++ );
838 810 : vv32 = L_shl( vv32, ( QSR + 2 ) ); /* Q(13-QSR+1) -> Q16 */
839 810 : *sigOutptr++ = round_fx( vv32 ); /* Q16 -> Q0*/
840 : }
841 :
842 405 : kk = add( kk, 1 );
843 405 : if ( EQ_16( kk, 4 ) )
844 : {
845 95 : kk = 0;
846 95 : move16();
847 : }
848 : }
849 : }
850 :
851 :
852 25 : kk = sub( kk, 1 );
853 25 : if ( kk < 0 )
854 : {
855 0 : kk = 3;
856 0 : move16();
857 : }
858 :
859 25 : if ( EQ_16( ctptr[10], 1 ) )
860 : {
861 20 : *sigOutptr++ = sigIn[i];
862 20 : move16();
863 : }
864 :
865 75 : FOR( k1 = ctptr[k]; k1 < fk1; k1 += inc )
866 : {
867 50 : k2 = sub( k1, k2d );
868 :
869 50 : cptr = &( cc[kk][0] );
870 50 : uptr = &( cu[k2][0] );
871 50 : vv32 = L_mult( 8192, *cptr++ );
872 50 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
873 50 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
874 50 : vv32 = L_mac( vv32, *uptr++, *cptr++ ); /* Q13*Q(-QSR) -> Q(13-QSR+1) 32 bits*/
875 50 : vv32 = L_shl( vv32, ( QSR + 2 ) ); /* Q(13-QSR+1) -> Q16 */
876 50 : *sigOutptr++ = i_mult( round_fx( vv32 ), 3 );
877 50 : move16(); /* Q16 -> Q0*/
878 : }
879 :
880 25 : if ( LT_16( ctptr[10], 3 ) )
881 : {
882 25 : *sigOutptr++ = sigIn[i + 1];
883 25 : move16();
884 : }
885 :
886 75 : FOR( k1 = ctptr[k + 1]; k1 < fk1; k1 += inc )
887 : {
888 50 : cptr = &( cc[kk][0] );
889 50 : uptr = &( cu[k1][0] );
890 50 : vv32 = L_mult( 8192, *cptr++ );
891 50 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
892 50 : vv32 = L_mac( vv32, *uptr++, *cptr++ );
893 50 : vv32 = L_mac( vv32, *uptr++, *cptr++ ); /* Q13*Q(-QSR) -> Q(13-QSR+1) 32 bits*/
894 50 : vv32 = L_shl( vv32, ( QSR + 2 ) ); /* Q(13-QSR+1) -> Q16 */
895 50 : *sigOutptr++ = i_mult( round_fx( vv32 ), 3 );
896 50 : move16(); /* Q16 -> Q0*/
897 : }
898 :
899 25 : if ( EQ_16( ctptr[10], 1 ) )
900 : {
901 20 : *sigOutptr = sigIn[i + 2];
902 20 : move16();
903 : }
904 : }
905 :
906 25 : free( sigin_sr_tab );
907 :
908 25 : return lg_out;
909 : }
910 :
911 : /*====================================================================*/
912 : /* FUNCTION : Decimate_allpass_steep_fx1 () */
913 : /*-------------------------------------------------------------------*/
914 : /* PURPOSE : decimation by a factor 2 */
915 : /*-------------------------------------------------------------------*/
916 : /* INPUT ARGUMENTS : */
917 : /* _ (const Word16 *) in_fx : input speech, Q0 */
918 : /* _ (Word16 []) mem: Stateinfo, Q0 */
919 : /* Size: 2*ALLPASSSECTIONS_STEEP+1 */
920 : /* _ (Word16) N: Number of Input samples */
921 : /* _ (Word16 []) out_fx :Output arry of size N/2 Q0 */
922 : /*-------------------------------------------------------------------*/
923 : /* OUTPUT ARGUMENTS : */
924 : /* _ (Word16 []) out_fx : output-signal, Q0 */
925 : /* _ (Word16 []) mem:gets updated, Q0 */
926 : /*-------------------------------------------------------------------*/
927 : /* INPUT/OUTPUT ARGUMENTS : */
928 : /*-------------------------------------------------------------------*/
929 : /* RETURN ARGUMENTS : _ None. */
930 : /*===================================================================*/
931 :
932 126841 : void Decimate_allpass_steep_fx(
933 : const Word16 *in_fx,
934 : Word16 mem[], /* array of size: 2*ALLPASSSECTIONS_STEEP+1 */
935 : Word16 N, /* number of input samples */
936 : Word16 out_fx[] ) /* array of size N/2 */
937 : {
938 :
939 : Word16 k;
940 : Word16 temp[ALLPASSSECTIONS_STEEP];
941 : Word32 Lacc, Lacc1;
942 : Word16 temp1, temp2;
943 126841 : Word16 sum = 0;
944 : #ifndef ISSUE_1836_replace_overflow_libcom
945 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
946 : Flag Overflow = 0;
947 : move32();
948 : #endif
949 : #endif
950 126841 : move16();
951 :
952 : /*upper allpass filter chain */
953 :
954 :
955 37952361 : FOR( k = 0; k < N / 2; k++ )
956 : {
957 :
958 37825520 : Lacc = L_deposit_h( mem[0] ); /* Q(16+x) */
959 : #ifdef ISSUE_1836_replace_overflow_libcom
960 37825520 : Lacc = L_mac_sat( Lacc, AP1_STEEP_FX[0], in_fx[2 * k] ); /* Q(16+x) */
961 37825520 : Lacc1 = L_deposit_h( in_fx[2 * k] ); /* Q16+Qx */
962 37825520 : temp1 = extract_h( Lacc ); /* Qx */
963 37825520 : Lacc1 = L_msu_sat( Lacc1, AP1_STEEP_FX[0], temp1 ); /* Q16+Qx */
964 : #else
965 : Lacc = L_mac_o( Lacc, AP1_STEEP_FX[0], in_fx[2 * k], &Overflow ); /* Q(16+x) */
966 : Lacc1 = L_deposit_h( in_fx[2 * k] ); /* Q16+Qx */
967 : temp1 = extract_h( Lacc ); /* Qx */
968 : Lacc1 = L_msu_o( Lacc1, AP1_STEEP_FX[0], temp1, &Overflow ); /* Q16+Qx */
969 : #endif
970 37825520 : mem[0] = extract_h( Lacc1 ); /* Qx */
971 37825520 : temp[0] = temp1;
972 37825520 : move16();
973 37825520 : move16();
974 :
975 37825520 : Lacc1 = L_deposit_h( mem[1] ); /* Q16+Qx */
976 : #ifdef ISSUE_1836_replace_overflow_libcom
977 37825520 : Lacc1 = ( L_mac_sat( Lacc1, AP1_STEEP_FX[1], temp1 ) ); /* Q16+Qx */
978 :
979 37825520 : temp2 = extract_h( Lacc1 ); /* Qx */
980 37825520 : Lacc = L_msu_sat( Lacc, AP1_STEEP_FX[1], temp2 ); /* Q16+Qx */
981 : #else
982 : Lacc1 = ( L_mac_o( Lacc1, AP1_STEEP_FX[1], temp1, &Overflow ) ); /* Q16+Qx */
983 :
984 : temp2 = extract_h( Lacc1 ); /* Qx */
985 : Lacc = L_msu_o( Lacc, AP1_STEEP_FX[1], temp2, &Overflow ); /* Q16+Qx */
986 : #endif
987 37825520 : mem[1] = extract_h( Lacc ); /* Qx */
988 37825520 : temp[1] = temp2;
989 37825520 : move16();
990 37825520 : move16();
991 :
992 :
993 37825520 : Lacc = L_deposit_h( mem[ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
994 : #ifdef ISSUE_1836_replace_overflow_libcom
995 37825520 : out_fx[k] = extract_h( L_mac_sat( Lacc, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2 ) ); /* Qx format */
996 37825520 : move16();
997 37825520 : mem[ALLPASSSECTIONS_STEEP - 1] = extract_h( L_msu_sat( Lacc1, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], out_fx[k] ) ); /* Qx */
998 37825520 : move16();
999 : #else
1000 : out_fx[k] = extract_h( L_mac_o( Lacc, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2, &Overflow ) ); /* Qx format */
1001 : move16();
1002 : mem[ALLPASSSECTIONS_STEEP - 1] = extract_h( L_msu_o( Lacc1, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], out_fx[k], &Overflow ) ); /* Qx */
1003 : move16();
1004 : #endif
1005 : }
1006 :
1007 : /* lower allpass filter chain */
1008 :
1009 126841 : Lacc = L_deposit_h( mem[ALLPASSSECTIONS_STEEP] ); /* Q(16+x) */
1010 : #ifdef ISSUE_1836_replace_overflow_libcom
1011 126841 : Lacc = L_mac_sat( Lacc, AP2_STEEP_FX[0], mem[2 * ALLPASSSECTIONS_STEEP] ); /* Q(16+x) */
1012 126841 : Lacc1 = L_deposit_h( mem[2 * ALLPASSSECTIONS_STEEP] ); /* Q(16+x) */
1013 126841 : temp1 = extract_h( Lacc ); /* Qx */
1014 126841 : Lacc1 = L_msu_sat( Lacc1, AP2_STEEP_FX[0], temp1 ); /* Q(16+x) */
1015 : #else
1016 : Lacc = L_mac_o( Lacc, AP2_STEEP_FX[0], mem[2 * ALLPASSSECTIONS_STEEP], &Overflow ); /*Q(16+x) */
1017 : Lacc1 = L_deposit_h( mem[2 * ALLPASSSECTIONS_STEEP] ); /* Q(16+x) */
1018 : temp1 = extract_h( Lacc ); /* Qx */
1019 : Lacc1 = L_msu_o( Lacc1, AP2_STEEP_FX[0], temp1, &Overflow ); /* Q(16+x) */
1020 : #endif
1021 126841 : mem[ALLPASSSECTIONS_STEEP] = extract_h( Lacc1 );
1022 126841 : temp[0] = temp1;
1023 126841 : move16();
1024 :
1025 126841 : Lacc1 = L_deposit_h( mem[ALLPASSSECTIONS_STEEP + 1] ); /* Q(16+x) */
1026 : #ifdef ISSUE_1836_replace_overflow_libcom
1027 126841 : Lacc1 = L_mac_sat( Lacc1, AP2_STEEP_FX[1], temp1 ); /* Q(16+x) */
1028 126841 : temp2 = extract_h( Lacc1 ); /* Qx */
1029 126841 : temp[1] = temp2;
1030 126841 : move16();
1031 126841 : Lacc = L_msu_sat( Lacc, AP2_STEEP_FX[1], temp2 ); /* Q(16+x) */
1032 : #else
1033 : Lacc1 = L_mac_o( Lacc1, AP2_STEEP_FX[1], temp1, &Overflow ); /* Q(16+x) */
1034 : temp2 = extract_h( Lacc1 ); /* Qx */
1035 : temp[1] = temp2;
1036 : move16();
1037 : Lacc = L_msu_o( Lacc, AP2_STEEP_FX[1], temp2, &Overflow ); /* Q(16+x) */
1038 : #endif
1039 126841 : mem[ALLPASSSECTIONS_STEEP + 1] = extract_h( Lacc ); /* Qx */
1040 126841 : move16();
1041 :
1042 126841 : Lacc = L_deposit_h( mem[2 * ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
1043 : #ifdef ISSUE_1836_replace_overflow_libcom
1044 126841 : Lacc = L_mac_sat( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2 ); /* Q(16+x) temp[ALLPASSSECTIONS_STEEP-1] */
1045 126841 : temp[2] = extract_h( Lacc ); /* temp[2] in Qx */
1046 126841 : move16();
1047 126841 : Lacc1 = L_msu_sat( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp[2] ); /* Q(16+x) */
1048 : #else
1049 : Lacc = L_mac_o( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2, &Overflow ); /* Q(16+x) temp[ALLPASSSECTIONS_STEEP-1] */
1050 : temp[2] = extract_h( Lacc ); /* temp[2] in Qx */
1051 : move16();
1052 : Lacc1 = L_msu_o( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp[2], &Overflow ); /* Q(16+x) */
1053 : #endif
1054 126841 : mem[2 * ALLPASSSECTIONS_STEEP - 1] = extract_h( Lacc1 ); /* Qx */
1055 126841 : move16();
1056 126841 : sum = mult_r( out_fx[0], 16384 ); /* Qx */
1057 126841 : out_fx[0] = add_sat( sum, mult_r( temp[ALLPASSSECTIONS_STEEP - 1], 16384 ) ); /* Qx */
1058 126841 : move16();
1059 :
1060 :
1061 37825520 : FOR( k = 1; k < N / 2; k++ )
1062 : {
1063 :
1064 :
1065 37698679 : Lacc = L_deposit_h( mem[ALLPASSSECTIONS_STEEP] ); /* Q(16+x) */
1066 : #ifdef ISSUE_1836_replace_overflow_libcom
1067 37698679 : Lacc = L_mac_sat( Lacc, AP2_STEEP_FX[0], in_fx[2 * k - 1] ); /* Q(16+x):temp[0] */
1068 37698679 : Lacc1 = L_deposit_h( in_fx[2 * k - 1] ); /* Q(16+x) */
1069 37698679 : temp1 = extract_h( Lacc ); /* Qx */
1070 37698679 : Lacc1 = L_msu_sat( Lacc1, AP2_STEEP_FX[0], temp1 ); /* Q(16+x) */
1071 : #else
1072 : Lacc = L_mac_o( Lacc, AP2_STEEP_FX[0], in_fx[2 * k - 1], &Overflow ); /* Q(16+x):temp[0] */
1073 : Lacc1 = L_deposit_h( in_fx[2 * k - 1] ); /* Q(16+x) */
1074 : temp1 = extract_h( Lacc ); /* Qx */
1075 : Lacc1 = L_msu_o( Lacc1, AP2_STEEP_FX[0], temp1, &Overflow ); /* Q(16+x) */
1076 : #endif
1077 :
1078 37698679 : mem[ALLPASSSECTIONS_STEEP] = extract_h( Lacc1 ); /* Qx */
1079 37698679 : move16();
1080 37698679 : temp[0] = temp1;
1081 37698679 : move16();
1082 :
1083 :
1084 37698679 : Lacc1 = L_deposit_h( mem[ALLPASSSECTIONS_STEEP + 1] ); /* Q(16+x) */
1085 : #ifdef ISSUE_1836_replace_overflow_libcom
1086 37698679 : Lacc1 = L_mac_sat( Lacc1, AP2_STEEP_FX[1], temp1 ); /* Q(16+x) */
1087 37698679 : temp2 = extract_h( Lacc1 ); /* Qx */
1088 37698679 : temp[1] = temp2;
1089 37698679 : move16();
1090 37698679 : Lacc = L_msu_sat( Lacc, AP2_STEEP_FX[1], temp2 ); /* Q(16+x) */
1091 37698679 : mem[ALLPASSSECTIONS_STEEP + 1] = extract_h( Lacc ); /* Qx */
1092 :
1093 :
1094 37698679 : Lacc = L_deposit_h( mem[2 * ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
1095 37698679 : Lacc = L_mac_sat( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp[1] ); /* Q(16+x) temp[ALLPASSSECTIONS_STEEP-1] */
1096 37698679 : temp[2] = extract_h( Lacc ); /*temp[2] in Qx */
1097 37698679 : Lacc1 = L_msu_sat( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp[2] ); /* Q(16+x) */
1098 : #else
1099 : Lacc1 = L_mac_o( Lacc1, AP2_STEEP_FX[1], temp1, &Overflow ); /* Q(16+x) */
1100 : temp2 = extract_h( Lacc1 ); /* Qx */
1101 : temp[1] = temp2;
1102 : move16();
1103 : Lacc = L_msu_o( Lacc, AP2_STEEP_FX[1], temp2, &Overflow ); /* Q(16+x) */
1104 : mem[ALLPASSSECTIONS_STEEP + 1] = extract_h( Lacc ); /* Qx */
1105 :
1106 :
1107 : Lacc = L_deposit_h( mem[2 * ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
1108 : Lacc = L_mac_o( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp[1], &Overflow ); /* Q(16+x) temp[ALLPASSSECTIONS_STEEP-1] */
1109 : temp[2] = extract_h( Lacc ); /*temp[2] in Qx */
1110 : Lacc1 = L_msu_o( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp[2], &Overflow ); /* Q(16+x) */
1111 : #endif
1112 37698679 : mem[2 * ALLPASSSECTIONS_STEEP - 1] = extract_h( Lacc1 ); /* Qx */
1113 :
1114 :
1115 37698679 : sum = mult_r( out_fx[k], 16384 ); /* Qx */
1116 37698679 : out_fx[k] = add_sat( sum, mult_r( temp[ALLPASSSECTIONS_STEEP - 1], 16384 ) );
1117 37698679 : move16();
1118 37698679 : move16(); /* Qx */
1119 : }
1120 :
1121 : /* z^(-1) */
1122 :
1123 126841 : mem[2 * ALLPASSSECTIONS_STEEP] = in_fx[N - 1];
1124 126841 : move16(); /* Qx */
1125 126841 : }
1126 :
1127 : /* IVAS 32-bit variant */
1128 4484 : void Decimate_allpass_steep_fx32(
1129 : const Word32 *in, /* i : input array of size N Qx */
1130 : Word32 *mem, /* i/o: memory Qx */
1131 : const Word16 N, /* i : number of input samples */
1132 : Word32 *out /* o : output array of size N/2 Qx */
1133 : )
1134 : {
1135 : Word16 n, k;
1136 : Word32 temp[ALLPASSSECTIONS_STEEP];
1137 :
1138 : /* upper allpass filter chain */
1139 1439364 : FOR( k = 0; k < N / 2; k++ )
1140 : {
1141 1434880 : temp[0] = Madd_32_16( mem[0], in[2 * k], AP1_STEEP_FX[0] ); // Qx
1142 1434880 : move32();
1143 1434880 : mem[0] = Msub_32_16( in[2 * k], temp[0], AP1_STEEP_FX[0] ); // Qx
1144 1434880 : move32();
1145 :
1146 1434880 : temp[1] = Madd_32_16( mem[1], temp[0], AP1_STEEP_FX[1] ); // Qx
1147 1434880 : move32();
1148 1434880 : mem[1] = Msub_32_16( temp[0], temp[1], AP1_STEEP_FX[1] ); // Qx
1149 1434880 : move32();
1150 :
1151 1434880 : out[k] = Madd_32_16( mem[ALLPASSSECTIONS_STEEP - 1], temp[ALLPASSSECTIONS_STEEP - 2], AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1152 1434880 : move32();
1153 1434880 : mem[ALLPASSSECTIONS_STEEP - 1] = Msub_32_16( temp[ALLPASSSECTIONS_STEEP - 2], out[k], AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1154 1434880 : move32();
1155 : }
1156 :
1157 : /* lower allpass filter chain */
1158 4484 : temp[0] = Madd_32_16( mem[ALLPASSSECTIONS_STEEP], mem[2 * ALLPASSSECTIONS_STEEP], AP2_STEEP_FX[0] ); // Qx
1159 4484 : move32();
1160 4484 : mem[ALLPASSSECTIONS_STEEP] = Msub_32_16( mem[2 * ALLPASSSECTIONS_STEEP], temp[0], AP2_STEEP_FX[0] ); // Qx
1161 4484 : move32();
1162 :
1163 : /* for better performance, unroll this loop */
1164 8968 : FOR( n = 1; n < ALLPASSSECTIONS_STEEP - 1; n++ )
1165 : {
1166 4484 : temp[n] = Madd_32_16( mem[ALLPASSSECTIONS_STEEP + n], temp[n - 1], AP2_STEEP_FX[n] ); // Qx
1167 4484 : move32();
1168 4484 : mem[ALLPASSSECTIONS_STEEP + 1] = Msub_32_16( temp[n - 1], temp[n], AP2_STEEP_FX[n] ); // Qx
1169 4484 : move32();
1170 : }
1171 :
1172 4484 : temp[ALLPASSSECTIONS_STEEP - 1] = Madd_32_16( mem[2 * ALLPASSSECTIONS_STEEP - 1], temp[ALLPASSSECTIONS_STEEP - 2], AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1173 4484 : move32();
1174 :
1175 4484 : mem[2 * ALLPASSSECTIONS_STEEP - 1] = Msub_32_16( temp[ALLPASSSECTIONS_STEEP - 2], temp[ALLPASSSECTIONS_STEEP - 1], AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1176 4484 : move32();
1177 4484 : out[0] = W_round48_L( W_mac_32_16( W_mult_32_16( out[0], 16384 /*0.5 in Q15*/ ), temp[ALLPASSSECTIONS_STEEP - 1], 16384 /*0.5 in Q15*/ ) ); // Qx
1178 4484 : move32();
1179 :
1180 1434880 : FOR( k = 1; k < N / 2; k++ )
1181 : {
1182 1430396 : temp[0] = Madd_32_16( mem[ALLPASSSECTIONS_STEEP], in[2 * k - 1], AP2_STEEP_FX[0] ); // Qx
1183 1430396 : move32();
1184 1430396 : mem[ALLPASSSECTIONS_STEEP] = Msub_32_16( in[2 * k - 1], temp[0], AP2_STEEP_FX[0] ); // Qx
1185 1430396 : move32();
1186 :
1187 : /* for better performance, unroll this loop */
1188 2860792 : FOR( n = 1; n < ALLPASSSECTIONS_STEEP - 1; n++ )
1189 : {
1190 1430396 : temp[n] = Madd_32_16( mem[ALLPASSSECTIONS_STEEP + n], temp[n - 1], AP2_STEEP_FX[n] ); // Qx
1191 1430396 : move32();
1192 1430396 : mem[ALLPASSSECTIONS_STEEP + n] = Msub_32_16( temp[n - 1], temp[n], AP2_STEEP_FX[n] ); // Qx
1193 1430396 : move32();
1194 : }
1195 :
1196 1430396 : temp[ALLPASSSECTIONS_STEEP - 1] = Madd_32_16( mem[2 * ALLPASSSECTIONS_STEEP - 1], temp[ALLPASSSECTIONS_STEEP - 2], AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1197 1430396 : move32();
1198 1430396 : mem[2 * ALLPASSSECTIONS_STEEP - 1] = Msub_32_16( temp[ALLPASSSECTIONS_STEEP - 2], temp[ALLPASSSECTIONS_STEEP - 1], AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1199 1430396 : move32();
1200 1430396 : out[k] = W_round48_L( W_mac_32_16( W_mult_32_16( out[k], 16384 /*0.5 in Q15*/ ), temp[ALLPASSSECTIONS_STEEP - 1], 16384 /*0.5 in Q15*/ ) ); // Qx
1201 1430396 : move32();
1202 : }
1203 :
1204 : /* z^(-1) */
1205 4484 : mem[2 * ALLPASSSECTIONS_STEEP] = in[N - 1];
1206 4484 : move32();
1207 :
1208 4484 : return;
1209 : }
1210 :
1211 :
1212 : /*-------------------------------------------------------------------*
1213 : * Interpolate_allpass_steep()
1214 : *
1215 : * Interpolation by a factor 2
1216 : *-------------------------------------------------------------------*/
1217 :
1218 23673 : void Interpolate_allpass_steep_fx(
1219 : const Word16 *in_fx,
1220 : Word16 mem[], /* array of size: 2*ALLPASSSECTIONS_STEEP+1 */
1221 : Word16 N, /* number of input samples */
1222 : Word16 out_fx[] ) /* array of size 2*N */
1223 : {
1224 :
1225 : Word16 k;
1226 23673 : Word32 Lacc = 0, Lacc1 = 0;
1227 : Word16 temp1, temp2;
1228 : #ifndef ISSUE_1836_replace_overflow_libcom
1229 : #ifdef BASOP_NOGLOB_DECLARE_LOCAL
1230 : Flag Overflow = 0;
1231 : move32();
1232 : #endif
1233 : #endif
1234 : /*** State in Q0,in_fx Q0, AP1_STEEP in Q15 AP2_STEEP in Q15 OP in Q0 ************/
1235 : /*upper allpass filter chain */
1236 :
1237 3343713 : FOR( k = 0; k < N; k++ )
1238 : {
1239 :
1240 3320040 : Lacc = L_deposit_h( mem[0] ); /* Q(16+x) */
1241 : #ifdef ISSUE_1836_replace_overflow_libcom
1242 3320040 : Lacc = L_mac_sat( Lacc, AP2_STEEP_FX[0], in_fx[k] ); /* Q(16+x):temp[0] */
1243 3320040 : Lacc1 = L_deposit_h( in_fx[k] ); /* Q(16+x) */
1244 3320040 : temp1 = round_fx_sat( Lacc ); /* Qx */
1245 3320040 : Lacc1 = L_msu_sat( Lacc1, AP2_STEEP_FX[0], temp1 ); /* Q(16+x) */
1246 :
1247 3320040 : mem[0] = round_fx_sat( Lacc1 );
1248 3320040 : move16();
1249 3320040 : Lacc1 = L_deposit_h( mem[1] ); /* Q(16+x) */
1250 3320040 : Lacc1 = ( L_mac_sat( Lacc1, AP2_STEEP_FX[1], temp1 ) ); /* Q(16+x):temp[1] */
1251 3320040 : Lacc = L_deposit_h( temp1 );
1252 :
1253 3320040 : temp2 = round_fx_sat( Lacc1 ); /* Qx */
1254 3320040 : Lacc = L_msu_sat( Lacc, AP2_STEEP_FX[1], temp2 ); /* Q(16+x) */
1255 3320040 : mem[1] = round_fx_sat( Lacc ); /* Qx */
1256 3320040 : move16();
1257 :
1258 3320040 : Lacc1 = L_deposit_h( temp2 );
1259 3320040 : Lacc = L_deposit_h( mem[ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
1260 3320040 : out_fx[2 * k + 1] = round_fx_sat( L_mac_sat( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2 ) ); /* Qx format */
1261 3320040 : move16();
1262 3320040 : mem[ALLPASSSECTIONS_STEEP - 1] = round_fx_sat( L_msu_sat( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], out_fx[2 * k + 1] ) ); /* Qx */
1263 3320040 : move16();
1264 : #else
1265 : Lacc1 = L_deposit_h( in_fx[k] ); /* Q(16+x) */
1266 : temp1 = round_fx_o( Lacc, &Overflow ); /* Qx */
1267 : Lacc1 = L_msu_o( Lacc1, AP2_STEEP_FX[0], temp1, &Overflow ); /* Q(16+x) */
1268 :
1269 : mem[0] = round_fx_o( Lacc1, &Overflow );
1270 : move16();
1271 : Lacc1 = L_deposit_h( mem[1] ); /* Q(16+x) */
1272 : Lacc1 = ( L_mac_o( Lacc1, AP2_STEEP_FX[1], temp1, &Overflow ) ); /* Q(16+x):temp[1] */
1273 : Lacc = L_deposit_h( temp1 );
1274 :
1275 : temp2 = round_fx_o( Lacc1, &Overflow ); /* Qx */
1276 : Lacc = L_msu_o( Lacc, AP2_STEEP_FX[1], temp2, &Overflow ); /* Q(16+x) */
1277 : mem[1] = round_fx_o( Lacc, &Overflow ); /* Qx */
1278 : move16();
1279 :
1280 : Lacc1 = L_deposit_h( temp2 );
1281 : Lacc = L_deposit_h( mem[ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
1282 : out_fx[2 * k + 1] = round_fx_o( L_mac_o( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2, &Overflow ), &Overflow ); /* Qx format */
1283 : move16();
1284 : mem[ALLPASSSECTIONS_STEEP - 1] = round_fx_o( L_msu_o( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], out_fx[2 * k + 1], &Overflow ), &Overflow ); /* Qx */
1285 : move16();
1286 : #endif
1287 : }
1288 :
1289 : /* lower allpass filter chain */
1290 :
1291 3343713 : FOR( k = 0; k < N; k++ )
1292 : {
1293 3320040 : Lacc = L_deposit_h( mem[ALLPASSSECTIONS_STEEP] ); /* Q(16+x) */
1294 : #ifdef ISSUE_1836_replace_overflow_libcom
1295 3320040 : Lacc = L_mac_sat( Lacc, AP1_STEEP_FX[0], in_fx[k] ); /* Q(16+x):temp[0] */
1296 3320040 : Lacc1 = L_deposit_h( in_fx[k] ); /* Q(16+x) */
1297 3320040 : temp1 = round_fx_sat( Lacc ); /* Qx */
1298 3320040 : Lacc1 = L_msu_sat( Lacc1, AP1_STEEP_FX[0], temp1 ); /* Q(16+x) */
1299 :
1300 3320040 : mem[ALLPASSSECTIONS_STEEP] = round_fx_sat( Lacc1 );
1301 3320040 : Lacc1 = L_deposit_h( mem[ALLPASSSECTIONS_STEEP + 1] ); /* Q(16+x) */
1302 3320040 : Lacc1 = L_mac_sat( Lacc1, AP1_STEEP_FX[1], temp1 ); /* Q(16+x):temp[1] */
1303 :
1304 3320040 : temp2 = round_fx_sat( Lacc1 ); /* Qx */
1305 3320040 : Lacc = L_deposit_h( temp1 );
1306 3320040 : Lacc = L_msu_sat( Lacc, AP1_STEEP_FX[1], temp2 ); /* Q(16+x) */
1307 3320040 : mem[ALLPASSSECTIONS_STEEP + 1] = round_fx_sat( Lacc ); /* Qx */
1308 :
1309 3320040 : Lacc = L_deposit_h( mem[2 * ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
1310 3320040 : Lacc1 = L_deposit_h( temp2 );
1311 3320040 : out_fx[2 * k] = round_fx_sat( L_mac_sat( Lacc, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2 ) ); /* Qx format */
1312 3320040 : move16();
1313 3320040 : mem[2 * ALLPASSSECTIONS_STEEP - 1] = round_fx_sat( L_msu_sat( Lacc1, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], out_fx[2 * k] ) ); /* Qx */
1314 3320040 : move16();
1315 : #else
1316 : Lacc = L_mac_o( Lacc, AP1_STEEP_FX[0], in_fx[k], &Overflow ); /* Q(16+x):temp[0] */
1317 : Lacc1 = L_deposit_h( in_fx[k] ); /* Q(16+x) */
1318 : temp1 = round_fx_o( Lacc, &Overflow ); /* Qx */
1319 : Lacc1 = L_msu_o( Lacc1, AP1_STEEP_FX[0], temp1, &Overflow ); /* Q(16+x) */
1320 :
1321 : mem[ALLPASSSECTIONS_STEEP] = round_fx_o( Lacc1, &Overflow );
1322 : Lacc1 = L_deposit_h( mem[ALLPASSSECTIONS_STEEP + 1] ); /* Q(16+x) */
1323 : Lacc1 = L_mac_o( Lacc1, AP1_STEEP_FX[1], temp1, &Overflow ); /* Q(16+x):temp[1] */
1324 :
1325 : temp2 = round_fx_o( Lacc1, &Overflow ); /* Qx */
1326 : Lacc = L_deposit_h( temp1 );
1327 : Lacc = L_msu_o( Lacc, AP1_STEEP_FX[1], temp2, &Overflow ); /* Q(16+x) */
1328 : mem[ALLPASSSECTIONS_STEEP + 1] = round_fx_o( Lacc, &Overflow ); /* Qx */
1329 :
1330 : Lacc = L_deposit_h( mem[2 * ALLPASSSECTIONS_STEEP - 1] ); /* Q(16+x) */
1331 : Lacc1 = L_deposit_h( temp2 );
1332 : out_fx[2 * k] = round_fx_o( L_mac_o( Lacc, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], temp2, &Overflow ), &Overflow ); /* Qx format */
1333 : move16();
1334 : mem[2 * ALLPASSSECTIONS_STEEP - 1] = round_fx_o( L_msu_o( Lacc1, AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1], out_fx[2 * k], &Overflow ), &Overflow ); /* Qx */
1335 : move16();
1336 : #endif
1337 : }
1338 :
1339 23673 : return;
1340 : }
1341 :
1342 : /* IVAS 32-bit variant */
1343 119730 : void Interpolate_allpass_steep_fx32(
1344 : const Word32 *in_fx, /* i : input array of size N Qx */
1345 : Word32 *mem_fx, /* i/o: memory Qx */
1346 : const Word16 N, /* i : number of input samples */
1347 : Word32 *out_fx /* o : output array of size 2*N Qx */
1348 : )
1349 : {
1350 : Word16 n, k;
1351 : Word32 temp_fx[ALLPASSSECTIONS_STEEP - 1];
1352 :
1353 : /* upper allpass filter chain */
1354 36566140 : FOR( k = 0; k < N; k++ )
1355 : {
1356 36446410 : temp_fx[0] = Madd_32_16( mem_fx[0], in_fx[k], AP2_STEEP_FX[0] ); // Qx
1357 36446410 : move32();
1358 36446410 : mem_fx[0] = Msub_32_16( in_fx[k], temp_fx[0], AP2_STEEP_FX[0] ); // Qx
1359 36446410 : move32();
1360 :
1361 : /* for better performance, unroll this loop */
1362 72892820 : FOR( n = 1; n < ALLPASSSECTIONS_STEEP - 1; n++ )
1363 : {
1364 36446410 : temp_fx[n] = Madd_32_16( mem_fx[n], temp_fx[n - 1], AP2_STEEP_FX[n] ); // Qx
1365 36446410 : move32();
1366 36446410 : mem_fx[n] = Msub_32_16( temp_fx[n - 1], temp_fx[n], AP2_STEEP_FX[n] ); // Qx
1367 36446410 : move32();
1368 : }
1369 :
1370 36446410 : out_fx[2 * k + 1] = Madd_32_16( mem_fx[ALLPASSSECTIONS_STEEP - 1], temp_fx[ALLPASSSECTIONS_STEEP - 2], AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1371 36446410 : move32();
1372 36446410 : mem_fx[ALLPASSSECTIONS_STEEP - 1] = Msub_32_16( temp_fx[ALLPASSSECTIONS_STEEP - 2], out_fx[2 * k + 1], AP2_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1373 36446410 : move32();
1374 : }
1375 :
1376 : /* lower allpass filter chain */
1377 36566140 : FOR( k = 0; k < N; k++ )
1378 : {
1379 36446410 : temp_fx[0] = Madd_32_16( mem_fx[ALLPASSSECTIONS_STEEP], in_fx[k], AP1_STEEP_FX[0] ); // Qx
1380 36446410 : move32();
1381 36446410 : mem_fx[ALLPASSSECTIONS_STEEP] = Msub_32_16( in_fx[k], temp_fx[0], AP1_STEEP_FX[0] ); // Qx
1382 36446410 : move32();
1383 :
1384 : /* for better performance, unroll this loop */
1385 72892820 : FOR( n = 1; n < ALLPASSSECTIONS_STEEP - 1; n++ )
1386 : {
1387 36446410 : temp_fx[n] = Madd_32_16( mem_fx[ALLPASSSECTIONS_STEEP + n], temp_fx[n - 1], AP1_STEEP_FX[n] ); // Qx
1388 36446410 : move32();
1389 36446410 : mem_fx[ALLPASSSECTIONS_STEEP + n] = Msub_32_16( temp_fx[n - 1], temp_fx[n], AP1_STEEP_FX[n] ); // Qx
1390 36446410 : move32();
1391 : }
1392 :
1393 36446410 : out_fx[2 * k] = Madd_32_16( mem_fx[2 * ALLPASSSECTIONS_STEEP - 1], temp_fx[ALLPASSSECTIONS_STEEP - 2], AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1394 36446410 : move32();
1395 36446410 : mem_fx[2 * ALLPASSSECTIONS_STEEP - 1] = Msub_32_16( temp_fx[ALLPASSSECTIONS_STEEP - 2], out_fx[2 * k], AP1_STEEP_FX[ALLPASSSECTIONS_STEEP - 1] ); // Qx
1396 36446410 : move32();
1397 : }
1398 :
1399 119730 : return;
1400 : }
1401 :
1402 :
1403 : /*-------------------------------------------------------------------*
1404 : * interpolate_3_over_2_allpass_fx()
1405 : *
1406 : * Interpolate 3/2 using allpass iir polyphase filter. Delay 4 samples @48k
1407 : *-------------------------------------------------------------------*/
1408 :
1409 1596 : void interpolate_3_over_2_allpass_fx(
1410 : const Word16 *input_fx,
1411 : /* i : input signal */ /* Q_input */
1412 : const Word16 len, /* i : number of input samples */
1413 : Word16 *out_fx,
1414 : /* o : output signal */ /* Q_input */
1415 : Word16 *mem_fx,
1416 : /* i/o: memory */ /* Q_input */
1417 : const Word16 *filt_coeff_fx /* i : filter coefficients */ /* Q15*/
1418 : )
1419 : {
1420 : /* mem of current frame would be stored in Qinput, so the next call to this function shoulf have Q_mem parameter set to prev_Q_input */
1421 : Word16 i, loop_len;
1422 : Word16 input_fx_temp[L_FRAME32k]; /* Limiting length of input signal to a max of L_FRAME32k samples */
1423 : Word16 Vu[2], Vm[2], Vl[2]; /* Outputs of three cascaded allpass stages (upper, middle, and lower) */ /* will be in Q_current */
1424 : Word16 out1_buff[L_FRAME48k * 2];
1425 : Word16 *out1;
1426 : Word16 mem_temp;
1427 :
1428 : Word16 s;
1429 :
1430 1596 : s = 0;
1431 1596 : move16();
1432 1013840 : FOR( i = 0; i < len; i++ )
1433 : {
1434 1012244 : s = s_max( s, abs_s( input_fx[i] ) );
1435 : }
1436 25536 : FOR( i = 0; i < INTERP_3_2_MEM_LEN; i++ )
1437 : {
1438 23940 : s = s_max( s, abs_s( mem_fx[i] ) );
1439 : }
1440 1596 : s = s_max( sub( norm_s( s ), 2 ), 0 );
1441 1596 : Copy_Scale_sig( input_fx, input_fx_temp, len, s );
1442 1596 : Scale_sig( mem_fx, INTERP_3_2_MEM_LEN, s );
1443 1596 : out1 = out1_buff;
1444 :
1445 1013840 : FOR( i = 0; i < len; i++ )
1446 : {
1447 : /* Upper branch */
1448 : /*Vu[0] = mem[0] + filt_coeff[0] * ( input_fx_temp[i] - mem[1] );
1449 : Vu[1] = mem[1] + filt_coeff[1] * ( Vu[0] - mem[2] );
1450 : mem[3] = mem[2] + filt_coeff[2] * ( Vu[1] - mem[3] );*/
1451 :
1452 1012244 : Vu[0] = add_sat( mem_fx[0], mult_r_sat( filt_coeff_fx[0], sub_sat( input_fx_temp[i], mem_fx[1] ) ) );
1453 1012244 : move16(); /* all Vu's in : Q_current*/
1454 1012244 : Vu[1] = add_sat( mem_fx[1], mult_r_sat( filt_coeff_fx[1], sub_sat( Vu[0], mem_fx[2] ) ) );
1455 1012244 : move16();
1456 1012244 : mem_fx[3] = add_sat( mem_fx[2], mult_r_sat( filt_coeff_fx[2], sub_sat( Vu[1], mem_fx[3] ) ) );
1457 1012244 : move16();
1458 :
1459 :
1460 1012244 : mem_fx[1] = Vu[0];
1461 1012244 : move16();
1462 1012244 : mem_fx[2] = Vu[1];
1463 1012244 : move16();
1464 1012244 : *out1++ = mem_fx[3];
1465 1012244 : move16();
1466 :
1467 : /* Middle branch */
1468 : /* Vm[0] = mem[0] + filt_coeff[3] * (input[i]-mem[4]);
1469 : Vm[1] = mem[4] + filt_coeff[4] * (Vm[0]-mem[5]);
1470 : mem[6] = mem[5] + filt_coeff[5] * (Vm[1]-mem[6]); */
1471 1012244 : Vm[0] = add_sat( mem_fx[0], mult_r_sat( filt_coeff_fx[3], sub_sat( input_fx_temp[i], mem_fx[4] ) ) );
1472 1012244 : move16();
1473 1012244 : Vm[1] = add_sat( mem_fx[4], mult_r_sat( filt_coeff_fx[4], sub_sat( Vm[0], mem_fx[5] ) ) );
1474 1012244 : move16();
1475 1012244 : mem_fx[6] = add_sat( mem_fx[5], mult_r_sat( filt_coeff_fx[5], sub_sat( Vm[1], mem_fx[6] ) ) );
1476 1012244 : move16();
1477 1012244 : mem_fx[4] = Vm[0];
1478 1012244 : move16();
1479 1012244 : mem_fx[5] = Vm[1];
1480 1012244 : move16();
1481 1012244 : *out1++ = mem_fx[6];
1482 1012244 : move16();
1483 :
1484 : /* Lower branch */
1485 : /* Vl[0] = mem[0] + filt_coeff[6] * (input[i]-mem[7]);
1486 : Vl[1] = mem[7] + filt_coeff[7] * (Vl[0]-mem[8]);
1487 : mem[9] = mem[8] + filt_coeff[8] * (Vl[1]-mem[9]); */
1488 1012244 : Vl[0] = add_sat( mem_fx[0], mult_r_sat( filt_coeff_fx[6], sub_sat( input_fx_temp[i], mem_fx[7] ) ) );
1489 1012244 : move16();
1490 1012244 : Vl[1] = add_sat( mem_fx[7], mult_r_sat( filt_coeff_fx[7], sub_sat( Vl[0], mem_fx[8] ) ) );
1491 1012244 : move16();
1492 1012244 : mem_fx[9] = add_sat( mem_fx[8], mult_r_sat( filt_coeff_fx[8], sub_sat( Vl[1], mem_fx[9] ) ) );
1493 1012244 : move16();
1494 1012244 : mem_fx[0] = input_fx_temp[i];
1495 1012244 : move16();
1496 1012244 : mem_fx[7] = Vl[0];
1497 1012244 : move16();
1498 1012244 : mem_fx[8] = Vl[1];
1499 1012244 : move16();
1500 1012244 : *out1++ = mem_fx[9];
1501 1012244 : move16();
1502 : }
1503 :
1504 : /* loop_len = len*3/2 */
1505 1596 : loop_len = shr( i_mult( len, 3 ), 1 );
1506 :
1507 : /*decimate by 2 and LPF*/
1508 1519962 : FOR( i = 0; i < loop_len; i++ )
1509 : {
1510 1518366 : mem_temp = out1_buff[shl( i, 1 )];
1511 1518366 : move16();
1512 1518366 : out_fx[i] = add_sat( mult_r_sat( 1550 /* 0.0473147f Q15*/, add_sat( mem_temp, mem_fx[10] ) ), mult_r_sat( -4965 /*-0.151521f Q15*/, add_sat( mem_fx[11], mem_fx[14] ) ) );
1513 1518366 : out_fx[i] = add_sat( out_fx[i], mult_r_sat( 20125 /*0.614152f Q15*/, add_sat( mem_fx[12], mem_fx[13] ) ) );
1514 1518366 : mem_fx[10] = mem_fx[11];
1515 1518366 : move16();
1516 1518366 : mem_fx[11] = mem_fx[12];
1517 1518366 : move16();
1518 1518366 : mem_fx[12] = mem_fx[13];
1519 1518366 : move16();
1520 1518366 : mem_fx[13] = mem_fx[14];
1521 1518366 : move16();
1522 1518366 : mem_fx[14] = mem_temp;
1523 1518366 : move16();
1524 : }
1525 1596 : Scale_sig( out_fx, i_mult( 3, shr( len, 1 ) ), -s );
1526 1596 : Scale_sig( mem_fx, INTERP_3_2_MEM_LEN, -s );
1527 1596 : return;
1528 : }
1529 :
1530 : /* IVAS 32-bit variant */
1531 82520 : void interpolate_3_over_2_allpass_fx32(
1532 : const Word32 *input, /* i : input signal Qx*/
1533 : const Word16 len, /* i : number of input samples */
1534 : Word32 *out, /* o : output signal Qx*/
1535 : Word32 *mem /* i/o: memory Qx*/
1536 : )
1537 : {
1538 : Word16 i, loop_len;
1539 : Word32 Vu[2], Vm[2], Vl[2]; /* Outputs of three cascaded allpass stages (upper, middle, and lower) */
1540 : Word32 out1_buff[L_FRAME32k * 3];
1541 : Word32 *out1;
1542 : Word32 mem_temp;
1543 82520 : const Word16 *filt_coeff = allpass_poles_3_ov_2; // Q15
1544 :
1545 82520 : out1 = out1_buff;
1546 :
1547 51051104 : FOR( i = 0; i < len; i++ )
1548 : {
1549 : /* Upper branch */
1550 50968584 : Vu[0] = Madd_32_16( mem[0], L_sub( input[i], mem[1] ), filt_coeff[0] ); // Qx + Q15 - Q15 -> Qx
1551 50968584 : move32();
1552 50968584 : Vu[1] = Madd_32_16( mem[1], L_sub( Vu[0], mem[2] ), filt_coeff[1] ); // Qx + Q15 - Q15 -> Qx
1553 50968584 : move32();
1554 50968584 : mem[3] = Madd_32_16( mem[2], L_sub( Vu[1], mem[3] ), filt_coeff[2] ); // Qx + Q15 - Q15 -> Qx
1555 50968584 : move32();
1556 :
1557 50968584 : mem[1] = Vu[0]; // Qx
1558 50968584 : move32();
1559 50968584 : mem[2] = Vu[1]; // Qx
1560 50968584 : move32();
1561 50968584 : *out1++ = mem[3]; // Qx
1562 50968584 : move32();
1563 :
1564 : /* Middle branch */
1565 50968584 : Vm[0] = Madd_32_16( mem[0], L_sub( input[i], mem[4] ), filt_coeff[3] ); // Qx + Q15 - Q15 -> Qx
1566 50968584 : move32();
1567 50968584 : Vm[1] = Madd_32_16( mem[4], L_sub( Vm[0], mem[5] ), filt_coeff[4] ); // Qx + Q15 - Q15 -> Qx
1568 50968584 : move32();
1569 50968584 : mem[6] = Madd_32_16( mem[5], L_sub( Vm[1], mem[6] ), filt_coeff[5] ); // Qx + Q15 - Q15 -> Qx
1570 50968584 : move32();
1571 :
1572 50968584 : mem[4] = Vm[0]; // Qx
1573 50968584 : move32();
1574 50968584 : mem[5] = Vm[1]; // Qx
1575 50968584 : move32();
1576 50968584 : *out1++ = mem[6]; // Qx
1577 50968584 : move32();
1578 :
1579 : /* Lower branch */
1580 50968584 : Vl[0] = Madd_32_16( mem[0], L_sub( input[i], mem[7] ), filt_coeff[6] ); // Qx + Q15 - Q15 -> Qx
1581 50968584 : move32();
1582 50968584 : Vl[1] = Madd_32_16( mem[7], L_sub( Vl[0], mem[8] ), filt_coeff[7] ); // Qx + Q15 - Q15 -> Qx
1583 50968584 : move32();
1584 50968584 : mem[9] = Madd_32_16( mem[8], L_sub( Vl[1], mem[9] ), filt_coeff[8] ); // Qx + Q15 - Q15 -> Qx
1585 50968584 : move32();
1586 :
1587 50968584 : mem[0] = input[i]; // Qx
1588 50968584 : move32();
1589 50968584 : mem[7] = Vl[0]; // Qx
1590 50968584 : move32();
1591 50968584 : mem[8] = Vl[1]; // Qx
1592 50968584 : move32();
1593 50968584 : *out1++ = mem[9]; // Qx
1594 50968584 : move32();
1595 : }
1596 :
1597 82520 : loop_len = shr( i_mult( len, 3 ), 1 );
1598 :
1599 : /*decimate by 2 and LPF*/
1600 76535396 : FOR( i = 0; i < loop_len; i++ )
1601 : {
1602 76452876 : mem_temp = out1_buff[2 * i];
1603 76452876 : move32();
1604 76452876 : out[i] = Madd_32_16( Mpy_32_16_1( L_add( mem_temp, mem[10] ), 1550 ), L_add( mem[11], mem[14] ), -4965 ); // Qx + Q15 - Q15 -> Qx
1605 : // 0.0473147f in Q15 -> 1550, -0.151521f in Q15 -> -4965
1606 76452876 : out[i] = Madd_32_16( out[i], L_add( mem[12], mem[13] ), 20125 );
1607 : // 0.614152f in Q15 -> 20125
1608 76452876 : mem[10] = mem[11]; // Qx
1609 76452876 : move32();
1610 76452876 : mem[11] = mem[12]; // Qx
1611 76452876 : move32();
1612 76452876 : mem[12] = mem[13]; // Qx
1613 76452876 : move32();
1614 76452876 : mem[13] = mem[14]; // Qx
1615 76452876 : move32();
1616 76452876 : mem[14] = mem_temp; // Qx
1617 76452876 : move32();
1618 : }
1619 :
1620 82520 : return;
1621 : }
1622 :
1623 :
1624 : /*-------------------------------------------------------------------*
1625 : * interpolate_3_over_1_allpass_fx()
1626 : *
1627 : * Interpolate 3/1 using allpass iir polyphase filter. Delay 4 samples @48k
1628 : *-------------------------------------------------------------------*/
1629 :
1630 0 : void ivas_interpolate_3_over_1_allpass_fx(
1631 : const Word16 *input_fx,
1632 : /* i : input signal */ /* Q_input */
1633 : const Word16 len, /* i : number of input samples */
1634 : Word16 *out_fx,
1635 : /* o : output signal */ /* Q_input */
1636 : Word16 *mem_fx /* i/o: memory */ /* Q_input */
1637 : )
1638 : {
1639 : /* mem of current frame would be stored in Qinput, so the next call to this function shoulf have Q_mem parameter set to prev_Q_input */
1640 : Word16 i;
1641 : Word16 Vu[2], Vm[2], Vl[2]; /* Outputs of three cascaded allpass stages (upper, middle, and lower) */
1642 : Word16 *out1;
1643 : Word16 mem_temp;
1644 0 : const Word16 *filt_coeff_fx = allpass_poles_3_ov_2;
1645 :
1646 0 : out1 = &out_fx[0];
1647 :
1648 0 : FOR( i = 0; i < len; i++ )
1649 : {
1650 : /* Upper branch */
1651 : /*Vu[0] = mem[0] + filt_coeff[0] * ( input_fx_temp[i] - mem[1] );
1652 : Vu[1] = mem[1] + filt_coeff[1] * ( Vu[0] - mem[2] );
1653 : mem[3] = mem[2] + filt_coeff[2] * ( Vu[1] - mem[3] );*/
1654 :
1655 0 : Vu[0] = add_sat( mem_fx[0], mult_r( filt_coeff_fx[0], sub_sat( input_fx[i], mem_fx[1] ) ) );
1656 0 : move16(); /* all Vu's in : Q_current*/
1657 0 : Vu[1] = add_sat( mem_fx[1], mult_r( filt_coeff_fx[1], sub_sat( Vu[0], mem_fx[2] ) ) );
1658 0 : move16();
1659 0 : mem_fx[3] = add_sat( mem_fx[2], mult_r( filt_coeff_fx[2], sub_sat( Vu[1], mem_fx[3] ) ) );
1660 0 : move16();
1661 :
1662 :
1663 0 : mem_fx[1] = Vu[0];
1664 0 : move16();
1665 0 : mem_fx[2] = Vu[1];
1666 0 : move16();
1667 0 : *out1++ = mem_fx[3];
1668 0 : move16();
1669 :
1670 : /* Middle branch */
1671 : /* Vm[0] = mem[0] + filt_coeff[3] * (input[i]-mem[4]);
1672 : Vm[1] = mem[4] + filt_coeff[4] * (Vm[0]-mem[5]);
1673 : mem[6] = mem[5] + filt_coeff[5] * (Vm[1]-mem[6]); */
1674 0 : Vm[0] = add_sat( mem_fx[0], mult_r( filt_coeff_fx[3], sub_sat( input_fx[i], mem_fx[4] ) ) );
1675 0 : move16();
1676 0 : Vm[1] = add_sat( mem_fx[4], mult_r( filt_coeff_fx[4], sub_sat( Vm[0], mem_fx[5] ) ) );
1677 0 : move16();
1678 0 : mem_fx[6] = add_sat( mem_fx[5], mult_r( filt_coeff_fx[5], sub_sat( Vm[1], mem_fx[6] ) ) );
1679 0 : move16();
1680 :
1681 0 : mem_fx[4] = Vm[0];
1682 0 : move16();
1683 0 : mem_fx[5] = Vm[1];
1684 0 : move16();
1685 0 : *out1++ = mem_fx[6];
1686 0 : move16();
1687 :
1688 : /* Lower branch */
1689 : /* Vl[0] = mem[0] + filt_coeff[6] * (input[i]-mem[7]);
1690 : Vl[1] = mem[7] + filt_coeff[7] * (Vl[0]-mem[8]);
1691 : mem[9] = mem[8] + filt_coeff[8] * (Vl[1]-mem[9]); */
1692 0 : Vl[0] = add_sat( mem_fx[0], mult_r( filt_coeff_fx[6], sub_sat( input_fx[i], mem_fx[7] ) ) );
1693 0 : move16();
1694 0 : Vl[1] = add_sat( mem_fx[7], mult_r( filt_coeff_fx[7], sub_sat( Vl[0], mem_fx[8] ) ) );
1695 0 : move16();
1696 0 : mem_fx[9] = add_sat( mem_fx[8], mult_r( filt_coeff_fx[8], sub_sat( Vl[1], mem_fx[9] ) ) );
1697 0 : move16();
1698 :
1699 0 : mem_fx[0] = input_fx[i];
1700 0 : move16();
1701 0 : mem_fx[7] = Vl[0];
1702 0 : move16();
1703 0 : mem_fx[8] = Vl[1];
1704 0 : move16();
1705 0 : *out1++ = mem_fx[9];
1706 0 : move16();
1707 : }
1708 : /*LPF*/
1709 0 : FOR( i = 0; i < len * 3; i++ )
1710 : {
1711 0 : mem_temp = out_fx[i];
1712 0 : move16();
1713 0 : out_fx[i] = sub_sat( mult_r( 18768 /*0.57276865021499168f Q15*/, add_sat( mem_fx[12], mem_fx[11] ) ), mult_r( 2425 /*0.074004974641176793f Q15*/, add_sat( mem_temp, mem_fx[10] ) ) );
1714 0 : mem_fx[10] = mem_fx[11];
1715 0 : move16();
1716 0 : mem_fx[11] = mem_fx[12];
1717 0 : move16();
1718 0 : mem_fx[12] = mem_temp;
1719 0 : move16();
1720 : }
1721 0 : return;
1722 : }
1723 :
1724 50004 : void interpolate_3_over_1_allpass_fx(
1725 : const Word16 *input_fx,
1726 : /* i : input signal */ /* Q_input */
1727 : const Word16 len, /* i : number of input samples */
1728 : Word16 *out_fx,
1729 : /* o : output signal */ /* Q_input */
1730 : Word16 *mem_fx /* i/o: memory */ /* Q_input */
1731 : )
1732 : {
1733 : /* mem of current frame would be stored in Qinput, so the next call to this function shoulf have Q_mem parameter set to prev_Q_input */
1734 : Word16 i;
1735 : Word16 Vu[2], Vm[2], Vl[2]; /* Outputs of three cascaded allpass stages (upper, middle, and lower) */
1736 : Word16 *out1;
1737 : Word16 mem_temp;
1738 50004 : const Word16 *filt_coeff_fx = allpass_poles_3_ov_2; // Q15
1739 :
1740 50004 : out1 = &out_fx[0];
1741 :
1742 4050324 : FOR( i = 0; i < len; i++ )
1743 : {
1744 : /* Upper branch */
1745 : /*Vu[0] = mem[0] + filt_coeff[0] * ( input_fx_temp[i] - mem[1] );
1746 : Vu[1] = mem[1] + filt_coeff[1] * ( Vu[0] - mem[2] );
1747 : mem[3] = mem[2] + filt_coeff[2] * ( Vu[1] - mem[3] );*/
1748 :
1749 4000320 : Vu[0] = add_sat( mem_fx[0], mult_r( filt_coeff_fx[0], sub_sat( input_fx[i], mem_fx[1] ) ) );
1750 4000320 : move16(); /* all Vu's in : Q_current*/
1751 4000320 : Vu[1] = add_sat( mem_fx[1], mult_r( filt_coeff_fx[1], sub_sat( Vu[0], mem_fx[2] ) ) );
1752 4000320 : move16();
1753 4000320 : mem_fx[3] = add_sat( mem_fx[2], mult_r( filt_coeff_fx[2], sub_sat( Vu[1], mem_fx[3] ) ) );
1754 4000320 : move16();
1755 :
1756 :
1757 4000320 : mem_fx[1] = Vu[0];
1758 4000320 : move16();
1759 4000320 : mem_fx[2] = Vu[1];
1760 4000320 : move16();
1761 4000320 : *out1++ = mem_fx[3];
1762 4000320 : move16();
1763 :
1764 : /* Middle branch */
1765 : /* Vm[0] = mem[0] + filt_coeff[3] * (input[i]-mem[4]);
1766 : Vm[1] = mem[4] + filt_coeff[4] * (Vm[0]-mem[5]);
1767 : mem[6] = mem[5] + filt_coeff[5] * (Vm[1]-mem[6]); */
1768 4000320 : Vm[0] = add_sat( mem_fx[0], mult_r( filt_coeff_fx[3], sub_sat( input_fx[i], mem_fx[4] ) ) );
1769 4000320 : move16();
1770 4000320 : Vm[1] = add_sat( mem_fx[4], mult_r( filt_coeff_fx[4], sub_sat( Vm[0], mem_fx[5] ) ) );
1771 4000320 : move16();
1772 4000320 : mem_fx[6] = add_sat( mem_fx[5], mult_r( filt_coeff_fx[5], sub_sat( Vm[1], mem_fx[6] ) ) );
1773 4000320 : move16();
1774 :
1775 4000320 : mem_fx[4] = Vm[0];
1776 4000320 : move16();
1777 4000320 : mem_fx[5] = Vm[1];
1778 4000320 : move16();
1779 4000320 : *out1++ = mem_fx[6];
1780 4000320 : move16();
1781 :
1782 : /* Lower branch */
1783 : /* Vl[0] = mem[0] + filt_coeff[6] * (input[i]-mem[7]);
1784 : Vl[1] = mem[7] + filt_coeff[7] * (Vl[0]-mem[8]);
1785 : mem[9] = mem[8] + filt_coeff[8] * (Vl[1]-mem[9]); */
1786 4000320 : Vl[0] = add_sat( mem_fx[0], mult_r( filt_coeff_fx[6], sub_sat( input_fx[i], mem_fx[7] ) ) );
1787 4000320 : move16();
1788 4000320 : Vl[1] = add_sat( mem_fx[7], mult_r( filt_coeff_fx[7], sub_sat( Vl[0], mem_fx[8] ) ) );
1789 4000320 : move16();
1790 4000320 : mem_fx[9] = add_sat( mem_fx[8], mult_r( filt_coeff_fx[8], sub_sat( Vl[1], mem_fx[9] ) ) );
1791 4000320 : move16();
1792 :
1793 4000320 : mem_fx[0] = input_fx[i];
1794 4000320 : move16();
1795 4000320 : mem_fx[7] = Vl[0];
1796 4000320 : move16();
1797 4000320 : mem_fx[8] = Vl[1];
1798 4000320 : move16();
1799 4000320 : *out1++ = mem_fx[9];
1800 4000320 : move16();
1801 : }
1802 : /*LPF*/
1803 12050964 : FOR( i = 0; i < len * 3; i++ )
1804 : {
1805 12000960 : mem_temp = out_fx[i];
1806 12000960 : move16();
1807 12000960 : out_fx[i] = sub_sat( mult_r( 18768 /*0.57276865021499168f Q15*/, add_sat( mem_fx[12], mem_fx[11] ) ), mult_r( 2425 /*0.074004974641176793f Q15*/, add_sat( mem_temp, mem_fx[10] ) ) );
1808 12000960 : mem_fx[10] = mem_fx[11];
1809 12000960 : move16();
1810 12000960 : mem_fx[11] = mem_fx[12];
1811 12000960 : move16();
1812 12000960 : mem_fx[12] = mem_temp;
1813 12000960 : move16();
1814 : }
1815 50004 : return;
1816 : }
1817 :
1818 : /* IVAS 32-bit variant */
1819 3338 : void interpolate_3_over_1_allpass_fx32(
1820 : const Word32 *input, /* i : input signal Qx */
1821 : const Word16 len, /* i : number of input samples */
1822 : Word32 *out, /* o : output signal */
1823 : Word32 *mem /* i/o: memory */
1824 : )
1825 : {
1826 : Word16 i, tmp16;
1827 : Word32 Vu[2], Vm[2], Vl[2]; /* Outputs of three cascaded allpass stages (upper, middle, and lower) */
1828 : Word32 *out1;
1829 : Word32 mem_temp;
1830 3338 : const Word16 *filt_coeff = allpass_poles_3_ov_2; // Qx
1831 :
1832 3338 : out1 = &out[0];
1833 :
1834 1071498 : FOR( i = 0; i < len; i++ )
1835 : {
1836 : /* Upper branch */
1837 1068160 : Vu[0] = L_add_sat( mem[0], Mpy_32_16_1( L_sub( input[i], mem[1] ), filt_coeff[0] ) ); // Qx
1838 1068160 : move32();
1839 1068160 : Vu[1] = L_add_sat( mem[1], Mpy_32_16_1( L_sub( Vu[0], mem[2] ), filt_coeff[1] ) ); // Qx
1840 1068160 : move32();
1841 1068160 : mem[3] = L_add_sat( mem[2], Mpy_32_16_1( L_sub( Vu[1], mem[3] ), filt_coeff[2] ) ); // Qx
1842 1068160 : move32();
1843 :
1844 1068160 : mem[1] = Vu[0]; // Qx
1845 1068160 : move32();
1846 1068160 : mem[2] = Vu[1]; // Qx
1847 1068160 : move32();
1848 1068160 : *out1++ = mem[3]; // Qx
1849 1068160 : move32();
1850 :
1851 : /* Middle branch */
1852 1068160 : Vm[0] = L_add_sat( mem[0], Mpy_32_16_1( L_sub( input[i], mem[4] ), filt_coeff[3] ) ); // Qx
1853 1068160 : move32();
1854 1068160 : Vm[1] = L_add_sat( mem[4], Mpy_32_16_1( L_sub( Vm[0], mem[5] ), filt_coeff[4] ) ); // Qx
1855 1068160 : move32();
1856 1068160 : mem[6] = L_add_sat( mem[5], Mpy_32_16_1( L_sub( Vm[1], mem[6] ), filt_coeff[5] ) ); // Qx
1857 1068160 : move32();
1858 :
1859 1068160 : mem[4] = Vm[0]; // Qx
1860 1068160 : move32();
1861 1068160 : mem[5] = Vm[1]; // Qx
1862 1068160 : move32();
1863 1068160 : *out1++ = mem[6]; // Qx
1864 1068160 : move32();
1865 :
1866 : /* Lower branch */
1867 1068160 : Vl[0] = L_add_sat( mem[0], Mpy_32_16_1( L_sub( input[i], mem[7] ), filt_coeff[6] ) ); // Qx
1868 1068160 : move32();
1869 1068160 : Vl[1] = L_add_sat( mem[7], Mpy_32_16_1( L_sub( Vl[0], mem[8] ), filt_coeff[7] ) ); // Qx
1870 1068160 : move32();
1871 1068160 : mem[9] = L_add_sat( mem[8], Mpy_32_16_1( L_sub( Vl[1], mem[9] ), filt_coeff[8] ) ); // Qx
1872 1068160 : move32();
1873 :
1874 1068160 : mem[0] = input[i]; // Qx
1875 1068160 : move32();
1876 1068160 : mem[7] = Vl[0]; // Qx
1877 1068160 : move32();
1878 1068160 : mem[8] = Vl[1]; // Qx
1879 1068160 : move32();
1880 1068160 : *out1++ = mem[9]; // Qx
1881 1068160 : move32();
1882 : }
1883 :
1884 : /*LPF*/
1885 3338 : tmp16 = imult1616( len, 3 );
1886 3207818 : FOR( i = 0; i < tmp16; i++ )
1887 : {
1888 3204480 : mem_temp = out[i]; // Qx
1889 3204480 : move32();
1890 3204480 : out[i] = L_sub_sat( Mpy_32_16_1( L_add_sat( mem[12], mem[11] ), 18768 ), Mpy_32_16_1( L_add_sat( mem_temp, mem[10] ), 2425 ) ); // Qx
1891 : // 0.572769 in Q15 -> 18768, 0.074005 in Q15 -> 2425
1892 3204480 : move32();
1893 3204480 : mem[10] = mem[11]; // Qx
1894 3204480 : move32();
1895 3204480 : mem[11] = mem[12]; // Qx
1896 3204480 : move32();
1897 3204480 : mem[12] = mem_temp; // Qx
1898 3204480 : move32();
1899 : }
1900 :
1901 3338 : return;
1902 : }
1903 :
1904 :
1905 : /*-------------------------------------------------------------------*
1906 : * decimate_3_over_2_allpass_fx()
1907 : *
1908 : * Decimate 2/3 using allpass iir polyphase filter. Delay 4 samples @48k
1909 : *-------------------------------------------------------------------*/
1910 :
1911 0 : void decimate_2_over_3_allpass_fx(
1912 : const Word16 *input,
1913 : /* i : input signal */ /* Q_input */
1914 : const Word16 len, /* i : number of input samples */
1915 : Word16 *out_fx,
1916 : /* o : output signal */ /* Q_input */
1917 : Word16 *mem_fx,
1918 : /* i/o: memory */ /* Q_input */
1919 : const Word16 *filt_coeff_fx,
1920 : /* i : filter coefficients */ /* Q15*/
1921 : const Word16 *lp_num_fx, /* i : Num Coefficients : Q15 */
1922 : const Word16 *lp_den_fx, /* o : Den Coefficients : Q15 */
1923 : Word16 *lp_mem_fx /* o : Filter memories : Q_input */
1924 : )
1925 : {
1926 :
1927 : Word16 i, loop_len;
1928 : Word16 Vu1, Vm1, Vl1; /* Outputs of three cascaded allpass stages (upper, middle, and lower) */
1929 0 : Word16 Vu0 = 0, Vm0 = 0, Vl0 = 0; /* initialize just to avoid compiler warnings */
1930 : Word16 out1_buff[L_FRAME48k * 2];
1931 : Word16 *out1, *in;
1932 : Word16 out, tmp;
1933 : Word16 mem_fx_11, mem_fx_7, mem_fx_3;
1934 : Word16 sc, input_fx[960];
1935 0 : sc = s_min( s_min( sub( Find_Max_Norm16( input, len ), 2 ), sub( Find_Max_Norm16( mem_fx, 12 ), 2 ) ), sub( Find_Max_Norm16( lp_mem_fx, 3 ), 2 ) );
1936 0 : Scale_sig( lp_mem_fx, 3, sc );
1937 0 : Copy_Scale_sig( input, input_fx, len, sc );
1938 0 : Scale_sig( mem_fx, 12, sc );
1939 0 : out1 = out1_buff;
1940 : /* *out1++ = lp_num[0] * ( input[0] + lp_mem[0] ) - lp_den[2] * lp_mem[2]; */
1941 0 : *out1++ = msu_r( L_mult( lp_num_fx[0], add( input_fx[0], lp_mem_fx[0] ) ), lp_den_fx[2], lp_mem_fx[2] );
1942 0 : move16();
1943 : /* *out1++ = lp_num[1] * input[0] - lp_den[2] * lp_mem[1]; */
1944 0 : *out1++ = msu_r( L_mult( lp_num_fx[1], input_fx[0] ), lp_den_fx[2], lp_mem_fx[1] );
1945 0 : move16();
1946 :
1947 0 : FOR( i = 1; i < len; i++ )
1948 : {
1949 : /* tmp = lp_num[0] * ( input[i] + input[i-1] ) - lp_den[2] * out1[-2];
1950 : *out1++ = tmp; */
1951 0 : tmp = msu_r( L_mult( lp_num_fx[0], add( input_fx[i], input_fx[i - 1] ) ), lp_den_fx[2], out1[-2] );
1952 0 : *out1++ = tmp;
1953 0 : move16();
1954 : /* tmp = lp_num[1] * input[i] - lp_den[2] * out1[-2];
1955 : *out1++ = tmp; */
1956 0 : tmp = msu_r( L_mult( lp_num_fx[1], input_fx[i] ), lp_den_fx[2], out1[-2] );
1957 0 : *out1++ = tmp;
1958 0 : move16();
1959 : }
1960 0 : lp_mem_fx[0] = input_fx[len - 1];
1961 0 : move16();
1962 0 : lp_mem_fx[1] = out1[-1];
1963 0 : move16();
1964 0 : lp_mem_fx[2] = out1[-2];
1965 0 : move16();
1966 :
1967 : /* do the all pass polyphase filter with pi/3 cutoff */
1968 0 : out1 = out_fx;
1969 0 : in = out1_buff;
1970 : /* loop_len = len*2/3 */
1971 0 : loop_len = shl( len, 1 ) / 3; /* Replace with a better way to divide by 3 when len is divisible by 3 */
1972 :
1973 0 : assert( loop_len > 0 );
1974 :
1975 0 : mem_fx_11 = mem_fx[11];
1976 0 : move16();
1977 0 : mem_fx_7 = mem_fx[7];
1978 0 : move16();
1979 0 : mem_fx_3 = mem_fx[3];
1980 0 : move16();
1981 0 : FOR( i = 0; i < loop_len; i++ )
1982 : {
1983 : /* Lower branch */
1984 : /*Vl0 = mem[8] + filt_coeff[6] * (*in - mem[9]);
1985 : Vl1 = mem[9] + filt_coeff[7] * (Vl0 - mem[10]);
1986 : mem[11] = mem[10] + filt_coeff[8] * (Vl1 - mem[11]); */
1987 0 : tmp = mult_r( filt_coeff_fx[6], sub( *in++, mem_fx[9] ) );
1988 0 : if ( i == 0 )
1989 : {
1990 0 : Vl0 = add( mem_fx[8], tmp );
1991 : }
1992 0 : if ( i != 0 )
1993 : {
1994 0 : Vl0 = add( *( in - 4 ), tmp );
1995 : }
1996 0 : Vl1 = add( mem_fx[9], mult_r( filt_coeff_fx[7], sub( Vl0, mem_fx[10] ) ) );
1997 0 : mem_fx_11 = add( mem_fx[10], mult_r( filt_coeff_fx[8], sub( Vl1, mem_fx_11 ) ) );
1998 :
1999 : /* mem[8] = *in++;
2000 : mem[9] = Vl0;
2001 : mem[10] = Vl1;
2002 : *out1 = mem[11]; */
2003 :
2004 0 : mem_fx[9] = Vl0;
2005 0 : move16();
2006 0 : mem_fx[10] = Vl1;
2007 0 : move16();
2008 :
2009 : /* Middle branch */
2010 : /* Vm0 = mem[4] + filt_coeff[3] * (*in - mem[5]);
2011 : Vm1 = mem[5] + filt_coeff[4] * (Vm0-mem[6]);
2012 : mem[7] = mem[6] + filt_coeff[5] * (Vm1-mem[7]); */
2013 0 : tmp = mult_r( filt_coeff_fx[3], sub( *in++, mem_fx[5] ) );
2014 0 : if ( i == 0 )
2015 : {
2016 0 : Vm0 = add( mem_fx[4], tmp );
2017 : }
2018 0 : if ( i != 0 )
2019 : {
2020 0 : Vm0 = add( *( in - 4 ), tmp );
2021 : }
2022 0 : Vm1 = add( mem_fx[5], mult_r( filt_coeff_fx[4], sub( Vm0, mem_fx[6] ) ) );
2023 0 : mem_fx_7 = add( mem_fx[6], mult_r( filt_coeff_fx[5], sub( Vm1, mem_fx_7 ) ) );
2024 :
2025 0 : mem_fx[5] = Vm0;
2026 0 : move16();
2027 0 : mem_fx[6] = Vm1;
2028 0 : move16();
2029 0 : out = add( mem_fx_11, mem_fx_7 );
2030 :
2031 : /* Upper branch */
2032 : /* Vu0 = mem[0] + filt_coeff[0] * ( *in - mem[1] );
2033 : Vu1 = mem[1] + filt_coeff[1] * ( Vu0 - mem[2] );
2034 : mem[3] = mem[2] + filt_coeff[2] * ( Vu1 - mem[3] ); */
2035 0 : tmp = mult_r( filt_coeff_fx[0], sub( *in++, mem_fx[1] ) );
2036 0 : if ( i == 0 )
2037 : {
2038 0 : Vu0 = add( mem_fx[0], tmp );
2039 : }
2040 0 : if ( i != 0 )
2041 : {
2042 0 : Vu0 = add( *( in - 4 ), tmp );
2043 : }
2044 0 : Vu1 = add( mem_fx[1], mult_r( filt_coeff_fx[1], sub( Vu0, mem_fx[2] ) ) );
2045 0 : mem_fx_3 = add( mem_fx[2], mult_r( filt_coeff_fx[2], sub( Vu1, mem_fx_3 ) ) );
2046 :
2047 0 : mem_fx[1] = Vu0;
2048 0 : move16();
2049 0 : mem_fx[2] = Vu1;
2050 0 : move16();
2051 0 : *out1++ = add( out, mem_fx_3 );
2052 0 : move16();
2053 : }
2054 0 : mem_fx[8] = *( in - 3 );
2055 0 : move16();
2056 0 : mem_fx[4] = *( in - 2 );
2057 0 : move16();
2058 0 : mem_fx[0] = *( in - 1 );
2059 0 : move16();
2060 0 : mem_fx[11] = mem_fx_11;
2061 0 : move16();
2062 0 : mem_fx[7] = mem_fx_7;
2063 0 : move16();
2064 0 : mem_fx[3] = mem_fx_3;
2065 0 : move16();
2066 :
2067 0 : Scale_sig( mem_fx, 12, negate( sc ) );
2068 0 : Scale_sig( out_fx, loop_len, negate( sc ) );
2069 0 : Scale_sig( lp_mem_fx, 3, negate( sc ) );
2070 0 : return;
2071 : }
2072 :
2073 :
2074 : /*-------------------------------------------------------------------*
2075 : * retro_interp4_5_fx()
2076 : *
2077 : *
2078 : *-------------------------------------------------------------------*/
2079 :
2080 544 : void retro_interp4_5_fx(
2081 : const Word16 *syn_fx,
2082 : Word16 *pst_old_syn_fx )
2083 : {
2084 : Word16 *pf5, *pf4;
2085 : Word16 c;
2086 :
2087 : /* resample st->pst_old_syn in a reverse way to preserve time-alignment */
2088 544 : pf4 = (Word16 *) &pst_old_syn_fx[58];
2089 544 : pf5 = (Word16 *) pst_old_syn_fx;
2090 31552 : FOR( c = 0; c < 57; c++ )
2091 : {
2092 31008 : *pf5++ = pf4[0];
2093 31008 : move16();
2094 : /* *pf5++ = 0.2f * pf4[0] + 0.8f * pf4[1]; */
2095 31008 : *pf5++ = mac_r( L_mult( 6554, pf4[0] ), 26214, pf4[1] );
2096 31008 : move16();
2097 : /* *pf5++ = 0.4f * pf4[1] + 0.6f * pf4[2]; */
2098 31008 : *pf5++ = mac_r( L_mult( 13107, pf4[1] ), 19661, pf4[2] );
2099 31008 : move16();
2100 : /* *pf5++ = 0.6f * pf4[2] + 0.4f * pf4[3]; */
2101 31008 : *pf5++ = mac_r( L_mult( 19661, pf4[2] ), 13107, pf4[3] );
2102 31008 : move16();
2103 : /* *pf5++ = 0.8f * pf4[3] + 0.2f * pf4[4]; */
2104 31008 : *pf5++ = mac_r( L_mult( 26214, pf4[3] ), 6554, pf4[4] );
2105 31008 : move16();
2106 31008 : pf4 += 4;
2107 : }
2108 544 : *pf5++ = pf4[0];
2109 544 : move16();
2110 : /* *pf5++ = 0.2f * pf4[0] + 0.8f * pf4[1]; */
2111 544 : *pf5++ = mac_r( L_mult( 6554, pf4[0] ), 26214, pf4[1] );
2112 544 : move16();
2113 : /* *pf5++ = 0.4f * pf4[1] + 0.6f * pf4[2]; */
2114 544 : *pf5++ = mac_r( L_mult( 13107, pf4[1] ), 19661, pf4[2] );
2115 544 : move16();
2116 : /* *pf5++ = 0.6f * pf4[2] + 0.4f * pf4[3]; */
2117 544 : *pf5++ = mac_r( L_mult( 19661, pf4[2] ), 13107, pf4[3] );
2118 544 : move16();
2119 : /* *pf5++ = 0.8f * pf4[3] + 0.2f * syn[0]; */
2120 544 : *pf5++ = mac_r( L_mult( 26214, pf4[3] ), 6554, syn_fx[0] );
2121 544 : move16();
2122 : /* all samples processed: NBPSF_PIT_MAX = 290 = (58*5) */
2123 :
2124 544 : return;
2125 : }
2126 :
2127 :
2128 : /*-------------------------------------------------------------------*
2129 : * retro_interp5_4_fx()
2130 : *
2131 : *
2132 : *-------------------------------------------------------------------*/
2133 :
2134 1222 : void retro_interp5_4_fx(
2135 : Word16 *pst_old_syn_fx )
2136 : {
2137 : Word16 *pf5, *pf4;
2138 : Word16 c;
2139 :
2140 : /* resample st->pst_old_syn in a reverse way to preserve time-alignment */
2141 1222 : pf4 = (Word16 *) &pst_old_syn_fx[NBPSF_PIT_MAX - 1];
2142 1222 : pf5 = pf4;
2143 72098 : FOR( c = 0; c < 58; c++ )
2144 : {
2145 : /* *pf4-- = 0.75f * pf5[0] + 0.25f * pf5[-1]; */
2146 70876 : *pf4-- = mac_r( L_mult( 24576, pf5[0] ), 8192, pf5[-1] );
2147 70876 : move16();
2148 : /* *pf4-- = 0.50f * pf5[-1] + 0.50f * pf5[-2]; */
2149 70876 : *pf4-- = mac_r( L_mult( 16384, pf5[-1] ), 16384, pf5[-2] );
2150 70876 : move16();
2151 : /* *pf4-- = 0.25f * pf5[-2] + 0.75f * pf5[-3]; */
2152 70876 : *pf4-- = mac_r( L_mult( 8192, pf5[-2] ), 24576, pf5[-3] );
2153 70876 : move16();
2154 70876 : *pf4-- = pf5[-4];
2155 70876 : move16();
2156 70876 : pf5 -= 5;
2157 : }
2158 : /* all samples processed: NBPSF_PIT_MAX = 290 = (58*5) */
2159 :
2160 1222 : return;
2161 : }
|
