Merge pull request musescore#18152 from RomanPudashkin/audio_plugin_scanner_various_improvements

audio_plugin_scanner_various_improvements

Author: RomanPudashkin

src/diagnostics/internal/diagnosticfileswriter.cpp

@@ -34,9 +34,8 @@ mu::Ret DiagnosticFilesWriter::writeDiagnosticFiles(const path_t& destinationPat
 {
     TRACEFUNC;
 
-    static const std::vector<std::string> DIRS_TO_WRITE {
+    const std::vector<std::string> DIRS_TO_WRITE {
         "logs",
-        "audio_plugins",
         "plugins",
         "workspaces",
     };
@@ -61,6 +60,7 @@ mu::Ret DiagnosticFilesWriter::writeDiagnosticFiles(const path_t& destinationPat
     const std::vector<std::string> FILES_TO_WRITE {
         "shortcuts.xml",
         "midi_mappings.xml",
+        "known_audio_plugins.json",
     };
 
     for (const std::string& fileName : FILES_TO_WRITE) {

src/framework/audio/audiomodule.cpp

@@ -191,9 +191,14 @@ void AudioModule::onInit(const framework::IApplication::RunMode& mode)
 
     // Init configuration
     m_configuration->init();
-    m_soundFontRepository->init();
     m_registerAudioPluginsScenario->init();
 
+    if (mode == framework::IApplication::RunMode::AudioPluginRegistration) {
+        return;
+    }
+
+    m_soundFontRepository->init();
+
     m_audioBuffer->init(m_configuration->audioChannelsCount(),
                         m_configuration->renderStep());
 
@@ -209,7 +214,7 @@ void AudioModule::onInit(const framework::IApplication::RunMode& mode)
         for (const io::path_t& p : paths) {
             pr->reg("soundfonts", p);
         }
-        pr->reg("audio_plugins", m_configuration->knownAudioPluginsDir());
+        pr->reg("known_audio_plugins", m_configuration->knownAudioPluginsFilePath());
     }
 }
 

src/framework/audio/audiotypes.h

@@ -186,15 +186,15 @@ struct AudioPluginInfo {
     int errorCode = 0;
 };
 
-inline AudioPluginType audioPluginTypeFromCategoriesString(const std::string& categoriesStr)
+inline AudioPluginType audioPluginTypeFromCategoriesString(const String& categoriesStr)
 {
-    static const std::map<std::string, AudioPluginType> STRING_TO_PLUGIN_TYPE_MAP = {
-        { "Fx", AudioPluginType::Fx },
-        { "Instrument", AudioPluginType::Instrument },
+    static const std::map<String, AudioPluginType> STRING_TO_PLUGIN_TYPE_MAP = {
+        { u"Fx", AudioPluginType::Fx },
+        { u"Instrument", AudioPluginType::Instrument },
     };
 
     for (auto it = STRING_TO_PLUGIN_TYPE_MAP.cbegin(); it != STRING_TO_PLUGIN_TYPE_MAP.cend(); ++it) {
-        if (categoriesStr.find(it->first) != std::string::npos) {
+        if (categoriesStr.contains(it->first)) {
             return it->second;
         }
     }

src/framework/audio/iaudioconfiguration.h

@@ -70,7 +70,7 @@ class IAudioConfiguration : MODULE_EXPORT_INTERFACE
     virtual async::Notification synthesizerStateChanged() const = 0;
     virtual async::Notification synthesizerStateGroupChanged(const std::string& groupName) const = 0;
 
-    virtual io::path_t knownAudioPluginsDir() const = 0;
+    virtual io::path_t knownAudioPluginsFilePath() const = 0;
 };
 }
 

src/framework/audio/internal/audioconfiguration.cpp

@@ -260,9 +260,9 @@ async::Notification AudioConfiguration::synthesizerStateGroupChanged(const std::
     return m_synthesizerStateGroupChanged[gname];
 }
 
-io::path_t AudioConfiguration::knownAudioPluginsDir() const
+io::path_t AudioConfiguration::knownAudioPluginsFilePath() const
 {
-    return globalConfiguration()->userAppDataPath() + "/audio_plugins";
+    return globalConfiguration()->userAppDataPath() + "/known_audio_plugins.json";
 }
 
 io::path_t AudioConfiguration::stateFilePath() const

src/framework/audio/internal/audioconfiguration.h

@@ -70,7 +70,7 @@ class AudioConfiguration : public IAudioConfiguration
     async::Notification synthesizerStateChanged() const override;
     async::Notification synthesizerStateGroupChanged(const std::string& groupName) const override;
 
-    io::path_t knownAudioPluginsDir() const override;
+    io::path_t knownAudioPluginsFilePath() const override;
 
 private:
     async::Channel<io::paths_t> m_soundFontDirsChanged;

src/framework/audio/internal/plugins/knownaudiopluginsregister.cpp

@@ -38,7 +38,7 @@ static JsonObject attributesToJson(const AudioResourceAttributes& attributes)
     JsonObject result;
 
     for (auto it = attributes.cbegin(); it != attributes.cend(); ++it) {
-        if (it->second == audio::PLAYBACK_SETUP_DATA_ATTRIBUTE) {
+        if (it->first == audio::PLAYBACK_SETUP_DATA_ATTRIBUTE) {
             continue;
         }
 
@@ -54,10 +54,17 @@ static JsonObject metaToJson(const AudioResourceMeta& meta)
 
     result.set("id", meta.id);
     result.set("type", mu::value(RESOURCE_TYPE_TO_STRING_MAP, meta.type, "Undefined"));
-    result.set("vendor", meta.vendor);
-    result.set("attributes", attributesToJson(meta.attributes));
     result.set("hasNativeEditorSupport", meta.hasNativeEditorSupport);
 
+    if (!meta.vendor.empty()) {
+        result.set("vendor", meta.vendor);
+    }
+
+    JsonObject attributesJson = attributesToJson(meta.attributes);
+    if (!attributesJson.empty()) {
+        result.set("attributes", attributesJson);
+    }
+
     return result;
 }
 
@@ -79,9 +86,13 @@ static AudioResourceMeta metaFromJson(const JsonObject& object)
     result.id = object.value("id").toStdString();
     result.type = mu::key(RESOURCE_TYPE_TO_STRING_MAP, object.value("type").toStdString());
     result.vendor = object.value("vendor").toStdString();
-    result.attributes = attributesFromJson(object.value("attributes").toObject());
     result.hasNativeEditorSupport = object.value("hasNativeEditorSupport").toBool();
 
+    JsonValue attributes = object.value("attributes");
+    if (attributes.isObject()) {
+        result.attributes = attributesFromJson(attributes.toObject());
+    }
+
     return result;
 }
 }
@@ -90,50 +101,45 @@ mu::Ret KnownAudioPluginsRegister::load()
 {
     TRACEFUNC;
 
-    io::path_t knownAudioPluginsDir = configuration()->knownAudioPluginsDir();
+    m_loaded = false;
+    m_pluginInfoMap.clear();
+    m_pluginPaths.clear();
 
-    if (!fileSystem()->exists(knownAudioPluginsDir)) {
-        fileSystem()->makePath(knownAudioPluginsDir);
+    io::path_t knownAudioPluginsPath = configuration()->knownAudioPluginsFilePath();
+    if (!fileSystem()->exists(knownAudioPluginsPath)) {
+        m_loaded = true;
+        return make_ok();
     }
 
-    RetVal<io::paths_t> paths = fileSystem()->scanFiles(knownAudioPluginsDir,
-                                                        { "*.json" },
-                                                        io::ScanMode::FilesInCurrentDir);
-    if (!paths.ret) {
-        return paths.ret;
+    RetVal<ByteArray> file = fileSystem()->readFile(knownAudioPluginsPath);
+    if (!file.ret) {
+        return file.ret;
     }
 
-    m_pluginInfoMap.clear();
-    m_pluginPaths.clear();
-
-    for (const io::path_t& infoPath : paths.val) {
-        RetVal<ByteArray> file = fileSystem()->readFile(infoPath);
-        if (!file.ret) {
-            LOGE() << file.ret.toString();
-            continue;
-        }
+    std::string err;
+    JsonDocument json = JsonDocument::fromJson(file.val, &err);
+    if (!err.empty()) {
+        return Ret(static_cast<int>(Ret::Code::UnknownError), err);
+    }
 
-        std::string err;
-        JsonDocument json = JsonDocument::fromJson(file.val, &err);
-        if (!err.empty()) {
-            LOGE() << err;
-            continue;
-        }
+    JsonArray array = json.rootArray();
 
-        JsonObject object = json.rootObject();
+    for (size_t i = 0; i < array.size(); ++i) {
+        JsonObject object = array.at(i).toObject();
 
         AudioPluginInfo info;
         info.meta = metaFromJson(object.value("meta").toObject());
-        info.meta.attributes.insert({ audio::PLAYBACK_SETUP_DATA_ATTRIBUTE, mpe::GENERIC_SETUP_DATA_STRING });
-        info.type = audioPluginTypeFromCategoriesString(info.meta.attributeVal(audio::CATEGORIES_ATTRIBUTE).toStdString());
+        info.meta.attributes.emplace(audio::PLAYBACK_SETUP_DATA_ATTRIBUTE, mpe::GENERIC_SETUP_DATA_STRING);
+        info.type = audioPluginTypeFromCategoriesString(info.meta.attributeVal(audio::CATEGORIES_ATTRIBUTE));
         info.path = object.value("path").toString();
         info.enabled = object.value("enabled").toBool();
         info.errorCode = object.value("errorCode").toInt();
 
-        m_pluginInfoMap[info.meta.id] = info;
         m_pluginPaths.insert(info.path);
+        m_pluginInfoMap.emplace(info.meta.id, std::move(info));
     }
 
+    m_loaded = true;
     return make_ok();
 }
 
@@ -177,60 +183,69 @@ bool KnownAudioPluginsRegister::exists(const AudioResourceId& resourceId) const
 
 mu::Ret KnownAudioPluginsRegister::registerPlugin(const AudioPluginInfo& info)
 {
-    TRACEFUNC;
-
-    JsonObject obj;
-    obj.set("meta", metaToJson(info.meta));
-    obj.set("path", info.path.toStdString());
-    obj.set("enabled", info.enabled);
-
-    if (info.errorCode != 0) {
-        obj.set("errorCode", info.errorCode);
+    IF_ASSERT_FAILED(m_loaded) {
+        return false;
     }
 
-    io::path_t path = pluginInfoPath(info.meta.vendor, info.meta.id);
-    Ret ret = fileSystem()->writeFile(path, JsonDocument(obj).toJson());
-    if (!ret) {
-        return ret;
+    auto it = m_pluginInfoMap.find(info.meta.id);
+    if (it != m_pluginInfoMap.end()) {
+        IF_ASSERT_FAILED(it->second.path != info.path) {
+            return false;
+        }
     }
 
-    m_pluginInfoMap[info.meta.id] = info;
+    m_pluginInfoMap.emplace(info.meta.id, info);
     m_pluginPaths.insert(info.path);
 
-    return make_ok();
+    Ret ret = writePluginsInfo();
+    return ret;
 }
 
 mu::Ret KnownAudioPluginsRegister::unregisterPlugin(const AudioResourceId& resourceId)
 {
-    TRACEFUNC;
+    IF_ASSERT_FAILED(m_loaded) {
+        return false;
+    }
 
     if (!exists(resourceId)) {
         return make_ok();
     }
 
-    AudioPluginInfo info = m_pluginInfoMap[resourceId];
-    io::path_t path = pluginInfoPath(info.meta.vendor, resourceId);
-
-    Ret ret = fileSystem()->remove(path);
-    if (!ret) {
-        return ret;
+    for (const auto& pair : m_pluginInfoMap) {
+        if (pair.first == resourceId) {
+            mu::remove(m_pluginPaths, pair.second.path);
+        }
     }
 
-    mu::remove(m_pluginInfoMap, resourceId);
-    mu::remove(m_pluginPaths, info.path);
+    m_pluginInfoMap.erase(resourceId);
 
-    return make_ok();
+    Ret ret = writePluginsInfo();
+    return ret;
 }
 
-mu::io::path_t KnownAudioPluginsRegister::pluginInfoPath(const AudioResourceVendor& vendor, const AudioResourceId& resourceId) const
+mu::Ret KnownAudioPluginsRegister::writePluginsInfo()
 {
-    io::path_t fileName;
+    TRACEFUNC;
+
+    JsonArray array;
+
+    for (const auto& pair : m_pluginInfoMap) {
+        const AudioPluginInfo& info = pair.second;
 
-    if (vendor.empty()) {
-        fileName = io::escapeFileName(resourceId);
-    } else {
-        fileName = io::escapeFileName(vendor + "_" + resourceId);
+        JsonObject obj;
+        obj.set("meta", metaToJson(info.meta));
+        obj.set("path", info.path.toStdString());
+        obj.set("enabled", info.enabled);
+
+        if (info.errorCode != 0) {
+            obj.set("errorCode", info.errorCode);
+        }
+
+        array << obj;
     }
 
-    return configuration()->knownAudioPluginsDir() + "/" + fileName + ".json";
+    io::path_t knownAudioPluginsPath = configuration()->knownAudioPluginsFilePath();
+    Ret ret = fileSystem()->writeFile(knownAudioPluginsPath, JsonDocument(array).toJson());
+
+    return ret;
 }

src/framework/audio/internal/plugins/knownaudiopluginsregister.h

@@ -48,9 +48,10 @@ class KnownAudioPluginsRegister : public IKnownAudioPluginsRegister
     Ret unregisterPlugin(const AudioResourceId& resourceId) override;
 
 private:
-    mu::io::path_t pluginInfoPath(const AudioResourceVendor& vendor, const AudioResourceId& resourceId) const;
+    Ret writePluginsInfo();
 
-    std::unordered_map<AudioResourceId, AudioPluginInfo> m_pluginInfoMap;
+    bool m_loaded = false;
+    std::multimap<AudioResourceId, AudioPluginInfo> m_pluginInfoMap;
     std::set<io::path_t> m_pluginPaths;
 };
 }

src/framework/audio/internal/plugins/registeraudiopluginsscenario.cpp

@@ -129,7 +129,7 @@ mu::Ret RegisterAudioPluginsScenario::registerPlugin(const io::path_t& pluginPat
 
     for (const AudioResourceMeta& meta : metaList.val) {
         AudioPluginInfo info;
-        info.type = audioPluginTypeFromCategoriesString(meta.attributeVal(audio::CATEGORIES_ATTRIBUTE).toStdString());
+        info.type = audioPluginTypeFromCategoriesString(meta.attributeVal(audio::CATEGORIES_ATTRIBUTE));
         info.meta = meta;
         info.path = pluginPath;
         info.enabled = true;
@@ -152,7 +152,13 @@ mu::Ret RegisterAudioPluginsScenario::registerFailedPlugin(const io::path_t& plu
     }
 
     AudioPluginInfo info;
-    info.meta.id = io::filename(pluginPath).toStdString();
+    info.meta.id = io::completeBasename(pluginPath).toStdString();
+
+    std::string ext = io::suffix(pluginPath);
+    if (ext.find("vst") != std::string::npos) {
+        info.meta.type = AudioResourceType::VstPlugin;
+    }
+
     info.path = pluginPath;
     info.enabled = false;
     info.errorCode = failCode;