r8brain-sys 7.3.0

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

#include "CDSPFIRFilter.h"
#include "CDSPFracInterpolator.h"
#include "CDSPRealFFT.h"
#include "CDSPSincFilterGen.h"
#include "r8butil.h"

using r8b::CDSPFIRFilter;
using r8b::CDSPFIRFilterCache;
using r8b::CDSPFracDelayFilterBank;
using r8b::CDSPFracDelayFilterBankCache;
using r8b::CDSPRealFFTKeeper;
using r8b::CDSPSincFilterGen;
using r8b::CSineGen;
using r8b::EDSPFilterPhaseResponse;

static CDSPSincFilterGen::CWindowFunc get_window_calculator(const int value)
{
    switch (value)
    {
    case 0: return &CDSPSincFilterGen::calcWindowHann;
    case 1: return &CDSPSincFilterGen::calcWindowHamming;
    case 3: return &CDSPSincFilterGen::calcWindowNuttall;
    case 4: return &CDSPSincFilterGen::calcWindowBlackmanNuttall;
    case 5: return &CDSPSincFilterGen::calcWindowKaiser;
    case 6: return &CDSPSincFilterGen::calcWindowGaussian;
    default: return &CDSPSincFilterGen::calcWindowBlackman;
    }
}

extern "C" {

double firFilter_getLPMinTransBand() { return CDSPFIRFilter::getLPMinTransBand(); }
double firFilter_getLPMaxTransBand() { return CDSPFIRFilter::getLPMaxTransBand(); }
double firFilter_getLPMinAtten() { return CDSPFIRFilter::getLPMinAtten(); }
double firFilter_getLPMaxAtten() { return CDSPFIRFilter::getLPMaxAtten(); }

int firFilter_isZeroPhase(const HCDSPFIRFilter* const filter)
{
    return reinterpret_cast<const CDSPFIRFilter*>(filter)->isZeroPhase();
}
int firFilter_getLatency(const HCDSPFIRFilter* const filter)
{
    return reinterpret_cast<const CDSPFIRFilter*>(filter)->getLatency();
}
double firFilter_getLatencyFrac(const HCDSPFIRFilter* const filter)
{
    return reinterpret_cast<const CDSPFIRFilter*>(filter)->getLatencyFrac();
}
int firFilter_getKernelLen(const HCDSPFIRFilter* const filter)
{
    return reinterpret_cast<const CDSPFIRFilter*>(filter)->getKernelLen();
}
int firFilter_getBlockLenBits(const HCDSPFIRFilter* const filter)
{
    return reinterpret_cast<const CDSPFIRFilter*>(filter)->getBlockLenBits();
}
const double* firFilter_getKernelBlock(const HCDSPFIRFilter* const filter)
{
    return reinterpret_cast<const CDSPFIRFilter*>(filter)->getKernelBlock();
}
void firFilter_unref(HCDSPFIRFilter* const filter)
{
    reinterpret_cast<CDSPFIRFilter*>(filter)->unref();
}
int firFilterCache_getObjCount() { return CDSPFIRFilterCache::getObjCount(); }
HCDSPFIRFilter* firFilterCache_getLPFilter(const double req_norm_freq,
    const double req_trans_band, const double req_attenuation,
    const int phase, const double req_gain,
    const double* const attenuation_corrections)
{
    return reinterpret_cast<HCDSPFIRFilter*>(&CDSPFIRFilterCache::getLPFilter(
        req_norm_freq, req_trans_band, req_attenuation,
        static_cast<EDSPFilterPhaseResponse>(phase), req_gain,
        attenuation_corrections));
}

HCDSPFracDelayFilterBank* fracDelayFilterBank_create(const int filter_fracs,
    const int element_size, const int interp_points,
    const double req_attenuation, const int is_third)
{
    return reinterpret_cast<HCDSPFracDelayFilterBank*>(
        new CDSPFracDelayFilterBank(filter_fracs, element_size, interp_points,
            req_attenuation, is_third != 0));
}
void fracDelayFilterBank_destroy(HCDSPFracDelayFilterBank* const bank)
{
    delete reinterpret_cast<CDSPFracDelayFilterBank*>(bank);
}
void fracDelayFilterBank_roundReqAtten(double* const attenuation,
    const int is_third)
{
    CDSPFracDelayFilterBank::roundReqAtten(*attenuation, is_third != 0);
}
int fracDelayFilterBank_getFilterLen(
    const HCDSPFracDelayFilterBank* const bank)
{
    return reinterpret_cast<const CDSPFracDelayFilterBank*>(bank)
        ->getFilterLen();
}
int fracDelayFilterBank_getFilterFracs(
    const HCDSPFracDelayFilterBank* const bank)
{
    return reinterpret_cast<const CDSPFracDelayFilterBank*>(bank)
        ->getFilterFracs();
}
const double* fracDelayFilterBank_getFilter(
    const HCDSPFracDelayFilterBank* const bank, const int index)
{
    return &(*reinterpret_cast<const CDSPFracDelayFilterBank*>(bank))[index];
}
void fracDelayFilterBank_unref(HCDSPFracDelayFilterBank* const bank)
{
    reinterpret_cast<CDSPFracDelayFilterBank*>(bank)->unref();
}
HCDSPFracDelayFilterBank* fracDelayFilterBankCache_getFilterBank(
    const int filter_fracs, const int element_size, const int interp_points,
    const double req_attenuation, const int is_third, const int is_static)
{
    return reinterpret_cast<HCDSPFracDelayFilterBank*>(
        &CDSPFracDelayFilterBankCache::getFilterBank(filter_fracs,
            element_size, interp_points, req_attenuation, is_third != 0,
            is_static != 0));
}

HCDSPRealFFTKeeper* realFFTKeeper_create()
{
    return reinterpret_cast<HCDSPRealFFTKeeper*>(new CDSPRealFFTKeeper());
}
HCDSPRealFFTKeeper* realFFTKeeper_createWithLen(const int len_bits)
{
    return reinterpret_cast<HCDSPRealFFTKeeper*>(
        new CDSPRealFFTKeeper(len_bits));
}
void realFFTKeeper_destroy(HCDSPRealFFTKeeper* const keeper)
{
    delete reinterpret_cast<CDSPRealFFTKeeper*>(keeper);
}
void realFFTKeeper_init(HCDSPRealFFTKeeper* const keeper, const int len_bits)
{
    reinterpret_cast<CDSPRealFFTKeeper*>(keeper)->init(len_bits);
}
void realFFTKeeper_reset(HCDSPRealFFTKeeper* const keeper)
{
    reinterpret_cast<CDSPRealFFTKeeper*>(keeper)->reset();
}
#define FFT_OBJECT(keeper) (*reinterpret_cast<const CDSPRealFFTKeeper*>(keeper))
double realFFTKeeper_getInvMulConst(const HCDSPRealFFTKeeper* const keeper)
{
    return FFT_OBJECT(keeper)->getInvMulConst();
}
int realFFTKeeper_getLenBits(const HCDSPRealFFTKeeper* const keeper)
{
    return FFT_OBJECT(keeper)->getLenBits();
}
int realFFTKeeper_getLen(const HCDSPRealFFTKeeper* const keeper)
{
    return FFT_OBJECT(keeper)->getLen();
}
void realFFTKeeper_forward(const HCDSPRealFFTKeeper* const keeper,
    double* const block) { FFT_OBJECT(keeper)->forward(block); }
void realFFTKeeper_inverse(const HCDSPRealFFTKeeper* const keeper,
    double* const block) { FFT_OBJECT(keeper)->inverse(block); }
void realFFTKeeper_multiplyBlocks(const HCDSPRealFFTKeeper* const keeper,
    const double* const input1, const double* const input2,
    double* const output)
{
    FFT_OBJECT(keeper)->multiplyBlocks(input1, input2, output);
}
void realFFTKeeper_multiplyBlocksInplace(
    const HCDSPRealFFTKeeper* const keeper, const double* const input,
    double* const input_output)
{
    FFT_OBJECT(keeper)->multiplyBlocks(input, input_output);
}
void realFFTKeeper_multiplyBlocksZP(const HCDSPRealFFTKeeper* const keeper,
    const double* const zero_phase_input, double* const input_output)
{
    FFT_OBJECT(keeper)->multiplyBlocksZP(zero_phase_input, input_output);
}
void realFFTKeeper_convertToZP(const HCDSPRealFFTKeeper* const keeper,
    double* const block) { FFT_OBJECT(keeper)->convertToZP(block); }

HCDSPSincFilterGen* sincFilterGen_create()
{
    return reinterpret_cast<HCDSPSincFilterGen*>(new CDSPSincFilterGen());
}
void sincFilterGen_destroy(HCDSPSincFilterGen* const generator)
{
    delete reinterpret_cast<CDSPSincFilterGen*>(generator);
}
#define SINC(generator) reinterpret_cast<CDSPSincFilterGen*>(generator)
#define SINC_CONST(generator) reinterpret_cast<const CDSPSincFilterGen*>(generator)
void sincFilterGen_setLen2(HCDSPSincFilterGen* const generator,
    const double len2) { SINC(generator)->Len2 = len2; }
double sincFilterGen_getLen2(const HCDSPSincFilterGen* const generator)
{ return SINC_CONST(generator)->Len2; }
int sincFilterGen_getKernelLen(const HCDSPSincFilterGen* const generator)
{ return SINC_CONST(generator)->KernelLen; }
int sincFilterGen_getHalfKernelLen(const HCDSPSincFilterGen* const generator)
{ return SINC_CONST(generator)->fl2; }
void sincFilterGen_setFreq1(HCDSPSincFilterGen* const generator,
    const double value) { SINC(generator)->Freq1 = value; }
double sincFilterGen_getFreq1(const HCDSPSincFilterGen* const generator)
{ return SINC_CONST(generator)->Freq1; }
void sincFilterGen_setFreq2(HCDSPSincFilterGen* const generator,
    const double value) { SINC(generator)->Freq2 = value; }
double sincFilterGen_getFreq2(const HCDSPSincFilterGen* const generator)
{ return SINC_CONST(generator)->Freq2; }
void sincFilterGen_setFracDelay(HCDSPSincFilterGen* const generator,
    const double value) { SINC(generator)->FracDelay = value; }
double sincFilterGen_getFracDelay(const HCDSPSincFilterGen* const generator)
{ return SINC_CONST(generator)->FracDelay; }
#define SINC_INIT(name) \
    void sincFilterGen_##name(HCDSPSincFilterGen* const generator, \
        const int window_type, const double* const params, \
        const int use_power) \
    { \
        SINC(generator)->name( \
            static_cast<CDSPSincFilterGen::EWindowFunctionType>(window_type), \
            params, use_power != 0); \
    }
