comparison audio/AudioCallbackPlaySource.cpp @ 595:b23bebfdfaba

Untabify

     m_resamplerWrapper(0)
 {
     m_viewManager->setAudioPlaySource(this);
 
     connect(m_viewManager, SIGNAL(selectionChanged()),
-	    this, SLOT(selectionChanged()));
+            this, SLOT(selectionChanged()));
     connect(m_viewManager, SIGNAL(playLoopModeChanged()),
-	    this, SLOT(playLoopModeChanged()));
+            this, SLOT(playLoopModeChanged()));
     connect(m_viewManager, SIGNAL(playSelectionModeChanged()),
-	    this, SLOT(playSelectionModeChanged()));
+            this, SLOT(playSelectionModeChanged()));
 
     connect(this, SIGNAL(playStatusChanged(bool)),
             m_viewManager, SLOT(playStatusChanged(bool)));
 
     connect(PlayParameterRepository::getInstance(),
-	    SIGNAL(playParametersChanged(PlayParameters *)),
-	    this, SLOT(playParametersChanged(PlayParameters *)));
+            SIGNAL(playParametersChanged(PlayParameters *)),
+            this, SLOT(playParametersChanged(PlayParameters *)));
 
     connect(Preferences::getInstance(),
             SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
             this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
 }

     if (m_fillThread) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "AudioCallbackPlaySource dtor: awakening thread" << endl;
 #endif
         m_condition.wakeAll();
-	m_fillThread->wait();
-	delete m_fillThread;
+        m_fillThread->wait();
+        delete m_fillThread;
     }
 
     clearModels();
     
     if (m_readBuffers != m_writeBuffers) {
-	delete m_readBuffers;
+        delete m_readBuffers;
     }
 
     delete m_writeBuffers;
 
     delete m_audioGenerator;

 
     m_mutex.lock();
 
     m_models.insert(model);
     if (model->getEndFrame() > m_lastModelEndFrame) {
-	m_lastModelEndFrame = model->getEndFrame();
+        m_lastModelEndFrame = model->getEndFrame();
     }
 
     bool buffersIncreased = false, srChanged = false;
 
     int modelChannels = 1;
     ReadOnlyWaveFileModel *rowfm = qobject_cast<ReadOnlyWaveFileModel *>(model);
     if (rowfm) modelChannels = rowfm->getChannelCount();
     if (modelChannels > m_sourceChannelCount) {
-	m_sourceChannelCount = modelChannels;
+        m_sourceChannelCount = modelChannels;
     }
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "AudioCallbackPlaySource: Adding model with " << modelChannels << " channels at rate " << model->getSampleRate() << endl;
 #endif

     if (m_sourceSampleRate == 0) {
 
         SVDEBUG << "AudioCallbackPlaySource::addModel: Source rate changing from 0 to "
             << model->getSampleRate() << endl;
 
-	m_sourceSampleRate = model->getSampleRate();
-	srChanged = true;
+        m_sourceSampleRate = model->getSampleRate();
+        srChanged = true;
 
     } else if (model->getSampleRate() != m_sourceSampleRate) {
 
         // If this is a read-only wave file model and we have no
         // other, we can just switch to this model's sample rate

     }
 
     if (!m_writeBuffers || (int)m_writeBuffers->size() < getTargetChannelCount()) {
         cerr << "m_writeBuffers size = " << (m_writeBuffers ? m_writeBuffers->size() : 0) << endl;
         cerr << "target channel count = " << (getTargetChannelCount()) << endl;
-	clearRingBuffers(true, getTargetChannelCount());
-	buffersIncreased = true;
+        clearRingBuffers(true, getTargetChannelCount());
+        buffersIncreased = true;
     } else {
-	if (willPlay) clearRingBuffers(true);
+        if (willPlay) clearRingBuffers(true);
     }
 
     if (srChanged) {
 
         SVCERR << "AudioCallbackPlaySource: Source rate changed" << endl;

             SVDEBUG << "AudioCallbackPlaySource::addModel: This is no more than the device channel count (" << getDeviceChannelCount() << "), so taking no action" << endl;
         }
     }
     
     if (!m_fillThread) {
-	m_fillThread = new FillThread(*this);
-	m_fillThread->start();
+        m_fillThread = new FillThread(*this);
+        m_fillThread->start();
     }
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     SVDEBUG << "AudioCallbackPlaySource::addModel: now have " << m_models.size() << " model(s)" << endl;
 #endif

     // in addModel and the rate will be updated without problems; but
     // if a new model is loaded at the rate that we were using for the
     // last one, then we save work by not having reset this here
     //
 //    if (m_models.empty()) {
