r8brain-sys 7.3.0

Raw bindings to `r8brain`, a sample rate converter designed by Aleksey Vaneev of Voxengo.
Documentation
use core::ffi::c_int;

use crate::{EDSPFilterPhaseResponse, EWindowCalculator, EWindowFunctionType};

macro_rules! opaque {
    ($($name:ident),+ $(,)?) => {$(
        #[repr(C)]
        #[derive(Debug)]
        pub struct $name { _unused: [u8; 0] }
    )+};
}

opaque!(
    HCDSPFIRFilter,
    HCDSPFracDelayFilterBank,
    HCDSPRealFFTKeeper,
    HCDSPSincFilterGen,
    HCSineGen,
);

unsafe extern "C" {
    pub fn firFilter_getLPMinTransBand() -> f64;
    pub fn firFilter_getLPMaxTransBand() -> f64;
    pub fn firFilter_getLPMinAtten() -> f64;
    pub fn firFilter_getLPMaxAtten() -> f64;
    pub fn firFilter_isZeroPhase(filter: *const HCDSPFIRFilter) -> c_int;
    pub fn firFilter_getLatency(filter: *const HCDSPFIRFilter) -> c_int;
    pub fn firFilter_getLatencyFrac(filter: *const HCDSPFIRFilter) -> f64;
    pub fn firFilter_getKernelLen(filter: *const HCDSPFIRFilter) -> c_int;
    pub fn firFilter_getBlockLenBits(filter: *const HCDSPFIRFilter) -> c_int;
    /// Returns a filter-owned frequency-domain kernel block.
    pub fn firFilter_getKernelBlock(filter: *const HCDSPFIRFilter) -> *const f64;
    /// Releases one reference obtained from `firFilterCache_getLPFilter`.
    pub fn firFilter_unref(filter: *mut HCDSPFIRFilter);
    pub fn firFilterCache_getObjCount() -> c_int;
    /// Acquires a reference-counted low-pass FIR filter from the global cache.
    pub fn firFilterCache_getLPFilter(
        ReqNormFreq: f64,
        ReqTransBand: f64,
        ReqAtten: f64,
        ReqPhase: EDSPFilterPhaseResponse,
        ReqGain: f64,
        AttenCorrs: *const f64,
    ) -> *mut HCDSPFIRFilter;

    pub fn fracDelayFilterBank_create(
        FilterFracs: c_int,
        ElementSize: c_int,
        InterpPoints: c_int,
        ReqAtten: f64,
        IsThird: c_int,
    ) -> *mut HCDSPFracDelayFilterBank;
    /// Deletes a directly constructed bank; do not use for cached banks.
    pub fn fracDelayFilterBank_destroy(bank: *mut HCDSPFracDelayFilterBank);
    pub fn fracDelayFilterBank_roundReqAtten(attenuation: *mut f64, IsThird: c_int);
    pub fn fracDelayFilterBank_getFilterLen(bank: *const HCDSPFracDelayFilterBank) -> c_int;
    pub fn fracDelayFilterBank_getFilterFracs(bank: *const HCDSPFracDelayFilterBank) -> c_int;
    /// Returns the first coefficient of the indexed filter entry.
    pub fn fracDelayFilterBank_getFilter(
        bank: *const HCDSPFracDelayFilterBank,
        index: c_int,
    ) -> *const f64;
    /// Releases a non-static cached bank reference.
    pub fn fracDelayFilterBank_unref(bank: *mut HCDSPFracDelayFilterBank);
    pub fn fracDelayFilterBankCache_getFilterBank(
        FilterFracs: c_int,
        ElementSize: c_int,
        InterpPoints: c_int,
        ReqAtten: f64,
        IsThird: c_int,
        IsStatic: c_int,
    ) -> *mut HCDSPFracDelayFilterBank;

    pub fn realFFTKeeper_create() -> *mut HCDSPRealFFTKeeper;
    /// Acquires an FFT of length `1 << LenBits`. PFFFT backends additionally
    /// require a transform length supported by PFFFT (32 is the safe minimum).
    pub fn realFFTKeeper_createWithLen(LenBits: c_int) -> *mut HCDSPRealFFTKeeper;
    pub fn realFFTKeeper_destroy(keeper: *mut HCDSPRealFFTKeeper);
    pub fn realFFTKeeper_init(keeper: *mut HCDSPRealFFTKeeper, LenBits: c_int);
    pub fn realFFTKeeper_reset(keeper: *mut HCDSPRealFFTKeeper);
    pub fn realFFTKeeper_getInvMulConst(keeper: *const HCDSPRealFFTKeeper) -> f64;
    pub fn realFFTKeeper_getLenBits(keeper: *const HCDSPRealFFTKeeper) -> c_int;
    pub fn realFFTKeeper_getLen(keeper: *const HCDSPRealFFTKeeper) -> c_int;
    /// Performs an in-place forward transform. PFFFT backends require the
    /// block pointer to be at least 16-byte aligned.
    pub fn realFFTKeeper_forward(keeper: *const HCDSPRealFFTKeeper, block: *mut f64);
    /// Performs an in-place inverse transform. PFFFT backends require the
    /// block pointer to be at least 16-byte aligned.
    pub fn realFFTKeeper_inverse(keeper: *const HCDSPRealFFTKeeper, block: *mut f64);
    pub fn realFFTKeeper_multiplyBlocks(
        keeper: *const HCDSPRealFFTKeeper,
        input1: *const f64,
        input2: *const f64,
        output: *mut f64,
    );
    pub fn realFFTKeeper_multiplyBlocksInplace(
        keeper: *const HCDSPRealFFTKeeper,
        input: *const f64,
        input_output: *mut f64,
    );
    pub fn realFFTKeeper_multiplyBlocksZP(
        keeper: *const HCDSPRealFFTKeeper,
        zero_phase_input: *const f64,
        input_output: *mut f64,
    );
    pub fn realFFTKeeper_convertToZP(keeper: *const HCDSPRealFFTKeeper, block: *mut f64);

    pub fn sincFilterGen_create() -> *mut HCDSPSincFilterGen;
    pub fn sincFilterGen_destroy(generator: *mut HCDSPSincFilterGen);
    pub fn sincFilterGen_setLen2(generator: *mut HCDSPSincFilterGen, Len2: f64);
    pub fn sincFilterGen_getLen2(generator: *const HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_getKernelLen(generator: *const HCDSPSincFilterGen) -> c_int;
    pub fn sincFilterGen_getHalfKernelLen(generator: *const HCDSPSincFilterGen) -> c_int;
    pub fn sincFilterGen_setFreq1(generator: *mut HCDSPSincFilterGen, Freq1: f64);
    pub fn sincFilterGen_getFreq1(generator: *const HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_setFreq2(generator: *mut HCDSPSincFilterGen, Freq2: f64);
    pub fn sincFilterGen_getFreq2(generator: *const HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_setFracDelay(generator: *mut HCDSPSincFilterGen, FracDelay: f64);
    pub fn sincFilterGen_getFracDelay(generator: *const HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_initWindow(
        generator: *mut HCDSPSincFilterGen,
        WinType: EWindowFunctionType,
        Params: *const f64,
        UsePower: c_int,
    );
    pub fn sincFilterGen_initBand(
        generator: *mut HCDSPSincFilterGen,
        WinType: EWindowFunctionType,
        Params: *const f64,
        UsePower: c_int,
    );
    pub fn sincFilterGen_initHilbert(
        generator: *mut HCDSPSincFilterGen,
        WinType: EWindowFunctionType,
        Params: *const f64,
        UsePower: c_int,
    );
    pub fn sincFilterGen_initFrac(
        generator: *mut HCDSPSincFilterGen,
        WinType: EWindowFunctionType,
        Params: *const f64,
        UsePower: c_int,
    );
    pub fn sincFilterGen_calcWindow(
        generator: *mut HCDSPSincFilterGen,
        calculator: EWindowCalculator,
    ) -> f64;
    pub fn sincFilterGen_calcWindowHann(generator: *mut HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_calcWindowHamming(generator: *mut HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_calcWindowBlackman(generator: *mut HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_calcWindowNuttall(generator: *mut HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_calcWindowBlackmanNuttall(generator: *mut HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_calcWindowKaiser(generator: *mut HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_calcWindowGaussian(generator: *mut HCDSPSincFilterGen) -> f64;
    pub fn sincFilterGen_generateWindow(
        generator: *mut HCDSPSincFilterGen,
        output: *mut f64,
        calculator: EWindowCalculator,
    );
    pub fn sincFilterGen_generateBand(
        generator: *mut HCDSPSincFilterGen,
        output: *mut f64,
        calculator: EWindowCalculator,
    );
    pub fn sincFilterGen_generateHilbert(
        generator: *mut HCDSPSincFilterGen,
        output: *mut f64,
        calculator: EWindowCalculator,
    );
    pub fn sincFilterGen_generateFrac(
        generator: *mut HCDSPSincFilterGen,
        output: *mut f64,
        calculator: EWindowCalculator,
        OutputIncrement: c_int,
    );

    pub fn sineGen_create() -> *mut HCSineGen;
    pub fn sineGen_createUnity(increment: f64, phase: f64) -> *mut HCSineGen;
    pub fn sineGen_createWithGain(increment: f64, phase: f64, gain: f64) -> *mut HCSineGen;
    pub fn sineGen_destroy(generator: *mut HCSineGen);
    pub fn sineGen_init(generator: *mut HCSineGen, increment: f64, phase: f64);
    pub fn sineGen_initWithGain(generator: *mut HCSineGen, increment: f64, phase: f64, gain: f64);
    pub fn sineGen_generate(generator: *mut HCSineGen) -> f64;

    pub fn calcFIRFilterResponse(
        filter: *const f64,
        FilterLen: c_int,
        CircularFrequency: f64,
        real: *mut f64,
        imaginary: *mut f64,
        FilterLatency: c_int,
    );
    pub fn calcFIRFilterGroupDelay(
        filter: *const f64,
        FilterLen: c_int,
        CircularFrequency: f64,
    ) -> f64;
    pub fn normalizeFIRFilter(filter: *mut f64, FilterLen: c_int, DCGain: f64, ElementStep: c_int);
    pub fn calcSpline3p8Coeffs(
        coefficients: *mut f64,
        xm3: f64,
        xm2: f64,
        xm1: f64,
        x0: f64,
        x1: f64,
        x2: f64,
        x3: f64,
        x4: f64,
    );
    pub fn calcSpline2p8Coeffs(
        coefficients: *mut f64,
        xm3: f64,
        xm2: f64,
        xm1: f64,
        x0: f64,
        x1: f64,
        x2: f64,
        x3: f64,
        x4: f64,
    );
    pub fn calcSpline3p4Coeffs(coefficients: *mut f64, points: *const f64);
    pub fn calcSpline3p6Coeffs(coefficients: *mut f64, points: *const f64);
    pub fn calcMinPhaseTransform(
        kernel: *mut f64,
        KernelLen: c_int,
        LenMultiplier: c_int,
        DoFinalMultiply: c_int,
        DCGroupDelay: *mut f64,
    );
    pub fn findGCD(larger: f64, smaller: f64, gcd: *mut f64) -> c_int;
    pub fn getWholeStepping(
        SrcSampleRate: f64,
        DstSampleRate: f64,
        InputStep: *mut c_int,
        OutputStep: *mut c_int,
    ) -> c_int;
    pub fn clampr(value: f64, minimum: f64, maximum: f64) -> f64;
    pub fn sqr(value: f64) -> f64;
    pub fn pow_a(value: f64, power: f64) -> f64;
    pub fn gauss(value: f64) -> f64;
    pub fn getBitOccupancy(value: c_int) -> c_int;
    /// Namespaced form of r8brain's `asinh` helper, avoiding a libm symbol collision.
    pub fn r8b_asinh(value: f64) -> f64;
    pub fn besselI0(value: f64) -> f64;
    pub fn convertResponseToLog(real: f64, imaginary: f64) -> f64;
    pub fn updateScanStep(
        step: *mut f64,
        CurrentGainSquared: f64,
        PreviousGainLog: *mut f64,
        Precision: f64,
        MaximumStep: f64,
        MinimumStep: f64,
    );
    pub fn findFIRFilterResponseMinLtoR(
        filter: *const f64,
        FilterLen: c_int,
        MinimumGainSquared: *mut f64,
        NormalizedFrequency: *mut f64,
        EndingFrequency: f64,
    );
    pub fn findFIRFilterResponseMaxLtoR(
        filter: *const f64,
        FilterLen: c_int,
        MaximumGainSquared: *mut f64,
        NormalizedFrequency: *mut f64,
        EndingFrequency: f64,
    );
    pub fn findFIRFilterResponseLevelRtoL(
        filter: *const f64,
        FilterLen: c_int,
        MaximumGainSquared: f64,
        NormalizedFrequency: *mut f64,
        EndingFrequency: f64,
    );
}