comparison audioio/AudioCallbackPlaySource.cpp @ 13:89bb89894ad6

* As previous commit

 
 #include <iostream>
 #include <cassert>
 
 //#define DEBUG_AUDIO_PLAY_SOURCE 1
+//#define DEBUG_AUDIO_PLAY_SOURCE_PLAYING 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_readBuffers(0),
     m_writeBuffers(0),
+    m_readBufferFill(0),
+    m_writeBufferFill(0),
+    m_bufferScavenger(1),
     m_sourceChannelCount(0),
     m_blockSize(1024),
     m_sourceSampleRate(0),
     m_targetSampleRate(0),
     m_playLatency(0),
     m_playing(false),
     m_exiting(false),
-    m_bufferedToFrame(0),
     m_lastModelEndFrame(0),
     m_outputLeft(0.0),
     m_outputRight(0.0),
     m_slowdownCounter(0),
     m_timeStretcher(0),

 	m_sourceChannelCount = modelChannels;
     }
 
     std::cerr << "Adding model with " << modelChannels << " channels " << std::endl;
 
-    if (!m_writeBuffers || m_writeBuffers->size() < modelChannels) {
-	m_audioGenerator->setTargetChannelCount(modelChannels);
-    }
-
-    if (!m_writeBuffers || (m_writeBuffers->size() < modelChannels)) {
-	clearRingBuffers(true, modelChannels);
+    if (!m_writeBuffers || (m_writeBuffers->size() < getTargetChannelCount())) {
+	clearRingBuffers(true, getTargetChannelCount());
 	buffersChanged = true;
     } else {
 	if (canPlay) clearRingBuffers(true);
     }
 

 	}
     }
 
     m_mutex.unlock();
 
+    m_audioGenerator->setTargetChannelCount(getTargetChannelCount());
+
     if (!m_fillThread) {
 	m_fillThread = new AudioCallbackPlaySourceFillThread(*this);
 	m_fillThread->start();
     }
 

     if (!haveLock) m_mutex.lock();
 
     if (count == 0) {
 	if (m_writeBuffers) count = m_writeBuffers->size();
     }
+
+    size_t sf = m_readBufferFill;
+    RingBuffer<float> *rb = getReadRingBuffer(0);
+    if (rb) {
+	//!!! This is incorrect if we're in a non-contiguous selection
+	//Same goes for all related code (subtracting the read space
+	//from the fill frame to try to establish where the effective
+	//pre-resample/timestretch read pointer is)
+	size_t rs = rb->getReadSpace();
+	if (rs < sf) sf -= rs;
+	else sf = 0;
+    }
+    m_writeBufferFill = sf;
 
     if (m_readBuffers != m_writeBuffers) {
 	delete m_writeBuffers;
     }
 

     // 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_bufferedToFrame = startFrame;
