Detect plugin-name ambiguities

diff --git a/libs/ardour/ardour/plugin.h b/libs/ardour/ardour/plugin.h
index 47278b9cff4e38a0745c14bde81cc497affb06d2..ad03806977c28eaae0c87ba7809a3cec0ca680ab 100644 (file)
--- a/libs/ardour/ardour/plugin.h
+++ b/libs/ardour/ardour/plugin.h
@@ -303,7 +303,6 @@ public:
        /** Emitted for preset-load to set a control-port */
        PBD::Signal2<void, uint32_t, float> PresetPortSetValue;
 
-
        /** @return true if plugin has a custom plugin GUI */
        virtual bool has_editor () const = 0;
 
@@ -455,7 +454,12 @@ find_plugin (ARDOUR::Session&, std::string unique_id, ARDOUR::PluginType);
 class LIBARDOUR_API PluginInfo
 {
 public:
-       PluginInfo () {}
+       PluginInfo ()
+               : multichannel_name_ambiguity (false)
+               , plugintype_name_ambiguity (false)
+               , index (0)
+       {}
+
        virtual ~PluginInfo () {}
 
        std::string        name;
@@ -466,6 +470,9 @@ public:
        ChanCount          n_outputs;
        ARDOUR::PluginType type;
 
+       bool multichannel_name_ambiguity;
+       bool plugintype_name_ambiguity;
+
        std::string unique_id;
 
        virtual PluginPtr load (Session& session) = 0;
@@ -491,7 +498,7 @@ public:
 
 protected:
        friend class PluginManager;
-       uint32_t index;
+       uint32_t index; //< used for LADSPA, index in module
 };
 
 } // namespace ARDOUR

diff --git a/libs/ardour/ardour/plugin_manager.h b/libs/ardour/ardour/plugin_manager.h
index a94a9368a170ebb184d9ddb70b8951f431aed21c..34e71fa133e49cea264486ab99ff7d767217614b 100644 (file)
--- a/libs/ardour/ardour/plugin_manager.h
+++ b/libs/ardour/ardour/plugin_manager.h
@@ -193,6 +193,9 @@ private:
        bool _cancel_scan;
        bool _cancel_timeout;
 
+       void detect_name_ambiguities (ARDOUR::PluginInfoList*);
+       void detect_type_ambiguities (ARDOUR::PluginInfoList&);
+
        void ladspa_refresh ();
        void lua_refresh ();
        void lua_refresh_cb ();

diff --git a/libs/ardour/plugin_manager.cc b/libs/ardour/plugin_manager.cc
index 34190471cea93ea70c24f7c092973c30a9263b7a..f2c4b0322c90cabbdf130eec68a74c9e2ae24f30 100644 (file)
--- a/libs/ardour/plugin_manager.cc
+++ b/libs/ardour/plugin_manager.cc
@@ -264,6 +264,72 @@ PluginManager::~PluginManager()
        }
 }
 
+struct PluginInfoPtrNameSorter {
+       bool operator () (PluginInfoPtr const& a, PluginInfoPtr const& b) const {
+               return PBD::downcase (a->name) < PBD::downcase (b->name);
+       }
+};
+
+void
+PluginManager::detect_name_ambiguities (PluginInfoList* pil)
+{
+       if (!pil) {
+               return;
+       }
+       pil->sort (PluginInfoPtrNameSorter ());
+
+       for (PluginInfoList::iterator i = pil->begin(); i != pil->end();) {
+                PluginInfoPtr& p = *i;
+                ++i;
+                if (i != pil->end() && (*i)->name == p->name) {
+                        /* mark name as ambiguous IFF ambiguity can be resolved
+                               * by listing number of audio outputs.
+                               * This is used in the instrument selector.
+                               */
+                        bool r = p->n_outputs.n_audio() != (*i)->n_outputs.n_audio();
+                        p->multichannel_name_ambiguity = r;
+                        (*i)->multichannel_name_ambiguity = r;
+                }
+       }
+}
+
+void
+PluginManager::detect_type_ambiguities (PluginInfoList& pil)
+{
+       PluginInfoList dup;
+       pil.sort (PluginInfoPtrNameSorter ());
+       for (PluginInfoList::iterator i = pil.begin(); i != pil.end(); ++i) {
+               switch (dup.size ()) {
+                       case 0:
+                               break;
+                       case 1:
+                               if (dup.back()->name != (*i)->name) {
+                                       dup.clear ();
+                               }
+                               break;
+                       default:
+                               if (dup.back()->name != (*i)->name) {
+                                       /* found multiple plugins with same name */
+                                       bool typediff = false;
+                                       for (PluginInfoList::iterator j = dup.begin(); j != dup.end(); ++j) {
+                                               if (dup.front()->type != (*j)->type) {
+                                                       typediff = true;
+                                                       break;
+                                               }
+                                       }
+                                       if (typediff) {
+                                               for (PluginInfoList::iterator j = dup.begin(); j != dup.end(); ++j) {
+                                                       (*j)->plugintype_name_ambiguity = true;
+                                               }
+                                       }
+                                       dup.clear ();
+                               }
+                               break;
+               }
+               dup.push_back (*i);
+       }
+}
+
 void
 PluginManager::refresh (bool cache_only)
 {
@@ -372,6 +438,40 @@ PluginManager::refresh (bool cache_only)
        PluginListChanged (); /* EMIT SIGNAL */
        PluginScanMessage(X_("closeme"), "", false);
        _cancel_scan = false;
+
+       BootMessage (_("Indexing Plugins..."));
+
+       detect_name_ambiguities (_windows_vst_plugin_info);
+       detect_name_ambiguities (_lxvst_plugin_info);
+       detect_name_ambiguities (_mac_vst_plugin_info);
+       detect_name_ambiguities (_au_plugin_info);
+       detect_name_ambiguities (_ladspa_plugin_info);
+       detect_name_ambiguities (_lv2_plugin_info);
+       detect_name_ambiguities (_lua_plugin_info);
+
+       PluginInfoList all_plugs;
+       if (_windows_vst_plugin_info) {
+               all_plugs.insert(all_plugs.end(), _windows_vst_plugin_info->begin(), _windows_vst_plugin_info->end());
+       }
+       if (_lxvst_plugin_info) {
+               all_plugs.insert(all_plugs.end(), _lxvst_plugin_info->begin(), _lxvst_plugin_info->end());
+       }
+       if (_mac_vst_plugin_info) {
+               all_plugs.insert(all_plugs.end(), _mac_vst_plugin_info->begin(), _mac_vst_plugin_info->end());
+       }
+       if (_au_plugin_info) {
+               all_plugs.insert(all_plugs.end(), _au_plugin_info->begin(), _au_plugin_info->end());
+       }
+       if (_ladspa_plugin_info) {
+               all_plugs.insert(all_plugs.end(), _ladspa_plugin_info->begin(), _ladspa_plugin_info->end());
+       }
+       if (_lv2_plugin_info) {
+               all_plugs.insert(all_plugs.end(), _lv2_plugin_info->begin(), _lv2_plugin_info->end());
+       }
+       if (_lua_plugin_info) {
+               all_plugs.insert(all_plugs.end(), _lua_plugin_info->begin(), _lua_plugin_info->end());
+       }
+       detect_type_ambiguities (all_plugs);
 }
 
 void