int PluginHost::addPlugin(const char *fname, int stackType, Channel *ch) {
Plugin *p = new Plugin();
bool success = true;
gVector <Plugin *> *pStack;
pStack = getStack(stackType, ch);
if (!p->load(fname)) {
//delete p;
//return 0;
success = false;
}
/* if the load failed we add a 'dead' plugin into the stack. This is
* useful to report a missing plugin. */
if (!success) {
pStack->add(p);
return 0;
}
/* otherwise let's try to initialize it. */
else {
/* try to init the plugin. If fails, delete it and return error. */
if (!p->init(&PluginHost::HostCallback)) {
delete p;
return 0;
}
/* plugin setup */
p->setup(G_Conf.samplerate, kernelAudio::realBufsize);
/* try to add the new plugin until succeed */
int lockStatus;
while (true) {
lockStatus = pthread_mutex_trylock(&G_Mixer.mutex_plugins);
if (lockStatus == 0) {
pStack->add(p);
pthread_mutex_unlock(&G_Mixer.mutex_plugins);
break;
}
}
char name[256]; p->getName(name);
gLog("[pluginHost] plugin id=%d loaded (%s), stack type=%d, stack size=%d\n", p->getId(), name, stackType, pStack->size);
/* p->resume() is suggested. Who knows... */
p->resume();
return 1;
}
}
void LoadPluginCmd::exec()
{
if (mPluginPath.empty())
return ;
Plugin* plugin = PluginManager::getSingletonPtr()->getPluginByFileName(mPluginPath);
if (!plugin)
{
if (PluginManager::getSingletonPtr()->loadPlugin(mPluginPath))
{
Plugin* plugin = PluginManager::getSingletonPtr()->getPluginByFileName(mPluginPath);
System* system = SystemManager::getSingletonPtr()->getSystemByName(plugin->getSystemName());
system->shutdown();
if (!plugin->initialize())
{
LOGE("Couldn't initialise the plugin '" + plugin->getName() + "'");
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" failed : Couldn't initialise the plugin '" + plugin->getName() + "'");
return ;
}
system->init();
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" loaded");
}
else
CommandManager::getSingletonPtr()->setReturnMessage("Failed to load plugin \"" + mPluginPath + "\"");
}
else
{
std::string pluginName = plugin->getName();
System* system = SystemManager::getSingletonPtr()->getSystemByName(plugin->getSystemName());
std::string systemPluginName = system->getPluginName();
if (pluginName != systemPluginName)
{
system->shutdown();
if (!plugin->initialize())
{
LOGE("Couldn't initialise the plugin '" + plugin->getName() + "'");
CommandManager::getSingletonPtr()->setReturnMessage("Couldn't initialise the plugin '" + plugin->getName() + "'");
return ;
}
system->init();
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" loaded. System " + system->getName() + " initialized.");
}
else
CommandManager::getSingletonPtr()->setReturnMessage("Plugin \"" + mPluginPath + "\" already loaded.");
}
}
void PluginManager::registerPlugin(Plugin* plugin)
{
// ensure that we haven't already loaded the plugin
for(vector<Plugin*>::iterator it = plugins.begin(); it != plugins.end(); ++it) {
Plugin *p = *it;
if ( ! strcmp(p->getName(), plugin->getName()) ) {
throw runtime_error( (string("Plugin with name '") + string(plugin->getName()) + string("' was loaded multiple times!")) );
}
}
plugins.push_back(plugin);
plugin->registerPlugin();
}
Plugin *PluginHost::addPlugin(const string &fid, int stackType,
pthread_mutex_t *mutex, class Channel *ch)
{
/* Get the proper stack to add the plugin to */
vector <Plugin *> *pStack;
pStack = getStack(stackType, ch);
/* Initialize plugin */
juce::PluginDescription *pd = knownPluginList.getTypeForFile(fid);
if (!pd) {
gu_log("[PluginHost::addPlugin] no plugin found with fid=%s!\n", fid.c_str());
missingPlugins = true;
unknownPluginList.push_back(fid);
return NULL;
}
Plugin *p = (Plugin *) pluginFormat.createInstanceFromDescription(*pd, samplerate, buffersize);
if (!p) {
gu_log("[PluginHost::addPlugin] unable to create instance with fid=%s!\n", fid.c_str());
missingPlugins = true;
return NULL;
}
//p->setStatus(1);
//p->setId();
//p->initEditor();
p->init();
p->prepareToPlay(samplerate, buffersize);
gu_log("[PluginHost::addPlugin] plugin instance with fid=%s created\n", fid.c_str());
/* Try to inject the plugin as soon as possible. */
int lockStatus;
while (true) {
lockStatus = pthread_mutex_trylock(mutex);
if (lockStatus == 0) {
pStack->push_back(p);
pthread_mutex_unlock(mutex);
break;
}
}
gu_log("[PluginHost::addPlugin] plugin id=%s loaded (%s), stack type=%d, stack size=%d\n",
fid.c_str(), p->getName().toStdString().c_str(), stackType, pStack->size());
return p;
}
/**
* Returns a plugin registered in the system with a specific name. If there are several, the first will be returned.
* @param pluginName name of the plugin to be returned.
* @return pointer to the plugin if found, NULL if not found
*/
Cing::Plugin* Application::getPlugin( const std::string& pluginName )
{
// search for a plugin with the received name (and return the first found
for ( PluginList::iterator it = m_plugins.begin(); it != m_plugins.end(); ++it )
{
Plugin* plugin = *it;
if ( plugin && (plugin->getName() == pluginName) )
{
return plugin;
}
}
// not found
return NULL;
}
void DlgPrefBeats::populate() {
VampAnalyser::initializePluginPaths();
m_listIdentifier.clear();
m_listName.clear();
m_listLibrary.clear();
disconnect(plugincombo, SIGNAL(currentIndexChanged(int)),
this, SLOT(pluginSelected(int)));
plugincombo->clear();
plugincombo->setDuplicatesEnabled(false);
connect(plugincombo, SIGNAL(currentIndexChanged(int)),
this, SLOT(pluginSelected(int)));
VampPluginLoader *loader = VampPluginLoader::getInstance();
std::vector<PluginLoader::PluginKey> plugins = loader->listPlugins();
qDebug() << "VampPluginLoader::listPlugins() returned" << plugins.size() << "plugins";
for (unsigned int iplugin=0; iplugin < plugins.size(); iplugin++) {
// TODO(XXX): WTF, 48000
Plugin *plugin = loader->loadPlugin(plugins[iplugin], 48000);
//TODO: find a way to add beat trackers only
if (plugin) {
Plugin::OutputList outputs = plugin->getOutputDescriptors();
for (unsigned int ioutput=0; ioutput < outputs.size(); ioutput++) {
QString displayname = QString::fromStdString(plugin->getIdentifier()) + ":"
+ QString::number(ioutput);
QString displaynametext = QString::fromStdString(plugin->getName());
qDebug() << "Plugin output displayname:" << displayname << displaynametext;
bool goodones = ((displayname.contains("mixxxbpmdetection")||
displayname.contains("qm-tempotracker:0"))||
displayname.contains("beatroot:0")||
displayname.contains("marsyas_ibt:0")||
displayname.contains("aubiotempo:0")
);
if (goodones) {
m_listName << displaynametext;
QString pluginlibrary = QString::fromStdString(plugins[iplugin]).section(":",0,0);
m_listLibrary << pluginlibrary;
QString displayname = QString::fromStdString(plugin->getIdentifier()) + ":"
+ QString::number(ioutput);
m_listIdentifier << displayname;
plugincombo->addItem(displaynametext, displayname);
}
}
delete plugin;
plugin = 0;
}
}
}
bool PluginManager::loadPlugin(QString file, bool silent) {
QLibrary* library = new QLibrary(file);
if(!library->load()) {
if(!silent) {
QMessageBox::critical (_gi, tr("Error loading plugin"), library->errorString());
}
return false;
}
std::cout << file.toStdString() << " loaded" << std::endl;
QFunctionPointer ptr = library->resolve("loadPlugin");
if(ptr == 0) {
if(!silent) {
QMessageBox::critical (_gi, tr("Error loading plugin"), tr("Could not find the plugin's entry point \"loadPlugin\""));
}
return false;
}
std::cout << file.toStdString() << ": entry point found" << std::endl;
typedef Plugin* (*entryPoint)();
entryPoint getPlugin = reinterpret_cast<entryPoint>(ptr);
Plugin* plugin = getPlugin();
if(plugin==NULL) {
if(!silent) {
QMessageBox::critical (_gi, tr("Error loading plugin"), tr("The getPlugin entry point does not return a valid Plugin"));
}
return false;
}
std::cout << file.toStdString() << ": got Plugin" << std::endl;
vector<GenericOperation*> operations = plugin->getOperations();
std::cout << "Plugin " << plugin->getName() << " loaded : " << operations.size() << " operations "<< std::endl;
//PluginService* pluginService = new PluginService(plugin);
_plugins.insert(pair<string,Plugin*>(file.toStdString(), plugin));
_libraries.insert(pair<Plugin*,QLibrary*>(plugin, library));
//_gi->addService(pluginService);
emit addPlugin(plugin);
return true;
}
size_t PluginEngine::loadPlugins( const std::string & pluginFldr ) {
// 1. get all files in pluginFldr that conform to a platform-dependent
// naming convention.
// 2. For each one, try to open it and determine if it has the interface
// expected for this plugin engine
// 3. If it does, register it with the appropriate manager.
// (NOt entirely sure what this means yet...ultimately, the manager
// has to be able to provide information about the entity in the
// plug-in and provide the ability to insantiate it. "information"
// may also include the ability to parse itself from the xml.
StringList files;
#ifdef _MSC_VER
std::string extension( "*.dll" );
#else
std::string extension( "*.so" );
#endif
if ( !os::listdir( pluginFldr, files, extension ) ) {
return 0;
}
StringListCItr itr = files.begin();
for ( ; itr != files.end(); ++itr ) {
std::string fullPath;
if ( ! os::path::absPath( os::path::join( 2, pluginFldr.c_str(), (*itr).c_str() ), fullPath ) ) {
logger << Logger::ERR_MSG << "Unable to get absolute path for " << (*itr);
continue;
}
Plugin * plugin;
try {
plugin = new Plugin( fullPath );
} catch ( std::exception & ) {
logger << Logger::ERR_MSG << "Failed loading " << fullPath << " as a plug-in";
continue;
}
logger << Logger::INFO_MSG << "Loaded: " << plugin->getName() << "\n";;
logger << "\t" << plugin->getDescription();
plugin->registerPlugin( this );
_plugins.insert( PluginMap::value_type( (*itr), plugin ) );
}
return files.size();
}
/*!
Add a plugin.
\param file The plugin file name.
\param server The server object to use.
messages.
\param global Specify if the library should be loaded globally.
*/
Plugin*
PluginsManager::preLoadPlugin (string &file, Server* server, bool global)
{
Plugin *plugin = createPluginObject ();
string name;
const char* namePtr;
if (plugin->preLoad (file, global))
{
server->log (MYSERVER_LOG_MSG_ERROR,
_("Error pre-loading plugin `%s'"),
file.c_str ());
delete plugin;
return NULL;
}
namePtr = plugin->getName ();
if (namePtr)
name.assign (namePtr);
else
{
server->log (MYSERVER_LOG_MSG_ERROR,
_("Error pre-loading plugin `%s'"),
file.c_str ());
delete plugin;
return NULL;
}
if (plugin->findSymbol ("__gpl_license") == NULL)
{
server->log (MYSERVER_LOG_MSG_ERROR,
_("Error loading plugin `%s', the license is not GPL"),
file.c_str ());
delete plugin;
return NULL;
}
return plugin;
}
void DlgPrefKey::populate() {
VampAnalyser::initializePluginPaths();
m_listIdentifier.clear();
m_listName.clear();
m_listLibrary.clear();
plugincombo->clear();
plugincombo->setDuplicatesEnabled(false);
VampPluginLoader* loader = VampPluginLoader::getInstance();
std::vector<PluginLoader::PluginKey> plugins = loader->listPlugins();
qDebug() << "VampPluginLoader::listPlugins() returned" << plugins.size() << "plugins";
for (unsigned int iplugin=0; iplugin < plugins.size(); iplugin++) {
// TODO(XXX): WTF, 48000
Plugin* plugin = loader->loadPlugin(plugins[iplugin], 48000);
//TODO(XXX): find a general way to add key detectors only
if (plugin) {
Plugin::OutputList outputs = plugin->getOutputDescriptors();
for (unsigned int ioutput=0; ioutput < outputs.size(); ioutput++) {
QString displayname = QString::fromStdString(plugin->getIdentifier()) + ":"
+ QString::number(ioutput);
QString displaynametext = QString::fromStdString(plugin->getName());
qDebug() << "Plugin output displayname:" << displayname << displaynametext;
bool goodones = displayname.contains(VAMP_ANALYSER_KEY_DEFAULT_PLUGIN_ID);
if (goodones) {
m_listName << displaynametext;
QString pluginlibrary = QString::fromStdString(plugins[iplugin]).section(":",0,0);
m_listLibrary << pluginlibrary;
QString displayname = QString::fromStdString(plugin->getIdentifier()) + ":"
+ QString::number(ioutput);
m_listIdentifier << displayname;
plugincombo->addItem(displaynametext, displayname);
}
}
delete plugin;
plugin = 0;
}
}
}
int main()
{
try
{
//Create a RoadRunner object
RoadRunner rr("r:\\installs\\cg\\xe3\\debug\\rr_support");
//Get the plugin manager
PluginManager& plugins = rr.getPluginManager();
if(!plugins.load())
{
clog<<"Failed loading plugins..\n";
}
if(plugins.getNumberOfPlugins() > 0)
{
cout<<"The following plugins are loaded:\n";
for(int i = 0; i < plugins.getNumberOfPlugins(); i++)
{
Plugin* aPlugin = plugins[i];
cout<<"Plugin "<<i<<": "<<aPlugin->getName()<<"\n";
cout<<aPlugin->getInfo();
aPlugin->execute();
}
}
plugins.unload();
Pause(true);
rr.~RoadRunner();
}
catch(const rr::Exception& ex)
{
clog<<"There was a problem: "<<ex.what();
}
return 0;
}
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;
}
}
const VampPluginDescriptor *
PluginAdapterBase::Impl::getDescriptor()
{
#ifdef DEBUG_PLUGIN_ADAPTER
std::cerr << "PluginAdapterBase::Impl[" << this << "]::getDescriptor" << std::endl;
#endif
if (m_populated) return &m_descriptor;
Plugin *plugin = m_base->createPlugin(48000);
if (plugin->getVampApiVersion() != VAMP_API_VERSION) {
std::cerr << "Vamp::PluginAdapterBase::Impl::getDescriptor: ERROR: "
<< "Plugin object API version "
<< plugin->getVampApiVersion()
<< " does not match actual API version "
<< VAMP_API_VERSION << std::endl;
delete plugin;
return 0;
}
m_parameters = plugin->getParameterDescriptors();
m_programs = plugin->getPrograms();
m_descriptor.vampApiVersion = plugin->getVampApiVersion();
m_descriptor.identifier = strdup(plugin->getIdentifier().c_str());
m_descriptor.name = strdup(plugin->getName().c_str());
m_descriptor.description = strdup(plugin->getDescription().c_str());
m_descriptor.maker = strdup(plugin->getMaker().c_str());
m_descriptor.pluginVersion = plugin->getPluginVersion();
m_descriptor.copyright = strdup(plugin->getCopyright().c_str());
m_descriptor.parameterCount = m_parameters.size();
m_descriptor.parameters = (const VampParameterDescriptor **)
malloc(m_parameters.size() * sizeof(VampParameterDescriptor));
unsigned int i;
for (i = 0; i < m_parameters.size(); ++i) {
VampParameterDescriptor *desc = (VampParameterDescriptor *)
malloc(sizeof(VampParameterDescriptor));
desc->identifier = strdup(m_parameters[i].identifier.c_str());
desc->name = strdup(m_parameters[i].name.c_str());
desc->description = strdup(m_parameters[i].description.c_str());
desc->unit = strdup(m_parameters[i].unit.c_str());
desc->minValue = m_parameters[i].minValue;
desc->maxValue = m_parameters[i].maxValue;
desc->defaultValue = m_parameters[i].defaultValue;
desc->isQuantized = m_parameters[i].isQuantized;
desc->quantizeStep = m_parameters[i].quantizeStep;
desc->valueNames = 0;
if (desc->isQuantized && !m_parameters[i].valueNames.empty()) {
desc->valueNames = (const char **)
malloc((m_parameters[i].valueNames.size()+1) * sizeof(char *));
for (unsigned int j = 0; j < m_parameters[i].valueNames.size(); ++j) {
desc->valueNames[j] = strdup(m_parameters[i].valueNames[j].c_str());
}
desc->valueNames[m_parameters[i].valueNames.size()] = 0;
}
m_descriptor.parameters[i] = desc;
}
m_descriptor.programCount = m_programs.size();
m_descriptor.programs = (const char **)
malloc(m_programs.size() * sizeof(const char *));
for (i = 0; i < m_programs.size(); ++i) {
m_descriptor.programs[i] = strdup(m_programs[i].c_str());
}
if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
m_descriptor.inputDomain = vampFrequencyDomain;
} else {
m_descriptor.inputDomain = vampTimeDomain;
}
m_descriptor.instantiate = vampInstantiate;
m_descriptor.cleanup = vampCleanup;
m_descriptor.initialise = vampInitialise;
m_descriptor.reset = vampReset;
m_descriptor.getParameter = vampGetParameter;
m_descriptor.setParameter = vampSetParameter;
m_descriptor.getCurrentProgram = vampGetCurrentProgram;
m_descriptor.selectProgram = vampSelectProgram;
m_descriptor.getPreferredStepSize = vampGetPreferredStepSize;
m_descriptor.getPreferredBlockSize = vampGetPreferredBlockSize;
m_descriptor.getMinChannelCount = vampGetMinChannelCount;
m_descriptor.getMaxChannelCount = vampGetMaxChannelCount;
m_descriptor.getOutputCount = vampGetOutputCount;
m_descriptor.getOutputDescriptor = vampGetOutputDescriptor;
m_descriptor.releaseOutputDescriptor = vampReleaseOutputDescriptor;
m_descriptor.process = vampProcess;
m_descriptor.getRemainingFeatures = vampGetRemainingFeatures;
m_descriptor.releaseFeatureSet = vampReleaseFeatureSet;
if (!m_adapterMap) {
m_adapterMap = new AdapterMap;
}
(*m_adapterMap)[&m_descriptor] = this;
delete plugin;
m_populated = true;
return &m_descriptor;
}
wxArrayString VampEffectsModule::FindPlugins(PluginManagerInterface & WXUNUSED(pm))
{
wxArrayString names;
PluginLoader *loader = PluginLoader::getInstance();
PluginLoader::PluginKeyList keys = loader->listPlugins();
for (PluginLoader::PluginKeyList::iterator i = keys.begin(); i != keys.end(); ++i)
{
Plugin *vp = PluginLoader::getInstance()->loadPlugin(*i, 48000); // rate doesn't matter here
if (!vp)
{
continue;
}
// We limit the listed plugin outputs to those whose results can
// readily be displayed in an Audacity label track.
//
// - Any output whose features have no values (time instants only),
// with or without duration, is fine
//
// - Any output whose features have more than one value, or an
// unknown or variable number of values, is right out
//
// - Any output whose features have exactly one value, with
// variable sample rate or with duration, should be OK --
// this implies a sparse feature, of which the time and/or
// duration are significant aspects worth displaying
//
// - An output whose features have exactly one value, with
// fixed sample rate and no duration, cannot be usefully
// displayed -- the value is the only significant piece of
// data there and we have no good value plot
Plugin::OutputList outputs = vp->getOutputDescriptors();
int output = 0;
for (Plugin::OutputList::iterator j = outputs.begin(); j != outputs.end(); ++j)
{
if (j->sampleType == Plugin::OutputDescriptor::FixedSampleRate ||
j->sampleType == Plugin::OutputDescriptor::OneSamplePerStep ||
!j->hasFixedBinCount ||
(j->hasFixedBinCount && j->binCount > 1))
{
// All of these qualities disqualify (see notes above)
++output;
continue;
}
wxString name = wxString::FromUTF8(vp->getName().c_str());
if (outputs.size() > 1)
{
// This is not the plugin's only output.
// Use "plugin name: output name" as the effect name,
// unless the output name is the same as the plugin name
wxString outputName = wxString::FromUTF8(j->name.c_str());
if (outputName != name)
{
name = wxString::Format(wxT("%s: %s"),
name.c_str(), outputName.c_str());
}
}
wxString path = wxString::FromUTF8(i->c_str()) + wxT("/") + name;
names.Add(path);
++output;
}
delete vp;
}
return names;
}
Plugin *VampEffectsModule::FindPlugin(const wxString & path,
int & output,
bool & hasParameters)
{
PluginLoader::PluginKey key = path.BeforeLast(wxT('/')).ToUTF8().data();
Plugin *vp = PluginLoader::getInstance()->loadPlugin(key, 48000); // rate doesn't matter here
if (!vp)
{
return false;
}
// We limit the listed plugin outputs to those whose results can
// readily be displayed in an Audacity label track.
//
// - Any output whose features have no values (time instants only),
// with or without duration, is fine
//
// - Any output whose features have more than one value, or an
// unknown or variable number of values, is right out
//
// - Any output whose features have exactly one value, with
// variable sample rate or with duration, should be OK --
// this implies a sparse feature, of which the time and/or
// duration are significant aspects worth displaying
//
// - An output whose features have exactly one value, with
// fixed sample rate and no duration, cannot be usefully
// displayed -- the value is the only significant piece of
// data there and we have no good value plot
Plugin::OutputList outputs = vp->getOutputDescriptors();
output = 0;
hasParameters = !vp->getParameterDescriptors().empty();
for (Plugin::OutputList::iterator j = outputs.begin(); j != outputs.end(); ++j)
{
if (j->sampleType == Plugin::OutputDescriptor::FixedSampleRate ||
j->sampleType == Plugin::OutputDescriptor::OneSamplePerStep ||
!j->hasFixedBinCount ||
(j->hasFixedBinCount && j->binCount > 1))
{
// All of these qualities disqualify (see notes above)
++output;
continue;
}
wxString name = wxString::FromUTF8(vp->getName().c_str());
if (outputs.size() > 1)
{
// This is not the plugin's only output.
// Use "plugin name: output name" as the effect name,
// unless the output name is the same as the plugin name
wxString outputName = wxString::FromUTF8(j->name.c_str());
if (outputName != name)
{
name = wxString::Format(wxT("%s: %s"),
name.c_str(), outputName.c_str());
}
}
if (wxString::FromUTF8(key.c_str()) + wxT("/") + name == path)
{
return vp;
}
++output;
}
delete vp;
return NULL;
}
LRESULT PluginListView::notify(WPARAM /*wParam*/, LPARAM lParam)
{
switch (((LPNMHDR)lParam)->code)
{
case LVN_GETDISPINFO:
{
if (_listMode == LISTMODE_LIST)
{
NMLVDISPINFO* plvdi = (NMLVDISPINFO*)lParam;
Plugin* plugin = reinterpret_cast<Plugin*>(plvdi->item.lParam);
switch (plvdi->item.iSubItem)
{
case 0:
{
plvdi->item.pszText = const_cast<TCHAR*>(plugin->getName().c_str());
break;
}
case 1:
{
plvdi->item.pszText = const_cast<TCHAR*>(plugin->getCategory().c_str());
break;
}
default:
if (plvdi->item.iSubItem == _nVersionColumns + 2)
{
plvdi->item.pszText = const_cast<TCHAR*>(plugin->getStability().c_str());
}
else
{
switch(_columns[plvdi->item.iSubItem - 2])
{
case VERSION_INSTALLED:
plvdi->item.pszText = plugin->getInstalledVersion().getDisplayString();
plvdi->item.cchTextMax = (int)_tcslen(plvdi->item.pszText);
break;
case VERSION_AVAILABLE:
plvdi->item.pszText = plugin->getVersion().getDisplayString();
plvdi->item.cchTextMax = (int)_tcslen(plvdi->item.pszText);
break;
}
}
break;
}
return TRUE;
}
break;
}
case LVN_COLUMNCLICK:
{
NMLISTVIEW *colInfo = reinterpret_cast<NMLISTVIEW*>(lParam);
int (CALLBACK *compareFunc)(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort) = NULL;
LVSORTCOLUMN sortColumn = LVSORTCOLUMN_NAME;
if (colInfo->iSubItem < 2 || colInfo->iSubItem == _nVersionColumns + 2)
{
compareFunc = PluginListView::stringComparer;
if (colInfo->iSubItem == 1)
{
sortColumn = LVSORTCOLUMN_CATEGORY;
}
else if (colInfo->iSubItem == _nVersionColumns + 2)
{
sortColumn = LVSORTCOLUMN_STABILITY;
}
}
else
{
compareFunc = PluginListView::versionComparer;
switch(_columns[colInfo->iSubItem - 2])
{
case VERSION_AVAILABLE:
sortColumn = LVSORTCOLUMN_VERSIONAVAILABLE;
break;
case VERSION_INSTALLED:
sortColumn = LVSORTCOLUMN_VERSIONINSTALLED;
break;
// Just in case there's another one introduced at some point (beta version or something)
default:
sortColumn = LVSORTCOLUMN_VERSIONAVAILABLE;
break;
}
}
ListView_SortItems(_hListView, compareFunc, static_cast<LPARAM>(sortColumn));
}
break;
case NM_CLICK:
if (_hDescription && lParam)
{
LPNMITEMACTIVATE itemActivate = reinterpret_cast<LPNMITEMACTIVATE>(lParam);
if (itemActivate->iItem >= 0)
{
ListView_SetItemState(_hListView, getCurrentSelectedIndex(), 0, LVIS_SELECTED);
ListView_SetItemState(_hListView, itemActivate->iItem, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
}
}
break;
case LVN_ITEMCHANGED:
{
LPNMLISTVIEW pnmv = reinterpret_cast<LPNMLISTVIEW>(lParam);
if (pnmv->uNewState & LVIS_SELECTED)
{
Plugin* plugin = reinterpret_cast<Plugin*>(pnmv->lParam);
if (plugin && _hDescription)
{
if (_displayUpdateDesc)
::SendMessage(_hDescription, WM_SETTEXT, 0, reinterpret_cast<LPARAM>(plugin->getUpdateDescription().c_str()));
else
::SendMessage(_hDescription, WM_SETTEXT, 0, reinterpret_cast<LPARAM>(plugin->getDescription().c_str()));
}
}
}
}
return FALSE;
}
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;
}
}
int main (int argc, char* argv[])
{
struct dirent **namelist;
int n;
bool listHelp = false;
bool listPlugins = false;
std::string arg;
for ( int i=1; i < argc; i++ ) {
arg = std::string( argv[i] );
if ( arg.compare( "--help" ) == 0 ) {
listHelp = true;
} else if ( arg.compare( "--list-modules" ) == 0 ) {
listPlugins = true;
} else {
std::cout << "usage: " << argv[0] << " [--help] [--list-modules]" << std::endl;
exit(0);
}
}
if ( !listPlugins && !listHelp ) {
std::cout << "usage: " << argv[0] << " [--help] [--list-modules]" << std::endl;
exit(0);
}
if ( listPlugins )
std::cout << "Nanox runtime library available plugins at '" << PLUGIN_DIR << "':" << std::endl;
n = scandir( PLUGIN_DIR, &namelist, 0, alphasort );
if ( n < 0 )
perror( "scandir" );
else {
while ( n-- ) {
std::string name( namelist[n]->d_name );
if ( name.compare( 0,9,"libnanox-" ) != 0 ) continue;
if ( name.compare( name.size()-3,3,".so" ) == 0 ) {
name.erase( name.size()-3 );
name.erase( 0, std::string("libnanox-").size() );
if ( PluginManager::isPlugin( name ) ) {
Plugin *plugin = PluginManager::loadAndGetPlugin( name , false );
if ( listPlugins && plugin != NULL )
std::cout << " " << name << " - " << plugin->getName() << " - version " << plugin->getVersion() << std::endl;
}
}
free( namelist[n] );
}
free( namelist );
}
if ( listHelp ) {
if ( listPlugins )
std::cout << std::endl;
std::cout << "Nanos++ runtime library version " << VERSION << "." << std::endl;
std::cout << std::endl;
std::cout << "The runtime configuration can be set using arguments added" << std::endl;
std::cout << "to the NX_ARGS environment variable or through specialised" << std::endl;
std::cout << "environment variables. As an example of NX_ARGS, to execute" << std::endl;
std::cout << "with verbose mode and 4 PEs the NX_ARGS environment variable" << std::endl;
std::cout << "should be: 'NX_ARGS=\"--pes=4 --verbose\"'." << std::endl;
std::cout << std::endl;
std::cout << "All NX_ARGS and env vars are listed below." << std::endl;
std::cout << std::endl;
std::cout << Config::getNanosHelp();
}
}
bool VampEffectsModule::AutoRegisterPlugins(PluginManagerInterface & pm)
{
#ifdef EFFECT_CATEGORIES
InitCategoryMap();
#endif
PluginLoader *loader = PluginLoader::getInstance();
EffectManager& em = EffectManager::Get();
PluginLoader::PluginKeyList keys = loader->listPlugins();
for (PluginLoader::PluginKeyList::iterator i = keys.begin();
i != keys.end(); ++i) {
Plugin *vp = loader->loadPlugin(*i, 48000); // rate doesn't matter here
if (!vp) continue;
#ifdef EFFECT_CATEGORIES
PluginLoader::PluginCategoryHierarchy category =
loader->getPluginCategory(*i);
wxString vampCategory = VampHierarchyToUri(category);
#endif
// We limit the listed plugin outputs to those whose results can
// readily be displayed in an Audacity label track.
//
// - Any output whose features have no values (time instants only),
// with or without duration, is fine
//
// - Any output whose features have more than one value, or an
// unknown or variable number of values, is right out
//
// - Any output whose features have exactly one value, with
// variable sample rate or with duration, should be OK --
// this implies a sparse feature, of which the time and/or
// duration are significant aspects worth displaying
//
// - An output whose features have exactly one value, with
// fixed sample rate and no duration, cannot be usefully
// displayed -- the value is the only significant piece of
// data there and we have no good value plot
Plugin::OutputList outputs = vp->getOutputDescriptors();
int n = 0;
bool hasParameters = !vp->getParameterDescriptors().empty();
for (Plugin::OutputList::iterator j = outputs.begin();
j != outputs.end(); ++j) {
if (j->sampleType == Plugin::OutputDescriptor::FixedSampleRate ||
j->sampleType == Plugin::OutputDescriptor::OneSamplePerStep ||
!j->hasFixedBinCount ||
(j->hasFixedBinCount && j->binCount > 1)) {
// All of these qualities disqualify (see notes above)
++n;
continue;
}
wxString name = LAT1CTOWX(vp->getName().c_str());
if (outputs.size() > 1) {
// This is not the plugin's only output.
// Use "plugin name: output name" as the effect name,
// unless the output name is the same as the plugin name
wxString outputName = LAT1CTOWX(j->name.c_str());
if (outputName != name) {
name = wxString::Format(wxT("%s: %s"),
name.c_str(), outputName.c_str());
}
}
#ifdef EFFECT_CATEGORIES
VampEffect *effect = new VampEffect(*i, n, hasParameters, name,
vampCategory);
#else
VampEffect *effect = new VampEffect(*i, n, hasParameters, name);
#endif
em.RegisterEffect(this, effect);
++n;
}
delete vp;
}
return true;
}
