Huge structural changes

Well, this commit got a bit out of hand, what with 26 files changed. Oh well.

Basically, we're using the buffermanager to dispense temporary buffers for playhandles and audioports to use.
This allows us to change the way playhandles work. Earlier, playhandles of the same track were waiting in line
to push their output to the audioport. This was of course inefficient, so now they just register themselves to the port,
then the port handles mixing the buffers.

Caveat: this is still a work in progress, the vol/pan knobs on instruments are temporarily non-functional - will be fixed in
the next commit, but I have to get some sleep now.

src/core/BufferManager.cpp

@@ -28,13 +28,16 @@
 
 sampleFrame ** BufferManager::s_available;
 QAtomicInt BufferManager::s_availableIndex = 0;
-QReadWriteLock BufferManager::s_mutex;
+sampleFrame ** BufferManager::s_released;
+QAtomicInt BufferManager::s_releasedIndex = 0;
+//QReadWriteLock BufferManager::s_mutex;
 int BufferManager::s_size;
 
 
 void BufferManager::init()
 {
 	s_available = MM_ALLOC( sampleFrame*, BM_INITIAL_BUFFERS );
+	s_released = MM_ALLOC( sampleFrame*, BM_INITIAL_BUFFERS );
 
 	int c = engine::mixer()->framesPerPeriod() * BM_INITIAL_BUFFERS;
 	sampleFrame * b = MM_ALLOC( sampleFrame, c );
@@ -53,29 +56,42 @@ sampleFrame * BufferManager::acquire()
 {
 	if( s_availableIndex < 0 )
 	{
-		s_mutex.lockForWrite();
-		if( s_availableIndex < 0 ) extend( BM_INCREMENT );
-		s_mutex.unlock();
+		qFatal( "BufferManager: out of buffers" );
 	}
-	s_mutex.lockForRead();
 	
-	sampleFrame * b = s_available[ s_availableIndex.fetchAndAddOrdered( -1 ) ];
+	int i = s_availableIndex.fetchAndAddOrdered( -1 );
+	sampleFrame * b = s_available[ i ];
 	
-	//qDebug( "acquired buffer: %p - index %d", b, int(s_availableIndex) );
-	s_mutex.unlock();
+	//qDebug( "acquired buffer: %p - index %d", b, i );
 	return b;
 }
 
 
 void BufferManager::release( sampleFrame * buf )
 {
-	s_mutex.lockForRead();
-	s_available[ s_availableIndex.fetchAndAddOrdered( 1 ) + 1 ] = buf;
-	//qDebug( "released buffer: %p - index %d", buf, int(s_availableIndex) );
-	s_mutex.unlock();
+	int i = s_releasedIndex.fetchAndAddOrdered( 1 );
+	s_released[ i ] = buf;
+	//qDebug( "released buffer: %p - index %d", buf, i );
 }
 
 
+void BufferManager::refresh() // non-threadsafe, hence it's called periodically from mixer at a time when no other threads can interfere
+{
+	if( s_releasedIndex == 0 ) return;
+	//qDebug( "refresh: %d buffers", int( s_releasedIndex ) );
+	
+	int j = s_availableIndex;
+	for( int i = 0; i < s_releasedIndex; ++i )
+	{
+		++j;
+		s_available[ j ] = s_released[ i ];
+	}
+	s_availableIndex = j;
+	s_releasedIndex = 0;
+}
+
+
+/* // non-extensible for now
 void BufferManager::extend( int c )
 {
 	s_size += c;
@@ -91,4 +107,4 @@ void BufferManager::extend( int c )
 		s_available[ s_availableIndex.fetchAndAddOrdered( 1 ) + 1 ] = b;
 		b += engine::mixer()->framesPerPeriod();
 	}
-}
+}*/

src/core/FxMixer.cpp

@@ -116,19 +116,10 @@ void FxChannel::unmuteForSolo()
 
 
 
-void FxChannel::doProcessing( sampleFrame * _buf )
+void FxChannel::doProcessing()
 {
 	const fpp_t fpp = engine::mixer()->framesPerPeriod();
 
-	// <tobydox> ignore the passed _buf
-	// <tobydox> always use m_buffer
-	// <tobydox> this is just an auxilliary buffer if doProcessing()
-	//			 needs one for processing while running
-	// <tobydox> particularly important for playHandles, so Instruments
-	//			 can operate on this buffer the whole time
-	// <tobydox> this improves cache hit rate
-	_buf = m_buffer;
-
 	if( m_muted == false )
 	{
 		foreach( FxRoute * senderRoute, m_receives )
@@ -150,21 +141,21 @@ void FxChannel::doProcessing( sampleFrame * _buf )
 				if( ! volBuf && ! sendBuf ) // neither volume nor send has sample-exact data...
 				{
 					const float v = sender->m_volumeModel.value() * sendModel->value();
-					MixHelpers::addMultiplied( _buf, ch_buf, v, fpp );
+					MixHelpers::addMultiplied( m_buffer, ch_buf, v, fpp );
 				}
 				else if( volBuf && sendBuf ) // both volume and send have sample-exact data
 				{
-					MixHelpers::addMultipliedByBuffers( _buf, ch_buf, volBuf, sendBuf, fpp );					
+					MixHelpers::addMultipliedByBuffers( m_buffer, ch_buf, volBuf, sendBuf, fpp );					
 				}
 				else if( volBuf ) // volume has sample-exact data but send does not
 				{
 					const float v = sendModel->value();
-					MixHelpers::addMultipliedByBuffer( _buf, ch_buf, v, volBuf, fpp );
+					MixHelpers::addMultipliedByBuffer( m_buffer, ch_buf, v, volBuf, fpp );
 				}
 				else // vice versa
 				{
 					const float v = sender->m_volumeModel.value();
-					MixHelpers::addMultipliedByBuffer( _buf, ch_buf, v, sendBuf, fpp );
+					MixHelpers::addMultipliedByBuffer( m_buffer, ch_buf, v, sendBuf, fpp );
 				}
 				m_hasInput = true;
 			}

src/core/InstrumentPlayHandle.cpp

@@ -0,0 +1,35 @@
+/*
+ * InstrumentPlayHandle.cpp - play-handle for driving an instrument
+ *
+ * Copyright (c) 2005-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
+ *
+ * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+
+
+#include "InstrumentPlayHandle.h"
+#include "InstrumentTrack.h"
+
+InstrumentPlayHandle::InstrumentPlayHandle( Instrument * instrument, InstrumentTrack* instrumentTrack ) :
+		PlayHandle( TypeInstrumentPlayHandle ),
+		m_instrument( instrument ),
+		m_instrumentTrack( instrumentTrack )
+{
+	setAudioPort( instrumentTrack->audioPort() );
+}

src/core/Mixer.cpp

@@ -57,7 +57,7 @@
 #include "MidiDummy.h"
 
 #include "MemoryHelper.h"
-
+#include "BufferManager.h"
 
 
 
@@ -355,6 +355,7 @@ const surroundSampleFrame * Mixer::renderNextBuffer()
 
 		if( it != m_playHandles.end() )
 		{
+			( *it )->audioPort()->removePlayHandle( ( *it ) );
 			if( ( *it )->type() == PlayHandle::TypeNotePlayHandle ) 
 			{
 				NotePlayHandleManager::release( (NotePlayHandle*) *it );
@@ -410,6 +411,7 @@ const surroundSampleFrame * Mixer::renderNextBuffer()
 		}
 		if( ( *it )->isFinished() )
 		{
+			( *it )->audioPort()->removePlayHandle( ( *it ) );
 			if( ( *it )->type() == PlayHandle::TypeNotePlayHandle ) 
 			{
 				NotePlayHandleManager::release( (NotePlayHandle*) *it );
@@ -424,7 +426,6 @@ const surroundSampleFrame * Mixer::renderNextBuffer()
 	}
 	unlockPlayHandleRemoval();
 
-
 	// STAGE 2: process effects of all instrument- and sampletracks
 	MixerWorkerThread::fillJobQueue<QVector<AudioPort *> >( m_audioPorts );
 	MixerWorkerThread::startAndWaitForJobs();
@@ -442,6 +443,9 @@ const surroundSampleFrame * Mixer::renderNextBuffer()
 	EnvelopeAndLfoParameters::instances()->trigger();
 	Controller::triggerFrameCounter();
 	AutomatableModel::incrementPeriodCounter();
+	
+	// refresh buffer pool
+	BufferManager::refresh();
 
 	m_profiler.finishPeriod( processingSampleRate(), m_framesPerPeriod );
 
@@ -472,45 +476,6 @@ void Mixer::clear()
 
 
 
-void Mixer::bufferToPort( const sampleFrame * buf,
-					const fpp_t frames,
-					stereoVolumeVector vv,
-						AudioPort * port )
-{
-	const int loop1_frame = qMin<int>( frames, m_framesPerPeriod );
-
-	port->lockFirstBuffer();
-	MixHelpers::addMultipliedStereo( port->firstBuffer(),				// dst
-										buf,							// src
-										vv.vol[0], vv.vol[1],			// coeff left/right
-										loop1_frame );					// frame count
-	port->unlockFirstBuffer();
-
-	if( frames > m_framesPerPeriod )
-	{
-		port->lockSecondBuffer();
-	
-		const fpp_t framesLeft = qMin<int>( frames - m_framesPerPeriod, m_framesPerPeriod );
-
-		MixHelpers::addMultipliedStereo( port->secondBuffer(),			// dst
-											buf + m_framesPerPeriod,	// src
-											vv.vol[0], vv.vol[1],		// coeff left/right
-											framesLeft );					// frame count
-
-		// we used both buffers so set flags
-		port->m_bufferUsage = AudioPort::BothBuffers;
-		port->unlockSecondBuffer();
-	}
-	else if( port->m_bufferUsage == AudioPort::NoUsage )
-	{
-		// only first buffer touched
-		port->m_bufferUsage = AudioPort::FirstBuffer;
-	}
-}
-
-
-
-
 void Mixer::clearAudioBuffer( sampleFrame * _ab, const f_cnt_t _frames,
 							const f_cnt_t _offset )
 {
@@ -665,7 +630,8 @@ bool Mixer::addPlayHandle( PlayHandle* handle )
 	if( criticalXRuns() == false )
 	{
 		m_playHandleMutex.lock();
-		m_newPlayHandles.append( handle );
+			m_newPlayHandles.append( handle );
+			handle->audioPort()->addPlayHandle( handle );
 		m_playHandleMutex.unlock();
 		return true;
 	}
@@ -688,6 +654,7 @@ void Mixer::removePlayHandle( PlayHandle * _ph )
 				_ph->affinity() == QThread::currentThread() )
 	{
 		lockPlayHandleRemoval();
+		_ph->audioPort()->removePlayHandle( _ph );
 		PlayHandleList::Iterator it =
 				qFind( m_playHandles.begin(),
 						m_playHandles.end(), _ph );
@@ -719,6 +686,7 @@ void Mixer::removePlayHandles( track * _track, bool removeIPHs )
 	{
 		if( ( *it )->isFromTrack( _track ) && ( removeIPHs || ( *it )->type() != PlayHandle::TypeInstrumentPlayHandle ) )
 		{
+			( *it )->audioPort()->removePlayHandle( ( *it ) );
 			if( ( *it )->type() == PlayHandle::TypeNotePlayHandle ) 
 			{
 				NotePlayHandleManager::release( (NotePlayHandle*) *it );

src/core/MixerWorkerThread.cpp

@@ -56,7 +56,7 @@ void MixerWorkerThread::JobQueue::addJob( ThreadableJob * _job )
 
 
 
-void MixerWorkerThread::JobQueue::run( sampleFrame * _buffer )
+void MixerWorkerThread::JobQueue::run()
 {
 	bool processedJob = true;
 	while( processedJob && (int) m_itemsDone < (int) m_queueSize )
@@ -67,7 +67,7 @@ void MixerWorkerThread::JobQueue::run( sampleFrame * _buffer )
 			ThreadableJob * job = m_items[i].fetchAndStoreOrdered( NULL );
 			if( job )
 			{
-				job->process( _buffer );
+				job->process();
 				processedJob = true;
 				m_itemsDone.fetchAndAddOrdered( 1 );
 			}
@@ -98,7 +98,6 @@ void MixerWorkerThread::JobQueue::wait()
 
 MixerWorkerThread::MixerWorkerThread( Mixer* mixer ) :
 	QThread( mixer ),
-	m_workingBuf( new sampleFrame[mixer->framesPerPeriod()] ),
 	m_quit( false )
 {
 	// initialize global static data
@@ -120,8 +119,6 @@ MixerWorkerThread::MixerWorkerThread( Mixer* mixer ) :
 
 MixerWorkerThread::~MixerWorkerThread()
 {
-	delete[] m_workingBuf;
-
 	workerThreads.removeAll( this );
 }
 
@@ -143,7 +140,7 @@ void MixerWorkerThread::startAndWaitForJobs()
 	// The last worker-thread is never started. Instead it's processed "inline"
 	// i.e. within the global Mixer thread. This way we can reduce latencies
 	// that otherwise would be caused by synchronizing with another thread.
-	globalJobQueue.run( workerThreads.last()->m_workingBuf );
+	globalJobQueue.run();
 	globalJobQueue.wait();
 }
 
@@ -166,7 +163,7 @@ void MixerWorkerThread::run()
 	{
 		m.lock();
 		queueReadyWaitCond->wait( &m );
-		globalJobQueue.run( m_workingBuf );
+		globalJobQueue.run();
 		m.unlock();
 	}
 }

src/core/NotePlayHandle.cpp

@@ -93,6 +93,8 @@ NotePlayHandle::NotePlayHandle( InstrumentTrack* instrumentTrack,
 		parent->m_hadChildren = true;
 
 		m_bbTrack = parent->m_bbTrack;
+		
+		parent->setUsesBuffer( false );
 	}
 
 	updateFrequency();
@@ -115,6 +117,13 @@ NotePlayHandle::NotePlayHandle( InstrumentTrack* instrumentTrack,
 			MidiTime::fromFrames( offset(), engine::framesPerTick() ), 
 			offset() );
 	}
+
+	if( m_instrumentTrack->instrument()->flags() & Instrument::IsSingleStreamed )
+	{
+		setUsesBuffer( false );
+	}
+	
+	setAudioPort( instrumentTrack->audioPort() );
 	
 	unlock();
 }
@@ -148,6 +157,9 @@ void NotePlayHandle::done()
 	m_subNotes.clear();
 
 	delete m_filter;
+	
+	if( buffer() ) releaseBuffer();
+
 	unlock();
 }
 

src/core/PlayHandle.cpp

@@ -0,0 +1,62 @@
+/*
+ * PlayHandle.cpp - base class PlayHandle - core of rendering engine
+ *
+ * Copyright (c) 2004-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
+ *
+ * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+ 
+#include "PlayHandle.h"
+#include "BufferManager.h"
+
+
+PlayHandle::PlayHandle( const Type type, f_cnt_t offset ) :
+		m_type( type ),
+		m_offset( offset ),
+		m_affinity( QThread::currentThread() ),
+		m_playHandleBuffer( NULL ),
+		m_usesBuffer( true )
+{
+}
+
+
+PlayHandle::~PlayHandle()
+{
+}
+
+
+void PlayHandle::doProcessing()
+{
+	if( m_usesBuffer )
+	{
+		if( ! m_playHandleBuffer ) m_playHandleBuffer = BufferManager::acquire();
+		play( m_playHandleBuffer );
+	}
+	else
+	{
+		play( m_playHandleBuffer );
+	}
+}
+
+
+void PlayHandle::releaseBuffer()
+{
+	BufferManager::release( m_playHandleBuffer );
+	m_playHandleBuffer = NULL;
+}

src/core/PresetPreviewPlayHandle.cpp

@@ -165,6 +165,7 @@ PresetPreviewPlayHandle::PresetPreviewPlayHandle( const QString & _preset_file,
 			typeInfo<f_cnt_t>::max() / 2,
 				note( 0, 0, DefaultKey, 100 ) );
 
+	setAudioPort( s_previewTC->previewInstrumentTrack()->audioPort() );
 
 	s_previewTC->setPreviewNote( m_previewNote );
 

src/core/SamplePlayHandle.cpp

@@ -38,13 +38,13 @@ SamplePlayHandle::SamplePlayHandle( const QString& sampleFile ) :
 	m_sampleBuffer( new SampleBuffer( sampleFile ) ),
 	m_doneMayReturnTrue( true ),
 	m_frame( 0 ),
-	m_audioPort( new AudioPort( "SamplePlayHandle", false ) ),
 	m_ownAudioPort( true ),
 	m_defaultVolumeModel( DefaultVolume, MinVolume, MaxVolume, 1 ),
 	m_volumeModel( &m_defaultVolumeModel ),
 	m_track( NULL ),
 	m_bbTrack( NULL )
 {
+	setAudioPort( new AudioPort( "SamplePlayHandle", false ) );
 }
 
 
@@ -55,13 +55,13 @@ SamplePlayHandle::SamplePlayHandle( SampleBuffer* sampleBuffer ) :
 	m_sampleBuffer( sharedObject::ref( sampleBuffer ) ),
 	m_doneMayReturnTrue( true ),
 	m_frame( 0 ),
-	m_audioPort( new AudioPort( "SamplePlayHandle", false ) ),
 	m_ownAudioPort( true ),
 	m_defaultVolumeModel( DefaultVolume, MinVolume, MaxVolume, 1 ),
 	m_volumeModel( &m_defaultVolumeModel ),
 	m_track( NULL ),
 	m_bbTrack( NULL )
 {
+	setAudioPort( new AudioPort( "SamplePlayHandle", false ) );
 }
 
 
@@ -72,13 +72,13 @@ SamplePlayHandle::SamplePlayHandle( SampleTCO* tco ) :
 	m_sampleBuffer( sharedObject::ref( tco->sampleBuffer() ) ),
 	m_doneMayReturnTrue( true ),
 	m_frame( 0 ),
-	m_audioPort( ( (SampleTrack *)tco->getTrack() )->audioPort() ),
 	m_ownAudioPort( false ),
 	m_defaultVolumeModel( DefaultVolume, MinVolume, MaxVolume, 1 ),
 	m_volumeModel( &m_defaultVolumeModel ),
 	m_track( tco->getTrack() ),
 	m_bbTrack( NULL )
 {
+	setAudioPort( ( (SampleTrack *)tco->getTrack() )->audioPort() );
 }
 
 
@@ -89,7 +89,7 @@ SamplePlayHandle::~SamplePlayHandle()
 	sharedObject::unref( m_sampleBuffer );
 	if( m_ownAudioPort )
 	{
-		delete m_audioPort;
+		delete audioPort();
 	}
 }
 
@@ -119,13 +119,11 @@ void SamplePlayHandle::play( sampleFrame * buffer )
 	if( !( m_track && m_track->isMuted() )
 				&& !( m_bbTrack && m_bbTrack->isMuted() ) )
 	{
-		stereoVolumeVector v =
+/*		stereoVolumeVector v =
 			{ { m_volumeModel->value() / DefaultVolume,
-				m_volumeModel->value() / DefaultVolume } };
+				m_volumeModel->value() / DefaultVolume } };*/
 		m_sampleBuffer->play( workingBuffer, &m_state, frames,
 								BaseFreq );
-		engine::mixer()->bufferToPort( buffer, fpp,
-						v, m_audioPort );
 	}
 
 	m_frame += frames;

src/core/audio/AudioPort.cpp

@@ -27,20 +27,18 @@
 #include "EffectChain.h"
 #include "FxMixer.h"
 #include "engine.h"
+#include "MixHelpers.h"
+#include "BufferManager.h"
 
 
 AudioPort::AudioPort( const QString & _name, bool _has_effect_chain ) :
-	m_bufferUsage( NoUsage ),
-	m_firstBuffer( new sampleFrame[engine::mixer()->framesPerPeriod()] ),
-	m_secondBuffer( new sampleFrame[
-				engine::mixer()->framesPerPeriod()] ),
+	m_bufferUsage( false ),
+	m_portBuffer( NULL ),
 	m_extOutputEnabled( false ),
 	m_nextFxChannel( 0 ),
 	m_name( "unnamed port" ),
 	m_effects( _has_effect_chain ? new EffectChain( NULL ) : NULL )
 {
-	engine::mixer()->clearAudioBuffer( m_firstBuffer, engine::mixer()->framesPerPeriod() );
-	engine::mixer()->clearAudioBuffer( m_secondBuffer, engine::mixer()->framesPerPeriod() );
 	engine::mixer()->addAudioPort( this );
 	setExtOutputEnabled( true );
 }
@@ -52,31 +50,12 @@ AudioPort::~AudioPort()
 {
 	setExtOutputEnabled( false );
 	engine::mixer()->removeAudioPort( this );
-	delete[] m_firstBuffer;
-	delete[] m_secondBuffer;
 	delete m_effects;
 }
 
 
 
 
-void AudioPort::nextPeriod()
-{
-	m_firstBufferLock.lock();
-	engine::mixer()->clearAudioBuffer( m_firstBuffer, engine::mixer()->framesPerPeriod() );
-	qSwap( m_firstBuffer, m_secondBuffer );
-
-	// this is how we decrease state of buffer-usage ;-)
-	m_bufferUsage = ( m_bufferUsage != NoUsage ) ?
-		( ( m_bufferUsage == FirstBuffer ) ?
-					NoUsage : FirstBuffer ) : NoUsage;
-
-	m_firstBufferLock.unlock();
-}
-
-
-
-
 void AudioPort::setExtOutputEnabled( bool _enabled )
 {
 	if( _enabled != m_extOutputEnabled )
@@ -109,23 +88,64 @@ bool AudioPort::processEffects()
 {
 	if( m_effects )
 	{
-		lockFirstBuffer();
-		bool hasInputNoise = m_bufferUsage != NoUsage;
-		bool more = m_effects->processAudioBuffer( m_firstBuffer, engine::mixer()->framesPerPeriod(), hasInputNoise );
-		unlockFirstBuffer();
+		bool more = m_effects->processAudioBuffer( m_portBuffer, engine::mixer()->framesPerPeriod(), m_bufferUsage );
 		return more;
 	}
 	return false;
 }
 
 
-void AudioPort::doProcessing( sampleFrame * )
+void AudioPort::doProcessing()
 {
-	const bool me = processEffects();
-	if( me || m_bufferUsage != NoUsage )
+	const fpp_t fpp = engine::mixer()->framesPerPeriod();
+
+	if( m_playHandles.isEmpty() ) return; // skip processing if no playhandles are connected
+
+	m_portBuffer = BufferManager::acquire(); // get buffer for processing
+
+	engine::mixer()->clearAudioBuffer( m_portBuffer, fpp ); // clear the audioport buffer so we can use it
+
+	//qDebug( "Playhandles: %d", m_playHandles.size() );
+	foreach( PlayHandle * ph, m_playHandles ) // now we mix all playhandle buffers into the audioport buffer
 	{
-		engine::fxMixer()->mixToChannel( firstBuffer(), nextFxChannel() );
-		nextPeriod();
+		if( ph->buffer() )
+		{
+			if( ph->usesBuffer() )
+			{
+				m_bufferUsage = true;
+				MixHelpers::add( m_portBuffer, ph->buffer(), fpp );
+			}
+			ph->releaseBuffer(); 	// gets rid of playhandle's buffer and sets 
+									// pointer to null, so if it doesn't get re-acquired we know to skip it next time
+		}
 	}
+	
+	const bool me = processEffects();
+	if( me || m_bufferUsage )
+	{
+		engine::fxMixer()->mixToChannel( m_portBuffer, m_nextFxChannel );
+		m_bufferUsage = false;
+	}
+	
+	BufferManager::release( m_portBuffer ); // release buffer, we don't need it anymore
 }
 
+
+void AudioPort::addPlayHandle( PlayHandle * handle )
+{
+	m_playHandleLock.lock();
+		m_playHandles.append( handle );
+	m_playHandleLock.unlock();
+}
+
+
+void AudioPort::removePlayHandle( PlayHandle * handle )
+{
+	m_playHandleLock.lock();
+		PlayHandleList::Iterator it =	qFind( m_playHandles.begin(), m_playHandles.end(), handle );
+		if( it != m_playHandles.end() )
+		{
+			m_playHandles.erase( it );
+		}
+	m_playHandleLock.unlock();
+}

src/tracks/InstrumentTrack.cpp

@@ -237,7 +237,7 @@ void InstrumentTrack::processAudioBuffer( sampleFrame* buf, const fpp_t frames,
 		}
 	}
 
-	engine::mixer()->bufferToPort( buf, frames, panningToVolumeVector( panning, v_scale ), &m_audioPort );
+	//engine::mixer()->bufferToPort( buf, frames, panningToVolumeVector( panning, v_scale ), &m_audioPort );
 }