comparison audioio/AudioCallbackPlaySource.cpp @ 371:dfcc5b355f33

Merge from branch warnfix_no_size_t

 #include <cassert>
 
 //#define DEBUG_AUDIO_PLAY_SOURCE 1
 //#define DEBUG_AUDIO_PLAY_SOURCE_PLAYING 1
 
-static const size_t DEFAULT_RING_BUFFER_SIZE = 131071;
+static const int DEFAULT_RING_BUFFER_SIZE = 131071;
 
 AudioCallbackPlaySource::AudioCallbackPlaySource(ViewManagerBase *manager,
                                                  QString clientName) :
     m_viewManager(manager),
     m_audioGenerator(new AudioGenerator()),

 
     delete m_writeBuffers;
 
     delete m_audioGenerator;
 
-    for (size_t i = 0; i < m_stretcherInputCount; ++i) {
+    for (int i = 0; i < m_stretcherInputCount; ++i) {
         delete[] m_stretcherInputs[i];
     }
     delete[] m_stretcherInputSizes;
     delete[] m_stretcherInputs;
 

 	m_lastModelEndFrame = model->getEndFrame();
     }
 
     bool buffersChanged = false, srChanged = false;
 
-    size_t modelChannels = 1;
+    int modelChannels = 1;
     DenseTimeValueModel *dtvm = dynamic_cast<DenseTimeValueModel *>(model);
     if (dtvm) modelChannels = dtvm->getChannelCount();
     if (modelChannels > m_sourceChannelCount) {
 	m_sourceChannelCount = modelChannels;
     }

                 srChanged = true;
             }
         }
     }
 
-    if (!m_writeBuffers || (m_writeBuffers->size() < getTargetChannelCount())) {
+    if (!m_writeBuffers || (int)m_writeBuffers->size() < getTargetChannelCount()) {
 	clearRingBuffers(true, getTargetChannelCount());
 	buffersChanged = true;
     } else {
 	if (canPlay) clearRingBuffers(true);
     }

 
     if (buffersChanged || srChanged) {
 	emit modelReplaced();
     }
 
-    connect(model, SIGNAL(modelChanged(size_t, size_t)),
-            this, SLOT(modelChanged(size_t, size_t)));
+    connect(model, SIGNAL(modelChangedWithin(int, int)),
+            this, SLOT(modelChangedWithin(int, int)));
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "AudioCallbackPlaySource::addModel: awakening thread" << endl;
 #endif
 
     m_condition.wakeAll();
 }
 
 void
-AudioCallbackPlaySource::modelChanged(size_t startFrame, size_t endFrame)
-{
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-    SVDEBUG << "AudioCallbackPlaySource::modelChanged(" << startFrame << "," << endFrame << ")" << endl;
+AudioCallbackPlaySource::modelChangedWithin(int 
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+                                            startFrame
+#endif
+                                            , int endFrame)
+{
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+    SVDEBUG << "AudioCallbackPlaySource::modelChangedWithin(" << startFrame << "," << endFrame << ")" << endl;
 #endif
     if (endFrame > m_lastModelEndFrame) {
         m_lastModelEndFrame = endFrame;
         rebuildRangeLists();
     }

 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "AudioCallbackPlaySource::removeModel(" << model << ")" << endl;
 #endif
 
-    disconnect(model, SIGNAL(modelChanged(size_t, size_t)),
-               this, SLOT(modelChanged(size_t, size_t)));
+    disconnect(model, SIGNAL(modelChangedWithin(int, int)),
+               this, SLOT(modelChangedWithin(int, int)));
 
     m_models.erase(model);
 
     if (m_models.empty()) {
 	if (m_converter) {

             m_crapConverter = 0;
 	}
 	m_sourceSampleRate = 0;
     }
 
-    size_t lastEnd = 0;
+    int lastEnd = 0;
     for (std::set<Model *>::const_iterator i = m_models.begin();
 	 i != m_models.end(); ++i) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	cout << "AudioCallbackPlaySource::removeModel(" << model << "): checking end frame on model " << *i << endl;
 #endif
-	if ((*i)->getEndFrame() > lastEnd) lastEnd = (*i)->getEndFrame();
+	if ((*i)->getEndFrame() > lastEnd) {
+            lastEnd = (*i)->getEndFrame();
+        }
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	cout << "(done, lastEnd now " << lastEnd << ")" << endl;
 #endif
     }
     m_lastModelEndFrame = lastEnd;

 
     clearRingBuffers();
 }    
 
 void
