r8brain-sys 7.3.0

Raw bindings to `r8brain`, a sample rate converter designed by Aleksey Vaneev of Voxengo.
Documentation
#ifndef R8BRAIN_SYS_SUPPORT_EXTERN_H
#define R8BRAIN_SYS_SUPPORT_EXTERN_H

typedef struct HCDSPFIRFilter HCDSPFIRFilter;
typedef struct HCDSPFracDelayFilterBank HCDSPFracDelayFilterBank;
typedef struct HCDSPRealFFTKeeper HCDSPRealFFTKeeper;
typedef struct HCDSPSincFilterGen HCDSPSincFilterGen;
typedef struct HCSineGen HCSineGen;

#ifdef __cplusplus
extern "C" {
#endif

double firFilter_getLPMinTransBand(void);
double firFilter_getLPMaxTransBand(void);
double firFilter_getLPMinAtten(void);
double firFilter_getLPMaxAtten(void);
int firFilter_isZeroPhase(const HCDSPFIRFilter* filter);
int firFilter_getLatency(const HCDSPFIRFilter* filter);
double firFilter_getLatencyFrac(const HCDSPFIRFilter* filter);
int firFilter_getKernelLen(const HCDSPFIRFilter* filter);
int firFilter_getBlockLenBits(const HCDSPFIRFilter* filter);
const double* firFilter_getKernelBlock(const HCDSPFIRFilter* filter);
void firFilter_unref(HCDSPFIRFilter* filter);
int firFilterCache_getObjCount(void);
HCDSPFIRFilter* firFilterCache_getLPFilter(double req_norm_freq,
    double req_trans_band, double req_attenuation, int phase,
    double req_gain, const double* attenuation_corrections);

HCDSPFracDelayFilterBank* fracDelayFilterBank_create(int filter_fracs,
    int element_size, int interp_points, double req_attenuation,
    int is_third);
void fracDelayFilterBank_destroy(HCDSPFracDelayFilterBank* bank);
void fracDelayFilterBank_roundReqAtten(double* attenuation, int is_third);
int fracDelayFilterBank_getFilterLen(const HCDSPFracDelayFilterBank* bank);
int fracDelayFilterBank_getFilterFracs(const HCDSPFracDelayFilterBank* bank);
const double* fracDelayFilterBank_getFilter(
    const HCDSPFracDelayFilterBank* bank, int index);
void fracDelayFilterBank_unref(HCDSPFracDelayFilterBank* bank);
HCDSPFracDelayFilterBank* fracDelayFilterBankCache_getFilterBank(
    int filter_fracs, int element_size, int interp_points,
    double req_attenuation, int is_third, int is_static);

HCDSPRealFFTKeeper* realFFTKeeper_create(void);
HCDSPRealFFTKeeper* realFFTKeeper_createWithLen(int len_bits);
void realFFTKeeper_destroy(HCDSPRealFFTKeeper* keeper);
void realFFTKeeper_init(HCDSPRealFFTKeeper* keeper, int len_bits);
void realFFTKeeper_reset(HCDSPRealFFTKeeper* keeper);
double realFFTKeeper_getInvMulConst(const HCDSPRealFFTKeeper* keeper);
int realFFTKeeper_getLenBits(const HCDSPRealFFTKeeper* keeper);
int realFFTKeeper_getLen(const HCDSPRealFFTKeeper* keeper);
void realFFTKeeper_forward(const HCDSPRealFFTKeeper* keeper, double* block);
void realFFTKeeper_inverse(const HCDSPRealFFTKeeper* keeper, double* block);
void realFFTKeeper_multiplyBlocks(const HCDSPRealFFTKeeper* keeper,
    const double* input1, const double* input2, double* output);
void realFFTKeeper_multiplyBlocksInplace(const HCDSPRealFFTKeeper* keeper,
    const double* input, double* input_output);
void realFFTKeeper_multiplyBlocksZP(const HCDSPRealFFTKeeper* keeper,
    const double* zero_phase_input, double* input_output);
void realFFTKeeper_convertToZP(const HCDSPRealFFTKeeper* keeper,
    double* block);

HCDSPSincFilterGen* sincFilterGen_create(void);
void sincFilterGen_destroy(HCDSPSincFilterGen* generator);
void sincFilterGen_setLen2(HCDSPSincFilterGen* generator, double len2);
double sincFilterGen_getLen2(const HCDSPSincFilterGen* generator);
int sincFilterGen_getKernelLen(const HCDSPSincFilterGen* generator);
int sincFilterGen_getHalfKernelLen(const HCDSPSincFilterGen* generator);
void sincFilterGen_setFreq1(HCDSPSincFilterGen* generator, double freq1);
double sincFilterGen_getFreq1(const HCDSPSincFilterGen* generator);
void sincFilterGen_setFreq2(HCDSPSincFilterGen* generator, double freq2);
double sincFilterGen_getFreq2(const HCDSPSincFilterGen* generator);
void sincFilterGen_setFracDelay(HCDSPSincFilterGen* generator,
    double frac_delay);
double sincFilterGen_getFracDelay(const HCDSPSincFilterGen* generator);
void sincFilterGen_initWindow(HCDSPSincFilterGen* generator,
    int window_type, const double* params, int use_power);
void sincFilterGen_initBand(HCDSPSincFilterGen* generator,
    int window_type, const double* params, int use_power);
void sincFilterGen_initHilbert(HCDSPSincFilterGen* generator,
    int window_type, const double* params, int use_power);
void sincFilterGen_initFrac(HCDSPSincFilterGen* generator,
    int window_type, const double* params, int use_power);
double sincFilterGen_calcWindow(HCDSPSincFilterGen* generator,
    int window_calculator);
double sincFilterGen_calcWindowHann(HCDSPSincFilterGen* generator);
double sincFilterGen_calcWindowHamming(HCDSPSincFilterGen* generator);
double sincFilterGen_calcWindowBlackman(HCDSPSincFilterGen* generator);
double sincFilterGen_calcWindowNuttall(HCDSPSincFilterGen* generator);
double sincFilterGen_calcWindowBlackmanNuttall(HCDSPSincFilterGen* generator);
double sincFilterGen_calcWindowKaiser(HCDSPSincFilterGen* generator);
double sincFilterGen_calcWindowGaussian(HCDSPSincFilterGen* generator);
void sincFilterGen_generateWindow(HCDSPSincFilterGen* generator,
    double* output, int window_calculator);
void sincFilterGen_generateBand(HCDSPSincFilterGen* generator,
    double* output, int window_calculator);
void sincFilterGen_generateHilbert(HCDSPSincFilterGen* generator,
    double* output, int window_calculator);
void sincFilterGen_generateFrac(HCDSPSincFilterGen* generator,
    double* output, int window_calculator, int output_increment);

HCSineGen* sineGen_create(void);
HCSineGen* sineGen_createUnity(double increment, double phase);
HCSineGen* sineGen_createWithGain(double increment, double phase,
    double gain);
void sineGen_destroy(HCSineGen* generator);
void sineGen_init(HCSineGen* generator, double increment, double phase);
void sineGen_initWithGain(HCSineGen* generator, double increment,
    double phase, double gain);
double sineGen_generate(HCSineGen* generator);

void calcFIRFilterResponse(const double* filter, int filter_len,
    double circular_frequency, double* real, double* imaginary,
    int filter_latency);
double calcFIRFilterGroupDelay(const double* filter, int filter_len,
    double circular_frequency);
void normalizeFIRFilter(double* filter, int filter_len, double dc_gain,
    int element_step);
void calcSpline3p8Coeffs(double* coefficients, double xm3, double xm2,
    double xm1, double x0, double x1, double x2, double x3, double x4);
void calcSpline2p8Coeffs(double* coefficients, double xm3, double xm2,
    double xm1, double x0, double x1, double x2, double x3, double x4);
void calcSpline3p4Coeffs(double* coefficients, const double* points);
void calcSpline3p6Coeffs(double* coefficients, const double* points);
void calcMinPhaseTransform(double* kernel, int kernel_len, int len_multiplier,
    int do_final_multiply, double* dc_group_delay);
int findGCD(double larger, double smaller, double* gcd);
int getWholeStepping(double src_sample_rate, double dst_sample_rate,
    int* input_step, int* output_step);
double clampr(double value, double minimum, double maximum);
double sqr(double value);
double pow_a(double value, double power);
double gauss(double value);
int getBitOccupancy(int value);
double r8b_asinh(double value);
double besselI0(double value);
double convertResponseToLog(double real, double imaginary);
void updateScanStep(double* step, double current_gain_squared,
    double* previous_gain_log, double precision, double maximum_step,
    double minimum_step);
void findFIRFilterResponseMinLtoR(const double* filter, int filter_len,
    double* minimum_gain_squared, double* normalized_frequency,
    double ending_frequency);
void findFIRFilterResponseMaxLtoR(const double* filter, int filter_len,
    double* maximum_gain_squared, double* normalized_frequency,
    double ending_frequency);
void findFIRFilterResponseLevelRtoL(const double* filter, int filter_len,
    double maximum_gain_squared, double* normalized_frequency,
    double ending_frequency);

#ifdef __cplusplus
} // extern "C"
#endif

#endif