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

Merge pull request #40 from paulfd/parse-parameters

Browse source 
Parse all parameters in opcodes
This commit is contained in:
Paul Ferrand 2020-02-04 23:48:46 +01:00 • committed by GitHub
commit bc72240bed
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 197 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
src/sfizz/Opcode.cpp
View file

@ -6,21 +6,65 @@
#include "Opcode.h"
#include "StringViewHelpers.h"
#include <cctype>
sfz::Opcode::Opcode(absl::string_view inputOpcode, absl::string_view inputValue)
: opcode(inputOpcode)
, value(inputValue)
{
const auto lastCharIndex = inputOpcode.find_last_not_of("1234567890");
if (lastCharIndex != inputOpcode.npos) {
int returnedValue;
absl::string_view parameterView = inputOpcode;
parameterView.remove_prefix(lastCharIndex + 1);
if (absl::SimpleAtoi(parameterView, &returnedValue)) {
parameter = returnedValue;
opcode.remove_suffix(opcode.size() - lastCharIndex - 1);
}
}
trimInPlace(value);
trimInPlace(opcode);
size_t nextCharIndex { 0 };
int parameterPosition { 0 };
auto nextNumIndex = opcode.find_first_of("1234567890");
while (nextNumIndex != opcode.npos) {
const auto numLetters = nextNumIndex - nextCharIndex;
parameterPosition += numLetters;
lettersOnlyHash = hash(opcode.substr(nextCharIndex, numLetters), lettersOnlyHash);
nextCharIndex = opcode.find_first_not_of("1234567890", nextNumIndex);
uint32_t returnedValue;
hasBackParameter = (nextCharIndex == opcode.npos);
const auto numDigits = hasBackParameter ? opcode.npos : nextCharIndex - nextNumIndex;
if (absl::SimpleAtoi(opcode.substr(nextNumIndex, numDigits), &returnedValue)) {
ASSERT(returnedValue < std::numeric_limits<uint8_t>::max());
parameterPositions.push_back(parameterPosition);
parameters.push_back(returnedValue);
}
nextNumIndex = opcode.find_first_of("1234567890", nextCharIndex);
}
if (nextCharIndex != opcode.npos)
lettersOnlyHash = hash(opcode.substr(nextCharIndex), lettersOnlyHash);
}
absl::optional<uint8_t> sfz::Opcode::backParameter() const noexcept
{
if (hasBackParameter && !parameters.empty())
return parameters.back();
return {};
}
absl::optional<uint8_t> sfz::Opcode::firstParameter() const noexcept
{
if (!hasBackParameter && !parameters.empty())
return parameters.front();
if (hasBackParameter && parameters.size() > 1)
return parameters.front();
return {};
}
absl::optional<uint8_t> sfz::Opcode::middleParameter() const noexcept
{
if (!hasBackParameter && parameters.size() > 1)
return parameters[1];
if (hasBackParameter && parameters.size() > 2)
return parameters[1];
return {};
}

21
src/sfizz/Opcode.h
View file

