VABinauralFreeFieldAudioRenderer.cpp

/*
 *  --------------------------------------------------------------------------------------------
 *
 *    VVV        VVV A           Virtual Acoustics (VA) | http://www.virtualacoustics.org
 *     VVV      VVV AAA          Licensed under the Apache License, Version 2.0
 *      VVV    VVV   AAA
 *       VVV  VVV     AAA        Copyright 2015-2017
 *        VVVVVV       AAA       Institute of Technical Acoustics (ITA)
 *         VVVV         AAA      RWTH Aachen University
 *
 *  --------------------------------------------------------------------------------------------
 */

#include "VABinauralFreefieldAudioRenderer.h"

#ifdef VACORE_WITH_RENDERER_BINAURAL_FREE_FIELD

// VA includes
#include <VA.h>

// VA core includes
#include "../../../directivities/VADirectivityDAFFEnergetic.h"
#include "../../../directivities/VADirectivityDAFFHRIR.h"
#include "../../../directivities/VADirectivityDAFFHATOHRIR.h"
#include "../../../Filtering/VAAtmosphere.h"
#include "../../../Motion/VAMotionModelBase.h"
#include "../../../Motion/VASharedMotionModel.h"
#include "../../../Motion/VASampleAndHoldMotionModel.h"
#include "../../../Scene/VAScene.h"
#include "../../../Utils/VAUtils.h"
#include "../../../VAAudiostreamTracker.h"
#include "../../../VACoreImpl.h"
#include "../../../VACoreConfig.h"
#include "../../../VALog.h"
#include <VAObjectPool.h>

// ITA includes
#include <DAFF.h>
#include <ITAUPConvolution.h>
#include <ITAUPFilter.h>
#include <ITAUPFilterPool.h>
#include <ITAAtomicPrimitives.h>
#include <ITAClock.h>
#include <ITACriticalSection.h>
#include <ITADataSourceRealization.h>
#include <ITAThirdOctaveFilterbank.h>
#include <ITAVariableDelayLine.h>
#include <ITASampleBuffer.h>
#include <ITAStopWatch.h>
#include <ITASampleFrame.h>
#include <ITAStreamInfo.h>
#include <ITAFastMath.h>
#include <ITAConstants.h>
#include <ITANumericUtils.h>

// Vista includes
#include <VistaInterProcComm/Concurrency/VistaThreadEvent.h>
#include <VistaBase/VistaQuaternion.h>

// STL includes
#include <algorithm>
#include <cassert>
#include <fstream>
#include <iomanip>

// 3rdParty includes
#include <tbb/atomic.h>
#include <tbb/concurrent_queue.h>

class CVABFFSoundPath : public CVAPoolObject
{
public:
	virtual ~CVABFFSoundPath();

	//! Retarded metrics of sound path
	class Metrics
	{
	public:
		double dRetardedDistance;				 //!< Metrical distance to retarded sound position
		VAQuat qOrientationRetSourceToReceiver; //!< Immediate angle of incidence to retarded source position in listener reference frame in YPR convention
		VAQuat qOrientationReceiverToRetSource; //!< Retarded angle of incidence to listener in source reference frame in YPR convention
	};

	//! State of directivity
	class CDirectivityState
	{
	public:
		inline CDirectivityState()
			: pData( NULL )
			, iRecord( -1 )
			, bDirectivityEnabled( true )
		{};

		IVADirectivity* pData;	//!< Directivity data, may be NULL
		int iRecord;			//!< Directivity index
		bool bDirectivityEnabled;

		inline bool operator==( const CDirectivityState& rhs ) const
		{
			bool bBothEnabled = ( bDirectivityEnabled == rhs.bDirectivityEnabled );
			bool bSameRecordIndex = ( iRecord == rhs.iRecord );
			bool bSameData = ( pData == rhs.pData );

			return ( bBothEnabled && bSameRecordIndex && bSameData );
		};
	};

	class CHRIRState
	{
	public:
		inline CHRIRState()
			: pData( NULL )
			, iRecord( -1 )
			, fDistance( 1.0f )
			, dHATODeg( 0.0f )
		{};

		IVADirectivity* pData;	 //!< HRIR data, may be NULL
		int iRecord;			 //!< HRIR index
		float fDistance;		 //!< HRIR dataset distance
		double dHATODeg; //!< HRIR head-above-torso orientation

		inline bool operator!=( const CHRIRState& rhs ) const
		{
			if( pData != rhs.pData ) return true;
			if( fDistance != rhs.fDistance ) return true;
			if( iRecord != rhs.iRecord ) return true;
			if( dHATODeg != rhs.dHATODeg ) return true;
			return false;
		};
	};

	CVABinauralFreeFieldAudioRenderer::CVABFFSource* pSource;
	CVABinauralFreeFieldAudioRenderer::CVABFFListener* pListener;

	CVASourceReceiverMetrics oRelations; //!< Informatioen on source and receiver relations (distances & angles)

	CDirectivityState oDirectivityStateCur;
	CDirectivityState oDirectivityStateNew;

	CHRIRState oHRIRStateCur;
	CHRIRState oHRIRStateNew;

	ITAAtomicBool bDelete;

	CITAThirdOctaveFilterbank* pThirdOctaveFilterBank;
	CITAVariableDelayLine* pVariableDelayLineChL;
	CITAVariableDelayLine* pVariableDelayLineChR;
	ITAUPConvolution* pFIRConvolverChL;
	ITAUPConvolution* pFIRConvolverChR;

	inline void PreRequest()
	{
		pSource = nullptr;
		pListener = nullptr;

		// Reset DSP elements
		pThirdOctaveFilterBank->Clear();
		pVariableDelayLineChL->Clear();
		pVariableDelayLineChR->Clear();
		pFIRConvolverChL->clear();
		pFIRConvolverChR->clear();
	};