-AudioCallbackPlaySource::clearRingBuffers(bool haveLock, size_t count)
+AudioCallbackPlaySource::clearRingBuffers(bool haveLock, int count)
 {
     if (!haveLock) m_mutex.lock();
 
     rebuildRangeLists();
 

 	delete m_writeBuffers;
     }
 
     m_writeBuffers = new RingBufferVector;
 
-    for (size_t i = 0; i < count; ++i) {
+    for (int i = 0; i < count; ++i) {
 	m_writeBuffers->push_back(new RingBuffer<float>(m_ringBufferSize));
     }
 
 //    cout << "AudioCallbackPlaySource::clearRingBuffers: Created "
 //	      << count << " write buffers" << endl;

 	m_mutex.unlock();
     }
 }
 
 void
-AudioCallbackPlaySource::play(size_t startFrame)
+AudioCallbackPlaySource::play(int startFrame)
 {
     if (m_viewManager->getPlaySelectionMode() &&
 	!m_viewManager->getSelections().empty()) {
 
         SVDEBUG << "AudioCallbackPlaySource::play: constraining frame " << startFrame << " to selection = ";

         m_monoStretcher->reset();
     }
 
     m_readBufferFill = m_writeBufferFill = startFrame;
     if (m_readBuffers) {
-        for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+        for (int c = 0; c < getTargetChannelCount(); ++c) {
             RingBuffer<float> *rb = getReadRingBuffer(c);
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
             cerr << "reset ring buffer for channel " << c << endl;
 #endif
             if (rb) rb->reset();

         return;
     }
 }
 
 void
-AudioCallbackPlaySource::setTarget(AudioCallbackPlayTarget *target, size_t size)
+AudioCallbackPlaySource::setTarget(AudioCallbackPlayTarget *target, int size)
 {
     m_target = target;
     cout << "AudioCallbackPlaySource::setTarget: Block size -> " << size << endl;
     if (size != 0) {
         m_blockSize = size;

             clearRingBuffers();
         }
     }
 }
 
-size_t
+int
 AudioCallbackPlaySource::getTargetBlockSize() const
 {
 //    cout << "AudioCallbackPlaySource::getTargetBlockSize() -> " << m_blockSize << endl;
     return m_blockSize;
 }
 
 void
-AudioCallbackPlaySource::setTargetPlayLatency(size_t latency)
+AudioCallbackPlaySource::setTargetPlayLatency(int latency)
 {
     m_playLatency = latency;
 }
 
-size_t
+int
 AudioCallbackPlaySource::getTargetPlayLatency() const
 {
     return m_playLatency;
 }
 
-size_t
+int
 AudioCallbackPlaySource::getCurrentPlayingFrame()
 {
     // This method attempts to estimate which audio sample frame is
     // "currently coming through the speakers".
 
-    size_t targetRate = getTargetSampleRate();
-    size_t latency = m_playLatency; // at target rate
+    int targetRate = getTargetSampleRate();
+    int latency = m_playLatency; // at target rate
     RealTime latency_t = RealTime::frame2RealTime(latency, targetRate);
 
     return getCurrentFrame(latency_t);
 }
 
-size_t
+int
 AudioCallbackPlaySource::getCurrentBufferedFrame()
 {
     return getCurrentFrame(RealTime::zeroTime);
 }
 
