comparison audioio/AudioCallbackPlaySource.cpp @ 130:4c9c04645685

* Reduce time stretcher to one channel when overload occurs

     m_auditioningPlugin(0),
     m_auditioningPluginBypassed(false),
     m_playStartFrame(0),
     m_playStartFramePassed(false),
     m_timeStretcher(0),
+    m_monoStretcher(0),
     m_stretchRatio(1.0),
     m_stretcherInputCount(0),
     m_stretcherInputs(0),
     m_stretcherInputSizes(0),
     m_fillThread(0),

     for (size_t i = 0; i < m_stretcherInputCount; ++i) {
         delete[] m_stretcherInputs[i];
     }
     delete[] m_stretcherInputSizes;
     delete[] m_stretcherInputs;
+
+    delete m_timeStretcher;
+    delete m_monoStretcher;
 
     m_bufferScavenger.scavenge(true);
     m_pluginScavenger.scavenge(true);
 }
 

     m_mutex.lock();
 
     if (m_timeStretcher) {
         m_timeStretcher->reset();
     }
+    if (m_monoStretcher) {
+        m_monoStretcher->reset();
+    }
 
     m_readBufferFill = m_writeBufferFill = startFrame;
     if (m_readBuffers) {
         for (size_t c = 0; c < getTargetChannelCount(); ++c) {
             RingBuffer<float> *rb = getReadRingBuffer(c);

 }
 
 void
 AudioCallbackPlaySource::audioProcessingOverload()
 {
+    std::cerr << "Audio processing overload!" << std::endl;
+
+    if (!m_playing) return;
+
     RealTimePluginInstance *ap = m_auditioningPlugin;
-    if (ap && m_playing && !m_auditioningPluginBypassed) {
+    if (ap && !m_auditioningPluginBypassed) {
         m_auditioningPluginBypassed = true;
         emit audioOverloadPluginDisabled();
+        return;
+    }
+
+    if (m_timeStretcher &&
+        m_timeStretcher->getTimeRatio() < 1.0 &&
+        m_stretcherInputCount > 1 &&
+        m_monoStretcher && !m_stretchMono) {
+        m_stretchMono = true;
+        emit audioTimeStretchMultiChannelDisabled();
+        return;
     }
 }
 
 void
 AudioCallbackPlaySource::setTarget(AudioCallbackPlayTarget *target, size_t size)

         RubberBandStretcher *stretcher = new RubberBandStretcher
             (getTargetSampleRate(),
              m_stretcherInputCount,
              RubberBandStretcher::OptionProcessRealTime,
              factor);
+        RubberBandStretcher *monoStretcher = new RubberBandStretcher
+            (getTargetSampleRate(),
+             1,
+             RubberBandStretcher::OptionProcessRealTime,
+             factor);
         m_stretcherInputs = new float *[m_stretcherInputCount];
         m_stretcherInputSizes = new size_t[m_stretcherInputCount];
         for (size_t c = 0; c < m_stretcherInputCount; ++c) {
             m_stretcherInputSizes[c] = 16384;
             m_stretcherInputs[c] = new float[m_stretcherInputSizes[c]];
         }
+        m_monoStretcher = monoStretcher;
         m_timeStretcher = stretcher;
         return;
     }
 }
 
 size_t
-AudioCallbackPlaySource::getSourceSamples(size_t count, float **buffer)
-{
+AudioCallbackPlaySource::getSourceSamples(size_t ucount, float **buffer)
+{
+    int count = ucount;
+
     if (!m_playing) {
 	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
-	    for (size_t i = 0; i < count; ++i) {
+	    for (int i = 0; i < count; ++i) {
 		buffer[ch][i] = 0.0;
 	    }
 	}
 	return 0;
     }

     }
 
     if (count == 0) return 0;
 
     RubberBandStretcher *ts = m_timeStretcher;
+    RubberBandStretcher *ms = m_monoStretcher;
+
     float ratio = ts ? ts->getTimeRatio() : 1.f;
 
     if (ratio != m_stretchRatio) {
         if (!ts) {
             std::cerr << "WARNING: AudioCallbackPlaySource::getSourceSamples: Time ratio change to " << m_stretchRatio << " is pending, but no stretcher is set" << std::endl;
             m_stretchRatio = 1.f;
         } else {
             ts->setTimeRatio(m_stretchRatio);
+            if (ms) ms->setTimeRatio(m_stretchRatio);
+            if (m_stretchRatio >= 1.0) m_stretchMono = false;
+        }
+    }
+
+    int stretchChannels = m_stretcherInputCount;
+    if (m_stretchMono) {
+        if (ms) {
+            ts = ms;
+            stretchChannels = 1;
+        } else {
+            m_stretchMono = false;
         }
     }
 
     if (m_target) {
         m_lastRetrievedBlockSize = count;
         m_lastRetrievalTimestamp = m_target->getCurrentTime();
     }
 
     if (!ts || ratio == 1.f) {
 
-	size_t got = 0;
+	int got = 0;
 
 	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
 
 	    RingBuffer<float> *rb = getReadRingBuffer(ch);
 

 		std::cout << "AudioCallbackPlaySource::getSamples: got " << got << " (of " << count << ") samples on channel " << ch << ", signalling for more (possibly)" << std::endl;
 #endif
 	    }
 
 	    for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
-		for (size_t i = got; i < count; ++i) {
+		for (int i = got; i < count; ++i) {
 		    buffer[ch][i] = 0.0;
 		}
 	    }
 	}
 

 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
         std::cerr << "reqd = " <<reqd << ", channels = " << channels << ", ic = " << m_stretcherInputCount << std::endl;
 #endif
 
         for (size_t c = 0; c < channels; ++c) {
-            if (c >= m_stretcherInputCount) continue;
+            if (c >= m_stretcherInputSizes) continue;
             if (reqd > m_stretcherInputSizes[c]) {
                 if (c == 0) {
                     std::cerr << "WARNING: resizing stretcher input buffer from " << m_stretcherInputSizes[c] << " to " << (reqd * 2) << std::endl;
                 }
                 delete[] m_stretcherInputs[c];

                 m_stretcherInputs[c] = new float[m_stretcherInputSizes[c]];
             }
         }
 
         for (size_t c = 0; c < channels; ++c) {
-            if (c >= m_stretcherInputCount) continue;
+            if (c >= m_stretcherInputSizes) continue;
             RingBuffer<float> *rb = getReadRingBuffer(c);
             if (rb) {
-                size_t gotHere = rb->read(m_stretcherInputs[c], got);
+                size_t gotHere;
+                if (stretchChannels == 1 && c > 0) {
+                    gotHere = rb->readAdding(m_stretcherInputs[0], got);
+                } else {
+                    gotHere = rb->read(m_stretcherInputs[c], got);
+                }
                 if (gotHere < got) got = gotHere;
                 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
                 if (c == 0) {
                     std::cerr << "feeding stretcher: got " << gotHere

             if (++warned == 5) break;
         }
     }
 
     ts->retrieve(buffer, count);
+
+    for (int c = stretchChannels; c < getTargetChannelCount(); ++c) {
+        for (int i = 0; i < count; ++i) {
+            buffer[c][i] = buffer[0][i];
+        }
+    }
 
     applyAuditioningEffect(count, buffer);
 
     m_condition.wakeAll();