fork/rust-sdks
git clone https://git.julia.blue/fork/rust-sdks
2e4d385
livekit/livekit-ffi@0.13.0
1/* SoX Resampler Library Copyright (c) 2007-16 robs@users.sourceforge.net 2* Licence for this file: LGPL v2.1 See LICENCE for details. 3* 4* Constant-rate resampling common code. */ 5 6#include <math.h> 7#include <assert.h> 8#include <string.h> 9#include <stdlib.h> 10 11#include "filter.h" 12 13#if definedSOXR_LIB 14#include "internal.h" 15#define STATIC 16#endif 17 18#include "cr.h" 19 20#define num_coefs4 ((core_flags&CORE_SIMD_POLY)? ((num_coefs+3)&~3) : num_coefs) 21 22#define coef_coef (C ,T ,x ) \ 23 C((T*)result, interp_order, num_coefs4, j, x, num_coefs4 - 1 - i) 24 25#define STORE (C ,T ) { \ 26 if (interp_order > 2) coef_coef(C,T,3) = (T)d; \ 27 if (interp_order > 1) coef_coef(C,T,2) = (T)c; \ 28 if (interp_order > 0) coef_coef(C,T,1) = (T)b; \ 29 coef_coef(C,T,0) = (T)f0;} 30 31static real * prepare_poly_fir_coefs (double const * coefs ,int num_coefs , 32int num_phases ,int interp_order ,double multiplier , 33core_flags_t core_flags ,alloc_t const * mem ) 34{ 35int i ,j ,length = num_coefs4 * num_phases * (interp_order + 1 ); 36real * result = mem -> calloc (1 ,(size_t )length <<LOG2_SIZEOF_REAL (core_flags )); 37double fm1 = coefs [0 ],f1 = 0 ,f2 = 0 ; 38 39for (i = num_coefs - 1 ;i >=0 ;-- i ) 40for (j = num_phases - 1 ;j >=0 ;-- j ) { 41double f0 = fm1 ,b = 0 ,c = 0 ,d = 0 ;/* = 0 to kill compiler warning */ 42int pos = i * num_phases + j - 1 ; 43fm1 = pos > 0 ?coefs [pos - 1 ]* multiplier :0 ; 44switch (interp_order ) { 45case 1 :b = f1 - f0 ;break ; 46case 2 :b = f1 - (.5 * (f2 + f0 )- f1 )- f0 ;c = .5 * (f2 + f0 )- f1 ;break ; 47case 3 :c = .5 * (f1 + fm1 )- f0 ;d = (1 /6. )* (f2 - f1 + fm1 - f0 - 4 * c );b = f1 - f0 - d - c ;break ; 48default :assert (!interp_order ); 49 } 50switch (core_flags & 3 ) { 51case 0 :if (WITH_CR32 )STORE (coef ,float );break ; 52case 1 :if (WITH_CR64 )STORE (coef ,double );break ; 53case 2 :if (WITH_CR32S )STORE (coef4 ,float );break ; 54default :if (WITH_CR64S )STORE (coef4 ,double );break ; 55 } 56f2 = f1 ,f1 = f0 ; 57 } 58return result ; 59} 60 61#undef STORE 62#undef coef_coef 63 64#define IS_FLOAT32 (WITH_CR32 || WITH_CR32S) && \ 65 (!(WITH_CR64 || WITH_CR64S) || sizeof_real == sizeof(float)) 66#define WITH_FLOAT64 WITH_CR64 || WITH_CR64S 67 68static void dft_stage_fn (stage_t * p ,fifo_t * output_fifo ) 69{ 70real * output ,* dft_out ; 71int i ,j ,num_in = max (0 ,fifo_occupancy (& p -> fifo )); 72rate_shared_t const * s = p -> shared ; 73dft_filter_t const * f = & s -> dft_filter [p -> dft_filter_num ]; 74int const overlap = f -> num_taps - 1 ; 75 76if (p -> at .integer + p -> L * num_in >=f -> dft_length ) { 77fn_t const * const RDFT_CB = p -> rdft_cb ; 78size_t const sizeof_real = sizeof (char ) <<LOG2_SIZEOF_REAL (p -> core_flags ); 79div_t divd = div (f -> dft_length - overlap - p -> at .integer + p -> L - 1 ,p -> L ); 80real const * input = fifo_read_ptr (& p -> fifo ); 81fifo_read (& p -> fifo ,divd .quot ,NULL ); 82num_in -= divd .quot ; 83 84output = fifo_reserve (output_fifo ,f -> dft_length ); 85dft_out = (p -> core_flags & CORE_SIMD_DFT )?p -> dft_out :output ; 86 87if (lsx_is_power_of_2 (p -> L )) {/* F-domain */ 88int portion = f -> dft_length /p -> L ; 89memcpy (dft_out ,input , (unsigned )portion * sizeof_real ); 90rdft_oforward (portion ,f -> dft_forward_setup ,dft_out ,p -> dft_scratch ); 91if (IS_FLOAT32 ) { 92#define dft_out ((float *)dft_out) 93for (i = portion + 2 ;i < (portion <<1 );i += 2 )/* Mirror image. */ 94dft_out [i ]= dft_out [(portion <<1 )- i ], 95dft_out [i + 1 ]= - dft_out [(portion <<1 )- i + 1 ]; 96dft_out [portion ]= dft_out [1 ]; 97dft_out [portion + 1 ]= 0 ; 98dft_out [1 ]= dft_out [0 ]; 99#undef dft_out 100 } 101else if (WITH_FLOAT64 ) { 102#define dft_out ((double *)dft_out) 103for (i = portion + 2 ;i < (portion <<1 );i += 2 )/* Mirror image. */ 104dft_out [i ]= dft_out [(portion <<1 )- i ], 105dft_out [i + 1 ]= - dft_out [(portion <<1 )- i + 1 ]; 106dft_out [portion ]= dft_out [1 ]; 107dft_out [portion + 1 ]= 0 ; 108dft_out [1 ]= dft_out [0 ]; 109#undef dft_out 110 } 111 112for (portion <<=1 ;i < f -> dft_length ;i += portion ,portion <<=1 ) { 113memcpy ((char * )dft_out + (size_t )i * sizeof_real ,dft_out , (size_t )portion * sizeof_real ); 114if (IS_FLOAT32 ) 115#define dft_out ((float *)dft_out) 116dft_out [i + 1 ]= 0 ; 117#undef dft_out 118else if (WITH_FLOAT64 ) 119#define dft_out ((double *)dft_out) 120dft_out [i + 1 ]= 0 ; 121#undef dft_out 122 } 123if (p -> step .integer > 0 ) 124rdft_reorder_back (f -> dft_length ,f -> dft_backward_setup ,dft_out ,p -> dft_scratch ); 125 }else { 126if (p -> L == 1 ) 127memcpy (dft_out ,input , (size_t )f -> dft_length * sizeof_real ); 128else { 129memset (dft_out ,0 , (size_t )f -> dft_length * sizeof_real ); 130if (IS_FLOAT32 ) 131for (j = 0 ,i = p -> at .integer ;i < f -> dft_length ;++ j ,i += p -> L ) 132 ((float * )dft_out )[i ]= ((float * )input )[j ]; 133else if (WITH_FLOAT64 ) 134for (j = 0 ,i = p -> at .integer ;i < f -> dft_length ;++ j ,i += p -> L ) 135 ((double * )dft_out )[i ]= ((double * )input )[j ]; 136p -> at .integer = p -> L - 1 - divd .rem ; 137 } 138if (p -> step .integer > 0 ) 139rdft_forward (f -> dft_length ,f -> dft_forward_setup ,dft_out ,p -> dft_scratch ); 140else 141rdft_oforward (f -> dft_length ,f -> dft_forward_setup ,dft_out ,p -> dft_scratch ); 142 } 143 144if (p -> step .integer > 0 ) { 145rdft_convolve (f -> dft_length ,f -> dft_backward_setup ,dft_out ,f -> coefs ); 146rdft_backward (f -> dft_length ,f -> dft_backward_setup ,dft_out ,p -> dft_scratch ); 147if ((p -> core_flags & CORE_SIMD_DFT )&& p -> step .integer == 1 ) 148memcpy (output ,dft_out , (size_t )f -> dft_length * sizeof_real ); 149if (p -> step .integer != 1 ) { 150if (IS_FLOAT32 ) 151for (j = 0 ,i = p -> remM ;i < f -> dft_length - overlap ;++ j , 152i += p -> step .integer ) 153 ((float * )output )[j ]= ((float * )dft_out )[i ]; 154else if (WITH_FLOAT64 ) 155for (j = 0 ,i = p -> remM ;i < f -> dft_length - overlap ;++ j , 156i += p -> step .integer ) 157 ((double * )output )[j ]= ((double * )dft_out )[i ]; 158p -> remM = i - (f -> dft_length - overlap ); 159fifo_trim_by (output_fifo ,f -> dft_length - j ); 160 } 161else fifo_trim_by (output_fifo ,overlap ); 162 } 163else {/* F-domain */ 164int m = - p -> step .integer ; 165rdft_convolve_portion (f -> dft_length >>m ,dft_out ,f -> coefs ); 166rdft_obackward (f -> dft_length >>m ,f -> dft_backward_setup ,dft_out ,p -> dft_scratch ); 167if (p -> core_flags & CORE_SIMD_DFT ) 168memcpy (output ,dft_out , (size_t )(f -> dft_length >>m )* sizeof_real ); 169fifo_trim_by (output_fifo , (((1 <<m )- 1 )* f -> dft_length + overlap ) >>m ); 170 } 171 (void )RDFT_CB ; 172 } 173p -> input_size = (f -> dft_length - p -> at .integer + p -> L - 1 ) /p -> L ; 174} 175 176/* Set to 4 x nearest power of 2 or half of that */ 177/* if danger of causing too many cache misses. */ 178static int set_dft_length (int num_taps ,int min ,int large ) 179{ 180double d = log ((double )num_taps ) /log (2. ); 181return 1 <<range_limit ((int )(d + 2.77 ),min ,max ((int )(d + 1.77 ),large )); 182} 183 184static void dft_stage_init ( 185unsigned instance ,double Fp ,double Fs ,double Fn ,double att , 186double phase_response ,stage_t * p ,int L ,int M ,double * multiplier , 187unsigned min_dft_size ,unsigned large_dft_size ,core_flags_t core_flags , 188fn_t const * RDFT_CB ) 189{ 190dft_filter_t * f = & p -> shared -> dft_filter [instance ]; 191int num_taps = 0 ,dft_length = f -> dft_length ,i ,offset ; 192bool f_domain_m = abs (3 - M )== 1 && Fs <=1 ; 193size_t const sizeof_real = sizeof (char ) <<LOG2_SIZEOF_REAL (core_flags ); 194 195if (!dft_length ) { 196int k = phase_response == 50 && lsx_is_power_of_2 (L )&& Fn == L ?L <<1 :4 ; 197double m ,* h = lsx_design_lpf (Fp ,Fs ,Fn ,att ,& num_taps ,- k ,-1. ); 198 199if (phase_response != 50 ) 200lsx_fir_to_phase (& h ,& num_taps ,& f -> post_peak ,phase_response ); 201else f -> post_peak = num_taps /2 ; 202 203dft_length = set_dft_length (num_taps , (int )min_dft_size , (int )large_dft_size ); 204f -> coefs = rdft_calloc ((size_t )dft_length ,sizeof_real ); 205offset = dft_length - num_taps + 1 ; 206m = (1. /dft_length )* rdft_multiplier ()* L * * multiplier ; 207if (IS_FLOAT32 )for (i = 0 ;i < num_taps ;++ i ) 208 ((float * )f -> coefs )[(i + offset )& (dft_length - 1 )]= (float )(h [i ]* m ); 209else if (WITH_FLOAT64 )for (i = 0 ;i < num_taps ;++ i ) 210 ((double * )f -> coefs )[(i + offset )& (dft_length - 1 )]= h [i ]* m ; 211free (h ); 212 } 213 214if (rdft_flags ()& RDFT_IS_SIMD ) 215p -> dft_out = rdft_malloc (sizeof_real * (size_t )dft_length ); 216if (rdft_flags ()& RDFT_NEEDS_SCRATCH ) 217p -> dft_scratch = rdft_malloc (2 * sizeof_real * (size_t )dft_length ); 218 219if (!f -> dft_length ) { 220void * coef_setup = rdft_forward_setup (dft_length ); 221int Lp = lsx_is_power_of_2 (L )?L :1 ; 222int Mp = f_domain_m ?M :1 ; 223f -> dft_forward_setup = rdft_forward_setup (dft_length /Lp ); 224f -> dft_backward_setup = rdft_backward_setup (dft_length /Mp ); 225if (Mp == 1 ) 226rdft_forward (dft_length ,coef_setup ,f -> coefs ,p -> dft_scratch ); 227else 228rdft_oforward (dft_length ,coef_setup ,f -> coefs ,p -> dft_scratch ); 229rdft_delete_setup (coef_setup ); 230f -> num_taps = num_taps ; 231f -> dft_length = dft_length ; 232lsx_debug ("fir_len=%i dft_length=%i Fp=%g Fs=%g Fn=%g att=%g %i/%i" , 233num_taps ,dft_length ,Fp ,Fs ,Fn ,att ,L ,M ); 234 } 235* multiplier = 1 ; 236p -> out_in_ratio = (double )L /M ; 237p -> core_flags = core_flags ; 238p -> rdft_cb = RDFT_CB ; 239p -> fn = dft_stage_fn ; 240p -> preload = f -> post_peak /L ; 241p -> at .integer = f -> post_peak %L ; 242p -> L = L ; 243p -> step .integer = f_domain_m ?- M /2 :M ; 244p -> dft_filter_num = instance ; 245p -> block_len = f -> dft_length - (f -> num_taps - 1 ); 246p -> phase0 = p -> at .integer /p -> L ; 247p -> input_size = (f -> dft_length - p -> at .integer + p -> L - 1 ) /p -> L ; 248} 249 250static struct half_fir_info const * find_half_fir ( 251struct half_fir_info const * firs ,size_t len ,double att ) 252{ 253size_t i ; 254for (i = 0 ;i + 1 < len && att > firs [i ].att ;++ i ); 255return & firs [i ]; 256} 257 258#define have_pre_stage (preM * preL != 1) 259#define have_arb_stage (arbM * arbL != 1) 260#define have_post_stage (postM * postL != 1) 261 262#include "soxr.h" 263 264STATIC char const * _soxr_init ( 265rate_t * const p ,/* Per audio channel. */ 266rate_shared_t * const shared ,/* By channels undergoing same rate change. */ 267double const io_ratio ,/* Input rate divided by output rate. */ 268soxr_quality_spec_t const * const q_spec , 269soxr_runtime_spec_t const * const r_spec , 270double multiplier ,/* Linear gain to apply during conversion. */ 271cr_core_t const * const core , 272core_flags_t const core_flags ) 273{ 274size_t const sizeof_real = sizeof (char ) <<LOG2_SIZEOF_REAL (core_flags ); 275double const tolerance = 1 + 1e-5 ; 276 277double bits = q_spec -> precision ; 278rolloff_t const rolloff = (rolloff_t )(q_spec -> flags & 3 ); 279int interpolator = (int )(r_spec -> flags & 3 )- 1 ; 280double const Fp0 = q_spec -> passband_end ,Fs0 = q_spec -> stopband_begin ; 281double const phase_response = q_spec -> phase_response ,tbw0 = Fs0 - Fp0 ; 282 283bool const maintain_3dB_pt = !!(q_spec -> flags & SOXR_MAINTAIN_3DB_PT ); 284double tbw_tighten = 1 ,alpha ; 285#define tighten (x ) (Fs0-(Fs0-(x))*tbw_tighten) 286 287double arbM = io_ratio ,Fn1 ,Fp1 = Fp0 ,Fs1 = Fs0 ,bits1 = min (bits ,33 ); 288double att = (bits1 + 1 )* linear_to_dB (2. ),attArb = att ;/* +1: pass+stop */ 289int preL = 1 ,preM = 1 ,shr = 0 ,arbL = 1 ,postL = 1 ,postM = 1 ; 290bool upsample = false,rational = false,iOpt = !(r_spec -> flags & SOXR_NOSMALLINTOPT ); 291bool lq_bits = (q_spec -> flags & SOXR_PROMOTE_TO_LQ )?bits <=16 :bits == 16 ; 292bool lq_Fp0 = (q_spec -> flags & SOXR_PROMOTE_TO_LQ )?Fp0 <=lq_bw0 :Fp0 == lq_bw0 ; 293int n = 0 ,i ,mode = lq_bits && rolloff == rolloff_medium ?io_ratio > 1 || 294phase_response != 50 || !lq_Fp0 || Fs0 != 1 : ((int )ceil (bits1 )- 6 ) /4 ; 295struct half_fir_info const * half_fir_info ; 296stage_t * s ; 297 298if (io_ratio < 1 && Fs0 - 1 > 1 - Fp0 /tolerance ) 299return "imaging greater than rolloff" ; 300if (.002 /tolerance > tbw0 || tbw0 > .5 * tolerance ) 301return "transition bandwidth not in [0.2,50] % of nyquist" ; 302if (.5 /tolerance > Fp0 || Fs0 > 1.5 * tolerance ) 303return "transition band not within [50,150] % of nyquist" ; 304if (bits != 0 && (15 > bits || bits > 33 )) 305return "precision not in [15,33] bits" ; 306if (io_ratio <=0 ) 307return "resampling factor not positive" ; 308if (0 > phase_response || phase_response > 100 ) 309return "phase response not in [0=min-phase,100=max-phase] %" ; 310 311p -> core = core ; 312p -> io_ratio = io_ratio ; 313if (bits != 0 )while (!n ++ ) {/* Determine stages: */ 314int try ,L ,M ,x ,maxL = interpolator > 0 ?1 :mode ?2048 : 315 (int )ceil (r_spec -> coef_size_kbytes * 1000. / (U100_l * (int )sizeof_real )); 316double d ,epsilon = 0 ,frac ; 317upsample = arbM < 1 ; 318for (i = (int )(.5 * arbM ),shr = 0 ;i >>=1 ;arbM *=.5 ,++ shr ); 319preM = upsample || (arbM > 1.5 && arbM < 2 ); 320postM = 1 + (arbM > 1 && preM ),arbM /=postM ; 321preL = 1 + (!preM && arbM < 2 )+ (upsample && mode ),arbM *=preL ; 322if ((frac = arbM - (int )arbM )!= 0 ) 323epsilon = fabs (floor (frac * MULT32 + .5 ) / (frac * MULT32 )- 1 ); 324for (i = 1 ,rational = frac == 0 ;i <=maxL && !rational ;++ i ) { 325d = frac * i ,try = (int )(d + .5 ); 326if ((rational = fabs (try /d - 1 ) <=epsilon )) {/* No long doubles! */ 327if (try == i ) 328arbM = ceil (arbM ),shr += x = arbM > 3 ,arbM /=1 + x ; 329else arbM = i * (int )arbM + try ,arbL = i ; 330 } 331 } 332L = preL * arbL ,M = (int )(arbM * postM ),x = (L |M )& 1 ,L >>= !x ,M >>= !x ; 333if (iOpt && postL == 1 && (d = preL * arbL /arbM )> 4 && d != 5 ) { 334for (postL = 4 ,i = (int )(d /16 ); (i >>=1 )&& postL < 256 ;postL <<=1 ); 335arbM = arbM * postL /arbL /preL ,arbL = 1 ,n = 0 ; 336 }else if (rational && (max (L ,M )< 3 + 2 * iOpt || L * M < 6 * iOpt )) 337preL = L ,preM = M ,arbM = arbL = postM = 1 ; 338if (!mode && (!rational || !n )) 339++ mode ,n = 0 ; 340 } 341 342p -> num_stages = shr + have_pre_stage + have_arb_stage + have_post_stage ; 343if (!p -> num_stages && multiplier != 1 ) { 344bits = arbL = 0 ;/* Use cubic_stage in this case. */ 345++ p -> num_stages ; 346 } 347p -> stages = calloc ((size_t )p -> num_stages + 1 ,sizeof (* p -> stages )); 348if (!p -> stages ) 349return "out of memory" ; 350for (i = 0 ;i < p -> num_stages ;++ i ) { 351p -> stages [i ].num = i ; 352p -> stages [i ].shared = shared ; 353p -> stages [i ].input_size = 8192 ; 354 } 355p -> stages [0 ].is_input = true; 356 357alpha = postM / (io_ratio * (postL <<0 )); 358 359if ((n = p -> num_stages )> 1 ) {/* Att. budget: */ 360if (have_arb_stage ) 361att += linear_to_dB (2. ),attArb = att ,-- n ; 362att += linear_to_dB ((double )n ); 363 } 364 365half_fir_info = find_half_fir (core -> half_firs ,core -> half_firs_len ,att ); 366for (i = 0 ,s = p -> stages ;i < shr ;++ i ,++ s ) { 367s -> fn = half_fir_info -> fn ; 368s -> coefs = half_fir_info -> coefs ; 369s -> n = half_fir_info -> num_coefs ; 370s -> pre_post = 4 * s -> n ; 371s -> preload = s -> pre = s -> pre_post >>1 ; 372 } 373 374if (have_pre_stage ) { 375if (maintain_3dB_pt && have_post_stage ) {/* Trans. bands overlapping. */ 376double x = tbw0 * lsx_inv_f_resp (-3. ,att ); 377x = - lsx_f_resp (x / (max (2 * alpha - Fs0 ,alpha )- Fp0 ),att ); 378if (x > .035 ) { 379tbw_tighten = ((4.3074e-3 - 3.9121e-4 * x )* x - .040009 )* x + 1.0014 ; 380lsx_debug ("tbw_tighten=%g (%gdB)" ,tbw_tighten ,x ); 381 } 382 } 383Fn1 = preM ?max (preL ,preM ) :arbM /arbL ; 384dft_stage_init (0 ,tighten (Fp1 ),Fs1 ,Fn1 ,att ,phase_response ,s ++ ,preL , 385max (preM ,1 ),& multiplier ,r_spec -> log2_min_dft_size , 386r_spec -> log2_large_dft_size ,core_flags ,core -> rdft_cb ); 387Fp1 /=Fn1 ,Fs1 /=Fn1 ; 388 } 389 390if (bits == 0 && have_arb_stage ) {/* `Quick' cubic arb stage: */ 391s -> fn = core -> cubic_stage_fn ; 392s -> mult = multiplier ,multiplier = 1 ; 393s -> step .whole = (int64_t )(arbM * MULT32 + .5 ); 394s -> pre_post = max (3 ,s -> step .integer ); 395s -> preload = s -> pre = 1 ; 396s -> out_in_ratio = MULT32 / (double )s -> step .whole ; 397 } 398else if (have_arb_stage ) {/* Higher quality arb stage: */ 399static const float rolloffs []= {-.01f ,-.3f ,0 ,-.103f }; 400poly_fir_t const * f = & core -> poly_firs [6 * (upsample + !!preM )+ mode - !upsample ]; 401int order ,num_coefs = (int )f -> interp [0 ].scalar ,phase_bits ,phases ; 402size_t coefs_size ; 403double at ,Fp = Fp1 ,Fs ,Fn ,mult = upsample ?1 :arbM /arbL ; 404poly_fir1_t const * f1 ; 405 406if (!upsample && preM ) 407Fn = 2 * mult ,Fs = 3 + fabs (Fs1 - 1 ); 408else Fn = 1 ,Fs = 2 - (mode ?Fp1 + (Fs1 - Fp1 )* .7 :Fs1 ); 409 410if (mode ) 411Fp = Fs - (Fs - Fp ) / (1 - lsx_inv_f_resp (rolloffs [rolloff ],attArb )); 412 413i = (interpolator < 0 ? !rational :max (interpolator , !rational ))- 1 ; 414do { 415f1 = & f -> interp [++ i ]; 416assert (f1 -> fn ); 417if (i ) 418arbM /=arbL ,arbL = 1 ,rational = false; 419phase_bits = (int )ceil (f1 -> scalar - log (mult )/log (2. )); 420phases = !rational ? (1 <<phase_bits ) :arbL ; 421if (f -> interp [0 ].scalar == 0 ) { 422int phases0 = max (phases ,19 ),n0 = 0 ; 423lsx_design_lpf (Fp ,Fs ,- Fn ,attArb ,& n0 ,phases0 ,f -> beta ); 424num_coefs = n0 /phases0 + 1 ,num_coefs += num_coefs & !preM ; 425 } 426if ((num_coefs & 1 )&& rational && (arbL & 1 )) 427phases <<=1 ,arbL <<=1 ,arbM *=2 ; 428at = arbL * (s -> phase0 = .5 * (num_coefs & 1 )); 429order = i + (i && mode > 4 ); 430coefs_size = (size_t )(num_coefs4 * phases * (order + 1 ))* sizeof_real ; 431 }while (interpolator < 0 && i < 2 && f -> interp [i + 1 ].fn && 432coefs_size /1000 > r_spec -> coef_size_kbytes ); 433 434if (!s -> shared -> poly_fir_coefs ) { 435int num_taps = num_coefs * phases - 1 ; 436double * coefs = lsx_design_lpf ( 437Fp ,Fs ,Fn ,attArb ,& num_taps ,phases ,f -> beta ); 438s -> shared -> poly_fir_coefs = prepare_poly_fir_coefs ( 439coefs ,num_coefs ,phases ,order ,multiplier ,core_flags ,& core -> mem ); 440lsx_debug ("fir_len=%i phases=%i coef_interp=%i size=%.3gk" , 441num_coefs ,phases ,order , (double )coefs_size /1000. ); 442free (coefs ); 443 } 444multiplier = 1 ; 445s -> fn = f1 -> fn ; 446s -> pre_post = num_coefs4 - 1 ; 447s -> preload = ((num_coefs - 1 ) >>1 )+ (num_coefs4 - num_coefs ); 448s -> n = num_coefs4 ; 449s -> phase_bits = phase_bits ; 450s -> L = arbL ; 451s -> use_hi_prec_clock = 452mode > 1 && (q_spec -> flags & SOXR_HI_PREC_CLOCK )&& !rational ; 453#if WITH_FLOAT_STD_PREC_CLOCK 454if (order && !s -> use_hi_prec_clock ) { 455s -> at .flt = at ; 456s -> step .flt = arbM ; 457s -> out_in_ratio = (double )(arbL /s -> step .flt ); 458 }else 459#endif 460 { 461s -> at .whole = (int64_t )(at * MULT32 + .5 ); 462#if WITH_HI_PREC_CLOCK 463if (s -> use_hi_prec_clock ) { 464double M = arbM * MULT32 ; 465s -> at .fix .ls .parts .ms = 0x80000000ul ; 466s -> step .whole = (int64_t )M ; 467M -= (double )s -> step .whole ; 468M *=MULT32 * MULT32 ; 469s -> step .fix .ls .all = (uint64_t )M ; 470 }else 471#endif 472s -> step .whole = (int64_t )(arbM * MULT32 + .5 ); 473s -> out_in_ratio = MULT32 * arbL / (double )s -> step .whole ; 474 } 475++ s ; 476 } 477 478if (have_post_stage ) 479dft_stage_init (1 ,tighten (Fp0 / (upsample ?alpha :1 )),upsample ?max (2 - 480Fs0 /alpha ,1 ) :Fs0 , (double )max (postL ,postM ),att ,phase_response , 481s ++ ,postL ,postM ,& multiplier ,r_spec -> log2_min_dft_size , 482r_spec -> log2_large_dft_size ,core_flags ,core -> rdft_cb ); 483 484lsx_debug ("%g: >>%i %i/%i %i/%g %i/%i (%x)" ,1 /io_ratio , 485shr ,preL ,preM ,arbL ,arbM ,postL ,postM ,core_flags ); 486 487for (i = 0 ,s = p -> stages ;i < p -> num_stages ;++ i ,++ s ) { 488fifo_create (& s -> fifo , (int )sizeof_real ); 489memset (fifo_reserve (& s -> fifo ,s -> preload ),0 , 490sizeof_real * (size_t )s -> preload ); 491lsx_debug_more ("%5i|%-5i preload=%i remL=%i" , 492s -> pre ,s -> pre_post - s -> pre ,s -> preload ,s -> at .integer ); 493 } 494fifo_create (& s -> fifo , (int )sizeof_real ); 495return 0 ; 496} 497 498static bool stage_process (stage_t * stage ,bool flushing ) 499{ 500fifo_t * fifo = & stage -> fifo ; 501bool done = false; 502int want ; 503while (!done && (want = stage -> input_size - fifo_occupancy (fifo ))> 0 ) { 504if (stage -> is_input ) { 505if (flushing ) 506memset (fifo_reserve (fifo ,want ),0 ,fifo -> item_size * (size_t )want ); 507else done = true; 508 } 509else done = stage_process (stage - 1 ,flushing ); 510 } 511stage -> fn (stage ,& stage [1 ].fifo ); 512return done && fifo_occupancy (fifo )< stage -> input_size ; 513} 514 515STATIC void _soxr_process (rate_t * p ,size_t olen ) 516{ 517int const n = p -> flushing ?min (- (int )p -> samples_out , (int )olen ) : (int )olen ; 518stage_t * stage = & p -> stages [p -> num_stages ]; 519fifo_t * fifo = & stage -> fifo ; 520bool done = false; 521while (!done && fifo_occupancy (fifo )< (int )n ) 522done = stage -> is_input || stage_process (stage - 1 ,p -> flushing ); 523} 524 525STATIC real * _soxr_input (rate_t * p ,real const * samples ,size_t n ) 526{ 527if (p -> flushing ) 528return 0 ; 529p -> samples_in += (int64_t )n ; 530return fifo_write (& p -> stages [0 ].fifo , (int )n ,samples ); 531} 532 533STATIC real const * _soxr_output (rate_t * p ,real * samples ,size_t * n0 ) 534{ 535fifo_t * fifo = & p -> stages [p -> num_stages ].fifo ; 536int n = p -> flushing ?min (- (int )p -> samples_out , (int )* n0 ) : (int )* n0 ; 537p -> samples_out += n = min (n ,fifo_occupancy (fifo )); 538return fifo_read (fifo , (int )(* n0 = (size_t )n ),samples ); 539} 540 541STATIC void _soxr_flush (rate_t * p ) 542{ 543if (p -> flushing )return ; 544p -> samples_out -= (int64_t )((double )p -> samples_in /p -> io_ratio + .5 ); 545p -> samples_in = 0 ; 546p -> flushing = true; 547} 548 549STATIC void _soxr_close (rate_t * p ) 550{ 551if (p -> stages ) { 552fn_t const * const RDFT_CB = p -> core -> rdft_cb ; 553rate_shared_t * shared = p -> stages [0 ].shared ; 554int i ; 555 556for (i = 0 ;i <=p -> num_stages ;++ i ) { 557stage_t * s = & p -> stages [i ]; 558rdft_free (s -> dft_scratch ); 559rdft_free (s -> dft_out ); 560fifo_delete (& s -> fifo ); 561 } 562if (shared ) { 563for (i = 0 ;i < 2 ;++ i ) { 564dft_filter_t * f = & shared -> dft_filter [i ]; 565rdft_free (f -> coefs ); 566rdft_delete_setup (f -> dft_forward_setup ); 567rdft_delete_setup (f -> dft_backward_setup ); 568 } 569p -> core -> mem .free (shared -> poly_fir_coefs ); 570memset (shared ,0 ,sizeof (* shared )); 571 } 572free (p -> stages ); 573 (void )RDFT_CB ; 574 } 575} 576 577#if definedSOXR_LIB 578STATIC double _soxr_delay (rate_t * p ) 579{ 580return (double )p -> samples_in /p -> io_ratio - (double )p -> samples_out ; 581} 582 583STATIC void _soxr_sizes (size_t * shared ,size_t * channel ) 584{ 585* shared = sizeof (rate_shared_t ); 586* channel = sizeof (rate_t ); 587} 588#endif