diff --git a/src/sfizz/Defaults.cpp b/src/sfizz/Defaults.cpp
index aa768dd7..fc8be532 100644
--- a/src/sfizz/Defaults.cpp
+++ b/src/sfizz/Defaults.cpp
@@ -145,6 +145,13 @@ extern const OpcodeSpec<float> lofiBitred { 0.0f, Range<float>(0.0f, 100.0f), kI
 extern const OpcodeSpec<float> lofiDecim { 0.0f, Range<float>(0.0f, 100.0f), kIgnoreOOB };
 extern const OpcodeSpec<float> rectify { 0.0f, Range<float>(0.0f, 100.0f), kIgnoreOOB };
 extern const OpcodeSpec<unsigned> stringsNumber { maxStrings, Range<unsigned>(0, maxStrings), kEnforceLowerBound };
+extern const OpcodeSpec<SfzTrigger> trigger { SfzTrigger::attack, Range<SfzTrigger>(SfzTrigger::attack, SfzTrigger::release_key), 0};
+extern const OpcodeSpec<SfzCrossfadeCurve> crossfadeCurve { SfzCrossfadeCurve::power, Range<SfzCrossfadeCurve>(SfzCrossfadeCurve::gain, SfzCrossfadeCurve::power), 0};
+extern const OpcodeSpec<SfzOffMode> offMode { SfzOffMode::fast, Range<SfzOffMode>(SfzOffMode::fast, SfzOffMode::time), 0};
+extern const OpcodeSpec<SfzVelocityOverride> velocityOverride { SfzVelocityOverride::current, Range<SfzVelocityOverride>(SfzVelocityOverride::current, SfzVelocityOverride::previous), 0};
+extern const OpcodeSpec<SfzSelfMask> selfMask { SfzSelfMask::mask, Range<SfzSelfMask>(SfzSelfMask::mask, SfzSelfMask::dontMask), 0};
+extern const OpcodeSpec<FilterType> filter { FilterType::kFilterNone, Range<FilterType>(FilterType::kFilterNone, FilterType::kFilterPeq), 0};
+extern const OpcodeSpec<EqType> eq { EqType::kEqNone, Range<EqType>(EqType::kEqNone, EqType::kEqHighShelf), 0};
 } // namespace Default
 
 } // namespace sfz
diff --git a/src/sfizz/Defaults.h b/src/sfizz/Defaults.h
index 9025265e..2c307e0c 100644
--- a/src/sfizz/Defaults.h
+++ b/src/sfizz/Defaults.h
@@ -26,6 +26,7 @@
 #pragma once
 #include "Range.h"
 #include "Config.h"
+#include "SfzFilter.h"
 #include <limits>
 #include <cstdint>
 
@@ -198,6 +199,13 @@ namespace Default
     extern const OpcodeSpec<float> lofiDecim;
     extern const OpcodeSpec<float> rectify;
     extern const OpcodeSpec<unsigned> stringsNumber;
+    extern const OpcodeSpec<SfzTrigger> trigger;
+    extern const OpcodeSpec<SfzOffMode> offMode;
+    extern const OpcodeSpec<SfzCrossfadeCurve> crossfadeCurve;
+    extern const OpcodeSpec<SfzVelocityOverride> velocityOverride;
+    extern const OpcodeSpec<SfzSelfMask> selfMask;
+    extern const OpcodeSpec<FilterType> filter;
+    extern const OpcodeSpec<EqType> eq;
 
     // Default/max count for objects
     constexpr int numEQs { 3 };
@@ -210,15 +218,6 @@ namespace Default
     constexpr int maxDistoStages { 4 };
     constexpr unsigned maxStrings { 88 };
 