	void UpdateDir( bool bDIRAuraModeEnabled );
	void UpdateMediumPropagation( double dSpeedOfSound, double dAdditionalDelaySeconds = 0.0f );
	double CalculateInverseDistanceDecrease( const double dMinimumDistance ) const;
	void UpdateHRIR( const CVAReceiverState::CVAAnthropometricParameter&, const double dHATODeg );

	//! Bestimmt die relativen Gren des Pfades
	/**
		* Diese berechneten Gren dienen als Grundlage zur Bestimmung der ausgewhlten
		* Datenstze und Einstellungen der DSP-Elemente. Ein weiteres Update der einzelnen
		* DSP-Elemente fhrt z.B. zum Filteraustausch, wenn die Statusnderung Auswirkungen hat
		* (tatschlich ein neuer Datensatz geholt werden muss).
		*
		* Diese Methode ist besonders leichtgewichtig, da sie im StreamProcess genutzt wird.
		*
		* // spter -> \return Gibt false zurck, falls die retardierten Werte noch nicht zur Verfgung stehen.
		*/
	void UpdateMetrics();
	// bool UpdateMetrics( double dTimestamp, double dSpeedOfSound ); // For retarded information

private:

	//! Standard-Konstruktor deaktivieren
	CVABFFSoundPath();

	//! Konstruktor
	CVABFFSoundPath( double dSamplerate, int iBlocklength, int iHRIRFilterLength, int iDirFilterLength );

	ITASampleFrame m_sfHRIRTemp;		 //!< Intern verwendeter Zwischenspeicher fr HRIR Datentze
	int m_iDefaultVDLSwitchingAlgorithm; //!< Umsetzung der Verzgerungsnderung

	friend class CVABFFSoundPathFactory;
};

class CVABFFSoundPathFactory : public IVAPoolObjectFactory
{
public:
	CVABFFSoundPathFactory( double dSamplerate, int iBlocklength, int iHRIRFilterLength, int iDirFilterLength )
		: m_dSamplerate( dSamplerate )
		, m_iBlocklength( iBlocklength )
		, m_iHRIRFilterLength( iHRIRFilterLength )
		, m_iDirFilterLength( iDirFilterLength )
	{};

	CVAPoolObject* CreatePoolObject()
	{
		return new CVABFFSoundPath( m_dSamplerate, m_iBlocklength, m_iHRIRFilterLength, m_iDirFilterLength );
	};

private:
	double m_dSamplerate;		//!< Abtastrate
	int m_iBlocklength;			//!< Blocklnge
	int m_iHRIRFilterLength;	//!< Filterlnge der HRIR
	int m_iDirFilterLength;		//!< Filterlnge der Richtcharakteristik
};

class CVABFFListenerPoolFactory : public IVAPoolObjectFactory
{
public:
	CVABFFListenerPoolFactory( CVACoreImpl* pCore, const CVABinauralFreeFieldAudioRenderer::CVABFFListener::Config& oConf )
		: m_pCore( pCore ), m_oListenerConf( oConf )
	{
	};

	CVAPoolObject* CreatePoolObject()
	{
		CVABinauralFreeFieldAudioRenderer::CVABFFListener * pListener;
		pListener = new CVABinauralFreeFieldAudioRenderer::CVABFFListener( m_pCore, m_oListenerConf );
		return pListener;
	};

private:
	CVACoreImpl* m_pCore;
	const CVABinauralFreeFieldAudioRenderer::CVABFFListener::Config& m_oListenerConf;

	//! Not for use, avoid C4512
	inline CVABFFListenerPoolFactory operator=( const CVABFFListenerPoolFactory & ) { VA_EXCEPT_NOT_IMPLEMENTED; };
};

class CVABFFSourcePoolFactory : public IVAPoolObjectFactory
{
public:
	CVABFFSourcePoolFactory( const CVABinauralFreeFieldAudioRenderer::CVABFFSource::Config& oConf )
		: m_oSourceConf( oConf )
	{
	};

	CVAPoolObject* CreatePoolObject()
	{
		CVABinauralFreeFieldAudioRenderer::CVABFFSource * pSource;
		pSource = new CVABinauralFreeFieldAudioRenderer::CVABFFSource( m_oSourceConf );
		return pSource;
	};

private:
	const CVABinauralFreeFieldAudioRenderer::CVABFFSource::Config& m_oSourceConf;

	//! Not for use, avoid C4512
	inline CVABFFSourcePoolFactory operator=( const CVABFFSourcePoolFactory & ) { VA_EXCEPT_NOT_IMPLEMENTED; };
};

// Renderer

