Revamp audio plugins module

framework/audio/common/audiotypes.h

@@ -37,6 +37,8 @@
 
 #include "mpe/events.h"
 
+#include "audioplugins/audiopluginstypes.h"
+
 #include "log.h"
 
 namespace muse::audio {
@@ -167,86 +169,91 @@ struct AudioEngineConfig {
 };
 
 using AudioSourceName = std::string;
-using AudioResourceId = std::string;
-using AudioResourceIdList = std::vector<AudioResourceId>;
-using AudioResourceVendor = std::string;
-using AudioResourceAttributes = std::map<String, String>;
 using AudioUnitConfig = std::map<std::string, std::string>;
 
-static const String PLAYBACK_SETUP_DATA_ATTRIBUTE(u"playbackSetupData");
-static const String CATEGORIES_ATTRIBUTE(u"categories");
-
+using AudioResourceId = muse::audioplugins::AudioResourceId;
+using AudioResourceIdList = muse::audioplugins::AudioResourceIdList;
+using AudioResourceVendor = muse::audioplugins::AudioResourceVendor;
+using AudioResourceAttributes = muse::audioplugins::AudioResourceAttributes;
+using AudioResourceMeta = muse::audioplugins::AudioResourceMeta;
+using AudioResourceMetaList = muse::audioplugins::AudioResourceMetaList;
+using AudioResourceMetaSet = muse::audioplugins::AudioResourceMetaSet;
+
+// Wire-format identifiers for the formats the muse audio engine dispatches
+// directly. The strings here are the canonical names persisted in the JSON
+// plugin cache. VST and MuseSampler also own their own per-module copies of
+// the matching string in their respective public headers; a round-trip test
+// in muse_audio_tests asserts they stay in sync.
+//
+// constexpr std::string_view (not inline std::string) so that the values are
+// available at compile time and don't participate in static initialization
+// order — the RESOURCE_TYPE_NAMES map below depends on them.
+inline constexpr std::string_view FLUID_SOUNDFONT_TYPE_NAME = "FluidSoundfont";
+inline constexpr std::string_view NATIVE_EFFECT_TYPE_NAME = "NativeEffect";
+
+// audio::AudioResourceType is an audio-engine-internal enum used to dispatch
+// synth/fx routing. It is intentionally kept separate from the framework's
+// opaque audioplugins::AudioResourceType (a std::string identifier persisted
+// by the audioplugins module). Map between them at the boundary via
+// resourceTypeFromString() / resourceTypeName(). The enum lists only the
+// formats the audio engine actually routes; apps with broader plugin support
+// (e.g. Audacity's LV2/AU/Nyquist) define their own enum and bridge.
 enum class AudioResourceType {
     Undefined = -1,
     FluidSoundfont,
     VstPlugin,
     NativeEffect,
     MuseSamplerSoundPack,
-    Lv2Plugin,
-    AudioUnit,
-    NyquistPlugin,
 };
 
-static const std::map<AudioResourceType, QString> RESOURCE_TYPE_MAP = {
-    { AudioResourceType::Undefined, "undefined" },
-    { AudioResourceType::MuseSamplerSoundPack, "muse_sampler_sound_pack" },
-    { AudioResourceType::FluidSoundfont, "fluid_soundfont" },
-    { AudioResourceType::VstPlugin, "vst_plugin" },
-    { AudioResourceType::NativeEffect, "muse_plugin" },
-    { AudioResourceType::Lv2Plugin, "lv2_plugin" },
-    { AudioResourceType::AudioUnit, "audio_unit" },
-    { AudioResourceType::NyquistPlugin, "nyquist_plugin" },
+static const std::map<AudioResourceType, std::string> RESOURCE_TYPE_NAMES = {
+    { AudioResourceType::FluidSoundfont,        std::string(FLUID_SOUNDFONT_TYPE_NAME) },
+    { AudioResourceType::VstPlugin,             "VstPlugin" },
+    { AudioResourceType::NativeEffect,          std::string(NATIVE_EFFECT_TYPE_NAME) },
+    { AudioResourceType::MuseSamplerSoundPack,  "MuseSamplerSoundPack" },
 };
 
-struct AudioResourceMeta {
-    AudioResourceId id;
-    AudioResourceVendor vendor;
-    AudioResourceAttributes attributes;
-    AudioResourceType type = AudioResourceType::Undefined;
-    bool hasNativeEditorSupport = false;
+inline const std::string& resourceTypeName(AudioResourceType type)
+{
+    auto it = RESOURCE_TYPE_NAMES.find(type);
+    if (it != RESOURCE_TYPE_NAMES.end()) {
+        return it->second;
+    }
+    static const std::string empty;
+    return empty;
+}
 
-    const String& attributeVal(const String& key) const
-    {
-        auto search = attributes.find(key);
-        if (search != attributes.cend()) {
-            return search->second;
+inline AudioResourceType resourceTypeFromString(const std::string& name)
+{
+    for (const auto& kv : RESOURCE_TYPE_NAMES) {
+        if (kv.second == name) {
+            return kv.first;
         }
-
-        static String empty;
-        return empty;
     }
+    return AudioResourceType::Undefined;
+}
 
-    bool isValid() const
-    {
-        return !id.empty()
-               && !vendor.empty()
-               && type != AudioResourceType::Undefined;
-    }
+inline bool isResourceType(const AudioResourceMeta& meta, AudioResourceType type)
+{
+    return resourceTypeFromString(meta.type) == type;
+}
 
-    bool operator==(const AudioResourceMeta& other) const
-    {
-        return id == other.id
-               && vendor == other.vendor
-               && type == other.type
-               && hasNativeEditorSupport == other.hasNativeEditorSupport
-               && attributes == other.attributes;
-    }
+static const String PLAYBACK_SETUP_DATA_ATTRIBUTE(u"playbackSetupData");
+static const String HAS_NATIVE_EDITOR_SUPPORT_ATTRIBUTE(u"hasNativeEditorSupport");
 
-    bool operator!=(const AudioResourceMeta& other) const
-    {
-        return !(*this == other);
-    }
+inline bool hasNativeEditorSupport(const AudioResourceMeta& meta)
+{
+    return muse::audioplugins::boolAttribute(meta, HAS_NATIVE_EDITOR_SUPPORT_ATTRIBUTE);
+}
 
-    bool operator<(const AudioResourceMeta& other) const
-    {
-        return id < other.id
-               || vendor < other.vendor;
-    }
+static const std::map<AudioResourceType, QString> RESOURCE_TYPE_MAP = {
+    { AudioResourceType::Undefined, "undefined" },
+    { AudioResourceType::MuseSamplerSoundPack, "muse_sampler_sound_pack" },
+    { AudioResourceType::FluidSoundfont, "fluid_soundfont" },
+    { AudioResourceType::VstPlugin, "vst_plugin" },
+    { AudioResourceType::NativeEffect, "muse_plugin" },
 };
 
-using AudioResourceMetaList = std::vector<AudioResourceMeta>;
-using AudioResourceMetaSet = std::set<AudioResourceMeta>;
-
 static const AudioResourceId MUSE_REVERB_ID("Muse Reverb");
 
 enum class AudioFxType {
@@ -304,14 +311,11 @@ struct AudioFxParams {
 
     AudioFxType type() const
     {
-        switch (resourceMeta.type) {
+        switch (resourceTypeFromString(resourceMeta.type)) {
         case AudioResourceType::VstPlugin: return AudioFxType::VstFx;
         case AudioResourceType::NativeEffect: return AudioFxType::MuseFx;
-        case AudioResourceType::AudioUnit:
-        case AudioResourceType::Lv2Plugin:
         case AudioResourceType::FluidSoundfont:
         case AudioResourceType::MuseSamplerSoundPack:
-        case AudioResourceType::NyquistPlugin:
         case AudioResourceType::Undefined: break;
         }
 
@@ -383,16 +387,13 @@ enum class AudioSourceType {
     MuseSampler
 };
 
-inline AudioSourceType sourceTypeFromResourceType(AudioResourceType type)
+inline AudioSourceType sourceTypeFromResourceType(const muse::audioplugins::AudioResourceType& metaType)
 {
-    switch (type) {
+    switch (resourceTypeFromString(metaType)) {
     case AudioResourceType::FluidSoundfont: return AudioSourceType::Fluid;
     case AudioResourceType::VstPlugin: return AudioSourceType::Vsti;
     case AudioResourceType::MuseSamplerSoundPack: return AudioSourceType::MuseSampler;
-    case AudioResourceType::AudioUnit:
-    case AudioResourceType::Lv2Plugin:
     case AudioResourceType::NativeEffect:
-    case AudioResourceType::NyquistPlugin:
     case AudioResourceType::Undefined: break;
     }
 

framework/audio/common/audioutils.h

@@ -30,15 +30,16 @@ inline AudioResourceMeta makeReverbMeta()
 {
     AudioResourceMeta meta;
     meta.id = MUSE_REVERB_ID;
-    meta.type = AudioResourceType::NativeEffect;
+    meta.type = NATIVE_EFFECT_TYPE_NAME;
     meta.vendor = "Muse";
-    meta.hasNativeEditorSupport = true;
+    meta.attributes.emplace(HAS_NATIVE_EDITOR_SUPPORT_ATTRIBUTE, u"true");
 
     return meta;
 }
 
-inline String audioResourceTypeToString(const AudioResourceType& type)
+inline String audioResourceTypeToString(const muse::audioplugins::AudioResourceType& metaType)
 {
+    AudioResourceType type = resourceTypeFromString(metaType);
     auto search = RESOURCE_TYPE_MAP.find(type);
 
     if (search != RESOURCE_TYPE_MAP.end()) {
@@ -54,7 +55,7 @@ inline String audioSourceName(const AudioInputParams& params)
         return params.resourceMeta.attributeVal(u"museName");
     }
 
-    if (params.resourceMeta.type == audio::AudioResourceType::FluidSoundfont) {
+    if (isResourceType(params.resourceMeta, AudioResourceType::FluidSoundfont)) {
         const String& presetName = params.resourceMeta.attributeVal(synth::PRESET_NAME_ATTRIBUTE);
         if (!presetName.empty()) {
             return presetName;
@@ -84,7 +85,7 @@ inline String audioSourceCategoryName(const AudioInputParams& params)
         return params.resourceMeta.attributeVal(u"museCategory");
     }
 
-    if (params.resourceMeta.type == audio::AudioResourceType::FluidSoundfont) {
+    if (isResourceType(params.resourceMeta, AudioResourceType::FluidSoundfont)) {
         return params.resourceMeta.attributeVal(synth::SOUNDFONT_NAME_ATTRIBUTE);
     }
 
@@ -109,17 +110,6 @@ inline AudioFxCategories audioFxCategoriesFromString(const String& str)
 
 inline bool isOnlineAudioResource(const AudioResourceMeta& meta)
 {
-    const String& attr = meta.attributeVal(u"isOnline");
-    if (attr.empty()) {
-        return false;
-    }
-
-    bool ok = true;
-    const int val = attr.toInt(&ok);
-    if (!ok) {
-        return false;
-    }
-
-    return val == 1;
+    return muse::audioplugins::boolAttribute(meta, u"isOnline");
 }
 }

framework/audio/common/rpc/rpcpacker.h

@@ -186,12 +186,12 @@ inline void unpack_custom(muse::msgpack::UnPacker& p, muse::audio::AudioFxCatego
 
 inline void pack_custom(muse::msgpack::Packer& p, const muse::audio::AudioResourceMeta& value)
 {
-    p.process(value.id, value.type, value.vendor, value.attributes, value.hasNativeEditorSupport);
+    p.process(value.id, value.type, value.vendor, value.attributes);
 }
 
 inline void unpack_custom(muse::msgpack::UnPacker& p, muse::audio::AudioResourceMeta& value)
 {
-    p.process(value.id, value.type, value.vendor, value.attributes, value.hasNativeEditorSupport);
+    p.process(value.id, value.type, value.vendor, value.attributes);
 }
 
 inline void pack_custom(muse::msgpack::Packer& p, const muse::audio::AudioFxParams& value)

framework/audio/engine/internal/audioengineconfiguration.cpp

@@ -41,8 +41,7 @@ static const AudioResourceMeta DEFAULT_AUDIO_RESOURCE_META = {
     DEFAULT_SOUND_FONT_NAME,
     "Fluid",
     DEFAULT_AUDIO_RESOURCE_ATTRIBUTES,
-    AudioResourceType::FluidSoundfont,
-    false /*hasNativeEditor*/ };
+    "FluidSoundfont" };
 
 void AudioEngineConfiguration::setConfig(const AudioEngineConfig& conf)
 {

framework/audio/engine/internal/enginerpccontroller.cpp

@@ -225,10 +225,8 @@ void EngineRpcController::init()
                 }
             };
 
-            AudioResourceType resourceType = params.source.resourceMeta.type;
-
             // Not Fluid
-            if (resourceType != AudioResourceType::FluidSoundfont) {
+            if (!isResourceType(params.source.resourceMeta, AudioResourceType::FluidSoundfont)) {
                 addTrackAndSendResponse(msg, trackName, playbackData, params);
                 return make_response_delayed(msg);
             }

framework/audio/engine/internal/synthesizers/fluidsynth/fluidresolver.cpp

@@ -113,13 +113,12 @@ void FluidResolver::refresh()
 
             AudioResourceMeta chooseAutomaticMeta;
             chooseAutomaticMeta.id = id;
-            chooseAutomaticMeta.type = AudioResourceType::FluidSoundfont;
+            chooseAutomaticMeta.type = FLUID_SOUNDFONT_TYPE_NAME;
             chooseAutomaticMeta.vendor = FLUID_VENDOR_NAME;
             chooseAutomaticMeta.attributes = {
                 { PLAYBACK_SETUP_DATA_ATTRIBUTE, muse::mpe::GENERIC_SETUP_DATA_STRING },
                 { SOUNDFONT_NAME_ATTRIBUTE, String::fromStdString(soundFont.name) }
             };
-            chooseAutomaticMeta.hasNativeEditorSupport = false;
 
             m_resourcesCache.emplace(id, SoundFontResource { soundFont.path, std::nullopt, std::move(chooseAutomaticMeta) });
         }
@@ -129,7 +128,7 @@ void FluidResolver::refresh()
 
             AudioResourceMeta meta;
             meta.id = id;
-            meta.type = AudioResourceType::FluidSoundfont;
+            meta.type = FLUID_SOUNDFONT_TYPE_NAME;
             meta.vendor = FLUID_VENDOR_NAME;
             meta.attributes = {
                 { PLAYBACK_SETUP_DATA_ATTRIBUTE, muse::mpe::GENERIC_SETUP_DATA_STRING },
@@ -138,7 +137,6 @@ void FluidResolver::refresh()
                 { PRESET_BANK_ATTRIBUTE, String::number(preset.program.bank) },
                 { PRESET_PROGRAM_ATTRIBUTE, String::number(preset.program.program) },
             };
-            meta.hasNativeEditorSupport = false;
 
             m_resourcesCache.emplace(id, SoundFontResource { soundFont.path, preset.program, std::move(meta) });
         }

framework/audio/tests/CMakeLists.txt

@@ -23,6 +23,7 @@ set(MODULE_TEST muse_audio_tests)
 set(MODULE_TEST_SRC
     ${CMAKE_CURRENT_LIST_DIR}/rpcpacker_tests.cpp
     ${CMAKE_CURRENT_LIST_DIR}/alignbuffer_tests.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/audioresourcetypes_tests.cpp
 )
 
 include(SetupGTest)