VAVBAPFreefieldAudioRenderer.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-2018
 *        VVVVVV       AAA       Institute of Technical Acoustics (ITA)
 *         VVVV         AAA      RWTH Aachen University
 *
 *  --------------------------------------------------------------------------------------------
 */

#include "VAVBAPFreefieldAudioRenderer.h"

#ifdef VACORE_WITH_RENDERER_VBAP_FREE_FIELD

#include "../../../Scene/VAScene.h"
#include "../../../Utils/VAUtils.h"
#include "../../../VAAudiostreamTracker.h"
#include "../../../VACoreImpl.h"
#include "../../../VACoreConfig.h"
#include <VAException.h>
#include "../../../VALog.h"

#include <ITAConfigUtils.h>
#include <ITAConstants.h>
#include <ITADataSourceRealization.h>
#include <ITANumericUtils.h>
#include <ITAStreamPatchbay.h>
#include <ITAStreamInfo.h>
#include <ITAFastMath.h>

#include <iostream>
#include <string>
#include <sstream>
#include <math.h>
#include "VistaMath/VistaGeometries.h"


CVAVBAPFreeFieldAudioRenderer::CVAVBAPFreeFieldAudioRenderer( const CVAAudioRendererInitParams& oParams )
	: m_pCurSceneState( nullptr )
	, m_bResetTrigger( false )
	, m_oParams( oParams )
{
	CVAConfigInterpreter conf( *oParams.pConfig );

	if( !conf.OptInteger( "SetupDimension", m_iSetupDimension, 2 ) )
		VA_WARN( "VBAPFreefieldRenderer", "No setup dimension given, using 2D plane (ignoring horizontal Y component)" );

	// Hardware output setup
	std::string sOutput;
	conf.ReqString( "Output", sOutput );
	m_pOutput = oParams.pCore->GetCoreConfig()->oHardwareSetup.GetOutput( sOutput );

	if( m_pOutput == nullptr )
		VA_EXCEPT2( INVALID_PARAMETER, "Unrecognized output '" + sOutput + "' in VBAP Freefield Renderer." );

	m_vecCaveCenterPos.SetValues( 0.0f, 0.0f, 0.0f );
	m_vecCaveCenterOrientYPR.SetToZeroVector();

	// Fill loudspeaker vector
	for( size_t i = 0; i < m_pOutput->vpDevices.size(); i++ )
	{
		const CVAHardwareDevice* pDevice( m_pOutput->vpDevices[ i ] );
		CLoudspeaker oLS;
		oLS.pos.SetValues( pDevice->vPos.x, pDevice->vPos.y, pDevice->vPos.z );
		oLS.iChannel = int( i );
		oLS.iIdentifier = int( i );
		oLS.sIdentifier = pDevice->sIdentifier;
		m_voLoudspeaker.push_back( oLS );
	}

	// Handling der Sektionen
	if( m_iSetupDimension == DIM_1D )
	{
		VA_EXCEPT0( NOT_IMPLEMENTED );
	}
	else if( m_iSetupDimension == DIM_2D )
	{
		// No sectioning required, calculation is performed using nearest neighbour algorithm
	}
	else if( m_iSetupDimension == DIM_3D )
	{
		int iNumSections; //Total number of sections
		conf.ReqInteger( "NumberOfSections", iNumSections );

		for( int j = 0; j < iNumSections; j++ )
		{
			/* todo implement with vista
			// Identifier fuer Loudspeaker holen
			std::string sHelperSectionName = std::string( "Sec" ) + IntToString( j+1 );
			std::string sHelperSectionLS;
			conf.ReqString( sHelperSectionName, sHelperSectionLS );
			sHelperSectionLS.erase( std::remove(sHelperSectionLS.begin(), sHelperSectionLS.end(), ' '), sHelperSectionLS.end()); //Leerzeichen entfernen
			std::vector<std::string> vsLsSection = splitString( sHelperSectionLS, "," ); // Teilen des Strings in einzelne Identifier(strings)

			//Eckpunkte des Polygons erzeugen aus Lautsprecher Positionen
			std::list< RG_Vector > vVertices;
			//Abspeichern der Position in der internen Lautsprecherliste
			std::vector <int> viLSIdentifier;
			// Liste mit Eckpunkten fllen
			for( int k=0; k<3; k++ ) //fuer 3 Eckpunkte
			{
			for ( int l=0; l<m_voLoudspeaker.size(); l++) //Identifier in Lautsprecherliste finden
			{
			if ( m_voLoudspeaker[l].sIdentifier == vsLsSection[k] )
			{
			vVertices.push_back(  m_voLoudspeaker[l].pos );
			viLSIdentifier.push_back(l);
			}
			}
			}

			// Polygone mssen exakt 3 Eckpunkte haben um ein gueltiges VBAP setup zu representieren
			assert( vVertices.size()==3 );

			//Polygon zur Ueberpruefung des Umlaufsinns/Normalenvektores
			RG_Polygon polyCheck(vVertices);
			RG_Line line(m_vecCaveCenterPos, ( *vVertices.begin() - m_vecCaveCenterPos) );

			//Abfrage ob Umlaufsinn korrekt, andernfalls Umlaufsinn ndern
			if ((polyCheck.plane.normal_vector.dot_product(line.getDirectionVector())<0))
			{
			std::reverse(vVertices.begin(),vVertices.end());
			std::reverse(viLSIdentifier.begin(),viLSIdentifier.end());
			}

			// Polygon und zustzliche Informationen fr Sektionen erzeugen
			RG_Polygon poly(vVertices);
			poly.create_2D_projection();
			CSection newSection;
			newSection.Polygon = poly;
			newSection.iLSIdentifier = viLSIdentifier;
			newSection.iIdentifier = int(j);
			// Sektion der Sektionenliste hinzufgen
			m_voSectionList.push_back(newSection);
			*/
		}
	}
	else
	{
		VA_EXCEPT2( INVALID_PARAMETER, "Unrecognizes dimension setup for VBAP renderer." );
	}

	int iNumChannels = int( m_voLoudspeaker.size() );
	double dSampleRate = oParams.pCore->GetCoreConfig()->oAudioDriverConfig.dSampleRate;
	int iBlockLength = oParams.pCore->GetCoreConfig()->oAudioDriverConfig.iBuffersize;
	m_pdsOutput = new ITADatasourceRealization( iNumChannels, dSampleRate, iBlockLength );

	m_pdsOutput->SetStreamEventHandler( this );
}