CVABinauralFreeFieldAudioRenderer::CVABinauralFreeFieldAudioRenderer( const CVAAudioRendererInitParams& oParams )
	: ITADatasourceRealization( 2, oParams.pCore->GetCoreConfig()->oAudioDriverConfig.dSampleRate, oParams.pCore->GetCoreConfig()->oAudioDriverConfig.iBuffersize )
	, CVAObject( oParams.sClass + ":" + oParams.sID )
	, m_pCore( oParams.pCore )
	, m_pCurSceneState( nullptr )
	, m_bDumpListeners( false )
	, m_dDumpListenersGain( 1.0 )
	, m_iHRIRFilterLength( -1 )
	, m_dAdditionalStaticDelaySeconds( 0.0f )
	, m_oParams( oParams )
{
	// read config
	Init( *oParams.pConfig );

	IVAPoolObjectFactory* pListenerFactory = new CVABFFListenerPoolFactory( m_pCore, m_oDefaultListenerConf );
	m_pListenerPool = IVAObjectPool::Create( 16, 2, pListenerFactory, true );

	IVAPoolObjectFactory* pSourceFactory = new CVABFFSourcePoolFactory( m_oDefaultSourceConf );
	m_pSourcePool = IVAObjectPool::Create( 16, 2, pSourceFactory, true );

	m_pSoundPathFactory = new CVABFFSoundPathFactory( GetSampleRate(), GetBlocklength(), m_iHRIRFilterLength, 128 );

	m_pSoundPathPool = IVAObjectPool::Create( 64, 8, m_pSoundPathFactory, true );

	m_pUpdateMessagePool = IVAObjectPool::Create( 2, 1, new CVAPoolObjectDefaultFactory<CVABFFUpdateMessage>, true );

	ctxAudio.m_sbTempL.Init( GetBlocklength(), true );
	ctxAudio.m_sbTempR.Init( GetBlocklength(), true );
	ctxAudio.m_iResetFlag = 0; // Normal operation mode
	ctxAudio.m_iStatus = 0; // Stopped

	m_iCurGlobalAuralizationMode = IVAInterface::VA_AURAMODE_DEFAULT;

	// Register the renderer as a module
	oParams.pCore->RegisterModule( this );
}

CVABinauralFreeFieldAudioRenderer::~CVABinauralFreeFieldAudioRenderer()
{
	delete m_pSoundPathPool;
	delete m_pUpdateMessagePool;
}

void CVABinauralFreeFieldAudioRenderer::Init( const CVAStruct& oArgs )
{
	CVAConfigInterpreter conf( oArgs );

	std::string sVLDInterpolationAlgorithm;
	conf.OptString( "SwitchingAlgorithm", sVLDInterpolationAlgorithm, "linear" );
	sVLDInterpolationAlgorithm = toLowercase( sVLDInterpolationAlgorithm );

	if( sVLDInterpolationAlgorithm == "switch" )
		m_iDefaultVDLSwitchingAlgorithm = CITAVariableDelayLine::SWITCH;
	else if( sVLDInterpolationAlgorithm == "crossfade" )
		m_iDefaultVDLSwitchingAlgorithm = CITAVariableDelayLine::CROSSFADE;
	else if( sVLDInterpolationAlgorithm == "linear" )
		m_iDefaultVDLSwitchingAlgorithm = CITAVariableDelayLine::LINEAR_INTERPOLATION;
	else if( sVLDInterpolationAlgorithm == "cubicspline" )
		m_iDefaultVDLSwitchingAlgorithm = CITAVariableDelayLine::CUBIC_SPLINE_INTERPOLATION;
	else if( sVLDInterpolationAlgorithm == "windowedsinc" )
		m_iDefaultVDLSwitchingAlgorithm = CITAVariableDelayLine::WINDOWED_SINC_INTERPOLATION;
	else
		ITA_EXCEPT1( INVALID_PARAMETER, "Unrecognized interpolation algorithm '" + sVLDInterpolationAlgorithm + "' in BinauralFreefieldAudioRendererConfig" );

	conf.OptInteger( "HRIRFilterLength", m_iHRIRFilterLength, 256 );

	conf.OptNumber( "AdditionalStaticDelaySeconds", m_dAdditionalStaticDelaySeconds, 0.0f );

	// Motion model Listener
	conf.OptInteger( "MotionModelNumHistoryKeys", m_oDefaultListenerConf.iMotionModelNumHistoryKeys, 1000 );

	if( m_oDefaultListenerConf.iMotionModelNumHistoryKeys < 1 )
		VA_EXCEPT2( INVALID_PARAMETER, "Basic motion model history needs to be greater than zero" );

	conf.OptNumber( "MotionModelWindowSize", m_oDefaultListenerConf.dMotionModelWindowSize, 0.1f );
	conf.OptNumber( "MotionModelWindowDelay", m_oDefaultListenerConf.dMotionModelWindowDelay, 0.1f );

	if( ( m_oDefaultListenerConf.dMotionModelWindowSize <= 0 ) || ( m_oDefaultListenerConf.dMotionModelWindowDelay < 0 ) )
		VA_EXCEPT2( INVALID_PARAMETER, "Basic motion model window parameters parse error (zero or negative?)" );

	conf.OptBool( "MotionModelLogInputListener", m_oDefaultListenerConf.bMotionModelLogInputEnabled, false );
	conf.OptBool( "MotionModelLogEstimatedOutputListener", m_oDefaultListenerConf.bMotionModelLogEstimatedEnabled, false );

	// Motion model Source
	conf.OptInteger( "MotionModelNumHistoryKeys", m_oDefaultSourceConf.iMotionModelNumHistoryKeys, 1000 );

	if( m_oDefaultSourceConf.iMotionModelNumHistoryKeys < 1 )
		VA_EXCEPT2( INVALID_PARAMETER, "Basic motion model history needs to be greater than zero" );

	conf.OptNumber( "MotionModelWindowSize", m_oDefaultSourceConf.dMotionModelWindowSize, 0.1f );
	conf.OptNumber( "MotionModelWindowDelay", m_oDefaultSourceConf.dMotionModelWindowDelay, 0.1f );

	if( ( m_oDefaultSourceConf.dMotionModelWindowSize <= 0 ) || ( m_oDefaultSourceConf.dMotionModelWindowDelay < 0 ) )
		VA_EXCEPT2( INVALID_PARAMETER, "Basic motion model window parameters parse error (zero or negative?)" );

	conf.OptBool( "MotionModelLogInputSources", m_oDefaultSourceConf.bMotionModelLogInputEnabled, false );
	conf.OptBool( "MotionModelLogEstimatedOutputSources", m_oDefaultSourceConf.bMotionModelLogEstimatedEnabled, false );

	return;
}

