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

Read enums through opcode.read

Browse source
This commit is contained in:
Paul Fd 2021-01-03 22:54:25 +01:00 • committed by Paul Ferrand
parent 17594241e7
commit 60b5783753
9 changed files with 147 additions and 174 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
src/sfizz/Defaults.cpp
View file

@ -145,6 +145,13 @@ extern const OpcodeSpec<float> lofiBitred { 0.0f, Range<float>(0.0f, 100.0f), kI
extern const OpcodeSpec<float> lofiDecim { 0.0f, Range<float>(0.0f, 100.0f), kIgnoreOOB };
extern const OpcodeSpec<float> rectify { 0.0f, Range<float>(0.0f, 100.0f), kIgnoreOOB };
extern const OpcodeSpec<unsigned> stringsNumber { maxStrings, Range<unsigned>(0, maxStrings), kEnforceLowerBound };
extern const OpcodeSpec<SfzTrigger> trigger { SfzTrigger::attack, Range<SfzTrigger>(SfzTrigger::attack, SfzTrigger::release_key), 0};
extern const OpcodeSpec<SfzCrossfadeCurve> crossfadeCurve { SfzCrossfadeCurve::power, Range<SfzCrossfadeCurve>(SfzCrossfadeCurve::gain, SfzCrossfadeCurve::power), 0};
extern const OpcodeSpec<SfzOffMode> offMode { SfzOffMode::fast, Range<SfzOffMode>(SfzOffMode::fast, SfzOffMode::time), 0};
extern const OpcodeSpec<SfzVelocityOverride> velocityOverride { SfzVelocityOverride::current, Range<SfzVelocityOverride>(SfzVelocityOverride::current, SfzVelocityOverride::previous), 0};
extern const OpcodeSpec<SfzSelfMask> selfMask { SfzSelfMask::mask, Range<SfzSelfMask>(SfzSelfMask::mask, SfzSelfMask::dontMask), 0};
extern const OpcodeSpec<FilterType> filter { FilterType::kFilterNone, Range<FilterType>(FilterType::kFilterNone, FilterType::kFilterPeq), 0};
extern const OpcodeSpec<EqType> eq { EqType::kEqNone, Range<EqType>(EqType::kEqNone, EqType::kEqHighShelf), 0};
} // namespace Default
} // namespace sfz

17
src/sfizz/Defaults.h
View file

@ -26,6 +26,7 @@
#pragma once
#include "Range.h"
#include "Config.h"
#include "SfzFilter.h"
#include <limits>
#include <cstdint>
@ -198,6 +199,13 @@ namespace Default
extern const OpcodeSpec<float> lofiDecim;
extern const OpcodeSpec<float> rectify;
extern const OpcodeSpec<unsigned> stringsNumber;
extern const OpcodeSpec<SfzTrigger> trigger;
extern const OpcodeSpec<SfzOffMode> offMode;
extern const OpcodeSpec<SfzCrossfadeCurve> crossfadeCurve;
extern const OpcodeSpec<SfzVelocityOverride> velocityOverride;
extern const OpcodeSpec<SfzSelfMask> selfMask;
extern const OpcodeSpec<FilterType> filter;
extern const OpcodeSpec<EqType> eq;
// Default/max count for objects
constexpr int numEQs { 3 };
@ -210,15 +218,6 @@ namespace Default
constexpr int maxDistoStages { 4 };
constexpr unsigned maxStrings { 88 };
// Default values for enums
constexpr SfzTrigger trigger { SfzTrigger::attack };
constexpr SfzOffMode offMode { SfzOffMode::fast };
constexpr SfzVelocityOverride velocityOverride { SfzVelocityOverride::current };
constexpr SfzSelfMask selfMask { SfzSelfMask::mask };
constexpr SfzCrossfadeCurve crossfadeKeyCurve { SfzCrossfadeCurve::power };
constexpr SfzCrossfadeCurve crossfadeVelCurve { SfzCrossfadeCurve::power };
constexpr SfzCrossfadeCurve crossfadeCCCurve { SfzCrossfadeCurve::power };
// Default values for ranges
constexpr Range<uint8_t> crossfadeKeyInRange { 0, 0 };
constexpr Range<uint8_t> crossfadeKeyOutRange { 127, 127 };