CVAVBAPFreeFieldAudioRenderer::~CVAVBAPFreeFieldAudioRenderer()
{
	delete m_pdsOutput;
}

void CVAVBAPFreeFieldAudioRenderer::Init( const CVAStruct& oArgs )
{
	return;
}

void CVAVBAPFreeFieldAudioRenderer::Reset()
{
	m_bResetTrigger = true;
	while( m_bResetTrigger )
	{
		VASleep( 10 ); // Wait for acknowledge
	}

	m_lSoundPaths.clear();
	m_lNewSoundPaths.clear();

}

void CVAVBAPFreeFieldAudioRenderer::UpdateScene( CVASceneState* 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 );

	// Schallpfade aktualisieren
	ManageSoundPaths( &oDiff );

	double px = 0, py = 0, pz = 0, vx = 0, vy = 0, vz = 0, ux = 0, uy = 0, uz = 0;

	// Try to receive position from user (aka first listener)
	int iListenerID;
	if( m_pNewSceneState->GetNumListeners() > 0 )
	{
		std::vector< int > viListenerIDs;
		m_pNewSceneState->GetListenerIDs( &viListenerIDs );

		// Use first listener as the user of VBAP system
		iListenerID = viListenerIDs[ 0 ];
		m_vUserPosVirtualScene = m_pNewSceneState->GetReceiverState( iListenerID )->GetMotionState()->GetPosition();
		VAVec3 p, v, u;
		m_oParams.pCore->GetSoundReceiverRealWorldPositionOrientationVU( iListenerID, p, v, u );
		ConvertVU2YPR_RAD( VAVec3( vx, vy, vz ), VAVec3( ux, uy, uz ), m_oUserYPRRealWorldRAD );
		m_vUserPosRealWorld.Set( float( p.x ), float( p.y ), float( p.z ) );

		// Define reproduction system in virtual scene
		m_vReproSystemVirtualPosition = m_vUserPosVirtualScene - m_vUserPosRealWorld;
	}

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