void CVABinauralFreeFieldAudioRenderer::Reset()
{
	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Received reset call, indicating reset now" );
	ctxAudio.m_iResetFlag = 1; // Request reset

	if( ctxAudio.m_iStatus == 0 || m_oParams.bOfflineRendering )
	{
		VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Was not streaming, will reset manually" );
		// if no streaming active, reset manually
		//SyncInternalData();
		ResetInternalData();
	}
	else
	{
		VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Still streaming, will now wait for reset acknownledge" );
	}

	// Wait for last streaming block before internal reset
	while( ctxAudio.m_iResetFlag != 2 )
	{
		VASleep( 10 ); // Wait for acknowledge
	}

	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Operation reset has green light, clearing items" );

	// Iterate over sound pathes and free items
	std::list< CVABFFSoundPath* >::iterator it = m_lSoundPaths.begin();
	while( it != m_lSoundPaths.end() )
	{
		CVABFFSoundPath* pPath = *it;

		int iNumRefs = pPath->GetNumReferences();
		assert( iNumRefs == 1 );
		pPath->RemoveReference();

		++it;
	}
	m_lSoundPaths.clear();

	// Iterate over listener and free items
	std::map< int, CVABFFListener* >::const_iterator lcit = m_mListeners.begin();
	while( lcit != m_mListeners.end() )
	{
		CVABFFListener* pListener( lcit->second );
		pListener->pData->RemoveReference();
		assert( pListener->GetNumReferences() == 1 );
		pListener->RemoveReference();
		lcit++;
	}
	m_mListeners.clear();

	// Iterate over sources and free items
	std::map< int, CVABFFSource* >::const_iterator scit = m_mSources.begin();
	while( scit != m_mSources.end() )
	{
		CVABFFSource* pSource( scit->second );
		pSource->pData->RemoveReference();
		assert( pSource->GetNumReferences() == 1 );
		pSource->RemoveReference();
		scit++;
	}
	m_mSources.clear();

	// Scene frei geben
	if( m_pCurSceneState )
	{
		m_pCurSceneState->RemoveReference();
		m_pCurSceneState = nullptr;
	}

	ctxAudio.m_iResetFlag = 0; // Enter normal mode

	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Reset successful" );
}

void CVABinauralFreeFieldAudioRenderer::UpdateScene( CVASceneState* pNewSceneState )
{
	assert( pNewSceneState );

	m_pNewSceneState = pNewSceneState;
	if( m_pNewSceneState == m_pCurSceneState )
		return;

	// Neue Szene referenzieren (gegen Freigabe sperren)
	m_pNewSceneState->AddReference();

	// Unterschiede ermitteln: Neue Szene vs. alte Szene
	CVASceneStateDiff oDiff;
	pNewSceneState->Diff( m_pCurSceneState, &oDiff );

	// Leere Update-Nachricht zusammenstellen
	m_pUpdateMessage = dynamic_cast< CVABFFUpdateMessage* >( m_pUpdateMessagePool->RequestObject() );

	// Quellen, Hrer und Pfade verwalten
	ManageSoundPaths( m_pCurSceneState, pNewSceneState, &oDiff );

	// Bewegungsinformationen der Quellen und Hrer aktualisieren
	UpdateTrajectories();

	// Entitten der Schallpfade aktualisieren
	UpdateSoundPaths();

	// Update-Nachricht an den Audiokontext schicken
	ctxAudio.m_qpUpdateMessages.push( m_pUpdateMessage );

	// Alte Szene freigeben (dereferenzieren)
	if( m_pCurSceneState ) m_pCurSceneState->RemoveReference();
	m_pCurSceneState = m_pNewSceneState;
	m_pNewSceneState = nullptr;
}

ITADatasource* CVABinauralFreeFieldAudioRenderer::GetOutputDatasource()
{
	return this;
}

