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