r8brain-sys 7.3.0

Raw bindings to `r8brain`, a sample rate converter designed by Aleksey Vaneev of Voxengo.
Documentation
#include "resampler-extern.h"

#include "CDSPResampler.h"

using r8b::CDSPResampler;
using r8b::CDSPResampler16;
using r8b::CDSPResampler16IR;
using r8b::CDSPResampler24;
using r8b::EDSPFilterPhaseResponse;

#define DEFINE_RESAMPLER_METHODS(prefix, handle_type, cpp_type) \
    void prefix##_destroy(handle_type* const resampler) \
    { \
        delete reinterpret_cast<cpp_type*>(resampler); \
    } \
    void prefix##_clear(handle_type* const resampler) \
    { \
        reinterpret_cast<cpp_type*>(resampler)->clear(); \
    } \
    int prefix##_getInLenBeforeOutPos(handle_type* const resampler, \
        const int req_out_pos) \
    { \
        return reinterpret_cast<cpp_type*>(resampler) \
            ->getInLenBeforeOutPos(req_out_pos); \
    } \
    int prefix##_getInLenBeforeOutStart(handle_type* const resampler, \
        const int req_out_pos) \
    { \
        return reinterpret_cast<cpp_type*>(resampler) \
            ->getInLenBeforeOutStart(req_out_pos); \
    } \
    int prefix##_getInputRequiredForOutput(handle_type* const resampler, \
        const int req_out_samples) \
    { \
        return reinterpret_cast<cpp_type*>(resampler) \
            ->getInputRequiredForOutput(req_out_samples); \
    } \
    int prefix##_getLatency(handle_type* const resampler) \
    { \
        return reinterpret_cast<cpp_type*>(resampler)->getLatency(); \
    } \
    double prefix##_getLatencyFrac(handle_type* const resampler) \
    { \
        return reinterpret_cast<cpp_type*>(resampler)->getLatencyFrac(); \
    } \
    int prefix##_getMaxOutLen(handle_type* const resampler, \
        const int max_in_len) \
    { \
        return reinterpret_cast<cpp_type*>(resampler) \
            ->getMaxOutLen(max_in_len); \
    } \
    int prefix##_process(handle_type* const resampler, double* const input, \
        const int input_len, double** const output) \
    { \
        return reinterpret_cast<cpp_type*>(resampler) \
            ->process(input, input_len, *output); \
    } \
    void prefix##_oneshot(handle_type* const resampler, \
        double* const input, const int input_len, \
        double* const output, const int output_len) \
    { \
        reinterpret_cast<cpp_type*>(resampler) \
            ->oneshot(input, input_len, output, output_len); \
    }

extern "C" {

HCDSPResampler* resampler_create(const double src_sample_rate,
    const double dst_sample_rate, const int max_in_len,
    const double req_trans_band, const double req_attenuation,
    const int phase)
{
    return reinterpret_cast<HCDSPResampler*>(new CDSPResampler(
        src_sample_rate, dst_sample_rate, max_in_len, req_trans_band,
        req_attenuation, static_cast<EDSPFilterPhaseResponse>(phase)));
}

DEFINE_RESAMPLER_METHODS(resampler, HCDSPResampler, CDSPResampler)

HCDSPResampler16* resampler16_create(const double src_sample_rate,
    const double dst_sample_rate, const int max_in_len,
    const double req_trans_band)
{
    return reinterpret_cast<HCDSPResampler16*>(new CDSPResampler16(
        src_sample_rate, dst_sample_rate, max_in_len, req_trans_band));
}

DEFINE_RESAMPLER_METHODS(resampler16, HCDSPResampler16, CDSPResampler16)

HCDSPResampler16IR* resampler16IR_create(const double src_sample_rate,
    const double dst_sample_rate, const int max_in_len,
    const double req_trans_band)
{
    return reinterpret_cast<HCDSPResampler16IR*>(new CDSPResampler16IR(
        src_sample_rate, dst_sample_rate, max_in_len, req_trans_band));
}

DEFINE_RESAMPLER_METHODS(
    resampler16IR, HCDSPResampler16IR, CDSPResampler16IR)

HCDSPResampler24* resampler24_create(const double src_sample_rate,
    const double dst_sample_rate, const int max_in_len,
    const double req_trans_band)
{
    return reinterpret_cast<HCDSPResampler24*>(new CDSPResampler24(
        src_sample_rate, dst_sample_rate, max_in_len, req_trans_band));
}

DEFINE_RESAMPLER_METHODS(resampler24, HCDSPResampler24, CDSPResampler24)

} // extern "C"