comparison transform/TransformFactory.cpp @ 53:94f1c2747de4

* Tidy up plugin parameter dialog by switching it to a simple constructor
  with separate methods for passing in the additional options if necessary
* Fix sizing problem on advanced pane toggle in plugin parameter dialog
* Make a start on passing in list of candidate input models for transform

     } else {
         return getTransformChannelRange(name, minChannels, maxChannels);
     }
 }
 
-bool
+Model *
 TransformFactory::getConfigurationForTransform(TransformName name,
-                                               Model *inputModel,
+                                               const std::vector<Model *> &candidateInputModels,
                                                PluginTransform::ExecutionContext &context,
                                                QString &configurationXml,
                                                AudioCallbackPlaySource *source)
 {
+    if (candidateInputModels.empty()) return 0;
+
+    Model *inputModel = candidateInputModels[0]; //!!! for now
+
     QString id = name.section(':', 0, 2);
     QString output = name.section(':', 3);
+    QString outputLabel = "";
     
     bool ok = false;
     configurationXml = m_lastConfigurations[name];
 
 //    std::cerr << "last configuration: " << configurationXml.toStdString() << std::endl;

     if (FeatureExtractionPluginFactory::instanceFor(id)) {
 
         Vamp::Plugin *vp =
             FeatureExtractionPluginFactory::instanceFor(id)->instantiatePlugin
             (id, inputModel->getSampleRate());
+
         if (vp) {
+
             plugin = vp;
             frequency = (vp->getInputDomain() == Vamp::Plugin::FrequencyDomain);
+
+            std::vector<Vamp::Plugin::OutputDescriptor> od =
+                vp->getOutputDescriptors();
+            if (od.size() > 1) {
+                for (size_t i = 0; i < od.size(); ++i) {
+                    if (od[i].name == output.toStdString()) {
+                        outputLabel = od[i].description.c_str();
+                        break;
+                    }
+                }
+            }
         }
 
     } else if (RealTimePluginFactory::instanceFor(id)) {
 
         RealTimePluginFactory *factory = RealTimePluginFactory::instanceFor(id);

 
         if (desc->audioInputPortCount > 0 && 
             desc->audioOutputPortCount > 0 &&
             !desc->isSynth) {
             effect = true;
+        }
+
+        if (output != "A") {
+            int outputNo = output.toInt();
+            if (outputNo >= 0 && outputNo < desc->controlOutputPortCount) {
+                outputLabel = desc->controlOutputPortNames[outputNo].c_str();
+            }
         }
 
         size_t sampleRate = inputModel->getSampleRate();
         size_t blockSize = 1024;
         size_t channels = 1;

             if (sourceChannels > maxChannels) targetChannels = maxChannels;
         }
 
         int defaultChannel = context.channel;
 
-        PluginParameterDialog *dialog = new PluginParameterDialog(plugin,
-                                                                  sourceChannels,
-                                                                  targetChannels,
-                                                                  defaultChannel,
-                                                                  output,
-                                                                  true,
-                                                                  frequency);
+        PluginParameterDialog *dialog = new PluginParameterDialog(plugin);
+
+        dialog->setChannelArrangement(sourceChannels, targetChannels,
+                                      defaultChannel);
+        
+        dialog->setOutputLabel(outputLabel);
+        
+        dialog->setShowProcessingOptions(true, frequency);
+
         if (dialog->exec() == QDialog::Accepted) {
             ok = true;
         }
 
         configurationXml = PluginXml(plugin).toXmlString();

         }
     }
 
     if (ok) m_lastConfigurations[name] = configurationXml;
 
-    return ok;
+    return ok ? inputModel : 0;
 }
 
 Transform *
 TransformFactory::createTransform(TransformName name, Model *inputModel,
                                   const PluginTransform::ExecutionContext &context,