-//	m_sourceSampleRate = 0;
+//        m_sourceSampleRate = 0;
 //    }
 
     sv_frame_t 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) {
+         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();
         }
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
-	cout << "(done, lastEnd now " << lastEnd << ")" << endl;
+        cout << "(done, lastEnd now " << lastEnd << ")" << endl;
 #endif
     }
     m_lastModelEndFrame = lastEnd;
 
     m_audioGenerator->removeModel(model);

 #endif
 
     rebuildRangeLists();
 
     if (count == 0) {
-	if (m_writeBuffers) count = int(m_writeBuffers->size());
+        if (m_writeBuffers) count = int(m_writeBuffers->size());
     }
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "current playing frame = " << getCurrentPlayingFrame() << endl;
 

 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "current buffered frame = " << m_writeBufferFill << endl;
 #endif
 
     if (m_readBuffers != m_writeBuffers) {
-	delete m_writeBuffers;
+        delete m_writeBuffers;
     }
 
     m_writeBuffers = new RingBufferVector;
 
     for (int i = 0; i < count; ++i) {
-	m_writeBuffers->push_back(new RingBuffer<float>(m_ringBufferSize));
+        m_writeBuffers->push_back(new RingBuffer<float>(m_ringBufferSize));
     }
 
     m_audioGenerator->reset();
     
 //    cout << "AudioCallbackPlaySource::clearRingBuffers: Created "
-//	      << count << " write buffers" << endl;
+//              << count << " write buffers" << endl;
 
     if (!haveLock) {
-	m_mutex.unlock();
+        m_mutex.unlock();
     }
 }
 
 void
 AudioCallbackPlaySource::play(sv_frame_t startFrame)

         SVCERR << "AudioCallbackPlaySource::play: No source sample rate available, not playing" << endl;
         return;
     }
     
     if (m_viewManager->getPlaySelectionMode() &&
-	!m_viewManager->getSelections().empty()) {
+        !m_viewManager->getSelections().empty()) {
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
         cout << "AudioCallbackPlaySource::play: constraining frame " << startFrame << " to selection = ";
 #endif
 

 
     } else {
         if (startFrame < 0) {
             startFrame = 0;
         }
-	if (startFrame >= m_lastModelEndFrame) {
-	    startFrame = 0;
-	}
+        if (startFrame >= m_lastModelEndFrame) {
+            startFrame = 0;
+        }
     }
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "play(" << startFrame << ") -> aligned playback model ";
 #endif

 
 void
 AudioCallbackPlaySource::selectionChanged()
 {
     if (m_viewManager->getPlaySelectionMode()) {
-	clearRingBuffers();
+        clearRingBuffers();
     }
 }
 
 void
 AudioCallbackPlaySource::playLoopModeChanged()

 
 void
 AudioCallbackPlaySource::playSelectionModeChanged()
 {
     if (!m_viewManager->getSelections().empty()) {
-	clearRingBuffers();
+        clearRingBuffers();
     }
 }
 
 void
 AudioCallbackPlaySource::playParametersChanged(PlayParameters *)

     if (rate == 0) return 0;
 
     int inbuffer = 0; // at target rate
 
     for (int c = 0; c < getTargetChannelCount(); ++c) {
-	RingBuffer<float> *rb = getReadRingBuffer(c);
-	if (rb) {
-	    int here = rb->getReadSpace();
-	    if (c == 0 || here < inbuffer) inbuffer = here;
-	}
+        RingBuffer<float> *rb = getReadRingBuffer(c);
+        if (rb) {
+            int here = rb->getReadSpace();
+            if (c == 0 || here < inbuffer) inbuffer = here;
+        }
     }
 
     sv_frame_t readBufferFill = m_readBufferFill;
     sv_frame_t lastRetrievedBlockSize = m_lastRetrievedBlockSize;
     double lastRetrievalTimestamp = m_lastRetrievalTimestamp;

     if (!m_playing) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
         cout << "AudioCallbackPlaySource::getSourceSamples: Not playing" << endl;
 #endif
         v_zero_channels(buffer, requestedChannels, count);