void CVAVBAPFreeFieldAudioRenderer::ManageSoundPaths( const CVASceneStateDiff* pDiff )
{
	// ber aktuelle Pfade iterieren und gelschte markieren
	std::list< SoundPath >::iterator it = m_lSoundPaths.begin();
	while( it != m_lSoundPaths.end() )
	{
		SoundPath& oPath( *it++ );
		int iSourceID = oPath.iSourceID;

		for( std::vector< int >::const_iterator cit = pDiff->viDelSoundSourceIDs.begin(); cit != pDiff->viDelSoundSourceIDs.end(); ++cit )
		{
			if( iSourceID == ( *cit ) )
			{
				oPath.bMarkDeleted.set( true ); // Pfad zum Lschen markieren
				break;
			}
		}
	}

	// Add new sources in internal list
	for( std::vector<int>::const_iterator cit = pDiff->viNewSoundSourceIDs.begin();
		cit != pDiff->viNewSoundSourceIDs.end(); ++cit )
	{
		SoundPath oPath( m_pdsOutput->GetNumberOfChannels() );
		oPath.iSourceID = *cit;

		// Only add, if no other renderer has been connected explicitly with this source
		const CVASoundSourceDesc* pSoundSourceDesc = m_oParams.pCore->GetSceneManager()->GetSoundSourceDesc( oPath.iSourceID );
		if( pSoundSourceDesc->sExplicitRendererID.empty() || pSoundSourceDesc->sExplicitRendererID == m_oParams.sID )
			m_lNewSoundPaths.push_back( oPath );
	}

	return;
}

ITADatasource* CVAVBAPFreeFieldAudioRenderer::GetOutputDatasource()
{
	return m_pdsOutput;
}

void CVAVBAPFreeFieldAudioRenderer::SyncInternalData()
{
	// ber aktuelle Pfade iterieren und gelschte entfernen
	std::list< SoundPath >::iterator it = m_lSoundPaths.begin();
	while( it != m_lSoundPaths.end() )
	{
		SoundPath& oPath( *it );
		int iSourceID = oPath.iSourceID;

		if( oPath.bMarkDeleted )
			it = m_lSoundPaths.erase( it );
		else
			++it;
	}

	// Add new pathes to internal list
	std::list< SoundPath >::const_iterator cit = m_lNewSoundPaths.begin();
	while( cit != m_lNewSoundPaths.end() )
	{
		m_lSoundPaths.push_back( *cit++ );
	}

	m_lNewSoundPaths.clear();

	return;
}

