comparison vamp-sdk/hostext/PluginChannelAdapter.cpp @ 197:fe30a25ee4f8

* Add processInterleaved to PluginChannelAdapter

     ~Impl();
 
     bool initialise(size_t channels, size_t stepSize, size_t blockSize);
 
     FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+    FeatureSet processInterleaved(const float *inputBuffers, RealTime timestamp);
 
 protected:
     Plugin *m_plugin;
     size_t m_blockSize;
     size_t m_inputChannels;
     size_t m_pluginChannels;
     float **m_buffer;
+    float **m_deinterleave;
     const float **m_forwardPtrs;
 };
 
 PluginChannelAdapter::PluginChannelAdapter(Plugin *plugin) :
     PluginWrapper(plugin)

 PluginChannelAdapter::FeatureSet
 PluginChannelAdapter::process(const float *const *inputBuffers,
                               RealTime timestamp)
 {
     return m_impl->process(inputBuffers, timestamp);
+}
+
+PluginChannelAdapter::FeatureSet
+PluginChannelAdapter::processInterleaved(const float *inputBuffers,
+                                         RealTime timestamp)
+{
+    return m_impl->processInterleaved(inputBuffers, timestamp);
 }
 
 PluginChannelAdapter::Impl::Impl(Plugin *plugin) :
     m_plugin(plugin),
     m_blockSize(0),
     m_inputChannels(0),
     m_pluginChannels(0),
     m_buffer(0),
+    m_deinterleave(0),
     m_forwardPtrs(0)
 {
 }
 
 PluginChannelAdapter::Impl::~Impl()

                 delete[] m_buffer[i];
             }
         }
         delete[] m_buffer;
         m_buffer = 0;
+    }
+
+    if (m_deinterleave) {
+        for (size_t i = 0; i < m_inputChannels; ++i) {
+            delete[] m_deinterleave[i];
+        }
+        delete[] m_deinterleave;
+        m_deinterleave = 0;
     }
 
     if (m_forwardPtrs) {
         delete[] m_forwardPtrs;
         m_forwardPtrs = 0;

 
     return m_plugin->initialise(m_pluginChannels, stepSize, blockSize);
 }
 
 PluginChannelAdapter::FeatureSet
+PluginChannelAdapter::Impl::processInterleaved(const float *inputBuffers,
+                                               RealTime timestamp)
+{
+    if (!m_deinterleave) {
+        m_deinterleave = new float *[m_inputChannels];
+        for (size_t i = 0; i < m_inputChannels; ++i) {
+            m_deinterleave[i] = new float[m_blockSize];
+        }
+    }
+
+    for (size_t i = 0; i < m_inputChannels; ++i) {
+        for (size_t j = 0; j < m_blockSize; ++j) {
+            m_deinterleave[i][j] = inputBuffers[j * m_inputChannels + i];
+        }
+    }
+
+    return process(m_deinterleave, timestamp);
+}
+
+PluginChannelAdapter::FeatureSet
 PluginChannelAdapter::Impl::process(const float *const *inputBuffers,
                                     RealTime timestamp)
 {
 //    std::cerr << "PluginChannelAdapter::process: " << m_inputChannels << " -> " << m_pluginChannels << " channels" << std::endl;