comparison audioio/AudioCallbackPlaySource.cpp @ 7:3a41ba527b4a

* Add command history class, and basic undo/redo menus.  No actual commands
  to undo/redo yet.  Selecting the placeholders sometimes seems to cause
  a crash, so this looks a little uncertain so far.

* Add Rename Layer

* Remove models from playback when their layers are removed (and ref counts
  hit zero)

* Don't hang around waiting so much when there's work to be done in the audio
  buffer fill thread

* Put more sensible names on layers generated from transforms

* Add basic editing to time-value layer like existing editing in time-instants
  layer, and make both of them snap to the appropriate resolution during drag

 		size_t request = count;
 		if (ch > 0) request = got;
 
 		got = rb->read(buffer[ch], request);
 	    
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
+#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 i = 0; i < count; ++i) {
 	    buffer[ch][i] = ob[m_slowdownCounter * count + i];
 	}
     }
 
-    if (m_slowdownCounter == 0) m_condition.wakeAll();
+//!!!    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
+bool
 AudioCallbackPlaySource::fillBuffers()
 {
     static float *tmp = 0;
     static size_t tmpSize = 0;
 

 	    size_t spaceHere = wb->getWriteSpace();
 	    if (c == 0 || spaceHere < space) space = spaceHere;
 	}
     }
     
-    if (space == 0) return;
+    if (space == 0) return false;
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     std::cout << "AudioCallbackPlaySourceFillThread: filling " << space << " frames" << std::endl;
 #endif
 

 	    double(getTargetSampleRate()) / double(getSourceSampleRate());
 	orig = size_t(orig / ratio + 0.1);
 
 	// orig must be a multiple of generatorBlockSize
 	orig = (orig / generatorBlockSize) * generatorBlockSize;
-	if (orig == 0) return;
+	if (orig == 0) return false;
 
 	size_t work = std::max(orig, space);
 
 	// We only allocate one buffer, but we use it in two halves.
 	// We place the non-interleaved values in the second half of

 	
     } else {
 
 	// space must be a multiple of generatorBlockSize
 	space = (space / generatorBlockSize) * generatorBlockSize;
-	if (space == 0) return;
+	if (space == 0) return false;
 
 	if (tmpSize < channels * space) {
 	    delete[] tmp;
 	    tmp = new float[channels * space];
 	    tmpSize = channels * space;

 	}
 
 	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
     }
+
+    return true;
 }    
 
 size_t
 AudioCallbackPlaySource::mixModels(size_t &frame, size_t count, float **buffers)
 {

 	processed += chunkSize;
 	chunkStart = nextChunkStart;
     }
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
-    std::cerr << "Returning selection playback at " << nextChunkStart << std::endl;
+    std::cerr << "Returning selection playback " << processed << " frames to " << nextChunkStart << std::endl;
 #endif
 
     frame = nextChunkStart;
     return processed;
 }

 #endif
 
     s.m_mutex.lock();
 
     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.m_bufferScavenger.scavenge();
-
 	s.m_timeStretcherScavenger.scavenge();
 
-	float ms = 100;
-	if (s.getSourceSampleRate() > 0) {
-	    ms = float(m_ringBufferSize) / float(s.getSourceSampleRate()) * 1000.0;
-	}
-
-	if (!s.m_playing) ms *= 10;
-	ms = ms / 8;
-
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-	std::cout << "AudioCallbackPlaySourceFillThread: waiting for " << ms << "ms..." << std::endl;
-#endif
-
-	s.m_condition.wait(&s.m_mutex, size_t(ms));
+	if (work && s.m_playing && s.getSourceSampleRate()) {
+
+	    s.m_mutex.unlock();
+	    s.m_mutex.lock();
+
+	} else {
+	    
+	    float ms = 100;
+	    if (s.getSourceSampleRate() > 0) {
+		ms = float(m_ringBufferSize) / float(s.getSourceSampleRate()) * 1000.0;
+	    }
+	    
+	    if (s.m_playing) ms /= 10;
+	    
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+	    std::cout << "AudioCallbackPlaySourceFillThread: waiting for " << ms << "ms..." << std::endl;
+#endif
+	    
+	    s.m_condition.wait(&s.m_mutex, size_t(ms));
+	}
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	std::cout << "AudioCallbackPlaySourceFillThread: awoken" << std::endl;
 #endif
+
+	work = false;
 
 	if (!s.getSourceSampleRate()) continue;
 
 	bool playing = s.m_playing;
 

 		if (rb) rb->reset();
 	    }
 	}
 	previouslyPlaying = playing;
 
-	s.fillBuffers();
+	work = s.fillBuffers();
     }
 
     s.m_mutex.unlock();
 }