fork/rust-sdks
git clone https://git.julia.blue/fork/rust-sdks
2e4d385
main
1/* SoX Resampler Library Copyright (c) 2007-18 robs@users.sourceforge.net 2* Licence for this file: LGPL v2.1 See LICENCE for details. */ 3 4#include <math.h> 5#include <stdlib.h> 6#include <string.h> 7#include <time.h> 8 9#include "soxr.h" 10#include "data-io.h" 11#include "internal.h" 12 13#if AVUTIL_FOUND 14#include <libavutil/cpu.h> 15#endif 16 17 18 19#if WITH_DEV_TRACE 20 21#include <stdarg.h> 22#include <stdio.h> 23 24int _soxr_trace_level ; 25 26void _soxr_trace (char const * fmt , ...) 27{ 28va_list args ; 29va_start (args ,fmt ); 30vfprintf (stderr ,fmt ,args ); 31fputc ('\n' ,stderr ); 32va_end (args ); 33} 34 35#endif 36 37 38 39char const * soxr_version (void ) 40{ 41return "libsoxr-" SOXR_THIS_VERSION_STR ; 42} 43 44 45 46 47typedef void sample_t ;/* float or double */ 48typedef void (* fn_t )(void ); 49typedef fn_t control_block_t [10 ]; 50 51#define resampler_input (*(sample_t * (*)(void *, sample_t * samples, size_t n))p->control_block[0]) 52#define resampler_process (*(void (*)(void *, size_t))p->control_block[1]) 53#define resampler_output (*(sample_t const * (*)(void *, sample_t * samples, size_t * n))p->control_block[2]) 54#define resampler_flush (*(void (*)(void *))p->control_block[3]) 55#define resampler_close (*(void (*)(void *))p->control_block[4]) 56#define resampler_delay (*(double (*)(void *))p->control_block[5]) 57#define resampler_sizes (*(void (*)(size_t * shared, size_t * channel))p->control_block[6]) 58#define resampler_create (*(char const * (*)(void * channel, void * shared, double io_ratio, soxr_quality_spec_t * q_spec, soxr_runtime_spec_t * r_spec, double scale))p->control_block[7]) 59#define resampler_set_io_ratio (*(void (*)(void *, double io_ratio, size_t len))p->control_block[8]) 60#define resampler_id (*(char const * (*)(void))p->control_block[9]) 61 62typedef void * resampler_t ;/* For one channel. */ 63typedef void * resampler_shared_t ;/* Between channels. */ 64typedef void (* deinterleave_t )(sample_t * * dest , 65soxr_datatype_t data_type ,void const * * src0 ,size_t n ,unsigned ch ); 66typedef size_t (* interleave_t )(soxr_datatype_t data_type ,void * * dest , 67sample_t const * const * src ,size_t ,unsigned ,unsigned long * ); 68 69struct soxr { 70unsigned num_channels ; 71double io_ratio ; 72soxr_error_t error ; 73soxr_quality_spec_t q_spec ; 74soxr_io_spec_t io_spec ; 75soxr_runtime_spec_t runtime_spec ; 76 77void * input_fn_state ; 78soxr_input_fn_t input_fn ; 79size_t max_ilen ; 80 81resampler_shared_t shared ; 82resampler_t * resamplers ; 83control_block_t control_block ; 84deinterleave_t deinterleave ; 85interleave_t interleave ; 86 87void * * channel_ptrs ; 88size_t clips ; 89unsigned long seed ; 90int flushing ; 91}; 92 93 94 95#if WITH_CR32 || WITH_CR32S || WITH_CR64 || WITH_CR64S 96#include "filter.h" 97#else 98#define lsx_to_3dB (x ) ((x)/(x)) 99#endif 100 101 102 103soxr_quality_spec_t soxr_quality_spec (unsigned long recipe ,unsigned long flags ) 104{ 105soxr_quality_spec_t spec ,* p = & spec ; 106unsigned q = recipe & 0xf ;/* TODO: move to soxr-lsr.c: */ 107unsigned quality = q > SOXR_LSR2Q + 2 ?SOXR_VHQ :q > SOXR_LSR2Q ?SOXR_QQ :q ; 108double rej ; 109memset (p ,0 ,sizeof (* p )); 110if (quality > SOXR_PRECISIONQ ) { 111p -> e = "invalid quality type" ; 112return spec ; 113 } 114flags |=quality < SOXR_LSR0Q ?RESET_ON_CLEAR :0 ; 115p -> phase_response = "\62\31\144" [(recipe & 0x30 )>>4 ]; 116p -> stopband_begin = 1 ; 117p -> precision = 118quality == SOXR_QQ ?0 : 119quality <=SOXR_16_BITQ ?16 : 120quality <=SOXR_32_BITQ ?4 + quality * 4 : 121quality <=SOXR_LSR2Q ?55 - quality * 4 :/* TODO: move to soxr-lsr.c */ 1220 ; 123rej = p -> precision * linear_to_dB (2. ); 124p -> flags = flags ; 125if (quality <=SOXR_32_BITQ || quality == SOXR_PRECISIONQ ) { 126#define LOW_Q_BW0 (1385 / 2048.)/* 0.67625 rounded to be a FP exact. */ 127p -> passband_end = quality == 1 ?LOW_Q_BW0 :1 - .05 /lsx_to_3dB (rej ); 128if (quality <=2 ) 129p -> flags &= ~SOXR_ROLLOFF_NONE ,p -> flags |=SOXR_ROLLOFF_MEDIUM ; 130 } 131else {/* TODO: move to soxr-lsr.c */ 132static float const bw []= {.931f ,.832f ,.663f }; 133p -> passband_end = bw [quality - SOXR_LSR0Q ]; 134if (quality == SOXR_LSR2Q ) { 135p -> flags &= ~SOXR_ROLLOFF_NONE ; 136p -> flags |=SOXR_ROLLOFF_LSR2Q |SOXR_PROMOTE_TO_LQ ; 137 } 138 } 139if (recipe & SOXR_STEEP_FILTER ) 140p -> passband_end = 1 - .01 /lsx_to_3dB (rej ); 141return spec ; 142} 143 144 145 146char const * soxr_engine (soxr_t p ) 147{ 148return resampler_id (); 149} 150 151 152 153size_t * soxr_num_clips (soxr_t p ) 154{ 155return & p -> clips ; 156} 157 158 159 160soxr_error_t soxr_error (soxr_t p ) 161{ 162return p -> error ; 163} 164 165 166 167soxr_runtime_spec_t soxr_runtime_spec (unsigned num_threads ) 168{ 169soxr_runtime_spec_t spec ,* p = & spec ; 170memset (p ,0 ,sizeof (* p )); 171p -> log2_min_dft_size = 10 ; 172p -> log2_large_dft_size = 17 ; 173p -> coef_size_kbytes = 400 ; 174p -> num_threads = num_threads ; 175return spec ; 176} 177 178 179 180soxr_io_spec_t soxr_io_spec ( 181soxr_datatype_t itype , 182soxr_datatype_t otype ) 183{ 184soxr_io_spec_t spec ,* p = & spec ; 185memset (p ,0 ,sizeof (* p )); 186if ((itype |otype ) >=SOXR_SPLIT * 2 ) 187p -> e = "invalid io datatype(s)" ; 188else { 189p -> itype = itype ; 190p -> otype = otype ; 191p -> scale = 1 ; 192 } 193return spec ; 194} 195 196 197 198#if (WITH_CR32S && WITH_CR32 )|| (WITH_CR64S && WITH_CR64 ) 199#if defined__GNUC__ && defined__x86_64__ 200#define CPUID (type ,eax_ ,ebx_ ,ecx_ ,edx_ ) \ 201 __asm__ __volatile__ ( \ 202 "cpuid \n\t" \ 203 : "=a" (eax_), "=b" (ebx_), "=c" (ecx_), "=d" (edx_) \ 204 : "a" (type), "c" (0)); 205#elif defined__GNUC__ && defined__i386__ 206#define CPUID (type ,eax_ ,ebx_ ,ecx_ ,edx_ ) \ 207 __asm__ __volatile__ ( \ 208 "mov %%ebx, %%edi \n\t" \ 209 "cpuid \n\t" \ 210 "xchg %%edi, %%ebx \n\t" \ 211 : "=a" (eax_), "=D" (ebx_), "=c" (ecx_), "=d" (edx_) \ 212 : "a" (type), "c" (0)); 213#elif defined_M_X64 && defined_MSC_VER && _MSC_VER > 1500 214void __cpuidex (int CPUInfo [4 ],int info_type ,int ecxvalue ); 215#pragma intrinsic(__cpuidex) 216#define CPUID (type ,eax_ ,ebx_ ,ecx_ ,edx_ ) do { \ 217 int regs[4]; \ 218 __cpuidex(regs, type, 0); \ 219 eax_ = regs[0], ebx_ = regs[1], ecx_ = regs[2], edx_ = regs[3]; \ 220 } while(0) 221#elif defined_M_X64 && defined_MSC_VER 222void __cpuidex (int CPUInfo [4 ],int info_type ); 223#pragma intrinsic(__cpuidex) 224#define CPUID (type ,eax_ ,ebx_ ,ecx_ ,edx_ ) do { \ 225 int regs[4]; \ 226 __cpuidex(regs, type); \ 227 eax_ = regs[0], ebx_ = regs[1], ecx_ = regs[2], edx_ = regs[3]; \ 228 } while(0) 229#elif defined_M_IX86 && defined_MSC_VER 230#define CPUID (type ,eax_ ,ebx_ ,ecx_ ,edx_ ) \ 231 __asm pushad \ 232 __asm mov eax, type \ 233 __asm xor ecx, ecx \ 234 __asm cpuid \ 235 __asm mov eax_, eax \ 236 __asm mov ebx_, ebx \ 237 __asm mov ecx_, ecx \ 238 __asm mov edx_, edx \ 239 __asm popad 240#endif 241#endif 242 243 244 245#if WITH_CR32S && WITH_CR32 246static bool cpu_has_simd32 (void ) 247 { 248#if defined__x86_64__ || defined_M_X64 249return true; 250#elif defined__i386__ || defined_M_IX86 251enum {SSE = 1 <<25 ,SSE2 = 1 <<26 }; 252unsigned eax_ ,ebx_ ,ecx_ ,edx_ ; 253CPUID (1 ,eax_ ,ebx_ ,ecx_ ,edx_ ); 254return (edx_ & (SSE |SSE2 ))!= 0 ; 255#elif definedAV_CPU_FLAG_NEON 256return !!(av_get_cpu_flags ()& AV_CPU_FLAG_NEON ); 257#else 258return false; 259#endif 260 } 261 262static bool should_use_simd32 (void ) 263 { 264char const * e ; 265return ((e = getenv ("SOXR_USE_SIMD" )))? !!atoi (e ) : 266 ((e = getenv ("SOXR_USE_SIMD32" )))? !!atoi (e ) :cpu_has_simd32 (); 267 } 268#else 269#define should_use_simd32 () true 270#endif 271 272 273 274#if WITH_CR64S && WITH_CR64 275#if defined__GNUC__ 276#define XGETBV (type ,eax_ ,edx_ ) \ 277 __asm__ __volatile__ ( \ 278 ".byte 0x0f, 0x01, 0xd0\n" \ 279 : "=a"(eax_), "=d"(edx_) : "c" (type)); 280#elif defined_M_X64 && defined_MSC_FULL_VER && _MSC_FULL_VER >=160040219 281#include <immintrin.h> 282#define XGETBV (type ,eax_ ,edx_ ) do { \ 283 union {uint64_t x; uint32_t y[2];} a = {_xgetbv(0)}; \ 284 eax_ = a.y[0], edx_ = a.y[1]; \ 285 } while(0) 286#elif defined_M_IX86 && defined_MSC_VER 287#define XGETBV (type ,eax_ ,edx_ ) \ 288 __asm pushad \ 289 __asm mov ecx, type \ 290 __asm _emit 0x0f \ 291 __asm _emit 0x01 \ 292 __asm _emit 0xd0 \ 293 __asm mov eax_, eax \ 294 __asm mov edx_, edx \ 295 __asm popad 296#else 297#define XGETBV (type ,eax_ ,edx_ ) eax_ = edx_ = 0 298#endif 299 300static bool cpu_has_simd64 (void ) 301 { 302enum {OSXSAVE = 1 <<27 ,AVX = 1 <<28 }; 303unsigned eax_ ,ebx_ ,ecx_ ,edx_ ; 304CPUID (1 ,eax_ ,ebx_ ,ecx_ ,edx_ ); 305if ((ecx_ & (OSXSAVE |AVX ))== (OSXSAVE |AVX )) { 306XGETBV (0 ,eax_ ,edx_ ); 307return (eax_ & 6 )== 6 ; 308 } 309return false; 310 } 311 312static bool should_use_simd64 (void ) 313 { 314char const * e ; 315return ((e = getenv ("SOXR_USE_SIMD" )))? !!atoi (e ) : 316 ((e = getenv ("SOXR_USE_SIMD64" )))? !!atoi (e ) :cpu_has_simd64 (); 317 } 318#else 319#define should_use_simd64 () true 320#endif 321 322 323 324extern control_block_t 325_soxr_rate32_cb , 326_soxr_rate32s_cb , 327_soxr_rate64_cb , 328_soxr_rate64s_cb , 329_soxr_vr32_cb ; 330 331 332 333static void runtime_num (char const * env_name , 334int min ,int max ,unsigned * field ) 335{ 336char const * e = getenv (env_name ); 337if (e ) { 338int i = atoi (e ); 339if (i >=min && i <=max ) 340* field = (unsigned )i ; 341 } 342} 343 344 345 346static void runtime_flag (char const * env_name , 347unsigned n_bits ,unsigned n_shift ,unsigned long * flags ) 348{ 349char const * e = getenv (env_name ); 350if (e ) { 351int i = atoi (e ); 352unsigned long mask = (1UL <<n_bits )- 1 ; 353if (i >=0 && i <= (int )mask ) 354* flags &= ~(mask <<n_shift ),* flags |= ((unsigned long )i <<n_shift ); 355 } 356} 357 358 359 360soxr_t soxr_create ( 361double input_rate ,double output_rate , 362unsigned num_channels , 363soxr_error_t * error0 , 364soxr_io_spec_t const * io_spec , 365soxr_quality_spec_t const * q_spec , 366soxr_runtime_spec_t const * runtime_spec ) 367{ 368double io_ratio = output_rate != 0 ?input_rate != 0 ? 369input_rate /output_rate :-1 :input_rate != 0 ?-1 :0 ; 370static const float datatype_full_scale []= {1 ,1 ,65536. * 32768 ,32768 }; 371soxr_t p = 0 ; 372soxr_error_t error = 0 ; 373 374#if WITH_DEV_TRACE 375#define _ (x ) (char)(sizeof(x)>=10? 'a'+(char)(sizeof(x)-10):'0'+(char)sizeof(x)) 376char const * e = getenv ("SOXR_TRACE" ); 377_soxr_trace_level = e ?atoi (e ) :0 ; 378 { 379static char const arch []= {_ (char ),_ (short ),_ (int ),_ (long ),_ (long long ) 380 ,' ' ,_ (float ),_ (double ),_ (long double ) 381 ,' ' ,_ (int * ), _ ( int ( * )(int)) 382, ' ' , HAVE_BIGENDIAN ? 'B' : 'L' 383#if defined _OPENMP 384, ' ' , 'O' , 'M' , 'P' 385#endif 386, 0 }; 387#undef _ 388lsx_debug ( "arch: %s" , arch); 389} 390#endif 391 392if (q_spec && q_spec -> e ) error = q_spec -> e ; 393else if (io_spec && (io_spec -> itype | io_spec -> otype ) >= SOXR_SPLIT * 2 ) 394error = "invalid io datatype(s)" ; 395 396if (!error && !(p = calloc ( sizeof ( * p), 1 ))) error = "malloc failed" ; 397 398if (p) { 399control_block_t * control_block; 400 401p -> q_spec = q_spec? * q_spec : soxr_quality_spec ( SOXR_HQ , 0 ); 402 403if (q_spec) { /* Backwards compatibility with original API: */ 404if (p -> q_spec . passband_end > 2 ) 405p -> q_spec . passband_end /= 100 ; 406if (p -> q_spec . stopband_begin > 2 ) 407p -> q_spec . stopband_begin = 2 - p -> q_spec . stopband_begin / 100 ; 408} 409 410p -> io_ratio = io_ratio; 411p -> num_channels = num_channels; 412if (io_spec) 413p -> io_spec = * io_spec; 414else 415p -> io_spec . scale = 1 ; 416 417p -> runtime_spec = runtime_spec? * runtime_spec : soxr_runtime_spec ( 1 ); 418 419runtime_num ( "SOXR_MIN_DFT_SIZE" , 8 , 15 , & p -> runtime_spec . log2_min_dft_size ); 420runtime_num ( "SOXR_LARGE_DFT_SIZE" , 8 , 20 , & p -> runtime_spec . log2_large_dft_size ); 421runtime_num ( "SOXR_COEFS_SIZE" , 100 , 800 , & p -> runtime_spec . coef_size_kbytes ); 422runtime_num ( "SOXR_NUM_THREADS" , 0 , 64 , & p -> runtime_spec . num_threads ); 423runtime_flag ( "SOXR_COEF_INTERP" , 2 , 0 , & p -> runtime_spec . flags ); 424 425runtime_flag ( "SOXR_STRICT_BUF" , 1 , 2 , & p -> runtime_spec . flags ); 426runtime_flag ( "SOXR_NOSMALLINTOPT" , 1 , 3 , & p -> runtime_spec . flags ); 427 428p -> io_spec . scale *= datatype_full_scale[p -> io_spec . otype & 3 ] / 429datatype_full_scale[p -> io_spec . itype & 3 ]; 430 431p -> seed = ( unsigned long ) time ( 0 ) ^ ( unsigned long )( size_t )p; 432 433#if WITH_CR32 || WITH_CR32S || WITH_VR32 434if ( 0 435#if WITH_VR32 436|| ((! WITH_CR32 && ! WITH_CR32S ) || (p -> q_spec . flags & SOXR_VR )) 437#endif 438#if WITH_CR32 || WITH_CR32S 439|| !( WITH_CR64 || WITH_CR64S ) || (p -> q_spec . precision <= 20 && !(p -> q_spec . flags & SOXR_DOUBLE_PRECISION )) 440#endif 441) { 442p -> deinterleave = ( deinterleave_t )_soxr_deinterleave_f; 443p -> interleave = ( interleave_t )_soxr_interleave_f; 444control_block = 445#if WITH_VR32 446((! WITH_CR32 && ! WITH_CR32S ) || (p -> q_spec . flags & SOXR_VR ))? & _soxr_vr32_cb : 447#endif 448#if WITH_CR32S 449! WITH_CR32 || should_use_simd32 ()? & _soxr_rate32s_cb : 450#endif 451& _soxr_rate32_cb; 452} 453#if WITH_CR64 || WITH_CR64S 454else 455#endif 456#endif 457#if WITH_CR64 || WITH_CR64S 458{ 459p -> deinterleave = ( deinterleave_t )_soxr_deinterleave; 460p -> interleave = ( interleave_t )_soxr_interleave; 461control_block = 462#if WITH_CR64S 463! WITH_CR64 || should_use_simd64 ()? & _soxr_rate64s_cb : 464#endif 465& _soxr_rate64_cb; 466} 467#endif 468memcpy ( & p -> control_block , control_block , sizeof( p -> control_block )); 469 470if ( p -> num_channels && io_ratio != 0 ) 471error = soxr_set_io_ratio ( p , io_ratio , 0 ); 472} 473if ( error ) 474soxr_delete ( p ), p = 0 ; 475if ( error0 ) 476* error0 = error ; 477return p ; 478} 479 480 481 482soxr_error_t soxr_set_input_fn ( soxr_t p , 483soxr_input_fn_t input_fn , void * input_fn_state , size_t max_ilen ) 484{ 485p -> input_fn_state = input_fn_state ; 486p -> input_fn = input_fn ; 487p -> max_ilen = max_ilen ? max_ilen : ( size_t ) -1 ; 488return 0 ; 489} 490 491 492 493static void soxr_delete0 ( soxr_t p ) 494{ 495unsigned i ; 496 497if ( p -> resamplers ) for ( i = 0 ; i < p -> num_channels ; ++ i ) { 498if ( p -> resamplers [ i ]) 499resampler_close ( p -> resamplers [ i ]); 500free ( p -> resamplers [ i ]); 501} 502free ( p -> resamplers ); 503free ( p -> channel_ptrs ); 504free ( p -> shared ); 505 506memset ( p , 0 , sizeof( * p )); 507} 508 509 510 511double soxr_delay ( soxr_t p ) 512{ 513return 514( p && ! p -> error && p -> resamplers )? resampler_delay ( p -> resamplers [ 0 ]) : 0 ; 515} 516 517 518 519static soxr_error_t fatal_error ( soxr_t p , soxr_error_t error ) 520{ 521soxr_delete0 ( p ); 522return p -> error = error ; 523} 524 525 526 527static soxr_error_t initialise ( soxr_t p ) 528{ 529unsigned i ; 530size_t shared_size , channel_size ; 531 532resampler_sizes ( & shared_size , & channel_size ); 533p -> channel_ptrs = calloc (sizeof( * p -> channel_ptrs ), p -> num_channels ); 534p -> shared = calloc ( shared_size , 1 ); 535p -> resamplers = calloc (sizeof( * p -> resamplers ), p -> num_channels ); 536if (! p -> shared || ! p -> channel_ptrs || ! p -> resamplers ) 537return fatal_error ( p , "malloc failed" ); 538 539for ( i = 0 ; i < p -> num_channels ; ++ i ) { 540soxr_error_t error ; 541if (!( p -> resamplers [ i ] = calloc ( channel_size , 1 ))) 542return fatal_error ( p , "malloc failed" ); 543error = resampler_create ( 544p -> resamplers [ i ], 545p -> shared , 546p -> io_ratio , 547& p -> q_spec , 548& p -> runtime_spec , 549p -> io_spec . scale ); 550if ( error ) 551return fatal_error ( p , error ); 552} 553return 0 ; 554} 555 556 557 558soxr_error_t soxr_set_num_channels ( soxr_t p , unsigned num_channels ) 559{ 560if (! p ) return "invalid soxr_t pointer" ; 561if ( num_channels == p -> num_channels ) return p -> error ; 562if (! num_channels ) return "invalid # of channels" ; 563if ( p -> resamplers ) return "# of channels can't be changed" ; 564p -> num_channels = num_channels ; 565return soxr_set_io_ratio ( p , p -> io_ratio , 0 ); 566} 567 568 569 570soxr_error_t soxr_set_io_ratio ( soxr_t p , double io_ratio , size_t slew_len ) 571{ 572unsigned i ; 573soxr_error_t error ; 574if (! p ) return "invalid soxr_t pointer" ; 575if (( error = p -> error )) return error ; 576if (! p -> num_channels ) return "must set # channels before O/I ratio" ; 577if ( io_ratio <= 0 ) return "I/O ratio out-of-range" ; 578if (! p -> channel_ptrs ) { 579p -> io_ratio = io_ratio ; 580return initialise ( p ); 581} 582if ( p -> control_block [ 8 ]) { 583for ( i = 0 ; ! error && i < p -> num_channels ; ++ i ) 584resampler_set_io_ratio ( p -> resamplers [ i ], io_ratio , slew_len ); 585return error ; 586} 587return fabs ( p -> io_ratio - io_ratio ) < 1e-15 ? 0 : 588"varying O/I ratio is not supported with this quality level" ; 589} 590 591 592 593void soxr_delete ( soxr_t p ) 594{ 595if ( p ) 596soxr_delete0 ( p ), free ( p ); 597} 598 599 600 601soxr_error_t soxr_clear ( soxr_t p ) /* TODO: this, properly. */ 602{ 603if ( p ) { 604struct soxr tmp = * p ; 605soxr_delete0 ( p ); 606memset ( p , 0 , sizeof( * p )); 607p -> input_fn = tmp . input_fn ; 608p -> runtime_spec = tmp . runtime_spec ; 609p -> q_spec = tmp . q_spec ; 610p -> io_spec = tmp . io_spec ; 611p -> num_channels = tmp . num_channels ; 612p -> input_fn_state = tmp . input_fn_state ; 613memcpy ( p -> control_block , tmp . control_block , sizeof( p -> control_block )); 614p -> deinterleave = tmp . deinterleave ; 615p -> interleave = tmp . interleave ; 616return ( p -> q_spec . flags & RESET_ON_CLEAR )? 617soxr_set_io_ratio ( p , tmp . io_ratio , 0 ) : 0 ; 618} 619return "invalid soxr_t pointer" ; 620} 621 622 623 624static void soxr_input_1ch ( soxr_t p , unsigned i , soxr_cbuf_t src , size_t len ) 625{ 626sample_t * dest = resampler_input ( p -> resamplers [ i ], NULL , len ); 627( * p -> deinterleave )( & dest , p -> io_spec . itype , & src , len , 1 ); 628} 629 630 631 632static size_t soxr_input ( soxr_t p , void const * in , size_t len ) 633{ 634bool separated = !!( p -> io_spec . itype & SOXR_SPLIT ); 635unsigned i ; 636if (! p || p -> error ) return 0 ; 637if (! in && len ) { p -> error = "null input buffer pointer" ; return 0 ;} 638if (! len ) { 639p -> flushing = true; 640return 0 ; 641} 642if ( separated ) 643for ( i = 0 ; i < p -> num_channels ; ++ i ) 644soxr_input_1ch ( p , i , (( soxr_cbufs_t ) in )[ i ], len ); 645else { 646for ( i = 0 ; i < p -> num_channels ; ++ i ) 647p -> channel_ptrs [ i ] = resampler_input ( p -> resamplers [ i ], NULL , len ); 648( * p -> deinterleave )( 649( sample_t ** ) p -> channel_ptrs , p -> io_spec . itype , & in , len , p -> num_channels ); 650} 651return len ; 652} 653 654 655 656static size_t soxr_output_1ch ( soxr_t p , unsigned i , soxr_buf_t dest , size_t len , bool separated ) 657{ 658sample_t const * src ; 659if ( p -> flushing ) 660resampler_flush ( p -> resamplers [ i ]); 661resampler_process ( p -> resamplers [ i ], len ); 662src = resampler_output ( p -> resamplers [ i ], NULL , & len ); 663if ( separated ) 664p -> clips += ( p -> interleave )( p -> io_spec . otype , & dest , & src , 665len , 1 , ( p -> io_spec . flags & SOXR_NO_DITHER )? 0 : & p -> seed ); 666else p -> channel_ptrs [ i ] = ( void /* const */ * ) src ; 667return len ; 668} 669 670 671 672static size_t soxr_output_no_callback ( soxr_t p , soxr_buf_t out , size_t len ) 673{ 674unsigned u ; 675size_t done = 0 ; 676bool separated = !!( p -> io_spec . otype & SOXR_SPLIT ); 677#if defined _OPENMP 678int i ; 679if (! p -> runtime_spec . num_threads && p -> num_channels > 1 ) 680#pragma omp parallel for 681for ( i = 0 ; i < ( int ) p -> num_channels ; ++ i ) { 682size_t done1 ; 683done1 = soxr_output_1ch ( p , ( unsigned ) i , (( soxr_bufs_t ) out )[ i ], len , separated ); 684if (! i ) 685done = done1 ; 686} else 687#endif 688for ( u = 0 ; u < p -> num_channels ; ++ u ) 689done = soxr_output_1ch ( p , u , (( soxr_bufs_t ) out )[ u ], len , separated ); 690 691if (! separated ) 692p -> clips += ( p -> interleave )( p -> io_spec . otype , & out , ( sample_t const * const * ) p -> channel_ptrs , 693done , p -> num_channels , ( p -> io_spec . flags & SOXR_NO_DITHER )? 0 : & p -> seed ); 694return done ; 695} 696 697 698 699size_t soxr_output ( soxr_t p , void * out , size_t len0 ) 700{ 701size_t odone , odone0 = 0 , olen = len0 , osize , idone ; 702size_t ilen = min ( p -> max_ilen , ( size_t ) ceil (( double ) olen * p -> io_ratio )); 703void const * in = out ; /* Set to !=0, so that caller may leave unset. */ 704bool was_flushing ; 705 706if (! p || p -> error ) return 0 ; 707if (! out && len0 ) { p -> error = "null output buffer pointer" ; return 0 ;} 708 709do { 710odone = soxr_output_no_callback ( p , out , olen ); 711odone0 += odone ; 712if ( odone0 == len0 || ! p -> input_fn || p -> flushing ) 713break; 714 715osize = soxr_datatype_size ( p -> io_spec . otype ) * p -> num_channels ; 716out = ( char * ) out + osize * odone ; 717olen -= odone ; 718idone = p -> input_fn ( p -> input_fn_state , & in , ilen ); 719was_flushing = p -> flushing ; 720if (! in ) 721p -> error = "input function reported failure" ; 722else soxr_input ( p , in , idone ); 723} while ( odone || idone || (! was_flushing && p -> flushing )); 724return odone0 ; 725} 726 727 728 729static size_t soxr_i_for_o ( soxr_t p , size_t olen , size_t ilen ) 730{ 731size_t result ; 732#if 0 733if ( p -> runtime_spec . flags & SOXR_STRICT_BUFFERING ) 734result = rate_i_for_o ( p -> resamplers [ 0 ], olen ); 735else 736#endif 737result = ( size_t ) ceil (( double ) olen * p -> io_ratio ); 738return min ( result , ilen ); 739} 740 741 742 743#if 0 744static size_t soxr_o_for_i ( soxr_t p , size_t ilen , size_t olen ) 745{ 746size_t result = ( size_t ) ceil (( double ) ilen / p -> io_ratio ); 747return min ( result , olen ); 748} 749#endif 750 751 752 753soxr_error_t soxr_process ( soxr_t p , 754void const * in , size_t ilen0 , size_t * idone0 , 755void * out , size_t olen , size_t * odone0 ) 756{ 757size_t ilen , idone , odone = 0 ; 758unsigned u ; 759bool flush_requested = false; 760 761if (! p ) return "null pointer" ; 762 763if (! in ) 764flush_requested = true, ilen = ilen0 = 0 ; 765else { 766if (( ptrdiff_t ) ilen0 < 0 ) 767flush_requested = true, ilen0 = ~ ilen0 ; 768if ( idone0 && ( 1 || flush_requested )) 769ilen = soxr_i_for_o ( p , olen , ilen0 ); 770else 771ilen = ilen0 /*, olen = soxr_o_for_i(p, ilen, olen)*/ ; 772} 773p -> flushing |= ilen == ilen0 && flush_requested ; 774 775if (! out && ! in ) 776idone = ilen ; 777else if ( p -> io_spec . itype & p -> io_spec . otype & SOXR_SPLIT ) { /* Both i & o */ 778#if defined _OPENMP 779int i ; 780if (! p -> runtime_spec . num_threads && p -> num_channels > 1 ) 781#pragma omp parallel for 782for ( i = 0 ; i < ( int ) p -> num_channels ; ++ i ) { 783size_t done ; 784if ( in ) 785soxr_input_1ch ( p , ( unsigned ) i , (( soxr_cbufs_t ) in )[ i ], ilen ); 786done = soxr_output_1ch ( p , ( unsigned ) i , (( soxr_bufs_t ) out )[ i ], olen , true); 787if (! i ) 788odone = done ; 789} else 790#endif 791for ( u = 0 ; u < p -> num_channels ; ++ u ) { 792if ( in ) 793soxr_input_1ch ( p , u , (( soxr_cbufs_t ) in )[ u ], ilen ); 794odone = soxr_output_1ch ( p , u , (( soxr_bufs_t ) out )[ u ], olen , true); 795} 796idone = ilen ; 797} 798else { 799idone = ilen ? soxr_input ( p , in , ilen ) : 0 ; 800odone = soxr_output ( p , out , olen ); 801} 802if ( idone0 ) * idone0 = idone ; 803if ( odone0 ) * odone0 = odone ; 804return p -> error ; 805} 806 807 808 809soxr_error_t soxr_oneshot ( 810double irate , double orate , 811unsigned num_channels , 812void const * in , size_t ilen , size_t * idone , 813void * out , size_t olen , size_t * odone , 814soxr_io_spec_t const * io_spec , 815soxr_quality_spec_t const * q_spec , 816soxr_runtime_spec_t const * runtime_spec ) 817{ 818soxr_t resampler ; 819soxr_error_t error = q_spec ? q_spec -> e : 0 ; 820if (! error ) { 821soxr_quality_spec_t q_spec1 ; 822if (! q_spec ) 823q_spec1 = soxr_quality_spec ( SOXR_LQ , 0 ), q_spec = & q_spec1 ; 824resampler = soxr_create ( irate , orate , num_channels , 825& error , io_spec , q_spec , runtime_spec ); 826} 827if (! error ) { 828error = soxr_process ( resampler , in , ~ ilen , idone , out , olen , odone ); 829soxr_delete ( resampler ); 830} 831return error ; 832} 833 834 835 836soxr_error_t soxr_set_error ( soxr_t p , soxr_error_t error ) 837{ 838if (! p ) return "null pointer" ; 839if (! p -> error && p -> error != error ) return p -> error ; 840p -> error = error ; 841return 0 ; 842}