void CVABinauralFreeFieldAudioRenderer::ManageSoundPaths( const CVASceneState* pCurScene,
	const CVASceneState* pNewScene,
	const CVASceneStateDiff* pDiff )
{
	// Warning: take care for explicit sources and listeners for this renderer!

	// Iterate over current paths and mark deleted (will be removed within internal sync of audio context thread)
	std::list< CVABFFSoundPath* >::iterator itp = m_lSoundPaths.begin();
	while( itp != m_lSoundPaths.end() )
	{
		CVABFFSoundPath* pPath( *itp );
		int iSourceID = pPath->pSource->pData->iID;
		int iListenerID = pPath->pListener->pData->iID;
		bool bDeletetionRequired = false;

		// Source deleted?
		std::vector< int >::const_iterator cits = pDiff->viDelSoundSourceIDs.begin();
		while( cits != pDiff->viDelSoundSourceIDs.end() )
		{
			const int& iIDDeletedSource( *cits++ );
			if( iSourceID == iIDDeletedSource )
			{
				bDeletetionRequired = true; // Source removed, deletion required
				break;
			}
		}

		if( bDeletetionRequired == false )
		{
			// Receiver deleted?
			std::vector< int >::const_iterator citr = pDiff->viDelReceiverIDs.begin();
			while( citr != pDiff->viDelReceiverIDs.end() )
			{
				const int& iIDListenerDeleted( *citr++ );
				if( iListenerID == iIDListenerDeleted )
				{
					bDeletetionRequired = true; // Listener removed, deletion required
					break;
				}
			}
		}

		if( bDeletetionRequired )
		{
			DeleteSoundPath( pPath );
			itp = m_lSoundPaths.erase( itp ); // Increment via erase on path list
		}
		else
		{
			++itp; // no deletion detected, continue
		}
	}

	// Deleted sources
	std::vector< int >::const_iterator cits = pDiff->viDelSoundSourceIDs.begin();
	while( cits != pDiff->viDelSoundSourceIDs.end() )
	{
		const int& iID( *cits++ );
		DeleteSource( iID );
	}

	// Deleted receivers
	std::vector< int >::const_iterator citr = pDiff->viDelReceiverIDs.begin();
	while( citr != pDiff->viDelReceiverIDs.end() )
	{
		const int& iID( *citr++ );
		DeleteListener( iID );
	}

	// New sources
	cits = pDiff->viNewSoundSourceIDs.begin();
	while( cits != pDiff->viNewSoundSourceIDs.end() )
	{
		const int& iID( *cits++ );

		// Only add, if no other renderer has been connected explicitly with this source
		const CVASoundSourceDesc* pSoundSourceDesc = m_pCore->GetSceneManager()->GetSoundSourceDesc( iID );
		if( pSoundSourceDesc->sExplicitRendererID.empty() || pSoundSourceDesc->sExplicitRendererID == m_oParams.sID )
			CVABFFSource* pSource = CreateSource( iID, pNewScene->GetSoundSourceState( iID ) );
	}

	// New receivers
	citr = pDiff->viNewReceiverIDs.begin();
	while( citr != pDiff->viNewReceiverIDs.end() )
	{
		const int& iID( *citr++ );
		CVABFFListener* pListener = CreateListener( iID, pNewScene->GetReceiverState( iID ) );
	}

	// New paths: (1) new receivers, current sources
	citr = pDiff->viNewReceiverIDs.begin();
	while( citr != pDiff->viNewReceiverIDs.end() )
	{
		int iListenerID = ( *citr++ );
		CVABFFListener* pListener = m_mListeners[ iListenerID ];

		for( size_t i = 0; i < pDiff->viComSoundSourceIDs.size(); i++ )
		{
			// Only add, if no other renderer has been connected explicitly with this source
			// and only, if not marked for deletion
			int iSourceID = pDiff->viComSoundSourceIDs[ i ];
			std::map< int, CVABFFSource* >::iterator it = m_mSources.find( iSourceID );
			if( it == m_mSources.end() )
				continue; // This source is skipped by the renderer
			CVABFFSource* pSource = it->second;

			const CVASoundSourceDesc* pSoundSourceDesc = m_pCore->GetSceneManager()->GetSoundSourceDesc( iSourceID );
			if( !pSource->bDeleted &&
				( pSoundSourceDesc->sExplicitRendererID.empty() || pSoundSourceDesc->sExplicitRendererID == m_oParams.sID ) )
				CVABFFSoundPath* pPath = CreateSoundPath( pSource, pListener );
		}
	}

	// New paths: (2) new sources, current receivers
	cits = pDiff->viNewSoundSourceIDs.begin();
	while( cits != pDiff->viNewSoundSourceIDs.end() )
	{
		const int& iSourceID( *cits++ );
		std::map< int, CVABFFSource* >::iterator it = m_mSources.find( iSourceID );
		if( it == m_mSources.end() )
			continue; // Explicit source is not connected to this renderer

		CVABFFSource* pSource = it->second;
		for( size_t i = 0; i < pDiff->viComReceiverIDs.size(); i++ )
		{
			int iListenerID = pDiff->viComReceiverIDs[ i ];
			CVABFFListener* pListener = m_mListeners[ iListenerID ];
			if( !pListener->bDeleted )
				CVABFFSoundPath* pPath = CreateSoundPath( pSource, pListener );
		}
	}

	// New paths: (3) new sources, new receivers
	cits = pDiff->viNewSoundSourceIDs.begin();
	while( cits != pDiff->viNewSoundSourceIDs.end() )
	{
		const int& iSourceID( *cits++ );
		std::map< int, CVABFFSource* >::iterator it = m_mSources.find( iSourceID );

		if( it == m_mSources.end() )
			continue;

		CVABFFSource* pSource = it->second;
		assert( pSource );

		citr = pDiff->viNewReceiverIDs.begin();
		while( citr != pDiff->viNewReceiverIDs.end() )
		{
			const int& iListenerID( *citr++ );
			CVABFFListener* pListener = m_mListeners[ iListenerID ];
			CVABFFSoundPath* pPath = CreateSoundPath( pSource, pListener );
		}
	}

	return;
}

