vamp-simple-host.cpp
Go to the documentation of this file.
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
/*
Vamp
An API for audio analysis and feature extraction plugins.
Centre for Digital Music, Queen Mary, University of London.
Copyright 2006 Chris Cannam, copyright 2007-2008 QMUL.
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the names of the Centre for
Digital Music; Queen Mary, University of London; and Chris Cannam
shall not be used in advertising or otherwise to promote the sale,
use or other dealings in this Software without prior written
authorization.
*/
/*
* This "simple" Vamp plugin host is no longer as simple as it was; it
* now has a lot of options and includes a lot of code to handle the
* various useful listing modes it supports.
*
* However, the runPlugin function still contains a reasonable
* implementation of a fairly generic Vamp plugin host capable of
* evaluating a given output on a given plugin for a sound file read
* via libsndfile.
*/
#include <vamp-hostsdk/PluginHostAdapter.h>
#include <vamp-hostsdk/PluginInputDomainAdapter.h>
#include <vamp-hostsdk/PluginLoader.h>
#include <iostream>
#include <fstream>
#include <set>
#include <sndfile.h>
#include <cstring>
#include <cstdlib>
#include "system.h"
#include <cmath>
using namespace std;
using Vamp::Plugin;
using Vamp::PluginHostAdapter;
using Vamp::RealTime;
using Vamp::HostExt::PluginLoader;
using Vamp::HostExt::PluginWrapper;
using Vamp::HostExt::PluginInputDomainAdapter;
#define HOST_VERSION "1.5"
enum Verbosity {
PluginIds,
PluginOutputIds,
PluginInformation,
PluginInformationDetailed
};
void printFeatures(int, int, int, Plugin::FeatureSet, ofstream *, bool frames);
void transformInput(float *, size_t);
void fft(unsigned int, bool, double *, double *, double *, double *);
void printPluginPath(bool verbose);
void printPluginCategoryList();
void enumeratePlugins(Verbosity);
void listPluginsInLibrary(string soname);
int runPlugin(string myname, string soname, string id, string output,
int outputNo, string inputFile, string outfilename, bool frames);
void usage(const char *name)
{
cerr << "\n"
<< name << ": A command-line host for Vamp audio analysis plugins.\n\n"
"Centre for Digital Music, Queen Mary, University of London.\n"
"Copyright 2006-2009 Chris Cannam and QMUL.\n"
"Freely redistributable; published under a BSD-style license.\n\n"
"Usage:\n\n"
" " << name << " [-s] pluginlibrary[." << PLUGIN_SUFFIX << "]:plugin[:output] file.wav [-o out.txt]\n"
" " << name << " [-s] pluginlibrary[." << PLUGIN_SUFFIX << "]:plugin file.wav [outputno] [-o out.txt]\n\n"
" -- Load plugin id \"plugin\" from \"pluginlibrary\" and run it on the\n"
" audio data in \"file.wav\", retrieving the named \"output\", or output\n"
" number \"outputno\" (the first output by default) and dumping it to\n"
" standard output, or to \"out.txt\" if the -o option is given.\n\n"
" \"pluginlibrary\" should be a library name, not a file path; the\n"
" standard Vamp library search path will be used to locate it. If\n"
" a file path is supplied, the directory part(s) will be ignored.\n\n"
" If the -s option is given, results will be labelled with the audio\n"
" sample frame at which they occur. Otherwise, they will be labelled\n"
" with time in seconds.\n\n"
" " << name << " -l\n"
" " << name << " --list\n\n"
" -- List the plugin libraries and Vamp plugins in the library search path\n"
" in a verbose human-readable format.\n\n"
" " << name << " --list-full\n\n"
" -- List all data reported by all the Vamp plugins in the library search\n"
" path in a very verbose human-readable format.\n\n"
" " << name << " --list-ids\n\n"
" -- List the plugins in the search path in a terse machine-readable format,\n"
" in the form vamp:soname:identifier.\n\n"
" " << name << " --list-outputs\n\n"
" -- List the outputs for plugins in the search path in a machine-readable\n"
" format, in the form vamp:soname:identifier:output.\n\n"
" " << name << " --list-by-category\n\n"
" -- List the plugins as a plugin index by category, in a machine-readable\n"
" format. The format may change in future releases.\n\n"
" " << name << " -p\n\n"
" -- Print out the Vamp library search path.\n\n"
" " << name << " -v\n\n"
" -- Display version information only.\n"
<< endl;
exit(2);
}
int main(int argc, char **argv)
{
char *scooter = argv[0];
char *name = 0;
while (scooter && *scooter) {
if (*scooter == '/' || *scooter == '\\') name = ++scooter;
else ++scooter;
}
if (!name || !*name) name = argv[0];
if (argc < 2) usage(name);
if (argc == 2) {
if (!strcmp(argv[1], "-v")) {
cout << "Simple Vamp plugin host version: " << HOST_VERSION << endl
<< "Vamp API version: " << VAMP_API_VERSION << endl
<< "Vamp SDK version: " << VAMP_SDK_VERSION << endl;
return 0;
} else if (!strcmp(argv[1], "-l") || !strcmp(argv[1], "--list")) {
printPluginPath(true);
enumeratePlugins(PluginInformation);
return 0;
} else if (!strcmp(argv[1], "--list-full")) {
enumeratePlugins(PluginInformationDetailed);
return 0;
} else if (!strcmp(argv[1], "-p")) {
printPluginPath(false);
return 0;
} else if (!strcmp(argv[1], "--list-ids")) {
enumeratePlugins(PluginIds);
return 0;
} else if (!strcmp(argv[1], "--list-outputs")) {
enumeratePlugins(PluginOutputIds);
return 0;
} else if (!strcmp(argv[1], "--list-by-category")) {
printPluginCategoryList();
return 0;
} else usage(name);
}
if (argc < 3) usage(name);
bool useFrames = false;
int base = 1;
if (!strcmp(argv[1], "-s")) {
useFrames = true;
base = 2;
}
string soname = argv[base];
string wavname = argv[base+1];
string plugid = "";
string output = "";
int outputNo = -1;
string outfilename;
if (argc >= base+3) {
int idx = base+2;
if (isdigit(*argv[idx])) {
outputNo = atoi(argv[idx++]);
}
if (argc == idx + 2) {
if (!strcmp(argv[idx], "-o")) {
outfilename = argv[idx+1];
} else usage(name);
} else if (argc != idx) {
(usage(name));
}
}
cerr << endl << name << ": Running..." << endl;
cerr << "Reading file: \"" << wavname << "\", writing to ";
if (outfilename == "") {
cerr << "standard output" << endl;
} else {
cerr << "\"" << outfilename << "\"" << endl;
}
string::size_type sep = soname.find(':');
if (sep != string::npos) {
plugid = soname.substr(sep + 1);
soname = soname.substr(0, sep);
sep = plugid.find(':');
if (sep != string::npos) {
output = plugid.substr(sep + 1);
plugid = plugid.substr(0, sep);
}
}
if (plugid == "") {
usage(name);
}
if (output != "" && outputNo != -1) {
usage(name);
}
if (output == "" && outputNo == -1) {
outputNo = 0;
}
return runPlugin(name, soname, plugid, output, outputNo,
wavname, outfilename, useFrames);
}
int runPlugin(string myname, string soname, string id,
string output, int outputNo, string wavname,
string outfilename, bool useFrames)
{
PluginLoader *loader = PluginLoader::getInstance();
PluginLoader::PluginKey key = loader->composePluginKey(soname, id);
SNDFILE *sndfile;
SF_INFO sfinfo;
memset(&sfinfo, 0, sizeof(SF_INFO));
sndfile = sf_open(wavname.c_str(), SFM_READ, &sfinfo);
if (!sndfile) {
cerr << myname << ": ERROR: Failed to open input file \""
<< wavname << "\": " << sf_strerror(sndfile) << endl;
return 1;
}
ofstream *out = 0;
if (outfilename != "") {
out = new ofstream(outfilename.c_str(), ios::out);
if (!*out) {
cerr << myname << ": ERROR: Failed to open output file \""
<< outfilename << "\" for writing" << endl;
delete out;
return 1;
}
}
Plugin *plugin = loader->loadPlugin
(key, sfinfo.samplerate, PluginLoader::ADAPT_ALL_SAFE);
if (!plugin) {
cerr << myname << ": ERROR: Failed to load plugin \"" << id
<< "\" from library \"" << soname << "\"" << endl;
sf_close(sndfile);
if (out) {
out->close();
delete out;
}
return 1;
}
cerr << "Running plugin: \"" << plugin->getIdentifier() << "\"..." << endl;
// Note that the following would be much simpler if we used a
// PluginBufferingAdapter as well -- i.e. if we had passed
// PluginLoader::ADAPT_ALL to loader->loadPlugin() above, instead
// of ADAPT_ALL_SAFE. Then we could simply specify our own block
// size, keep the step size equal to the block size, and ignore
// the plugin's bleatings. However, there are some issues with
// using a PluginBufferingAdapter that make the results sometimes
// technically different from (if effectively the same as) the
// un-adapted plugin, so we aren't doing that here. See the
// PluginBufferingAdapter documentation for details.
int blockSize = plugin->getPreferredBlockSize();
int stepSize = plugin->getPreferredStepSize();
if (blockSize == 0) {
blockSize = 1024;
}
if (stepSize == 0) {
if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
stepSize = blockSize/2;
} else {
stepSize = blockSize;
}
} else if (stepSize > blockSize) {
cerr << "WARNING: stepSize " << stepSize << " > blockSize " << blockSize << ", resetting blockSize to ";
if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
blockSize = stepSize * 2;
} else {
blockSize = stepSize;
}
cerr << blockSize << endl;
}
int overlapSize = blockSize - stepSize;
sf_count_t currentStep = 0;
int finalStepsRemaining = max(1, (blockSize / stepSize) - 1); // at end of file, this many part-silent frames needed after we hit EOF
int channels = sfinfo.channels;
float *filebuf = new float[blockSize * channels];
float **plugbuf = new float*[channels];
for (int c = 0; c < channels; ++c) plugbuf[c] = new float[blockSize + 2];
cerr << "Using block size = " << blockSize << ", step size = "
<< stepSize << endl;
// The channel queries here are for informational purposes only --
// a PluginChannelAdapter is being used automatically behind the
// scenes, and it will take case of any channel mismatch
int minch = plugin->getMinChannelCount();
int maxch = plugin->getMaxChannelCount();
cerr << "Plugin accepts " << minch << " -> " << maxch << " channel(s)" << endl;
cerr << "Sound file has " << channels << " (will mix/augment if necessary)" << endl;
Plugin::OutputList outputs = plugin->getOutputDescriptors();
Plugin::OutputDescriptor od;
int returnValue = 1;
int progress = 0;
RealTime rt;
PluginWrapper *wrapper = 0;
RealTime adjustment = RealTime::zeroTime;
if (outputs.empty()) {
cerr << "ERROR: Plugin has no outputs!" << endl;
goto done;
}
if (outputNo < 0) {
for (size_t oi = 0; oi < outputs.size(); ++oi) {
if (outputs[oi].identifier == output) {
outputNo = oi;
break;
}
}
if (outputNo < 0) {
cerr << "ERROR: Non-existent output \"" << output << "\" requested" << endl;
goto done;
}
} else {
if (int(outputs.size()) <= outputNo) {
cerr << "ERROR: Output " << outputNo << " requested, but plugin has only " << outputs.size() << " output(s)" << endl;
goto done;
}
}
od = outputs[outputNo];
cerr << "Output is: \"" << od.identifier << "\"" << endl;
if (!plugin->initialise(channels, stepSize, blockSize)) {
cerr << "ERROR: Plugin initialise (channels = " << channels
<< ", stepSize = " << stepSize << ", blockSize = "
<< blockSize << ") failed." << endl;
goto done;
}
wrapper = dynamic_cast<PluginWrapper *>(plugin);
if (wrapper) {
// See documentation for
// PluginInputDomainAdapter::getTimestampAdjustment
PluginInputDomainAdapter *ida =
wrapper->getWrapper<PluginInputDomainAdapter>();
if (ida) adjustment = ida->getTimestampAdjustment();
}
// Here we iterate over the frames, avoiding asking the numframes in case it's streaming input.
do {
int count;
if ((blockSize==stepSize) || (currentStep==0)) {
// read a full fresh block
if ((count = sf_readf_float(sndfile, filebuf, blockSize)) < 0) {
cerr << "ERROR: sf_readf_float failed: " << sf_strerror(sndfile) << endl;
break;
}
if (count != blockSize) --finalStepsRemaining;
} else {
// otherwise shunt the existing data down and read the remainder.
memmove(filebuf, filebuf + (stepSize * channels), overlapSize * channels * sizeof(float));
if ((count = sf_readf_float(sndfile, filebuf + (overlapSize * channels), stepSize)) < 0) {
cerr << "ERROR: sf_readf_float failed: " << sf_strerror(sndfile) << endl;
break;
}
if (count != stepSize) --finalStepsRemaining;
count += overlapSize;
}
for (int c = 0; c < channels; ++c) {
int j = 0;
while (j < count) {
plugbuf[c][j] = filebuf[j * sfinfo.channels + c];
++j;
}
while (j < blockSize) {
plugbuf[c][j] = 0.0f;
++j;
}
}
rt = RealTime::frame2RealTime(currentStep * stepSize, sfinfo.samplerate);
printFeatures
(RealTime::realTime2Frame(rt + adjustment, sfinfo.samplerate),
sfinfo.samplerate, outputNo, plugin->process(plugbuf, rt),
out, useFrames);
if (sfinfo.frames > 0){
int pp = progress;
progress = lrintf((float(currentStep * stepSize) / sfinfo.frames) * 100.f);
if (progress != pp && out) {
cerr << "\r" << progress << "%";
}
}
++currentStep;
} while (finalStepsRemaining > 0);
if (out) cerr << "\rDone" << endl;
rt = RealTime::frame2RealTime(currentStep * stepSize, sfinfo.samplerate);
printFeatures(RealTime::realTime2Frame(rt + adjustment, sfinfo.samplerate),
sfinfo.samplerate, outputNo,
plugin->getRemainingFeatures(), out, useFrames);
returnValue = 0;
done:
delete plugin;
if (out) {
out->close();
delete out;
}
sf_close(sndfile);
return returnValue;
}
void
printFeatures(int frame, int sr, int output,
Plugin::FeatureSet features, ofstream *out, bool useFrames)
{
for (unsigned int i = 0; i < features[output].size(); ++i) {
if (useFrames) {
int displayFrame = frame;
if (features[output][i].hasTimestamp) {
displayFrame = RealTime::realTime2Frame
(features[output][i].timestamp, sr);
}
(out ? *out : cout) << displayFrame;
if (features[output][i].hasDuration) {
displayFrame = RealTime::realTime2Frame
(features[output][i].duration, sr);
(out ? *out : cout) << "," << displayFrame;
}
(out ? *out : cout) << ":";
} else {
RealTime rt = RealTime::frame2RealTime(frame, sr);
if (features[output][i].hasTimestamp) {
rt = features[output][i].timestamp;
}
(out ? *out : cout) << rt.toString();
if (features[output][i].hasDuration) {
rt = features[output][i].duration;
(out ? *out : cout) << "," << rt.toString();
}
(out ? *out : cout) << ":";
}
for (unsigned int j = 0; j < features[output][i].values.size(); ++j) {
(out ? *out : cout) << " " << features[output][i].values[j];
}
(out ? *out : cout) << " " << features[output][i].label;
(out ? *out : cout) << endl;
}
}
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;
}
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
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;
}
}
Vamp::HostExt::PluginLoader::composePluginKey
PluginKey composePluginKey(std::string libraryName, std::string identifier)
Given a Vamp plugin library name and plugin identifier, return the corresponding plugin key in a form...
Vamp::Plugin
Vamp::Plugin is a base class for plugin instance classes that provide feature extraction from audio o...
Definition: vamp-sdk/Plugin.h:124
PluginIds
Definition: vamp-simple-host.cpp:77
listPluginsInLibrary
void listPluginsInLibrary(string soname)
Vamp::Plugin::getPreferredStepSize
virtual size_t getPreferredStepSize() const
Get the preferred step size (window increment – the distance in sample frames between the start frame...
Definition: vamp-sdk/Plugin.h:194
PluginInformation
Definition: vamp-simple-host.cpp:79
Vamp::PluginBase::getPluginVersion
virtual int getPluginVersion() const =0
Get the version number of the plugin.
Vamp::PluginBase::getName
virtual std::string getName() const =0
Get a human-readable name or title of the plugin.
runPlugin
int runPlugin(string myname, string soname, string id, string output, int outputNo, string inputFile, string outfilename, bool frames)
Definition: vamp-simple-host.cpp:265
transformInput
void transformInput(float *, size_t)
Vamp::HostExt::PluginInputDomainAdapter::getTimestampAdjustment
RealTime getTimestampAdjustment() const
Return the amount by which the timestamps supplied to process() are being incremented when they are p...
PluginHostAdapter.h
Verbosity
Verbosity
Definition: vamp-simple-host.cpp:76
VAMP_SDK_VERSION
#define VAMP_SDK_VERSION
Definition: plugguard.h:74
Vamp::PluginBase::getIdentifier
virtual std::string getIdentifier() const =0
Get the computer-usable name of the plugin.
Vamp::PluginBase::getVampApiVersion
virtual unsigned int getVampApiVersion() const
Get the Vamp API compatibility level of the plugin.
Definition: vamp-sdk/PluginBase.h:68
Vamp::Plugin::getOutputDescriptors
virtual OutputList getOutputDescriptors() const =0
Get the outputs of this plugin.
header
static string header(string text, int level)
Definition: vamp-simple-host.cpp:567
Vamp::HostExt::PluginWrapper::getWrapper
WrapperType * getWrapper()
Return a pointer to the plugin wrapper of type WrapperType surrounding this wrapper's plugin...
Definition: PluginWrapper.h:116
Vamp::Plugin::process
virtual FeatureSet process(const float *const *inputBuffers, RealTime timestamp)=0
Process a single block of input data.
main
int main(int argc, char **argv)
Definition: vamp-simple-host.cpp:137
Vamp::HostExt::PluginLoader::getLibraryPathForPlugin
std::string getLibraryPathForPlugin(PluginKey plugin)
Return the file path of the dynamic library from which the given plugin will be loaded (if available)...
Vamp::HostExt::PluginInputDomainAdapter
PluginInputDomainAdapter is a Vamp plugin adapter that converts time-domain input into frequency-doma...
Definition: PluginInputDomainAdapter.h:87
Vamp::PluginBase::getMaker
virtual std::string getMaker() const =0
Get the name of the author or vendor of the plugin in human-readable form.
PLUGIN_SUFFIX
#define PLUGIN_SUFFIX
Definition: system.h:67
Vamp::HostExt::PluginLoader::listPlugins
PluginKeyList listPlugins()
Search for all available Vamp plugins, and return a list of them in the order in which they were foun...
Vamp::Plugin::initialise
virtual bool initialise(size_t inputChannels, size_t stepSize, size_t blockSize)=0
Initialise a plugin to prepare it for use with the given number of input channels, step size (window increment, in sample frames) and block size (window size, in sample frames).
Vamp::Plugin::TimeDomain
Definition: vamp-sdk/Plugin.h:152
VAMP_API_VERSION
#define VAMP_API_VERSION
Plugin API version.
Definition: vamp.h:53
PluginOutputIds
Definition: vamp-simple-host.cpp:78
Vamp::RealTime
RealTime represents time values to nanosecond precision with accurate arithmetic and frame-rate conve...
Definition: vamp-sdk/RealTime.h:66
Vamp::PluginHostAdapter
PluginHostAdapter is a wrapper class that a Vamp host can use to make the C-language VampPluginDescri...
Definition: PluginHostAdapter.h:68
PluginInputDomainAdapter.h
printFeatures
void printFeatures(int, int, int, Plugin::FeatureSet, ofstream *, bool frames)
Definition: vamp-simple-host.cpp:495
PluginLoader.h
Vamp::HostExt::PluginWrapper
PluginWrapper is a simple base class for adapter plugins.
Definition: PluginWrapper.h:62
PluginInformationDetailed
Definition: vamp-simple-host.cpp:80
Vamp::HostExt::PluginLoader::loadPlugin
Plugin * loadPlugin(PluginKey key, float inputSampleRate, int adapterFlags=0)
Load a Vamp plugin, given its identifying key.
Vamp::Plugin::getInputDomain
virtual InputDomain getInputDomain() const =0
Get the plugin's required input domain.
printPluginCategoryList
void printPluginCategoryList()
Definition: vamp-simple-host.cpp:797
usage
void usage(const char *name)
Definition: vamp-simple-host.cpp:93
HOST_VERSION
#define HOST_VERSION
Definition: vamp-simple-host.cpp:74
system.h
Vamp::HostExt::PluginLoader
Vamp::HostExt::PluginLoader is a convenience class for discovering and loading Vamp plugins using the...
Definition: PluginLoader.h:72
Vamp::PluginBase::getCopyright
virtual std::string getCopyright() const =0
Get the copyright statement or licensing summary for the plugin.
Vamp::Plugin::getRemainingFeatures
virtual FeatureSet getRemainingFeatures()=0
After all blocks have been processed, calculate and return any remaining features derived from the co...
Vamp::PluginBase::getParameterDescriptors
virtual ParameterList getParameterDescriptors() const
Get the controllable parameters of this plugin.
Definition: vamp-sdk/PluginBase.h:204
Vamp::Plugin::getMaxChannelCount
virtual size_t getMaxChannelCount() const
Get the maximum supported number of input channels.
Definition: vamp-sdk/Plugin.h:204
fft
void fft(unsigned int, bool, double *, double *, double *, double *)
Vamp::RealTime::toString
std::string toString() const
Return a human-readable debug-type string to full precision (probably not a format to show to a user ...
Vamp::PluginBase::getDescription
virtual std::string getDescription() const =0
Get a human-readable description for the plugin, typically a line of text that may optionally be disp...
printPluginPath
void printPluginPath(bool verbose)
Definition: vamp-simple-host.cpp:547
Vamp::Plugin::getPreferredBlockSize
virtual size_t getPreferredBlockSize() const
Get the preferred block size (window size – the number of sample frames passed in each block to the p...
Definition: vamp-sdk/Plugin.h:179
Vamp::Plugin::getMinChannelCount
virtual size_t getMinChannelCount() const
Get the minimum supported number of input channels.
Definition: vamp-sdk/Plugin.h:199
Vamp::HostExt::PluginLoader::getPluginCategory
PluginCategoryHierarchy getPluginCategory(PluginKey plugin)
Return the category hierarchy for a Vamp plugin, given its identifying key.
enumeratePlugins
void enumeratePlugins(Verbosity)
Definition: vamp-simple-host.cpp:578