-    // Default values for enums
-    constexpr SfzTrigger trigger { SfzTrigger::attack };
-    constexpr SfzOffMode offMode { SfzOffMode::fast };
-    constexpr SfzVelocityOverride velocityOverride { SfzVelocityOverride::current };
-    constexpr SfzSelfMask selfMask { SfzSelfMask::mask };
-    constexpr SfzCrossfadeCurve crossfadeKeyCurve { SfzCrossfadeCurve::power };
-    constexpr SfzCrossfadeCurve crossfadeVelCurve { SfzCrossfadeCurve::power };
-    constexpr SfzCrossfadeCurve crossfadeCCCurve { SfzCrossfadeCurve::power };
-
     // Default values for ranges
     constexpr Range<uint8_t> crossfadeKeyInRange { 0, 0 };
     constexpr Range<uint8_t> crossfadeKeyOutRange { 127, 127 };
diff --git a/src/sfizz/Opcode.cpp b/src/sfizz/Opcode.cpp
index e7e3222a..a2609ca6 100644
--- a/src/sfizz/Opcode.cpp
+++ b/src/sfizz/Opcode.cpp
@@ -304,6 +304,117 @@ absl::optional<OscillatorEnabled> Opcode::read(OpcodeSpec<OscillatorEnabled>) co
     return *v ? OscillatorEnabled::On : OscillatorEnabled::Off;
 }
 
+template <>
+absl::optional<SfzTrigger> Opcode::read(OpcodeSpec<SfzTrigger>) const
+{
+    switch (hash(value)) {
+    case hash("attack"): return SfzTrigger::attack;
+    case hash("first"): return SfzTrigger::first;
+    case hash("legato"): return SfzTrigger::legato;
+    case hash("release"): return SfzTrigger::release;
+    case hash("release_key"): return SfzTrigger::release_key;
+    }
+
+    DBG("Unknown trigger value: " << value);
+    return absl::nullopt;
+}
+
+template <>
+absl::optional<SfzCrossfadeCurve> Opcode::read(OpcodeSpec<SfzCrossfadeCurve>) const
+{
+    switch (hash(value)) {
+    case hash("power"): return SfzCrossfadeCurve::power;
+    case hash("gain"): return SfzCrossfadeCurve::gain;
+    }
+
+    DBG("Unknown crossfade power curve: " << value);
+    return absl::nullopt;
+}
+
+template <>
+absl::optional<SfzOffMode> Opcode::read(OpcodeSpec<SfzOffMode>) const
+{
+    switch (hash(value)) {
+    case hash("fast"): return SfzOffMode::fast;
+    case hash("normal"): return SfzOffMode::normal;
+    case hash("time"): return SfzOffMode::time;
+    }
+
+    DBG("Unknown off mode: " << value);
+    return absl::nullopt;
+}
+
+template <>
+absl::optional<FilterType> Opcode::read(OpcodeSpec<FilterType>) const
+{
+    switch (hash(value)) {
+    case hash("lpf_1p"): return kFilterLpf1p;
+    case hash("hpf_1p"): return kFilterHpf1p;
+    case hash("lpf_2p"): return kFilterLpf2p;
+    case hash("hpf_2p"): return kFilterHpf2p;
+    case hash("bpf_2p"): return kFilterBpf2p;
+    case hash("brf_2p"): return kFilterBrf2p;
+    case hash("bpf_1p"): return kFilterBpf1p;
+    case hash("brf_1p"): return kFilterBrf1p;
+    case hash("apf_1p"): return kFilterApf1p;
+    case hash("lpf_2p_sv"): return kFilterLpf2pSv;
+    case hash("hpf_2p_sv"): return kFilterHpf2pSv;
+    case hash("bpf_2p_sv"): return kFilterBpf2pSv;
+    case hash("brf_2p_sv"): return kFilterBrf2pSv;
+    case hash("lpf_4p"): return kFilterLpf4p;
+    case hash("hpf_4p"): return kFilterHpf4p;
+    case hash("lpf_6p"): return kFilterLpf6p;
+    case hash("hpf_6p"): return kFilterHpf6p;
+    case hash("pink"): return kFilterPink;
+    case hash("lsh"): return kFilterLsh;
+    case hash("hsh"): return kFilterHsh;
+    case hash("bpk_2p"): //fallthrough
+    case hash("pkf_2p"): //fallthrough
+    case hash("peq"): return kFilterPeq;
+    }
+
+    DBG("Unknown filter type: " << value);
+    return kFilterNone;
+}
+
+template <>
+absl::optional<EqType> Opcode::read(OpcodeSpec<EqType>) const
+{
+    switch (hash(value)) {
+    case hash("peak"): return kEqPeak;
+    case hash("lshelf"): return kEqLowShelf;
+    case hash("hshelf"): return kEqHighShelf;
+    }
+
+    DBG("Unknown EQ type: " << value);
+    return kEqNone;
+}
+
+template <>
+absl::optional<SfzVelocityOverride> Opcode::read(OpcodeSpec<SfzVelocityOverride>) const
+{
+    switch (hash(value)) {
+    case hash("current"): return SfzVelocityOverride::current;
+    case hash("previous"): return SfzVelocityOverride::previous;
+    }
+
+    DBG("Unknown velocity override: " << value);
+    return absl::nullopt;
+}
+
+template <>
+absl::optional<SfzSelfMask> Opcode::read(OpcodeSpec<SfzSelfMask>) const
+{
+    switch (hash(value)) {
+    case hash("on"):
+    case hash("mask"): return SfzSelfMask::mask;
+    case hash("off"): return SfzSelfMask::dontMask;
+    }
+
+    DBG("Unknown velocity override: " << value);
+    return absl::nullopt;
+}
+
 template <>
 absl::optional<bool> Opcode::read(OpcodeSpec<bool>) const
 {
diff --git a/src/sfizz/Region.cpp b/src/sfizz/Region.cpp
index cc73a2d1..22e0ef54 100644
--- a/src/sfizz/Region.cpp
+++ b/src/sfizz/Region.cpp
@@ -204,19 +204,7 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
             offBy = *value;
         break;
     case hash("off_mode"): // also offmode
-        switch (hash(opcode.value)) {
-        case hash("fast"):
-            offMode = SfzOffMode::fast;
-            break;
-        case hash("normal"):
-            offMode = SfzOffMode::normal;
-            break;
-        case hash("time"):
-            offMode = SfzOffMode::time;
-            break;
-        default:
-            DBG("Unkown off mode:" << opcode.value);
-        }
+         offMode = opcode.read(Default::offMode).value_or(offMode);
         break;
     case hash("off_time"):
         offMode = SfzOffMode::time;
@@ -360,16 +348,8 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
         }
         break;
     case hash("sw_vel"):
