fork/rust-sdks

git clone https://git.julia.blue/fork/rust-sdks

Théo Monnomsoxr-sys (#438)2e4d385

livekit/livekit-ffi@0.13.0
22.3 KiB842 linesraw
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{
28  va_list args;
29  va_start(args, fmt);
30  vfprintf(stderr, fmt, args);
31  fputc('\n', stderr);
32  va_end(args);
33}
34
35#endif
36
37
38
39char const * soxr_version(void)
40{
41  return "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,
65    soxr_datatype_t data_type, void const * * src0, size_t n, unsigned ch);
66typedef size_t (* interleave_t)(soxr_datatype_t data_type, void * * dest,
67    sample_t const * const * src, size_t, unsigned, unsigned long *);
68
69struct soxr {
70  unsigned num_channels;
71  double io_ratio;
72  soxr_error_t error;
73  soxr_quality_spec_t q_spec;
74  soxr_io_spec_t io_spec;
75  soxr_runtime_spec_t runtime_spec;
76
77  void * input_fn_state;
78  soxr_input_fn_t input_fn;
79  size_t max_ilen;
80
81  resampler_shared_t shared;
82  resampler_t * resamplers;
83  control_block_t control_block;
84  deinterleave_t deinterleave;
85  interleave_t interleave;
86
87  void * * channel_ptrs;
88  size_t clips;
89  unsigned long seed;
90  int 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{
105  soxr_quality_spec_t spec, * p = &spec;
106  unsigned q = recipe & 0xf;                         /* TODO: move to soxr-lsr.c: */
107  unsigned quality = q > SOXR_LSR2Q+2? SOXR_VHQ : q > SOXR_LSR2Q? SOXR_QQ : q;
108  double rej;
109  memset(p, 0, sizeof(*p));
110  if (quality > SOXR_PRECISIONQ) {
111    p->e = "invalid quality type";
112    return spec;
113  }
114  flags |= quality < SOXR_LSR0Q ? RESET_ON_CLEAR : 0;
115  p->phase_response = "\62\31\144"[(recipe & 0x30)>>4];
116  p->stopband_begin = 1;
117  p->precision =
118    quality == SOXR_QQ      ?  0 :
119    quality <= SOXR_16_BITQ ? 16 :
120    quality <= SOXR_32_BITQ ?  4 + quality * 4 :
121    quality <= SOXR_LSR2Q   ? 55 - quality * 4 : /* TODO: move to soxr-lsr.c */
122    0;
123  rej = p->precision * linear_to_dB(2.);
124  p->flags = flags;
125  if (quality <= SOXR_32_BITQ || quality == SOXR_PRECISIONQ) {
126    #define LOW_Q_BW0     (1385 / 2048.) /* 0.67625 rounded to be a FP exact. */
127    p->passband_end = quality == 1? LOW_Q_BW0 : 1 - .05 / lsx_to_3dB(rej);
128    if (quality <= 2)
129      p->flags &= ~SOXR_ROLLOFF_NONE, p->flags |= SOXR_ROLLOFF_MEDIUM;
130  }
131  else { /* TODO: move to soxr-lsr.c */
132    static float const bw[] = {.931f, .832f, .663f};
133    p->passband_end = bw[quality - SOXR_LSR0Q];
134    if (quality == SOXR_LSR2Q) {
135      p->flags &= ~SOXR_ROLLOFF_NONE;
136      p->flags |= SOXR_ROLLOFF_LSR2Q | SOXR_PROMOTE_TO_LQ;
137    }
138  }
139  if (recipe & SOXR_STEEP_FILTER)
140    p->passband_end = 1 - .01 / lsx_to_3dB(rej);
141  return spec;
142}
143
144
145
146char const * soxr_engine(soxr_t p)
147{
148  return resampler_id();
149}
150
151
152
153size_t * soxr_num_clips(soxr_t p)
154{
155  return &p->clips;
156}
157
158
159
160soxr_error_t soxr_error(soxr_t p)
161{
162  return p->error;
163}
164
165
166
167soxr_runtime_spec_t soxr_runtime_spec(unsigned num_threads)
168{
169  soxr_runtime_spec_t spec, * p = &spec;
170  memset(p, 0, sizeof(*p));
171  p->log2_min_dft_size = 10;
172  p->log2_large_dft_size = 17;
173  p->coef_size_kbytes = 400;
174  p->num_threads = num_threads;
175  return spec;
176}
177
178
179
180soxr_io_spec_t soxr_io_spec(
181  soxr_datatype_t itype,
182  soxr_datatype_t otype)
183{
184  soxr_io_spec_t spec, * p = &spec;
185  memset(p, 0, sizeof(*p));
186  if ((itype | otype) >= SOXR_SPLIT * 2)
187    p->e = "invalid io datatype(s)";
188  else {
189    p->itype = itype;
190    p->otype = otype;
191    p->scale = 1;
192  }
193  return 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
214     void __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
222     void __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
246  static bool cpu_has_simd32(void)
247  {
248  #if defined __x86_64__ || defined _M_X64
249    return true;
250  #elif defined __i386__ || defined _M_IX86
251    enum {SSE = 1 << 25, SSE2 = 1 << 26};
252    unsigned eax_, ebx_, ecx_, edx_;
253    CPUID(1, eax_, ebx_, ecx_, edx_);
254    return (edx_ & (SSE|SSE2)) != 0;
255  #elif defined AV_CPU_FLAG_NEON
256    return !!(av_get_cpu_flags() & AV_CPU_FLAG_NEON);
257  #else
258    return false;
259  #endif
260  }
261
262  static bool should_use_simd32(void)
263  {
264    char const * e;
265    return ((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
300  static bool cpu_has_simd64(void)
301  {
302    enum {OSXSAVE = 1 << 27, AVX = 1 << 28};
303    unsigned eax_, ebx_, ecx_, edx_;
304    CPUID(1, eax_, ebx_, ecx_, edx_);
305    if ((ecx_ & (OSXSAVE|AVX)) == (OSXSAVE|AVX)) {
306      XGETBV(0, eax_, edx_);
307      return (eax_ & 6) == 6;
308    }
309    return false;
310  }
311
312  static bool should_use_simd64(void)
313  {
314    char const * e;
315    return ((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,
334    int min, int max, unsigned * field)
335{
336  char const * e = getenv(env_name);
337  if (e) {
338    int i = atoi(e);
339    if (i >= min && i <= max)
340      *field = (unsigned)i;
341  }
342}
343
344
345
346static void runtime_flag(char const * env_name,
347    unsigned n_bits, unsigned n_shift, unsigned long * flags)
348{
349  char const * e = getenv(env_name);
350  if (e) {
351    int i = atoi(e);
352    unsigned long mask = (1UL << n_bits) - 1;
353    if (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(
361  double input_rate, double output_rate,
362  unsigned num_channels,
363  soxr_error_t * error0,
364  soxr_io_spec_t const * io_spec,
365  soxr_quality_spec_t const * q_spec,
366  soxr_runtime_spec_t const * runtime_spec)
367{
368  double io_ratio = output_rate!=0? input_rate!=0?
369    input_rate / output_rate : -1 : input_rate!=0? -1 : 0;
370  static const float datatype_full_scale[] = {1, 1, 65536.*32768, 32768};
371  soxr_t p = 0;
372  soxr_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))
376  char const * e = getenv("SOXR_TRACE");
377  _soxr_trace_level = e? atoi(e) : 0;
378  {
379    static 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 _
388    lsx_debug("arch: %s", arch);
389  }
390#endif
391
392  if (q_spec && q_spec->e)  error = q_spec->e;
393  else if (io_spec && (io_spec->itype | io_spec->otype) >= SOXR_SPLIT * 2)
394    error = "invalid io datatype(s)";
395
396  if (!error && !(p = calloc(sizeof(*p), 1))) error = "malloc failed";
397
398  if (p) {
399    control_block_t * control_block;
400
401    p->q_spec = q_spec? *q_spec : soxr_quality_spec(SOXR_HQ, 0);
402
403    if (q_spec) { /* Backwards compatibility with original API: */
404      if (p->q_spec.passband_end > 2)
405        p->q_spec.passband_end /= 100;
406      if (p->q_spec.stopband_begin > 2)
407        p->q_spec.stopband_begin = 2 - p->q_spec.stopband_begin / 100;
408    }
409
410    p->io_ratio = io_ratio;
411    p->num_channels = num_channels;
412    if (io_spec)
413      p->io_spec = *io_spec;
414    else
415      p->io_spec.scale = 1;
416
417    p->runtime_spec = runtime_spec? *runtime_spec : soxr_runtime_spec(1);
418
419    runtime_num("SOXR_MIN_DFT_SIZE", 8, 15, &p->runtime_spec.log2_min_dft_size);
420    runtime_num("SOXR_LARGE_DFT_SIZE", 8, 20, &p->runtime_spec.log2_large_dft_size);
421    runtime_num("SOXR_COEFS_SIZE", 100, 800, &p->runtime_spec.coef_size_kbytes);
422    runtime_num("SOXR_NUM_THREADS", 0, 64, &p->runtime_spec.num_threads);
423    runtime_flag("SOXR_COEF_INTERP", 2, 0, &p->runtime_spec.flags);
424
425    runtime_flag("SOXR_STRICT_BUF", 1, 2, &p->runtime_spec.flags);
426    runtime_flag("SOXR_NOSMALLINTOPT", 1, 3, &p->runtime_spec.flags);
427
428    p->io_spec.scale *= datatype_full_scale[p->io_spec.otype & 3] /
429                        datatype_full_scale[p->io_spec.itype & 3];
430
431    p->seed = (unsigned long)time(0) ^ (unsigned long)(size_t)p;
432
433#if WITH_CR32 || WITH_CR32S || WITH_VR32
434    if (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        ) {
442      p->deinterleave = (deinterleave_t)_soxr_deinterleave_f;
443      p->interleave = (interleave_t)_soxr_interleave_f;
444      control_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
454    else
455#endif
456#endif
457#if WITH_CR64 || WITH_CR64S
458    {
459      p->deinterleave = (deinterleave_t)_soxr_deinterleave;
460      p->interleave = (interleave_t)_soxr_interleave;
461      control_block =
462#if WITH_CR64S
463          !WITH_CR64 || should_use_simd64()? &_soxr_rate64s_cb :
464#endif
465          &_soxr_rate64_cb;
466    }
467#endif
468    memcpy(&p->control_block, control_block, sizeof(p->control_block));
469
470    if (p->num_channels && io_ratio!=0)
471      error = soxr_set_io_ratio(p, io_ratio, 0);
472  }
473  if (error)
474    soxr_delete(p), p = 0;
475  if (error0)
476    *error0 = error;
477  return p;
478}
479
480
481
482soxr_error_t soxr_set_input_fn(soxr_t p,
483    soxr_input_fn_t input_fn, void * input_fn_state, size_t max_ilen)
484{
485  p->input_fn_state = input_fn_state;
486  p->input_fn = input_fn;
487  p->max_ilen = max_ilen? max_ilen : (size_t)-1;
488  return 0;
489}
490
491
492
493static void soxr_delete0(soxr_t p)
494{
495  unsigned i;
496
497  if (p->resamplers) for (i = 0; i < p->num_channels; ++i) {
498    if (p->resamplers[i])
499      resampler_close(p->resamplers[i]);
500    free(p->resamplers[i]);
501  }
502  free(p->resamplers);
503  free(p->channel_ptrs);
504  free(p->shared);
505
506  memset(p, 0, sizeof(*p));
507}
508
509
510
511double soxr_delay(soxr_t p)
512{
513  return
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{
521  soxr_delete0(p);
522  return p->error = error;
523}
524
525
526
527static soxr_error_t initialise(soxr_t p)
528{
529  unsigned i;
530  size_t shared_size, channel_size;
531
532  resampler_sizes(&shared_size, &channel_size);
533  p->channel_ptrs = calloc(sizeof(*p->channel_ptrs), p->num_channels);
534  p->shared = calloc(shared_size, 1);
535  p->resamplers = calloc(sizeof(*p->resamplers), p->num_channels);
536  if (!p->shared || !p->channel_ptrs || !p->resamplers)
537    return fatal_error(p, "malloc failed");
538
539  for (i = 0; i < p->num_channels; ++i) {
540    soxr_error_t error;
541    if (!(p->resamplers[i] = calloc(channel_size, 1)))
542      return fatal_error(p, "malloc failed");
543    error = resampler_create(
544        p->resamplers[i],
545        p->shared,
546        p->io_ratio,
547        &p->q_spec,
548        &p->runtime_spec,
549        p->io_spec.scale);
550    if (error)
551      return fatal_error(p, error);
552  }
553  return 0;
554}
555
556
557
558soxr_error_t soxr_set_num_channels(soxr_t p, unsigned num_channels)
559{
560  if (!p)                return "invalid soxr_t pointer";
561  if (num_channels == p->num_channels) return p->error;
562  if (!num_channels)     return "invalid # of channels";
563  if (p->resamplers)     return "# of channels can't be changed";
564  p->num_channels = num_channels;
565  return 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{
572  unsigned i;
573  soxr_error_t error;
574  if (!p)                 return "invalid soxr_t pointer";
575  if ((error = p->error)) return error;
576  if (!p->num_channels)   return "must set # channels before O/I ratio";
577  if (io_ratio <= 0)      return "I/O ratio out-of-range";
578  if (!p->channel_ptrs) {
579    p->io_ratio = io_ratio;
580    return initialise(p);
581  }
582  if (p->control_block[8]) {
583    for (i = 0; !error && i < p->num_channels; ++i)
584      resampler_set_io_ratio(p->resamplers[i], io_ratio, slew_len);
585    return error;
586  }
587  return 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{
595  if (p)
596    soxr_delete0(p), free(p);
597}
598
599
600
601soxr_error_t soxr_clear(soxr_t p) /* TODO: this, properly. */
602{
603  if (p) {
604    struct soxr tmp = *p;
605    soxr_delete0(p);
606    memset(p, 0, sizeof(*p));
607    p->input_fn = tmp.input_fn;
608    p->runtime_spec = tmp.runtime_spec;
609    p->q_spec = tmp.q_spec;
610    p->io_spec = tmp.io_spec;
611    p->num_channels = tmp.num_channels;
612    p->input_fn_state = tmp.input_fn_state;
613    memcpy(p->control_block, tmp.control_block, sizeof(p->control_block));
614    p->deinterleave = tmp.deinterleave;
615    p->interleave = tmp.interleave;
616    return (p->q_spec.flags & RESET_ON_CLEAR)?
617      soxr_set_io_ratio(p, tmp.io_ratio, 0) : 0;
618  }
619  return "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{
626  sample_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{
634  bool separated = !!(p->io_spec.itype & SOXR_SPLIT);
635  unsigned i;
636  if (!p || p->error) return 0;
637  if (!in && len) {p->error = "null input buffer pointer"; return 0;}
638  if (!len) {
639    p->flushing = true;
640    return 0;
641  }
642  if (separated)
643    for (i = 0; i < p->num_channels; ++i)
644      soxr_input_1ch(p, i, ((soxr_cbufs_t)in)[i], len);
645  else {
646    for (i = 0; i < p->num_channels; ++i)
647      p->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  }
651  return 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{
658  sample_t const * src;
659  if (p->flushing)
660    resampler_flush(p->resamplers[i]);
661  resampler_process(p->resamplers[i], len);
662  src = resampler_output(p->resamplers[i], NULL, &len);
663  if (separated)
664    p->clips += (p->interleave)(p->io_spec.otype, &dest, &src,
665      len, 1, (p->io_spec.flags & SOXR_NO_DITHER)? 0 : &p->seed);
666  else p->channel_ptrs[i] = (void /* const */ *)src;
667  return len;
668}
669
670
671
672static size_t soxr_output_no_callback(soxr_t p, soxr_buf_t out, size_t len)
673{
674  unsigned u;
675  size_t done = 0;
676  bool separated = !!(p->io_spec.otype & SOXR_SPLIT);
677#if defined _OPENMP
678  int i;
679  if (!p->runtime_spec.num_threads && p->num_channels > 1)
680#pragma omp parallel for
681  for (i = 0; i < (int)p->num_channels; ++i) {
682    size_t done1;
683    done1 = soxr_output_1ch(p, (unsigned)i, ((soxr_bufs_t)out)[i], len, separated);
684    if (!i)
685      done = done1;
686  } else
687#endif
688  for (u = 0; u < p->num_channels; ++u)
689    done = soxr_output_1ch(p, u, ((soxr_bufs_t)out)[u], len, separated);
690
691  if (!separated)
692    p->clips += (p->interleave)(p->io_spec.otype, &out, (sample_t const * const *)p->channel_ptrs,
693        done, p->num_channels, (p->io_spec.flags & SOXR_NO_DITHER)? 0 : &p->seed);
694  return done;
695}
696
697
698
699size_t soxr_output(soxr_t p, void * out, size_t len0)
700{
701  size_t odone, odone0 = 0, olen = len0, osize, idone;
702  size_t ilen = min(p->max_ilen, (size_t)ceil((double)olen *p->io_ratio));
703  void const * in = out; /* Set to !=0, so that caller may leave unset. */
704  bool was_flushing;
705
706  if (!p || p->error) return 0;
707  if (!out && len0) {p->error = "null output buffer pointer"; return 0;}
708
709  do {
710    odone = soxr_output_no_callback(p, out, olen);
711    odone0 += odone;
712    if (odone0 == len0 || !p->input_fn || p->flushing)
713      break;
714
715    osize = soxr_datatype_size(p->io_spec.otype) * p->num_channels;
716    out = (char *)out + osize * odone;
717    olen -= odone;
718    idone = p->input_fn(p->input_fn_state, &in, ilen);
719    was_flushing = p->flushing;
720    if (!in)
721      p->error = "input function reported failure";
722    else soxr_input(p, in, idone);
723  } while (odone || idone || (!was_flushing && p->flushing));
724  return odone0;
725}
726
727
728
729static size_t soxr_i_for_o(soxr_t p, size_t olen, size_t ilen)
730{
731  size_t result;
732#if 0
733  if (p->runtime_spec.flags & SOXR_STRICT_BUFFERING)
734    result = rate_i_for_o(p->resamplers[0], olen);
735  else
736#endif
737    result = (size_t)ceil((double)olen * p->io_ratio);
738  return 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{
746  size_t result = (size_t)ceil((double)ilen / p->io_ratio);
747  return min(result, olen);
748}
749#endif
750
751
752
753soxr_error_t soxr_process(soxr_t p,
754    void const * in , size_t ilen0, size_t * idone0,
755    void       * out, size_t olen , size_t * odone0)
756{
757  size_t ilen, idone, odone = 0;
758  unsigned u;
759  bool flush_requested = false;
760
761  if (!p) return "null pointer";
762
763  if (!in)
764    flush_requested = true, ilen = ilen0 = 0;
765  else {
766    if ((ptrdiff_t)ilen0 < 0)
767      flush_requested = true, ilen0 = ~ilen0;
768    if (idone0 && (1 || flush_requested))
769      ilen = soxr_i_for_o(p, olen, ilen0);
770    else
771      ilen = ilen0/*, olen = soxr_o_for_i(p, ilen, olen)*/;
772  }
773  p->flushing |= ilen == ilen0 && flush_requested;
774
775  if (!out && !in)
776    idone = ilen;
777  else if (p->io_spec.itype & p->io_spec.otype & SOXR_SPLIT) { /* Both i & o */
778#if defined _OPENMP
779    int i;
780    if (!p->runtime_spec.num_threads && p->num_channels > 1)
781#pragma omp parallel for
782    for (i = 0; i < (int)p->num_channels; ++i) {
783      size_t done;
784      if (in)
785        soxr_input_1ch(p, (unsigned)i, ((soxr_cbufs_t)in)[i], ilen);
786      done = soxr_output_1ch(p, (unsigned)i, ((soxr_bufs_t)out)[i], olen, true);
787      if (!i)
788        odone = done;
789    } else
790#endif
791    for (u = 0; u < p->num_channels; ++u) {
792      if (in)
793        soxr_input_1ch(p, u, ((soxr_cbufs_t)in)[u], ilen);
794      odone = soxr_output_1ch(p, u, ((soxr_bufs_t)out)[u], olen, true);
795    }
796    idone = ilen;
797  }
798  else {
799    idone = ilen? soxr_input (p, in , ilen) : 0;
800    odone = soxr_output(p, out, olen);
801  }
802  if (idone0) *idone0 = idone;
803  if (odone0) *odone0 = odone;
804  return p->error;
805}
806
807
808
809soxr_error_t soxr_oneshot(
810    double irate, double orate,
811    unsigned num_channels,
812    void const * in , size_t ilen, size_t * idone,
813    void * out, size_t olen, size_t * odone,
814    soxr_io_spec_t const * io_spec,
815    soxr_quality_spec_t const * q_spec,
816    soxr_runtime_spec_t const * runtime_spec)
817{
818  soxr_t resampler;
819  soxr_error_t error = q_spec? q_spec->e : 0;
820  if (!error) {
821    soxr_quality_spec_t q_spec1;
822    if (!q_spec)
823      q_spec1 = soxr_quality_spec(SOXR_LQ, 0), q_spec = &q_spec1;
824    resampler = soxr_create(irate, orate, num_channels,
825        &error, io_spec, q_spec, runtime_spec);
826  }
827  if (!error) {
828    error = soxr_process(resampler, in, ~ilen, idone, out, olen, odone);
829    soxr_delete(resampler);
830  }
831  return error;
832}
833
834
835
836soxr_error_t soxr_set_error(soxr_t p, soxr_error_t error)
837{
838  if (!p) return "null pointer";
839  if (!p->error && p->error != error) return p->error;
840  p->error = error;
841  return 0;
842}