@ -12,6 +12,7 @@
#include "StringViewHelpers.h"
#include <absl/types/optional.h>
#include <string_view>
#include <vector>
#include <type_traits>
// charconv support is still sketchy with clang/gcc so we use abseil's numbers
@ -19,18 +20,23 @@
namespace sfz {
/**
* @brief Opcode description class; should be very lightweight to use
* and move around. The class parses the parameters of the opcode
* on construction.
* @brief Opcode description class. The class parses the parameters
* of the opcode on construction.
*
*/
struct Opcode {
Opcode() = delete;
absl::optional<uint8_t> backParameter() const noexcept;
absl::optional<uint8_t> firstParameter() const noexcept;
absl::optional<uint8_t> middleParameter() const noexcept;
Opcode(absl::string_view inputOpcode, absl::string_view inputValue);
absl::string_view opcode {};
absl::string_view value {};
// This is to handle the integer parameter of some opcodes
absl::optional<uint8_t> parameter;
uint64_t lettersOnlyHash { Fnv1aBasis };
// This is to handle the integer parameters of some opcodes
std::vector<uint8_t> parameters;
std::vector<int> parameterPositions;
bool hasBackParameter { false };
LEAK_DETECTOR(Opcode);
};
@ -186,8 +192,9 @@ template <class ValueType>
inline void setCCPairFromOpcode(const Opcode& opcode, absl::optional<CCValuePair>& target, const Range<ValueType>& validRange)
{
auto value = readOpcode(opcode.value, validRange);
if (value && opcode.parameter && Default::ccNumberRange.containsWithEnd(*opcode.parameter))
target = std::make_pair(*opcode.parameter, *value);
const auto backParameter = opcode.backParameter();
if (value && backParameter && Default::ccNumberRange.containsWithEnd(*backParameter))
target = std::make_pair(*backParameter, *value);
else
target = {};
}

71
src/sfizz/Region.cpp
View file

@ -17,13 +17,14 @@
bool sfz::Region::parseOpcode(const Opcode& opcode)
{
const auto backParameter = opcode.backParameter();
// Check that the parameter is well formed
if (opcode.parameter && !sfz::Default::ccNumberRange.containsWithEnd(*opcode.parameter)) {
DBG("Wrong parameter value (" << std::to_string(*opcode.parameter) << ") for opcode " << opcode.opcode);
if (backParameter && !sfz::Default::ccNumberRange.containsWithEnd(*backParameter)) {
DBG("Wrong parameter value (" << std::to_string(*backParameter) << ") for opcode " << opcode.opcode);
return false;
}
switch (hash(opcode.opcode)) {
switch (opcode.lettersOnlyHash) {
// Sound source: sample playback
case hash("sample"):
{
@ -135,13 +136,13 @@ bool sfz::Region::parseOpcode(const Opcode& opcode)
setRangeEndFromOpcode(opcode, bendRange, Default::bendRange);
break;
case hash("locc"):
if (opcode.parameter) {
setRangeStartFromOpcode(opcode, ccConditions[*opcode.parameter], Default::ccValueRange);
if (backParameter) {
setRangeStartFromOpcode(opcode, ccConditions[*backParameter], Default::ccValueRange);
}
break;
case hash("hicc"):
if (opcode.parameter)
setRangeEndFromOpcode(opcode, ccConditions[*opcode.parameter], Default::ccValueRange);
if (backParameter)
setRangeEndFromOpcode(opcode, ccConditions[*backParameter], Default::ccValueRange);
break;
case hash("sw_lokey"):
setRangeStartFromOpcode(opcode, keyswitchRange, Default::keyRange);
@ -233,13 +234,13 @@ bool sfz::Region::parseOpcode(const Opcode& opcode)
break;
case hash("on_locc"):
case hash("start_locc"):
if (opcode.parameter)
setRangeStartFromOpcode(opcode, ccTriggers[*opcode.parameter], Default::ccTriggerValueRange);
if (backParameter)
setRangeStartFromOpcode(opcode, ccTriggers[*backParameter], Default::ccTriggerValueRange);
break;
case hash("on_hicc"):
case hash("start_hicc"):
if (opcode.parameter)
setRangeEndFromOpcode(opcode, ccTriggers[*opcode.parameter], Default::ccTriggerValueRange);
if (backParameter)
setRangeEndFromOpcode(opcode, ccTriggers[*backParameter], Default::ccTriggerValueRange);
break;
// Performance parameters: amplifier
@ -293,7 +294,7 @@ bool sfz::Region::parseOpcode(const Opcode& opcode)
{
auto value = readOpcode(opcode.value, Default::ampVelcurveRange);
if (value)
velocityPoints.emplace_back(*opcode.parameter, *value);
velocityPoints.emplace_back(*backParameter, *value);
}
break;
case hash("xfin_lokey"):
@ -345,23 +346,23 @@ bool sfz::Region::parseOpcode(const Opcode& opcode)
}
break;
case hash("xfin_locc"):
if (opcode.parameter) {
setRangeStartFromOpcode(opcode, crossfadeCCInRange[*opcode.parameter], Default::ccValueRange);
if (backParameter) {
setRangeStartFromOpcode(opcode, crossfadeCCInRange[*backParameter], Default::ccValueRange);
}
break;
case hash("xfin_hicc"):
if (opcode.parameter) {
setRangeEndFromOpcode(opcode, crossfadeCCInRange[*opcode.parameter], Default::ccValueRange);
if (backParameter) {
setRangeEndFromOpcode(opcode, crossfadeCCInRange[*backParameter], Default::ccValueRange);
}
break;
case hash("xfout_locc"):
if (opcode.parameter) {
setRangeStartFromOpcode(opcode, crossfadeCCOutRange[*opcode.parameter], Default::ccValueRange);
if (backParameter) {
setRangeStartFromOpcode(opcode, crossfadeCCOutRange[*backParameter], Default::ccValueRange);
}
break;
case hash("xfout_hicc"):
if (opcode.parameter) {
setRangeEndFromOpcode(opcode, crossfadeCCOutRange[*opcode.parameter], Default::ccValueRange);
if (backParameter) {
setRangeEndFromOpcode(opcode, crossfadeCCOutRange[*backParameter], Default::ccValueRange);
}
break;
case hash("xf_cccurve"):
@ -433,23 +434,29 @@ bool sfz::Region::parseOpcode(const Opcode& opcode)
case hash("ampeg_sustain"):
setValueFromOpcode(opcode, amplitudeEG.sustain, Default::egPercentRange);
break;
case hash("ampeg_vel2attack"):
setValueFromOpcode(opcode, amplitudeEG.vel2attack, Default::egOnCCTimeRange);
case hash("ampeg_velattack"):
if (!opcode.parameters.empty() && opcode.parameters.front() == 2)
setValueFromOpcode(opcode, amplitudeEG.vel2attack, Default::egOnCCTimeRange);
break;
case hash("ampeg_vel2decay"):
setValueFromOpcode(opcode, amplitudeEG.vel2decay, Default::egOnCCTimeRange);
case hash("ampeg_veldecay"):
if (!opcode.parameters.empty() && opcode.parameters.front() == 2)
setValueFromOpcode(opcode, amplitudeEG.vel2decay, Default::egOnCCTimeRange);
break;
case hash("ampeg_vel2delay"):
setValueFromOpcode(opcode, amplitudeEG.vel2delay, Default::egOnCCTimeRange);
case hash("ampeg_veldelay"):
if (!opcode.parameters.empty() && opcode.parameters.front() == 2)
setValueFromOpcode(opcode, amplitudeEG.vel2delay, Default::egOnCCTimeRange);
break;
case hash("ampeg_vel2hold"):
setValueFromOpcode(opcode, amplitudeEG.vel2hold, Default::egOnCCTimeRange);
case hash("ampeg_velhold"):
if (!opcode.parameters.empty() && opcode.parameters.front() == 2)
setValueFromOpcode(opcode, amplitudeEG.vel2hold, Default::egOnCCTimeRange);
break;
case hash("ampeg_vel2release"):
setValueFromOpcode(opcode, amplitudeEG.vel2release, Default::egOnCCTimeRange);
case hash("ampeg_velrelease"):
if (!opcode.parameters.empty() && opcode.parameters.front() == 2)
setValueFromOpcode(opcode, amplitudeEG.vel2release, Default::egOnCCTimeRange);
break;
case hash("ampeg_vel2sustain"):
setValueFromOpcode(opcode, amplitudeEG.vel2sustain, Default::egOnCCPercentRange);
case hash("ampeg_velsustain"):
if (!opcode.parameters.empty() && opcode.parameters.front() == 2)
setValueFromOpcode(opcode, amplitudeEG.vel2sustain, Default::egOnCCPercentRange);
break;
case hash("ampeg_attackcc"):
case hash("ampeg_attack_oncc"):

13
src/sfizz/Synth.cpp
View file

@ -137,7 +137,7 @@ void sfz::Synth::clear()
void sfz::Synth::handleGlobalOpcodes(const std::vector<Opcode>& members)
{
for (auto& member : members) {
switch (hash(member.opcode)) {
switch (member.lettersOnlyHash) {
case hash("sw_default"):
setValueFromOpcode(member, defaultSwitch, Default::keyRange);
break;
@ -152,20 +152,21 @@ void sfz::Synth::handleGlobalOpcodes(const std::vector<Opcode>& members)
void sfz::Synth::handleControlOpcodes(const std::vector<Opcode>& members)
{
for (auto& member : members) {
switch (hash(member.opcode)) {
const auto backParameter = member.backParameter();
switch (member.lettersOnlyHash) {
case hash("Set_cc"):
[[fallthrough]];
case hash("set_cc"):
if (member.parameter && Default::ccNumberRange.containsWithEnd(*member.parameter)) {
if (backParameter && Default::ccNumberRange.containsWithEnd(*backParameter)) {
const auto ccValue = readOpcode(member.value, Default::ccValueRange).value_or(0);
midiState.ccEvent(*member.parameter, ccValue);
midiState.ccEvent(*backParameter, ccValue);
}
break;
case hash("Label_cc"):
[[fallthrough]];
case hash("label_cc"):
if (member.parameter && Default::ccNumberRange.containsWithEnd(*member.parameter))
ccNames.emplace_back(*member.parameter, std::string(member.value));
if (backParameter && Default::ccNumberRange.containsWithEnd(*backParameter))
ccNames.emplace_back(*backParameter, std::string(member.value));
break;
case hash("Default_path"):
[[fallthrough]];

91
tests/OpcodeT.cpp
View file

@ -14,34 +14,109 @@ TEST_CASE("[Opcode] Construction")
{
sfz::Opcode opcode { "sample", "dummy" };
REQUIRE(opcode.opcode == "sample");
REQUIRE(opcode.lettersOnlyHash == hash("sample"));
REQUIRE(opcode.parameters.empty());
REQUIRE(opcode.value == "dummy");
REQUIRE(!opcode.parameter);
REQUIRE(!opcode.backParameter());
REQUIRE(!opcode.firstParameter());
REQUIRE(!opcode.middleParameter());
}
SECTION("Normal construction with underscore")
{
sfz::Opcode opcode { "sample_underscore", "dummy" };
REQUIRE(opcode.opcode == "sample_underscore");
REQUIRE(opcode.lettersOnlyHash == hash("sample_underscore"));
REQUIRE(opcode.parameters.empty());
REQUIRE(opcode.value == "dummy");
REQUIRE(!opcode.parameter);
REQUIRE(!opcode.backParameter());
REQUIRE(!opcode.firstParameter());
REQUIRE(!opcode.middleParameter());
}
SECTION("Parameterized opcode")
{
sfz::Opcode opcode { "sample123", "dummy" };
REQUIRE(opcode.opcode == "sample");
REQUIRE(opcode.opcode == "sample123");
REQUIRE(opcode.lettersOnlyHash == hash("sample"));
REQUIRE(opcode.value == "dummy");
REQUIRE(opcode.parameter);
REQUIRE(*opcode.parameter == 123);
REQUIRE(opcode.parameters.size() == 1);
REQUIRE(opcode.parameters == std::vector<uint8_t>({ 123 }));
REQUIRE(opcode.parameterPositions == std::vector<int>({ 6 }));
REQUIRE(opcode.backParameter());
REQUIRE(*opcode.backParameter() == 123);
REQUIRE(!opcode.firstParameter());
REQUIRE(!opcode.middleParameter());
}
SECTION("Parameterized opcode with underscore")
{
sfz::Opcode opcode { "sample_underscore123", "dummy" };
REQUIRE(opcode.opcode == "sample_underscore");
REQUIRE(opcode.opcode == "sample_underscore123");
REQUIRE(opcode.lettersOnlyHash == hash("sample_underscore"));
REQUIRE(opcode.value == "dummy");
REQUIRE(opcode.parameter);
REQUIRE(*opcode.parameter == 123);
REQUIRE(opcode.parameters == std::vector<uint8_t>({ 123 }));
REQUIRE(opcode.parameterPositions == std::vector<int>({ 17 }));
REQUIRE(opcode.backParameter());
REQUIRE(*opcode.backParameter() == 123);
}
SECTION("Parameterized opcode within the opcode")
{
sfz::Opcode opcode { "sample1_underscore", "dummy" };
REQUIRE(opcode.opcode == "sample1_underscore");
REQUIRE(opcode.lettersOnlyHash == hash("sample_underscore"));
REQUIRE(opcode.value == "dummy");
REQUIRE(opcode.parameters == std::vector<uint8_t>({ 1 }));
REQUIRE(!opcode.backParameter());
REQUIRE(opcode.firstParameter());
REQUIRE(*opcode.firstParameter() == 1);
REQUIRE(!opcode.middleParameter());
}
SECTION("Parameterized opcode within the opcode")
{
sfz::Opcode opcode { "sample123_underscore", "dummy" };
REQUIRE(opcode.opcode == "sample123_underscore");
REQUIRE(opcode.lettersOnlyHash == hash("sample_underscore"));
REQUIRE(opcode.value == "dummy");
REQUIRE(opcode.parameters.size() == 1);
REQUIRE(opcode.parameters[0] == 123);
}
SECTION("Parameterized opcode within the opcode twice")
{
sfz::Opcode opcode { "sample123_double44_underscore", "dummy" };
REQUIRE(opcode.opcode == "sample123_double44_underscore");
REQUIRE(opcode.lettersOnlyHash == hash("sample_double_underscore"));
REQUIRE(opcode.value == "dummy");
REQUIRE(opcode.parameters.size() == 2);
REQUIRE(opcode.parameters[0] == 123);
REQUIRE(opcode.parameters[1] == 44);
REQUIRE(opcode.parameters == std::vector<uint8_t>({ 123, 44 }));
REQUIRE(opcode.parameterPositions == std::vector<int>({ 6, 13 }));
REQUIRE(!opcode.backParameter());
REQUIRE(opcode.firstParameter());
REQUIRE(*opcode.firstParameter() == 123);
REQUIRE(opcode.middleParameter());
REQUIRE(*opcode.middleParameter() == 44);
}
SECTION("Parameterized opcode within the opcode twice, with a back parameter")
{
sfz::Opcode opcode { "sample123_double44_underscore23", "dummy" };
REQUIRE(opcode.opcode == "sample123_double44_underscore23");
REQUIRE(opcode.lettersOnlyHash == hash("sample_double_underscore"));
REQUIRE(opcode.value == "dummy");
REQUIRE(opcode.parameters.size() == 3);
REQUIRE(opcode.parameters == std::vector<uint8_t>({ 123, 44, 23 }));
REQUIRE(opcode.parameterPositions == std::vector<int>({ 6, 13, 24 }));
REQUIRE(opcode.backParameter());
REQUIRE(*opcode.backParameter() == 23);
REQUIRE(opcode.firstParameter());
REQUIRE(*opcode.firstParameter() == 123);
REQUIRE(opcode.middleParameter());
REQUIRE(*opcode.middleParameter() == 44);
}
}