sam/sfizz
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #45 from jpcima/filters-bis

Browse source 
Filters bis
This commit is contained in:
JP Cimalando 2020-02-08 12:42:42 +01:00 • committed by GitHub
commit 9734456ad0
55 changed files with 1596 additions and 981 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
scripts/generate_filters.sh
View file

@ -15,7 +15,7 @@ faustgen() {
mkdir -p src/sfizz/gen/filters mkdir -p src/sfizz/gen/filters
local outfile=src/sfizz/gen/filters/sfz"$1".cxx local outfile=src/sfizz/gen/filters/sfz"$1".cxx
local code=`faust $FAUSTARGS -pn sfz"$1" -cn faust"$1" src/sfizz/dsp/filters/sfz_filters.dsp` local code=`faust $FAUSTARGS -pn sfz"$1" -cn faust"$1" -scn sfzFilterDsp src/sfizz/dsp/filters/sfz_filters.dsp`
# find variable names of our controls # find variable names of our controls
local cutoffVar=`echo "$code" | $SED -r 's%.*\("Cutoff", &[ \t]*([a-zA-Z0-9_]+).*%\1%;t;d'` local cutoffVar=`echo "$code" | $SED -r 's%.*\("Cutoff", &[ \t]*([a-zA-Z0-9_]+).*%\1%;t;d'`
@ -35,8 +35,6 @@ faustgen() {
# direct access to parameter variables # direct access to parameter variables
$SED -r -i 's/\bprivate:/public:/' "$outfile" $SED -r -i 's/\bprivate:/public:/' "$outfile"
# no virtuals please
$SED -r -i 's/\bvirtual\b//' "$outfile"
# rename the variables for us to access more easily # rename the variables for us to access more easily
if test ! -z "$cutoffVar"; then if test ! -z "$cutoffVar"; then

436
src/sfizz/SfzFilter.cpp
View file

@ -8,237 +8,171 @@
#include "SfzFilter.h" #include "SfzFilter.h"
#include "SfzFilterImpls.cxx" #include "SfzFilterImpls.cxx"
#include <cstring> #include <cstring>
#include <cassert>
#include "SIMDHelpers.h" #include "SIMDHelpers.h"
#include "Debug.h"
namespace sfz { namespace sfz {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// SFZ v2 multi-mode filter // SFZ v2 multi-mode filter
template <unsigned NCh> struct Filter::Impl {
struct Filter<NCh>::Impl {
FilterType fType = kFilterNone; FilterType fType = kFilterNone;
unsigned fChannels = 1;
enum { maxChannels = 2 };
sfzLpf1p<NCh> fDspLpf1p; sfzLpf1p fDspLpf1p;
sfzLpf2p<NCh> fDspLpf2p; sfzLpf2p fDspLpf2p;
sfzLpf4p<NCh> fDspLpf4p; sfzLpf4p fDspLpf4p;
sfzLpf6p<NCh> fDspLpf6p; sfzLpf6p fDspLpf6p;
sfzHpf1p<NCh> fDspHpf1p; sfzHpf1p fDspHpf1p;
sfzHpf2p<NCh> fDspHpf2p; sfzHpf2p fDspHpf2p;
sfzHpf4p<NCh> fDspHpf4p; sfzHpf4p fDspHpf4p;
sfzHpf6p<NCh> fDspHpf6p; sfzHpf6p fDspHpf6p;
sfzBpf1p<NCh> fDspBpf1p; sfzBpf1p fDspBpf1p;
sfzBpf2p<NCh> fDspBpf2p; sfzBpf2p fDspBpf2p;
sfzBpf4p<NCh> fDspBpf4p; sfzBpf4p fDspBpf4p;
sfzBpf6p<NCh> fDspBpf6p; sfzBpf6p fDspBpf6p;
sfzApf1p<NCh> fDspApf1p; sfzApf1p fDspApf1p;
sfzBrf1p<NCh> fDspBrf1p; sfzBrf1p fDspBrf1p;
sfzBrf2p<NCh> fDspBrf2p; sfzBrf2p fDspBrf2p;
sfzPink<NCh> fDspPink; sfzPink fDspPink;
sfzLpf2pSv<NCh> fDspLpf2pSv; sfzLpf2pSv fDspLpf2pSv;
sfzHpf2pSv<NCh> fDspHpf2pSv; sfzHpf2pSv fDspHpf2pSv;
sfzBpf2pSv<NCh> fDspBpf2pSv; sfzBpf2pSv fDspBpf2pSv;
sfzBrf2pSv<NCh> fDspBrf2pSv; sfzBrf2pSv fDspBrf2pSv;
sfzLsh<NCh> fDspLsh; sfzLsh fDspLsh;
sfzHsh<NCh> fDspHsh; sfzHsh fDspHsh;
sfzPeq<NCh> fDspPeq; sfzPeq fDspPeq;
template <class F> static void process(F &filter, const float *const in[NCh], float *const out[NCh], float cutoff, float q, float pksh, unsigned nframes); sfz2chLpf1p fDsp2chLpf1p;
template <class F> static void processModulated(F &filter, const float *const in[NCh], float *const out[NCh], const float *cutoff, const float *q, const float *pksh, unsigned nframes); sfz2chLpf2p fDsp2chLpf2p;
sfz2chLpf4p fDsp2chLpf4p;
sfz2chLpf6p fDsp2chLpf6p;
sfz2chHpf1p fDsp2chHpf1p;
sfz2chHpf2p fDsp2chHpf2p;
sfz2chHpf4p fDsp2chHpf4p;
sfz2chHpf6p fDsp2chHpf6p;
sfz2chBpf1p fDsp2chBpf1p;
sfz2chBpf2p fDsp2chBpf2p;
sfz2chBpf4p fDsp2chBpf4p;
sfz2chBpf6p fDsp2chBpf6p;
sfz2chApf1p fDsp2chApf1p;
sfz2chBrf1p fDsp2chBrf1p;
sfz2chBrf2p fDsp2chBrf2p;
sfz2chPink fDsp2chPink;
sfz2chLpf2pSv fDsp2chLpf2pSv;
sfz2chHpf2pSv fDsp2chHpf2pSv;
sfz2chBpf2pSv fDsp2chBpf2pSv;
sfz2chBrf2pSv fDsp2chBrf2pSv;
sfz2chLsh fDsp2chLsh;
sfz2chHsh fDsp2chHsh;
sfz2chPeq fDsp2chPeq;
sfzFilterDsp *getDsp(unsigned channels, FilterType type);
static constexpr uint32_t idDsp(unsigned channels, FilterType type)
{
return static_cast<unsigned>(type)|(channels << 16);
}
}; };
template <unsigned NCh> Filter::Filter()
Filter<NCh>::Filter()
: P{new Impl} : P{new Impl}
{ {
} }
template <unsigned NCh> Filter::~Filter()
Filter<NCh>::~Filter()
{ {
} }
template <unsigned NCh> void Filter::init(double sampleRate)
void Filter<NCh>::init(double sampleRate)
{ {
P->fDspLpf1p.init(sampleRate); for (unsigned channels = 1; channels <= Impl::maxChannels; ++channels) {
P->fDspLpf2p.init(sampleRate); FilterType ftype = static_cast<FilterType>(1);
P->fDspLpf4p.init(sampleRate); while (sfzFilterDsp *dsp = P->getDsp(channels, ftype)) {
P->fDspLpf6p.init(sampleRate); dsp->init(sampleRate);
P->fDspHpf1p.init(sampleRate); ftype = static_cast<FilterType>(static_cast<int>(ftype) + 1);
P->fDspHpf2p.init(sampleRate); }
P->fDspHpf4p.init(sampleRate);
P->fDspHpf6p.init(sampleRate);
P->fDspBpf1p.init(sampleRate);
P->fDspBpf2p.init(sampleRate);
P->fDspBpf4p.init(sampleRate);
P->fDspBpf6p.init(sampleRate);
P->fDspApf1p.init(sampleRate);
P->fDspBrf1p.init(sampleRate);
P->fDspBrf2p.init(sampleRate);
P->fDspPink.init(sampleRate);
P->fDspLpf2pSv.init(sampleRate);
P->fDspHpf2pSv.init(sampleRate);
P->fDspBpf2pSv.init(sampleRate);
P->fDspBrf2pSv.init(sampleRate);
P->fDspLsh.init(sampleRate);
P->fDspHsh.init(sampleRate);
P->fDspPeq.init(sampleRate);
}
template <unsigned NCh>
void Filter<NCh>::clear()
{
switch (P->fType) {
case kFilterNone: break;
case kFilterApf1p: P->fDspApf1p.instanceClear(); break;
case kFilterBpf1p: P->fDspBpf1p.instanceClear(); break;
case kFilterBpf2p: P->fDspBpf2p.instanceClear(); break;
case kFilterBpf4p: P->fDspBpf4p.instanceClear(); break;
case kFilterBpf6p: P->fDspBpf6p.instanceClear(); break;
case kFilterBrf1p: P->fDspBrf1p.instanceClear(); break;
case kFilterBrf2p: P->fDspBrf2p.instanceClear(); break;
case kFilterHpf1p: P->fDspHpf1p.instanceClear(); break;
case kFilterHpf2p: P->fDspHpf2p.instanceClear(); break;
case kFilterHpf4p: P->fDspHpf4p.instanceClear(); break;
case kFilterHpf6p: P->fDspHpf6p.instanceClear(); break;
case kFilterLpf1p: P->fDspLpf1p.instanceClear(); break;
case kFilterLpf2p: P->fDspLpf2p.instanceClear(); break;
case kFilterLpf4p: P->fDspLpf4p.instanceClear(); break;
case kFilterLpf6p: P->fDspLpf6p.instanceClear(); break;
case kFilterPink: P->fDspPink.instanceClear(); break;
case kFilterLpf2pSv: P->fDspLpf2pSv.instanceClear(); break;
case kFilterHpf2pSv: P->fDspHpf2pSv.instanceClear(); break;
case kFilterBpf2pSv: P->fDspBpf2pSv.instanceClear(); break;
case kFilterBrf2pSv: P->fDspBrf2pSv.instanceClear(); break;
case kFilterLsh: P->fDspLsh.instanceClear(); break;
case kFilterHsh: P->fDspHsh.instanceClear(); break;
case kFilterPeq: P->fDspPeq.instanceClear(); break;
} }
} }
template <unsigned NCh> void Filter::clear()
template <class F>
void Filter<NCh>::Impl::process(F &filter, const float *const in[NCh], float *const out[NCh], float cutoff, float q, float pksh, unsigned nframes)
{ {
filter.setCutoff(cutoff); sfzFilterDsp *dsp = P->getDsp(P->fChannels, P->fType);
filter.setQ(q);
filter.setPkShGain(pksh); if (dsp)
filter.compute(nframes, const_cast<float **>(in), const_cast<float **>(out)); dsp->instanceClear();
} }
template <unsigned NCh> void Filter::process(const float *const in[], float *const out[], float cutoff, float q, float pksh, unsigned nframes)
void Filter<NCh>::process(const float *const in[NCh], float *const out[NCh], float cutoff, float q, float pksh, unsigned nframes)
{ {
if (P->fType == kFilterNone) { unsigned channels = P->fChannels;
for (unsigned c = 0; c < NCh; ++c) sfzFilterDsp *dsp = P->getDsp(channels, P->fType);
if (!dsp) {
for (unsigned c = 0; c < channels; ++c)
copy<float>({ in[c], nframes }, { out[c], nframes }); copy<float>({ in[c], nframes }, { out[c], nframes });
return; return;
} }
switch (P->fType) { dsp->configureStandard(cutoff, q, pksh);
case kFilterApf1p: P->process(P->fDspApf1p, in, out, cutoff, q, pksh, nframes); break; dsp->compute(nframes, const_cast<float **>(in), const_cast<float **>(out));
case kFilterBpf1p: P->process(P->fDspBpf1p, in, out, cutoff, q, pksh, nframes); break;
case kFilterBpf2p: P->process(P->fDspBpf2p, in, out, cutoff, q, pksh, nframes); break;
case kFilterBpf4p: P->process(P->fDspBpf4p, in, out, cutoff, q, pksh, nframes); break;
case kFilterBpf6p: P->process(P->fDspBpf6p, in, out, cutoff, q, pksh, nframes); break;
case kFilterBrf1p: P->process(P->fDspBrf1p, in, out, cutoff, q, pksh, nframes); break;
case kFilterBrf2p: P->process(P->fDspBrf2p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf1p: P->process(P->fDspHpf1p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf2p: P->process(P->fDspHpf2p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf4p: P->process(P->fDspHpf4p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf6p: P->process(P->fDspHpf6p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf1p: P->process(P->fDspLpf1p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf2p: P->process(P->fDspLpf2p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf4p: P->process(P->fDspLpf4p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf6p: P->process(P->fDspLpf6p, in, out, cutoff, q, pksh, nframes); break;
case kFilterPink: P->process(P->fDspPink, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf2pSv: P->process(P->fDspLpf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf2pSv: P->process(P->fDspHpf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterBpf2pSv: P->process(P->fDspBpf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterBrf2pSv: P->process(P->fDspBrf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterLsh: P->process(P->fDspLsh, in, out, cutoff, q, pksh, nframes); break;
case kFilterHsh: P->process(P->fDspHsh, in, out, cutoff, q, pksh, nframes); break;
case kFilterPeq: P->process(P->fDspPeq, in, out, cutoff, q, pksh, nframes); break;
default: assert(false);
}
} }
template <unsigned NCh> void Filter::processModulated(const float *const in[], float *const out[], const float *cutoff, const float *q, const float *pksh, unsigned nframes)
template <class F>
void Filter<NCh>::Impl::processModulated(F &filter, const float *const in[NCh], float *const out[NCh], const float *cutoff, const float *q, const float *pksh, unsigned nframes)
{ {
unsigned frame = 0; unsigned channels = P->fChannels;
sfzFilterDsp *dsp = P->getDsp(channels, P->fType);
if (!dsp) {
for (unsigned c = 0; c < channels; ++c)
copy<float>({ in[c], nframes }, { out[c], nframes });
return;
}
unsigned frame = 0;
while (frame < nframes) { while (frame < nframes) {
unsigned current = nframes - frame; unsigned current = nframes - frame;
if (current > config::filterControlInterval) if (current > config::filterControlInterval)
current = config::filterControlInterval; current = config::filterControlInterval;
const float *current_in[NCh]; const float *current_in[Impl::maxChannels];
float *current_out[NCh]; float *current_out[Impl::maxChannels];
for (unsigned c = 0; c < NCh; ++c) { for (unsigned c = 0; c < channels; ++c) {
current_in[c] = in[c] + frame; current_in[c] = in[c] + frame;
current_out[c] = out[c] + frame; current_out[c] = out[c] + frame;
} }
filter.setCutoff(cutoff[frame]); dsp->configureStandard(cutoff[frame], q[frame], pksh[frame]);
filter.setQ(q[frame]); dsp->compute(current, const_cast<float **>(current_in), const_cast<float **>(current_out));
filter.setPkShGain(pksh[frame]);
filter.compute(current, const_cast<float **>(current_in), const_cast<float **>(current_out));
frame += current; frame += current;
} }
} }
template <unsigned NCh> unsigned Filter::channels() const
void Filter<NCh>::processModulated(const float *const in[NCh], float *const out[NCh], const float *cutoff, const float *q, const float *pksh, unsigned nframes)
{ {
if (P->fType == kFilterNone) { return P->fChannels;
for (unsigned c = 0; c < NCh; ++c) }
copy<float>({ in[c], nframes }, { out[c], nframes });
return;
}
switch (P->fType) { void Filter::setChannels(unsigned channels)
case kFilterApf1p: P->processModulated(P->fDspApf1p, in, out, cutoff, q, pksh, nframes); break; {
case kFilterBpf1p: P->processModulated(P->fDspBpf1p, in, out, cutoff, q, pksh, nframes); break; ASSERT(channels < Impl::maxChannels);
case kFilterBpf2p: P->processModulated(P->fDspBpf2p, in, out, cutoff, q, pksh, nframes); break; if (P->fChannels != channels) {
case kFilterBpf4p: P->processModulated(P->fDspBpf4p, in, out, cutoff, q, pksh, nframes); break; P->fChannels = channels;
case kFilterBpf6p: P->processModulated(P->fDspBpf6p, in, out, cutoff, q, pksh, nframes); break; clear();
case kFilterBrf1p: P->processModulated(P->fDspBrf1p, in, out, cutoff, q, pksh, nframes); break;
case kFilterBrf2p: P->processModulated(P->fDspBrf2p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf1p: P->processModulated(P->fDspHpf1p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf2p: P->processModulated(P->fDspHpf2p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf4p: P->processModulated(P->fDspHpf4p, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf6p: P->processModulated(P->fDspHpf6p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf1p: P->processModulated(P->fDspLpf1p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf2p: P->processModulated(P->fDspLpf2p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf4p: P->processModulated(P->fDspLpf4p, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf6p: P->processModulated(P->fDspLpf6p, in, out, cutoff, q, pksh, nframes); break;
case kFilterPink: P->processModulated(P->fDspPink, in, out, cutoff, q, pksh, nframes); break;
case kFilterLpf2pSv: P->processModulated(P->fDspLpf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterHpf2pSv: P->processModulated(P->fDspHpf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterBpf2pSv: P->processModulated(P->fDspBpf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterBrf2pSv: P->processModulated(P->fDspBrf2pSv, in, out, cutoff, q, pksh, nframes); break;
case kFilterLsh: P->processModulated(P->fDspLsh, in, out, cutoff, q, pksh, nframes); break;
case kFilterHsh: P->processModulated(P->fDspHsh, in, out, cutoff, q, pksh, nframes); break;
case kFilterPeq: P->processModulated(P->fDspPeq, in, out, cutoff, q, pksh, nframes); break;
default: assert(false);
} }
} }
template <unsigned NCh> FilterType Filter::type() const
FilterType Filter<NCh>::type() const
{ {
return P->fType; return P->fType;
} }
template <unsigned NCh> void Filter::setType(FilterType type)
void Filter<NCh>::setType(FilterType type)
{ {
if (P->fType != type) { if (P->fType != type) {
P->fType = type; P->fType = type;
@ -246,87 +180,171 @@ void Filter<NCh>::setType(FilterType type)
} }
} }
template class Filter<1>; sfzFilterDsp *Filter::Impl::getDsp(unsigned channels, FilterType type)
template class Filter<2>; {
switch (idDsp(channels, type)) {
default: return nullptr;
case idDsp(1, kFilterApf1p): return &fDspApf1p;
case idDsp(1, kFilterBpf1p): return &fDspBpf1p;
case idDsp(1, kFilterBpf2p): return &fDspBpf2p;
case idDsp(1, kFilterBpf4p): return &fDspBpf4p;
case idDsp(1, kFilterBpf6p): return &fDspBpf6p;
case idDsp(1, kFilterBrf1p): return &fDspBrf1p;
case idDsp(1, kFilterBrf2p): return &fDspBrf2p;
case idDsp(1, kFilterHpf1p): return &fDspHpf1p;
case idDsp(1, kFilterHpf2p): return &fDspHpf2p;
case idDsp(1, kFilterHpf4p): return &fDspHpf4p;
case idDsp(1, kFilterHpf6p): return &fDspHpf6p;
case idDsp(1, kFilterLpf1p): return &fDspLpf1p;
case idDsp(1, kFilterLpf2p): return &fDspLpf2p;
case idDsp(1, kFilterLpf4p): return &fDspLpf4p;
case idDsp(1, kFilterLpf6p): return &fDspLpf6p;
case idDsp(1, kFilterPink): return &fDspPink;
case idDsp(1, kFilterLpf2pSv): return &fDspLpf2pSv;
case idDsp(1, kFilterHpf2pSv): return &fDspHpf2pSv;
case idDsp(1, kFilterBpf2pSv): return &fDspBpf2pSv;
case idDsp(1, kFilterBrf2pSv): return &fDspBrf2pSv;
case idDsp(1, kFilterLsh): return &fDspLsh;
case idDsp(1, kFilterHsh): return &fDspHsh;
case idDsp(1, kFilterPeq): return &fDspPeq;
case idDsp(2, kFilterApf1p): return &fDsp2chApf1p;
case idDsp(2, kFilterBpf1p): return &fDsp2chBpf1p;
case idDsp(2, kFilterBpf2p): return &fDsp2chBpf2p;
case idDsp(2, kFilterBpf4p): return &fDsp2chBpf4p;
case idDsp(2, kFilterBpf6p): return &fDsp2chBpf6p;
case idDsp(2, kFilterBrf1p): return &fDsp2chBrf1p;
case idDsp(2, kFilterBrf2p): return &fDsp2chBrf2p;
case idDsp(2, kFilterHpf1p): return &fDsp2chHpf1p;
case idDsp(2, kFilterHpf2p): return &fDsp2chHpf2p;
case idDsp(2, kFilterHpf4p): return &fDsp2chHpf4p;
case idDsp(2, kFilterHpf6p): return &fDsp2chHpf6p;
case idDsp(2, kFilterLpf1p): return &fDsp2chLpf1p;
case idDsp(2, kFilterLpf2p): return &fDsp2chLpf2p;
case idDsp(2, kFilterLpf4p): return &fDsp2chLpf4p;
case idDsp(2, kFilterLpf6p): return &fDsp2chLpf6p;
case idDsp(2, kFilterPink): return &fDsp2chPink;
case idDsp(2, kFilterLpf2pSv): return &fDsp2chLpf2pSv;
case idDsp(2, kFilterHpf2pSv): return &fDsp2chHpf2pSv;
case idDsp(2, kFilterBpf2pSv): return &fDsp2chBpf2pSv;
case idDsp(2, kFilterBrf2pSv): return &fDsp2chBrf2pSv;
case idDsp(2, kFilterLsh): return &fDsp2chLsh;
case idDsp(2, kFilterHsh): return &fDsp2chHsh;
case idDsp(2, kFilterPeq): return &fDsp2chPeq;
}
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// SFZ v1 equalizer filter // SFZ v1 equalizer filter
template <unsigned NCh> struct FilterEq::Impl {
struct FilterEq<NCh>::Impl { unsigned fChannels = 1;
sfzEq<NCh> fDsp; enum { maxChannels = 2 };
sfzEq fDsp;
sfz2chEq fDsp2ch;
sfzFilterDsp *getDsp(unsigned channels);
}; };
template <unsigned NCh> FilterEq::FilterEq()
FilterEq<NCh>::FilterEq()
: P{new Impl} : P{new Impl}
{ {
} }
template <unsigned NCh> FilterEq::~FilterEq()
FilterEq<NCh>::~FilterEq()
{ {
} }
template <unsigned NCh> void FilterEq::init(double sampleRate)
void FilterEq<NCh>::init(double sampleRate)
{ {
sfzEq<NCh> &filter = P->fDsp; for (unsigned channels = 1; channels <= Impl::maxChannels; ++channels) {
sfzFilterDsp *dsp = P->getDsp(channels);
filter.init(sampleRate); dsp->init(sampleRate);
}
} }
template <unsigned NCh> void FilterEq::clear()
void FilterEq<NCh>::clear()
{ {
sfzEq<NCh> &filter = P->fDsp; sfzFilterDsp *dsp = P->getDsp(P->fChannels);
filter.instanceClear(); if (dsp)
dsp->instanceClear();
} }
template <unsigned NCh> void FilterEq::process(const float *const in[], float *const out[], float cutoff, float bw, float pksh, unsigned nframes)
void FilterEq<NCh>::process(const float *const in[NCh], float *const out[NCh], float cutoff, float bw, float pksh, unsigned nframes)
{ {
sfzEq<NCh> &filter = P->fDsp; unsigned channels = P->fChannels;
sfzFilterDsp *dsp = P->getDsp(channels);
filter.setCutoff(cutoff); if (!dsp) {
filter.setBandwidth(bw); for (unsigned c = 0; c < channels; ++c)
filter.setPkShGain(pksh); copy<float>({ in[c], nframes }, { out[c], nframes });
filter.compute(nframes, const_cast<float **>(in), const_cast<float **>(out)); return;
}
dsp->configureEq(cutoff, bw, pksh);
dsp->compute(nframes, const_cast<float **>(in), const_cast<float **>(out));
} }
template <unsigned NCh> void FilterEq::processModulated(const float *const in[], float *const out[], const float *cutoff, const float *bw, const float *pksh, unsigned nframes)
void FilterEq<NCh>::processModulated(const float *const in[NCh], float *const out[NCh], const float *cutoff, const float *bw, const float *pksh, unsigned nframes)
{ {
sfzEq<NCh> &filter = P->fDsp; unsigned channels = P->fChannels;
sfzFilterDsp *dsp = P->getDsp(channels);
if (!dsp) {
for (unsigned c = 0; c < channels; ++c)
copy<float>({ in[c], nframes }, { out[c], nframes });
return;
}
unsigned frame = 0; unsigned frame = 0;
while (frame < nframes) { while (frame < nframes) {
unsigned current = nframes - frame; unsigned current = nframes - frame;
if (current > config::filterControlInterval) if (current > config::filterControlInterval)
current = config::filterControlInterval; current = config::filterControlInterval;
const float *current_in[NCh]; const float *current_in[Impl::maxChannels];
float *current_out[NCh]; float *current_out[Impl::maxChannels];
for (unsigned c = 0; c < NCh; ++c) { for (unsigned c = 0; c < channels; ++c) {
current_in[c] = in[c] + frame; current_in[c] = in[c] + frame;
current_out[c] = out[c] + frame; current_out[c] = out[c] + frame;
} }
filter.setCutoff(cutoff[frame]); dsp->configureEq(cutoff[frame], bw[frame], pksh[frame]);
filter.setBandwidth(bw[frame]); dsp->compute(current, const_cast<float **>(current_in), const_cast<float **>(current_out));
filter.setPkShGain(pksh[frame]);
filter.compute(current, const_cast<float **>(current_in), const_cast<float **>(current_out));
frame += current; frame += current;
} }
} }
template class FilterEq<1>;
template class FilterEq<2>; unsigned FilterEq::channels() const
{
return P->fChannels;
}
void FilterEq::setChannels(unsigned channels)
{
ASSERT(channels < Impl::maxChannels);
if (P->fChannels != channels) {
P->fChannels = channels;
clear();
}
}
sfzFilterDsp *FilterEq::Impl::getDsp(unsigned channels)
{
switch (channels) {
default: return nullptr;
case 1: return &fDsp;
case 2: return &fDsp2ch;
}
}
} // namespace sfz } // namespace sfz

34
src/sfizz/SfzFilter.h
View file

@ -13,14 +13,13 @@ enum FilterType : int;
/** /**
Multi-mode filter for SFZ v2 Multi-mode filter for SFZ v2
Available for mono and stereo. (NCh=1, NCh=2) Available for mono and stereo. (channels=1, channels=2)
Parameters: Parameters:
`cutoff`: it's the opcode `filN_cutoff` (Hz) `cutoff`: it's the opcode `filN_cutoff` (Hz)
`q`: it's the opcode `filN_resonance` (dB) `q`: it's the opcode `filN_resonance` (dB)
`pksh`: it's the opcode `filN_gain` (dB) `pksh`: it's the opcode `filN_gain` (dB)
*/ */
template <unsigned NCh>
class Filter { class Filter {
public: public:
Filter(); Filter();
@ -44,7 +43,7 @@ public:
`pksh` is a peak/shelf gain expressed in dB. `pksh` is a peak/shelf gain expressed in dB.
`in[i]` and `out[i]` may refer to identical buffers, for in-place processing `in[i]` and `out[i]` may refer to identical buffers, for in-place processing
*/ */
void process(const float *const in[NCh], float *const out[NCh], float cutoff, float q, float pksh, unsigned nframes); void process(const float *const in[], float *const out[], float cutoff, float q, float pksh, unsigned nframes);
/** /**
Process one cycle of the filter with cutoff and Q values varying over time. Process one cycle of the filter with cutoff and Q values varying over time.
@ -53,7 +52,17 @@ public:
`pksh` is a peak/shelf gain expressed in dB. `pksh` is a peak/shelf gain expressed in dB.
`in[i]` and `out[i]` may refer to identical buffers, for in-place processing `in[i]` and `out[i]` may refer to identical buffers, for in-place processing
*/ */
void processModulated(const float *const in[NCh], float *const out[NCh], const float *cutoff, const float *q, const float *pksh, unsigned nframes); void processModulated(const float *const in[], float *const out[], const float *cutoff, const float *q, const float *pksh, unsigned nframes);
/**
Get the number of channels.
*/
unsigned channels() const;
/**
Set the number of channels.
*/
void setChannels(unsigned channels);
/** /**
Get the type of filter. Get the type of filter.
@ -99,14 +108,13 @@ enum FilterType : int {
/** /**
Equalizer filter for SFZ v1 Equalizer filter for SFZ v1
Available for mono and stereo. (NCh=1, NCh=2) Available for mono and stereo. (channels=1, channels=2)
Parameters: Parameters:
`cutoff`: it's the opcode `egN_freq` (Hz) `cutoff`: it's the opcode `egN_freq` (Hz)
`bw`: it's the opcode `eqN_bw` (octave) `bw`: it's the opcode `eqN_bw` (octave)
`pksh`: it's the opcode `eqN_gain` (dB) `pksh`: it's the opcode `eqN_gain` (dB)
*/ */
template <unsigned NCh>
class FilterEq { class FilterEq {
public: public:
FilterEq(); FilterEq();
@ -130,7 +138,7 @@ public:
`pksh` is a peak/shelf gain expressed in dB. `pksh` is a peak/shelf gain expressed in dB.
`in[i]` and `out[i]` may refer to identical buffers, for in-place processing `in[i]` and `out[i]` may refer to identical buffers, for in-place processing
*/ */
void process(const float *const in[NCh], float *const out[NCh], float cutoff, float bw, float pksh, unsigned nframes); void process(const float *const in[], float *const out[], float cutoff, float bw, float pksh, unsigned nframes);
/** /**
Process one cycle of the filter with cutoff and bandwidth values varying over time. Process one cycle of the filter with cutoff and bandwidth values varying over time.
@ -139,7 +147,17 @@ public:
`pksh` is a peak/shelf gain expressed in dB. `pksh` is a peak/shelf gain expressed in dB.
`in[i]` and `out[i]` may refer to identical buffers, for in-place processing `in[i]` and `out[i]` may refer to identical buffers, for in-place processing
*/ */
void processModulated(const float *const in[NCh], float *const out[NCh], const float *cutoff, const float *bw, const float *pksh, unsigned nframes); void processModulated(const float *const in[], float *const out[], const float *cutoff, const float *bw, const float *pksh, unsigned nframes);
/**
Get the number of channels.
*/
unsigned channels() const;
/**
Set the number of channels.
*/
void setChannels(unsigned channels);
private: private:
struct Impl; struct Impl;

182
src/sfizz/SfzFilterImpls.cxx
View file

@ -4,10 +4,24 @@
// license. You should have receive a LICENSE.md file along with the code. // license. You should have receive a LICENSE.md file along with the code.
// If not, contact the sfizz maintainers at https://github.com/sfztools/sfizz // If not, contact the sfizz maintainers at https://github.com/sfztools/sfizz
struct dsp {};
struct Meta {}; struct Meta {};
struct UI {}; struct UI {};
/**
Base of the faust DSP for filters
*/
struct sfzFilterDsp {
public:
virtual ~sfzFilterDsp() {}
virtual void init(int) = 0;
virtual void instanceClear() = 0;
virtual void compute(int, float **, float **) = 0;
virtual void configureStandard(float, float, float) {}
virtual void configureEq(float, float, float) {}
};
#if defined(__GNUC__) || defined(__clang__) #if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter" #pragma GCC diagnostic ignored "-Wunused-parameter"
@ -72,9 +86,12 @@ struct UI {};
Parameterized by cutoff and Q Parameterized by cutoff and Q
*/ */
template <class F> struct sfzFilter : public F { template <class F> struct sfzFilter : public F {
void setCutoff(float v) { F::fCutoff = v; } void configureStandard(float cutoff, float q, float pksh) override
void setQ(float v) { F::fQ = v; } {
void setPkShGain(float) {} F::fCutoff = cutoff;
F::fQ = q;
(void)pksh;
}
}; };
/** /**
@ -82,9 +99,12 @@ template <class F> struct sfzFilter : public F {
Parameterized by cutoff only Parameterized by cutoff only
*/ */
template <class F> struct sfzFilterNoQ : public F { template <class F> struct sfzFilterNoQ : public F {
void setCutoff(float v) { F::fCutoff = v; } void configureStandard(float cutoff, float q, float pksh) override
void setQ(float) {} {
void setPkShGain(float) {} F::fCutoff = cutoff;
(void)q;
(void)pksh;
}
}; };
/** /**
@ -92,9 +112,12 @@ template <class F> struct sfzFilterNoQ : public F {
Not parameterized Not parameterized
*/ */
template <class F> struct sfzFilterNoCutoff : public F { template <class F> struct sfzFilterNoCutoff : public F {
void setCutoff(float) {} void configureStandard(float cutoff, float q, float pksh) override
void setQ(float) {} {
void setPkShGain(float) {} (void)cutoff;
(void)q;
(void)pksh;
}
}; };
/** /**
@ -102,9 +125,12 @@ template <class F> struct sfzFilterNoCutoff : public F {
Parameterized by cutoff, Q, peak/shelf gain Parameterized by cutoff, Q, peak/shelf gain
*/ */
template <class F> struct sfzFilterPkSh : public F { template <class F> struct sfzFilterPkSh : public F {
void setCutoff(float v) { F::fCutoff = v; } void configureStandard(float cutoff, float q, float pksh) override
void setQ(float v) { F::fQ = v; } {
void setPkShGain(float v) { F::fPkShGain = v; } F::fCutoff = cutoff;
F::fQ = q;
F::fPkShGain = pksh;
}
}; };
/** /**
@ -112,82 +138,60 @@ template <class F> struct sfzFilterPkSh : public F {
Parameterized by cutoff, bandwidth, peak/shelf gain Parameterized by cutoff, bandwidth, peak/shelf gain
*/ */
template <class F> struct sfzFilterEq : public F { template <class F> struct sfzFilterEq : public F {
void setCutoff(float v) { F::fCutoff = v; } void configureEq(float cutoff, float bw, float pksh) override
void setBandwidth(float v) { F::fBandwidth = v; } {
void setPkShGain(float v) { F::fPkShGain = v; } F::fCutoff = cutoff;
F::fBandwidth = bw;
F::fPkShGain = pksh;
}
}; };
template <unsigned NCh> struct sfzLpf1p; struct sfzLpf1p final : public sfzFilterNoQ<faustLpf1p> {};
template <unsigned NCh> struct sfzLpf2p; struct sfzLpf2p final : public sfzFilter<faustLpf2p> {};
template <unsigned NCh> struct sfzLpf4p; struct sfzLpf4p final : public sfzFilter<faustLpf4p> {};
template <unsigned NCh> struct sfzLpf6p; struct sfzLpf6p final : public sfzFilter<faustLpf6p> {};
template <unsigned NCh> struct sfzHpf1p; struct sfzHpf1p final : public sfzFilterNoQ<faustHpf1p> {};
template <unsigned NCh> struct sfzHpf2p; struct sfzHpf2p final : public sfzFilter<faustHpf2p> {};
template <unsigned NCh> struct sfzHpf4p; struct sfzHpf4p final : public sfzFilter<faustHpf4p> {};
template <unsigned NCh> struct sfzHpf6p; struct sfzHpf6p final : public sfzFilter<faustHpf6p> {};
template <unsigned NCh> struct sfzBpf1p; struct sfzBpf1p final : public sfzFilterNoQ<faustBpf1p> {};
template <unsigned NCh> struct sfzBpf2p; struct sfzBpf2p final : public sfzFilter<faustBpf2p> {};
template <unsigned NCh> struct sfzBpf4p; struct sfzBpf4p final : public sfzFilter<faustBpf4p> {};
template <unsigned NCh> struct sfzBpf6p; struct sfzBpf6p final : public sfzFilter<faustBpf6p> {};
template <unsigned NCh> struct sfzApf1p; struct sfzApf1p final : public sfzFilterNoQ<faustApf1p> {};
template <unsigned NCh> struct sfzBrf1p; struct sfzBrf1p final : public sfzFilterNoQ<faustBrf1p> {};
template <unsigned NCh> struct sfzBrf2p; struct sfzBrf2p final : public sfzFilter<faustBrf2p> {};
template <unsigned NCh> struct sfzPink; struct sfzPink final : public sfzFilterNoCutoff<faustPink> {};
template <unsigned NCh> struct sfzLpf2pSv; struct sfzLpf2pSv final : public sfzFilter<faustLpf2pSv> {};
template <unsigned NCh> struct sfzHpf2pSv; struct sfzHpf2pSv final : public sfzFilter<faustHpf2pSv> {};
template <unsigned NCh> struct sfzBpf2pSv; struct sfzBpf2pSv final : public sfzFilter<faustBpf2pSv> {};
template <unsigned NCh> struct sfzBrf2pSv; struct sfzBrf2pSv final : public sfzFilter<faustBrf2pSv> {};
template <unsigned NCh> struct sfzLsh; struct sfzLsh final : public sfzFilterPkSh<faustLsh> {};
template <unsigned NCh> struct sfzHsh; struct sfzHsh final : public sfzFilterPkSh<faustHsh> {};
template <unsigned NCh> struct sfzPeq; struct sfzPeq final : public sfzFilterPkSh<faustPeq> {};
template <unsigned NCh> struct sfzEq; struct sfzEq final : public sfzFilterEq<faustEq> {};
template<> struct sfzLpf1p<1> : public sfzFilterNoQ<faustLpf1p> {}; struct sfz2chLpf1p final : public sfzFilterNoQ<faust2chLpf1p> {};
template<> struct sfzLpf2p<1> : public sfzFilter<faustLpf2p> {}; struct sfz2chLpf2p final : public sfzFilter<faust2chLpf2p> {};
template<> struct sfzLpf4p<1> : public sfzFilter<faustLpf4p> {}; struct sfz2chLpf4p final : public sfzFilter<faust2chLpf4p> {};
template<> struct sfzLpf6p<1> : public sfzFilter<faustLpf6p> {}; struct sfz2chLpf6p final : public sfzFilter<faust2chLpf6p> {};
template<> struct sfzHpf1p<1> : public sfzFilterNoQ<faustHpf1p> {}; struct sfz2chHpf1p final : public sfzFilterNoQ<faust2chHpf1p> {};
template<> struct sfzHpf2p<1> : public sfzFilter<faustHpf2p> {}; struct sfz2chHpf2p final : public sfzFilter<faust2chHpf2p> {};
template<> struct sfzHpf4p<1> : public sfzFilter<faustHpf4p> {}; struct sfz2chHpf4p final : public sfzFilter<faust2chHpf4p> {};
template<> struct sfzHpf6p<1> : public sfzFilter<faustHpf6p> {}; struct sfz2chHpf6p final : public sfzFilter<faust2chHpf6p> {};
template<> struct sfzBpf1p<1> : public sfzFilterNoQ<faustBpf1p> {}; struct sfz2chBpf1p final : public sfzFilterNoQ<faust2chBpf1p> {};
template<> struct sfzBpf2p<1> : public sfzFilter<faustBpf2p> {}; struct sfz2chBpf2p final : public sfzFilter<faust2chBpf2p> {};
template<> struct sfzBpf4p<1> : public sfzFilter<faustBpf4p> {}; struct sfz2chBpf4p final : public sfzFilter<faust2chBpf4p> {};
template<> struct sfzBpf6p<1> : public sfzFilter<faustBpf6p> {}; struct sfz2chBpf6p final : public sfzFilter<faust2chBpf6p> {};
template<> struct sfzApf1p<1> : public sfzFilterNoQ<faustApf1p> {}; struct sfz2chApf1p final : public sfzFilterNoQ<faust2chApf1p> {};
template<> struct sfzBrf1p<1> : public sfzFilterNoQ<faustBrf1p> {}; struct sfz2chBrf1p final : public sfzFilterNoQ<faust2chBrf1p> {};
template<> struct sfzBrf2p<1> : public sfzFilter<faustBrf2p> {}; struct sfz2chBrf2p final : public sfzFilter<faust2chBrf2p> {};
template<> struct sfzPink<1> : public sfzFilterNoCutoff<faustPink> {}; struct sfz2chPink final : public sfzFilterNoCutoff<faust2chPink> {};
template<> struct sfzLpf2pSv<1> : public sfzFilter<faustLpf2pSv> {}; struct sfz2chLpf2pSv final : public sfzFilter<faust2chLpf2pSv> {};
template<> struct sfzHpf2pSv<1> : public sfzFilter<faustHpf2pSv> {}; struct sfz2chHpf2pSv final : public sfzFilter<faust2chHpf2pSv> {};
template<> struct sfzBpf2pSv<1> : public sfzFilter<faustBpf2pSv> {}; struct sfz2chBpf2pSv final : public sfzFilter<faust2chBpf2pSv> {};
template<> struct sfzBrf2pSv<1> : public sfzFilter<faustBrf2pSv> {}; struct sfz2chBrf2pSv final : public sfzFilter<faust2chBrf2pSv> {};
template<> struct sfzLsh<1> : public sfzFilterPkSh<faustLsh> {}; struct sfz2chLsh final : public sfzFilterPkSh<faust2chLsh> {};
template<> struct sfzHsh<1> : public sfzFilterPkSh<faustHsh> {}; struct sfz2chHsh final : public sfzFilterPkSh<faust2chHsh> {};
template<> struct sfzPeq<1> : public sfzFilterPkSh<faustPeq> {}; struct sfz2chPeq final : public sfzFilterPkSh<faust2chPeq> {};
template<> struct sfzEq<1> : public sfzFilterEq<faustEq> {}; struct sfz2chEq final : public sfzFilterEq<faust2chEq> {};
template<> struct sfzLpf1p<2> : public sfzFilterNoQ<faust2chLpf1p> {};
template<> struct sfzLpf2p<2> : public sfzFilter<faust2chLpf2p> {};
template<> struct sfzLpf4p<2> : public sfzFilter<faust2chLpf4p> {};
template<> struct sfzLpf6p<2> : public sfzFilter<faust2chLpf6p> {};
template<> struct sfzHpf1p<2> : public sfzFilterNoQ<faust2chHpf1p> {};
template<> struct sfzHpf2p<2> : public sfzFilter<faust2chHpf2p> {};
template<> struct sfzHpf4p<2> : public sfzFilter<faust2chHpf4p> {};
template<> struct sfzHpf6p<2> : public sfzFilter<faust2chHpf6p> {};
template<> struct sfzBpf1p<2> : public sfzFilterNoQ<faust2chBpf1p> {};
template<> struct sfzBpf2p<2> : public sfzFilter<faust2chBpf2p> {};
template<> struct sfzBpf4p<2> : public sfzFilter<faust2chBpf4p> {};
template<> struct sfzBpf6p<2> : public sfzFilter<faust2chBpf6p> {};
template<> struct sfzApf1p<2> : public sfzFilterNoQ<faust2chApf1p> {};
template<> struct sfzBrf1p<2> : public sfzFilterNoQ<faust2chBrf1p> {};
template<> struct sfzBrf2p<2> : public sfzFilter<faust2chBrf2p> {};
template<> struct sfzPink<2> : public sfzFilterNoCutoff<faust2chPink> {};
template<> struct sfzLpf2pSv<2> : public sfzFilter<faust2chLpf2pSv> {};
template<> struct sfzHpf2pSv<2> : public sfzFilter<faust2chHpf2pSv> {};
template<> struct sfzBpf2pSv<2> : public sfzFilter<faust2chBpf2pSv> {};
template<> struct sfzBrf2pSv<2> : public sfzFilter<faust2chBrf2pSv> {};
template<> struct sfzLsh<2> : public sfzFilterPkSh<faust2chLsh> {};
template<> struct sfzHsh<2> : public sfzFilterPkSh<faust2chHsh> {};
template<> struct sfzPeq<2> : public sfzFilterPkSh<faust2chPeq> {};
template<> struct sfzEq<2> : public sfzFilterEq<faust2chEq> {};

28
src/sfizz/gen/filters/sfz2chApf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chApf1p : public dsp { class faust2chApf1p : public sfzFilterDsp {
public: public:
@ -43,13 +43,13 @@ class faust2chApf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faust2chApf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -89,16 +89,16 @@ class faust2chApf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -110,28 +110,28 @@ class faust2chApf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chApf1p* clone() { virtual faust2chApf1p* clone() {
return new faust2chApf1p(); return new faust2chApf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBpf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBpf1p : public dsp { class faust2chBpf1p : public sfzFilterDsp {
public: public:
@ -45,13 +45,13 @@ class faust2chBpf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -69,7 +69,7 @@ class faust2chBpf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -91,16 +91,16 @@ class faust2chBpf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec2[l0] = 0.0; fRec2[l0] = 0.0;
} }
@ -118,28 +118,28 @@ class faust2chBpf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBpf1p* clone() { virtual faust2chBpf1p* clone() {
return new faust2chBpf1p(); return new faust2chBpf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBpf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBpf2p : public dsp { class faust2chBpf2p : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faust2chBpf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -72,7 +72,7 @@ class faust2chBpf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -94,17 +94,17 @@ class faust2chBpf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -128,28 +128,28 @@ class faust2chBpf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBpf2p* clone() { virtual faust2chBpf2p* clone() {
return new faust2chBpf2p(); return new faust2chBpf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBpf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBpf2pSv : public dsp { class faust2chBpf2pSv : public sfzFilterDsp {
public: public:
@ -49,13 +49,13 @@ class faust2chBpf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -73,7 +73,7 @@ class faust2chBpf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -95,17 +95,17 @@ class faust2chBpf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec3[l0] = 0.0; fRec3[l0] = 0.0;
} }
@ -132,28 +132,28 @@ class faust2chBpf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBpf2pSv* clone() { virtual faust2chBpf2pSv* clone() {
return new faust2chBpf2pSv(); return new faust2chBpf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBpf4p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBpf4p : public dsp { class faust2chBpf4p : public sfzFilterDsp {
public: public:
@ -50,13 +50,13 @@ class faust2chBpf4p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -74,7 +74,7 @@ class faust2chBpf4p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -96,17 +96,17 @@ class faust2chBpf4p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -136,28 +136,28 @@ class faust2chBpf4p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBpf4p* clone() { virtual faust2chBpf4p* clone() {
return new faust2chBpf4p(); return new faust2chBpf4p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBpf6p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBpf6p : public dsp { class faust2chBpf6p : public sfzFilterDsp {
public: public:
@ -52,13 +52,13 @@ class faust2chBpf6p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -76,7 +76,7 @@ class faust2chBpf6p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -98,17 +98,17 @@ class faust2chBpf6p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -144,28 +144,28 @@ class faust2chBpf6p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBpf6p* clone() { virtual faust2chBpf6p* clone() {
return new faust2chBpf6p(); return new faust2chBpf6p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBrf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBrf1p : public dsp { class faust2chBrf1p : public sfzFilterDsp {
public: public:
@ -45,13 +45,13 @@ class faust2chBrf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -69,7 +69,7 @@ class faust2chBrf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -91,16 +91,16 @@ class faust2chBrf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec2[l0] = 0.0; fRec2[l0] = 0.0;
} }
@ -118,28 +118,28 @@ class faust2chBrf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBrf1p* clone() { virtual faust2chBrf1p* clone() {
return new faust2chBrf1p(); return new faust2chBrf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBrf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBrf2p : public dsp { class faust2chBrf2p : public sfzFilterDsp {
public: public:
@ -46,13 +46,13 @@ class faust2chBrf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -70,7 +70,7 @@ class faust2chBrf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -92,17 +92,17 @@ class faust2chBrf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -120,28 +120,28 @@ class faust2chBrf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBrf2p* clone() { virtual faust2chBrf2p* clone() {
return new faust2chBrf2p(); return new faust2chBrf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chBrf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chBrf2pSv : public dsp { class faust2chBrf2pSv : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faust2chBrf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -72,7 +72,7 @@ class faust2chBrf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -94,17 +94,17 @@ class faust2chBrf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec5[l0] = 0.0; fRec5[l0] = 0.0;
} }
@ -128,28 +128,28 @@ class faust2chBrf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chBrf2pSv* clone() { virtual faust2chBrf2pSv* clone() {
return new faust2chBrf2pSv(); return new faust2chBrf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chEq.cxx
View file

@ -28,7 +28,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chEq : public dsp { class faust2chEq : public sfzFilterDsp {
public: public:
@ -51,13 +51,13 @@ class faust2chEq : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -75,7 +75,7 @@ class faust2chEq : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -97,20 +97,20 @@ class faust2chEq : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))); fConst0 = std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)));
fConst1 = (6.2831853071795862 / fConst0); fConst1 = (6.2831853071795862 / fConst0);
fConst2 = (2.1775860903036022 / fConst0); fConst2 = (2.1775860903036022 / fConst0);
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fBandwidth = FAUSTFLOAT(1.0); fBandwidth = FAUSTFLOAT(1.0);
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -131,28 +131,28 @@ class faust2chEq : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chEq* clone() { virtual faust2chEq* clone() {
return new faust2chEq(); return new faust2chEq();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chHpf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chHpf1p : public dsp { class faust2chHpf1p : public sfzFilterDsp {
public: public:
@ -43,13 +43,13 @@ class faust2chHpf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faust2chHpf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -89,16 +89,16 @@ class faust2chHpf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -110,28 +110,28 @@ class faust2chHpf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chHpf1p* clone() { virtual faust2chHpf1p* clone() {
return new faust2chHpf1p(); return new faust2chHpf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chHpf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chHpf2p : public dsp { class faust2chHpf2p : public sfzFilterDsp {
public: public:
@ -47,13 +47,13 @@ class faust2chHpf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -71,7 +71,7 @@ class faust2chHpf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -93,17 +93,17 @@ class faust2chHpf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -124,28 +124,28 @@ class faust2chHpf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chHpf2p* clone() { virtual faust2chHpf2p* clone() {
return new faust2chHpf2p(); return new faust2chHpf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chHpf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chHpf2pSv : public dsp { class faust2chHpf2pSv : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faust2chHpf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -72,7 +72,7 @@ class faust2chHpf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -94,17 +94,17 @@ class faust2chHpf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec4[l0] = 0.0; fRec4[l0] = 0.0;
} }
@ -128,28 +128,28 @@ class faust2chHpf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chHpf2pSv* clone() { virtual faust2chHpf2pSv* clone() {
return new faust2chHpf2pSv(); return new faust2chHpf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chHpf4p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chHpf4p : public dsp { class faust2chHpf4p : public sfzFilterDsp {
public: public:
@ -49,13 +49,13 @@ class faust2chHpf4p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -73,7 +73,7 @@ class faust2chHpf4p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -95,17 +95,17 @@ class faust2chHpf4p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -132,28 +132,28 @@ class faust2chHpf4p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chHpf4p* clone() { virtual faust2chHpf4p* clone() {
return new faust2chHpf4p(); return new faust2chHpf4p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chHpf6p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chHpf6p : public dsp { class faust2chHpf6p : public sfzFilterDsp {
public: public:
@ -51,13 +51,13 @@ class faust2chHpf6p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -75,7 +75,7 @@ class faust2chHpf6p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -97,17 +97,17 @@ class faust2chHpf6p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -140,28 +140,28 @@ class faust2chHpf6p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chHpf6p* clone() { virtual faust2chHpf6p* clone() {
return new faust2chHpf6p(); return new faust2chHpf6p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chHsh.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chHsh : public dsp { class faust2chHsh : public sfzFilterDsp {
public: public:
@ -49,13 +49,13 @@ class faust2chHsh : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -73,7 +73,7 @@ class faust2chHsh : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -95,18 +95,18 @@ class faust2chHsh : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -130,28 +130,28 @@ class faust2chHsh : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chHsh* clone() { virtual faust2chHsh* clone() {
return new faust2chHsh(); return new faust2chHsh();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chLpf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chLpf1p : public dsp { class faust2chLpf1p : public sfzFilterDsp {
public: public:
@ -43,13 +43,13 @@ class faust2chLpf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faust2chLpf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -89,16 +89,16 @@ class faust2chLpf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -110,28 +110,28 @@ class faust2chLpf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chLpf1p* clone() { virtual faust2chLpf1p* clone() {
return new faust2chLpf1p(); return new faust2chLpf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chLpf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chLpf2p : public dsp { class faust2chLpf2p : public sfzFilterDsp {
public: public:
@ -47,13 +47,13 @@ class faust2chLpf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -71,7 +71,7 @@ class faust2chLpf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -93,17 +93,17 @@ class faust2chLpf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -124,28 +124,28 @@ class faust2chLpf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chLpf2p* clone() { virtual faust2chLpf2p* clone() {
return new faust2chLpf2p(); return new faust2chLpf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chLpf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chLpf2pSv : public dsp { class faust2chLpf2pSv : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faust2chLpf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -72,7 +72,7 @@ class faust2chLpf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -94,17 +94,17 @@ class faust2chLpf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec3[l0] = 0.0; fRec3[l0] = 0.0;
} }
@ -128,28 +128,28 @@ class faust2chLpf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chLpf2pSv* clone() { virtual faust2chLpf2pSv* clone() {
return new faust2chLpf2pSv(); return new faust2chLpf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chLpf4p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chLpf4p : public dsp { class faust2chLpf4p : public sfzFilterDsp {
public: public:
@ -49,13 +49,13 @@ class faust2chLpf4p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -73,7 +73,7 @@ class faust2chLpf4p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -95,17 +95,17 @@ class faust2chLpf4p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -132,28 +132,28 @@ class faust2chLpf4p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chLpf4p* clone() { virtual faust2chLpf4p* clone() {
return new faust2chLpf4p(); return new faust2chLpf4p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chLpf6p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chLpf6p : public dsp { class faust2chLpf6p : public sfzFilterDsp {
public: public:
@ -51,13 +51,13 @@ class faust2chLpf6p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -75,7 +75,7 @@ class faust2chLpf6p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -97,17 +97,17 @@ class faust2chLpf6p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -140,28 +140,28 @@ class faust2chLpf6p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chLpf6p* clone() { virtual faust2chLpf6p* clone() {
return new faust2chLpf6p(); return new faust2chLpf6p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chLsh.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chLsh : public dsp { class faust2chLsh : public sfzFilterDsp {
public: public:
@ -49,13 +49,13 @@ class faust2chLsh : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -73,7 +73,7 @@ class faust2chLsh : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -95,18 +95,18 @@ class faust2chLsh : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -130,28 +130,28 @@ class faust2chLsh : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chLsh* clone() { virtual faust2chLsh* clone() {
return new faust2chLsh(); return new faust2chLsh();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chPeq.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chPeq : public dsp { class faust2chPeq : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faust2chPeq : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -72,7 +72,7 @@ class faust2chPeq : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -94,18 +94,18 @@ class faust2chPeq : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -126,28 +126,28 @@ class faust2chPeq : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chPeq* clone() { virtual faust2chPeq* clone() {
return new faust2chPeq(); return new faust2chPeq();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfz2chPink.cxx
View file

@ -26,7 +26,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faust2chPink : public dsp { class faust2chPink : public sfzFilterDsp {
public: public:
@ -39,13 +39,13 @@ class faust2chPink : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 2; return 2;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 2; return 2;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -63,7 +63,7 @@ class faust2chPink : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -85,14 +85,14 @@ class faust2chPink : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 4); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 4); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -101,28 +101,28 @@ class faust2chPink : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faust2chPink* clone() { virtual faust2chPink* clone() {
return new faust2chPink(); return new faust2chPink();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* input1 = inputs[1]; FAUSTFLOAT* input1 = inputs[1];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];

28
src/sfizz/gen/filters/sfzApf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustApf1p : public dsp { class faustApf1p : public sfzFilterDsp {
public: public:
@ -42,13 +42,13 @@ class faustApf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -62,7 +62,7 @@ class faustApf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -80,16 +80,16 @@ class faustApf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -98,28 +98,28 @@ class faustApf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustApf1p* clone() { virtual faustApf1p* clone() {
return new faustApf1p(); return new faustApf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * ((fConst0 * double(fCutoff)) + -1.0)); double fSlow0 = (0.0010000000000000009 * ((fConst0 * double(fCutoff)) + -1.0));

28
src/sfizz/gen/filters/sfzBpf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBpf1p : public dsp { class faustBpf1p : public sfzFilterDsp {
public: public:
@ -43,13 +43,13 @@ class faustBpf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -63,7 +63,7 @@ class faustBpf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -81,16 +81,16 @@ class faustBpf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec2[l0] = 0.0; fRec2[l0] = 0.0;
} }
@ -102,28 +102,28 @@ class faustBpf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBpf1p* clone() { virtual faustBpf1p* clone() {
return new faustBpf1p(); return new faustBpf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * std::exp((fConst0 * (0.0 - (6.2831853071795862 * double(fCutoff)))))); double fSlow0 = (0.0010000000000000009 * std::exp((fConst0 * (0.0 - (6.2831853071795862 * double(fCutoff))))));

28
src/sfizz/gen/filters/sfzBpf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBpf2p : public dsp { class faustBpf2p : public sfzFilterDsp {
public: public:
@ -47,13 +47,13 @@ class faustBpf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faustBpf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -85,17 +85,17 @@ class faustBpf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -116,28 +116,28 @@ class faustBpf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBpf2p* clone() { virtual faustBpf2p* clone() {
return new faustBpf2p(); return new faustBpf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzBpf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBpf2pSv : public dsp { class faustBpf2pSv : public sfzFilterDsp {
public: public:
@ -47,13 +47,13 @@ class faustBpf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faustBpf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -85,17 +85,17 @@ class faustBpf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec3[l0] = 0.0; fRec3[l0] = 0.0;
} }
@ -116,28 +116,28 @@ class faustBpf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBpf2pSv* clone() { virtual faustBpf2pSv* clone() {
return new faustBpf2pSv(); return new faustBpf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff)))); double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff))));

28
src/sfizz/gen/filters/sfzBpf4p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBpf4p : public dsp { class faustBpf4p : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faustBpf4p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -68,7 +68,7 @@ class faustBpf4p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -86,17 +86,17 @@ class faustBpf4p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -120,28 +120,28 @@ class faustBpf4p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBpf4p* clone() { virtual faustBpf4p* clone() {
return new faustBpf4p(); return new faustBpf4p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzBpf6p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBpf6p : public dsp { class faustBpf6p : public sfzFilterDsp {
public: public:
@ -49,13 +49,13 @@ class faustBpf6p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -69,7 +69,7 @@ class faustBpf6p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -87,17 +87,17 @@ class faustBpf6p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -124,28 +124,28 @@ class faustBpf6p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBpf6p* clone() { virtual faustBpf6p* clone() {
return new faustBpf6p(); return new faustBpf6p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzBrf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBrf1p : public dsp { class faustBrf1p : public sfzFilterDsp {
public: public:
@ -43,13 +43,13 @@ class faustBrf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -63,7 +63,7 @@ class faustBrf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -81,16 +81,16 @@ class faustBrf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec2[l0] = 0.0; fRec2[l0] = 0.0;
} }
@ -102,28 +102,28 @@ class faustBrf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBrf1p* clone() { virtual faustBrf1p* clone() {
return new faustBrf1p(); return new faustBrf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * ((fConst0 * double(fCutoff)) + -1.0)); double fSlow0 = (0.0010000000000000009 * ((fConst0 * double(fCutoff)) + -1.0));

28
src/sfizz/gen/filters/sfzBrf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBrf2p : public dsp { class faustBrf2p : public sfzFilterDsp {
public: public:
@ -45,13 +45,13 @@ class faustBrf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -65,7 +65,7 @@ class faustBrf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -83,17 +83,17 @@ class faustBrf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -108,28 +108,28 @@ class faustBrf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBrf2p* clone() { virtual faustBrf2p* clone() {
return new faustBrf2p(); return new faustBrf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzBrf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustBrf2pSv : public dsp { class faustBrf2pSv : public sfzFilterDsp {
public: public:
@ -46,13 +46,13 @@ class faustBrf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -66,7 +66,7 @@ class faustBrf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -84,17 +84,17 @@ class faustBrf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec5[l0] = 0.0; fRec5[l0] = 0.0;
} }
@ -112,28 +112,28 @@ class faustBrf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustBrf2pSv* clone() { virtual faustBrf2pSv* clone() {
return new faustBrf2pSv(); return new faustBrf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff)))); double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff))));

28
src/sfizz/gen/filters/sfzEq.cxx
View file

@ -28,7 +28,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustEq : public dsp { class faustEq : public sfzFilterDsp {
public: public:
@ -50,13 +50,13 @@ class faustEq : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -70,7 +70,7 @@ class faustEq : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -88,20 +88,20 @@ class faustEq : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))); fConst0 = std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)));
fConst1 = (6.2831853071795862 / fConst0); fConst1 = (6.2831853071795862 / fConst0);
fConst2 = (2.1775860903036022 / fConst0); fConst2 = (2.1775860903036022 / fConst0);
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fBandwidth = FAUSTFLOAT(1.0); fBandwidth = FAUSTFLOAT(1.0);
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -119,28 +119,28 @@ class faustEq : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustEq* clone() { virtual faustEq* clone() {
return new faustEq(); return new faustEq();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = std::max<double>(0.0, double(fCutoff)); double fSlow0 = std::max<double>(0.0, double(fCutoff));

28
src/sfizz/gen/filters/sfzHpf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustHpf1p : public dsp { class faustHpf1p : public sfzFilterDsp {
public: public:
@ -42,13 +42,13 @@ class faustHpf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -62,7 +62,7 @@ class faustHpf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -80,16 +80,16 @@ class faustHpf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -98,28 +98,28 @@ class faustHpf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustHpf1p* clone() { virtual faustHpf1p* clone() {
return new faustHpf1p(); return new faustHpf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * std::exp((fConst0 * (0.0 - (6.2831853071795862 * double(fCutoff)))))); double fSlow0 = (0.0010000000000000009 * std::exp((fConst0 * (0.0 - (6.2831853071795862 * double(fCutoff))))));

28
src/sfizz/gen/filters/sfzHpf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustHpf2p : public dsp { class faustHpf2p : public sfzFilterDsp {
public: public:
@ -46,13 +46,13 @@ class faustHpf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -66,7 +66,7 @@ class faustHpf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -84,17 +84,17 @@ class faustHpf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -112,28 +112,28 @@ class faustHpf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustHpf2p* clone() { virtual faustHpf2p* clone() {
return new faustHpf2p(); return new faustHpf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzHpf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustHpf2pSv : public dsp { class faustHpf2pSv : public sfzFilterDsp {
public: public:
@ -46,13 +46,13 @@ class faustHpf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -66,7 +66,7 @@ class faustHpf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -84,17 +84,17 @@ class faustHpf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec4[l0] = 0.0; fRec4[l0] = 0.0;
} }
@ -112,28 +112,28 @@ class faustHpf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustHpf2pSv* clone() { virtual faustHpf2pSv* clone() {
return new faustHpf2pSv(); return new faustHpf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff)))); double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff))));

28
src/sfizz/gen/filters/sfzHpf4p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustHpf4p : public dsp { class faustHpf4p : public sfzFilterDsp {
public: public:
@ -47,13 +47,13 @@ class faustHpf4p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faustHpf4p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -85,17 +85,17 @@ class faustHpf4p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -116,28 +116,28 @@ class faustHpf4p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustHpf4p* clone() { virtual faustHpf4p* clone() {
return new faustHpf4p(); return new faustHpf4p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzHpf6p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustHpf6p : public dsp { class faustHpf6p : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faustHpf6p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -68,7 +68,7 @@ class faustHpf6p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -86,17 +86,17 @@ class faustHpf6p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -120,28 +120,28 @@ class faustHpf6p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustHpf6p* clone() { virtual faustHpf6p* clone() {
return new faustHpf6p(); return new faustHpf6p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzHsh.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustHsh : public dsp { class faustHsh : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faustHsh : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -68,7 +68,7 @@ class faustHsh : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -86,18 +86,18 @@ class faustHsh : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -118,28 +118,28 @@ class faustHsh : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustHsh* clone() { virtual faustHsh* clone() {
return new faustHsh(); return new faustHsh();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = std::pow(10.0, (0.025000000000000001 * double(fPkShGain))); double fSlow0 = std::pow(10.0, (0.025000000000000001 * double(fPkShGain)));

28
src/sfizz/gen/filters/sfzLpf1p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustLpf1p : public dsp { class faustLpf1p : public sfzFilterDsp {
public: public:
@ -42,13 +42,13 @@ class faustLpf1p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -62,7 +62,7 @@ class faustLpf1p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -80,16 +80,16 @@ class faustLpf1p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (1.0 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -98,28 +98,28 @@ class faustLpf1p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustLpf1p* clone() { virtual faustLpf1p* clone() {
return new faustLpf1p(); return new faustLpf1p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * std::exp((fConst0 * (0.0 - (6.2831853071795862 * double(fCutoff)))))); double fSlow0 = (0.0010000000000000009 * std::exp((fConst0 * (0.0 - (6.2831853071795862 * double(fCutoff))))));

28
src/sfizz/gen/filters/sfzLpf2p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustLpf2p : public dsp { class faustLpf2p : public sfzFilterDsp {
public: public:
@ -46,13 +46,13 @@ class faustLpf2p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -66,7 +66,7 @@ class faustLpf2p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -84,17 +84,17 @@ class faustLpf2p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -112,28 +112,28 @@ class faustLpf2p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustLpf2p* clone() { virtual faustLpf2p* clone() {
return new faustLpf2p(); return new faustLpf2p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzLpf2pSv.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustLpf2pSv : public dsp { class faustLpf2pSv : public sfzFilterDsp {
public: public:
@ -46,13 +46,13 @@ class faustLpf2pSv : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -66,7 +66,7 @@ class faustLpf2pSv : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -84,17 +84,17 @@ class faustLpf2pSv : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (3.1415926535897931 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec3[l0] = 0.0; fRec3[l0] = 0.0;
} }
@ -112,28 +112,28 @@ class faustLpf2pSv : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustLpf2pSv* clone() { virtual faustLpf2pSv* clone() {
return new faustLpf2pSv(); return new faustLpf2pSv();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff)))); double fSlow0 = (0.0010000000000000009 * std::tan((fConst0 * double(fCutoff))));

28
src/sfizz/gen/filters/sfzLpf4p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustLpf4p : public dsp { class faustLpf4p : public sfzFilterDsp {
public: public:
@ -47,13 +47,13 @@ class faustLpf4p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faustLpf4p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -85,17 +85,17 @@ class faustLpf4p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -116,28 +116,28 @@ class faustLpf4p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustLpf4p* clone() { virtual faustLpf4p* clone() {
return new faustLpf4p(); return new faustLpf4p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzLpf6p.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustLpf6p : public dsp { class faustLpf6p : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faustLpf6p : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -68,7 +68,7 @@ class faustLpf6p : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -86,17 +86,17 @@ class faustLpf6p : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
@ -120,28 +120,28 @@ class faustLpf6p : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustLpf6p* clone() { virtual faustLpf6p* clone() {
return new faustLpf6p(); return new faustLpf6p();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzLsh.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustLsh : public dsp { class faustLsh : public sfzFilterDsp {
public: public:
@ -48,13 +48,13 @@ class faustLsh : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -68,7 +68,7 @@ class faustLsh : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -86,18 +86,18 @@ class faustLsh : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -118,28 +118,28 @@ class faustLsh : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustLsh* clone() { virtual faustLsh* clone() {
return new faustLsh(); return new faustLsh();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = std::pow(10.0, (0.025000000000000001 * double(fPkShGain))); double fSlow0 = std::pow(10.0, (0.025000000000000001 * double(fPkShGain)));

28
src/sfizz/gen/filters/sfzPeq.cxx
View file

@ -27,7 +27,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustPeq : public dsp { class faustPeq : public sfzFilterDsp {
public: public:
@ -47,13 +47,13 @@ class faustPeq : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -67,7 +67,7 @@ class faustPeq : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -85,18 +85,18 @@ class faustPeq : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate)))); fConst0 = (6.2831853071795862 / std::min<double>(192000.0, std::max<double>(1.0, double(fSampleRate))));
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
fCutoff = FAUSTFLOAT(440.0); fCutoff = FAUSTFLOAT(440.0);
fQ = FAUSTFLOAT(0.0); fQ = FAUSTFLOAT(0.0);
fPkShGain = FAUSTFLOAT(0.0); fPkShGain = FAUSTFLOAT(0.0);
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
fRec1[l0] = 0.0; fRec1[l0] = 0.0;
} }
@ -114,28 +114,28 @@ class faustPeq : public dsp {
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustPeq* clone() { virtual faustPeq* clone() {
return new faustPeq(); return new faustPeq();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff))); double fSlow0 = (fConst0 * std::max<double>(0.0, double(fCutoff)));

28
src/sfizz/gen/filters/sfzPink.cxx
View file

@ -26,7 +26,7 @@ Compilation options: -lang cpp -inpl -double -ftz 0
#define exp10 __exp10 #define exp10 __exp10
#endif #endif
class faustPink : public dsp { class faustPink : public sfzFilterDsp {
public: public:
@ -38,13 +38,13 @@ class faustPink : public dsp {
void metadata(Meta* m) { void metadata(Meta* m) {
} }
int getNumInputs() { virtual int getNumInputs() {
return 1; return 1;
} }
int getNumOutputs() { virtual int getNumOutputs() {
return 1; return 1;
} }
int getInputRate(int channel) { virtual int getInputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -58,7 +58,7 @@ class faustPink : public dsp {
} }
return rate; return rate;
} }
int getOutputRate(int channel) { virtual int getOutputRate(int channel) {
int rate; int rate;
switch ((channel)) { switch ((channel)) {
case 0: { case 0: {
@ -76,41 +76,41 @@ class faustPink : public dsp {
static void classInit(int sample_rate) { static void classInit(int sample_rate) {
} }
void instanceConstants(int sample_rate) { virtual void instanceConstants(int sample_rate) {
fSampleRate = sample_rate; fSampleRate = sample_rate;
} }
void instanceResetUserInterface() { virtual void instanceResetUserInterface() {
} }
void instanceClear() { virtual void instanceClear() {
for (int l0 = 0; (l0 < 4); l0 = (l0 + 1)) { for (int l0 = 0; (l0 < 4); l0 = (l0 + 1)) {
fRec0[l0] = 0.0; fRec0[l0] = 0.0;
} }
} }
void init(int sample_rate) { virtual void init(int sample_rate) {
classInit(sample_rate); classInit(sample_rate);
instanceInit(sample_rate); instanceInit(sample_rate);
} }
void instanceInit(int sample_rate) { virtual void instanceInit(int sample_rate) {
instanceConstants(sample_rate); instanceConstants(sample_rate);
instanceResetUserInterface(); instanceResetUserInterface();
instanceClear(); instanceClear();
} }
faustPink* clone() { virtual faustPink* clone() {
return new faustPink(); return new faustPink();
} }
int getSampleRate() { virtual int getSampleRate() {
return fSampleRate; return fSampleRate;
} }
void buildUserInterface(UI* ui_interface) { virtual void buildUserInterface(UI* ui_interface) {
} }
void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
FAUSTFLOAT* input0 = inputs[0]; FAUSTFLOAT* input0 = inputs[0];
FAUSTFLOAT* output0 = outputs[0]; FAUSTFLOAT* output0 = outputs[0];
for (int i = 0; (i < count); i = (i + 1)) { for (int i = 0; (i < count); i = (i + 1)) {

13
tests/CMakeLists.txt
View file

@ -31,4 +31,17 @@ target_link_libraries(sfizz_tests PRIVATE sfizz::sfizz)
sfizz_enable_lto_if_needed(sfizz_tests) sfizz_enable_lto_if_needed(sfizz_tests)
# target_link_libraries(sfizz_tests PRIVATE absl::strings absl::str_format absl::flat_hash_map cnpy absl::span absl::algorithm) # target_link_libraries(sfizz_tests PRIVATE absl::strings absl::str_format absl::flat_hash_map cnpy absl::span absl::algorithm)
find_package(PkgConfig)
if(PKGCONFIG_FOUND)
pkg_check_modules(JACK "jack")
endif()
find_package(Qt5 COMPONENTS Widgets)
if(JACK_FOUND AND TARGET Qt5::Widgets)
add_executable(sfizz_demo_filters DemoFilters.cpp)
target_include_directories(sfizz_demo_filters PRIVATE ${JACK_INCLUDE_DIRS})
target_link_libraries(sfizz_demo_filters PRIVATE sfizz::sfizz Qt5::Widgets ${JACK_LIBRARIES})
set_target_properties(sfizz_demo_filters PROPERTIES AUTOUIC ON)
endif()
file(COPY "." DESTINATION ${CMAKE_BINARY_DIR}/tests) file(COPY "." DESTINATION ${CMAKE_BINARY_DIR}/tests)

325
tests/DemoFilters.cpp Normal file
View file

@ -0,0 +1,325 @@
// SPDX-License-Identifier: BSD-2-Clause
// This code is part of the sfizz library and is licensed under a BSD 2-clause
// license. You should have receive a LICENSE.md file along with the code.
// If not, contact the sfizz maintainers at https://github.com/sfztools/sfizz
#include "sfizz/SfzFilter.h"
#include "ui_DemoFilters.h"
#include <QApplication>
#include <QMainWindow>
#include <QMessageBox>
#include <QButtonGroup>
#include <QDebug>
#include <jack/jack.h>
#include <memory>
///
struct jack_delete {
void operator()(jack_client_t *x) const noexcept { jack_client_close(x); }
};
typedef std::unique_ptr<jack_client_t, jack_delete> jack_client_u;
///
class DemoApp : public QApplication {
public:
DemoApp(int &argc, char **argv);
bool initSound();
void initWindow();
private:
static int processAudio(jack_nframes_t nframes, void *cbdata);
private:
void valueChangedType(int value);
void valueChangedCutoff(int value);
void valueChangedResonance(int value);
void valueChangedPkShGain(int value);
void valueChangedBandwidth(int value);
void valueChangedFilterMode(int value);
private:
QMainWindow *fWindow = nullptr;
Ui::DemoFiltersWindow fUi;
static constexpr int cutoffMin = 10.0;
static constexpr int cutoffMax = 20000.0;
static constexpr int resoMin = 0.0;
static constexpr int resoMax = 40.0;
static constexpr int pkshMin = -40.0;
static constexpr int pkshMax = 40.0;
static constexpr int bwMin = 1.0;
static constexpr int bwMax = 10.0;
int fType = sfz::kFilterNone;
int fCutoff = 500.0;
int fReso = 0.0;
int fPksh = 20.0;
int fBw = 1.0;
sfz::Filter fFilter;
sfz::FilterEq fFilterEq;
enum FilterMode {
kFilterModeMulti,
kFilterModeEq,
};
FilterMode fFilterMode = kFilterModeMulti;
jack_client_u fClient;
jack_port_t *fPorts[4] = {};
};
DemoApp::DemoApp(int &argc, char **argv)
: QApplication(argc, argv)
{
setApplicationName(tr("Sfizz Filters"));
}
bool DemoApp::initSound()
{
jack_client_t *client = jack_client_open(
applicationName().toUtf8().data(), JackNoStartServer, nullptr);
if (!client) {
QMessageBox::critical(nullptr, tr("Error"), tr("Cannot open JACK audio."));
return false;
}
fClient.reset(client);
double sampleRate = jack_get_sample_rate(client);
fFilter.init(sampleRate);
fFilter.setChannels(2);
fFilterEq.init(sampleRate);
fFilterEq.setChannels(2);
fPorts[0] = jack_port_register(client, "in_left", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
fPorts[1] = jack_port_register(client, "in_right", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
fPorts[2] = jack_port_register(client, "out_left", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
fPorts[3] = jack_port_register(client, "out_right", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
if (!(fPorts[0] && fPorts[1] && fPorts[2] && fPorts[3])) {
QMessageBox::critical(nullptr, tr("Error"), tr("Cannot register JACK ports."));
return false;
}
jack_set_process_callback(client, &processAudio, this);
if (jack_activate(client) != 0) {
QMessageBox::critical(nullptr, tr("Error"), tr("Cannot activate JACK client."));
return false;
}
return true;
}
void DemoApp::initWindow()
{
QMainWindow *window = new QMainWindow;
fWindow = window;
fUi.setupUi(window);
window->setWindowTitle(applicationDisplayName());
QComboBox *cbTypes = fUi.comboBox;
cbTypes->addItem("None", static_cast<int>(sfz::kFilterNone));
cbTypes->addItem("Apf1p", static_cast<int>(sfz::kFilterApf1p));
cbTypes->addItem("Bpf1p", static_cast<int>(sfz::kFilterBpf1p));
cbTypes->addItem("Bpf2p", static_cast<int>(sfz::kFilterBpf2p));
cbTypes->addItem("Bpf4p", static_cast<int>(sfz::kFilterBpf4p));
cbTypes->addItem("Bpf6p", static_cast<int>(sfz::kFilterBpf6p));
cbTypes->addItem("Brf1p", static_cast<int>(sfz::kFilterBrf1p));
cbTypes->addItem("Brf2p", static_cast<int>(sfz::kFilterBrf2p));
cbTypes->addItem("Hpf1p", static_cast<int>(sfz::kFilterHpf1p));
cbTypes->addItem("Hpf2p", static_cast<int>(sfz::kFilterHpf2p));
cbTypes->addItem("Hpf4p", static_cast<int>(sfz::kFilterHpf4p));
cbTypes->addItem("Hpf6p", static_cast<int>(sfz::kFilterHpf6p));
cbTypes->addItem("Lpf1p", static_cast<int>(sfz::kFilterLpf1p));
cbTypes->addItem("Lpf2p", static_cast<int>(sfz::kFilterLpf2p));
cbTypes->addItem("Lpf4p", static_cast<int>(sfz::kFilterLpf4p));
cbTypes->addItem("Lpf6p", static_cast<int>(sfz::kFilterLpf6p));
cbTypes->addItem("Pink", static_cast<int>(sfz::kFilterPink));
cbTypes->addItem("Lpf2pSv", static_cast<int>(sfz::kFilterLpf2pSv));
cbTypes->addItem("Hpf2pSv", static_cast<int>(sfz::kFilterHpf2pSv));
cbTypes->addItem("Bpf2pSv", static_cast<int>(sfz::kFilterBpf2pSv));
cbTypes->addItem("Brf2pSv", static_cast<int>(sfz::kFilterBrf2pSv));
cbTypes->addItem("Lsh", static_cast<int>(sfz::kFilterLsh));
cbTypes->addItem("Hsh", static_cast<int>(sfz::kFilterHsh));
cbTypes->addItem("Peq", static_cast<int>(sfz::kFilterPeq));
cbTypes->setCurrentIndex(cbTypes->findData(fType));
fUi.lcdType->display(fType);
connect(
cbTypes, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, [this, cbTypes](int index) { valueChangedType(cbTypes->itemData(index).toInt()); });
fUi.dialCutoff->setRange(cutoffMin, cutoffMax);
fUi.dialResonance->setRange(resoMin, resoMax);
fUi.dialPkShGain->setRange(pkshMin, pkshMax);
fUi.dialBandwidth->setRange(bwMin, bwMax);
fUi.spinCutoff->setRange(cutoffMin, cutoffMax);
fUi.spinResonance->setRange(resoMin, resoMax);
fUi.spinPkShGain->setRange(pkshMin, pkshMax);
fUi.spinBandwidth->setRange(bwMin, bwMax);
fUi.dialCutoff->setValue(fCutoff);
fUi.dialResonance->setValue(fReso);
fUi.dialPkShGain->setValue(fPksh);
fUi.dialBandwidth->setValue(fBw);
fUi.spinCutoff->setValue(fCutoff);
fUi.spinResonance->setValue(fReso);
fUi.spinPkShGain->setValue(fPksh);
fUi.spinBandwidth->setValue(fBw);
connect(
fUi.dialCutoff, &QDial::valueChanged,
this, [this](int value) { valueChangedCutoff(value); });
connect(
fUi.spinCutoff, QOverload<int>::of(&QSpinBox::valueChanged),
this, [this](int value) { valueChangedCutoff(value); });
connect(
fUi.dialResonance, &QDial::valueChanged,
this, [this](int value) { valueChangedResonance(value); });
connect(
fUi.spinResonance, QOverload<int>::of(&QSpinBox::valueChanged),
this, [this](int value) { valueChangedResonance(value); });
connect(
fUi.dialPkShGain, &QDial::valueChanged,
this, [this](int value) { valueChangedPkShGain(value); });
connect(
fUi.spinPkShGain, QOverload<int>::of(&QSpinBox::valueChanged),
this, [this](int value) { valueChangedPkShGain(value); });
connect(
fUi.dialBandwidth, &QDial::valueChanged,
this, [this](int value) { valueChangedBandwidth(value); });
connect(
fUi.spinBandwidth, QOverload<int>::of(&QSpinBox::valueChanged),
this, [this](int value) { valueChangedBandwidth(value); });
QButtonGroup *grpMode = new QButtonGroup(this);
grpMode->addButton(fUi.btnMultiMode, kFilterModeMulti);
grpMode->addButton(fUi.btnEqMode, kFilterModeEq);
fUi.btnMultiMode->setChecked(true);
grpMode->setExclusive(true);
connect(
grpMode, QOverload<int, bool>::of(&QButtonGroup::buttonToggled), this,
[this](int id, bool toggled) {
if (toggled)
valueChangedFilterMode(id);
});
window->adjustSize();
window->setFixedSize(window->size());
window->show();
}
int DemoApp::processAudio(jack_nframes_t nframes, void *cbdata)
{
DemoApp *self = reinterpret_cast<DemoApp *>(cbdata);
const float *ins[2];
float *outs[2];
ins[0] = reinterpret_cast<float *>(jack_port_get_buffer(self->fPorts[0], nframes));
ins[1] = reinterpret_cast<float *>(jack_port_get_buffer(self->fPorts[1], nframes));
outs[0] = reinterpret_cast<float *>(jack_port_get_buffer(self->fPorts[2], nframes));
outs[1] = reinterpret_cast<float *>(jack_port_get_buffer(self->fPorts[3], nframes));
switch (self->fFilterMode) {
default:
case kFilterModeMulti:
self->fFilter.setType(static_cast<sfz::FilterType>(self->fType));
self->fFilter.process(ins, outs, self->fCutoff, self->fReso, self->fPksh, nframes);
break;
case kFilterModeEq:
self->fFilterEq.process(ins, outs, self->fCutoff, self->fBw, self->fPksh, nframes);
break;
}
return 0;
}
void DemoApp::valueChangedType(int value)
{
fType = value;
fUi.lcdType->display(value);
}
void DemoApp::valueChangedCutoff(int value)
{
fUi.dialCutoff->blockSignals(true);
fUi.dialCutoff->setValue(value);
fUi.dialCutoff->blockSignals(false);
fUi.spinCutoff->blockSignals(true);
fUi.spinCutoff->setValue(value);
fUi.spinCutoff->blockSignals(false);
fCutoff = value;
}
void DemoApp::valueChangedResonance(int value)
{
fUi.dialResonance->blockSignals(true);
fUi.dialResonance->setValue(value);
fUi.dialResonance->blockSignals(false);
fUi.spinResonance->blockSignals(true);
fUi.spinResonance->setValue(value);
fUi.spinResonance->blockSignals(false);
fReso = value;
}
void DemoApp::valueChangedPkShGain(int value)
{
fUi.dialPkShGain->blockSignals(true);
fUi.dialPkShGain->setValue(value);
fUi.dialPkShGain->blockSignals(false);
fUi.spinPkShGain->blockSignals(true);
fUi.spinPkShGain->setValue(value);
fUi.spinPkShGain->blockSignals(false);
fPksh = value;
}
void DemoApp::valueChangedBandwidth(int value)
{
fUi.dialBandwidth->blockSignals(true);
fUi.dialBandwidth->setValue(value);
fUi.dialBandwidth->blockSignals(false);
fUi.spinBandwidth->blockSignals(true);
fUi.spinBandwidth->setValue(value);
fUi.spinBandwidth->blockSignals(false);
fBw = value;
}
void DemoApp::valueChangedFilterMode(int value)
{
fUi.stackedWidget->setCurrentIndex(value);
fFilterMode = static_cast<FilterMode>(value);
}
int main(int argc, char *argv[])
{
DemoApp app(argc, argv);
if (!app.initSound())
return 1;
app.initWindow();
return app.exec();
}

239
tests/DemoFilters.ui Normal file
View file

@ -0,0 +1,239 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>DemoFiltersWindow</class>
<widget class="QMainWindow" name="DemoFiltersWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>415</width>
<height>216</height>
</rect>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<widget class="QDial" name="dialCutoff"/>
</item>
<item row="0" column="1">
<widget class="QDial" name="dialPkShGain"/>
</item>
<item row="0" column="2" rowspan="3">
<widget class="QStackedWidget" name="stackedWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="widget">
<layout class="QGridLayout" name="gridLayout">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QDial" name="dialResonance"/>
</item>
<item row="0" column="1">
<widget class="QLCDNumber" name="lcdType">
<property name="digitCount">
<number>2</number>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QSpinBox" name="spinResonance">
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="suffix">
<string> dB</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QComboBox" name="comboBox"/>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Resonance</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Type</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="widget_2">
<layout class="QGridLayout" name="gridLayout_3">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QDial" name="dialBandwidth"/>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_5">
<property name="text">
<string>Bandwidth</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QSpinBox" name="spinBandwidth">
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="suffix">
<string> oct</string>
</property>
</widget>
</item>
<item row="0" column="1" rowspan="3">
<widget class="QWidget" name="widget_3" native="true"/>
</item>
</layout>
</widget>
</widget>
</item>
<item row="1" column="0">
<widget class="QSpinBox" name="spinCutoff">
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="suffix">
<string> Hz</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QSpinBox" name="spinPkShGain">
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
<property name="suffix">
<string> dB</string>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Cutoff</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QLabel" name="label_4">
<property name="text">
<string>Peak/shelf gain</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item row="3" column="0" colspan="3">
<widget class="QFrame" name="frame">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QRadioButton" name="btnMultiMode">
<property name="text">
<string>Multi-mode</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QRadioButton" name="btnEqMode">
<property name="text">
<string>Equalizer</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</widget>
<resources/>
<connections/>
</ui>