SINC_INIT(initWindow)
SINC_INIT(initBand)
SINC_INIT(initHilbert)
SINC_INIT(initFrac)
double sincFilterGen_calcWindow(HCDSPSincFilterGen* const generator,
    const int calculator)
{
    return (SINC(generator)->*get_window_calculator(calculator))();
}
#define SINC_CALCULATE(name) \
    double sincFilterGen_##name(HCDSPSincFilterGen* const generator) \
    { return SINC(generator)->name(); }
SINC_CALCULATE(calcWindowHann)
SINC_CALCULATE(calcWindowHamming)
SINC_CALCULATE(calcWindowBlackman)
SINC_CALCULATE(calcWindowNuttall)
SINC_CALCULATE(calcWindowBlackmanNuttall)
SINC_CALCULATE(calcWindowKaiser)
SINC_CALCULATE(calcWindowGaussian)
#define SINC_GENERATE(name) \
    void sincFilterGen_##name(HCDSPSincFilterGen* const generator, \
        double* const output, const int calculator) \
    { \
        SINC(generator)->name(output, get_window_calculator(calculator)); \
    }
SINC_GENERATE(generateWindow)
SINC_GENERATE(generateBand)
SINC_GENERATE(generateHilbert)
void sincFilterGen_generateFrac(HCDSPSincFilterGen* const generator,
    double* const output, const int calculator, const int output_increment)
{
    SINC(generator)->generateFrac(output, get_window_calculator(calculator),
        output_increment);
}

