comparison audioio/AudioCallbackPlaySource.cpp @ 6:f3d777b693f7

* Introduce potentially-separate read and write ring buffers, so we can swap
  in a new set when something changes -- thus allowing us to respond quickly
  when something changes during playback, without losing the long buffers

* Some fixes for display & editing

 #include "model/DenseTimeValueModel.h"
 #include "model/SparseOneDimensionalModel.h"
 #include "dsp/timestretching/IntegerTimeStretcher.h"
 
 #include <iostream>
+#include <cassert>
 
 //#define DEBUG_AUDIO_PLAY_SOURCE 1
 
 //const size_t AudioCallbackPlaySource::m_ringBufferSize = 102400;
 const size_t AudioCallbackPlaySource::m_ringBufferSize = 131071;
 
 AudioCallbackPlaySource::AudioCallbackPlaySource(ViewManager *manager) :
     m_viewManager(manager),
     m_audioGenerator(new AudioGenerator(manager)),
-    m_bufferCount(0),
+    m_readBuffers(0),
+    m_writeBuffers(0),
+    m_sourceChannelCount(0),
     m_blockSize(1024),
     m_sourceSampleRate(0),
     m_targetSampleRate(0),
     m_playLatency(0),
     m_playing(false),

     m_slowdownCounter(0),
     m_timeStretcher(0),
     m_fillThread(0),
     m_converter(0)
 {
-    // preallocate some slots, to avoid reallocation in an
-    // un-thread-safe manner later
-    while (m_buffers.size() < 20) m_buffers.push_back(0);
-
     m_viewManager->setAudioPlaySource(this);
 
     connect(m_viewManager, SIGNAL(selectionChanged()),
 	    this, SLOT(selectionChanged()));
     connect(m_viewManager, SIGNAL(playLoopModeChanged()),

 	m_fillThread->wait();
 	delete m_fillThread;
     }
 
     clearModels();
+    
+    if (m_readBuffers != m_writeBuffers) {
+	delete m_readBuffers;
+    }
+
+    delete m_writeBuffers;
+
+    m_bufferScavenger.scavenge(true);
 }
 
 void
 AudioCallbackPlaySource::addModel(Model *model)
 {

 		  << " vs " << m_sourceSampleRate
 		  << "), playback will be wrong"
 		  << std::endl;
     }
 
-    size_t sz = m_ringBufferSize;
-    if (m_bufferCount > 0) {
-	sz = m_buffers[0]->getSize();
-    }
-
     size_t modelChannels = 1;
     DenseTimeValueModel *dtvm = dynamic_cast<DenseTimeValueModel *>(model);
     if (dtvm) modelChannels = dtvm->getChannelCount();