-size_t
+int
 AudioCallbackPlaySource::getCurrentFrame(RealTime latency_t)
 {
-    bool resample = false;
-    double resampleRatio = 1.0;
-
     // We resample when filling the ring buffer, and time-stretch when
     // draining it.  The buffer contains data at the "target rate" and
     // the latency provided by the target is also at the target rate.
     // Because of the multiple rates involved, we do the actual
     // calculation using RealTime instead.
 
-    size_t sourceRate = getSourceSampleRate();
-    size_t targetRate = getTargetSampleRate();
+    int sourceRate = getSourceSampleRate();
+    int targetRate = getTargetSampleRate();
 
     if (sourceRate == 0 || targetRate == 0) return 0;
 
-    size_t inbuffer = 0; // at target rate
-
-    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+    int inbuffer = 0; // at target rate
+
+    for (int c = 0; c < getTargetChannelCount(); ++c) {
 	RingBuffer<float> *rb = getReadRingBuffer(c);
 	if (rb) {
-	    size_t here = rb->getReadSpace();
+	    int here = rb->getReadSpace();
 	    if (c == 0 || here < inbuffer) inbuffer = here;
 	}
     }
 
-    size_t readBufferFill = m_readBufferFill;
-    size_t lastRetrievedBlockSize = m_lastRetrievedBlockSize;
+    int readBufferFill = m_readBufferFill;
+    int lastRetrievedBlockSize = m_lastRetrievedBlockSize;
     double lastRetrievalTimestamp = m_lastRetrievalTimestamp;
     double currentTime = 0.0;
     if (m_target) currentTime = m_target->getCurrentTime();
 
     bool looping = m_viewManager->getPlayLoopMode();
 
     RealTime inbuffer_t = RealTime::frame2RealTime(inbuffer, targetRate);
 
-    size_t stretchlat = 0;
+    int stretchlat = 0;
     double timeRatio = 1.0;
 
     if (m_timeStretcher) {
         stretchlat = m_timeStretcher->getLatency();
         timeRatio = m_timeStretcher->getTimeRatio();

 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
     cerr << "\nbuffered to: " << bufferedto_t << ", in buffer: " << inbuffer_t << ", time ratio " << timeRatio << "\n  stretcher latency: " << stretchlat_t << ", device latency: " << latency_t << "\n  since request: " << sincerequest_t << ", last retrieved quantity: " << lastretrieved_t << endl;
 #endif
 
-    RealTime end = RealTime::frame2RealTime(m_lastModelEndFrame, sourceRate);
-
     // Normally the range lists should contain at least one item each
     // -- if playback is unconstrained, that item should report the
     // entire source audio duration.
 
     if (m_rangeStarts.empty()) {

         // this code is only used in case of error in rebuildRangeLists
         RealTime playing_t = bufferedto_t
             - latency_t - stretchlat_t - lastretrieved_t - inbuffer_t
             + sincerequest_t;
         if (playing_t < RealTime::zeroTime) playing_t = RealTime::zeroTime;
-        size_t frame = RealTime::realTime2Frame(playing_t, sourceRate);
+        int frame = RealTime::realTime2Frame(playing_t, sourceRate);
         return m_viewManager->alignPlaybackFrameToReference(frame);
     }
 
     int inRange = 0;
     int index = 0;
 
-    for (size_t i = 0; i < m_rangeStarts.size(); ++i) {
+    for (int i = 0; i < (int)m_rangeStarts.size(); ++i) {
         if (bufferedto_t >= m_rangeStarts[i]) {
             inRange = index;
         } else {
             break;
         }
         ++index;
     }
 
-    if (inRange >= m_rangeStarts.size()) inRange = m_rangeStarts.size()-1;
+    if (inRange >= (int)m_rangeStarts.size()) inRange = m_rangeStarts.size()-1;
 
     RealTime playing_t = bufferedto_t;
 
     playing_t = playing_t
         - latency_t - stretchlat_t - lastretrieved_t - inbuffer_t

 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
     cerr << "  playing time: " << playing_t << endl;
 #endif
 
     if (!looping) {
-        if (inRange == m_rangeStarts.size()-1 &&
+        if (inRange == (int)m_rangeStarts.size()-1 &&
             playing_t >= m_rangeStarts[inRange] + m_rangeDurations[inRange]) {
 cerr << "Not looping, inRange " << inRange << " == rangeStarts.size()-1, playing_t " << playing_t << " >= m_rangeStarts[inRange] " << m_rangeStarts[inRange] << " + m_rangeDurations[inRange] " << m_rangeDurations[inRange] << " -- stopping" << endl;
             stop();
         }
     }
 
     if (playing_t < RealTime::zeroTime) playing_t = RealTime::zeroTime;
 
-    size_t frame = RealTime::realTime2Frame(playing_t, sourceRate);
+    int frame = RealTime::realTime2Frame(playing_t, sourceRate);
 
     if (m_lastCurrentFrame > 0 && !looping) {
         if (frame < m_lastCurrentFrame) {
             frame = m_lastCurrentFrame;
         }

     bool constrained = (m_viewManager->getPlaySelectionMode());
 
     m_rangeStarts.clear();
     m_rangeDurations.clear();
 
-    size_t sourceRate = getSourceSampleRate();
+    int sourceRate = getSourceSampleRate();
     if (sourceRate == 0) return;
 
     RealTime end = RealTime::frame2RealTime(m_lastModelEndFrame, sourceRate);
     if (end == RealTime::zeroTime) return;
 

     right = m_outputRight;
     return true;
 }
 
 void
-AudioCallbackPlaySource::setTargetSampleRate(size_t sr)
+AudioCallbackPlaySource::setTargetSampleRate(int sr)
 {
     bool first = (m_targetSampleRate == 0);
 
     m_targetSampleRate = sr;
     initialiseConverter();

 {
     m_audioGenerator->clearSoloModelSet();
     clearRingBuffers();
 }
 
-size_t
+int
 AudioCallbackPlaySource::getTargetSampleRate() const
 {
     if (m_targetSampleRate) return m_targetSampleRate;
     else return getSourceSampleRate();
 }
 
-size_t
+int
 AudioCallbackPlaySource::getSourceChannelCount() const
 {
     return m_sourceChannelCount;
 }
 
-size_t
+int
 AudioCallbackPlaySource::getTargetChannelCount() const
 {
     if (m_sourceChannelCount < 2) return 2;
     return m_sourceChannelCount;
 }
 
-size_t
+int
 AudioCallbackPlaySource::getSourceSampleRate() const
 {
     return m_sourceSampleRate;
 }
 

             (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 = new int[m_stretcherInputCount];
+        for (int c = 0; c < m_stretcherInputCount; ++c) {
             m_stretcherInputSizes[c] = 16384;
             m_stretcherInputs[c] = new float[m_stretcherInputSizes[c]];
         }
         m_monoStretcher = monoStretcher;
         m_timeStretcher = stretcher;
     }
 
     emit activity(tr("Change time-stretch factor to %1").arg(factor));
 }
 
-size_t
-AudioCallbackPlaySource::getSourceSamples(size_t ucount, float **buffer)
+int
+AudioCallbackPlaySource::getSourceSamples(int ucount, float **buffer)
 {
     int count = ucount;
 
     if (!m_playing) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
         SVDEBUG << "AudioCallbackPlaySource::getSourceSamples: Not playing" << endl;
 #endif
-	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
+	for (int ch = 0; ch < getTargetChannelCount(); ++ch) {
 	    for (int i = 0; i < count; ++i) {
 		buffer[ch][i] = 0.0;
 	    }
 	}
 	return 0;

 #endif
 
     // Ensure that all buffers have at least the amount of data we
     // need -- else reduce the size of our requests correspondingly
 
-    for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
+    for (int ch = 0; ch < getTargetChannelCount(); ++ch) {
 
         RingBuffer<float> *rb = getReadRingBuffer(ch);
         
         if (!rb) {
             cerr << "WARNING: AudioCallbackPlaySource::getSourceSamples: "

                       << ", returning no data here" << endl;
             count = 0;
             break;
         }
 
-        size_t rs = rb->getReadSpace();
+        int rs = rb->getReadSpace();
         if (rs < count) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
             cerr << "WARNING: AudioCallbackPlaySource::getSourceSamples: "
                       << "Ring buffer for channel " << ch << " has only "
                       << rs << " (of " << count << ") samples available ("

 
     if (!ts || ratio == 1.f) {
 
 	int got = 0;
 
-	for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
+	for (int ch = 0; ch < getTargetChannelCount(); ++ch) {
 
 	    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;
+		int request = count;
 		if (ch > 0) request = got;
 
 		got = rb->read(buffer[ch], request);
 	    
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
 		cout << "AudioCallbackPlaySource::getSamples: got " << got << " (of " << count << ") samples on channel " << ch << ", signalling for more (possibly)" << endl;
 #endif
 	    }
 
-	    for (size_t ch = 0; ch < getTargetChannelCount(); ++ch) {
+	    for (int ch = 0; ch < getTargetChannelCount(); ++ch) {
 		for (int i = got; i < count; ++i) {
 		    buffer[ch][i] = 0.0;
 		}
 	    }
 	}

         m_condition.wakeAll();
 
 	return got;
     }
 
-    size_t channels = getTargetChannelCount();
-    size_t available;
+    int channels = getTargetChannelCount();
+    int available;
     int warned = 0;
-    size_t fedToStretcher = 0;
+    int fedToStretcher = 0;
 
     // The input block for a given output is approx output / ratio,
     // but we can't predict it exactly, for an adaptive timestretcher.
 
     while ((available = ts->available()) < count) {
 
-        size_t reqd = lrintf((count - available) / ratio);
-        reqd = std::max(reqd, ts->getSamplesRequired());
+        int reqd = lrintf((count - available) / ratio);
+        reqd = std::max(reqd, (int)ts->getSamplesRequired());
         if (reqd == 0) reqd = 1;
                 
-        size_t got = reqd;
+        int got = reqd;
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
         cerr << "reqd = " <<reqd << ", channels = " << channels << ", ic = " << m_stretcherInputCount << endl;
 #endif
 
-        for (size_t c = 0; c < channels; ++c) {
+        for (int c = 0; c < channels; ++c) {
             if (c >= m_stretcherInputCount) continue;
             if (reqd > m_stretcherInputSizes[c]) {
                 if (c == 0) {
                     cerr << "WARNING: resizing stretcher input buffer from " << m_stretcherInputSizes[c] << " to " << (reqd * 2) << endl;
                 }

                 m_stretcherInputSizes[c] = reqd * 2;
                 m_stretcherInputs[c] = new float[m_stretcherInputSizes[c]];
             }
         }
 
-        for (size_t c = 0; c < channels; ++c) {
+        for (int c = 0; c < channels; ++c) {
             if (c >= m_stretcherInputCount) continue;
             RingBuffer<float> *rb = getReadRingBuffer(c);
             if (rb) {
-                size_t gotHere;
+                int gotHere;
                 if (stretchChannels == 1 && c > 0) {
                     gotHere = rb->readAdding(m_stretcherInputs[0], got);
                 } else {
                     gotHere = rb->read(m_stretcherInputs[c], got);
                 }

 
     return count;
 }
 
 void
-AudioCallbackPlaySource::applyAuditioningEffect(size_t count, float **buffers)
+AudioCallbackPlaySource::applyAuditioningEffect(int count, float **buffers)
 {
     if (m_auditioningPluginBypassed) return;
     RealTimePluginInstance *plugin = m_auditioningPlugin;
     if (!plugin) return;
     
-    if (plugin->getAudioInputCount() != getTargetChannelCount()) {
+    if ((int)plugin->getAudioInputCount() != getTargetChannelCount()) {
 //        cerr << "plugin input count " << plugin->getAudioInputCount() 
 //                  << " != our channel count " << getTargetChannelCount()
 //                  << endl;
         return;
     }
-    if (plugin->getAudioOutputCount() != getTargetChannelCount()) {
+    if ((int)plugin->getAudioOutputCount() != getTargetChannelCount()) {
 //        cerr << "plugin output count " << plugin->getAudioOutputCount() 
 //                  << " != our channel count " << getTargetChannelCount()
 //                  << endl;
         return;
     }
-    if (plugin->getBufferSize() < count) {
+    if ((int)plugin->getBufferSize() < count) {
 //        cerr << "plugin buffer size " << plugin->getBufferSize() 
 //                  << " < our block size " << count
 //                  << endl;
         return;
     }
 
     float **ib = plugin->getAudioInputBuffers();
     float **ob = plugin->getAudioOutputBuffers();
 
-    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
-        for (size_t i = 0; i < count; ++i) {
+    for (int c = 0; c < getTargetChannelCount(); ++c) {
+        for (int i = 0; i < count; ++i) {
             ib[c][i] = buffers[c][i];
         }
     }
 
     plugin->run(Vamp::RealTime::zeroTime, count);
     
-    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
-        for (size_t i = 0; i < count; ++i) {
+    for (int c = 0; c < getTargetChannelCount(); ++c) {
+        for (int i = 0; i < count; ++i) {
             buffers[c][i] = ob[c][i];
         }
     }
 }    
 
 // Called from fill thread, m_playing true, mutex held
 bool
 AudioCallbackPlaySource::fillBuffers()
 {
     static float *tmp = 0;
-    static size_t tmpSize = 0;
-
-    size_t space = 0;
-    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+    static int tmpSize = 0;
+
+    int space = 0;
+    for (int c = 0; c < getTargetChannelCount(); ++c) {
 	RingBuffer<float> *wb = getWriteRingBuffer(c);
 	if (wb) {
-	    size_t spaceHere = wb->getWriteSpace();
+	    int spaceHere = wb->getWriteSpace();
 	    if (c == 0 || spaceHere < space) space = spaceHere;
 	}
     }
     
     if (space == 0) {

         cout << "AudioCallbackPlaySourceFillThread: no space to fill" << endl;
 #endif
         return false;
     }
 
-    size_t f = m_writeBufferFill;
+    int f = m_writeBufferFill;
 	
     bool readWriteEqual = (m_readBuffers == m_writeBuffers);
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     if (!readWriteEqual) {

 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << (resample ? "" : "not ") << "resampling (source " << getSourceSampleRate() << ", target " << getTargetSampleRate() << ")" << endl;
 #endif
 
-    size_t channels = getTargetChannelCount();
-
-    size_t orig = space;
-    size_t got = 0;
+    int channels = getTargetChannelCount();
+
+    int orig = space;
+    int got = 0;
 
     static float **bufferPtrs = 0;
-    static size_t bufferPtrCount = 0;
+    static int bufferPtrCount = 0;
 
     if (bufferPtrCount < channels) {
 	if (bufferPtrs) delete[] bufferPtrs;
 	bufferPtrs = new float *[channels];
 	bufferPtrCount = channels;
     }
 
-    size_t generatorBlockSize = m_audioGenerator->getBlockSize();
+    int generatorBlockSize = m_audioGenerator->getBlockSize();
 
     if (resample && !m_converter) {
 	static bool warned = false;
 	if (!warned) {
 	    cerr << "WARNING: sample rates differ, but no converter available!" << endl;

 
     if (resample && m_converter) {
 
 	double ratio =
 	    double(getTargetSampleRate()) / double(getSourceSampleRate());
-	orig = size_t(orig / ratio + 0.1);
+	orig = int(orig / ratio + 0.1);
 
 	// orig must be a multiple of generatorBlockSize
 	orig = (orig / generatorBlockSize) * generatorBlockSize;
 	if (orig == 0) return false;
 
-	size_t work = std::max(orig, space);
+	int 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
 	// the buffer (orig samples for channel 0, orig samples for
 	// channel 1 etc), and then interleave them into the first

 
 	float *nonintlv = tmp + channels * work;
 	float *intlv = tmp;
 	float *srcout = tmp + channels * work;
 	
-	for (size_t c = 0; c < channels; ++c) {
-	    for (size_t i = 0; i < orig; ++i) {
+	for (int c = 0; c < channels; ++c) {
+	    for (int i = 0; i < orig; ++i) {
 		nonintlv[channels * i + c] = 0.0f;
 	    }
 	}
 
-	for (size_t c = 0; c < channels; ++c) {
+	for (int c = 0; c < channels; ++c) {
 	    bufferPtrs[c] = nonintlv + c * orig;
 	}
 
 	got = mixModels(f, orig, bufferPtrs); // also modifies f
 
 	// and interleave into first half
-	for (size_t c = 0; c < channels; ++c) {
-	    for (size_t i = 0; i < got; ++i) {
+	for (int c = 0; c < channels; ++c) {
+	    for (int i = 0; i < got; ++i) {
 		float sample = nonintlv[c * got + i];
 		intlv[channels * i + c] = sample;
 	    }
 	}
 		

             err = src_process(m_crapConverter, &data);
         } else {
             err = src_process(m_converter, &data);
         }
 
-	size_t toCopy = size_t(got * ratio + 0.1);
+	int toCopy = int(got * ratio + 0.1);
 
 	if (err) {
 	    cerr
 		<< "AudioCallbackPlaySourceFillThread: ERROR in samplerate conversion: "
 		<< src_strerror(err) << endl;

 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	    cout << "Resampled " << got << " frames to " << toCopy << " frames" << endl;
 #endif
 	}
 	
-	for (size_t c = 0; c < channels; ++c) {
-	    for (size_t i = 0; i < toCopy; ++i) {
+	for (int c = 0; c < channels; ++c) {
+	    for (int i = 0; i < toCopy; ++i) {
 		tmp[i] = srcout[channels * i + c];
 	    }
 	    RingBuffer<float> *wb = getWriteRingBuffer(c);
 	    if (wb) wb->write(tmp, toCopy);
 	}

 	if (readWriteEqual) m_readBufferFill = f;
 
     } else {
 
 	// space must be a multiple of generatorBlockSize
-        size_t reqSpace = space;
+        int reqSpace = space;
 	space = (reqSpace / generatorBlockSize) * generatorBlockSize;
 	if (space == 0) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
             cout << "requested fill of " << reqSpace
                       << " is less than generator block size of "

 	    delete[] tmp;
 	    tmp = new float[channels * space];
 	    tmpSize = channels * space;
 	}
 
-	for (size_t c = 0; c < channels; ++c) {
+	for (int c = 0; c < channels; ++c) {
 
 	    bufferPtrs[c] = tmp + c * space;
 	    
-	    for (size_t i = 0; i < space; ++i) {
+	    for (int i = 0; i < space; ++i) {
 		tmp[c * space + i] = 0.0f;
 	    }
 	}
 
-	size_t got = mixModels(f, space, bufferPtrs); // also modifies f
-
-	for (size_t c = 0; c < channels; ++c) {
+	int got = mixModels(f, space, bufferPtrs); // also modifies f
+
+	for (int c = 0; c < channels; ++c) {
 
 	    RingBuffer<float> *wb = getWriteRingBuffer(c);
 	    if (wb) {
-                size_t actual = wb->write(bufferPtrs[c], got);
+                int actual = wb->write(bufferPtrs[c], got);
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 		cout << "Wrote " << actual << " samples for ch " << c << ", now "
 			  << wb->getReadSpace() << " to read" 
 			  << endl;
 #endif

     }
 
     return true;
 }    
 
-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;
+int
+AudioCallbackPlaySource::mixModels(int &frame, int count, float **buffers)
+{
+    int processed = 0;
+    int chunkStart = frame;
+    int chunkSize = count;
+    int selectionSize = 0;
+    int nextChunkStart = chunkStart + chunkSize;
     
     bool looping = m_viewManager->getPlayLoopMode();
     bool constrained = (m_viewManager->getPlaySelectionMode() &&
 			!m_viewManager->getSelections().empty());
 
     static float **chunkBufferPtrs = 0;
-    static size_t chunkBufferPtrCount = 0;
-    size_t channels = getTargetChannelCount();
+    static int chunkBufferPtrCount = 0;
+    int channels = getTargetChannelCount();
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "Selection playback: start " << frame << ", size " << count <<", channels " << channels << endl;
 #endif
 

 	if (chunkBufferPtrs) delete[] chunkBufferPtrs;
 	chunkBufferPtrs = new float *[channels];
 	chunkBufferPtrCount = channels;
     }
 
-    for (size_t c = 0; c < channels; ++c) {
+    for (int c = 0; c < channels; ++c) {
 	chunkBufferPtrs[c] = buffers[c];
     }
 
     while (processed < count) {
 	
 	chunkSize = count - processed;
 	nextChunkStart = chunkStart + chunkSize;
 	selectionSize = 0;
 
-	size_t fadeIn = 0, fadeOut = 0;
+	int fadeIn = 0, fadeOut = 0;
 
 	if (constrained) {
 
-            size_t rChunkStart =
+            int rChunkStart =
                 m_viewManager->alignPlaybackFrameToReference(chunkStart);
 	    
 	    Selection selection =
 		m_viewManager->getContainingSelection(rChunkStart, true);
 	    

 		chunkSize = 0;
 		nextChunkStart = chunkStart;
 
 	    } else {
 
-                size_t sf = m_viewManager->alignReferenceToPlaybackFrame
+                int sf = m_viewManager->alignReferenceToPlaybackFrame
                     (selection.getStartFrame());
-                size_t ef = m_viewManager->alignReferenceToPlaybackFrame
+                int ef = m_viewManager->alignReferenceToPlaybackFrame
                     (selection.getEndFrame());
 
 		selectionSize = ef - sf;
 
 		if (chunkStart < sf) {

 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	cout << "Selection playback: chunk at " << chunkStart << " -> " << nextChunkStart << " (size " << chunkSize << ")" << endl;
 #endif
 
-	size_t got = 0;
-
 	if (selectionSize < 100) {
 	    fadeIn = 0;
 	    fadeOut = 0;
 	} else if (selectionSize < 300) {
 	    if (fadeIn > 0) fadeIn = 10;

 	}
 
 	for (std::set<Model *>::iterator mi = m_models.begin();
 	     mi != m_models.end(); ++mi) {
 	    
-	    got = m_audioGenerator->mixModel(*mi, chunkStart, 
-					     chunkSize, chunkBufferPtrs,
-					     fadeIn, fadeOut);
-	}
-
-	for (size_t c = 0; c < channels; ++c) {
+	    (void) m_audioGenerator->mixModel(*mi, chunkStart, 
+                                              chunkSize, chunkBufferPtrs,
+                                              fadeIn, fadeOut);
+	}
+
+	for (int c = 0; c < channels; ++c) {
 	    chunkBufferPtrs[c] += chunkSize;
 	}
 
 	processed += chunkSize;
 	chunkStart = nextChunkStart;

 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) {
+    for (int 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) {

 	    }
 	    break;
 	}
     }
 
-    size_t rf = m_readBufferFill;
+    int rf = m_readBufferFill;
     RingBuffer<float> *rb = getReadRingBuffer(0);
     if (rb) {
-	size_t rs = rb->getReadSpace();
+	int rs = rb->getReadSpace();
 	//!!! incorrect when in non-contiguous selection, see comments elsewhere
 //	cout << "rs = " << rs << endl;
 	if (rs < rf) rf -= rs;
 	else rf = 0;
     }
     
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
     SVDEBUG << "AudioCallbackPlaySource::unifyRingBuffers: m_readBufferFill = " << m_readBufferFill << ", rf = " << rf << ", m_writeBufferFill = " << m_writeBufferFill << endl;
 #endif
 
-    size_t wf = m_writeBufferFill;
-    size_t skip = 0;
-    for (size_t c = 0; c < getTargetChannelCount(); ++c) {
+    int wf = m_writeBufferFill;
+    int skip = 0;
+    for (int c = 0; c < getTargetChannelCount(); ++c) {
 	RingBuffer<float> *wb = getWriteRingBuffer(c);
 	if (wb) {
 	    if (c == 0) {
 		
-		size_t wrs = wb->getReadSpace();
+		int wrs = wb->getReadSpace();
 //		cout << "wrs = " << wrs << endl;
 
 		if (wrs < wf) wf -= wrs;
 		else wf = 0;
 //		cout << "wf = " << wf << endl;

 #ifdef DEBUG_AUDIO_PLAY_SOURCE
             if (!s.m_playing) cout << endl;
 	    cout << "AudioCallbackPlaySourceFillThread: waiting for " << ms << "ms..." << endl;
 #endif
 	    
-	    s.m_condition.wait(&s.m_mutex, size_t(ms));
+	    s.m_condition.wait(&s.m_mutex, int(ms));
 	}
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
 	cout << "AudioCallbackPlaySourceFillThread: awoken" << endl;
 #endif

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