void CVAVBAPFreeFieldAudioRenderer::HandleProcessStream( ITADatasourceRealization*, const ITAStreamInfo* pStreamInfo )
{
	// Synchronize internal lists of pathes
	SyncInternalData();
	ITASampleBuffer sbTemp;
	sbTemp.Init( m_pdsOutput->GetBlocklength(), true ); // cleared temp buffer

	// Clear output buffer
	for( unsigned int i = 0; i < m_pdsOutput->GetNumberOfChannels(); i++ )
	{
		float* pfOutputData = m_pdsOutput->GetWritePointer( i );
		fm_zero( pfOutputData, m_pdsOutput->GetBlocklength() );
	}

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

	// Iterate over pathes
	std::list< SoundPath >::iterator it = m_lSoundPaths.begin();
	while( it != m_lSoundPaths.end() )
	{
		SoundPath& oPath( *it++ );
		int iID = oPath.iSourceID;

		// If no scene present, immediately return
		if( m_pCurSceneState == nullptr )
			break;

		CVASoundSourceState* pState = m_pCurSceneState->GetSoundSourceState( iID );

		// If no motion state present, skip this source
		if( pState == nullptr )
			continue;

		int iAuralizationMode = ( m_iCurGlobalAuralizationMode & pState->GetAuralizationMode() );

		std::vector< double >& vdLoudspeakerGains( oPath.m_vdNewGains );
		std::vector< double >& vdLoudspeakerLastGains( oPath.m_vdOldGains );

		CVASoundSourceDesc* pSourceData = m_oParams.pCore->GetSceneManager()->GetSoundSourceDesc( iID );
		const ITASampleBuffer* psbInput = pSourceData->pSignalSourceInputBuf;

		const CVAMotionState* pMotionState = pState->GetMotionState();
		if( pMotionState != nullptr )
		{
			//Quellposition relativ zum Cavemittelpunkt berechnen
			VAVec3 vSoundSource = GetSourcePosition( pMotionState );

			int iListenerID;
			std::vector< int > viListenerIDs;
			m_pCurSceneState->GetListenerIDs( &viListenerIDs );

			// Use first listener as the user of VBAP system
			iListenerID = viListenerIDs[ 0 ];

			// Quelle und Hrer an der selben Position ... auslassen
			if( vSoundSource.Length() == 0.0f )
				continue;

			bool bRet = true;
			switch( m_iSetupDimension )
			{
			case 2:
				bRet = CalculateLoudspeakerGains2D( vSoundSource, vdLoudspeakerGains );
				break;
			case 3:
				bRet = CalculateLoudspeakerGains3D( vSoundSource, vdLoudspeakerGains );
				break;
			default:
				continue;
			}

			if( !bRet )
				VA_WARN( "VBAP", "Could not calculate gains" );

			double dOverallGain = pState->GetVolume( m_oParams.pCore->GetCoreConfig()->dDefaultAmplitudeCalibration );			// Lautsrke der Quelle einstellen
			dOverallGain /= vSoundSource.Length();				// 1/r Gesetz

			for( int k = 0; k < vdLoudspeakerGains.size(); k++ )		// anwenden
			{
				vdLoudspeakerGains[ k ] *= dOverallGain;
				vdLoudspeakerGains[ k ] = min( 1, vdLoudspeakerGains[ k ] );	// limitieren
			}

			const float* pfInputData = psbInput->data();
			const int iBlocklength = m_pdsOutput->GetBlocklength();
			for( unsigned int j = 0; j < m_pdsOutput->GetNumberOfChannels(); j++ )
			{
				float* pfOutputData = m_pdsOutput->GetWritePointer( j );

				if( ( vdLoudspeakerLastGains[ j ] == 0 ) && ( vdLoudspeakerGains[ j ] == 0 ) )
					continue;

				if( !( iAuralizationMode & IVAInterface::VA_AURAMODE_DIRECT_SOUND ) )
					vdLoudspeakerGains[ j ] = 0.0f; // No direct sound -> no gains

				for( int k = 0; k < iBlocklength; k++ )
				{
					double dcos = cos( k / iBlocklength*( ITAConstants::PI_F / 2 ) );
					pfOutputData[ k ] += pfInputData[ k ] * float( ( dcos * dcos * ( vdLoudspeakerLastGains[ j ] - vdLoudspeakerGains[ j ] ) + vdLoudspeakerGains[ j ] ) );
				}

				vdLoudspeakerLastGains[ j ] = vdLoudspeakerGains[ j ];
				vdLoudspeakerGains[ j ] = 0.0f;
			}
		}
	}

	m_pdsOutput->IncrementWritePointer();

	if( m_bResetTrigger )
	{
		if( m_pCurSceneState )
		{
			m_pCurSceneState->RemoveReference();
			m_pCurSceneState = nullptr;
		}
		m_bResetTrigger = false;
	}
}

void CVAVBAPFreeFieldAudioRenderer::LoadScene( const std::string& sFilename ) {}

void CVAVBAPFreeFieldAudioRenderer::UpdateGlobalAuralizationMode( int iAuraMode )
{
	m_iCurGlobalAuralizationMode = iAuraMode;
}

