#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();
}
int fracDelayFilterBankCache_getObjCount()
{
return CDSPFracDelayFilterBankCache::getObjCount();
}
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);
}
}