void CVABinauralFreeFieldAudioRenderer::ProcessStream( const ITAStreamInfo* pStreamInfo )
{
	if( ctxAudio.m_iStatus == 0 )
	{
		// If streaming is active, set to 1
		ctxAudio.m_iStatus = 1;
	}

	// Schallpfade abgleichen
	SyncInternalData();

	float* pfOutputChL = GetWritePointer( 0 );
	float* pfOutputChR = GetWritePointer( 1 );

	fm_zero( pfOutputChL, GetBlocklength() );
	fm_zero( pfOutputChR, GetBlocklength() );

	const CVAAudiostreamState* pStreamState = dynamic_cast< const CVAAudiostreamState* >( pStreamInfo );
	double dListenerTime = pStreamState->dSysTime;

	// Check for reset request
	if( ctxAudio.m_iResetFlag == 1 )
	{
		VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Process stream detecting reset request, will reset internally now" );
		ResetInternalData();

		return;
	}
	else if( ctxAudio.m_iResetFlag == 2 )
	{
		VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Process stream detecting ongoing reset, will stop processing here" );

		return;
	}

	SampleTrajectoriesInternal( dListenerTime );

	std::list< CVABFFListener* >::iterator lit = ctxAudio.m_lListeners.begin();
	while( lit != ctxAudio.m_lListeners.end() )
	{
		CVABFFListener* pListener( *( lit++ ) );
		pListener->psfOutput->zero();
	}

	// Update sound pathes
	std::list< CVABFFSoundPath* >::iterator spit = ctxAudio.m_lSoundPaths.begin();
	while( spit != ctxAudio.m_lSoundPaths.end() )
	{
		CVABFFSoundPath* pPath( *spit );
		CVAReceiverState* pListenerState = ( m_pCurSceneState ? m_pCurSceneState->GetReceiverState( pPath->pListener->pData->iID ) : NULL );
		CVASoundSourceState* pSourceState = ( m_pCurSceneState ? m_pCurSceneState->GetSoundSourceState( pPath->pSource->pData->iID ) : NULL );

		if( pListenerState == nullptr || pSourceState == nullptr )
		{
			// Skip if no data is present
			spit++;
			continue;
		}

		if( !pPath->pListener->bValidTrajectoryPresent || !pPath->pSource->bValidTrajectoryPresent )
		{
			// Skip if no valid trajectory data is present
			spit++;
			continue;
		}

		// --= Parameter update =--

		pPath->UpdateMetrics();

		// VDL Doppler shift settings
		bool bDPEnabledGlobal = ( m_iCurGlobalAuralizationMode & IVAInterface::VA_AURAMODE_DOPPLER ) > 0;
		bool bDPEnabledListener = ( pListenerState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_DOPPLER ) > 0;
		bool bDPEnabledSource = ( pSourceState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_DOPPLER ) > 0;
		bool bDPEnabledCurrent = ( pPath->pVariableDelayLineChL->GetAlgorithm() != CITAVariableDelayLine::SWITCH ); // switch = disabled
		bool bDPStatusChanged = ( bDPEnabledCurrent != ( bDPEnabledGlobal && bDPEnabledListener && bDPEnabledSource ) );
		if( bDPStatusChanged )
		{
			pPath->pVariableDelayLineChL->SetAlgorithm( !bDPEnabledCurrent ? m_iDefaultVDLSwitchingAlgorithm : CITAVariableDelayLine::SWITCH );
			pPath->pVariableDelayLineChR->SetAlgorithm( !bDPEnabledCurrent ? m_iDefaultVDLSwitchingAlgorithm : CITAVariableDelayLine::SWITCH );
		}
		pPath->UpdateMediumPropagation( m_pCore->oHomogeneousMedium.dSoundSpeed, m_dAdditionalStaticDelaySeconds );

		// Spherical spreading loss
		bool bSSLEnabledSource = ( pSourceState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_SPREADING_LOSS ) > 0;
		bool bSSLEnabledListener = ( pListenerState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_SPREADING_LOSS ) > 0;
		bool bSSLEnabledGlobal = ( m_iCurGlobalAuralizationMode & IVAInterface::VA_AURAMODE_SPREADING_LOSS ) > 0;
		bool bSSLEnabled = ( bSSLEnabledSource && bSSLEnabledListener && bSSLEnabledGlobal );
		double dDistanceDecrease = pPath->CalculateInverseDistanceDecrease( m_pCore->GetCoreConfig()->dDefaultMinimumDistance );
		if( bSSLEnabled == false )
			dDistanceDecrease = m_pCore->GetCoreConfig()->dDefaultDistance;

		bool bDIREnabledSource = ( pSourceState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_SOURCE_DIRECTIVITY ) > 0;
		bool bDIREnabledListener = ( pListenerState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_SOURCE_DIRECTIVITY ) > 0;
		bool bDIREnabledGlobal = ( m_iCurGlobalAuralizationMode & IVAInterface::VA_AURAMODE_SOURCE_DIRECTIVITY ) > 0;
		bool bDIREnabled = ( bDIREnabledSource && bDIREnabledListener && bDIREnabledGlobal );
		pPath->UpdateDir( bDIREnabled );

		// HATO
		const VistaQuaternion qHATO( pListenerState->GetMotionState()->GetHeadAboveTorsoOrientation().comp );
		const double dHATODeg = rad2grad( qHATO.GetAngles().b );
		pPath->UpdateHRIR( pListenerState->GetAnthropometricData(), dHATODeg );

		// Sound source gain / direct sound audibility via AuraMode flags
		bool bDSSourceStatusEnabled = ( pSourceState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_DIRECT_SOUND );
		bool bDSListenerStatusEnabled = ( pListenerState->GetAuralizationMode() & IVAInterface::VA_AURAMODE_DIRECT_SOUND );
		bool bDSGlobalStatusEnabled = ( m_iCurGlobalAuralizationMode & IVAInterface::VA_AURAMODE_DIRECT_SOUND );
		bool bDSEnabled = bDSSourceStatusEnabled && bDSListenerStatusEnabled && bDSGlobalStatusEnabled;

		float fSoundSourceGain = float( dDistanceDecrease * pSourceState->GetVolume( m_oParams.pCore->GetCoreConfig()->dDefaultAmplitudeCalibration ) );
		if( pPath->pSource->pData->bMuted || ( bDSEnabled == false ) )
			fSoundSourceGain = 0.0f;
		pPath->pFIRConvolverChL->SetGain( fSoundSourceGain );
		pPath->pFIRConvolverChR->SetGain( fSoundSourceGain );

		// --= DSP =--

		CVASoundSourceDesc* pSourceData = pPath->pSource->pData;
		const ITASampleBuffer* psbInput = pSourceData->pSignalSourceInputBuf;
		assert( psbInput ); // Knallt es hier, dann ist die Eingabequelle noch nicht gesetzt
		assert( pSourceData->iID >= 0 ); // Knallt es hier, dann wurde dem SoundPath unterm hintern die Quelle entzogen! -> Problem mit Referenzierung und Reset?

		pPath->pThirdOctaveFilterBank->Process( psbInput->data(), ctxAudio.m_sbTempL.data() );
		pPath->pVariableDelayLineChR->Process( &( ctxAudio.m_sbTempL ), &( ctxAudio.m_sbTempR ) );
		pPath->pVariableDelayLineChL->Process( &( ctxAudio.m_sbTempL ), &( ctxAudio.m_sbTempL ) ); // inplace
		pPath->pFIRConvolverChL->Process( ctxAudio.m_sbTempL.data(), ( *pPath->pListener->psfOutput )[ 0 ].data(), ITAUPConvolution::OUTPUT_MIX );
		pPath->pFIRConvolverChR->Process( ctxAudio.m_sbTempR.data(), ( *pPath->pListener->psfOutput )[ 1 ].data(), ITAUPConvolution::OUTPUT_MIX );

		spit++;
	}

	// TODO: Select active listener
	if( !ctxAudio.m_lListeners.empty() )
	{
		CVABFFListener* pActiveListener = *( ctxAudio.m_lListeners.begin() );
		fm_copy( pfOutputChL, ( *pActiveListener->psfOutput )[ 0 ].data(), m_uiBlocklength );
		fm_copy( pfOutputChR, ( *pActiveListener->psfOutput )[ 1 ].data(), m_uiBlocklength );

		// Listener dumping
		if( m_iDumpListenersFlag > 0 )
		{
			std::map< int, CVABFFListener* >::iterator it = m_mListeners.begin();
			while( it != m_mListeners.end() )
			{
				CVABFFListener* pListener = it++->second;
				pListener->psfOutput->mul_scalar( float( m_dDumpListenersGain ) );
				pListener->pListenerOutputAudioFileWriter->write( pListener->psfOutput );
			}

			// Ack on dump stop
			if( m_iDumpListenersFlag == 2 )
				m_iDumpListenersFlag = 0;
		}
	}

	IncrementWritePointer();

	return;
}