HCSineGen* sineGen_create()
{ return reinterpret_cast<HCSineGen*>(new CSineGen()); }
HCSineGen* sineGen_createUnity(const double increment, const double phase)
{ return reinterpret_cast<HCSineGen*>(new CSineGen(increment, phase)); }
HCSineGen* sineGen_createWithGain(const double increment, const double phase,
    const double gain)
{ return reinterpret_cast<HCSineGen*>(new CSineGen(increment, phase, gain)); }
void sineGen_destroy(HCSineGen* const generator)
{ delete reinterpret_cast<CSineGen*>(generator); }
void sineGen_init(HCSineGen* const generator, const double increment,
    const double phase)
{ reinterpret_cast<CSineGen*>(generator)->init(increment, phase); }
void sineGen_initWithGain(HCSineGen* const generator, const double increment,
    const double phase, const double gain)
{ reinterpret_cast<CSineGen*>(generator)->init(increment, phase, gain); }
double sineGen_generate(HCSineGen* const generator)
{ return reinterpret_cast<CSineGen*>(generator)->generate(); }

void calcFIRFilterResponse(const double* const filter, const int filter_len,
    const double frequency, double* const real, double* const imaginary,
    const int latency)
{ r8b::calcFIRFilterResponse(filter, filter_len, frequency, *real, *imaginary, latency); }
double calcFIRFilterGroupDelay(const double* const filter,
    const int filter_len, const double frequency)
{ return r8b::calcFIRFilterGroupDelay(filter, filter_len, frequency); }
void normalizeFIRFilter(double* const filter, const int filter_len,
    const double gain, const int step)
{ r8b::normalizeFIRFilter(filter, filter_len, gain, step); }
void calcSpline3p8Coeffs(double* const c, const double xm3, const double xm2,
    const double xm1, const double x0, const double x1, const double x2,
    const double x3, const double x4)
{ r8b::calcSpline3p8Coeffs(c, xm3, xm2, xm1, x0, x1, x2, x3, x4); }
void calcSpline2p8Coeffs(double* const c, const double xm3, const double xm2,
    const double xm1, const double x0, const double x1, const double x2,
    const double x3, const double x4)
{ r8b::calcSpline2p8Coeffs(c, xm3, xm2, xm1, x0, x1, x2, x3, x4); }
void calcSpline3p4Coeffs(double* const c, const double* const points)
{ r8b::calcSpline3p4Coeffs(c, points); }
void calcSpline3p6Coeffs(double* const c, const double* const points)
{ r8b::calcSpline3p6Coeffs(c, points); }
void calcMinPhaseTransform(double* const kernel, const int kernel_len,
    const int len_multiplier, const int do_final_multiply,
    double* const dc_group_delay)
{ r8b::calcMinPhaseTransform(kernel, kernel_len, len_multiplier,
    do_final_multiply != 0, dc_group_delay); }
