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