comparison transform/RealTimePluginTransform.cpp @ 39:f18093617b78

* Introduce WritableWaveFileModel, and use it as an output model for audio
  real-time plugin transforms.  Updates aren't working correctly yet.

 #include "plugin/PluginXml.h"
 
 #include "data/model/Model.h"
 #include "data/model/SparseTimeValueModel.h"
 #include "data/model/DenseTimeValueModel.h"
+#include "data/model/WritableWaveFileModel.h"
 
 #include <iostream>
 
 RealTimePluginTransform::RealTimePluginTransform(Model *inputModel,
                                                  QString pluginId,

         return;
     }
 
     if (m_outputNo == -1) {
 
-        //!!! process audio!
+        WritableWaveFileModel *model = new WritableWaveFileModel
+            (input->getSampleRate(), input->getChannelCount()); //!!!
+
+        m_output = model;
 
     } else {
 	
         SparseTimeValueModel *model = new SparseTimeValueModel
             (input->getSampleRate(), m_context.blockSize, 0.0, 0.0, false);

 RealTimePluginTransform::run()
 {
     DenseTimeValueModel *input = getInput();
     if (!input) return;
 
-    SparseTimeValueModel *model = dynamic_cast<SparseTimeValueModel *>(m_output);
-    if (!model) return;
-
-    if (m_outputNo >= m_plugin->getControlOutputCount()) return;
+    SparseTimeValueModel *stvm = dynamic_cast<SparseTimeValueModel *>(m_output);
+    WritableWaveFileModel *wwfm = dynamic_cast<WritableWaveFileModel *>(m_output);
+    if (!stvm && !wwfm) return;
+
+    if (stvm && (m_outputNo >= m_plugin->getControlOutputCount())) return;
 
     size_t sampleRate = input->getSampleRate();
     int channelCount = input->getChannelCount();
     if (m_context.channel != -1) channelCount = 1;
 

     size_t startFrame = m_input->getStartFrame();
     size_t   endFrame = m_input->getEndFrame();
     size_t blockFrame = startFrame;
 
     size_t prevCompletion = 0;
+
+    size_t latency = m_plugin->getLatency();
 
     int i = 0;
 
     while (blockFrame < endFrame) {
 

 	    }
 	}
 
         m_plugin->run(Vamp::RealTime::frame2RealTime(blockFrame, sampleRate));
 
-        float value = m_plugin->getControlOutputValue(m_outputNo);
-
-	model->addPoint(SparseTimeValueModel::Point
-                        (blockFrame - m_plugin->getLatency(), value, ""));
+        if (stvm) {
+
+            float value = m_plugin->getControlOutputValue(m_outputNo);
+
+            size_t pointFrame = blockFrame;
+            if (pointFrame > latency) pointFrame -= latency;
+            else pointFrame = 0;
+
+            stvm->addPoint(SparseTimeValueModel::Point
+                           (pointFrame, value, ""));
+
+        } else if (wwfm) {
+
+            float **buffers = m_plugin->getAudioOutputBuffers();
+
+            if (blockFrame >= latency) {
+                wwfm->addSamples(buffers, blockSize);
+            } else if (blockFrame + blockSize >= latency) {
+                size_t offset = latency - blockFrame;
+                size_t count = blockSize - offset;
+                float **tmp = new float *[channelCount];
+                for (size_t c = 0; c < channelCount; ++c) {
+                    tmp[c] = buffers[c] + offset;
+                }
+                wwfm->addSamples(tmp, count);
+                delete[] tmp;
+            }
+        }
 
 	if (blockFrame == startFrame || completion > prevCompletion) {
-	    model->setCompletion(completion);
+	    if (stvm) stvm->setCompletion(completion);
 	    prevCompletion = completion;
 	}
         
 	blockFrame += blockSize;
     }
     
-    model->setCompletion(100);
-}
-
+    if (stvm) stvm->setCompletion(100);
+    if (wwfm) wwfm->sync();
+}
+