int findGCD(const double larger, const double smaller, double* const gcd)
{ return r8b::findGCD(larger, smaller, *gcd); }
int getWholeStepping(const double src_rate, const double dst_rate,
    int* const input_step, int* const output_step)
{ return r8b::getWholeStepping(src_rate, dst_rate, *input_step, *output_step); }
double clampr(const double value, const double minimum, const double maximum)
{ return r8b::clampr(value, minimum, maximum); }
double sqr(const double value) { return r8b::sqr(value); }
double pow_a(const double value, const double power)
{ return r8b::pow_a(value, power); }
double gauss(const double value) { return r8b::gauss(value); }
int getBitOccupancy(const int value) { return r8b::getBitOccupancy(value); }
double r8b_asinh(const double value) { return r8b::asinh(value); }
double besselI0(const double value) { return r8b::besselI0(value); }
double convertResponseToLog(const double real, const double imaginary)
{ return r8b::convertResponseToLog(real, imaginary); }
void updateScanStep(double* const step, const double current_gain_squared,
    double* const previous_gain_log, const double precision,
    const double maximum_step, const double minimum_step)
{
    r8b::updateScanStep(*step, current_gain_squared, *previous_gain_log,
        precision, maximum_step, minimum_step);
}
void findFIRFilterResponseMinLtoR(const double* const filter,
    const int filter_len, double* const minimum_gain_squared,
    double* const normalized_frequency, const double ending_frequency)
{
    r8b::findFIRFilterResponseMinLtoR(filter, filter_len,
        *minimum_gain_squared, *normalized_frequency, ending_frequency);
}
void findFIRFilterResponseMaxLtoR(const double* const filter,
    const int filter_len, double* const maximum_gain_squared,
    double* const normalized_frequency, const double ending_frequency)
{
    r8b::findFIRFilterResponseMaxLtoR(filter, filter_len,
        *maximum_gain_squared, *normalized_frequency, ending_frequency);
}
void findFIRFilterResponseLevelRtoL(const double* const filter,
    const int filter_len, const double maximum_gain_squared,
    double* const normalized_frequency, const double ending_frequency)
{
    r8b::findFIRFilterResponseLevelRtoL(filter, filter_len,
        maximum_gain_squared, *normalized_frequency, ending_frequency);
}

} // extern "C"