111
src/sfizz/Opcode.cpp
View file

@ -304,6 +304,117 @@ absl::optional<OscillatorEnabled> Opcode::read(OpcodeSpec<OscillatorEnabled>) co
return *v ? OscillatorEnabled::On : OscillatorEnabled::Off;
}
template <>
absl::optional<SfzTrigger> Opcode::read(OpcodeSpec<SfzTrigger>) const
{
switch (hash(value)) {
case hash("attack"): return SfzTrigger::attack;
case hash("first"): return SfzTrigger::first;
case hash("legato"): return SfzTrigger::legato;
case hash("release"): return SfzTrigger::release;
case hash("release_key"): return SfzTrigger::release_key;
}
DBG("Unknown trigger value: " << value);
return absl::nullopt;
}
template <>
absl::optional<SfzCrossfadeCurve> Opcode::read(OpcodeSpec<SfzCrossfadeCurve>) const
{
switch (hash(value)) {
case hash("power"): return SfzCrossfadeCurve::power;
case hash("gain"): return SfzCrossfadeCurve::gain;
}
DBG("Unknown crossfade power curve: " << value);
return absl::nullopt;
}
template <>
absl::optional<SfzOffMode> Opcode::read(OpcodeSpec<SfzOffMode>) const
{
switch (hash(value)) {
case hash("fast"): return SfzOffMode::fast;
case hash("normal"): return SfzOffMode::normal;
case hash("time"): return SfzOffMode::time;
}
DBG("Unknown off mode: " << value);
return absl::nullopt;
}
template <>
absl::optional<FilterType> Opcode::read(OpcodeSpec<FilterType>) const
{
switch (hash(value)) {
case hash("lpf_1p"): return kFilterLpf1p;
case hash("hpf_1p"): return kFilterHpf1p;
case hash("lpf_2p"): return kFilterLpf2p;
case hash("hpf_2p"): return kFilterHpf2p;
case hash("bpf_2p"): return kFilterBpf2p;
case hash("brf_2p"): return kFilterBrf2p;
case hash("bpf_1p"): return kFilterBpf1p;
case hash("brf_1p"): return kFilterBrf1p;
case hash("apf_1p"): return kFilterApf1p;
case hash("lpf_2p_sv"): return kFilterLpf2pSv;
case hash("hpf_2p_sv"): return kFilterHpf2pSv;
case hash("bpf_2p_sv"): return kFilterBpf2pSv;
case hash("brf_2p_sv"): return kFilterBrf2pSv;
case hash("lpf_4p"): return kFilterLpf4p;
case hash("hpf_4p"): return kFilterHpf4p;
case hash("lpf_6p"): return kFilterLpf6p;
case hash("hpf_6p"): return kFilterHpf6p;
case hash("pink"): return kFilterPink;
case hash("lsh"): return kFilterLsh;
case hash("hsh"): return kFilterHsh;
case hash("bpk_2p"): //fallthrough
case hash("pkf_2p"): //fallthrough
case hash("peq"): return kFilterPeq;
}
DBG("Unknown filter type: " << value);
return kFilterNone;
}
template <>
absl::optional<EqType> Opcode::read(OpcodeSpec<EqType>) const
{
switch (hash(value)) {
case hash("peak"): return kEqPeak;
case hash("lshelf"): return kEqLowShelf;
case hash("hshelf"): return kEqHighShelf;
}
DBG("Unknown EQ type: " << value);
return kEqNone;
}
template <>
absl::optional<SfzVelocityOverride> Opcode::read(OpcodeSpec<SfzVelocityOverride>) const
{
switch (hash(value)) {
case hash("current"): return SfzVelocityOverride::current;
case hash("previous"): return SfzVelocityOverride::previous;
}
DBG("Unknown velocity override: " << value);
return absl::nullopt;
}
template <>
absl::optional<SfzSelfMask> Opcode::read(OpcodeSpec<SfzSelfMask>) const
{
switch (hash(value)) {
case hash("on"):
case hash("mask"): return SfzSelfMask::mask;
case hash("off"): return SfzSelfMask::dontMask;
}
DBG("Unknown velocity override: " << value);
return absl::nullopt;
}
template <>
absl::optional<bool> Opcode::read(OpcodeSpec<bool>) const
{

100
src/sfizz/Region.cpp
View file

@ -204,19 +204,7 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
offBy = *value;
break;
case hash("off_mode"): // also offmode
switch (hash(opcode.value)) {
case hash("fast"):
offMode = SfzOffMode::fast;
break;
case hash("normal"):
offMode = SfzOffMode::normal;
break;
case hash("time"):
offMode = SfzOffMode::time;
break;
default:
DBG("Unkown off mode:" << opcode.value);
}
offMode = opcode.read(Default::offMode).value_or(offMode);
break;
case hash("off_time"):
offMode = SfzOffMode::time;
@ -360,16 +348,8 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
}
break;
case hash("sw_vel"):
switch (hash(opcode.value)) {
case hash("current"):
velocityOverride = SfzVelocityOverride::current;
break;
case hash("previous"):
velocityOverride = SfzVelocityOverride::previous;
break;
default:
DBG("Unknown velocity mode: " << opcode.value);
}
velocityOverride =
opcode.read(Default::velocityOverride).value_or(velocityOverride);
break;
case hash("sustain_cc"):
@ -419,25 +399,7 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
break;
// Region logic: triggers
case hash("trigger"):
switch (hash(opcode.value)) {
case hash("attack"):
trigger = SfzTrigger::attack;
break;
case hash("first"):
trigger = SfzTrigger::first;
break;
case hash("legato"):
trigger = SfzTrigger::legato;
break;
case hash("release"):
trigger = SfzTrigger::release;
break;
case hash("release_key"):
trigger = SfzTrigger::release_key;
break;
default:
DBG("Unknown trigger mode: " << opcode.value);
}
trigger = opcode.read(Default::trigger).value_or(trigger);
break;
case hash("start_locc&"): // also on_locc&
if (opcode.parameters.back() >= config::numCCs)
@ -564,28 +526,10 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
crossfadeVelOutRange.setEnd(normalizeVelocity(*value));
break;
case hash("xf_keycurve"):
switch (hash(opcode.value)) {
case hash("power"):
crossfadeKeyCurve = SfzCrossfadeCurve::power;
break;
case hash("gain"):
crossfadeKeyCurve = SfzCrossfadeCurve::gain;
break;
default:
DBG("Unknown crossfade power curve: " << opcode.value);
}
crossfadeKeyCurve = opcode.read(Default::crossfadeCurve).value_or(crossfadeKeyCurve);
break;
case hash("xf_velcurve"):
switch (hash(opcode.value)) {
case hash("power"):
crossfadeVelCurve = SfzCrossfadeCurve::power;
break;
case hash("gain"):
crossfadeVelCurve = SfzCrossfadeCurve::gain;
break;
default:
DBG("Unknown crossfade power curve: " << opcode.value);
}
crossfadeVelCurve = opcode.read(Default::crossfadeCurve).value_or(crossfadeVelCurve);
break;
case hash("xfin_locc&"):
if (opcode.parameters.back() >= config::numCCs)
@ -612,16 +556,7 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
crossfadeCCOutRange[opcode.parameters.back()].setEnd(normalizeCC(*value));
break;
case hash("xf_cccurve"):
switch (hash(opcode.value)) {
case hash("power"):
crossfadeCCCurve = SfzCrossfadeCurve::power;
break;
case hash("gain"):
crossfadeCCCurve = SfzCrossfadeCurve::gain;
break;
default:
DBG("Unknown crossfade power curve: " << opcode.value);
}
crossfadeCCCurve = opcode.read(Default::crossfadeCurve).value_or(crossfadeCCCurve);
break;
case hash("rt_decay"):
rtDecay = opcode.read(Default::rtDecay).value_or(rtDecay);
@ -745,14 +680,8 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
if (!extendIfNecessary(filters, filterIndex + 1, Default::numFilters))
return false;
absl::optional<FilterType> ftype = Filter::typeFromName(opcode.value);
if (ftype)
filters[filterIndex].type = *ftype;
else {
filters[filterIndex].type = FilterType::kFilterNone;
DBG("Unknown filter type: " << opcode.value);
}
filters[filterIndex].type =
opcode.read(Default::filter).value_or(filters[filterIndex].type);
}
break;
@ -835,15 +764,10 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
if (!extendIfNecessary(equalizers, eqIndex + 1, Default::numEQs))
return false;
absl::optional<EqType> ftype = FilterEq::typeFromName(opcode.value);
equalizers[eqIndex].type =
opcode.read(Default::eq).value_or(equalizers[eqIndex].type);
if (ftype)
equalizers[eqIndex].type = *ftype;
else {
equalizers[eqIndex].type = EqType::kEqNone;
DBG("Unknown EQ type: " << opcode.value);
}
}
}
break;
// Performance parameters: pitch

