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

WIP

Browse source
This commit is contained in:
Paul Fd 2021-01-10 19:01:20 +01:00 • committed by Paul Ferrand
parent e9941b4337
commit 293e7a935f
40 changed files with 753 additions and 876 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/sfizz/Curve.cpp
View file

@ -40,11 +40,7 @@ Curve Curve::buildCurveFromHeader(
if (index >= NumValues)
continue;
auto valueOpt = opc.read(fullRange);
if (!valueOpt)
continue;
setPoint(static_cast<int>(index), *valueOpt);
setPoint(static_cast<int>(index), opc.read(fullRange));
}
curve.fill(itp, fillStatus);
@ -267,12 +263,8 @@ void CurveSet::addCurveFromHeader(absl::Span<const Opcode> members)
int curveIndex = -1;
Curve::Interpolator itp = Curve::Interpolator::Linear;
if (const Opcode* opc = findOpcode(hash("curve_index"))) {
if (auto opt = opc->read(Default::curveCC))
curveIndex = *opt;
else
DBG("Invalid value for curve index: " << opc->value);
}
if (const Opcode* opc = findOpcode(hash("curve_index")))
curveIndex = opc->read(Default::curveCC);
#if 0 // potential sfizz extension
if (const Opcode* opc = findOpcode(hash("sfizz:curve_interpolator"))) {

195
src/sfizz/Defaults.cpp
View file

@ -1,150 +1,163 @@
#include "Defaults.h"
#include "MathHelpers.h"
#include "SfzHelpers.h"
namespace sfz {
namespace Default {
constexpr auto uint32_t_max = std::numeric_limits<uint32_t>::max();
extern const OpcodeSpec<float> delay { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> delayRandom { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<int64_t> offset { 0, Range<int64_t>(0, uint32_t_max), kEnforceLowerBound };
extern const OpcodeSpec<int64_t> offsetMod { 0, Range<int64_t>(0, uint32_t_max), kEnforceLowerBound };
extern const OpcodeSpec<int64_t> offsetRandom { 0, Range<int64_t>(0, uint32_t_max), kEnforceLowerBound };
extern const OpcodeSpec<uint32_t> sampleEnd { uint32_t_max, Range<uint32_t>(0, uint32_t_max), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<uint32_t> sampleCount { 0, Range<uint32_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<uint32_t> loopRange { 0, Range<uint32_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<float> loopCrossfade { 1e-3, Range<float>(1e-3, 1.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> delay { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> delayRandom { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<int64_t> offset { 0, Range<int64_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<int64_t> offsetMod { 0, Range<int64_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<int64_t> offsetRandom { 0, Range<int64_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<uint32_t> sampleEnd { uint32_t_max, Range<uint32_t>(0, uint32_t_max), kEnforceLowerBound };
extern const OpcodeSpec<uint32_t> sampleCount { 1, Range<uint32_t>(1, uint32_t_max), 0 };
extern const OpcodeSpec<uint32_t> loopStart { 0, Range<uint32_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<uint32_t> loopEnd { uint32_t_max, Range<uint32_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<float> loopCrossfade { 1e-3, Range<float>(1e-3, 1.0f), 0 };
extern const OpcodeSpec<OscillatorEnabled> oscillator { OscillatorEnabled::Auto, Range<OscillatorEnabled>(OscillatorEnabled::Auto, OscillatorEnabled::On), 0 };
extern const OpcodeSpec<float> oscillatorPhase { 0.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<int> oscillatorMode { 0, Range<int>(0, 2), kIgnoreOOB };
extern const OpcodeSpec<int> oscillatorMulti { 1, Range<int>(1, config::oscillatorsPerVoice), kIgnoreOOB };
extern const OpcodeSpec<int> oscillatorMode { 0, Range<int>(0, 2), 0 };
extern const OpcodeSpec<int> oscillatorMulti { 1, Range<int>(1, config::oscillatorsPerVoice), 0 };
extern const OpcodeSpec<float> oscillatorDetune { 0.0f, Range<float>(-12000.0f, 12000.0f), 0 };
extern const OpcodeSpec<float> oscillatorDetuneMod { 0.0f, Range<float>(-12000.0f, 12000.0f), 0 };
extern const OpcodeSpec<float> oscillatorModDepth { 0.0f, Range<float>(0.0f, 10000.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> oscillatorModDepthMod { 0.0f, Range<float>(0.0f, 10000.0f), kEnforceLowerBound };
extern const OpcodeSpec<int> oscillatorQuality { 1, Range<int>(0, 3), kIgnoreOOB };
extern const OpcodeSpec<float> oscillatorModDepth { 0.0f, Range<float>(0.0f, 10000.0f), kNormalizePercent };
extern const OpcodeSpec<float> oscillatorModDepthMod { 0.0f, Range<float>(0.0f, 10000.0f), 0 };
extern const OpcodeSpec<int> oscillatorQuality { 1, Range<int>(0, 3), 0 };
extern const OpcodeSpec<uint32_t> group { 0, Range<uint32_t>(0, uint32_t_max), 0 };
extern const OpcodeSpec<float> offTime { 6e-3f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> offTime { 6e-3f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<uint32_t> polyphony { config::maxVoices, Range<uint32_t>(0, config::maxVoices), 0 };
extern const OpcodeSpec<uint32_t> notePolyphony { config::maxVoices, Range<uint32_t>(0, config::maxVoices), 0 };
extern const OpcodeSpec<uint8_t> key { 60, Range<uint8_t>(0, 127), kIgnoreOOB | kCanBeNote };
extern const OpcodeSpec<uint8_t> midi7 { 0, Range<uint8_t>(0, 127), kIgnoreOOB };
extern const OpcodeSpec<float> float7 { 0.0f , Range<float>(0.0f, 127.0f), kIgnoreOOB };
extern const OpcodeSpec<float> bend { 0.0f, Range<float>(-8192.0f, 8192.0f), kIgnoreOOB };
extern const OpcodeSpec<float> normalized { 0.0f, Range<float>(0.0f, 1.0f), kIgnoreOOB };
extern const OpcodeSpec<float> bipolar { 0.0f, Range<float>(-1.0f, 1.0f), kIgnoreOOB };
extern const OpcodeSpec<uint16_t> ccNumber { 0, Range<uint16_t>(0, config::numCCs), kIgnoreOOB };
extern const OpcodeSpec<uint8_t> smoothCC { 0, Range<uint8_t>(0, 100), kIgnoreOOB };
extern const OpcodeSpec<uint8_t> curveCC { 0, Range<uint8_t>(0, 255), kIgnoreOOB };
extern const OpcodeSpec<uint8_t> sustainCC { 64, Range<uint8_t>(0, 127), kIgnoreOOB };
extern const OpcodeSpec<float> sustainThreshold { 0.0039f, Range<float>(0.0f, 1.0f), kIgnoreOOB };
extern const OpcodeSpec<uint8_t> key { 60, Range<uint8_t>(0, 127), kCanBeNote };
extern const OpcodeSpec<uint8_t> loKey { 0, Range<uint8_t>(0, 127), kCanBeNote };
extern const OpcodeSpec<uint8_t> hiKey { 127, Range<uint8_t>(0, 127), kCanBeNote };
extern const OpcodeSpec<float> loCC { 0.0f , Range<float>(0.0f, 127.0f), kNormalizeMidi };
extern const OpcodeSpec<float> hiCC { 1.0f , Range<float>(0.0f, 127.0f), kNormalizeMidi };
extern const OpcodeSpec<float> loVel { 0.0f , Range<float>(0.0f, 127.0f), kNormalizeMidi };
extern const OpcodeSpec<float> hiVel { 1.0f , Range<float>(0.0f, 127.0f), kNormalizeMidi };
extern const OpcodeSpec<uint8_t> loChannelAftertouch { 0, Range<uint8_t>(0, 127), 0 };
extern const OpcodeSpec<uint8_t> hiChannelAftertouch { 127, Range<uint8_t>(0, 127), 0 };
extern const OpcodeSpec<float> loBend { -1.0f, Range<float>(-8192.0f, 8192.0f), kNormalizeBend };
extern const OpcodeSpec<float> hiBend { 1.0f, Range<float>(-8192.0f, 8192.0f), kNormalizeBend };
extern const OpcodeSpec<float> loNormalized { 0.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> hiNormalized { 1.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> loBipolar { -1.0f, Range<float>(-1.0f, 1.0f), 0 };
extern const OpcodeSpec<float> hiBipolar { 1.0f, Range<float>(-1.0f, 1.0f), 0 };
extern const OpcodeSpec<uint16_t> ccNumber { 0, Range<uint16_t>(0, config::numCCs), 0 };
extern const OpcodeSpec<uint8_t> smoothCC { 0, Range<uint8_t>(0, 100), 0 };
extern const OpcodeSpec<uint8_t> curveCC { 0, Range<uint8_t>(0, 255), 0 };
extern const OpcodeSpec<uint8_t> sustainCC { 64, Range<uint8_t>(0, 127), 0 };
extern const OpcodeSpec<float> sustainThreshold { 0.0039f, Range<float>(0.0f, 127.0f), kNormalizeMidi };
extern const OpcodeSpec<bool> checkSustain { true, Range<bool>(0, 1), 0 };
extern const OpcodeSpec<bool> checkSostenuto { true, Range<bool>(0, 1), 0 };
extern const OpcodeSpec<float> bpm { 0.0f, Range<float>(0.0f, 500.0f), kEnforceLowerBound };
extern const OpcodeSpec<uint8_t> sequence { 1, Range<uint8_t>(1, 100), kIgnoreOOB };
extern const OpcodeSpec<float> loBPM { 0.0f, Range<float>(0.0f, 500.0f), 0 };
extern const OpcodeSpec<float> hiBPM { 500.0f, Range<float>(0.0f, 500.0f), 0 };
extern const OpcodeSpec<uint8_t> sequence { 1, Range<uint8_t>(1, 100), 0 };
extern const OpcodeSpec<float> volume { 0.0f, Range<float>(-144.0f, 48.0f), 0 };
extern const OpcodeSpec<float> volumeMod { 0.0f, Range<float>(-144.0f, 48.0f), 0 };
extern const OpcodeSpec<float> amplitude { 100.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> amplitudeMod { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> pan { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> panMod { 0.0f, Range<float>(-200.0f, 200.0f), 0 };
extern const OpcodeSpec<float> position { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> positionMod { 0.0f, Range<float>(-200.0f, 200.0f), 0 };
extern const OpcodeSpec<float> width { 100.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> widthMod { 0.0f, Range<float>(-200.0f, 200.0f), 0 };
extern const OpcodeSpec<uint8_t> crossfadeIn { 0, Range<uint8_t>(0, 127), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> crossfadeInNorm { 0.0f, Range<float>(0.0f, 1.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<uint8_t> crossfadeOut { 127, Range<uint8_t>(0, 127), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> crossfadeOutNorm { 1.0f, Range<float>(0.0f, 1.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> amplitude { 100.0f, Range<float>(0.0f, 10000.0f), kNormalizePercent };
extern const OpcodeSpec<float> amplitudeMod { 0.0f, Range<float>(0.0f, 10000.0f), kNormalizePercent };
extern const OpcodeSpec<float> pan { 0.0f, Range<float>(-100.0f, 100.0f), kNormalizePercent };
extern const OpcodeSpec<float> panMod { 0.0f, Range<float>(-200.0f, 200.0f), kNormalizePercent };
extern const OpcodeSpec<float> position { 0.0f, Range<float>(-100.0f, 100.0f), kNormalizePercent };
extern const OpcodeSpec<float> positionMod { 0.0f, Range<float>(-200.0f, 200.0f), kNormalizePercent };
extern const OpcodeSpec<float> width { 100.0f, Range<float>(-100.0f, 100.0f), kNormalizePercent };
extern const OpcodeSpec<float> widthMod { 0.0f, Range<float>(-200.0f, 200.0f), kNormalizePercent };
extern const OpcodeSpec<float> crossfadeIn { 0.0f, Range<float>(0.0f, 127.0f), kNormalizeMidi };
extern const OpcodeSpec<float> crossfadeInNorm { 0.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> crossfadeOut { 1.0f, Range<float>(0.0f, 127.0f), kNormalizeMidi };
extern const OpcodeSpec<float> crossfadeOutNorm { 1.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> ampKeytrack { 0.0f, Range<float>(-96.0f, 12.0f), 0 };
extern const OpcodeSpec<float> ampVeltrack { 100.0f, Range<float>(-100.0f, 100.0f), kIgnoreOOB };
extern const OpcodeSpec<float> ampVelcurve { 0.0f, Range<float>(0.0f, 1.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> ampRandom { 0.0f, Range<float>(0.0f, 24.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> ampVeltrack { 100.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> ampVelcurve { 0.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> ampRandom { 0.0f, Range<float>(0.0f, 24.0f), 0 };
extern const OpcodeSpec<bool> rtDead { false, Range<bool>(0, 1), 0 };
extern const OpcodeSpec<float> rtDecay { 0.0f, Range<float>(0.0f, 200.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> filterCutoff { 0.0f, Range<float>(0.0f, 20000.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> filterCutoffMod { 0.0f, Range<float>(-12000.0f, 12000.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> filterResonance { 0.0f, Range<float>(0.0f, 96.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> filterResonanceMod { 0.0f, Range<float>(0.0f, 96.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> rtDecay { 0.0f, Range<float>(0.0f, 200.0f), 0 };
extern const OpcodeSpec<float> filterCutoff { 0.0f, Range<float>(0.0f, 20000.0f), 0 };
extern const OpcodeSpec<float> filterCutoffMod { 0.0f, Range<float>(-12000.0f, 12000.0f), 0 };
extern const OpcodeSpec<float> filterResonance { 0.0f, Range<float>(0.0f, 96.0f), 0 };
extern const OpcodeSpec<float> filterResonanceMod { 0.0f, Range<float>(0.0f, 96.0f), 0 };
extern const OpcodeSpec<float> filterGain { 0.0f, Range<float>(-96.0f, 96.0f), 0 };
extern const OpcodeSpec<float> filterGainMod { 0.0f, Range<float>(-96.0f, 96.0f), 0 };
extern const OpcodeSpec<float> filterRandom { 0.0f, Range<float>(0.0f, 12000.0f), kEnforceLowerBound };
extern const OpcodeSpec<int> filterKeytrack { 0, Range<int>(0, 1200), kEnforceLowerBound };
extern const OpcodeSpec<float> filterRandom { 0.0f, Range<float>(0.0f, 12000.0f), 0 };
extern const OpcodeSpec<int> filterKeytrack { 0, Range<int>(0, 1200), 0 };
extern const OpcodeSpec<int> filterVeltrack { 0, Range<int>(-12000, 12000), 0 };
extern const OpcodeSpec<float> eqBandwidth { 1.0f, Range<float>(0.001f, 4.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> eqBandwidth { 1.0f, Range<float>(0.001f, 4.0f), 0 };
extern const OpcodeSpec<float> eqBandwidthMod { 0.0f, Range<float>(-4.0f, 4.0f), 0 };
extern const OpcodeSpec<float> eqFrequency { 0.0f, Range<float>(0.0f, 30000.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> eqFrequency { 0.0f, Range<float>(0.0f, 30000.0f), 0 };
extern const OpcodeSpec<float> eqFrequencyMod { 0.0f, Range<float>(-30000.0f, 30000.0f), 0 };
extern const OpcodeSpec<float> eqGain { 0.0f, Range<float>(-96.0f, 96.0f), 0 };
extern const OpcodeSpec<float> eqGainMod { 0.0f, Range<float>(-96.0f, 96.0f), 0 };
extern const OpcodeSpec<float> eqVel2Frequency { 0.0f, Range<float>(-30000.0f, 30000.0f), 0 };
extern const OpcodeSpec<float> eqVel2Gain { 0.0f, Range<float>(-96.0f, 96.0f), 0 };
extern const OpcodeSpec<int> pitchKeytrack { 100, Range<int>(-1200, 1200), 0 };
extern const OpcodeSpec<float> pitchRandom { 0.0f, Range<float>(0.0f, 12000.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> pitchRandom { 0.0f, Range<float>(0.0f, 12000.0f), 0 };
extern const OpcodeSpec<int> pitchVeltrack { 0, Range<int>(-12000, 12000), 0 };
extern const OpcodeSpec<int> transpose { 0, Range<int>(-127, 127), kIgnoreOOB };
extern const OpcodeSpec<int> transpose { 0, Range<int>(-127, 127), 0 };
extern const OpcodeSpec<float> pitch { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> pitchMod { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> bendUp { 200.0f, Range<float>(-12000.0f, 12000.0f), 0 };
extern const OpcodeSpec<float> bendDown { -200.0f, Range<float>(-12000.0f, 12000.0f), 0 };
extern const OpcodeSpec<float> bendStep { 1.0f, Range<float>(1.0f, 1200.0f), kIgnoreOOB };
extern const OpcodeSpec<float> bendStep { 1.0f, Range<float>(1.0f, 1200.0f), 0 };
extern const OpcodeSpec<float> lfoFreq { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> lfoFreqMod { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> lfoBeats { 0.0f, Range<float>(0.0f, 1000.0f), 0 };
extern const OpcodeSpec<float> lfoBeatsMod { 0.0f, Range<float>(-1000.0f, 1000.0f), 0 };
extern const OpcodeSpec<float> lfoPhase { 0.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> lfoPhase { 0.0f, Range<float>(0.0f, 1.0f), kWrapPhase };
extern const OpcodeSpec<float> lfoDelay { 0.0f, Range<float>(0.0f, 30.0f), 0 };
extern const OpcodeSpec<float> lfoFade { 0.0f, Range<float>(0.0f, 30.0f), 0 };
extern const OpcodeSpec<unsigned> lfoCount { 0, Range<unsigned>(0, 1000), 0 };
extern const OpcodeSpec<unsigned> lfoSteps { 0, Range<unsigned>(0, static_cast<unsigned>(config::maxLFOSteps)), 0 };
extern const OpcodeSpec<float> lfoStepX { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<int> lfoWave { 0, Range<int>(0, 15), 0 };
extern const OpcodeSpec<float> lfoStepX { 0.0f, Range<float>(-100.0f, 100.0f), kNormalizePercent };
extern const OpcodeSpec<LFOWave> lfoWave { LFOWave::Triangle, Range<LFOWave>(LFOWave::Triangle, LFOWave::RandomSH), 0 };
extern const OpcodeSpec<float> lfoOffset { 0.0f, Range<float>(-1.0f, 1.0f), 0 };
extern const OpcodeSpec<float> lfoRatio { 1.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> lfoScale { 1.0f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> egTime { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> egRelease { 0.001f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> egTime { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> egRelease { 0.001f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> egTimeMod { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> egPercent { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> egPercent { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> egPercentMod { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> egDepth { 0.0f, Range<float>(-12000.0f, 12000.0f), 0 };
extern const OpcodeSpec<float> egVel2Depth { 0.0f, Range<float>(-12000.0f, 12000.0f), 0 };
extern const OpcodeSpec<bool> flexEGAmpeg { false, Range<bool>(0, 1), 0 };
extern const OpcodeSpec<int> flexEGDynamic { 0, Range<int>(0, 1), kIgnoreOOB };
extern const OpcodeSpec<int> flexEGSustain { 0, Range<int>(0, 100), kIgnoreOOB };
extern const OpcodeSpec<float> flexEGPointTime { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> flexEGPointLevel { 0.0f, Range<float>(-1.0f, 1.0f), kIgnoreOOB };
extern const OpcodeSpec<float> flexEGPointShape { 0.0f, Range<float>(-100.0f, 100.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<int> sampleQuality { 1, Range<int>(1, 10), kIgnoreOOB };
extern const OpcodeSpec<int> flexEGDynamic { 0, Range<int>(0, 1), 0 };
extern const OpcodeSpec<int> flexEGSustain { 0, Range<int>(0, 100), 0 };
extern const OpcodeSpec<float> flexEGPointTime { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> flexEGPointLevel { 0.0f, Range<float>(-1.0f, 1.0f), 0 };
extern const OpcodeSpec<float> flexEGPointShape { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<int> sampleQuality { 1, Range<int>(1, 10), 0 };
extern const OpcodeSpec<int> octaveOffset { 0, Range<int>(-10, 10), 0 };
extern const OpcodeSpec<int> noteOffset { 0, Range<int>(-127, 127), 0 };
extern const OpcodeSpec<float> effect { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> effect { 0.0f, Range<float>(0.0f, 100.0f), kNormalizePercent };
extern const OpcodeSpec<int> apanWaveform { 0, Range<int>(0, std::numeric_limits<int>::max()), 0 };
extern const OpcodeSpec<float> apanFrequency { 0.0f, Range<float>(0.0f, std::numeric_limits<float>::max()), kEnforceLowerBound };
extern const OpcodeSpec<float> apanPhase { 0.5f, Range<float>(0.0f, 1.0f), 0 };
extern const OpcodeSpec<float> apanLevel { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> distoTone { 100.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<float> distoDepth { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound | kEnforceUpperBound };
extern const OpcodeSpec<unsigned> distoStages { 1, Range<unsigned>(1, maxDistoStages), kEnforceLowerBound };
extern const OpcodeSpec<float> compAttack { 0.005f, Range<float>(0.0f, 10.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> compRelease { 0.05f, Range<float>(0.0f, 10.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> apanFrequency { 0.0f, Range<float>(0.0f, std::numeric_limits<float>::max()), 0 };
extern const OpcodeSpec<float> apanPhase { 0.5f, Range<float>(0.0f, 1.0f), kWrapPhase };
extern const OpcodeSpec<float> apanLevel { 0.0f, Range<float>(0.0f, 100.0f), kNormalizePercent };
extern const OpcodeSpec<float> distoTone { 100.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> distoDepth { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<unsigned> distoStages { 1, Range<unsigned>(1, maxDistoStages), 0 };
extern const OpcodeSpec<float> compAttack { 0.005f, Range<float>(0.0f, 10.0f), 0 };
extern const OpcodeSpec<float> compRelease { 0.05f, Range<float>(0.0f, 10.0f), 0 };
extern const OpcodeSpec<bool> compSTLink { false, Range<bool>(0, 1), 0 };
extern const OpcodeSpec<float> compThreshold { 0.0f, Range<float>(-100.0f, 0.0f), kIgnoreOOB };
extern const OpcodeSpec<float> compRatio { 1.0f, Range<float>(1.0f, 50.0f), kIgnoreOOB };
extern const OpcodeSpec<float> compGain { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
extern const OpcodeSpec<float> fverbSize { 0.0f, Range<float>(0.0f, 100.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> fverbPredelay { 0.0f, Range<float>(0.0f, 10.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> fverbTone { 100.0f, Range<float>(0.0f, 100.0f), kIgnoreOOB };
extern const OpcodeSpec<float> fverbDamp { 0.0f, Range<float>(0.0f, 100.0f), kIgnoreOOB };
extern const OpcodeSpec<float> compThreshold { 0.0f, Range<float>(-100.0f, 0.0f), 0 };
extern const OpcodeSpec<float> compRatio { 1.0f, Range<float>(1.0f, 50.0f), 0 };
extern const OpcodeSpec<float> compGain { 1.0f, Range<float>(-100.0f, 100.0f), kDb2Mag };
extern const OpcodeSpec<float> fverbSize { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> fverbPredelay { 0.0f, Range<float>(0.0f, 10.0f), 0 };
extern const OpcodeSpec<float> fverbTone { 100.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> fverbDamp { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<bool> gateSTLink { false, Range<bool>(0, 1), 0 };
extern const OpcodeSpec<float> gateAttack { 0.005f, Range<float>(0.0f, 10.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> gateRelease { 0.05f, Range<float>(0.0f, 10.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> gateHold { 0.0f, Range<float>(0.0f, 10.0f), kEnforceLowerBound };
extern const OpcodeSpec<float> gateThreshold { 0.0f, Range<float>(-100.0f, 0.0f), kIgnoreOOB };
extern const OpcodeSpec<float> lofiBitred { 0.0f, Range<float>(0.0f, 100.0f), kIgnoreOOB };
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<float> gateAttack { 0.005f, Range<float>(0.0f, 10.0f), 0 };
extern const OpcodeSpec<float> gateRelease { 0.05f, Range<float>(0.0f, 10.0f), 0 };
extern const OpcodeSpec<float> gateHold { 0.0f, Range<float>(0.0f, 10.0f), 0 };
extern const OpcodeSpec<float> gateThreshold { 0.0f, Range<float>(-100.0f, 0.0f), 0 };
extern const OpcodeSpec<float> lofiBitred { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> lofiDecim { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<float> rectify { 0.0f, Range<float>(0.0f, 100.0f), 0 };
extern const OpcodeSpec<unsigned> stringsNumber { maxStrings, Range<unsigned>(0, maxStrings), 0 };
extern const OpcodeSpec<Trigger> trigger { Trigger::attack, Range<Trigger>(Trigger::attack, Trigger::release_key), 0};
extern const OpcodeSpec<CrossfadeCurve> crossfadeCurve { CrossfadeCurve::power, Range<CrossfadeCurve>(CrossfadeCurve::gain, CrossfadeCurve::power), 0};
extern const OpcodeSpec<OffMode> offMode { OffMode::fast, Range<OffMode>(OffMode::fast, OffMode::time), 0};

54
src/sfizz/Defaults.h
View file

@ -41,20 +41,37 @@ enum class VelocityOverride { current = 0, previous };
enum class CrossfadeCurve { gain = 0, power };
enum class SelfMask { mask = 0, dontMask };
enum class OscillatorEnabled { Auto = -1, Off = 0, On = 1 };
enum class LFOWave : int {
Triangle,
Sine,
Pulse75,
Square,
Pulse25,
Pulse12_5,
Ramp,
Saw,
// ARIA extra
RandomSH = 12,
};
enum OpcodeFlags : int {
kIgnoreOOB = 1,
kCanBeNote = 1,
kEnforceLowerBound = 1 << 1,
kEnforceUpperBound = 1 << 2,
kCanBeNote = 1 << 3,
kNormalizePercent = 1 << 3,
kNormalizeMidi = 1 << 4,
kNormalizeBend = 1 << 5,
kWrapPhase = 1 << 6,
kDb2Mag = 1 << 7,
};
template<class T>
struct OpcodeSpec
{
T value;
T defaultValue;
Range<T> bounds;
int flags;
operator T() const { return defaultValue; }
};
namespace Default
@ -66,7 +83,8 @@ namespace Default
extern const OpcodeSpec<int64_t> offsetRandom;
extern const OpcodeSpec<uint32_t> sampleEnd;
extern const OpcodeSpec<uint32_t> sampleCount;
extern const OpcodeSpec<uint32_t> loopRange;
extern const OpcodeSpec<uint32_t> loopStart;
extern const OpcodeSpec<uint32_t> loopEnd;
extern const OpcodeSpec<float> loopCrossfade;
extern const OpcodeSpec<float> oscillatorPhase;
extern const OpcodeSpec<OscillatorEnabled> oscillator;
@ -82,11 +100,20 @@ namespace Default
extern const OpcodeSpec<uint32_t> polyphony;
extern const OpcodeSpec<uint32_t> notePolyphony;
extern const OpcodeSpec<uint8_t> key;
extern const OpcodeSpec<uint8_t> midi7;
extern const OpcodeSpec<float> float7;
extern const OpcodeSpec<float> bend;
extern const OpcodeSpec<float> normalized;
extern const OpcodeSpec<float> bipolar;
extern const OpcodeSpec<uint8_t> loKey;
extern const OpcodeSpec<uint8_t> hiKey;
extern const OpcodeSpec<float> loVel;
extern const OpcodeSpec<float> hiVel;
extern const OpcodeSpec<float> loCC;
extern const OpcodeSpec<float> hiCC;
extern const OpcodeSpec<float> loBend;
extern const OpcodeSpec<float> hiBend;
extern const OpcodeSpec<float> loNormalized;
extern const OpcodeSpec<float> hiNormalized;
extern const OpcodeSpec<float> loBipolar;
extern const OpcodeSpec<float> hiBipolar;
extern const OpcodeSpec<uint8_t> loChannelAftertouch;
extern const OpcodeSpec<uint8_t> hiChannelAftertouch;
extern const OpcodeSpec<uint16_t> ccNumber;
extern const OpcodeSpec<uint8_t> curveCC;
extern const OpcodeSpec<uint8_t> smoothCC;
@ -94,7 +121,8 @@ namespace Default
extern const OpcodeSpec<bool> checkSustain;
extern const OpcodeSpec<bool> checkSostenuto;
extern const OpcodeSpec<float> sustainThreshold;
extern const OpcodeSpec<float> bpm;
extern const OpcodeSpec<float> loBPM;
extern const OpcodeSpec<float> hiBPM;
extern const OpcodeSpec<uint8_t> sequence;
extern const OpcodeSpec<float> volume;
extern const OpcodeSpec<float> volumeMod;
@ -106,9 +134,9 @@ namespace Default
extern const OpcodeSpec<float> positionMod;
extern const OpcodeSpec<float> width;
extern const OpcodeSpec<float> widthMod;
extern const OpcodeSpec<uint8_t> crossfadeIn;
extern const OpcodeSpec<float> crossfadeIn;
extern const OpcodeSpec<float> crossfadeInNorm;
extern const OpcodeSpec<uint8_t> crossfadeOut;
extern const OpcodeSpec<float> crossfadeOut;
extern const OpcodeSpec<float> crossfadeOutNorm;
extern const OpcodeSpec<float> ampKeytrack;
extern const OpcodeSpec<float> ampVeltrack;
@ -152,7 +180,7 @@ namespace Default
extern const OpcodeSpec<unsigned> lfoCount;
extern const OpcodeSpec<unsigned> lfoSteps;
extern const OpcodeSpec<float> lfoStepX;
extern const OpcodeSpec<int> lfoWave;
extern const OpcodeSpec<LFOWave> lfoWave;
extern const OpcodeSpec<float> lfoOffset;
extern const OpcodeSpec<float> lfoRatio;
extern const OpcodeSpec<float> lfoScale;

26
src/sfizz/EGDescription.h
View file

@ -66,21 +66,21 @@ struct EGDescription {
EGDescription& operator=(const EGDescription&) = default;
EGDescription& operator=(EGDescription&&) = default;
float attack { Default::egTime.value };
float decay { Default::egTime.value };
float delay { Default::egTime.value };
float hold { Default::egTime.value };
float release { Default::egTime.value };
float attack { Default::egTime };
float decay { Default::egTime };
float delay { Default::egTime };
float hold { Default::egTime };
float release { Default::egTime };
float start { Default::egPercent.bounds.getStart() };
float sustain { Default::egPercent.bounds.getEnd() };
float depth { Default::egDepth.value };
float vel2attack { Default::egTimeMod.value };
float vel2decay { Default::egTimeMod.value };
float vel2delay { Default::egTimeMod.value };
float vel2hold { Default::egTimeMod.value };
float vel2release { Default::egPercentMod.value };
float vel2sustain { Default::egPercentMod.value };
float vel2depth { Default::egVel2Depth.value };
float depth { Default::egDepth };
float vel2attack { Default::egTimeMod };
float vel2decay { Default::egTimeMod };
float vel2delay { Default::egTimeMod };
float vel2hold { Default::egTimeMod };
float vel2release { Default::egPercentMod };
float vel2sustain { Default::egPercentMod };
float vel2depth { Default::egVel2Depth };
CCMap<float> ccAttack;
CCMap<float> ccDecay;

10
src/sfizz/EQDescription.h
View file

@ -14,11 +14,11 @@ namespace sfz
{
struct EQDescription
{
float bandwidth { Default::eqBandwidth.value };
float frequency { Default::eqFrequency.value };
float gain { Default::eqGain.value };
float vel2frequency { Default::eqVel2Frequency.value };
float vel2gain { Default::eqVel2Gain.value };
float bandwidth { Default::eqBandwidth };
float frequency { Default::eqFrequency };
float gain { Default::eqGain };
float vel2frequency { Default::eqVel2Frequency };
float vel2gain { Default::eqVel2Gain };
EqType type { EqType::kEqPeak };
};
}

6
src/sfizz/EQPool.h
View file

@ -43,9 +43,9 @@ private:
Resources& resources;
const EQDescription* description;
std::unique_ptr<FilterEq> eq;
float baseBandwidth { Default::eqBandwidth.value };
float baseFrequency { Default::eqFrequency.value };
float baseGain { Default::eqGain.value };
float baseBandwidth { Default::eqBandwidth };
float baseFrequency { Default::eqFrequency };
float baseGain { Default::eqGain };
bool prepared { false };
ModMatrix::TargetId gainTarget;
ModMatrix::TargetId frequencyTarget;

4
src/sfizz/Effects.h
View file

@ -179,8 +179,8 @@ private:
std::vector<std::unique_ptr<Effect>> _effects;
AudioBuffer<float> _inputs { EffectChannels, config::defaultSamplesPerBlock };
AudioBuffer<float> _outputs { EffectChannels, config::defaultSamplesPerBlock };
float _gainToMain { Default::effect.value };
float _gainToMix { Default::effect.value };
float _gainToMain { Default::effect };
float _gainToMix { Default::effect };
};
} // namespace sfz

8
src/sfizz/FilePool.cpp
View file

@ -255,7 +255,7 @@ absl::optional<sfz::FileInformation> sfz::FilePool::getFileInformation(const Fil
if (!fileId.isReverse()) {
if (haveInstrumentInfo && instrumentInfo.loop_count > 0) {
returnedValue.hasLoop = true;
returnedValue.loopBegin = instrumentInfo.loops[0].start;
returnedValue.loopStart = instrumentInfo.loops[0].start;
returnedValue.loopEnd = min(returnedValue.end, instrumentInfo.loops[0].end - 1);
}
} else {
@ -297,7 +297,7 @@ bool sfz::FilePool::preloadFile(const FileId& fileId, uint32_t maxOffset) noexce
const auto factor = static_cast<double>(oversamplingFactor);
fileInformation->sampleRate = factor * static_cast<double>(reader->sampleRate());
fileInformation->end = static_cast<uint32_t>(factor * fileInformation->end);
fileInformation->loopBegin = static_cast<uint32_t>(factor * fileInformation->loopBegin);
fileInformation->loopStart = static_cast<uint32_t>(factor * fileInformation->loopStart);
fileInformation->loopEnd = static_cast<uint32_t>(factor * fileInformation->loopEnd);
auto insertedPair = preloadedFiles.insert_or_assign(fileId, {
readFromFile(*reader, framesToLoad, oversamplingFactor),
@ -329,7 +329,7 @@ sfz::FileDataHolder sfz::FilePool::loadFile(const FileId& fileId) noexcept
const auto factor = static_cast<double>(oversamplingFactor);
fileInformation->sampleRate = factor * static_cast<double>(reader->sampleRate());
fileInformation->end = static_cast<uint32_t>(factor * fileInformation->end);
fileInformation->loopBegin = static_cast<uint32_t>(factor * fileInformation->loopBegin);
fileInformation->loopStart = static_cast<uint32_t>(factor * fileInformation->loopStart);
fileInformation->loopEnd = static_cast<uint32_t>(factor * fileInformation->loopEnd);
auto insertedPair = preloadedFiles.insert_or_assign(fileId, {
readFromFile(*reader, frames, oversamplingFactor),
@ -461,7 +461,7 @@ void sfz::FilePool::setOversamplingFactor(sfz::Oversampling factor) noexcept
FileInformation& information = preloadedFile.second.information;
information.sampleRate *= samplerateChange;
information.end = static_cast<uint32_t>(samplerateChange * information.end);
information.loopBegin = static_cast<uint32_t>(samplerateChange * information.loopBegin);
information.loopStart = static_cast<uint32_t>(samplerateChange * information.loopStart);
information.loopEnd = static_cast<uint32_t>(samplerateChange * information.loopEnd);
if (preloadedFile.second.status == FileData::Status::Done) {

6
src/sfizz/FilePool.h
View file

@ -51,10 +51,10 @@ using FileAudioBuffer = AudioBuffer<float, 2, config::defaultAlignment,
using FileAudioBufferPtr = std::shared_ptr<FileAudioBuffer>;
struct FileInformation {
uint32_t end { Default::sampleEnd.value };
uint32_t end { Default::sampleEnd };
uint32_t maxOffset { 0 };
uint32_t loopBegin { Default::loopRange.bounds.getStart() };
uint32_t loopEnd { Default::loopRange.bounds.getEnd() };
uint32_t loopStart { Default::loopStart };
uint32_t loopEnd { Default::loopEnd };
bool hasLoop { false };
double sampleRate { config::defaultSampleRate };
int numChannels { 0 };

14
src/sfizz/FilterDescription.h
View file

@ -14,13 +14,13 @@ namespace sfz
{
struct FilterDescription
{
float cutoff { Default::filterCutoff.value };
float resonance { Default::filterCutoff.value };
float gain { Default::filterGain.value };
int keytrack { Default::filterKeytrack.value };
uint8_t keycenter { Default::key.value };
int veltrack { Default::filterVeltrack.value };
float random { Default::filterRandom.value };
float cutoff { Default::filterCutoff };
float resonance { Default::filterCutoff };
float gain { Default::filterGain };
int keytrack { Default::filterKeytrack };
uint8_t keycenter { Default::key };
int veltrack { Default::filterVeltrack };
float random { Default::filterRandom };
FilterType type { FilterType::kFilterLpf2p };
};
}

8
src/sfizz/FilterPool.h
View file

@ -22,7 +22,7 @@ public:
* @param noteNumber the triggering note number
* @param velocity the triggering note velocity/value
*/
void setup(const Region& region, unsigned filterId, int noteNumber = static_cast<int>(Default::key.value), float velocity = 0);
void setup(const Region& region, unsigned filterId, int noteNumber = static_cast<int>(Default::key), float velocity = 0);
/**
* @brief Process a block of stereo inputs
*
@ -45,9 +45,9 @@ private:
Resources& resources;
const FilterDescription* description;
std::unique_ptr<Filter> filter;
float baseCutoff { Default::filterCutoff.value };
float baseResonance { Default::filterResonance.value };
float baseGain { Default::filterGain.value };
float baseCutoff { Default::filterCutoff };
float baseResonance { Default::filterResonance };
float baseGain { Default::filterGain };
ModMatrix::TargetId gainTarget;
ModMatrix::TargetId cutoffTarget;
ModMatrix::TargetId resonanceTarget;

12
src/sfizz/FlexEGDescription.h
View file

@ -18,24 +18,24 @@ namespace FlexEGs {
};
struct FlexEGPoint {
float time { Default::flexEGPointTime.value }; // duration until next step (s)
float level { Default::flexEGPointLevel.value }; // normalized amplitude
float time { Default::flexEGPointTime }; // duration until next step (s)
float level { Default::flexEGPointLevel }; // normalized amplitude
void setShape(float shape);
float shape() const noexcept { return shape_; }
const Curve& curve() const;
private:
float shape_ { Default::flexEGPointShape.value }; // 0: linear, positive: exp, negative: log
float shape_ { Default::flexEGPointShape }; // 0: linear, positive: exp, negative: log
std::shared_ptr<Curve> shapeCurve_;
};
struct FlexEGDescription {
int dynamic { Default::flexEGDynamic.value }; // whether parameters can be modulated while EG runs
int sustain { Default::flexEGSustain.value }; // index of the sustain point (default to 0 in ARIA)
int dynamic { Default::flexEGDynamic }; // whether parameters can be modulated while EG runs
int sustain { Default::flexEGSustain }; // index of the sustain point (default to 0 in ARIA)
std::vector<FlexEGPoint> points;
// ARIA
bool ampeg { Default::flexEGAmpeg.value }; // replaces the SFZv1 AmpEG (lowest with this bit wins)
bool ampeg { Default::flexEGAmpeg }; // replaces the SFZv1 AmpEG (lowest with this bit wins)
};
} // namespace sfz

33
src/sfizz/LFODescription.h
View file

@ -11,34 +11,21 @@
namespace sfz {
enum class LFOWave : int {
Triangle,
Sine,
Pulse75,
Square,
Pulse25,
Pulse12_5,
Ramp,
Saw,
// ARIA extra
RandomSH = 12,
};
struct LFODescription {
LFODescription();
~LFODescription();
static const LFODescription& getDefault();
float freq { Default::lfoFreq.value }; // lfoN_freq
float beats { Default::lfoBeats.value }; // lfoN_beats
float phase0 { Default::lfoPhase.value }; // lfoN_phase
float delay { Default::lfoDelay.value }; // lfoN_delay
float fade { Default::lfoFade.value }; // lfoN_fade
unsigned count { Default::lfoCount.value }; // lfoN_count
float freq { Default::lfoFreq }; // lfoN_freq
float beats { Default::lfoBeats }; // lfoN_beats
float phase0 { Default::lfoPhase }; // lfoN_phase
float delay { Default::lfoDelay }; // lfoN_delay
float fade { Default::lfoFade }; // lfoN_fade
unsigned count { Default::lfoCount }; // lfoN_count
struct Sub {
LFOWave wave { static_cast<LFOWave>(Default::lfoWave.value) }; // lfoN_wave[X]
float offset { Default::lfoOffset.value }; // lfoN_offset[X]
float ratio { Default::lfoRatio.value }; // lfoN_ratio[X]
float scale { Default::lfoScale.value }; // lfoN_scale[X]
LFOWave wave { Default::lfoWave }; // lfoN_wave[X]
float offset { Default::lfoOffset }; // lfoN_offset[X]
float ratio { Default::lfoRatio }; // lfoN_ratio[X]
float scale { Default::lfoScale }; // lfoN_scale[X]
};
struct StepSequence {
std::vector<float> steps {}; // lfoN_stepX - normalized to unity

101
src/sfizz/Opcode.cpp
View file

@ -5,6 +5,7 @@
// If not, contact the sfizz maintainers at https://github.com/sfztools/sfizz
#include "Opcode.h"
#include "LFODescription.h"
#include "StringViewHelpers.h"
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
@ -141,30 +142,22 @@ absl::optional<T> readInt_(OpcodeSpec<T> spec, absl::string_view v)
if (spec.flags & kEnforceUpperBound)
return spec.bounds.getEnd();
if (spec.flags & kIgnoreOOB)
return {};
}
if (returnedValue < static_cast<int64_t>(spec.bounds.getStart())) {
return {};
} else if (returnedValue < static_cast<int64_t>(spec.bounds.getStart())) {
if (spec.flags & kEnforceLowerBound)
return spec.bounds.getStart();
if (spec.flags & kIgnoreOOB)
return {};
return {};
}
T castValue = static_cast<T>(returnedValue);
if ((castValue != returnedValue) & kIgnoreOOB)
return {};
return castValue;
return returnedValue;
}
#define INSTANTIATE_FOR_INTEGRAL(T) \
template <> \
absl::optional<T> Opcode::read(OpcodeSpec<T> spec) const \
T Opcode::read(OpcodeSpec<T> spec) const \
{ \
return readInt_<T>(spec, value); \
return readInt_<T>(spec, value).value_or(spec.defaultValue); \
}
INSTANTIATE_FOR_INTEGRAL(uint8_t)
@ -198,30 +191,37 @@ absl::optional<T> readFloat_(OpcodeSpec<T> spec, absl::string_view v)
if (!absl::SimpleAtof(v, &returnedValue))
return absl::nullopt;
if (returnedValue > static_cast<int64_t>(spec.bounds.getEnd())) {
if (spec.flags & kWrapPhase)
returnedValue = wrapPhase(returnedValue);
else if (returnedValue > static_cast<int64_t>(spec.bounds.getEnd())) {
if (spec.flags & kEnforceUpperBound)
return spec.bounds.getEnd();
if (spec.flags & kIgnoreOOB)
return {};
}
if (returnedValue < static_cast<int64_t>(spec.bounds.getStart())) {
return {};
} else if (returnedValue < static_cast<int64_t>(spec.bounds.getStart())) {
if (spec.flags & kEnforceLowerBound)
return spec.bounds.getStart();
if (spec.flags & kIgnoreOOB)
return {};
return {};
}
if (spec.flags & kNormalizeMidi)
returnedValue = normalize7Bits(returnedValue);
else if (spec.flags & kNormalizePercent)
returnedValue = normalizePercents(returnedValue);
else if (spec.flags & kNormalizeBend)
returnedValue = normalizeBend(returnedValue);
else if (spec.flags & kDb2Mag)
returnedValue = db2mag(returnedValue);
return returnedValue;
}
#define INSTANTIATE_FOR_FLOATING_POINT(T) \
template <> \
absl::optional<T> Opcode::read(OpcodeSpec<T> spec) const \
T Opcode::read(OpcodeSpec<T> spec) const \
{ \
return readFloat_<T>(spec, value); \
return readFloat_<T>(spec, value).value_or(spec.defaultValue); \
}
INSTANTIATE_FOR_FLOATING_POINT(float)
@ -288,24 +288,21 @@ absl::optional<bool> readBooleanFromOpcode(const Opcode& opcode)
// ARIA-style booleans? (seen in egN_dynamic=1 for example)
// TODO check this
const OpcodeSpec<int64_t> fullInt64 { 0, Range<int64_t>::wholeRange(), 0 };
if (auto value = opcode.read(fullInt64))
return *value != 0;
return absl::nullopt;
return opcode.read(fullInt64);
}
template <>
absl::optional<OscillatorEnabled> Opcode::read(OpcodeSpec<OscillatorEnabled>) const
OscillatorEnabled Opcode::read(OpcodeSpec<OscillatorEnabled> spec) const
{
auto v = readBooleanFromOpcode(*this);
if (!v)
return absl::nullopt;
return spec.defaultValue;
return *v ? OscillatorEnabled::On : OscillatorEnabled::Off;
}
template <>
absl::optional<Trigger> Opcode::read(OpcodeSpec<Trigger>) const
Trigger Opcode::read(OpcodeSpec<Trigger> spec) const
{
switch (hash(value)) {
case hash("attack"): return Trigger::attack;
@ -316,11 +313,11 @@ absl::optional<Trigger> Opcode::read(OpcodeSpec<Trigger>) const
}
DBG("Unknown trigger value: " << value);
return absl::nullopt;
return spec.defaultValue;
}
template <>
absl::optional<CrossfadeCurve> Opcode::read(OpcodeSpec<CrossfadeCurve>) const
CrossfadeCurve Opcode::read(OpcodeSpec<CrossfadeCurve> spec) const
{
switch (hash(value)) {
case hash("power"): return CrossfadeCurve::power;
@ -328,11 +325,11 @@ absl::optional<CrossfadeCurve> Opcode::read(OpcodeSpec<CrossfadeCurve>) const
}
DBG("Unknown crossfade power curve: " << value);
return absl::nullopt;
return spec.defaultValue;
}
template <>
absl::optional<OffMode> Opcode::read(OpcodeSpec<OffMode>) const
OffMode Opcode::read(OpcodeSpec<OffMode> spec) const
{
switch (hash(value)) {
case hash("fast"): return OffMode::fast;
@ -341,11 +338,11 @@ absl::optional<OffMode> Opcode::read(OpcodeSpec<OffMode>) const
}
DBG("Unknown off mode: " << value);
return absl::nullopt;
return spec.defaultValue;
}
template <>
absl::optional<FilterType> Opcode::read(OpcodeSpec<FilterType>) const
FilterType Opcode::read(OpcodeSpec<FilterType> spec) const
{
switch (hash(value)) {
case hash("lpf_1p"): return kFilterLpf1p;
@ -374,11 +371,11 @@ absl::optional<FilterType> Opcode::read(OpcodeSpec<FilterType>) const
}
DBG("Unknown filter type: " << value);
return kFilterNone;
return spec.defaultValue;
}
template <>
absl::optional<EqType> Opcode::read(OpcodeSpec<EqType>) const
EqType Opcode::read(OpcodeSpec<EqType> spec) const
{
switch (hash(value)) {
case hash("peak"): return kEqPeak;
@ -387,11 +384,11 @@ absl::optional<EqType> Opcode::read(OpcodeSpec<EqType>) const
}
DBG("Unknown EQ type: " << value);
return kEqNone;
return spec.defaultValue;
}
template <>
absl::optional<VelocityOverride> Opcode::read(OpcodeSpec<VelocityOverride>) const
VelocityOverride Opcode::read(OpcodeSpec<VelocityOverride> spec) const
{
switch (hash(value)) {
case hash("current"): return VelocityOverride::current;
@ -399,11 +396,11 @@ absl::optional<VelocityOverride> Opcode::read(OpcodeSpec<VelocityOverride>) cons
}
DBG("Unknown velocity override: " << value);
return absl::nullopt;
return spec.defaultValue;
}
template <>
absl::optional<SelfMask> Opcode::read(OpcodeSpec<SelfMask>) const
SelfMask Opcode::read(OpcodeSpec<SelfMask> spec) const
{
switch (hash(value)) {
case hash("on"):
@ -412,13 +409,25 @@ absl::optional<SelfMask> Opcode::read(OpcodeSpec<SelfMask>) const
}
DBG("Unknown velocity override: " << value);
return absl::nullopt;
return spec.defaultValue;
}
template <>
absl::optional<bool> Opcode::read(OpcodeSpec<bool>) const
bool Opcode::read(OpcodeSpec<bool> spec) const
{
return readBooleanFromOpcode(*this);
return readBooleanFromOpcode(*this).value_or(spec.defaultValue);
}
template <>
LFOWave Opcode::read(OpcodeSpec<LFOWave> spec) const
{
const OpcodeSpec<int> intSpec {
static_cast<int>(spec.defaultValue),
Range<int>(static_cast<int>(spec.bounds.getStart()), static_cast<int>(spec.bounds.getEnd())),
0
};
int value = read(intSpec);
return static_cast<LFOWave>(value);
}
} // namespace sfz

2
src/sfizz/Opcode.h
View file

@ -102,7 +102,7 @@ struct Opcode {
}
template <class T>
absl::optional<T> read(OpcodeSpec<T> spec) const;
T read(OpcodeSpec<T> spec) const;
private:
static OpcodeCategory identifyCategory(absl::string_view name);

710
src/sfizz/Region.cpp
View file

File diff suppressed because it is too large Load diff

118
src/sfizz/Region.h
View file

@ -319,44 +319,44 @@ struct Region {
// Sound source: sample playback
std::shared_ptr<FileId> sampleId { new FileId }; // Sample
absl::optional<int> sampleQuality {};
float delay { Default::delay.value }; // delay
float delayRandom { Default::delayRandom.value }; // delay_random
int64_t offset { Default::offset.value }; // offset
int64_t offsetRandom { Default::offsetRandom.value }; // offset_random
CCMap<int64_t> offsetCC { Default::offsetMod.value };
uint32_t sampleEnd { Default::sampleEnd.value }; // end
absl::optional<uint32_t> sampleCount {}; // count
float delay { Default::delay }; // delay
float delayRandom { Default::delayRandom }; // delay_random
int64_t offset { Default::offset }; // offset
int64_t offsetRandom { Default::offsetRandom }; // offset_random
CCMap<int64_t> offsetCC { Default::offsetMod };
uint32_t sampleEnd { Default::sampleEnd }; // end
uint32_t sampleCount { Default::sampleCount }; // count
absl::optional<LoopMode> loopMode {}; // loopmode
Range<uint32_t> loopRange { Default::loopRange.bounds }; //loopstart and loopend
float loopCrossfade { Default::loopCrossfade.value }; // loop_crossfade
Range<uint32_t> loopRange { Default::loopStart, Default::loopEnd }; //loopstart and loopend
float loopCrossfade { Default::loopCrossfade }; // loop_crossfade
// Wavetable oscillator
float oscillatorPhase { Default::oscillatorPhase.value };
OscillatorEnabled oscillatorEnabled { Default::oscillator.value }; // oscillator
float oscillatorPhase { Default::oscillatorPhase };
OscillatorEnabled oscillatorEnabled { Default::oscillator }; // oscillator
bool hasWavetableSample { false }; // (set according to sample file)
int oscillatorMode { Default::oscillatorMode.value };
int oscillatorMulti { Default::oscillatorMulti.value };
float oscillatorDetune { Default::oscillatorDetune.value };
float oscillatorModDepth { Default::oscillatorModDepth.value };
int oscillatorMode { Default::oscillatorMode };
int oscillatorMulti { Default::oscillatorMulti };
float oscillatorDetune { Default::oscillatorDetune };
float oscillatorModDepth { Default::oscillatorModDepth };
absl::optional<int> oscillatorQuality;
// Instrument settings: voice lifecycle
uint32_t group { Default::group.value }; // group
uint32_t group { Default::group }; // group
absl::optional<uint32_t> offBy {}; // off_by
OffMode offMode { Default::offMode.value }; // off_mode
float offTime { Default::offTime.value }; // off_mode
OffMode offMode { Default::offMode }; // off_mode
float offTime { Default::offTime }; // off_mode
absl::optional<uint32_t> notePolyphony {}; // note_polyphony
uint32_t polyphony { config::maxVoices }; // polyphony
SelfMask selfMask { Default::selfMask.value };
bool rtDead { Default::rtDead.value };
SelfMask selfMask { Default::selfMask };
bool rtDead { Default::rtDead };
// Region logic: key mapping
Range<uint8_t> keyRange { Default::key.bounds }; //lokey, hikey and key
Range<float> velocityRange { Default::normalized.bounds }; // hivel and lovel
Range<uint8_t> keyRange { Default::loKey, Default::hiKey }; //lokey, hikey and key
Range<float> velocityRange { Default::loVel, Default::hiVel }; // hivel and lovel
// Region logic: MIDI conditions
Range<float> bendRange { Default::bipolar.bounds }; // hibend and lobend
CCMap<Range<float>> ccConditions { Default::normalized.bounds };
Range<float> bendRange { Default::loBend, Default::hiBend }; // hibend and lobend
CCMap<Range<float>> ccConditions {{ Default::loCC, Default::hiCC }};
absl::optional<uint8_t> lastKeyswitch {}; // sw_last
absl::optional<Range<uint8_t>> lastKeyswitchRange {}; // sw_last
absl::optional<std::string> keyswitchLabel {};
@ -364,45 +364,45 @@ struct Region {
absl::optional<uint8_t> downKeyswitch {}; // sw_down
absl::optional<uint8_t> previousKeyswitch {}; // sw_previous
absl::optional<uint8_t> defaultSwitch {};
VelocityOverride 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
float sustainThreshold { Default::sustainThreshold.value }; // sustain_cc
VelocityOverride velocityOverride { Default::velocityOverride }; // sw_vel
bool checkSustain { Default::checkSustain }; // sustain_sw
bool checkSostenuto { Default::checkSostenuto }; // sostenuto_sw
uint16_t sustainCC { Default::sustainCC }; // sustain_cc
float sustainThreshold { Default::sustainThreshold }; // sustain_cc
// Region logic: internal conditions
Range<uint8_t> aftertouchRange { Default::midi7.bounds }; // hichanaft and lochanaft
Range<float> bpmRange { Default::bpm.bounds }; // hibpm and lobpm
Range<float> randRange { Default::normalized.bounds }; // hirand and lorand
uint8_t sequenceLength { Default::sequence.value }; // seq_length
uint8_t sequencePosition { Default::sequence.value }; // seq_position
Range<uint8_t> aftertouchRange { Default::loChannelAftertouch, Default::hiChannelAftertouch }; // hichanaft and lochanaft
Range<float> bpmRange { Default::loBPM, Default::hiBPM }; // hibpm and lobpm
Range<float> randRange { Default::loNormalized, Default::hiNormalized }; // hirand and lorand
uint8_t sequenceLength { Default::sequence }; // seq_length
uint8_t sequencePosition { Default::sequence }; // seq_position
// Region logic: triggers
Trigger trigger { Default::trigger.value }; // trigger
CCMap<Range<float>> ccTriggers { Default::normalized.bounds }; // on_loccN on_hiccN
Trigger trigger { Default::trigger }; // trigger
CCMap<Range<float>> ccTriggers {{ Default::loCC, Default::hiCC }}; // on_loccN on_hiccN
// Performance parameters: amplifier
float volume { Default::volume.value }; // volume
float amplitude { normalizePercents(Default::amplitude.value) }; // amplitude
float pan { normalizePercents(Default::pan.value) }; // pan
float width { normalizePercents(Default::width.value) }; // width
float position { normalizePercents(Default::position.value) }; // position
uint8_t ampKeycenter { Default::key.value }; // amp_keycenter
float ampKeytrack { Default::ampKeytrack.value }; // amp_keytrack
float ampVeltrack { normalizePercents(Default::ampVeltrack.value) }; // amp_veltrack
float volume { Default::volume }; // volume
float amplitude { normalizePercents(Default::amplitude) }; // amplitude
float pan { normalizePercents(Default::pan) }; // pan
float width { normalizePercents(Default::width) }; // width
float position { normalizePercents(Default::position) }; // position
uint8_t ampKeycenter { Default::key }; // amp_keycenter
float ampKeytrack { Default::ampKeytrack }; // amp_keytrack
float ampVeltrack { normalizePercents(Default::ampVeltrack) }; // amp_veltrack
std::vector<std::pair<uint8_t, float>> velocityPoints; // amp_velcurve_N
absl::optional<Curve> velCurve {};
float ampRandom { Default::ampRandom.value }; // amp_random
float ampRandom { Default::ampRandom }; // amp_random
Range<uint8_t> crossfadeKeyInRange { Default::crossfadeKeyInRange };
Range<uint8_t> crossfadeKeyOutRange { Default::crossfadeKeyOutRange };
Range<float> crossfadeVelInRange { Default::crossfadeVelInRange };
Range<float> crossfadeVelOutRange { Default::crossfadeVelOutRange };
CrossfadeCurve crossfadeKeyCurve { Default::crossfadeCurve.value };
CrossfadeCurve crossfadeVelCurve { Default::crossfadeCurve.value };
CrossfadeCurve crossfadeCCCurve { Default::crossfadeCurve.value };
CrossfadeCurve crossfadeKeyCurve { Default::crossfadeCurve };
CrossfadeCurve crossfadeVelCurve { Default::crossfadeCurve };
CrossfadeCurve crossfadeCCCurve { Default::crossfadeCurve };
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
float rtDecay { Default::rtDecay }; // rt_decay
float globalAmplitude { 1.0 }; // global_amplitude
float masterAmplitude { 1.0 }; // master_amplitude
@ -416,17 +416,17 @@ struct Region {
std::vector<FilterDescription> filters;
// Performance parameters: pitch
uint8_t pitchKeycenter { Default::key.value }; // pitch_keycenter
uint8_t pitchKeycenter { Default::key }; // pitch_keycenter
bool pitchKeycenterFromSample { false };
int pitchKeytrack { Default::pitchKeytrack.value }; // pitch_keytrack
float pitchRandom { Default::pitchRandom.value }; // pitch_random
int pitchVeltrack { Default::pitchVeltrack.value }; // pitch_veltrack
int transpose { Default::transpose.value }; // transpose
float pitch { Default::pitch.value }; // tune
float bendUp { Default::bendUp.value };
float bendDown { Default::bendDown.value };
float bendStep { Default::bendStep.value };
uint8_t bendSmooth { Default::smoothCC.value };
int pitchKeytrack { Default::pitchKeytrack }; // pitch_keytrack
float pitchRandom { Default::pitchRandom }; // pitch_random
int pitchVeltrack { Default::pitchVeltrack }; // pitch_veltrack
int transpose { Default::transpose }; // transpose
float pitch { Default::pitch }; // tune
float bendUp { Default::bendUp };
float bendDown { Default::bendDown };
float bendStep { Default::bendStep };
uint8_t bendSmooth { Default::smoothCC };
// Envelopes
EGDescription amplitudeEG;

58
src/sfizz/Synth.cpp
View file

@ -191,7 +191,7 @@ void Synth::Impl::buildRegion(const std::vector<Opcode>& regionOpcodes)
currentSwitch_ = *lastRegion->defaultSwitch;
// There was a combination of group= and polyphony= on a region, so set the group polyphony
if (lastRegion->group != Default::group.value && lastRegion->polyphony != config::maxVoices) {
if (lastRegion->group != Default::group && lastRegion->polyphony != config::maxVoices) {
voiceManager_.setGroupPolyphony(lastRegion->group, lastRegion->polyphony);
} else {
// Just check that there are enough polyphony groups
@ -276,12 +276,10 @@ void Synth::Impl::handleMasterOpcodes(const std::vector<Opcode>& members)
switch (member.lettersOnlyHash) {
case hash("polyphony"):
ASSERT(currentSet_ != nullptr);
if (auto value = member.read(Default::polyphony))
currentSet_->setPolyphonyLimit(*value);
currentSet_->setPolyphonyLimit(member.read(Default::polyphony));
break;
case hash("sw_default"):
if (auto value = member.read(Default::key))
currentSwitch_ = *value;
currentSwitch_ = member.read(Default::key);
break;
}
}
@ -295,12 +293,10 @@ void Synth::Impl::handleGlobalOpcodes(const std::vector<Opcode>& members)
switch (member.lettersOnlyHash) {
case hash("polyphony"):
ASSERT(currentSet_ != nullptr);
if (auto value = member.read(Default::polyphony))
currentSet_->setPolyphonyLimit(*value);
currentSet_->setPolyphonyLimit(member.read(Default::polyphony));
break;
case hash("sw_default"):
if (auto value = member.read(Default::key))
currentSwitch_ = *value;
currentSwitch_ = member.read(Default::key);
break;
case hash("volume"):
// FIXME : Probably best not to mess with this and let the host control the volume
@ -320,16 +316,13 @@ void Synth::Impl::handleGroupOpcodes(const std::vector<Opcode>& members, const s
switch (member.lettersOnlyHash) {
case hash("group"):
if (auto value = member.read(Default::group))
groupIdx = *value;
groupIdx = member.read(Default::group);
break;
case hash("polyphony"):
if (auto value = member.read(Default::polyphony))
maxPolyphony = *value;
maxPolyphony = member.read(Default::polyphony);
break;
case hash("sw_default"):
if (auto value = member.read(Default::key))
currentSwitch_ = *value;
currentSwitch_ = member.read(Default::key);
break;
}
};
@ -358,16 +351,12 @@ void Synth::Impl::handleControlOpcodes(const std::vector<Opcode>& members)
switch (member.lettersOnlyHash) {
case hash("set_cc&"):
if (Default::ccNumber.bounds.containsWithEnd(member.parameters.back())) {
const auto ccValue = member.read(Default::midi7);
if (ccValue)
setDefaultHdcc(member.parameters.back(), normalizeCC(*ccValue));
setDefaultHdcc(member.parameters.back(), member.read(Default::loCC));
}
break;
case hash("set_hdcc&"):
if (Default::ccNumber.bounds.containsWithEnd(member.parameters.back())) {
const auto ccValue = member.read(Default::normalized);
if (ccValue)
setDefaultHdcc(member.parameters.back(), *ccValue);
setDefaultHdcc(member.parameters.back(), member.read(Default::loNormalized));
}
break;
case hash("label_cc&"):
@ -385,10 +374,10 @@ void Synth::Impl::handleControlOpcodes(const std::vector<Opcode>& members)
DBG("Changing default sample path to " << defaultPath_);
break;
case hash("note_offset"):
noteOffset_ = member.read(Default::noteOffset).value_or(noteOffset_);
noteOffset_ = member.read(Default::noteOffset);
break;
case hash("octave_offset"):
octaveOffset_ = member.read(Default::octaveOffset).value_or(octaveOffset_);
octaveOffset_ = member.read(Default::octaveOffset);
break;
case hash("hint_ram_based"):
if (member.value == "1")
@ -451,22 +440,19 @@ void Synth::Impl::handleEffectOpcodes(const std::vector<Opcode>& rawMembers)
// note(jpc): gain opcodes are linear volumes in % units
case hash("directtomain"):
if (auto valueOpt = opcode.read(Default::effect))
getOrCreateBus(0).setGainToMain(*valueOpt / 100);
getOrCreateBus(0).setGainToMain(opcode.read(Default::effect));
break;
case hash("fx&tomain"): // fx&tomain
if (opcode.parameters.front() < 1 || opcode.parameters.front() > config::maxEffectBuses)
break;
if (auto valueOpt = opcode.read(Default::effect))
getOrCreateBus(opcode.parameters.front()).setGainToMain(*valueOpt / 100);
getOrCreateBus(opcode.parameters.front()).setGainToMain(opcode.read(Default::effect));
break;
case hash("fx&tomix"): // fx&tomix
if (opcode.parameters.front() < 1 || opcode.parameters.front() > config::maxEffectBuses)
break;
if (auto valueOpt = opcode.read(Default::effect))
getOrCreateBus(opcode.parameters.front()).setGainToMix(*valueOpt / 100);
getOrCreateBus(opcode.parameters.front()).setGainToMix(opcode.read(Default::effect));
break;
}
}
@ -589,10 +575,10 @@ void Synth::Impl::finalizeSfzLoad()
region->sampleEnd = std::min(region->sampleEnd, fileInformation->end);
if (fileInformation->hasLoop) {
if (region->loopRange.getStart() == Default::loopRange.bounds.getStart())
region->loopRange.setStart(fileInformation->loopBegin);
if (region->loopRange.getStart() == Default::loopStart)
region->loopRange.setStart(fileInformation->loopStart);
if (region->loopRange.getEnd() == Default::loopRange.bounds.getEnd())
if (region->loopRange.getEnd() == Default::loopEnd)
region->loopRange.setEnd(fileInformation->loopEnd);
if (!region->loopMode)
@ -602,7 +588,7 @@ void Synth::Impl::finalizeSfzLoad()
if (region->isRelease() && !region->loopMode)
region->loopMode = LoopMode::one_shot;
if (region->loopRange.getEnd() == Default::loopRange.bounds.getEnd())
if (region->loopRange.getEnd() == Default::loopEnd)
region->loopRange.setEnd(region->sampleEnd);
if (fileInformation->numChannels == 2)
@ -668,13 +654,13 @@ void Synth::Impl::finalizeSfzLoad()
// Set the default frequencies on equalizers if needed
if (region->equalizers.size() > 0
&& region->equalizers[0].frequency == Default::eqFrequency.value) {
&& region->equalizers[0].frequency == Default::eqFrequency) {
region->equalizers[0].frequency = Default::defaultEQFreq[0];
if (region->equalizers.size() > 1
&& region->equalizers[1].frequency == Default::eqFrequency.value) {
&& region->equalizers[1].frequency == Default::eqFrequency) {
region->equalizers[1].frequency = Default::defaultEQFreq[1];
if (region->equalizers.size() > 2
&& region->equalizers[2].frequency == Default::eqFrequency.value) {
&& region->equalizers[2].frequency == Default::eqFrequency) {
region->equalizers[2].frequency = Default::defaultEQFreq[2];
}
}

2
src/sfizz/SynthConfig.h
View file

@ -13,7 +13,7 @@ struct SynthConfig
{
bool freeWheeling { false };
int liveSampleQuality { Default::sampleQuality.value };
int liveSampleQuality { Default::sampleQuality };
int freeWheelingSampleQuality { Default::freewheelingQuality };
int currentSampleQuality() const noexcept

6
src/sfizz/SynthMessaging.cpp
View file

@ -144,11 +144,7 @@ void sfz::Synth::dispatchMessage(Client& client, int delay, const char* path, co
MATCH("/region&/count", "") {
GET_REGION_OR_BREAK(indices[0])
if (!region.sampleCount) {
client.receive<'N'>(delay, path, {});
} else {
client.receive<'h'>(delay, path, *region.sampleCount);
}
client.receive<'h'>(delay, path, region.sampleCount);
} break;
MATCH("/region&/loop_range", "") {

4
src/sfizz/SynthPrivate.h
View file

@ -257,8 +257,8 @@ struct Synth::Impl final: public Parser::Listener {
// Control opcodes
std::string defaultPath_ { "" };
int noteOffset_ { Default::noteOffset.value };
int octaveOffset_ { Default::octaveOffset.value };
int noteOffset_ { Default::noteOffset };
int octaveOffset_ { Default::octaveOffset };
// Modulation source generators
std::unique_ptr<ControllerSource> genController_;

4
src/sfizz/Voice.cpp
View file

@ -371,7 +371,7 @@ void Voice::startVoice(Region* region, int delay, const TriggerEvent& event) noe
}
const float phase = region->getPhase();
const int quality =
region->oscillatorQuality.value_or(Default::oscillatorQuality.value);
region->oscillatorQuality.value_or(Default::oscillatorQuality);
for (WavetableOscillator& osc : impl.waveOscillators_) {
osc.setWavetable(wave);
osc.setPhase(phase);
@ -465,7 +465,7 @@ void Voice::off(int delay, bool fast) noexcept
Impl& impl = *impl_;
if (!impl.region_->flexAmpEG) {
if (impl.region_->offMode == OffMode::fast || fast) {
impl.egAmplitude_.setReleaseTime(Default::offTime.value);
impl.egAmplitude_.setReleaseTime(Default::offTime);
} else if (impl.region_->offMode == OffMode::time) {
impl.egAmplitude_.setReleaseTime(impl.region_->offTime);
}

18
src/sfizz/effects/Apan.cpp
View file

@ -81,28 +81,22 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("apan_waveform"):
if (auto value = opc.read(Default::apanWaveform))
apan->_lfoWave = *value;
apan->_lfoWave = opc.read(Default::apanWaveform);
break;
case hash("apan_freq"):
if (auto value = opc.read(Default::apanFrequency))
apan->_lfoFrequency = *value;
apan->_lfoFrequency = opc.read(Default::apanFrequency);
break;
case hash("apan_phase"):
if (auto value = opc.read(Default::apanPhase))
apan->_lfoPhaseOffset = wrapPhase(*value);
apan->_lfoPhaseOffset = opc.read(Default::apanPhase);
break;
case hash("apan_dry"):
if (auto value = opc.read(Default::apanLevel))
apan->_dry = *value / 100.0f;
apan->_dry = opc.read(Default::apanLevel);
break;
case hash("apan_wet"):
if (auto value = opc.read(Default::apanLevel))
apan->_wet = *value / 100.0f;
apan->_wet = opc.read(Default::apanLevel);
break;
case hash("apan_depth"):
if (auto value = opc.read(Default::apanLevel))
apan->_depth = *value / 100.0f;
apan->_depth = opc.read(Default::apanLevel);
break;
}
}

12
src/sfizz/effects/Apan.h
View file

@ -52,12 +52,12 @@ namespace fx {
sfz::Buffer<float> _lfoOutRight { config::defaultSamplesPerBlock };
// Controls
float _dry { Default::apanLevel.value };
float _wet { Default::apanLevel.value };
float _depth { Default::apanLevel.value };
int _lfoWave { Default::apanWaveform.value };
float _lfoFrequency { Default::apanFrequency.value };
float _lfoPhaseOffset { Default::apanPhase.value };
float _dry { Default::apanLevel };
float _wet { Default::apanLevel };
float _depth { Default::apanLevel };
int _lfoWave { Default::apanWaveform };
float _lfoFrequency { Default::apanFrequency };
float _lfoPhaseOffset { Default::apanPhase };
// State
float _lfoPhase { 0.0f };

29
src/sfizz/effects/Compressor.cpp
View file

@ -31,8 +31,8 @@ namespace fx {
struct Compressor::Impl {
faustCompressor _compressor[2];
bool _stlink { Default::compSTLink.value };
float _inputGain { Default::compGain.value };
bool _stlink { Default::compSTLink };
float _inputGain { Default::compGain };
AudioBuffer<float, 2> _tempBuffer2x { 2, _oversampling * config::defaultSamplesPerBlock };
AudioBuffer<float, 2> _gain2x { 2, _oversampling * config::defaultSamplesPerBlock };
hiir::Downsampler2xFpu<12> _downsampler2x[EffectChannels];
@ -163,35 +163,38 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("comp_attack"):
if (auto value = opc.read(Default::compAttack)) {
{
auto value = opc.read(Default::compAttack);
for (size_t c = 0; c < 2; ++c)
impl.set_Attack(c, *value);
impl.set_Attack(c, value);
}
break;
case hash("comp_release"):
if (auto value = opc.read(Default::compRelease)) {
{
auto value = opc.read(Default::compRelease);
for (size_t c = 0; c < 2; ++c)
impl.set_Release(c, *value);
impl.set_Release(c, value);
}
break;
case hash("comp_threshold"):
if (auto value = opc.read(Default::compThreshold)) {
{
auto value = opc.read(Default::compThreshold);
for (size_t c = 0; c < 2; ++c)
impl.set_Threshold(c, *value);
impl.set_Threshold(c, value);
}
break;
case hash("comp_ratio"):
if (auto value = opc.read(Default::compRatio)) {
{
auto value = opc.read(Default::compRatio);
for (size_t c = 0; c < 2; ++c)
impl.set_Ratio(c, *value);
impl.set_Ratio(c, value);
}
break;
case hash("comp_gain"):
if (auto value = opc.read(Default::compGain))
impl._inputGain = db2mag(*value);
impl._inputGain = opc.read(Default::compGain);
break;
case hash("comp_stlink"):
impl._stlink = opc.read(Default::compSTLink).value_or(impl._stlink);
impl._stlink = opc.read(Default::compSTLink);
break;
}
}

25
src/sfizz/effects/Disto.cpp
View file

@ -38,11 +38,11 @@ struct Disto::Impl {
enum { maxStages = 4 };
float _samplePeriod { 1.0f / config::defaultSampleRate };
float _tone { Default::distoTone.value };
float _depth { Default::distoDepth.value };
float _dry { Default::effect.value };
float _wet { Default::effect.value };
unsigned _numStages = { Default::distoStages.value };
float _tone { Default::distoTone };
float _depth { Default::distoDepth };
float _dry { Default::effect };
float _wet { Default::effect };
unsigned _numStages = { Default::distoStages };
float _toneLpfMem[EffectChannels] = {};
faustDisto _stages[EffectChannels][Default::maxDistoStages];
@ -205,24 +205,19 @@ std::unique_ptr<Effect> Disto::makeInstance(absl::Span<const Opcode> members)
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("disto_tone"):
if (auto value = opc.read(Default::distoTone))
impl._tone = *value;
impl._tone = opc.read(Default::distoTone);
break;
case hash("disto_depth"):
if (auto value = opc.read(Default::distoDepth))
impl._depth = *value;
impl._depth = opc.read(Default::distoDepth);
break;
case hash("disto_stages"):
if (auto value = opc.read(Default::distoStages))
impl._numStages = *value;
impl._numStages = opc.read(Default::distoStages);
break;
case hash("disto_dry"):
if (auto value = opc.read(Default::effect))
impl._dry = *value * 0.01f;
impl._dry = opc.read(Default::effect);
break;
case hash("disto_wet"):
if (auto value = opc.read(Default::effect))
impl._wet = *value * 0.01f;
impl._wet = opc.read(Default::effect);
break;
}
}

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

@ -70,22 +70,17 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("eq_freq"):
if (auto value = opc.read(Default::eqFrequency))
desc.frequency = *value;
desc.frequency = opc.read(Default::eqFrequency);
break;
case hash("eq_bw"):
if (auto value = opc.read(Default::eqBandwidth))
desc.bandwidth = *value;
desc.bandwidth = opc.read(Default::eqBandwidth);
break;
case hash("eq_gain"):
if (auto value = opc.read(Default::eqGain))
desc.gain = *value;
desc.gain = opc.read(Default::eqGain);
break;
case hash("eq_type"):
{
desc.type = opc.read(Default::eq).value_or(desc.type);
break;
}
desc.type = opc.read(Default::eq);
break;
}
}

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

@ -72,22 +72,17 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("filter_cutoff"):
if (auto value = opc.read(Default::filterCutoff))
desc.cutoff = *value;
desc.cutoff = opc.read(Default::filterCutoff);
break;
case hash("filter_resonance"):
if (auto value = opc.read(Default::filterResonance))
desc.resonance = *value;
desc.resonance = opc.read(Default::filterResonance);
break;
case hash("filter_type"):
{
desc.type = opc.read(Default::filter).value_or(desc.type);
break;
}
desc.type = opc.read(Default::filter);
break;
// extension
case hash("sfizz:filter_gain"):
if (auto value = opc.read(Default::filterGain))
desc.gain = *value;
desc.gain = opc.read(Default::filterGain);
break;
}
}

28
src/sfizz/effects/Fverb.cpp
View file

@ -180,13 +180,13 @@ namespace fx {
std::unique_ptr<Effect> fx { reverb };
const Impl::Profile* profile = &Impl::largeHall;
float dry { Default::effect.value };
float wet { Default::effect.value };
float input { Default::effect.value };
float size { Default::fverbSize.value };
float predelay { Default::fverbPredelay.value };
float tone { Default::fverbTone.value };
float damp { Default::fverbDamp.value };
float dry { Default::effect };
float wet { Default::effect };
float input { Default::effect };
float size { Default::fverbSize };
float predelay { Default::fverbPredelay };
float tone { Default::fverbTone };
float damp { Default::fverbDamp };
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
@ -212,25 +212,25 @@ namespace fx {
break;
case hash("reverb_dry"):
dry = opc.read(Default::effect).value_or(dry);
dry = opc.read(Default::effect);
break;
case hash("reverb_wet"):
wet = opc.read(Default::effect).value_or(wet);
wet = opc.read(Default::effect);
break;
case hash("reverb_input"):
input = opc.read(Default::effect).value_or(input);
input = opc.read(Default::effect);
break;
case hash("reverb_size"):
size = opc.read(Default::fverbSize).value_or(size);
size = opc.read(Default::fverbSize);
break;
case hash("reverb_predelay"):
predelay = opc.read(Default::fverbPredelay).value_or(predelay);
predelay = opc.read(Default::fverbPredelay);
break;
case hash("reverb_tone"):
tone = opc.read(Default::fverbTone).value_or(tone);
tone = opc.read(Default::fverbTone);
break;
case hash("reverb_damp"):
damp = opc.read(Default::fverbDamp).value_or(damp);
damp = opc.read(Default::fverbDamp);
break;
}
}

3
src/sfizz/effects/Gain.cpp
View file

@ -62,8 +62,7 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("gain"):
if (auto value = opc.read(Default::volume))
gain->_gain = *value;
gain->_gain = opc.read(Default::volume);
break;
}
}

24
src/sfizz/effects/Gate.cpp
View file

@ -34,7 +34,7 @@ namespace fx {
struct Gate::Impl {
faustGate _gate[2];
bool _stlink { Default::gateSTLink.value };
bool _stlink { Default::gateSTLink };
float _inputGain = 1.0;
AudioBuffer<float, 2> _tempBuffer2x { 2, _oversampling * config::defaultSamplesPerBlock };
AudioBuffer<float, 2> _gain2x { 2, _oversampling * config::defaultSamplesPerBlock };
@ -166,31 +166,35 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("gate_attack"):
if (auto value = opc.read(Default::gateAttack)) {
{
auto value = opc.read(Default::gateAttack);
for (size_t c = 0; c < 2; ++c)
impl.set_Attack(c, *value);
impl.set_Attack(c, value);
}
break;
case hash("gate_hold"):
if (auto value = opc.read(Default::gateHold)) {
{
auto value = opc.read(Default::gateHold);
for (size_t c = 0; c < 2; ++c)
impl.set_Hold(c, *value);
impl.set_Hold(c, value);
}
break;
case hash("gate_release"):
if (auto value = opc.read(Default::gateRelease)) {
{
auto value = opc.read(Default::gateRelease);
for (size_t c = 0; c < 2; ++c)
impl.set_Release(c, *value);
impl.set_Release(c, value);
}
break;
case hash("gate_threshold"):
if (auto value = opc.read(Default::gateThreshold)) {
{
auto value = opc.read(Default::gateThreshold);
for (size_t c = 0; c < 2; ++c)
impl.set_Threshold(c, *value);
impl.set_Threshold(c, value);
}
break;
case hash("gate_stlink"):
impl._stlink = opc.read(Default::gateSTLink).value_or(impl._stlink);
impl._stlink = opc.read(Default::gateSTLink);
}
}

6
src/sfizz/effects/Lofi.cpp
View file

@ -85,12 +85,10 @@ namespace fx {
for (const Opcode& opcode : members) {
switch (opcode.lettersOnlyHash) {
case hash("bitred"):
if (auto value = opcode.read(Default::lofiBitred))
lofi->_bitred_depth = *value;
lofi->_bitred_depth = opcode.read(Default::lofiBitred);
break;
case hash("decim"):
if (auto value = opcode.read(Default::lofiDecim))
lofi->_decim_depth = *value;
lofi->_decim_depth = opcode.read(Default::lofiDecim);
break;
}
}

3
src/sfizz/effects/Rectify.cpp
View file

@ -95,8 +95,7 @@ namespace fx {
rectify->_full = false;
break;
case hash("rectify"):
if (auto value = opc.read(Default::rectify))
rectify->_amount = *value;
rectify->_amount = opc.read(Default::rectify);
break;
}
}

6
src/sfizz/effects/Strings.cpp
View file

@ -132,12 +132,10 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("strings_number"):
if (auto value = opc.read(Default::stringsNumber))
strings->_numStrings = *value;
strings->_numStrings = opc.read(Default::stringsNumber);
break;
case hash("strings_wet"):
if (auto value = opc.read(Default::effect))
strings->_wet = *value;
strings->_wet = opc.read(Default::effect);
break;
}
}

2
src/sfizz/effects/Strings.h
View file

@ -52,7 +52,7 @@ namespace fx {
enum { MaximumNumStrings = 88 };
unsigned _numStrings { Default::maxStrings };
float _wet { Default::effect.value };
float _wet { Default::effect };
std::unique_ptr<ResonantArray> _stringsArray;

3
src/sfizz/effects/Width.cpp
View file

@ -69,8 +69,7 @@ namespace fx {
for (const Opcode& opc : members) {
switch (opc.lettersOnlyHash) {
case hash("width"):
if (auto value = opc.read(Default::width))
width->_width = *value;
width->_width = opc.read(Default::width);
break;
}
}

27
tests/OpcodeT.cpp
View file

@ -317,8 +317,8 @@ TEST_CASE("[Opcode] opcode read (uint8_t)")
SECTION("Ignore")
{
Opcode opcode { "", "110" };
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(0, 100), kIgnoreOOB };
REQUIRE( !opcode.read(spec) );
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(0, 100), 0 };
REQUIRE( opcode.read(spec) == spec.defaultValue );
}
SECTION("Clamp upper")
@ -345,21 +345,21 @@ TEST_CASE("[Opcode] opcode read (uint8_t)")
SECTION("Text after")
{
Opcode opcode { "", "10garbage" };
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(20, 100), kEnforceLowerBound };
REQUIRE( opcode.read(spec) == 20 );
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(0, 100), 0 };
REQUIRE( opcode.read(spec) == 10 );
}
SECTION("Text before")
{
Opcode opcode { "", "garbage10" };
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(20, 100), 0 };
REQUIRE( !opcode.read(spec) );
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(0, 100), 0 };
REQUIRE( opcode.read(spec) == spec.defaultValue );
}
SECTION("Can be note")
{
Opcode opcode { "", "c4" };
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(20, 100), kCanBeNote };
OpcodeSpec<uint8_t> spec { 0, Range<uint8_t>(0, 100), kCanBeNote };
REQUIRE( opcode.read(spec) == 60 );
}
}
@ -387,13 +387,6 @@ TEST_CASE("[Opcode] opcode read (int)")
REQUIRE( opcode.read(spec) == -16);
}
SECTION("Ignore")
{
Opcode opcode { "", "110" };
OpcodeSpec<int> spec { 0, Range<int>(-100, 100), kIgnoreOOB };
REQUIRE( !opcode.read(spec) );
}
SECTION("Clamp upper")
{
Opcode opcode { "", "110" };
@ -418,7 +411,7 @@ TEST_CASE("[Opcode] opcode read (int)")
SECTION("Text after")
{
Opcode opcode { "", "10garbage" };
OpcodeSpec<int> spec { 0, Range<int>(20, 100), kEnforceLowerBound };
OpcodeSpec<int> spec { 0, Range<int>(20, 100), 0 };
REQUIRE( opcode.read(spec) == 20 );
}
@ -464,8 +457,8 @@ TEST_CASE("[Opcode] opcode read (float)")
SECTION("Ignore")
{
Opcode opcode { "", "110" };
OpcodeSpec<float> spec { 0.0f, Range<float>(-100.0f, 100.0f), kIgnoreOOB };
REQUIRE( !opcode.read(spec) );
OpcodeSpec<float> spec { 0.0f, Range<float>(-100.0f, 100.0f), 0 };
REQUIRE( opcode.read(spec) == spec.defaultValue );
}
SECTION("Clamp upper")

6
tests/RegionValueComputationsT.cpp
View file

@ -299,15 +299,15 @@ TEST_CASE("[Region] rt_decay")
region.parseOpcode({ "rt_decay", "10" });
midiState.noteOnEvent(0, 64, 64_norm);
midiState.advanceTime(100);
REQUIRE( region.getBaseVolumedB(64) == Approx(Default::volume.value - 1.0f).margin(0.1) );
REQUIRE( region.getBaseVolumedB(64) == Approx(Default::volume - 1.0f).margin(0.1) );
region.parseOpcode({ "rt_decay", "20" });
midiState.noteOnEvent(0, 64, 64_norm);
midiState.advanceTime(100);
REQUIRE( region.getBaseVolumedB(64) == Approx(Default::volume.value - 2.0f).margin(0.1) );
REQUIRE( region.getBaseVolumedB(64) == Approx(Default::volume - 2.0f).margin(0.1) );
region.parseOpcode({ "trigger", "attack" });
midiState.noteOnEvent(0, 64, 64_norm);
midiState.advanceTime(100);
REQUIRE( region.getBaseVolumedB(64) == Approx(Default::volume.value).margin(0.1) );
REQUIRE( region.getBaseVolumedB(64) == Approx(Default::volume).margin(0.1) );
}
TEST_CASE("[Region] Base delay")

10
tests/RegionValuesT.cpp
View file

@ -248,9 +248,9 @@ TEST_CASE("[Values] Count")
synth.dispatchMessage(client, 0, "/region1/count", "", nullptr);
synth.dispatchMessage(client, 0, "/region2/count", "", nullptr);
std::vector<std::string> expected {
"/region0/count,N : { }",
"/region0/count,h : { 1 }",
"/region1/count,h : { 2 }",
"/region2/count,N : { }",
"/region2/count,h : { 1 }",
};
REQUIRE(messageList == expected);
}
@ -453,7 +453,7 @@ TEST_CASE("[Values] Off time")
std::vector<std::string> expected {
"/region0/off_time,f : { 0.006 }",
"/region1/off_time,f : { 0.1 }",
"/region2/off_time,f : { 0 }",
"/region2/off_time,f : { 0.006 }",
};
REQUIRE(messageList == expected);
}
@ -747,7 +747,7 @@ TEST_CASE("[Values] Upswitch")
"/region2/sw_up,N : { }",
"/region3/sw_up,N : { }",
"/region4/sw_up,i : { 60 }",
"/region5/sw_up,i : { 64 }",
"/region5/sw_up,i : { 60 }",
};
REQUIRE(messageList == expected);
}
@ -778,7 +778,7 @@ TEST_CASE("[Values] Downswitch")
"/region2/sw_down,N : { }",
"/region3/sw_down,N : { }",
"/region4/sw_down,i : { 60 }",
"/region5/sw_down,i : { 64 }",
"/region5/sw_down,i : { 60 }",
};
REQUIRE(messageList == expected);
}

2
tests/SynthT.cpp
View file

@ -572,7 +572,7 @@ TEST_CASE("[Synth] sample quality")
// default sample quality
synth.noteOn(0, 60, 100);
REQUIRE(synth.getNumActiveVoices() == 1);
REQUIRE(synth.getVoiceView(0)->getCurrentSampleQuality() == sfz::Default::sampleQuality.value);
REQUIRE(synth.getVoiceView(0)->getCurrentSampleQuality() == sfz::Default::sampleQuality);
synth.allSoundOff();
// default sample quality, freewheeling