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; }