-
-    while (m_bufferCount < modelChannels) {
-
-	if (m_buffers.size() < modelChannels) {
-	    // This is a hideously chancy operation -- the RT thread
-	    // could be using this vector.  We allocated several slots
-	    // in the ctor to avoid exactly this, but if we ever end
-	    // up with more channels than that (!) then we're just
-	    // going to have to risk it
-	    m_buffers.push_back(new RingBuffer<float>(sz));
-
-	} else {
-	    // The usual case
-	    m_buffers[m_bufferCount] = new RingBuffer<float>(sz);
-	}
-
-	++m_bufferCount;
+    if (modelChannels > m_sourceChannelCount) {
+	m_sourceChannelCount = modelChannels;
+    }
+
+    std::cerr << "Adding model with " << modelChannels << " channels " << std::endl;
+
+    if (!m_writeBuffers || m_writeBuffers->size() < modelChannels) {
+	m_audioGenerator->setTargetChannelCount(modelChannels);
+    }
+
+    m_audioGenerator->addModel(model);
+
+    if (!m_writeBuffers || (m_writeBuffers->size() < modelChannels)) {
+	clearRingBuffers(true, modelChannels);
 	buffersChanged = true;
-    }
-
-    if (buffersChanged) {
-	m_audioGenerator->setTargetChannelCount(m_bufferCount);
+    } else {
+	clearRingBuffers(true);
     }
 
     if (buffersChanged || srChanged) {
 	if (m_converter) {
 	    src_delete(m_converter);
 	    m_converter = 0;
 	}
     }
 
-    m_audioGenerator->addModel(model);
-
     m_mutex.unlock();
 
     if (!m_fillThread) {
 	m_fillThread = new AudioCallbackPlaySourceFillThread(*this);
 	m_fillThread->start();

 #endif
 
     if (buffersChanged || srChanged) {
 	emit modelReplaced();
     }
+
+    m_condition.wakeAll();
 }
 
 void
 AudioCallbackPlaySource::removeModel(Model *model)
 {

     m_lastModelEndFrame = lastEnd;
 
     m_audioGenerator->removeModel(model);
 
     m_mutex.unlock();
+
+    clearRingBuffers();
 }
 
 void
 AudioCallbackPlaySource::clearModels()
 {

 
     m_sourceSampleRate = 0;
 
     m_mutex.unlock();
 }    
+
+void
+AudioCallbackPlaySource::clearRingBuffers(bool haveLock, size_t count)
+{
+    if (!haveLock) m_mutex.lock();
+
+    if (count == 0) {
+	if (m_writeBuffers) count = m_writeBuffers->size();
+    }
+
+    if (m_readBuffers != m_writeBuffers) {
+	delete m_writeBuffers;
+    }
+
+    m_writeBuffers = new RingBufferVector;
+
+    for (size_t i = 0; i < count; ++i) {
+	m_writeBuffers->push_back(new RingBuffer<float>(m_ringBufferSize));
+    }
+
+    std::cerr << "AudioCallbackPlaySource::clearRingBuffers: Created "
+	      << count << " write buffers" << std::endl;
+
+    if (!haveLock) {
+	m_mutex.unlock();
+	m_condition.wakeAll();
+    }
+}
 
 void
 AudioCallbackPlaySource::play(size_t startFrame)
 {
     if (m_viewManager->getPlaySelectionMode() &&

 
     // The fill thread will automatically empty its buffers before
     // starting again if we have not so far been playing, but not if
     // we're just re-seeking.
 
+    m_mutex.lock();
     if (m_playing) {
-	m_mutex.lock();
 	m_bufferedToFrame = startFrame;
-	for (size_t c = 0; c < m_bufferCount; ++c) {
-	    getRingBuffer(c).reset();
-	    if (m_converter) src_reset(m_converter);
-	}
-	m_mutex.unlock();
+	if (m_readBuffers) {
+	    for (size_t c = 0; c < getSourceChannelCount(); ++c) {
+		RingBuffer<float> *rb = getReadRingBuffer(c);
+		if (rb) rb->reset();
+	    }
+	}
+	if (m_converter) src_reset(m_converter);
     } else {
+	if (m_converter) src_reset(m_converter);
 	m_bufferedToFrame = startFrame;
     }
+    m_mutex.unlock();
 
     m_audioGenerator->reset();
 
     m_playing = true;
     m_condition.wakeAll();

 
 void
 AudioCallbackPlaySource::selectionChanged()
 {
     if (m_viewManager->getPlaySelectionMode()) {
-	m_mutex.lock();
-	for (size_t c = 0; c < m_bufferCount; ++c) {
-	    getRingBuffer(c).reset();
-	}
-	m_mutex.unlock();
-	m_condition.wakeAll();
+	clearRingBuffers();
     }
 }
 
 void
 AudioCallbackPlaySource::playLoopModeChanged()
 {
+    clearRingBuffers();
 }
 
 void
 AudioCallbackPlaySource::playSelectionModeChanged()
 {
     if (!m_viewManager->getSelections().empty()) {
-	m_mutex.lock();
-	for (size_t c = 0; c < m_bufferCount; ++c) {
-	    getRingBuffer(c).reset();
-	}
-	m_mutex.unlock();
-	m_condition.wakeAll();
+	clearRingBuffers();
     }
 }
 
 void
 AudioCallbackPlaySource::setTargetBlockSize(size_t size)
 {
     std::cerr << "AudioCallbackPlaySource::setTargetBlockSize() -> " << size << std::endl;
+    assert(size < m_ringBufferSize);
     m_blockSize = size;
-    for (size_t i = 0; i < m_bufferCount; ++i) {
-	getRingBuffer(i).resize(m_ringBufferSize);
-    }
 }
 
 size_t
 AudioCallbackPlaySource::getTargetBlockSize() const
 {

 	ratio = double(getSourceSampleRate()) / double(getTargetSampleRate());
     }
 
     size_t readSpace = 0;
     for (size_t c = 0; c < getSourceChannelCount(); ++c) {
-	size_t spaceHere = getRingBuffer(c).getReadSpace();
-	if (c == 0 || spaceHere < readSpace) readSpace = spaceHere;
+	RingBuffer<float> *rb = getReadRingBuffer(c);
+	if (rb) {
+	    size_t spaceHere = rb->getReadSpace();
+	    if (c == 0 || spaceHere < readSpace) readSpace = spaceHere;
+	}
     }
 
     if (resample) {
 	readSpace = size_t(readSpace * ratio + 0.1);
     }

     m_targetSampleRate = sr;
 
     if (getSourceSampleRate() != getTargetSampleRate()) {
 
 	int err = 0;
-	m_converter = src_new(SRC_SINC_BEST_QUALITY, m_bufferCount, &err);
+	m_converter = src_new(SRC_SINC_BEST_QUALITY, m_sourceChannelCount, &err);
 	if (!m_converter) {
 	    std::cerr
 		<< "AudioCallbackPlaySource::setModel: ERROR in creating samplerate converter: "
 		<< src_strerror(err) << std::endl;
 	}

 }
 
 size_t
 AudioCallbackPlaySource::getSourceChannelCount() const
 {
-    return m_bufferCount;
+    return m_sourceChannelCount;
 }
 
 size_t
 AudioCallbackPlaySource::getSourceSampleRate() const
 {

 
 	size_t got = 0;
 
 	for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
 
-	    RingBuffer<float> &rb = *m_buffers[ch];
-
-	    // this is marginally more likely to leave our channels in
-	    // sync after a processing failure than just passing "count":
-	    size_t request = count;
-	    if (ch > 0) request = got;
-
-	    got = rb.read(buffer[ch], request);
+	    RingBuffer<float> *rb = getReadRingBuffer(ch);
+
+	    if (rb) {
+
+		// this is marginally more likely to leave our channels in
+		// sync after a processing failure than just passing "count":
+		size_t request = count;
+		if (ch > 0) request = got;
+
+		got = rb->read(buffer[ch], request);
 	    
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
-	    std::cout << "AudioCallbackPlaySource::getSamples: got " << got << " samples on channel " << ch << ", signalling for more (possibly)" << std::endl;
-#endif
-	}
-
-	for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
-	    for (size_t i = got; i < count; ++i) {
-		buffer[ch][i] = 0.0;
+		std::cout << "AudioCallbackPlaySource::getSamples: got " << got << " samples on channel " << ch << ", signalling for more (possibly)" << std::endl;
+#endif
+	    }
+
+	    for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
+		for (size_t i = got; i < count; ++i) {
+		    buffer[ch][i] = 0.0;
+		}
 	    }
 	}
 
         m_condition.wakeAll();
 	return got;

 	size_t got = 0;
 	double *ib = timeStretcher->getInputBuffer();
 
 	for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
 
-	    RingBuffer<float> &rb = *m_buffers[ch];
-	    size_t request = count;
-	    if (ch > 0) request = got; // see above
-	    got = rb.read(buffer[ch], request);
-
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-	    std::cout << "AudioCallbackPlaySource::getSamples: got " << got << " samples on channel " << ch << ", running time stretcher" << std::endl;
-#endif
-
-	    for (size_t i = 0; i < count; ++i) {
-		ib[i] = buffer[ch][i];
-	    }
+	    RingBuffer<float> *rb = getReadRingBuffer(ch);
+
+	    if (rb) {
+
+		size_t request = count;
+		if (ch > 0) request = got; // see above
+		got = rb->read(buffer[ch], request);
+
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+		std::cout << "AudioCallbackPlaySource::getSamples: got " << got << " samples on channel " << ch << ", running time stretcher" << std::endl;
+#endif
+
+		for (size_t i = 0; i < count; ++i) {
+		    ib[i] = buffer[ch][i];
+		}
 	    
-	    timeStretcher->run(ch);
+		timeStretcher->run(ch);
+	    }
 	}
 
     } else if (m_slowdownCounter >= timeStretcher->getFactor()) {
 	// reset this in case the factor has changed leaving the
 	// counter out of range

     if (m_slowdownCounter == 0) m_condition.wakeAll();
     m_slowdownCounter = (m_slowdownCounter + 1) % timeStretcher->getFactor();
     return count;
 }
 
