comparison transform/RealTimePluginTransform.cpp @ 27:61259228d029

* More to do with passing around step/blocksize etc from plugin dialog to
  plugins.  Still some puzzling unresolved details.

 
 #include <iostream>
 
 RealTimePluginTransform::RealTimePluginTransform(Model *inputModel,
                                                  QString pluginId,
-                                                 int channel,
+                                                 const ExecutionContext &context,
                                                  QString configurationXml,
                                                  QString units,
-                                                 int output,
-                                                 size_t blockSize) :
-    Transform(inputModel),
+                                                 int output) :
+    PluginTransform(inputModel, context),
     m_plugin(0),
-    m_channel(channel),
-    m_outputNo(output),
-    m_blockSize(blockSize)
+    m_outputNo(output)
 {
-    if (!m_blockSize) m_blockSize = 1024;
+    if (!m_context.blockSize) m_context.blockSize = 1024;
 
     std::cerr << "RealTimePluginTransform::RealTimePluginTransform: plugin " << pluginId.toStdString() << ", output " << output << std::endl;
 
     RealTimePluginFactory *factory =
 	RealTimePluginFactory::instanceFor(pluginId);

 
     DenseTimeValueModel *input = getInput();
     if (!input) return;
 
     m_plugin = factory->instantiatePlugin(pluginId, 0, 0, m_input->getSampleRate(),
-                                          m_blockSize,
+                                          m_context.blockSize,
                                           input->getChannelCount());
 
     if (!m_plugin) {
 	std::cerr << "RealTimePluginTransform: Failed to instantiate plugin \""
 		  << pluginId.toStdString() << "\"" << std::endl;

         std::cerr << "RealTimePluginTransform: Plugin has fewer than desired " << m_outputNo << " control outputs" << std::endl;
         return;
     }
 	
     SparseTimeValueModel *model = new SparseTimeValueModel
-        (input->getSampleRate(), m_blockSize, 0.0, 0.0, false);
+        (input->getSampleRate(), m_context.blockSize, 0.0, 0.0, false);
 
     if (units != "") model->setScaleUnits(units);
 
     m_output = model;
 }

 
     if (m_outputNo >= m_plugin->getControlOutputCount()) return;
 
     size_t sampleRate = input->getSampleRate();
     int channelCount = input->getChannelCount();
-    if (m_channel != -1) channelCount = 1;
+    if (m_context.channel != -1) channelCount = 1;
 
     size_t blockSize = m_plugin->getBufferSize();
 
     float **buffers = m_plugin->getAudioInputBuffers();
 

 
 	size_t got = 0;
 
 	if (channelCount == 1) {
 	    got = input->getValues
-		(m_channel, blockFrame, blockFrame + blockSize, buffers[0]);
+		(m_context.channel, blockFrame, blockFrame + blockSize, buffers[0]);
 	    while (got < blockSize) {
 		buffers[0][got++] = 0.0;
 	    }
-            if (m_channel == -1 && channelCount > 1) {
+            if (m_context.channel == -1 && channelCount > 1) {
                 // use mean instead of sum, as plugin input
                 for (size_t i = 0; i < got; ++i) {
                     buffers[0][i] /= channelCount;
                 }
             }