+	m_readBufferFill = m_writeBufferFill = startFrame;
 	if (m_readBuffers) {
-	    for (size_t c = 0; c < getSourceChannelCount(); ++c) {
+	    for (size_t c = 0; c < getTargetChannelCount(); ++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_readBufferFill = m_writeBufferFill = startFrame;
     }
     m_mutex.unlock();
 
     m_audioGenerator->reset();
 

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

     if (timeStretcher) {
 	latency += timeStretcher->getStretcher(0)->getProcessingLatency();
     }
 
     latency += readSpace;
-    size_t bufferedFrame = m_bufferedToFrame;
+    size_t bufferedFrame = m_readBufferFill;
 
     bool looping = m_viewManager->getPlayLoopMode();
     bool constrained = (m_viewManager->getPlaySelectionMode() &&
 			!m_viewManager->getSelections().empty());
 

     m_targetSampleRate = sr;
 
     if (getSourceSampleRate() != getTargetSampleRate()) {
 
 	int err = 0;
-	m_converter = src_new(SRC_SINC_BEST_QUALITY, m_sourceChannelCount, &err);
+	m_converter = src_new(SRC_SINC_BEST_QUALITY,
+			      getTargetChannelCount(), &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_sourceChannelCount;
+}
+
+size_t
+AudioCallbackPlaySource::getTargetChannelCount() const
+{
+    if (m_sourceChannelCount < 2) return 2;
     return m_sourceChannelCount;
 }
 
 size_t
 AudioCallbackPlaySource::getSourceSampleRate() const

 	return;
     }
 
     if (factor > 1) {
 	TimeStretcherData *newStretcher = new TimeStretcherData
-	    (getSourceChannelCount(), factor, getTargetBlockSize());
+	    (getTargetChannelCount(), factor, getTargetBlockSize());
 	m_slowdownCounter = 0;
 	m_timeStretcher = newStretcher;
     } else {
 	m_timeStretcher = 0;
     }

 	    
 size_t
 AudioCallbackPlaySource::getSourceSamples(size_t count, float **buffer)
 {
     if (!m_playing) {
-	for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
+	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
 	    for (size_t i = 0; i < count; ++i) {
 		buffer[ch][i] = 0.0;
 	    }
 	}
 	return 0;

 
     if (!timeStretcher || timeStretcher->getFactor() == 1) {
 
 	size_t got = 0;
 
-	for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
+	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
 
 	    RingBuffer<float> *rb = getReadRingBuffer(ch);
 
 	    if (rb) {
 

 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
 		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 ch = 0; ch < getTargetChannelCount(); ++ch) {
 		for (size_t i = got; i < count; ++i) {
 		    buffer[ch][i] = 0.0;
 		}
 	    }
 	}

     if (m_slowdownCounter == 0) {
 
 	size_t got = 0;
 	double *ib = timeStretcher->getInputBuffer();
 
-	for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
+	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
 
 	    RingBuffer<float> *rb = getReadRingBuffer(ch);
 
 	    if (rb) {
 

 	// reset this in case the factor has changed leaving the
 	// counter out of range
 	m_slowdownCounter = 0;
     }
 
-    for (size_t ch = 0; ch < getSourceChannelCount(); ++ch) {
+    for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
 
 	double *ob = timeStretcher->getOutputBuffer(ch);
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	std::cerr << "AudioCallbackPlaySource::getSamples: Copying from (" << (m_slowdownCounter * count) << "," << count << ") to buffer" << std::endl;

 {
     static float *tmp = 0;
     static size_t tmpSize = 0;
 
     size_t space = 0;
-    for (size_t c = 0; c < getSourceChannelCount(); ++c) {
+    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
 	RingBuffer<float> *wb = getWriteRingBuffer(c);
 	if (wb) {
 	    size_t spaceHere = wb->getWriteSpace();
 	    if (c == 0 || spaceHere < space) space = spaceHere;
 	}
     }
     
     if (space == 0) return false;
 
+    size_t f = m_writeBufferFill;
+	
+    bool readWriteEqual = (m_readBuffers == m_writeBuffers);
+
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     std::cout << "AudioCallbackPlaySourceFillThread: filling " << space << " frames" << std::endl;
 #endif
 
-    size_t f = m_bufferedToFrame;
-	
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     std::cout << "buffered to " << f << " already" << std::endl;
 #endif
 
     bool resample = (getSourceSampleRate() != getTargetSampleRate());
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     std::cout << (resample ? "" : "not ") << "resampling (source " << getSourceSampleRate() << ", target " << getTargetSampleRate() << ")" << std::endl;
 #endif
 
-    size_t channels = getSourceChannelCount();
+    size_t channels = getTargetChannelCount();
+
     size_t orig = space;
     size_t got = 0;
 
     static float **bufferPtrs = 0;
     static size_t bufferPtrCount = 0;

 	    }
 	    RingBuffer<float> *wb = getWriteRingBuffer(c);
 	    if (wb) wb->write(tmp, toCopy);
 	}
 
-	m_bufferedToFrame = f;
-	
+	m_writeBufferFill = f;
+	if (readWriteEqual) m_readBufferFill = f;
+
     } else {
 
 	// space must be a multiple of generatorBlockSize
 	space = (space / generatorBlockSize) * generatorBlockSize;
 	if (space == 0) return false;

 			  << wb->getReadSpace() << " to read" 
 			  << std::endl;
 #endif
 	}
 
-	m_bufferedToFrame = f;
+	m_writeBufferFill = f;
+	if (readWriteEqual) m_readBufferFill = 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
     }
 
     return true;
 }    

     bool constrained = (m_viewManager->getPlaySelectionMode() &&
 			!m_viewManager->getSelections().empty());
 
     static float **chunkBufferPtrs = 0;
     static size_t chunkBufferPtrCount = 0;
-    size_t channels = getSourceChannelCount();
+    size_t channels = getTargetChannelCount();
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     std::cerr << "Selection playback: start " << frame << ", size " << count <<", channels " << channels << std::endl;
 #endif
 

     frame = nextChunkStart;
     return processed;
 }
 
 void