void CVABinauralFreeFieldAudioRenderer::UpdateTrajectories()
{
	// Neue Quellendaten bernehmen
	for( std::map< int, CVABFFSource* >::iterator it = m_mSources.begin(); it != m_mSources.end(); ++it )
	{
		int iSourceID = it->first;
		CVABFFSource* pSource = it->second;

		CVASoundSourceState* pSourceCur = ( m_pCurSceneState ? m_pCurSceneState->GetSoundSourceState( iSourceID ) : nullptr );
		CVASoundSourceState* pSourceNew = ( m_pNewSceneState ? m_pNewSceneState->GetSoundSourceState( iSourceID ) : nullptr );

		const CVAMotionState* pMotionCur = ( pSourceCur ? pSourceCur->GetMotionState() : nullptr );
		const CVAMotionState* pMotionNew = ( pSourceNew ? pSourceNew->GetMotionState() : nullptr );

		if( pMotionNew && ( pMotionNew != pMotionCur ) )
		{
			VA_TRACE( "BinauralFreeFieldAudioRenderer", "Source " << iSourceID << " new motion state" );
			pSource->pMotionModel->InputMotionKey( pMotionNew );
		}
	}

	// Neue Hrerdaten bernehmen
	for( std::map< int, CVABFFListener* >::iterator it = m_mListeners.begin(); it != m_mListeners.end(); ++it )
	{
		int iListenerID = it->first;
		CVABFFListener* pListener = it->second;

		CVAReceiverState* pListenerCur = ( m_pCurSceneState ? m_pCurSceneState->GetReceiverState( iListenerID ) : nullptr );
		CVAReceiverState* pListenerNew = ( m_pNewSceneState ? m_pNewSceneState->GetReceiverState( iListenerID ) : nullptr );

		const CVAMotionState* pMotionCur = ( pListenerCur ? pListenerCur->GetMotionState() : nullptr );
		const CVAMotionState* pMotionNew = ( pListenerNew ? pListenerNew->GetMotionState() : nullptr );

		if( pMotionNew && ( pMotionNew != pMotionCur ) )
		{
			VA_TRACE( "BinauralFreeFieldAudioRenderer", "Listener " << iListenerID << " new position " );// << *pMotionNew);
			pListener->pMotionModel->InputMotionKey( pMotionNew );
		}
	}
}

void CVABinauralFreeFieldAudioRenderer::SampleTrajectoriesInternal( double dTime )
{
	bool bValid = true;
	for( std::list< CVABFFSource* >::iterator it = ctxAudio.m_lSources.begin(); it != ctxAudio.m_lSources.end(); ++it )
	{
		CVABFFSource* pSource = *it;

		pSource->pMotionModel->HandleMotionKeys();
		bValid &= pSource->pMotionModel->EstimatePosition( dTime, pSource->vPredPos );
		bValid &= pSource->pMotionModel->EstimateOrientation( dTime, pSource->vPredView, pSource->vPredUp );
		pSource->bValidTrajectoryPresent = bValid;
	}

	bValid = true;
	for( std::list< CVABFFListener* >::iterator it = ctxAudio.m_lListeners.begin(); it != ctxAudio.m_lListeners.end(); ++it )
	{
		CVABFFListener* pListener = *it;

		pListener->pMotionModel->HandleMotionKeys();
		bValid &= pListener->pMotionModel->EstimatePosition( dTime, pListener->vPredPos );
		bValid &= pListener->pMotionModel->EstimateOrientation( dTime, pListener->vPredView, pListener->vPredUp );
		pListener->bValidTrajectoryPresent = bValid;
	}
}