void CVAVBAPFreeFieldAudioRenderer::CalculateInverseMatrix3x3( const double *dOriginalMatrix, double *dInverseMatrix ) const
{
	// Matritzen werden zeilenweise gelesen/geschrieben

	// bennene Koeffizienten
	//Zeile 1
	const double& a11 = dOriginalMatrix[ 0 ];
	const double& a12 = dOriginalMatrix[ 1 ];
	const double& a13 = dOriginalMatrix[ 2 ];
	//Zeile 2
	const double& a21 = dOriginalMatrix[ 3 ];
	const double& a22 = dOriginalMatrix[ 4 ];
	const double& a23 = dOriginalMatrix[ 5 ];
	//Zeile 3
	const double& a31 = dOriginalMatrix[ 6 ];
	const double& a32 = dOriginalMatrix[ 7 ];
	const double& a33 = dOriginalMatrix[ 8 ];

	// finde Determinante
	double dDetOriginalMatrix = ( a11*a22*a33 ) + ( a12*a23*a31 ) + ( a13*a21*a32 ) - ( a13*a22*a31 ) - ( a12*a21*a33 ) - ( a11*a23*a32 );

	//Koeffizienten der Transponierten
	//Zeile 1
	const double& t11 = a11;
	const double& t12 = a21;
	const double& t13 = a31;
	//Zeile 2
	const double& t21 = a12;
	const double& t22 = a22;
	const double& t23 = a32;
	//Zeile 3
	const double& t31 = a13;
	const double& t32 = a23;
	const double& t33 = a33;


	//Finde die Determinanten der Untermatrix
	//Zeile 1
	dInverseMatrix[ 0 ] = t22*t33 - t23*t32;
	dInverseMatrix[ 1 ] = t21*t33 - t23*t31;
	dInverseMatrix[ 2 ] = t21*t32 - t22*t31;
	//Zeile 2
	dInverseMatrix[ 3 ] = t12*t33 - t13*t32;
	dInverseMatrix[ 4 ] = t11*t33 - t13*t31;
	dInverseMatrix[ 5 ] = t11*t32 - t12*t31;
	//Zeile 3
	dInverseMatrix[ 6 ] = t12*t23 - t13*t22;
	dInverseMatrix[ 7 ] = t11*t23 - t13*t21;
	dInverseMatrix[ 8 ] = t11*t22 - t12*t21;


	// Bilde neue Matrix mit Vorzeichen
	//Zeile 1
	dInverseMatrix[ 0 ] /= dDetOriginalMatrix;
	dInverseMatrix[ 1 ] /= -dDetOriginalMatrix;
	dInverseMatrix[ 2 ] /= dDetOriginalMatrix;
	//Zeile 2
	dInverseMatrix[ 3 ] /= -dDetOriginalMatrix;
	dInverseMatrix[ 4 ] /= dDetOriginalMatrix;
	dInverseMatrix[ 5 ] /= -dDetOriginalMatrix;
	//Zeile 3
	dInverseMatrix[ 6 ] /= dDetOriginalMatrix;
	dInverseMatrix[ 7 ] /= -dDetOriginalMatrix;
	dInverseMatrix[ 8 ] /= dDetOriginalMatrix;
}


bool CVAVBAPFreeFieldAudioRenderer::IsSourceDirectionWithinSection( const VAVec3& vDirection, const CSection& oSection ) const
{
	/* @todo implement with Vista
	const VistaPolygon& poly( oSection.Polygon);
	VistaRay line( m_vecCaveCenterPos, VistaVector3D( vDirection.comp ) );
	VistaVector3D point;
	//Abfrage ob Quelle berhaupt treffbar ist
	VistaVector3D v3Dir = poly.GetUpVector();
	if( v3Dir.Dot(line.GetDir()) <= 0 )
	return false;
	//Abfrage ob Polygon parallel zum Quellenvektor (falls hier treffen wrde, ungltiges VBAP set-up)
	if(intersection(line, poly.plane, point)==2)
	return false;

	return poly.point_in_polygon(point);
	*/
	return false;
}