-	return 0;
+        return 0;
     }
     if (requestedChannels < channels) {
         SVDEBUG << "AudioCallbackPlaySource::getSourceSamples: Not enough device channels (" << requestedChannels << ", need " << channels << "); hoping device is about to be reopened" << endl;
         v_zero_channels(buffer, requestedChannels, count);
         return 0;

         m_lastRetrievalTimestamp = m_target->getCurrentTime();
     }
 
     if (!ts || ratio == 1.f) {
 
-	int got = 0;
+        int got = 0;
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
         cout << "channels == " << channels << endl;
 #endif
         
-	for (int ch = 0; ch < channels; ++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":
-		sv_frame_t request = count;
-		if (ch > 0) request = got;
-
-		got = rb->read(buffer[ch], int(request));
-	    
+        for (int ch = 0; ch < channels; ++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":
+                sv_frame_t request = count;
+                if (ch > 0) request = got;
+
+                got = rb->read(buffer[ch], int(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 (int ch = 0; ch < channels; ++ch) {
-		for (int i = got; i < count; ++i) {
-		    buffer[ch][i] = 0.0;
-		}
-	    }
-	}
+                cout << "AudioCallbackPlaySource::getSamples: got " << got << " (of " << count << ") samples on channel " << ch << ", signalling for more (possibly)" << endl;
+#endif
+            }
+
+            for (int ch = 0; ch < channels; ++ch) {
+                for (int i = got; i < count; ++i) {
+                    buffer[ch][i] = 0.0;
+                }
+            }
+        }
 
         applyAuditioningEffect(count, buffer);
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "AudioCallbackPlaySource::getSamples: awakening thread" << endl;
 #endif
 
         m_condition.wakeAll();
 
-	return got;
+        return got;
     }
 
     sv_frame_t available;
     sv_frame_t fedToStretcher = 0;
     int warned = 0;

     static float *tmp = 0;
     static sv_frame_t tmpSize = 0;
 
     sv_frame_t space = 0;
     for (int c = 0; c < getTargetChannelCount(); ++c) {
-	RingBuffer<float> *wb = getWriteRingBuffer(c);
-	if (wb) {
-	    sv_frame_t spaceHere = wb->getWriteSpace();
-	    if (c == 0 || spaceHere < space) space = spaceHere;
-	}
+        RingBuffer<float> *wb = getWriteRingBuffer(c);
+        if (wb) {
+            sv_frame_t spaceHere = wb->getWriteSpace();
+            if (c == 0 || spaceHere < space) space = spaceHere;
+        }
     }
     
     if (space == 0) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
         cout << "AudioCallbackPlaySourceFillThread: no space to fill" << endl;

 
     // space is now the number of samples that can be written on each
     // channel's write ringbuffer
     
     sv_frame_t f = m_writeBufferFill;
-	
+        
     bool readWriteEqual = (m_readBuffers == m_writeBuffers);
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     if (!readWriteEqual) {
         cout << "AudioCallbackPlaySourceFillThread: note read buffers != write buffers" << endl;

 
     static float **bufferPtrs = 0;
     static int bufferPtrCount = 0;
 
     if (bufferPtrCount < channels) {
-	if (bufferPtrs) delete[] bufferPtrs;
-	bufferPtrs = new float *[channels];
-	bufferPtrCount = channels;
+        if (bufferPtrs) delete[] bufferPtrs;
+        bufferPtrs = new float *[channels];
+        bufferPtrCount = channels;
     }
 
     sv_frame_t generatorBlockSize = m_audioGenerator->getBlockSize();
 
     // space must be a multiple of generatorBlockSize

     }
 
     for (int c = 0; c < channels; ++c) {
 
         bufferPtrs[c] = tmp + c * space;
-	    
+            
         for (int i = 0; i < space; ++i) {
             tmp[c * space + i] = 0.0f;
         }
     }
 

     sv_frame_t selectionSize = 0;
     sv_frame_t nextChunkStart = chunkStart + chunkSize;
     
     bool looping = m_viewManager->getPlayLoopMode();
     bool constrained = (m_viewManager->getPlaySelectionMode() &&
-			!m_viewManager->getSelections().empty());
+                        !m_viewManager->getSelections().empty());
 
     int channels = getTargetChannelCount();
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "mixModels: start " << frame << ", size " << count << ", channels " << channels << endl;

     
     static float **chunkBufferPtrs = 0;
     static int chunkBufferPtrCount = 0;
 
     if (chunkBufferPtrCount < channels) {
-	if (chunkBufferPtrs) delete[] chunkBufferPtrs;
-	chunkBufferPtrs = new float *[channels];
-	chunkBufferPtrCount = channels;
+        if (chunkBufferPtrs) delete[] chunkBufferPtrs;
+        chunkBufferPtrs = new float *[channels];
+        chunkBufferPtrCount = channels;
     }
 
     for (int c = 0; c < channels; ++c) {
-	chunkBufferPtrs[c] = buffers[c];
+        chunkBufferPtrs[c] = buffers[c];
     }
 
     while (processed < count) {
-	
-	chunkSize = count - processed;
-	nextChunkStart = chunkStart + chunkSize;
-	selectionSize = 0;
-
-	sv_frame_t fadeIn = 0, fadeOut = 0;
-
-	if (constrained) {
+        
+        chunkSize = count - processed;
+        nextChunkStart = chunkStart + chunkSize;
+        selectionSize = 0;
+
+        sv_frame_t fadeIn = 0, fadeOut = 0;
+
+        if (constrained) {
 
             sv_frame_t rChunkStart =
                 m_viewManager->alignPlaybackFrameToReference(chunkStart);
-	    
-	    Selection selection =
-		m_viewManager->getContainingSelection(rChunkStart, true);
-	    
-	    if (selection.isEmpty()) {
-		if (looping) {
-		    selection = *m_viewManager->getSelections().begin();
-		    chunkStart = m_viewManager->alignReferenceToPlaybackFrame
+            
+            Selection selection =
+                m_viewManager->getContainingSelection(rChunkStart, true);
+            
+            if (selection.isEmpty()) {
+                if (looping) {
+                    selection = *m_viewManager->getSelections().begin();
+                    chunkStart = m_viewManager->alignReferenceToPlaybackFrame
                         (selection.getStartFrame());
-		    fadeIn = 50;
-		}
-	    }
-
-	    if (selection.isEmpty()) {
-
-		chunkSize = 0;
-		nextChunkStart = chunkStart;
-
-	    } else {
+                    fadeIn = 50;
+                }
+            }
+
+            if (selection.isEmpty()) {
+
+                chunkSize = 0;
+                nextChunkStart = chunkStart;
+
+            } else {
 
                 sv_frame_t sf = m_viewManager->alignReferenceToPlaybackFrame
                     (selection.getStartFrame());
                 sv_frame_t ef = m_viewManager->alignReferenceToPlaybackFrame
                     (selection.getEndFrame());
 
-		selectionSize = ef - sf;
-
-		if (chunkStart < sf) {
-		    chunkStart = sf;
-		    fadeIn = 50;
-		}
-
-		nextChunkStart = chunkStart + chunkSize;
-
-		if (nextChunkStart >= ef) {
-		    nextChunkStart = ef;
-		    fadeOut = 50;
-		}
-
-		chunkSize = nextChunkStart - chunkStart;
-	    }
-	
-	} else if (looping && m_lastModelEndFrame > 0) {
-
-	    if (chunkStart >= m_lastModelEndFrame) {
-		chunkStart = 0;
-	    }
-	    if (chunkSize > m_lastModelEndFrame - chunkStart) {
-		chunkSize = m_lastModelEndFrame - chunkStart;
-	    }
-	    nextChunkStart = chunkStart + chunkSize;
-	}
+                selectionSize = ef - sf;
+
+                if (chunkStart < sf) {
+                    chunkStart = sf;
+                    fadeIn = 50;
+                }
+
+                nextChunkStart = chunkStart + chunkSize;
+
+                if (nextChunkStart >= ef) {
+                    nextChunkStart = ef;
+                    fadeOut = 50;
+                }
+
+                chunkSize = nextChunkStart - chunkStart;
+            }
+        
+        } else if (looping && m_lastModelEndFrame > 0) {
+
+            if (chunkStart >= m_lastModelEndFrame) {
+                chunkStart = 0;
+            }
+            if (chunkSize > m_lastModelEndFrame - chunkStart) {
+                chunkSize = m_lastModelEndFrame - chunkStart;
+            }
+            nextChunkStart = chunkStart + chunkSize;
+        }
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
-	cout << "chunkStart " << chunkStart << ", chunkSize " << chunkSize << ", nextChunkStart " << nextChunkStart << ", frame " << frame << ", count " << count << ", processed " << processed << endl;
+        cout << "chunkStart " << chunkStart << ", chunkSize " << chunkSize << ", nextChunkStart " << nextChunkStart << ", frame " << frame << ", count " << count << ", processed " << processed << endl;
 #endif
         
-	if (!chunkSize) {
-	    // 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;
+        if (!chunkSize) {
+            // 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;
             if (frame < nextChunkStart) {
                 frame = nextChunkStart;
             }
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
-	    cout << "mixModels: ending at " << nextChunkStart << ", returning frame as "
+            cout << "mixModels: ending at " << nextChunkStart << ", returning frame as "
                  << frame << endl;
 #endif
-	    return count;
-	}
-
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-	cout << "mixModels: chunk at " << chunkStart << " -> " << nextChunkStart << " (size " << chunkSize << ")" << endl;
-#endif
-
-	if (selectionSize < 100) {
-	    fadeIn = 0;
-	    fadeOut = 0;
-	} else if (selectionSize < 300) {
-	    if (fadeIn > 0) fadeIn = 10;
-	    if (fadeOut > 0) fadeOut = 10;
-	}
-
-	if (fadeIn > 0) {
-	    if (processed * 2 < fadeIn) {
-		fadeIn = processed * 2;
-	    }
-	}
-
-	if (fadeOut > 0) {
-	    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) {
-	    
-	    (void) m_audioGenerator->mixModel(*mi, chunkStart, 
+            return count;
+        }
+
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+        cout << "mixModels: chunk at " << chunkStart << " -> " << nextChunkStart << " (size " << chunkSize << ")" << endl;
+#endif
+
+        if (selectionSize < 100) {
+            fadeIn = 0;
+            fadeOut = 0;
+        } else if (selectionSize < 300) {
+            if (fadeIn > 0) fadeIn = 10;
+            if (fadeOut > 0) fadeOut = 10;
+        }
+
+        if (fadeIn > 0) {
+            if (processed * 2 < fadeIn) {
+                fadeIn = processed * 2;
+            }
+        }
+
+        if (fadeOut > 0) {
+            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) {
+            
+            (void) m_audioGenerator->mixModel(*mi, chunkStart, 
                                               chunkSize, chunkBufferPtrs,
                                               fadeIn, fadeOut);
-	}
-
-	for (int c = 0; c < channels; ++c) {
-	    chunkBufferPtrs[c] += chunkSize;
-	}
-
-	processed += chunkSize;
-	chunkStart = nextChunkStart;
+        }
+
+        for (int c = 0; c < channels; ++c) {
+            chunkBufferPtrs[c] += chunkSize;
+        }
+
+        processed += chunkSize;
+        chunkStart = nextChunkStart;
     }
 
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
     cout << "mixModels returning " << processed << " frames to " << nextChunkStart << endl;
 #endif

 {
     if (m_readBuffers == m_writeBuffers) return;
 
     // only unify if there will be something to read
     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) {
-		    // OK, we don't have enough and there's more to
-		    // read -- don't unify until we can do better
+        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
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
                     cout << "AudioCallbackPlaySource::unifyRingBuffers: Not unifying: write buffer has less (" << wb->getReadSpace() << ") than " << m_blockSize*2 << " to read and write buffer fill (" << m_writeBufferFill << ") is not close to end frame (" << m_lastModelEndFrame << ")" << endl;
 #endif
-		    return;
-		}
-	    }
-	    break;
-	}
+                    return;
+                }
+            }
+            break;
+        }
     }
 
     sv_frame_t rf = m_readBufferFill;
     RingBuffer<float> *rb = getReadRingBuffer(0);
     if (rb) {
-	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;
+        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
     cout << "AudioCallbackPlaySource::unifyRingBuffers: m_readBufferFill = " << m_readBufferFill << ", rf = " << rf << ", m_writeBufferFill = " << m_writeBufferFill << endl;
 #endif
 
     sv_frame_t wf = m_writeBufferFill;
     sv_frame_t skip = 0;
     for (int c = 0; c < getTargetChannelCount(); ++c) {
-	RingBuffer<float> *wb = getWriteRingBuffer(c);
-	if (wb) {
-	    if (c == 0) {
-		
-		int wrs = wb->getReadSpace();
-//		cout << "wrs = " << wrs << endl;
-
-		if (wrs < wf) wf -= wrs;
-		else wf = 0;
-//		cout << "wf = " << wf << endl;
-		
-		if (wf < rf) skip = rf - wf;
-		if (skip == 0) break;
-	    }
-
-//	    cout << "skipping " << skip << endl;
-	    wb->skip(int(skip));
-	}
-    }
-		    
+        RingBuffer<float> *wb = getWriteRingBuffer(c);
+        if (wb) {
+            if (c == 0) {
+                
+                int wrs = wb->getReadSpace();
+//                cout << "wrs = " << wrs << endl;
+
+                if (wrs < wf) wf -= wrs;
+                else wf = 0;
+//                cout << "wf = " << wf << endl;
+                
+                if (wf < rf) skip = rf - wf;
+                if (skip == 0) break;
+            }
+
+//            cout << "skipping " << skip << endl;
+            wb->skip(int(skip));
+        }
+    }
+                    
     m_bufferScavenger.claim(m_readBuffers);
     m_readBuffers = m_writeBuffers;
     m_readBufferFill = m_writeBufferFill;
 #ifdef DEBUG_AUDIO_PLAY_SOURCE_PLAYING
     cout << "unified" << endl;

     bool previouslyPlaying = s.m_playing;
     bool work = false;
 
     while (!s.m_exiting) {
 
-	s.unifyRingBuffers();
-	s.m_bufferScavenger.scavenge();
+        s.unifyRingBuffers();
+        s.m_bufferScavenger.scavenge();
         s.m_pluginScavenger.scavenge();
 
-	if (work && s.m_playing && s.getSourceSampleRate()) {
-	    
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-	    cout << "AudioCallbackPlaySourceFillThread: not waiting" << endl;
-#endif
-
-	    s.m_mutex.unlock();
-	    s.m_mutex.lock();
-
-	} else {
-	    
-	    double ms = 100;
-	    if (s.getSourceSampleRate() > 0) {
-		ms = double(s.m_ringBufferSize) / s.getSourceSampleRate() * 1000.0;
-	    }
-	    
-	    if (s.m_playing) ms /= 10;
+        if (work && s.m_playing && s.getSourceSampleRate()) {
+            
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+            cout << "AudioCallbackPlaySourceFillThread: not waiting" << endl;
+#endif
+
+            s.m_mutex.unlock();
+            s.m_mutex.lock();
+
+        } else {
+            
+            double ms = 100;
+            if (s.getSourceSampleRate() > 0) {
+                ms = double(s.m_ringBufferSize) / s.getSourceSampleRate() * 1000.0;
+            }
+            
+            if (s.m_playing) ms /= 10;
 
 #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, int(ms));
-	}
-
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-	cout << "AudioCallbackPlaySourceFillThread: awoken" << endl;
-#endif
-
-	work = false;
-
-	if (!s.getSourceSampleRate()) {
+            cout << "AudioCallbackPlaySourceFillThread: waiting for " << ms << "ms..." << endl;
+#endif
+            
+            s.m_condition.wait(&s.m_mutex, int(ms));
+        }
+
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+        cout << "AudioCallbackPlaySourceFillThread: awoken" << endl;
+#endif
+
+        work = false;
+
+        if (!s.getSourceSampleRate()) {
 #ifdef DEBUG_AUDIO_PLAY_SOURCE
             cout << "AudioCallbackPlaySourceFillThread: source sample rate is zero" << endl;
 #endif
             continue;
         }
 
-	bool playing = s.m_playing;
-
-	if (playing && !previouslyPlaying) {
-#ifdef DEBUG_AUDIO_PLAY_SOURCE
-	    cout << "AudioCallbackPlaySourceFillThread: playback state changed, resetting" << endl;
-#endif
-	    for (int c = 0; c < s.getTargetChannelCount(); ++c) {
-		RingBuffer<float> *rb = s.getReadRingBuffer(c);
-		if (rb) rb->reset();
-	    }
-	}
-	previouslyPlaying = playing;
-
-	work = s.fillBuffers();
+        bool playing = s.m_playing;
+
+        if (playing && !previouslyPlaying) {
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+            cout << "AudioCallbackPlaySourceFillThread: playback state changed, resetting" << endl;
+#endif
+            for (int c = 0; c < s.getTargetChannelCount(); ++c) {
+                RingBuffer<float> *rb = s.getReadRingBuffer(c);
+                if (rb) rb->reset();
+            }
+        }
+        previouslyPlaying = playing;
+
+        work = s.fillBuffers();
     }
 
     s.m_mutex.unlock();
 }