comparison audioio/AudioCallbackPlaySource.cpp @ 41:fbd7a497fd89

* Audition effects plugins during playback

 #include "view/ViewManager.h"
 #include "base/PlayParameterRepository.h"
 #include "base/Preferences.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/SparseOneDimensionalModel.h"
+#include "plugin/RealTimePluginInstance.h"
 #include "PhaseVocoderTimeStretcher.h"
 
 #include <iostream>
 #include <cassert>
 

     m_playing(false),
     m_exiting(false),
     m_lastModelEndFrame(0),
     m_outputLeft(0.0),
     m_outputRight(0.0),
+    m_auditioningPlugin(0),
     m_timeStretcher(0),
     m_fillThread(0),
     m_converter(0),
     m_crapConverter(0),
     m_resampleQuality(Preferences::getInstance()->getResampleQuality())

     delete m_writeBuffers;
 
     delete m_audioGenerator;
 
     m_bufferScavenger.scavenge(true);
+    m_pluginScavenger.scavenge(true);
+    m_timeStretcherScavenger.scavenge(true);
 }
 
 void
 AudioCallbackPlaySource::addModel(Model *model)
 {

 #endif
 
     initialiseConverter();
 }
 
+void
+AudioCallbackPlaySource::setAuditioningPlugin(RealTimePluginInstance *plugin)
+{
+    RealTimePluginInstance *formerPlugin = m_auditioningPlugin;
+    m_auditioningPlugin = plugin;
+    if (formerPlugin) m_pluginScavenger.claim(formerPlugin);
+}
+
 size_t
 AudioCallbackPlaySource::getTargetSampleRate() const
 {
     if (m_targetSampleRate) return m_targetSampleRate;
     else return getSourceSampleRate();

 		for (size_t i = got; i < count; ++i) {
 		    buffer[ch][i] = 0.0;
 		}
 	    }
 	}
+
+        applyAuditioningEffect(count, buffer);
 
         m_condition.wakeAll();
 	return got;
     }
 

         for (size_t i = 0; i < count; ++i) {
             buffer[0][i] /= channels;
         }
     }
 
+    applyAuditioningEffect(count, buffer);
+
     m_condition.wakeAll();
 
     return count;
 }
+
+void
+AudioCallbackPlaySource::applyAuditioningEffect(size_t count, float **buffers)
+{
+    RealTimePluginInstance *plugin = m_auditioningPlugin;
+    if (!plugin) return;
+
+    if (plugin->getAudioInputCount() != getTargetChannelCount()) {
+        std::cerr << "plugin input count " << plugin->getAudioInputCount() 
+                  << " != our channel count " << getTargetChannelCount()
+                  << std::endl;
+        return;
+    }
+    if (plugin->getAudioOutputCount() != getTargetChannelCount()) {
+        std::cerr << "plugin output count " << plugin->getAudioOutputCount() 
+                  << " != our channel count " << getTargetChannelCount()
+                  << std::endl;
+        return;
+    }
+    if (plugin->getBufferSize() != count) {
+        std::cerr << "plugin buffer size " << plugin->getBufferSize() 
+                  << " != our block size " << count
+                  << std::endl;
+        return;
+    }
+
+    float **ib = plugin->getAudioInputBuffers();
+    float **ob = plugin->getAudioOutputBuffers();
+
+    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+        for (size_t i = 0; i < count; ++i) {
+            ib[c][i] = buffers[c][i];
+        }
+    }
+
+    plugin->run(Vamp::RealTime::zeroTime);
+    
+    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+        for (size_t i = 0; i < count; ++i) {
+            buffers[c][i] = ob[c][i];
+        }
+    }
+}    
 
 // Called from fill thread, m_playing true, mutex held
 bool
 AudioCallbackPlaySource::fillBuffers()
 {

 
     while (!s.m_exiting) {
 
 	s.unifyRingBuffers();
 	s.m_bufferScavenger.scavenge();
+        s.m_pluginScavenger.scavenge();
 	s.m_timeStretcherScavenger.scavenge();
 
 	if (work && s.m_playing && s.getSourceSampleRate()) {
 	    
 #ifdef DEBUG_AUDIO_PLAY_SOURCE