Revamp audio plugins module

src/app/CMakeLists.txt

@@ -215,6 +215,9 @@ set(APP_SRC
     appfactory.cpp
     appfactory.h
 
+    internal/audiopluginsappconfigmodule.cpp
+    internal/audiopluginsappconfigmodule.h
+
     internal/guiapp.cpp
     internal/guiapp.h
 )

src/app/appfactory.cpp

@@ -24,6 +24,7 @@
 
 #ifdef MUSE_MODULE_AUDIOPLUGINS
 #include "framework/audioplugins/audiopluginsmodule.h"
+#include "internal/audiopluginsappconfigmodule.h"
 #endif
 
 #ifdef MUSE_MODULE_CLOUD
@@ -314,6 +315,7 @@ std::shared_ptr<muse::IApplication> AppFactory::newGuiApp(const std::shared_ptr<
     app->addModule(new muse::audio::AudioModule());
 #ifdef MUSE_MODULE_AUDIOPLUGINS
     app->addModule(new muse::audioplugins::AudioPluginsModule());
+    app->addModule(new mu::app::AudioPluginsAppConfigModule());
 #endif
     app->addModule(new muse::automation::AutomationModule());
     app->addModule(new muse::draw::DrawModule());
@@ -455,6 +457,7 @@ static void addConsoleModules(std::shared_ptr<MuseScoreConsoleApp> app)
     app->addModule(new muse::audio::AudioModule());
 #ifdef MUSE_MODULE_AUDIOPLUGINS
     app->addModule(new muse::audioplugins::AudioPluginsModule());
+    app->addModule(new mu::app::AudioPluginsAppConfigModule());
 #endif
     app->addModule(new muse::draw::DrawModule());
     app->addModule(new muse::midi::MidiModule());
@@ -547,6 +550,7 @@ static void addAudioPluginRegistrationModules(std::shared_ptr<MuseScoreConsoleAp
 
 #ifdef MUSE_MODULE_AUDIOPLUGINS
     app->addModule(new muse::audioplugins::AudioPluginsModule());
+    app->addModule(new mu::app::AudioPluginsAppConfigModule());
 #endif
 
 #ifdef MUSE_MODULE_VST

src/app/internal/audiopluginsappconfigmodule.cpp

@@ -0,0 +1,95 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 MuseScore Limited and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include "audiopluginsappconfigmodule.h"
+
+#include "modularity/ioc.h"
+
+#include "global/serialization/json.h"
+
+#include "audio/common/audiotypes.h"
+#include "mpe/playbacksetupdata.h"
+
+#include "audioplugins/iaudiopluginsconfiguration.h"
+#include "audioplugins/iknownaudiopluginsmigrationregister.h"
+
+using namespace mu::app;
+using namespace muse::audioplugins;
+
+static const std::string mname("audiopluginsappconfig");
+
+std::string AudioPluginsAppConfigModule::moduleName() const
+{
+    return mname;
+}
+
+void AudioPluginsAppConfigModule::resolveImports()
+{
+    auto configuration = muse::modularity::globalIoc()->resolve<IAudioPluginsConfiguration>(moduleName());
+    if (configuration) {
+        // MuseScore's audio engine routes synthesis via the playbackSetupData
+        // attribute. It is runtime-only — the engine re-injects the generic
+        // default at every load, so the cache file should not persist it.
+        AudioResourceAttributes runtimeDefaults;
+        runtimeDefaults.emplace(muse::audio::PLAYBACK_SETUP_DATA_ATTRIBUTE,
+                                muse::mpe::GENERIC_SETUP_DATA_STRING);
+        configuration->setRuntimeAttributeDefaults(runtimeDefaults);
+    }
+
+    // MuseScore-specific audioplugins migrations only — framework-owned
+    // steps (v0->v1 structural, v1->v2 enabled->state) are pre-registered
+    // by the framework's AudioPluginsModule.
+    auto migrations = muse::modularity::globalIoc()->resolve<IKnownAudioPluginsMigrationRegister>(moduleName());
+    if (migrations) {
+        // v2 → v3: hasNativeEditorSupport moved from a top-level meta field
+        // into meta.attributes (string "true"/"false"). MuseScore-specific:
+        // audacity has no native-editor concept.
+        migrations->registerMigration(2, [](const muse::JsonArray& plugins) {
+            const std::string nativeEditorKey = muse::audio::HAS_NATIVE_EDITOR_SUPPORT_ATTRIBUTE.toStdString();
+            muse::JsonArray out;
+            for (size_t i = 0; i < plugins.size(); ++i) {
+                muse::JsonObject obj = plugins.at(i).toObject();
+                muse::JsonObject meta = obj.value("meta").toObject();
+                if (meta.contains(nativeEditorKey)) {
+                    muse::JsonObject attrs;
+                    if (meta.contains("attributes")) {
+                        attrs = meta.value("attributes").toObject();
+                    }
+                    const bool b = meta.value(nativeEditorKey).toBool();
+                    attrs.set(nativeEditorKey, b ? std::string("true") : std::string("false"));
+                    meta.set("attributes", attrs);
+
+                    // JsonObject has no remove(); rebuild without the legacy key.
+                    muse::JsonObject metaWithoutLegacy;
+                    for (const std::string& k : meta.keys()) {
+                        if (k == nativeEditorKey) {
+                            continue;
+                        }
+                        metaWithoutLegacy.set(k, meta.value(k));
+                    }
+                    obj.set("meta", metaWithoutLegacy);
+                }
+                out << obj;
+            }
+            return out;
+        });
+    }
+}

src/app/internal/audiopluginsappconfigmodule.h

@@ -0,0 +1,33 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 MuseScore Limited and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "modularity/imodulesetup.h"
+
+namespace mu::app {
+class AudioPluginsAppConfigModule : public muse::modularity::IModuleSetup
+{
+public:
+    std::string moduleName() const override;
+    void resolveImports() override;
+};
+}

src/converter/internal/compat/notationmeta.cpp

@@ -378,9 +378,9 @@ QJsonArray NotationMeta::tracksJsonArray(notation::INotationPtr notation)
         QJsonObject jsonTrack;
         jsonTrack.insert("instrumentId", trackId.instrumentId.toQString());
         jsonTrack.insert("partId", trackId.partId.toQString());
-        jsonTrack.insert("type", audioResourceTypeToString(inputParams.resourceMeta.type).toQString());
+        jsonTrack.insert("type", audio::audioResourceTypeToString(inputParams.resourceMeta.type).toQString());
 
-        audio::AudioSourceType sourceType = sourceTypeFromResourceType(inputParams.resourceMeta.type);
+        audio::AudioSourceType sourceType = audio::sourceTypeFromResourceType(inputParams.resourceMeta.type);
         if (sourceType != audio::AudioSourceType::Fluid) {
             if (sourceType == audio::AudioSourceType::MuseSampler) {
                 jsonTrack.insert("vendor", QString::fromStdString(inputParams.resourceMeta.attributeVal(

src/notationscene/qml/MuseScore/NotationScene/percussionpanel/percussionpanelmodel.cpp

@@ -554,7 +554,8 @@ void PercussionPanelModel::resetLayout()
     }
 
     const muse::audio::AudioResourceMeta& resourceMeta = audioSettings()->trackInputParams(currentTrackId()).resourceMeta;
-    const bool isMuseSamplerDrumset = resourceMeta.type == muse::audio::AudioResourceType::MuseSamplerSoundPack;
+    const bool isMuseSamplerDrumset = muse::audio::isResourceType(resourceMeta,
+                                                                  muse::audio::AudioResourceType::MuseSamplerSoundPack);
 
     Drumset defaultDrumset = isMuseSamplerDrumset ? museSamplerDefaultDrumset() : standardDefaultDrumset();
 
@@ -594,7 +595,7 @@ Drumset PercussionPanelModel::museSamplerDefaultDrumset() const
 
     const muse::audio::AudioResourceMeta& resourceMeta = audioSettings()->trackInputParams(currentTrackId()).resourceMeta;
 
-    const int instrumentId = resourceMeta.attributeVal(u"museUID").toInt();
+    const int instrumentId = muse::audioplugins::intAttribute(resourceMeta, u"museUID");
 
     const muse::ByteArray drumMapping = museSampler()->drumMapping(instrumentId);
     IF_ASSERT_FAILED(!drumMapping.empty()) {

src/playback/internal/drumsetloader.cpp

@@ -41,7 +41,7 @@ void DrumsetLoader::loadDrumset(INotationPtr notation, const InstrumentTrackId&
     }
 
     // restore the default drumset when changing from MuseSounds to MS Basic / VST
-    if (resourceMeta.type != AudioResourceType::MuseSamplerSoundPack) {
+    if (!isResourceType(resourceMeta, AudioResourceType::MuseSamplerSoundPack)) {
         const InstrumentTemplate& templ = instrumentsRepository()->instrumentTemplate(trackId.instrumentId);
         if (!templ.useDrumset) {
             return;
@@ -56,7 +56,7 @@ void DrumsetLoader::loadDrumset(INotationPtr notation, const InstrumentTrackId&
         return;
     }
 
-    int instrumentId = resourceMeta.attributeVal(u"museUID").toInt();
+    int instrumentId = muse::audioplugins::intAttribute(resourceMeta, u"museUID");
 
     auto it = m_drumsetCache.find(instrumentId);
     if (it != m_drumsetCache.end()) {

src/playback/internal/playbackcontroller.cpp

@@ -492,7 +492,8 @@ bool PlaybackController::shouldLoadDrumset(const engraving::InstrumentTrackId& i
         return false;
     }
 
-    return oldMeta.type == AudioResourceType::MuseSamplerSoundPack || newMeta.type == AudioResourceType::MuseSamplerSoundPack;
+    return isResourceType(oldMeta, AudioResourceType::MuseSamplerSoundPack)
+           || isResourceType(newMeta, AudioResourceType::MuseSamplerSoundPack);
 }
 
 void PlaybackController::addSoundFlagsIfNeed(const std::vector<EngravingItem*>& selection)

src/playback/internal/soundprofilesrepository.cpp

@@ -67,11 +67,11 @@ void SoundProfilesRepository::refresh()
                 continue;
             }
 
-            if (resource.type == AudioResourceType::FluidSoundfont) {
+            if (isResourceType(resource, AudioResourceType::FluidSoundfont)) {
                 basicProfile.data.emplace(mpe::PlaybackSetupData::fromString(setup->second), resource);
             }
 
-            if (resource.type == AudioResourceType::MuseSamplerSoundPack) {
+            if (isResourceType(resource, AudioResourceType::MuseSamplerSoundPack)) {
                 museProfile.data.emplace(mpe::PlaybackSetupData::fromString(setup->second), resource);
             }
         }

src/playback/qml/MuseScore/Playback/inputresourceitem.cpp

@@ -87,9 +87,11 @@ void InputResourceItem::requestAvailableResources()
         if (!isBlank()) {
             QString currentResourceId = QString::fromStdString(m_currentInputParams.resourceMeta.id);
 
-            result << buildMenuItem(makeMenuResourceItemId(m_currentInputParams.resourceMeta.type, currentResourceId),
-                                    title(),
-                                    /*checked*/ true, /*subItems*/ QVariantList(), /*includeInFilteredLists*/ false);
+            result <<
+                buildMenuItem(makeMenuResourceItemId(muse::audio::resourceTypeFromString(m_currentInputParams.resourceMeta.type),
+                                                     currentResourceId),
+                              title(),
+                              /*checked*/ true, /*subItems*/ QVariantList(), /*includeInFilteredLists*/ false);
 
             result << buildSeparator();
         }
@@ -208,7 +210,7 @@ bool InputResourceItem::isActive() const
 
 bool InputResourceItem::hasNativeEditorSupport() const
 {
-    return m_currentInputParams.resourceMeta.hasNativeEditorSupport;
+    return muse::audio::hasNativeEditorSupport(m_currentInputParams.resourceMeta);
 }
 
 QVariantMap InputResourceItem::buildMuseMenuItem(const ResourceByVendorMap& resourcesByVendor) const
@@ -300,7 +302,8 @@ QVariantMap InputResourceItem::buildMuseMenuItem(const ResourceByVendorMap& reso
 
     return buildMenuItem(MUSE_MENU_ITEM_ID,
                          MUSE_MENU_ITEM_ID,
-                         m_currentInputParams.resourceMeta.type == AudioResourceType::MuseSamplerSoundPack,
+                         muse::audio::isResourceType(m_currentInputParams.resourceMeta,
+                                                     muse::audio::AudioResourceType::MuseSamplerSoundPack),
                          subItemsByType,
                          /*includeInFilteredLists*/ false);
 }
@@ -314,7 +317,7 @@ QVariantMap InputResourceItem::buildVstMenuItem(const ResourceByVendorMap& resou
 
         for (const AudioResourceMeta& resourceMeta : pair.second) {
             QString resourceId = QString::fromStdString(resourceMeta.id);
-            subItemsByVendor << buildMenuItem(makeMenuResourceItemId(resourceMeta.type, resourceId),
+            subItemsByVendor << buildMenuItem(makeMenuResourceItemId(muse::audio::resourceTypeFromString(resourceMeta.type), resourceId),
                                               resourceId,
                                               m_currentInputParams.resourceMeta.id == resourceMeta.id);
         }
@@ -330,7 +333,8 @@ QVariantMap InputResourceItem::buildVstMenuItem(const ResourceByVendorMap& resou
 
     return buildMenuItem(VST_MENU_ITEM_ID,
                          VST_MENU_ITEM_ID,
-                         m_currentInputParams.resourceMeta.type == AudioResourceType::VstPlugin,
+                         muse::audio::isResourceType(m_currentInputParams.resourceMeta,
+                                                     muse::audio::AudioResourceType::VstPlugin),
                          subItemsByType,
                          /*includeInFilteredLists*/ false);
 }
@@ -391,7 +395,8 @@ QVariantMap InputResourceItem::buildSoundFontsMenuItem(const ResourceByVendorMap
 
     return buildMenuItem(SOUNDFONTS_MENU_ITEM_ID,
                          muse::qtrc("playback", "SoundFonts"),
-                         m_currentInputParams.resourceMeta.type == AudioResourceType::FluidSoundfont,
+                         muse::audio::isResourceType(m_currentInputParams.resourceMeta,
+                                                     muse::audio::AudioResourceType::FluidSoundfont),
                          soundFontItems,
                          /*includeInFilteredLists*/ false);
 }
@@ -436,7 +441,8 @@ QVariantMap InputResourceItem::buildMsBasicMenuItem(const AudioResourceMetaList&
                 presetName = muse::qtrc("playback", "Bank %1, preset %2").arg(item.preset.bank).arg(item.preset.program);
             }
 
-            return buildMenuItem(makeMenuResourceItemId(resourceMeta.type, QString::fromStdString(resourceMeta.id)),
+            return buildMenuItem(makeMenuResourceItemId(muse::audio::resourceTypeFromString(resourceMeta.type),
+                                                        QString::fromStdString(resourceMeta.id)),
                                  presetName,
                                  isCurrent);
         }
@@ -487,7 +493,8 @@ QVariantMap InputResourceItem::buildMsBasicMenuItem(const AudioResourceMetaList&
 
     // Prepend the "Choose automatically" item
     categoryItems.prepend(buildSeparator());
-    categoryItems.prepend(buildMenuItem(makeMenuResourceItemId(chooseAutomaticMeta.type, QString::fromStdString(chooseAutomaticMeta.id)),
+    categoryItems.prepend(buildMenuItem(makeMenuResourceItemId(muse::audio::resourceTypeFromString(chooseAutomaticMeta.type),
+                                                               QString::fromStdString(chooseAutomaticMeta.id)),
                                         muse::qtrc("playback", "Choose automatically"),
                                         isCurrentSoundFont && !currentPreset.has_value(),
                                         /*subItems*/ QVariantList(),
@@ -552,7 +559,8 @@ QVariantMap InputResourceItem::buildSoundFontMenuItem(const muse::String& soundF
 
     // Prepend the "Choose automatically" item
     bankItems.prepend(buildSeparator());
-    bankItems.prepend(buildMenuItem(makeMenuResourceItemId(chooseAutomaticMeta.type, QString::fromStdString(chooseAutomaticMeta.id)),
+    bankItems.prepend(buildMenuItem(makeMenuResourceItemId(muse::audio::resourceTypeFromString(chooseAutomaticMeta.type),
+                                                           QString::fromStdString(chooseAutomaticMeta.id)),
                                     muse::qtrc("playback", "Choose automatically"),
                                     isCurrentSoundFont && !currentPreset.has_value(),
                                     /*subItems*/ QVariantList(),
@@ -571,7 +579,7 @@ void InputResourceItem::updateAvailableResources(const AudioResourceMetaList& av
     m_availableResourceMap.clear();
 
     for (const AudioResourceMeta& meta : availableResources) {
-        ResourceByVendorMap& resourcesByVendor = m_availableResourceMap[meta.type];
+        ResourceByVendorMap& resourcesByVendor = m_availableResourceMap[muse::audio::resourceTypeFromString(meta.type)];
         AudioResourceMetaList& resourcesMetaList = resourcesByVendor[meta.vendor];
         resourcesMetaList.push_back(meta);
     }

src/playback/qml/MuseScore/Playback/outputresourceitem.cpp

@@ -3,6 +3,7 @@
 #include <QList>
 
 #include "audio/common/audioutils.h"
+#include "vst/vstpluginattrs.h"
 
 #include "log.h"
 #include "translation.h"
@@ -183,7 +184,7 @@ void OutputResourceItem::updateCurrentFxParams(const AudioResourceMeta& newMeta)
     requestToCloseNativeEditorView();
 
     audio::AudioFxParams newParams = m_currentFxParams;
-    newParams.categories = audio::audioFxCategoriesFromString(newMeta.attributeVal(audio::CATEGORIES_ATTRIBUTE));
+    newParams.categories = audio::audioFxCategoriesFromString(newMeta.attributeVal(vst::CATEGORIES_ATTRIBUTE));
     newParams.resourceMeta = newMeta;
     newParams.configuration.clear();
     newParams.active = newMeta.isValid();
@@ -213,5 +214,5 @@ bool OutputResourceItem::isBlank() const
 
 bool OutputResourceItem::hasNativeEditorSupport() const
 {
-    return m_currentFxParams.resourceMeta.hasNativeEditorSupport;
+    return muse::audio::hasNativeEditorSupport(m_currentFxParams.resourceMeta);
 }