CVABFFSoundPath* CVABinauralFreeFieldAudioRenderer::CreateSoundPath( CVABFFSource* pSource, CVABFFListener* pListener )
{
	int iSourceID = pSource->pData->iID;
	int iListenerID = pListener->pData->iID;

	assert( !pSource->bDeleted && !pListener->bDeleted );

	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Creating sound path from source " << iSourceID << " -> listener " << iListenerID );

	CVABFFSoundPath* pPath = dynamic_cast< CVABFFSoundPath* >( m_pSoundPathPool->RequestObject() );

	pPath->pSource = pSource;
	pPath->pListener = pListener;

	pPath->bDelete = false;

	CVASoundSourceState* pSourceNew = ( m_pNewSceneState ? m_pNewSceneState->GetSoundSourceState( iSourceID ) : nullptr );
	if( pSourceNew != nullptr )
		pPath->oDirectivityStateNew.pData = ( IVADirectivity* ) pSourceNew->GetDirectivityData();

	CVAReceiverState* pListenerNew = ( m_pNewSceneState ? m_pNewSceneState->GetReceiverState( iListenerID ) : nullptr );
	if( pListenerNew != nullptr )
		pPath->oHRIRStateNew.pData = ( IVADirectivity* ) pListenerNew->GetDirectivity();

	// Configure DSP elements
	pPath->pVariableDelayLineChL->SetAlgorithm( m_iDefaultVDLSwitchingAlgorithm );
	pPath->pVariableDelayLineChR->SetAlgorithm( m_iDefaultVDLSwitchingAlgorithm );


	m_lSoundPaths.push_back( pPath );
	m_pUpdateMessage->vNewPaths.push_back( pPath );

	return pPath;
}

void CVABinauralFreeFieldAudioRenderer::DeleteSoundPath( CVABFFSoundPath* pPath )
{
	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Marking sound path from source " << pPath->pSource->pData->iID << " -> listener " << pPath->pListener->pData->iID << " for deletion" );

	pPath->bDelete = true;
	pPath->RemoveReference();
	m_pUpdateMessage->vDelPaths.push_back( pPath );
}

CVABinauralFreeFieldAudioRenderer::CVABFFListener* CVABinauralFreeFieldAudioRenderer::CreateListener( const int iID, const CVAReceiverState* pListenerState )
{
	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Creating listener with ID " << iID );

	CVABFFListener* pListener = dynamic_cast< CVABFFListener* >( m_pListenerPool->RequestObject() ); // Reference = 1

	pListener->pData = m_pCore->GetSceneManager()->GetListenerDesc( iID );
	pListener->pData->AddReference();

	// Move to prerequest of pool?
	pListener->psfOutput = new ITASampleFrame( 2,
		m_pCore->GetCoreConfig()->oAudioDriverConfig.iBuffersize,
		true );
	assert( pListener->pData );
	pListener->bDeleted = false;

	// Motion model
	CVABasicMotionModel* pMotionInstance = dynamic_cast< CVABasicMotionModel* >( pListener->pMotionModel->GetInstance() );
	pMotionInstance->SetName( std::string( "bfrend_mm_listener_" + pListener->pData->sName ) );
	pMotionInstance->Reset();

	m_mListeners.insert( std::pair< int, CVABinauralFreeFieldAudioRenderer::CVABFFListener* >( iID, pListener ) );

	m_pUpdateMessage->vNewListeners.push_back( pListener );

	return pListener;
}

void CVABinauralFreeFieldAudioRenderer::DeleteListener( int iListenerID )
{
	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Marking listener with ID " << iListenerID << " for removal" );
	std::map< int, CVABFFListener* >::iterator it = m_mListeners.find( iListenerID );
	CVABFFListener* pListener = it->second;
	m_mListeners.erase( it );
	pListener->bDeleted = true;
	pListener->pData->RemoveReference();
	pListener->RemoveReference();

	m_pUpdateMessage->vDelListeners.push_back( pListener );

	return;
}

CVABinauralFreeFieldAudioRenderer::CVABFFSource* CVABinauralFreeFieldAudioRenderer::CreateSource( int iID, const CVASoundSourceState* pSourceState )
{
	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Creating source with ID " << iID );
	CVABFFSource* pSource = dynamic_cast< CVABFFSource* >( m_pSourcePool->RequestObject() );

	pSource->pData = m_pCore->GetSceneManager()->GetSoundSourceDesc( iID );
	pSource->pData->AddReference();

	pSource->bDeleted = false;

	CVABasicMotionModel* pMotionInstance = dynamic_cast< CVABasicMotionModel* >( pSource->pMotionModel->GetInstance() );
	pMotionInstance->SetName( std::string( "bfrend_mm_source_" + pSource->pData->sName ) );
	pMotionInstance->Reset();

	m_mSources.insert( std::pair< int, CVABFFSource* >( iID, pSource ) );

	m_pUpdateMessage->vNewSources.push_back( pSource );

	return pSource;
}

void CVABinauralFreeFieldAudioRenderer::DeleteSource( int iSourceID )
{
	VA_VERBOSE( "BinauralFreeFieldAudioRenderer", "Marking source with ID " << iSourceID << " for removal" );
	std::map< int, CVABFFSource* >::iterator it = m_mSources.find( iSourceID );

	if( it == m_mSources.end() ) // Not found in internal list ...
	{
		CVASoundSourceDesc* pDesc = m_pCore->GetSceneManager()->GetSoundSourceDesc( iSourceID );
		if( !pDesc->sExplicitRendererID.empty() || pDesc->sExplicitRendererID == GetObjectName() )
			VA_WARN( "BinauralFreeFieldAudioRenderer", "Attempted to remote an explicit sound source for this renderer which could not be found." );
		return;
	}

	CVABFFSource* pSource = it->second;
	m_mSources.erase( it );
	pSource->bDeleted = true;
	pSource->pData->RemoveReference();
	pSource->RemoveReference();

	m_pUpdateMessage->vDelSources.push_back( pSource );

	return;
}

void CVABinauralFreeFieldAudioRenderer::SyncInternalData()
{