-        switch (hash(opcode.value)) {
-        case hash("current"):
-            velocityOverride = SfzVelocityOverride::current;
-            break;
-        case hash("previous"):
-            velocityOverride = SfzVelocityOverride::previous;
-            break;
-        default:
-            DBG("Unknown velocity mode: " << opcode.value);
-        }
+        velocityOverride =
+            opcode.read(Default::velocityOverride).value_or(velocityOverride);
         break;
 
     case hash("sustain_cc"):
@@ -419,25 +399,7 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
         break;
     // Region logic: triggers
     case hash("trigger"):
-        switch (hash(opcode.value)) {
-        case hash("attack"):
-            trigger = SfzTrigger::attack;
-            break;
-        case hash("first"):
-            trigger = SfzTrigger::first;
-            break;
-        case hash("legato"):
-            trigger = SfzTrigger::legato;
-            break;
-        case hash("release"):
-            trigger = SfzTrigger::release;
-            break;
-        case hash("release_key"):
-            trigger = SfzTrigger::release_key;
-            break;
-        default:
-            DBG("Unknown trigger mode: " << opcode.value);
-        }
+        trigger = opcode.read(Default::trigger).value_or(trigger);
         break;
     case hash("start_locc&"): // also on_locc&
         if (opcode.parameters.back() >= config::numCCs)
@@ -564,28 +526,10 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
             crossfadeVelOutRange.setEnd(normalizeVelocity(*value));
         break;
     case hash("xf_keycurve"):