14
src/sfizz/Region.h
View file

@ -343,11 +343,11 @@ struct Region {
// Instrument settings: voice lifecycle
uint32_t group { Default::group.value }; // group
absl::optional<uint32_t> offBy {}; // off_by
SfzOffMode offMode { Default::offMode }; // off_mode
SfzOffMode offMode { Default::offMode.value }; // off_mode
float offTime { Default::offTime.value }; // off_mode
absl::optional<uint32_t> notePolyphony {}; // note_polyphony
uint32_t polyphony { config::maxVoices }; // polyphony
SfzSelfMask selfMask { Default::selfMask };
SfzSelfMask selfMask { Default::selfMask.value };
bool rtDead { Default::rtDead.value };
// Region logic: key mapping
@ -364,7 +364,7 @@ struct Region {
absl::optional<uint8_t> downKeyswitch {}; // sw_down
absl::optional<uint8_t> previousKeyswitch {}; // sw_previous
absl::optional<uint8_t> defaultSwitch {};
SfzVelocityOverride velocityOverride { Default::velocityOverride }; // sw_vel
SfzVelocityOverride velocityOverride { Default::velocityOverride.value }; // sw_vel
bool checkSustain { Default::checkSustain.value }; // sustain_sw
bool checkSostenuto { Default::checkSostenuto.value }; // sostenuto_sw
uint16_t sustainCC { Default::sustainCC.value }; // sustain_cc
@ -378,7 +378,7 @@ struct Region {
uint8_t sequencePosition { Default::sequence.value }; // seq_position
// Region logic: triggers
SfzTrigger trigger { Default::trigger }; // trigger
SfzTrigger trigger { Default::trigger.value }; // trigger
CCMap<Range<float>> ccTriggers { Default::normalized.bounds }; // on_loccN on_hiccN
// Performance parameters: amplifier
@ -397,9 +397,9 @@ struct Region {
Range<uint8_t> crossfadeKeyOutRange { Default::crossfadeKeyOutRange };
Range<float> crossfadeVelInRange { Default::crossfadeVelInRange };
Range<float> crossfadeVelOutRange { Default::crossfadeVelOutRange };
SfzCrossfadeCurve crossfadeKeyCurve { Default::crossfadeKeyCurve };
SfzCrossfadeCurve crossfadeVelCurve { Default::crossfadeVelCurve };
SfzCrossfadeCurve crossfadeCCCurve { Default::crossfadeCCCurve };
SfzCrossfadeCurve crossfadeKeyCurve { Default::crossfadeCurve.value };
SfzCrossfadeCurve crossfadeVelCurve { Default::crossfadeCurve.value };
SfzCrossfadeCurve crossfadeCCCurve { Default::crossfadeCurve.value };
CCMap<Range<float>> crossfadeCCInRange { Default::crossfadeCCInRange }; // xfin_loccN xfin_hiccN
CCMap<Range<float>> crossfadeCCOutRange { Default::crossfadeCCOutRange }; // xfout_loccN xfout_hiccN
float rtDecay { Default::rtDecay.value }; // rt_decay

46
src/sfizz/SfzFilter.cpp
View file

@ -204,39 +204,6 @@ void Filter::setType(FilterType type)
}
}
absl::optional<FilterType> Filter::typeFromName(absl::string_view name)
{
absl::optional<FilterType> ftype;
switch (hash(name)) {
case hash("lpf_1p"): ftype = kFilterLpf1p; break;
case hash("hpf_1p"): ftype = kFilterHpf1p; break;
case hash("lpf_2p"): ftype = kFilterLpf2p; break;
case hash("hpf_2p"): ftype = kFilterHpf2p; break;
case hash("bpf_2p"): ftype = kFilterBpf2p; break;
case hash("brf_2p"): ftype = kFilterBrf2p; break;
case hash("bpf_1p"): ftype = kFilterBpf1p; break;
case hash("brf_1p"): ftype = kFilterBrf1p; break;
case hash("apf_1p"): ftype = kFilterApf1p; break;
case hash("lpf_2p_sv"): ftype = kFilterLpf2pSv; break;
case hash("hpf_2p_sv"): ftype = kFilterHpf2pSv; break;
case hash("bpf_2p_sv"): ftype = kFilterBpf2pSv; break;
case hash("brf_2p_sv"): ftype = kFilterBrf2pSv; break;
case hash("lpf_4p"): ftype = kFilterLpf4p; break;
case hash("hpf_4p"): ftype = kFilterHpf4p; break;
case hash("lpf_6p"): ftype = kFilterLpf6p; break;
case hash("hpf_6p"): ftype = kFilterHpf6p; break;
case hash("pink"): ftype = kFilterPink; break;
case hash("lsh"): ftype = kFilterLsh; break;
case hash("hsh"): ftype = kFilterHsh; break;
case hash("bpk_2p"): //fallthrough
case hash("pkf_2p"): //fallthrough
case hash("peq"): ftype = kFilterPeq; break;
}
return ftype;
}
sfzFilterDsp *Filter::Impl::getDsp(unsigned channels, FilterType type)
{
switch (idDsp(channels, type)) {
@ -444,19 +411,6 @@ void FilterEq::setType(EqType type)
}
}
absl::optional<EqType> FilterEq::typeFromName(absl::string_view name)
{
absl::optional<EqType> ftype;
switch (hash(name)) {
case hash("peak"): ftype = kEqPeak; break;
case hash("lshelf"): ftype = kEqLowShelf; break;
case hash("hshelf"): ftype = kEqHighShelf; break;
}
return ftype;
}
sfzFilterDsp *FilterEq::Impl::getDsp(unsigned channels, EqType type)
{
switch (idDsp(channels, type)) {

10
src/sfizz/SfzFilter.h
View file

@ -84,11 +84,6 @@ public:
*/
void setType(FilterType type);
/**
Get the filter type associated with the given name.
*/
static absl::optional<FilterType> typeFromName(absl::string_view name);
private:
struct Impl;
std::unique_ptr<Impl> P;
@ -194,11 +189,6 @@ public:
*/
void setType(EqType type);
/**
Get the filter type associated with the given name.
*/
static absl::optional<EqType> typeFromName(absl::string_view name);
private:
struct Impl;
std::unique_ptr<Impl> P;

8
src/sfizz/effects/Eq.cpp
View file

@ -83,13 +83,7 @@ namespace fx {
break;
case hash("eq_type"):
{
absl::optional<EqType> ftype = sfz::FilterEq::typeFromName(opc.value);
if (ftype)
desc.type = *ftype;
else {
desc.type = EqType::kEqNone;
DBG("Unknown EQ type: " << std::string(opc.value));
}
desc.type = opc.read(Default::eq).value_or(desc.type);
break;
}
}

8
src/sfizz/effects/Filter.cpp
View file

@ -81,13 +81,7 @@ namespace fx {
break;
case hash("filter_type"):
{
absl::optional<FilterType> ftype = sfz::Filter::typeFromName(opc.value);
if (ftype)
desc.type = *ftype;
else {
desc.type = FilterType::kFilterNone;
DBG("Unknown filter type: " << std::string(opc.value));
}
desc.type = opc.read(Default::filter).value_or(desc.type);
break;
}
// extension