+AudioCallbackPlaySource::unifyRingBuffers()
+{
+    if (m_readBuffers == m_writeBuffers) return;
+
+    // only unify if there will be something to read
+    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+	RingBuffer<float> *wb = getWriteRingBuffer(c);
+	if (wb) {
+	    if (wb->getReadSpace() < m_blockSize * 2) {
+		if ((m_writeBufferFill + m_blockSize * 2) < 
+		    m_lastModelEndFrame) {
+		    // OK, we don't have enough and there's more to
+		    // read -- don't unify until we can do better
+		    return;
+		}
+	    }
+	    break;
+	}
+    }
+
+    size_t rf = m_readBufferFill;
+    RingBuffer<float> *rb = getReadRingBuffer(0);
+    if (rb) {
+	size_t rs = rb->getReadSpace();
+	//!!! incorrect when in non-contiguous selection, see comments elsewhere
+//	std::cerr << "rs = " << rs << std::endl;
+	if (rs < rf) rf -= rs;
+	else rf = 0;
+    }
+    
+    //std::cerr << "m_readBufferFill = " << m_readBufferFill << ", rf = " << rf << ", m_writeBufferFill = " << m_writeBufferFill << std::endl;
+
+    size_t wf = m_writeBufferFill;
+    size_t skip = 0;
+    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+	RingBuffer<float> *wb = getWriteRingBuffer(c);
+	if (wb) {
+	    if (c == 0) {
+		
+		size_t wrs = wb->getReadSpace();
+//		std::cerr << "wrs = " << wrs << std::endl;
+
+		if (wrs < wf) wf -= wrs;
+		else wf = 0;
+//		std::cerr << "wf = " << wf << std::endl;
+		
+		if (wf < rf) skip = rf - wf;
+		if (skip == 0) break;
+	    }
+
+//	    std::cerr << "skipping " << skip << std::endl;
+	    wb->skip(skip);
+	}
+    }
+		    
+    m_bufferScavenger.claim(m_readBuffers);
+    m_readBuffers = m_writeBuffers;
+    m_readBufferFill = m_writeBufferFill;
+    std::cerr << "unified" << std::endl;
+}
+
+void
 AudioCallbackPlaySource::AudioCallbackPlaySourceFillThread::run()
 {
     AudioCallbackPlaySource &s(m_source);
     
 #ifdef DEBUG_AUDIO_PLAY_SOURCE

     bool previouslyPlaying = s.m_playing;
     bool work = false;
 
     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.unifyRingBuffers();
 	s.m_bufferScavenger.scavenge();
 	s.m_timeStretcherScavenger.scavenge();
 
 	if (work && s.m_playing && s.getSourceSampleRate()) {
 

 
 	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) {
+	    for (size_t c = 0; c < s.getTargetChannelCount(); ++c) {
 		RingBuffer<float> *rb = s.getReadRingBuffer(c);
 		if (rb) rb->reset();
 	    }
 	}
 	previouslyPlaying = playing;