comparison plugin/transform/RealTimeEffectModelTransformer.cpp @ 350:d7c41483af8f

* Merge from transforms branch -- switch over to using Transform object
  properly

 #include "data/model/SparseTimeValueModel.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/WritableWaveFileModel.h"
 #include "data/model/WaveFileModel.h"
 
+#include "TransformFactory.h"
+
 #include <iostream>
 
-RealTimeEffectModelTransformer::RealTimeEffectModelTransformer(Model *inputModel,
-                                                               QString pluginId,
-                                                               const ExecutionContext &context,
-                                                               QString configurationXml,
-                                                               QString units,
-                                                               int output) :
-    PluginTransformer(inputModel, context),
-    m_pluginId(pluginId),
-    m_configurationXml(configurationXml),
-    m_units(units),
-    m_plugin(0),
-    m_outputNo(output)
-{
-    if (!m_context.blockSize) m_context.blockSize = 1024;
+RealTimeEffectModelTransformer::RealTimeEffectModelTransformer(Input in,
+                                                               const Transform &transform) :
+    ModelTransformer(in, transform),
+    m_plugin(0)
+{
+    m_units = TransformFactory::getInstance()->getTransformUnits
+        (transform.getIdentifier());
+    m_outputNo =
+        (transform.getOutput() == "A") ? -1 : transform.getOutput().toInt();
+
+    QString pluginId = transform.getPluginIdentifier();
+
+    if (!m_transform.getBlockSize()) m_transform.setBlockSize(1024);
 
 //    std::cerr << "RealTimeEffectModelTransformer::RealTimeEffectModelTransformer: plugin " << pluginId.toStdString() << ", output " << output << std::endl;
 
     RealTimePluginFactory *factory =
 	RealTimePluginFactory::instanceFor(pluginId);

 	std::cerr << "RealTimeEffectModelTransformer: No factory available for plugin id \""
 		  << pluginId.toStdString() << "\"" << std::endl;
 	return;
     }
 
-    DenseTimeValueModel *input = getInput();
+    DenseTimeValueModel *input = getConformingInput();
     if (!input) return;
 
     m_plugin = factory->instantiatePlugin(pluginId, 0, 0,
-                                          m_input->getSampleRate(),
-                                          m_context.blockSize,
+                                          input->getSampleRate(),
+                                          m_transform.getBlockSize(),
                                           input->getChannelCount());
 
     if (!m_plugin) {
 	std::cerr << "RealTimeEffectModelTransformer: Failed to instantiate plugin \""
 		  << pluginId.toStdString() << "\"" << std::endl;
 	return;
     }
 
-    if (configurationXml != "") {
-        PluginXml(m_plugin).setParametersFromXml(configurationXml);
-    }
+    TransformFactory::getInstance()->setPluginParameters(m_transform, m_plugin);
 
     if (m_outputNo >= 0 &&
         m_outputNo >= int(m_plugin->getControlOutputCount())) {
         std::cerr << "RealTimeEffectModelTransformer: Plugin has fewer than desired " << m_outputNo << " control outputs" << std::endl;
         return;

         m_output = model;
 
     } else {
 	
         SparseTimeValueModel *model = new SparseTimeValueModel
-            (input->getSampleRate(), m_context.blockSize, 0.0, 0.0, false);
-
-        if (units != "") model->setScaleUnits(units);
+            (input->getSampleRate(), m_transform.getBlockSize(), 0.0, 0.0, false);
+
+        if (m_units != "") model->setScaleUnits(m_units);
 
         m_output = model;
     }
 }
 

 {
     delete m_plugin;
 }
 
 DenseTimeValueModel *
-RealTimeEffectModelTransformer::getInput()
+RealTimeEffectModelTransformer::getConformingInput()
 {
     DenseTimeValueModel *dtvm =
 	dynamic_cast<DenseTimeValueModel *>(getInputModel());
     if (!dtvm) {
-	std::cerr << "RealTimeEffectModelTransformer::getInput: WARNING: Input model is not conformable to DenseTimeValueModel" << std::endl;
+	std::cerr << "RealTimeEffectModelTransformer::getConformingInput: WARNING: Input model is not conformable to DenseTimeValueModel" << std::endl;
     }
     return dtvm;
 }
 
 void
 RealTimeEffectModelTransformer::run()
 {
-    DenseTimeValueModel *input = getInput();
+    DenseTimeValueModel *input = getConformingInput();
     if (!input) return;
 
     while (!input->isReady()) {
         if (dynamic_cast<WaveFileModel *>(input)) break; // no need to wait
         std::cerr << "RealTimeEffectModelTransformer::run: Waiting for input model to be ready..." << std::endl;

 
     if (stvm && (m_outputNo >= int(m_plugin->getControlOutputCount()))) return;
 
     size_t sampleRate = input->getSampleRate();
     size_t channelCount = input->getChannelCount();
-    if (!wwfm && m_context.channel != -1) channelCount = 1;
+    if (!wwfm && m_input.getChannel() != -1) channelCount = 1;
 
     long blockSize = m_plugin->getBufferSize();
 
     float **inbufs = m_plugin->getAudioInputBuffers();
 
-    long startFrame = m_input->getStartFrame();
-    long   endFrame = m_input->getEndFrame();
+    long startFrame = m_input.getModel()->getStartFrame();
+    long   endFrame = m_input.getModel()->getEndFrame();
     
-    long contextStart = m_context.startFrame;
-    long contextDuration = m_context.duration;
+    RealTime contextStartRT = m_transform.getStartTime();
+    RealTime contextDurationRT = m_transform.getDuration();
+
+    long contextStart =
+        RealTime::realTime2Frame(contextStartRT, sampleRate);
+
+    long contextDuration =
+        RealTime::realTime2Frame(contextDurationRT, sampleRate);
 
     if (contextStart == 0 || contextStart < startFrame) {
         contextStart = startFrame;
     }
 

 	long got = 0;
 
 	if (channelCount == 1) {
             if (inbufs && inbufs[0]) {
                 got = input->getData
-                    (m_context.channel, blockFrame, blockSize, inbufs[0]);
+                    (m_input.getChannel(), blockFrame, blockSize, inbufs[0]);
                 while (got < blockSize) {
                     inbufs[0][got++] = 0.0;
                 }          
             }
             for (size_t ch = 1; ch < m_plugin->getAudioInputCount(); ++ch) {