comparison audioio/AudioCallbackPlaySource.cpp @ 62:ae2627ac7db2

* Add support for Rubber Band timestretcher

 #include "base/Preferences.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/WaveFileModel.h"
 #include "data/model/SparseOneDimensionalModel.h"
 #include "plugin/RealTimePluginInstance.h"
+
+#ifdef HAVE_RUBBERBAND
+#include <rubberband/RubberBandStretcher.h>
+using namespace RubberBand;
+#else
 #include "PhaseVocoderTimeStretcher.h"
+#endif
 
 #include <iostream>
 #include <cassert>
 
 //#define DEBUG_AUDIO_PLAY_SOURCE 1

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

     }
 
     size_t latency = m_playLatency;
     if (resample) latency = size_t(m_playLatency * ratio + 0.1);
 
+#ifdef HAVE_RUBBERBAND
+    if (m_timeStretcher) {
+        latency += m_timeStretcher->getLatency();
+    }
+#else
     PhaseVocoderTimeStretcher *timeStretcher = m_timeStretcher;
     if (timeStretcher) {
 	latency += timeStretcher->getProcessingLatency();
     }
+#endif
 
     latency += readSpace;
     size_t bufferedFrame = m_readBufferFill;
 
     bool looping = m_viewManager->getPlayLoopMode();

 }
 
 void
 AudioCallbackPlaySource::setTimeStretch(float factor, bool sharpen, bool mono)
 {
+#ifdef HAVE_RUBBERBAND
+    if (m_timeStretcher) {
+        m_timeStretchRatioMutex.lock();
+        m_timeStretcher->setTimeRatio(factor);
+        m_timeStretchRatioMutex.unlock();
+        return;
+    } else {
+        RubberBandStretcher *stretcher = new RubberBandStretcher
+            (getTargetSampleRate(),
+             getTargetChannelCount(),
+             RubberBandStretcher::OptionProcessRealTime,
+             factor);
+        m_timeStretcher = stretcher;
+        return;
+    }
+#else
     // Avoid locks -- create, assign, mark old one for scavenging
     // later (as a call to getSourceSamples may still be using it)
 
     PhaseVocoderTimeStretcher *existingStretcher = m_timeStretcher;
 

     }
 
     if (existingStretcher) {
 	m_timeStretcherScavenger.claim(existingStretcher);
     }
+#endif
 }
 
 size_t
 AudioCallbackPlaySource::getSourceSamples(size_t count, float **buffer)
 {

         }
     }
 
     if (count == 0) return 0;
 
+#ifdef HAVE_RUBBERBAND
+    RubberBandStretcher *ts = m_timeStretcher;
+    float ratio = ts ? ts->getTimeRatio() : 1.f;
+#else
     PhaseVocoderTimeStretcher *ts = m_timeStretcher;
-
-    if (!ts || ts->getRatio() == 1) {
+    float ratio = ts ? ts->getRatio() : 1.f;
+#endif
+
+    if (!ts || ratio == 1.f) {
 
 	size_t got = 0;
 
 	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
 

 
         m_condition.wakeAll();
 	return got;
     }
 
-    float ratio = ts->getRatio();
-
-//            std::cout << "ratio = " << ratio << std::endl;
-
     size_t channels = getTargetChannelCount();
+
+#ifdef HAVE_RUBBERBAND
+    bool mix = false;
+#else
     bool mix = (channels > 1 && ts->getChannelCount() == 1);
+#endif
 
     size_t available;
 
     int warned = 0;
 

     // output is approx output / ratio, but we can't predict it
     // exactly, for an adaptive timestretcher.  The stretcher will
     // need some additional buffer space.  See the time stretcher code
     // and comments.
 
+#ifdef HAVE_RUBBERBAND
+    m_timeStretchRatioMutex.lock();
+    while ((available = ts->available()) < count) {
+#else
     while ((available = ts->getAvailableOutputSamples()) < count) {
+#endif
 
         size_t reqd = lrintf((count - available) / ratio);
+#ifdef HAVE_RUBBERBAND
+        reqd = std::max(reqd, ts->getSamplesRequired());
+#else
         reqd = std::max(reqd, ts->getRequiredInputSamples());
+#endif
         if (reqd == 0) reqd = 1;
                 
         float *ib[channels];
 
         size_t got = reqd;

         if (got < reqd) {
             std::cerr << "WARNING: Read underrun in playback ("
                       << got << " < " << reqd << ")" << std::endl;
         }
                 
+#ifdef HAVE_RUBBERBAND
+        ts->process(ib, got, false);
+#else
         ts->putInput(ib, got);
+#endif
 
         for (size_t c = 0; c < channels; ++c) {
             delete[] ib[c];
         }
 
         if (got == 0) break;
 
+#ifdef HAVE_RUBBERBAND
+        if (ts->available() == available) {
+#else
         if (ts->getAvailableOutputSamples() == available) {
+#endif
             std::cerr << "WARNING: AudioCallbackPlaySource::getSamples: Added " << got << " samples to time stretcher, created no new available output samples (warned = " << warned << ")" << std::endl;
             if (++warned == 5) break;
         }
     }
 
+#ifdef HAVE_RUBBERBAND
+    ts->retrieve(buffer, count);
+    m_timeStretchRatioMutex.unlock();
+#else
     ts->getOutput(buffer, count);
+#endif
 
     if (mix) {
         for (size_t c = 1; c < channels; ++c) {
             for (size_t i = 0; i < count; ++i) {
                 buffer[c][i] = buffer[0][i] / channels;

 	data.src_ratio = ratio;
 	data.end_of_input = 0;
 	
 	int err = 0;
 
+#ifdef HAVE_RUBBERBAND
+        if (m_timeStretcher && m_timeStretcher->getTimeRatio() < 0.4) {
+#else
         if (m_timeStretcher && m_timeStretcher->getRatio() < 0.4) {
+#endif
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
             std::cout << "Using crappy converter" << std::endl;
 #endif
             err = src_process(m_crapConverter, &data);
         } else {

     while (!s.m_exiting) {
 
 	s.unifyRingBuffers();
 	s.m_bufferScavenger.scavenge();
         s.m_pluginScavenger.scavenge();
+#ifndef HAVE_RUBBERBAND
 	s.m_timeStretcherScavenger.scavenge();
+#endif
 
 	if (work && s.m_playing && s.getSourceSampleRate()) {
 	    
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	    std::cout << "AudioCallbackPlaySourceFillThread: not waiting" << std::endl;