-        switch (hash(opcode.value)) {
-        case hash("power"):
-            crossfadeKeyCurve = SfzCrossfadeCurve::power;
-            break;
-        case hash("gain"):
-            crossfadeKeyCurve = SfzCrossfadeCurve::gain;
-            break;
-        default:
-            DBG("Unknown crossfade power curve: " << opcode.value);
-        }
+        crossfadeKeyCurve = opcode.read(Default::crossfadeCurve).value_or(crossfadeKeyCurve);
         break;
     case hash("xf_velcurve"):
-        switch (hash(opcode.value)) {
-        case hash("power"):
-            crossfadeVelCurve = SfzCrossfadeCurve::power;
-            break;
-        case hash("gain"):
-            crossfadeVelCurve = SfzCrossfadeCurve::gain;
-            break;
-        default:
-            DBG("Unknown crossfade power curve: " << opcode.value);
-        }
+        crossfadeVelCurve = opcode.read(Default::crossfadeCurve).value_or(crossfadeVelCurve);
         break;
     case hash("xfin_locc&"):
         if (opcode.parameters.back() >= config::numCCs)
@@ -612,16 +556,7 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
             crossfadeCCOutRange[opcode.parameters.back()].setEnd(normalizeCC(*value));
         break;
     case hash("xf_cccurve"):
-        switch (hash(opcode.value)) {
-        case hash("power"):
-            crossfadeCCCurve = SfzCrossfadeCurve::power;
-            break;
-        case hash("gain"):
-            crossfadeCCCurve = SfzCrossfadeCurve::gain;
-            break;
-        default:
-            DBG("Unknown crossfade power curve: " << opcode.value);
-        }
+        crossfadeCCCurve = opcode.read(Default::crossfadeCurve).value_or(crossfadeCCCurve);
         break;
     case hash("rt_decay"):
         rtDecay = opcode.read(Default::rtDecay).value_or(rtDecay);
@@ -745,14 +680,8 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
             if (!extendIfNecessary(filters, filterIndex + 1, Default::numFilters))
                 return false;
 
-            absl::optional<FilterType> ftype = Filter::typeFromName(opcode.value);
-
-            if (ftype)
-                filters[filterIndex].type = *ftype;
-            else {
-                filters[filterIndex].type = FilterType::kFilterNone;
-                DBG("Unknown filter type: " << opcode.value);
-            }
+            filters[filterIndex].type =
+                opcode.read(Default::filter).value_or(filters[filterIndex].type);
         }
         break;
 
@@ -835,15 +764,10 @@ bool sfz::Region::parseOpcode(const Opcode& rawOpcode)
             if (!extendIfNecessary(equalizers, eqIndex + 1, Default::numEQs))
                 return false;
 
-            absl::optional<EqType> ftype = FilterEq::typeFromName(opcode.value);
+            equalizers[eqIndex].type =
+                opcode.read(Default::eq).value_or(equalizers[eqIndex].type);
 
-            if (ftype)
-                equalizers[eqIndex].type = *ftype;
-            else {
-                equalizers[eqIndex].type = EqType::kEqNone;
-                DBG("Unknown EQ type: " << opcode.value);
-            }
-        }
+       }
         break;
 
     // Performance parameters: pitch
