comparison plugin/transform/TransformerFactory.cpp @ 329:3179d8b29336

* Another incremental Transform update

 
 TransformerFactory::~TransformerFactory()
 {
 }
 
-TransformerFactory::TransformerList
-TransformerFactory::getAllTransformers()
-{
-    if (m_transforms.empty()) populateTransformers();
-
-    std::set<TransformerDesc> dset;
-    for (TransformerDescriptionMap::const_iterator i = m_transforms.begin();
+TransformList
+TransformerFactory::getAllTransforms()
+{
+    if (m_transforms.empty()) populateTransforms();
+
+    std::set<TransformDescription> dset;
+    for (TransformDescriptionMap::const_iterator i = m_transforms.begin();
 	 i != m_transforms.end(); ++i) {
 	dset.insert(i->second);
     }
 
-    TransformerList list;
-    for (std::set<TransformerDesc>::const_iterator i = dset.begin();
+    TransformList list;
+    for (std::set<TransformDescription>::const_iterator i = dset.begin();
 	 i != dset.end(); ++i) {
 	list.push_back(*i);
     }
 
     return list;
 }
 
 std::vector<QString>
 TransformerFactory::getAllTransformerTypes()
 {
-    if (m_transforms.empty()) populateTransformers();
+    if (m_transforms.empty()) populateTransforms();
 
     std::set<QString> types;
-    for (TransformerDescriptionMap::const_iterator i = m_transforms.begin();
+    for (TransformDescriptionMap::const_iterator i = m_transforms.begin();
 	 i != m_transforms.end(); ++i) {
         types.insert(i->second.type);
     }
 
     std::vector<QString> rv;

 }
 
 std::vector<QString>
 TransformerFactory::getTransformerCategories(QString transformType)
 {
-    if (m_transforms.empty()) populateTransformers();
+    if (m_transforms.empty()) populateTransforms();
 
     std::set<QString> categories;
-    for (TransformerDescriptionMap::const_iterator i = m_transforms.begin();
+    for (TransformDescriptionMap::const_iterator i = m_transforms.begin();
          i != m_transforms.end(); ++i) {
         if (i->second.type == transformType) {
             categories.insert(i->second.category);
         }
     }

 }
 
 std::vector<QString>
 TransformerFactory::getTransformerMakers(QString transformType)
 {
-    if (m_transforms.empty()) populateTransformers();
+    if (m_transforms.empty()) populateTransforms();
 
     std::set<QString> makers;
-    for (TransformerDescriptionMap::const_iterator i = m_transforms.begin();
+    for (TransformDescriptionMap::const_iterator i = m_transforms.begin();
          i != m_transforms.end(); ++i) {
         if (i->second.type == transformType) {
             makers.insert(i->second.maker);
         }
     }

 
     return rv;
 }
 
 void
-TransformerFactory::populateTransformers()
-{
-    TransformerDescriptionMap transforms;
+TransformerFactory::populateTransforms()
+{
+    TransformDescriptionMap transforms;
 
     populateFeatureExtractionPlugins(transforms);
     populateRealTimePlugins(transforms);
 
     // disambiguate plugins with similar names
 
     std::map<QString, int> names;
     std::map<QString, QString> pluginSources;
     std::map<QString, QString> pluginMakers;
 
-    for (TransformerDescriptionMap::iterator i = transforms.begin();
+    for (TransformDescriptionMap::iterator i = transforms.begin();
          i != transforms.end(); ++i) {
 
-        TransformerDesc desc = i->second;
+        TransformDescription desc = i->second;
 
         QString td = desc.name;
         QString tn = td.section(": ", 0, 0);
         QString pn = desc.identifier.section(":", 1, 1);
 

     }
 
     std::map<QString, int> counts;
     m_transforms.clear();
 
-    for (TransformerDescriptionMap::iterator i = transforms.begin();
+    for (TransformDescriptionMap::iterator i = transforms.begin();
          i != transforms.end(); ++i) {
 
-        TransformerDesc desc = i->second;
+        TransformDescription desc = i->second;
 	QString identifier = desc.identifier;
         QString maker = desc.maker;
 
         QString td = desc.name;
         QString tn = td.section(": ", 0, 0);

 	m_transforms[identifier] = desc;
     }	    
 }
 
 void
-TransformerFactory::populateFeatureExtractionPlugins(TransformerDescriptionMap &transforms)
+TransformerFactory::populateFeatureExtractionPlugins(TransformDescriptionMap &transforms)
 {
     std::vector<QString> plugs =
 	FeatureExtractionPluginFactory::getAllPluginIdentifiers();
 
     for (size_t i = 0; i < plugs.size(); ++i) {

 
 	FeatureExtractionPluginFactory *factory =
 	    FeatureExtractionPluginFactory::instanceFor(pluginId);
 
 	if (!factory) {
-	    std::cerr << "WARNING: TransformerFactory::populateTransformers: No feature extraction plugin factory for instance " << pluginId.toLocal8Bit().data() << std::endl;
+	    std::cerr << "WARNING: TransformerFactory::populateTransforms: No feature extraction plugin factory for instance " << pluginId.toLocal8Bit().data() << std::endl;
 	    continue;
 	}
 
 	Vamp::Plugin *plugin = 
 	    factory->instantiatePlugin(pluginId, 48000);
 
 	if (!plugin) {
-	    std::cerr << "WARNING: TransformerFactory::populateTransformers: Failed to instantiate plugin " << pluginId.toLocal8Bit().data() << std::endl;
+	    std::cerr << "WARNING: TransformerFactory::populateTransforms: Failed to instantiate plugin " << pluginId.toLocal8Bit().data() << std::endl;
 	    continue;
 	}
 		
 	QString pluginName = plugin->getName().c_str();
         QString category = factory->getPluginCategory(pluginId);

                                  !plugin->getParameterDescriptors().empty());
 
 //            std::cerr << "Feature extraction plugin transform: " << transformId.toStdString() << std::endl;
 
 	    transforms[transformId] = 
-                TransformerDesc(tr("Analysis"),
+                TransformDescription(tr("Analysis"),
                               category,
                               transformId,
                               userName,
                               friendlyName,
                               description,

         delete plugin;
     }
 }
 
 void
-TransformerFactory::populateRealTimePlugins(TransformerDescriptionMap &transforms)
+TransformerFactory::populateRealTimePlugins(TransformDescriptionMap &transforms)
 {
     std::vector<QString> plugs =
 	RealTimePluginFactory::getAllPluginIdentifiers();
 
     static QRegExp unitRE("[\\[\\(]([A-Za-z0-9/]+)[\\)\\]]$");

 
         RealTimePluginFactory *factory =
             RealTimePluginFactory::instanceFor(pluginId);
 
 	if (!factory) {
-	    std::cerr << "WARNING: TransformerFactory::populateTransformers: No real time plugin factory for instance " << pluginId.toLocal8Bit().data() << std::endl;
+	    std::cerr << "WARNING: TransformerFactory::populateTransforms: No real time plugin factory for instance " << pluginId.toLocal8Bit().data() << std::endl;
 	    continue;
 	}
 
         const RealTimePluginDescriptor *descriptor =
             factory->getPluginDescriptor(pluginId);
 
         if (!descriptor) {
-	    std::cerr << "WARNING: TransformerFactory::populateTransformers: Failed to query plugin " << pluginId.toLocal8Bit().data() << std::endl;
+	    std::cerr << "WARNING: TransformerFactory::populateTransforms: Failed to query plugin " << pluginId.toLocal8Bit().data() << std::endl;
 	    continue;
 	}
 	
 //!!!        if (descriptor->controlOutputPortCount == 0 ||
 //            descriptor->audioInputPortCount == 0) continue;

                         .arg(pluginName)
                         .arg(maker);
                 }
 
                 transforms[transformId] = 
-                    TransformerDesc(tr("Effects Data"),
+                    TransformDescription(tr("Effects Data"),
                                   category,
                                   transformId,
                                   userName,
                                   userName,
                                   description,

                         .arg(pluginName)
                         .arg(maker);
                 }
 
                 transforms[transformId] =
-                    TransformerDesc(type,
+                    TransformDescription(type,
                                   category,
                                   transformId,
                                   pluginName,
                                   pluginName,
                                   description,

         }
     }
 }
 
 bool
-TransformerFactory::haveTransformer(TransformerId identifier)
+TransformerFactory::haveTransformer(TransformId identifier)
 {
     return (m_transforms.find(identifier) != m_transforms.end());
 }
 
 QString
-TransformerFactory::getTransformerName(TransformerId identifier)
+TransformerFactory::getTransformerName(TransformId identifier)
 {
     if (m_transforms.find(identifier) != m_transforms.end()) {
 	return m_transforms[identifier].name;
     } else return "";
 }
 
 QString
-TransformerFactory::getTransformerFriendlyName(TransformerId identifier)
+TransformerFactory::getTransformerFriendlyName(TransformId identifier)
 {
     if (m_transforms.find(identifier) != m_transforms.end()) {
 	return m_transforms[identifier].friendlyName;
     } else return "";
 }
 
 QString
-TransformerFactory::getTransformerUnits(TransformerId identifier)
+TransformerFactory::getTransformerUnits(TransformId identifier)
 {
     if (m_transforms.find(identifier) != m_transforms.end()) {
 	return m_transforms[identifier].units;
     } else return "";
 }
 
 bool
-TransformerFactory::isTransformerConfigurable(TransformerId identifier)
+TransformerFactory::isTransformerConfigurable(TransformId identifier)
 {
     if (m_transforms.find(identifier) != m_transforms.end()) {
 	return m_transforms[identifier].configurable;
     } else return false;
 }
 
 bool
-TransformerFactory::getTransformerChannelRange(TransformerId identifier,
+TransformerFactory::getTransformerChannelRange(TransformId identifier,
                                            int &min, int &max)
 {
     QString id = identifier.section(':', 0, 2);
 
     if (FeatureExtractionPluginFactory::instanceFor(id)) {

 
     return false;
 }
 
 bool
-TransformerFactory::getChannelRange(TransformerId identifier, Vamp::PluginBase *plugin,
+TransformerFactory::getChannelRange(TransformId identifier, Vamp::PluginBase *plugin,
                                   int &minChannels, int &maxChannels)
 {
     Vamp::Plugin *vp = 0;
     if ((vp = dynamic_cast<Vamp::Plugin *>(plugin)) ||
         (vp = dynamic_cast<Vamp::PluginHostAdapter *>(plugin))) {

         return getTransformerChannelRange(identifier, minChannels, maxChannels);
     }
 }
 
 Model *
-TransformerFactory::getConfigurationForTransformer(TransformerId identifier,
+TransformerFactory::getConfigurationForTransformer(TransformId identifier,
                                                const std::vector<Model *> &candidateInputModels,
                                                PluginTransformer::ExecutionContext &context,
                                                QString &configurationXml,
                                                AudioCallbackPlaySource *source,
                                                size_t startFrame,

 
     return ok ? inputModel : 0;
 }
 
 PluginTransformer::ExecutionContext
-TransformerFactory::getDefaultContextForTransformer(TransformerId identifier,
+TransformerFactory::getDefaultContextForTransformer(TransformId identifier,
                                                 Model *inputModel)
 {
     PluginTransformer::ExecutionContext context(-1);
 
     QString id = identifier.section(':', 0, 2);

 
     return context;
 }
 
 Transformer *
-TransformerFactory::createTransformer(TransformerId identifier, Model *inputModel,
+TransformerFactory::createTransformer(TransformId identifier, Model *inputModel,
                                   const PluginTransformer::ExecutionContext &context,
                                   QString configurationXml)
 {
     Transformer *transform = 0;
 

     if (transform) transform->setObjectName(identifier);
     return transform;
 }
 
 Model *
-TransformerFactory::transform(TransformerId identifier, Model *inputModel,
+TransformerFactory::transform(TransformId identifier, Model *inputModel,
                             const PluginTransformer::ExecutionContext &context,
                             QString configurationXml)
 {
     Transformer *t = createTransformer(identifier, inputModel, context,
                                    configurationXml);