+// Called from fill thread, m_playing true, mutex held
 void
 AudioCallbackPlaySource::fillBuffers()
 {
     static float *tmp = 0;
     static size_t tmpSize = 0;
 
     size_t space = 0;
-    for (size_t c = 0; c < m_bufferCount; ++c) {
-	size_t spaceHere = getRingBuffer(c).getWriteSpace();
-	if (c == 0 || spaceHere < space) space = spaceHere;
+    for (size_t c = 0; c < getSourceChannelCount(); ++c) {
+	RingBuffer<float> *wb = getWriteRingBuffer(c);
+	if (wb) {
+	    size_t spaceHere = wb->getWriteSpace();
+	    if (c == 0 || spaceHere < space) space = spaceHere;
+	}
     }
     
     if (space == 0) return;
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE

 
 	for (size_t c = 0; c < channels; ++c) {
 	    bufferPtrs[c] = nonintlv + c * orig;
 	}
 
-	bool ended = !mixModels(f, orig, bufferPtrs);
-	got = orig;
+	got = mixModels(f, orig, bufferPtrs);
 
 	// and interleave into first half
 	for (size_t c = 0; c < channels; ++c) {
-	    for (size_t i = 0; i < orig; ++i) {
-		float sample = 0;
-		if (i < got) {
-		    sample = nonintlv[c * orig + i];
-		}
+	    for (size_t i = 0; i < got; ++i) {
+		float sample = nonintlv[c * got + i];
 		intlv[channels * i + c] = sample;
 	    }
 	}
 		
 	SRC_DATA data;
 	data.data_in = intlv;
 	data.data_out = srcout;
-	data.input_frames = orig;
+	data.input_frames = got;
 	data.output_frames = work;
 	data.src_ratio = ratio;
 	data.end_of_input = 0;
 	
 	int err = src_process(m_converter, &data);
-	size_t toCopy = size_t(work * ratio + 0.1);
-	
+//	size_t toCopy = size_t(work * ratio + 0.1);
+	size_t toCopy = size_t(got * ratio + 0.1);
+
 	if (err) {
 	    std::cerr
 		<< "AudioCallbackPlaySourceFillThread: ERROR in samplerate conversion: "
 		<< src_strerror(err) << std::endl;
 	    //!!! Then what?

 	
 	for (size_t c = 0; c < channels; ++c) {
 	    for (size_t i = 0; i < toCopy; ++i) {
 		tmp[i] = srcout[channels * i + c];
 	    }
-	    getRingBuffer(c).write(tmp, toCopy);
+	    RingBuffer<float> *wb = getWriteRingBuffer(c);
+	    if (wb) wb->write(tmp, toCopy);
 	}
 
 	m_bufferedToFrame = f;
 	
     } else {

 	    for (size_t i = 0; i < space; ++i) {
 		tmp[c * space + i] = 0.0f;
 	    }
 	}
 
-	bool ended = !mixModels(f, space, bufferPtrs);
+	size_t got = mixModels(f, space, bufferPtrs);
 
 	for (size_t c = 0; c < channels; ++c) {
 
-	    getRingBuffer(c).write(bufferPtrs[c], space);
-
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-	    std::cerr << "Wrote " << got << " frames for ch " << c << ", now "
-		      << getRingBuffer(c).getReadSpace() << " to read" 
-		      << std::endl;
+	    RingBuffer<float> *wb = getWriteRingBuffer(c);
+	    if (wb) wb->write(bufferPtrs[c], got);
+
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+	    if (wb)
+		std::cerr << "Wrote " << got << " frames for ch " << c << ", now "
+			  << wb->getReadSpace() << " to read" 
+			  << std::endl;
 #endif
 	}
 
 	m_bufferedToFrame = f;
 	//!!! how do we know when ended? need to mark up a fully-buffered flag and check this if we find the buffers empty in getSourceSamples
     }
 }    
 
-bool
+size_t
 AudioCallbackPlaySource::mixModels(size_t &frame, size_t count, float **buffers)
 {
     size_t processed = 0;
     size_t chunkStart = frame;
     size_t chunkSize = count;
+    size_t selectionSize = 0;
     size_t nextChunkStart = chunkStart + chunkSize;
     
     bool looping = m_viewManager->getPlayLoopMode();
     bool constrained = (m_viewManager->getPlaySelectionMode() &&
 			!m_viewManager->getSelections().empty());

 
     while (processed < count) {
 	
 	chunkSize = count - processed;
 	nextChunkStart = chunkStart + chunkSize;
+	selectionSize = 0;
 
 	size_t fadeIn = 0, fadeOut = 0;
 
 	if (constrained) {
 	    

 		chunkSize = 0;
 		nextChunkStart = chunkStart;
 
 	    } else {
 
+		selectionSize =
+		    selection.getEndFrame() -
+		    selection.getStartFrame();
+
 		if (chunkStart < selection.getStartFrame()) {
 		    chunkStart = selection.getStartFrame();
 		    fadeIn = 50;
 		}
 
 		nextChunkStart = chunkStart + chunkSize;
 
-		if (nextChunkStart > selection.getEndFrame()) {
+		if (nextChunkStart >= selection.getEndFrame()) {
 		    nextChunkStart = selection.getEndFrame();
 		    fadeOut = 50;
 		}
 
 		chunkSize = nextChunkStart - chunkStart;

 		chunkSize = m_lastModelEndFrame - chunkStart;
 	    }
 	    nextChunkStart = chunkStart + chunkSize;
 	}
 	
+//	std::cerr << "chunkStart " << chunkStart << ", chunkSize " << chunkSize << ", nextChunkStart " << nextChunkStart << ", frame " << frame << ", count " << count << ", processed " << processed << std::endl;
+
 	if (!chunkSize) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	    std::cerr << "Ending selection playback at " << nextChunkStart << std::endl;
 #endif
 	    // We need to maintain full buffers so that the other
 	    // thread can tell where it's got to in the playback -- so
 	    // return the full amount here
 	    frame = frame + count;
-	    return false;
+	    return count;
 	}
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	std::cerr << "Selection playback: chunk at " << chunkStart << " -> " << nextChunkStart << " (size " << chunkSize << ")" << std::endl;
 #endif
 
 	size_t got = 0;
 
-	if (chunkSize < 100) {
+	if (selectionSize < 100) {
 	    fadeIn = 0;
 	    fadeOut = 0;
-	} else if (chunkSize < 300) {
+	} else if (selectionSize < 300) {
 	    if (fadeIn > 0) fadeIn = 10;
 	    if (fadeOut > 0) fadeOut = 10;
 	}
 
 	if (fadeIn > 0) {

 		fadeIn = processed * 2;
 	    }
 	}
 
 	if (fadeOut > 0) {
-	    if ((count - processed) * 2 < fadeOut) {
-		fadeOut = (count - processed) * 2;
+	    if ((count - processed - chunkSize) * 2 < fadeOut) {
+		fadeOut = (count - processed - chunkSize) * 2;
 	    }
 	}
 
 	for (std::set<Model *>::iterator mi = m_models.begin();
 	     mi != m_models.end(); ++mi) {

 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     std::cerr << "Returning selection playback at " << nextChunkStart << std::endl;
 #endif
 
     frame = nextChunkStart;
-    return true;
+    return processed;
 }
 
 void
 AudioCallbackPlaySource::AudioCallbackPlaySourceFillThread::run()
 {

     s.m_mutex.lock();
 
     bool previouslyPlaying = s.m_playing;
 
     while (!s.m_exiting) {
+
+	if (s.m_readBuffers != s.m_writeBuffers) {
+	    s.m_bufferScavenger.claim(s.m_readBuffers);
+	    s.m_readBuffers = s.m_writeBuffers;
+	    std::cerr << "unified" << std::endl;
+	}
+	
+	s.m_bufferScavenger.scavenge();
 
 	s.m_timeStretcherScavenger.scavenge();
 
 	float ms = 100;
 	if (s.getSourceSampleRate() > 0) {

 	if (playing && !previouslyPlaying) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	    std::cout << "AudioCallbackPlaySourceFillThread: playback state changed, resetting" << std::endl;
 #endif
 	    for (size_t c = 0; c < s.getSourceChannelCount(); ++c) {
-		s.getRingBuffer(c).reset();
+		RingBuffer<float> *rb = s.getReadRingBuffer(c);
+		if (rb) rb->reset();
 	    }
 	}
 	previouslyPlaying = playing;
-
-	if (!playing) continue;
 
 	s.fillBuffers();
     }
 
     s.m_mutex.unlock();