bool CVAVBAPFreeFieldAudioRenderer::CalculateLoudspeakerGains3D( const VAVec3& vSoundSource, std::vector< double >& vdLoudspeakerGains ) const
{
	const CSection* pActiveSection = NULL;
	for( size_t i = 0; i < m_voSectionList.size(); i++ )
	{
		const CSection& oSection( m_voSectionList[ i ] );

		if( IsSourceDirectionWithinSection( vSoundSource, oSection ) )
		{
			pActiveSection = &oSection;
			break;
		}

	}

	if( pActiveSection == nullptr )
	{
		return false;
	}

	// --= calculate gains =--

	/* @todo implement with Vista
	RG_Polygon poly = pActiveSection->Polygon;
	const RG_Vector &posLS1 = poly.vertices[0];
	const RG_Vector &posLS2 = poly.vertices[1];
	const RG_Vector &posLS3 = poly.vertices[2];

	double *pMatrix;
	double *pInverse;
	double Matrix[9];
	double dInverseMatrix[9];

	Matrix[0] = posLS1.x;
	Matrix[1] = posLS1.y;
	Matrix[2] = posLS1.z;

	Matrix[3] = posLS2.x;
	Matrix[4] = posLS2.y;
	Matrix[5] = posLS2.z;

	Matrix[6] = posLS3.x;
	Matrix[7] = posLS3.y;
	Matrix[8] = posLS3.z;

	dInverseMatrix[0] = 0;
	dInverseMatrix[1] = 0;
	dInverseMatrix[2] = 0;

	dInverseMatrix[3] = 0;
	dInverseMatrix[4] = 0;
	dInverseMatrix[5] = 0;

	dInverseMatrix[6] = 0;
	dInverseMatrix[7] = 0;
	dInverseMatrix[8] = 0;

	pInverse = dInverseMatrix;
	pMatrix = Matrix;
	CalculateInverseMatrix3x3( pMatrix, pInverse );

	// Get loudspeaker identifier

	const int &LSID1 = pActiveSection->iLSIdentifier[0];
	const int &LSID2 = pActiveSection->iLSIdentifier[1];
	const int &LSID3 = pActiveSection->iLSIdentifier[2];

	vdLoudspeakerGains[LSID1] = vSoundSource.x*dInverseMatrix[0]+vSoundSource.y*dInverseMatrix[3]+vSoundSource.z*dInverseMatrix[6];
	vdLoudspeakerGains[LSID2] = vSoundSource.x*dInverseMatrix[1]+vSoundSource.y*dInverseMatrix[4]+vSoundSource.z*dInverseMatrix[7];
	vdLoudspeakerGains[LSID3] = vSoundSource.x*dInverseMatrix[2]+vSoundSource.y*dInverseMatrix[5]+vSoundSource.z*dInverseMatrix[8];

	double dCorrection = sqrt(vdLoudspeakerGains[LSID1]*vdLoudspeakerGains[LSID1]+vdLoudspeakerGains[LSID2]*vdLoudspeakerGains[LSID2]+vdLoudspeakerGains[LSID3]*vdLoudspeakerGains[LSID3]);

	vdLoudspeakerGains[LSID1]/=dCorrection;
	vdLoudspeakerGains[LSID2]/=dCorrection;
	vdLoudspeakerGains[LSID3]/=dCorrection;

	*/

	return true;
}

