vamp plugin lister

4 files changed, 301 insertions, 3 deletions

diff --git a/vamphost/addons.make b/vamphost/addons.make
index 8b13789..a66eaad 100644
--- a/vamphost/addons.make
+++ b/vamphost/addons.make
@@ -1 +1 @@
-
+ofxXmlSettings
diff --git a/vamphost/src/ofxVamphost.cpp b/vamphost/src/ofxVamphost.cpp
index 3844c60..6d2cefc 100644
--- a/vamphost/src/ofxVamphost.cpp
+++ b/vamphost/src/ofxVamphost.cpp
@@ -6,6 +6,296 @@ int Vamphost::getRT(){
 	return rt.msec();
 }
 
+enum Verbosity {
+    PluginIds,
+    PluginOutputIds,
+    PluginInformation,
+    PluginInformationDetailed
+};
+
+static string header(string text, int level)
+{
+    string out = '\n' + text + '\n';
+    for (size_t i = 0; i < text.length(); ++i) {
+        out += (level == 1 ? '=' : level == 2 ? '-' : '~');
+    }
+    out += '\n';
+    return out;
+}
+
+
+void printPluginPath(bool verbose)
+{
+	if (verbose) {
+	        cout << "\nVamp plugin search path: ";
+	     }
+	
+	     vector<string> path = PluginHostAdapter::getPluginPath();
+	     for (size_t i = 0; i < path.size(); ++i) {
+	         if (verbose) {
+	            cout << "[" << path[i] << "]";
+	         } else {
+	             cout << path[i] << endl;
+	         }
+	    }
+	 
+	    if (verbose) cout << endl;
+}
+
+void enumeratePlugins(Verbosity verbosity)
+{
+    PluginLoader *loader = PluginLoader::getInstance();
+
+    if (verbosity == PluginInformation) {
+        cout << "\nVamp plugin libraries found in search path:" << endl;
+    }
+
+    vector<PluginLoader::PluginKey> plugins = loader->listPlugins();
+    typedef multimap<string, PluginLoader::PluginKey>
+        LibraryMap;
+    LibraryMap libraryMap;
+
+    for (size_t i = 0; i < plugins.size(); ++i) {
+        string path = loader->getLibraryPathForPlugin(plugins[i]);
+        libraryMap.insert(LibraryMap::value_type(path, plugins[i]));
+    }
+
+    string prevPath = "";
+    int index = 0;
+
+    for (LibraryMap::iterator i = libraryMap.begin();
+         i != libraryMap.end(); ++i) {
+        
+        string path = i->first;
+        PluginLoader::PluginKey key = i->second;
+
+        if (path != prevPath) {
+            prevPath = path;
+            index = 0;
+            if (verbosity == PluginInformation) {
+                cout << "\n  " << path << ":" << endl;
+            } else if (verbosity == PluginInformationDetailed) {
+                string::size_type ki = i->second.find(':');
+                string text = "Library \"" + i->second.substr(0, ki) + "\"";
+                cout << "\n" << header(text, 1);
+            }
+        }
+
+        Plugin *plugin = loader->loadPlugin(key, 48000);
+        if (plugin) {
+
+            char c = char('A' + index);
+            if (c > 'Z') c = char('a' + (index - 26));
+
+            PluginLoader::PluginCategoryHierarchy category =
+                loader->getPluginCategory(key);
+            string catstr;
+            if (!category.empty()) {
+                for (size_t ci = 0; ci < category.size(); ++ci) {
+                    if (ci > 0) catstr += " > ";
+                        catstr += category[ci];
+                }
+            }
+
+            if (verbosity == PluginInformation) {
+
+                cout << "    [" << c << "] [v"
+                     << plugin->getVampApiVersion() << "] "
+                     << plugin->getName() << ", \""
+                     << plugin->getIdentifier() << "\"" << " ["
+                     << plugin->getMaker() << "]" << endl;
+                
+                if (catstr != "") {
+                    cout << "       > " << catstr << endl;
+                }
+
+                if (plugin->getDescription() != "") {
+                    cout << "        - " << plugin->getDescription() << endl;
+                }
+
+            } else if (verbosity == PluginInformationDetailed) {
+
+                cout << header(plugin->getName(), 2);
+                cout << " - Identifier:         "
+                     << key << endl;
+                cout << " - Plugin Version:     " 
+                     << plugin->getPluginVersion() << endl;
+                cout << " - Vamp API Version:   "
+                     << plugin->getVampApiVersion() << endl;
+                cout << " - Maker:              \""
+                     << plugin->getMaker() << "\"" << endl;
+                cout << " - Copyright:          \""
+                     << plugin->getCopyright() << "\"" << endl;
+                cout << " - Description:        \""
+                     << plugin->getDescription() << "\"" << endl;
+                cout << " - Input Domain:       "
+                     << (plugin->getInputDomain() == Vamp::Plugin::TimeDomain ?
+                         "Time Domain" : "Frequency Domain") << endl;
+                cout << " - Default Step Size:  " 
+                     << plugin->getPreferredStepSize() << endl;
+                cout << " - Default Block Size: " 
+                     << plugin->getPreferredBlockSize() << endl;
+                cout << " - Minimum Channels:   " 
+                     << plugin->getMinChannelCount() << endl;
+                cout << " - Maximum Channels:   " 
+                     << plugin->getMaxChannelCount() << endl;
+
+            } else if (verbosity == PluginIds) {
+                cout << "vamp:" << key << endl;
+            }
+            
+            Plugin::OutputList outputs =
+                plugin->getOutputDescriptors();
+
+            if (verbosity == PluginInformationDetailed) {
+
+                Plugin::ParameterList params = plugin->getParameterDescriptors();
+                for (size_t j = 0; j < params.size(); ++j) {
+                    Plugin::ParameterDescriptor &pd(params[j]);
+                    cout << "\nParameter " << j+1 << ": \"" << pd.name << "\"" << endl;
+                    cout << " - Identifier:         " << pd.identifier << endl;
+                    cout << " - Description:        \"" << pd.description << "\"" << endl;
+                    if (pd.unit != "") {
+                        cout << " - Unit:               " << pd.unit << endl;
+                    }
+                    cout << " - Range:              ";
+                    cout << pd.minValue << " -> " << pd.maxValue << endl;
+                    cout << " - Default:            ";
+                    cout << pd.defaultValue << endl;
+                    if (pd.isQuantized) {
+                        cout << " - Quantize Step:      "
+                             << pd.quantizeStep << endl;
+                    }
+                    if (!pd.valueNames.empty()) {
+                        cout << " - Value Names:        ";
+                        for (size_t k = 0; k < pd.valueNames.size(); ++k) {
+                            if (k > 0) cout << ", ";
+                            cout << "\"" << pd.valueNames[k] << "\"";
+                        }
+                        cout << endl;
+                    }
+                }
+
+                if (outputs.empty()) {
+                    cout << "\n** Note: This plugin reports no outputs!" << endl;
+                }
+                for (size_t j = 0; j < outputs.size(); ++j) {
+                    Plugin::OutputDescriptor &od(outputs[j]);
+                    cout << "\nOutput " << j+1 << ": \"" << od.name << "\"" << endl;
+                    cout << " - Identifier:         " << od.identifier << endl;
+                    cout << " - Description:        \"" << od.description << "\"" << endl;
+                    if (od.unit != "") {
+                        cout << " - Unit:               " << od.unit << endl;
+                    }
+                    if (od.hasFixedBinCount) {
+                        cout << " - Default Bin Count:  " << od.binCount << endl;
+                    }
+                    if (!od.binNames.empty()) {
+                        bool have = false;
+                        for (size_t k = 0; k < od.binNames.size(); ++k) {
+                            if (od.binNames[k] != "") {
+                                have = true; break;
+                            }
+                        }
+                        if (have) {
+                            cout << " - Bin Names:          ";
+                            for (size_t k = 0; k < od.binNames.size(); ++k) {
+                                if (k > 0) cout << ", ";
+                                cout << "\"" << od.binNames[k] << "\"";
+                            }
+                            cout << endl;
+                        }
+                    }
+                    if (od.hasKnownExtents) {
+                        cout << " - Default Extents:    ";
+                        cout << od.minValue << " -> " << od.maxValue << endl;
+                    }
+                    if (od.isQuantized) {
+                        cout << " - Quantize Step:      "
+                             << od.quantizeStep << endl;
+                    }
+                    cout << " - Sample Type:        "
+                         << (od.sampleType ==
+                             Plugin::OutputDescriptor::OneSamplePerStep ?
+                             "One Sample Per Step" :
+                             od.sampleType ==
+                             Plugin::OutputDescriptor::FixedSampleRate ?
+                             "Fixed Sample Rate" :
+                             "Variable Sample Rate") << endl;
+                    if (od.sampleType !=
+                        Plugin::OutputDescriptor::OneSamplePerStep) {
+                        cout << " - Default Rate:       "
+                             << od.sampleRate << endl;
+                    }
+                    cout << " - Has Duration:       "
+                         << (od.hasDuration ? "Yes" : "No") << endl;
+                }
+            }
+
+            if (outputs.size() > 1 || verbosity == PluginOutputIds) {
+                for (size_t j = 0; j < outputs.size(); ++j) {
+                    if (verbosity == PluginInformation) {
+                        cout << "         (" << j << ") "
+                             << outputs[j].name << ", \""
+                             << outputs[j].identifier << "\"" << endl;
+                        if (outputs[j].description != "") {
+                            cout << "             - " 
+                                 << outputs[j].description << endl;
+                        }
+                    } else if (verbosity == PluginOutputIds) {
+                        cout << "vamp:" << key << ":" << outputs[j].identifier << endl;
+                    }
+                }
+            }
+
+            ++index;
+
+            delete plugin;
+        }
+    }
+
+    if (verbosity == PluginInformation ||
+        verbosity == PluginInformationDetailed) {
+        cout << endl;
+    }
+}
+
+void printPluginCategoryList()
+{
+    PluginLoader *loader = PluginLoader::getInstance();
+
+    vector<PluginLoader::PluginKey> plugins = loader->listPlugins();
+
+    set<string> printedcats;
+
+    for (size_t i = 0; i < plugins.size(); ++i) {
+
+        PluginLoader::PluginKey key = plugins[i];
+        
+        PluginLoader::PluginCategoryHierarchy category =
+            loader->getPluginCategory(key);
+
+        Plugin *plugin = loader->loadPlugin(key, 48000);
+        if (!plugin) continue;
+
+        string catstr = "";
+
+        if (category.empty()) catstr = '|';
+        else {
+            for (size_t j = 0; j < category.size(); ++j) {
+                catstr += category[j];
+                catstr += '|';
+                if (printedcats.find(catstr) == printedcats.end()) {
+                    std::cout << catstr << std::endl;
+                    printedcats.insert(catstr);
+                }
+            }
+        }
+
+        std::cout << catstr << key << ":::" << plugin->getName() << ":::" << plugin->getMaker() << ":::" << plugin->getDescription() << std::endl;
+    }
+}
+
 int Vamphost::init(const string &soname,const string &id,const int &_channels,const int &_rate,const int &_outputNo,const string &_output){
 
 	//stuff that only happens once
@@ -165,8 +455,6 @@ void Vamphost::process_frame(float *data,int samples_in_frame){
 
 			Plugin::FeatureSet feat=plugin->process(plugbuf, rt);
 
-			if (feat[outputNo].size()>0) cerr<<"BEAT"<<endl;
-
 			for (unsigned int i = 0; i < feat[outputNo].size(); ++i) {
 				features[((float)feat[outputNo][i].timestamp.sec)+(((float)feat[outputNo][i].timestamp.nsec)*.000000001)]=featureNo;
 				featureNo++;
diff --git a/vamphost/src/testApp.cpp b/vamphost/src/testApp.cpp
index 659ed35..d9cbfe7 100644
--- a/vamphost/src/testApp.cpp
+++ b/vamphost/src/testApp.cpp
@@ -26,6 +26,12 @@ void testApp::setup() {
     //string id="qm-tempotracker";
     //string id="qm-barbeattracker";
 
+    ofxXmlSettings xml;
+    if(xml.loadFile("settings.xml") ){
+        string graph_dir=xml.getAttribute("Rotor","graph_dir","",0);
+    }
+    else cerr<<"Rotor: settings.xml not found, using defaults"<<endl;
+
     string soname="vamp-example-plugins.so";
     string id="percussiononsets";
 
diff --git a/vamphost/src/testApp.h b/vamphost/src/testApp.h
index ad24233..390071a 100644
--- a/vamphost/src/testApp.h
+++ b/vamphost/src/testApp.h
@@ -3,6 +3,7 @@
 
 #include "ofMain.h"
 #include "ofxVamphost.h"
+#include "ofxXmlSettings.h"
 
 
 class testApp : public ofBaseApp{
@@ -35,6 +36,9 @@ public:
 	
 	ofSoundStream soundStream;
 	Vamphost vamphost;
+
+	vector<map<string,vector<string> > > pluginList;
+
     
 };