diff --git a/src/sfizz/Region.h b/src/sfizz/Region.h
index d7784767..e064e1b6 100644
--- a/src/sfizz/Region.h
+++ b/src/sfizz/Region.h
@@ -343,11 +343,11 @@ struct Region {
     // Instrument settings: voice lifecycle
     uint32_t group { Default::group.value }; // group
     absl::optional<uint32_t> offBy {}; // off_by
-    SfzOffMode offMode { Default::offMode }; // off_mode
+    SfzOffMode offMode { Default::offMode.value }; // off_mode
     float offTime { Default::offTime.value }; // off_mode
     absl::optional<uint32_t> notePolyphony {}; // note_polyphony
     uint32_t polyphony { config::maxVoices }; // polyphony
-    SfzSelfMask selfMask { Default::selfMask };
+    SfzSelfMask selfMask { Default::selfMask.value };
     bool rtDead { Default::rtDead.value };
 
     // Region logic: key mapping
@@ -364,7 +364,7 @@ struct Region {
     absl::optional<uint8_t> downKeyswitch {}; // sw_down
     absl::optional<uint8_t> previousKeyswitch {}; // sw_previous
     absl::optional<uint8_t> defaultSwitch {};
-    SfzVelocityOverride velocityOverride { Default::velocityOverride }; // sw_vel
+    SfzVelocityOverride velocityOverride { Default::velocityOverride.value }; // sw_vel
     bool checkSustain { Default::checkSustain.value }; // sustain_sw
     bool checkSostenuto { Default::checkSostenuto.value }; // sostenuto_sw
     uint16_t sustainCC { Default::sustainCC.value }; // sustain_cc
@@ -378,7 +378,7 @@ struct Region {
     uint8_t sequencePosition { Default::sequence.value }; // seq_position
 
     // Region logic: triggers
-    SfzTrigger trigger { Default::trigger }; // trigger
+    SfzTrigger trigger { Default::trigger.value }; // trigger
     CCMap<Range<float>> ccTriggers { Default::normalized.bounds }; // on_loccN on_hiccN
 
     // Performance parameters: amplifier
@@ -397,9 +397,9 @@ struct Region {
     Range<uint8_t> crossfadeKeyOutRange { Default::crossfadeKeyOutRange };
     Range<float> crossfadeVelInRange { Default::crossfadeVelInRange };
     Range<float> crossfadeVelOutRange { Default::crossfadeVelOutRange };
-    SfzCrossfadeCurve crossfadeKeyCurve { Default::crossfadeKeyCurve };
-    SfzCrossfadeCurve crossfadeVelCurve { Default::crossfadeVelCurve };
-    SfzCrossfadeCurve crossfadeCCCurve { Default::crossfadeCCCurve };
+    SfzCrossfadeCurve crossfadeKeyCurve { Default::crossfadeCurve.value };
+    SfzCrossfadeCurve crossfadeVelCurve { Default::crossfadeCurve.value };
+    SfzCrossfadeCurve crossfadeCCCurve { Default::crossfadeCurve.value };
     CCMap<Range<float>> crossfadeCCInRange { Default::crossfadeCCInRange }; // xfin_loccN xfin_hiccN
     CCMap<Range<float>> crossfadeCCOutRange { Default::crossfadeCCOutRange }; // xfout_loccN xfout_hiccN
     float rtDecay { Default::rtDecay.value }; // rt_decay
diff --git a/src/sfizz/SfzFilter.cpp b/src/sfizz/SfzFilter.cpp
index 039dddb2..a1d22239 100644
--- a/src/sfizz/SfzFilter.cpp
+++ b/src/sfizz/SfzFilter.cpp
@@ -204,39 +204,6 @@ void Filter::setType(FilterType type)
     }
 }
 
-absl::optional<FilterType> Filter::typeFromName(absl::string_view name)
-{
-    absl::optional<FilterType> ftype;
-
-    switch (hash(name)) {
-    case hash("lpf_1p"): ftype = kFilterLpf1p; break;
-    case hash("hpf_1p"): ftype = kFilterHpf1p; break;
-    case hash("lpf_2p"): ftype = kFilterLpf2p; break;
-    case hash("hpf_2p"): ftype = kFilterHpf2p; break;
-    case hash("bpf_2p"): ftype = kFilterBpf2p; break;
-    case hash("brf_2p"): ftype = kFilterBrf2p; break;
-    case hash("bpf_1p"): ftype = kFilterBpf1p; break;
-    case hash("brf_1p"): ftype = kFilterBrf1p; break;
-    case hash("apf_1p"): ftype = kFilterApf1p; break;
-    case hash("lpf_2p_sv"): ftype = kFilterLpf2pSv; break;
-    case hash("hpf_2p_sv"): ftype = kFilterHpf2pSv; break;
-    case hash("bpf_2p_sv"): ftype = kFilterBpf2pSv; break;
-    case hash("brf_2p_sv"): ftype = kFilterBrf2pSv; break;
-    case hash("lpf_4p"): ftype = kFilterLpf4p; break;
-    case hash("hpf_4p"): ftype = kFilterHpf4p; break;
-    case hash("lpf_6p"): ftype = kFilterLpf6p; break;
-    case hash("hpf_6p"): ftype = kFilterHpf6p; break;
-    case hash("pink"): ftype = kFilterPink; break;
-    case hash("lsh"): ftype = kFilterLsh; break;
-    case hash("hsh"): ftype = kFilterHsh; break;
-    case hash("bpk_2p"): //fallthrough
-    case hash("pkf_2p"): //fallthrough
-    case hash("peq"): ftype = kFilterPeq; break;
-    }
-
-    return ftype;
-}
-
 sfzFilterDsp *Filter::Impl::getDsp(unsigned channels, FilterType type)
 {
     switch (idDsp(channels, type)) {
@@ -444,19 +411,6 @@ void FilterEq::setType(EqType type)
     }
 }
 
-absl::optional<EqType> FilterEq::typeFromName(absl::string_view name)
-{
-    absl::optional<EqType> ftype;
-
-    switch (hash(name)) {
-    case hash("peak"): ftype = kEqPeak; break;
-    case hash("lshelf"): ftype = kEqLowShelf; break;
-    case hash("hshelf"): ftype = kEqHighShelf; break;
-    }
-
-    return ftype;
-}
-
 sfzFilterDsp *FilterEq::Impl::getDsp(unsigned channels, EqType type)
 {
     switch (idDsp(channels, type)) {
diff --git a/src/sfizz/SfzFilter.h b/src/sfizz/SfzFilter.h
index 62cba612..b64ffe8e 100644
--- a/src/sfizz/SfzFilter.h
+++ b/src/sfizz/SfzFilter.h
@@ -84,11 +84,6 @@ public:
      */
     void setType(FilterType type);
 
-    /**
-       Get the filter type associated with the given name.
-     */
-    static absl::optional<FilterType> typeFromName(absl::string_view name);
-
 private:
     struct Impl;
     std::unique_ptr<Impl> P;
@@ -194,11 +189,6 @@ public:
      */
     void setType(EqType type);
 
-    /**
-       Get the filter type associated with the given name.
-     */
-    static absl::optional<EqType> typeFromName(absl::string_view name);
-
 private:
     struct Impl;
     std::unique_ptr<Impl> P;
diff --git a/src/sfizz/effects/Eq.cpp b/src/sfizz/effects/Eq.cpp
index 7c9b5594..751ccc12 100644
--- a/src/sfizz/effects/Eq.cpp
+++ b/src/sfizz/effects/Eq.cpp
@@ -83,13 +83,7 @@ namespace fx {
                 break;
             case hash("eq_type"):
                 {
-                    absl::optional<EqType> ftype = sfz::FilterEq::typeFromName(opc.value);
-                    if (ftype)
-                        desc.type = *ftype;
-                    else {
-                        desc.type = EqType::kEqNone;
-                        DBG("Unknown EQ type: " << std::string(opc.value));
-                    }
+                    desc.type = opc.read(Default::eq).value_or(desc.type);
                     break;
                 }
             }
diff --git a/src/sfizz/effects/Filter.cpp b/src/sfizz/effects/Filter.cpp
index 836306f3..b3765b61 100644
--- a/src/sfizz/effects/Filter.cpp
+++ b/src/sfizz/effects/Filter.cpp
@@ -81,13 +81,7 @@ namespace fx {
                 break;
             case hash("filter_type"):
                 {
-                    absl::optional<FilterType> ftype = sfz::Filter::typeFromName(opc.value);
-                    if (ftype)
-                        desc.type = *ftype;
-                    else {
-                        desc.type = FilterType::kFilterNone;
-                        DBG("Unknown filter type: " << std::string(opc.value));
-                    }
+                    desc.type = opc.read(Default::filter).value_or(desc.type);
                     break;
                 }
             // extension