bool CVAVBAPFreeFieldAudioRenderer::CalculateLoudspeakerGains2D( const VAVec3& vSoundSource, std::vector< double >& vdLoudspeakerGains ) const
{
	std::vector< int > viMinIDs; //Die Indices der zu nutzenden Lautsprecher
	viMinIDs.resize( 2 );
	std::vector <double> vdMinValues; //Der Abstand des Lautsprecher zur Quelle
	vdMinValues.resize( 2 );

	for( int j = 0; j < 2; j++ )
	{
		viMinIDs[ j ] = -1;
		vdMinValues[ j ] = 8e9; //unendlich wert spezifizieren (optional)
	}

	// Aktive Lautsprecher finden 2D
	for( size_t j = 0; j < m_voLoudspeaker.size(); j++ ) // Schleife ber LS
	{
		// Entfernung berechnen
		VistaVector3D vDifference = m_voLoudspeaker[ j ].pos - VistaVector3D( vSoundSource.comp );
		double dDistance = vDifference.GetLength();

		if( dDistance < *max_element( vdMinValues.begin(), vdMinValues.end() ) )
		{
			// @todo: Warning klren ...
			int iIDChange = int( max_element( vdMinValues.begin(), vdMinValues.end() ) - vdMinValues.begin() );
			viMinIDs[ iIDChange ] = int( j );
			vdMinValues[ iIDChange ] = dDistance;
		}
	}

	int iLS1 = viMinIDs[ 0 ];
	int iLS2 = viMinIDs[ 1 ];

	const VistaVector3D &posLS1 = m_voLoudspeaker[ iLS1 ].pos;
	const VistaVector3D &posLS2 = m_voLoudspeaker[ iLS2 ].pos;

	if( ( viMinIDs[ 0 ] == -1 ) || ( viMinIDs[ 1 ] == -1 ) )
		return false;

	// Berechnung der Gains ber die Inverse
	double dDetA = ( -posLS1[ 2 ] * posLS2[ 0 ] ) - ( -posLS2[ 2 ] * posLS1[ 0 ] );

	if( dDetA == 0.0f )
		return false;

	// Berechnung der Gains nach Pulkki
	vdLoudspeakerGains[ viMinIDs[ 0 ] ] = ( 1 / dDetA*( ( -vSoundSource.z*posLS2[ 0 ] ) + ( vSoundSource.x*posLS2[ 2 ] ) ) );
	vdLoudspeakerGains[ viMinIDs[ 1 ] ] = ( 1 / dDetA*( ( -vSoundSource.z*-posLS1[ 0 ] ) + ( vSoundSource.x*-posLS1[ 2 ] ) ) );

	// Normalisierung nach Pulkki
	double dCorrection = sqrt( vdLoudspeakerGains[ viMinIDs[ 0 ] ] * vdLoudspeakerGains[ viMinIDs[ 0 ] ] + vdLoudspeakerGains[ viMinIDs[ 1 ] ] * vdLoudspeakerGains[ viMinIDs[ 1 ] ] );
	vdLoudspeakerGains[ viMinIDs[ 0 ] ] /= dCorrection;
	vdLoudspeakerGains[ viMinIDs[ 1 ] ] /= dCorrection;

	return true;
}

VAVec3 CVAVBAPFreeFieldAudioRenderer::GetSourcePosition( const CVAMotionState* pMotionState )
{
	VAVec3 vSoundSource;
	vSoundSource.x = ( pMotionState->GetPosition().x - m_vReproSystemVirtualPosition.x );
	vSoundSource.y = ( pMotionState->GetPosition().y - m_vReproSystemVirtualPosition.y );
	vSoundSource.z = ( pMotionState->GetPosition().z - m_vReproSystemVirtualPosition.z );

	VAVec3 vRotYaw( m_vRotYaw[ 0 ], m_vRotYaw[ 1 ], m_vRotYaw[ 2 ] );
	VAVec3 vRotPitch( m_vRotPitch[ 0 ], m_vRotPitch[ 1 ], m_vRotPitch[ 2 ] );
	VAVec3 vRotRoll( m_vRotRoll[ 0 ], m_vRotRoll[ 1 ], m_vRotRoll[ 2 ] );

	vSoundSource.rotatedAround( vRotYaw, float( m_oUserYPRRealWorldRAD.yaw ) );
	vSoundSource.rotatedAround( vRotPitch, float( m_oUserYPRRealWorldRAD.pitch ) );
	vSoundSource.rotatedAround( vRotRoll, float( m_oUserYPRRealWorldRAD.roll ) );

	vSoundSource.rotatedAround( vRotYaw, float( -m_oUserYPRVirtualScene.yaw ) );
	vSoundSource.rotatedAround( vRotPitch, float( -m_oUserYPRVirtualScene.pitch ) );
	vSoundSource.rotatedAround( vRotRoll, float( -m_oUserYPRVirtualScene.roll ) );

	return VAVec3( vSoundSource.x, vSoundSource.y, vSoundSource.z );
}

#endif // VACORE_WITH_RENDERER_VBAP_FREE_FIELD