VACoreImpl.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 "VACoreImpl.h"

// VA base
#include <VA.h>

// VA includes
#include "Audiosignals/VAAudioSignalSourceManager.h"
#include "Audiosignals/VAAudiofileSignalSource.h"
#include "Audiosignals/VAAudiofileSignalSource.h"
#include "Audiosignals/VAEngineSignalSource.h"
#include "Audiosignals/VAMachineSignalSource.h"
#include "Audiosignals/VASequencerSignalSource.h"
#include "directivities/VADirectivityManager.h"
#include "Rendering/VAAudioRenderer.h"
#include "Rendering/VAAudioRendererRegistry.h"
#include "Reproduction/VAAudioReproductionModule.h"
#include "Reproduction/VAAudioReproductionModuleRegistry.h"
#include "Scene/VAScene.h"
#include "Scene/VASoundSourceDesc.h"
#include "Scene/VAListenerDesc.h"
#include "Utils/VADebug.h"
#include "Utils/VAUtils.h"
#include "VAAudiostreamTracker.h"
#include "VALog.h"
#include "VACoreEventManager.h"
#include "VACoreFactory.h"
#include "VACoreThread.h"
#include "VASourceListenerMetrics.h"

#include "Drivers/Audio/VAAudioDriverBackend.h"
#include "Drivers/Audio/VAAudioDriverConfig.h"

#ifdef VACORE_WITH_AUDIO_BACKEND_ASIO
#include "Drivers/Audio/VAASIOBackend.h"
#endif
#ifdef VACORE_WITH_AUDIO_BACKEND_PORTAUDIO
#include "Drivers/Audio/VAPortaudioBackend.h"
#endif

// ITA includes
#include <ITAASCIITable.h>
#include <ITAClock.h>
#include <ITAException.h>
#include <ITAFileSystemUtils.h>
#include <ITAFunctors.h>
#include <ITAStreamDetector.h>
#include <ITASoundSample.h>
#include <ITASoundSampler.h>
#include <ITASoundSamplePool.h>
#include <ITAStreamAmplifier.h>
#include <ITAStreamPatchBay.h>
#include <ITAStreamProbe.h>
#include <ITAStringUtils.h>

// Vista includes
#include <VistaTools/VistaFileSystemFile.h>
#include <VistaTools/VistaFileSystemDirectory.h>

// 3rdParty includes
#include <DAFF.h>

// STL includes
#include <algorithm>
#include <iomanip>
#include <iostream>

/*

	Informationen
	=-=-=-=-=-=-=

	Thread-safety & locking

	Alle durch die Schnittstelle nach aussen angebotenen Funktionen, werden
	gegen Reentrance grob-granular mittels eines kritischen Bereiches gesperrt.
	Damit sind auch parallele Calls auf unterschiedliche Methoden der Klasse
	unterbunden. Sollte dies zu Performance-Problemen fhren, kann ein
	verfeinerter Locking-Mechanismus entwickelt werden. Zunchst mal aber so.


	TODO: berall sicherstellen, das ITAExceptions zu VAExceptions umgebaut werden!!!

	*/


// --= Hilfsmakros =--

// berprfung ob Initialisiert
#define VA_CHECK_INITIALIZED \
{ if (m_iState != VA_CORESTATE_READY) VA_EXCEPT2(MODAL_ERROR, "Core not initialized"); }

// Mutex-Lock welches parallelen Methoden-Mehrfracheintritt (reentrance) im Methoden-Scope verhindert
#define VA_NO_REENTRANCE \
ITACriticalSectionLock oReentranceLock(m_csReentrance)

// Manuelles das Lock gegen parallelen Methoden-Mehrfracheintritt (reentrance) holen
#define VA_LOCK_REENTRANCE \
m_csReentrance.enter()

// Manuelle das Lock gegen parallelen Methoden-Mehrfracheintritt (reentrance) freigeben 
#define VA_UNLOCK_REENTRANCE \
m_csReentrance.leave()

/*

	Sichere Ausnahmebehandlung

	Problem: Intern knnen auch andere Typen von Ausnahmen als
	CVAException geworfen werden. Nach aussen hin drfen
	aber NUR CVAExceptions geworfen werden (Konsistent)

	Lsung: TRY-/CATCH-Makros fr abgesicherte Bereiche in allen Methoden
	der externen Schnittstelle. Zweistufiger Aufbau.
	1. (innen) Fange alle Exception-Typen und konvertiere sie in CVAExceptions
	2. (aussen) Fange die einzig mgl. CVAExceptions und biete
	gemeinsamen Catch-Weg zur Problemlsung (Aufrumen) an

	try {
	try {
	// Code ...
	} catch (ITAException& e) {
	// Konvertiere zu CVAException
	} catch (VistaExceptionBase& e) {
	// Konvertiere zu CVAException
	} catch (...)
	// Generiere unerwartete CVAException
	}
	} catch (CVAException& e) {
	// Gemeinsames Aufrumen
	}

	Beispiel:

	VA_TRY {
	// Code ..
	} VA_CATCH {
	// Mach was ...
	}

	Hinweis: Initiale/finale Geschweifte Klammer fehlen, da diese hinter die Makros geschrieben werden

	*/

#define VA_TRY \
try { try

#define VA_CATCH(EXPR) \
catch( CVAException& e ) { throw e; } \
catch( ITAException& e ) { throw convert2VAException( e ); } \
catch( VistaExceptionBase& e ) { throw convert2VAException( e ); } \
catch( ... ) { throw getDefaultUnexpectedVAException(); } \
} catch( CVAException& EXPR )

#define VA_FINALLY \
catch( CVAException& e ) { throw e; } \
catch( ITAException& e ) { throw convert2VAException( e ); } \
catch( VistaExceptionBase& e ) { throw convert2VAException(e); } \
catch( ... ) { throw getDefaultUnexpectedVAException(); } \
} catch( ... )

#define VA_RETHROW \
catch( CVAException& e ) { throw e; } \
catch( ITAException& e ) { throw convert2VAException( e ); } \
catch( VistaExceptionBase& e ) { throw convert2VAException( e ); } \
catch( ... ) { throw getDefaultUnexpectedVAException(); } \
} catch( ... ) { throw; }


IVAInterface* VACore::CreateCoreInstance( const CVAStruct& oArgs )
{
	VA_TRACE( "Config", oArgs );
	return new CVACoreImpl( oArgs );
}

IVAInterface* VACore::CreateCoreInstance( const std::string& sConfigFile )
{
	CVAStruct oFinalCoreConfigStruct, oCurrentConfig;
	std::list< VistaFileSystemFile > voConfigFiles;
	std::vector< VistaFileSystemDirectory > voIncludePaths;
	voConfigFiles.push_back( VistaFileSystemFile( sConfigFile ) );

	VA_PRINT( "VA working directory: '" << VistaFileSystemDirectory::GetCurrentWorkingDirectory() << "'" );

	while( voConfigFiles.empty() == false )
	{
		VistaFileSystemFile oCurrentConfigFile( voConfigFiles.front() );
		voConfigFiles.pop_front();

		if( oCurrentConfigFile.Exists() == false )
		{
			for( size_t n = 0; n < voIncludePaths.size(); n++ )
			{
				std::string sCombinedFilePath = voIncludePaths[ n ].GetName() + PATH_SEPARATOR + oCurrentConfigFile.GetLocalName();
				oCurrentConfigFile.SetName( sCombinedFilePath );
				if( oCurrentConfigFile.Exists() && oCurrentConfigFile.IsFile() )
				{
					VA_INFO( "Config", "Including further configuration file '" + oCurrentConfigFile.GetLocalName() +
						"' from include path '" + voIncludePaths[ n ].GetName() + "'" );
					break;
				}
			}

			if( !oCurrentConfigFile.Exists() )
			{
				VA_EXCEPT2( FILE_NOT_FOUND, "Configuration file '" + oCurrentConfigFile.GetLocalName() + "' not found, aborting." );
			}
		}

		VA_VERBOSE( "Config", std::string( "Reading INI file '" ) + oCurrentConfigFile.GetLocalName() + "'" );
		readINIFileAsStruct( oCurrentConfigFile.GetName(), oCurrentConfig );

		if( oCurrentConfig.HasKey( "paths" ) )
		{
			const CVAStruct& oPaths( oCurrentConfig[ "paths" ] );
			CVAStruct::const_iterator it = oPaths.Begin();
			while( it != oPaths.End() )
			{
				const CVAStructValue& oIncludePath( ( it++ )->second );
				VistaFileSystemDirectory oNewPathDir( oIncludePath );
				if( oNewPathDir.Exists() && oNewPathDir.IsDirectory() )
					voIncludePaths.push_back( oNewPathDir );
			}
		}

		if( oCurrentConfig.HasKey( "files" ) )
		{
			const CVAStruct& oPaths( oCurrentConfig[ "files" ] );
			CVAStruct::const_iterator it = oPaths.Begin();
			while( it != oPaths.End() )
			{
				const CVAStructValue& oIncludeFile( ( it++ )->second );

				voConfigFiles.push_back( VistaFileSystemFile( oIncludeFile ) );
			}
		}

		oCurrentConfig.RemoveKey( "files" );

		// Merge structs (check for uniqueness)
		oFinalCoreConfigStruct.Merge( oCurrentConfig, true );
	}

	return CreateCoreInstance( oFinalCoreConfigStruct );
}

#ifdef WIN32
// Trick um DLL-Pfad zu ermitteln
EXTERN_C IMAGE_DOS_HEADER __ImageBase;
#endif

std::string VACore::GetCoreLibFilePath()
{
#ifdef WIN32
	CHAR pszPath[ MAX_PATH + 1 ] = { 0 };
	GetModuleFileNameA( ( HINSTANCE ) &__ImageBase, pszPath, _countof( pszPath ) );
	return std::string( pszPath );
#else
	VA_EXCEPT2( NOT_IMPLEMENTED, "This function is not implemented for your platform. Sorry." );
	return "";
#endif // WIN32
}

CVACoreImpl::CVACoreImpl( const CVAStruct& oArgs )
	: m_pAudioDriverBackend( nullptr ),
	m_pGlobalSamplePool( nullptr ),
	m_pGlobalSampler( nullptr ),
	m_pSignalSourceMan( nullptr ),
	m_pDirMan( nullptr ),
	m_pSceneMan( nullptr ),
	m_pNewSceneState( nullptr ),
	m_iCurActiveListener( -1 ),
	m_iNewActiveListener( -1 ),
	m_iUpdActiveListener( -1 ),
	m_pCoreEventMan( nullptr ),
	m_pCoreThread( nullptr ),
	m_pInputAmp( nullptr ),
	m_pR2RPatchbay( nullptr ),
	m_pOutputPatchbay( nullptr ),
	m_pInputStreamDetector( nullptr ),
	m_pOutputStreamDetector( nullptr ),
	m_pOutputTracker( nullptr ),
	m_pStreamProbeDeviceInput( nullptr ),
	m_pStreamProbeFinal( nullptr ),
	m_pCurSceneState( nullptr ),
	m_pClock( ITAClock::getDefaultClock() ),
	m_pTicker( NULL ),
	m_lSyncModOwner( -1 ),
	m_lSyncModSpinCount( 0 ),
	m_iState( VA_CORESTATE_CREATED ),

	// TODO: Welche Default-Wert mssen erst in Initialize gesetzt werden?
	m_iGlobalAuralizationMode( IVAInterface::VA_AURAMODE_ALL ),
	m_dOutputGain( 1 ), m_dInputGain( 1 ),
	m_bOutputMuted( false ), m_bInputMuted( false ),
	m_dStreamClockOffset( 0 ), m_fCoreClockOffset( 0 ),

	// --= Profiling =--
	m_pmCoreThreadLoopTotalDuration( "Core thread loop" )
{
	VA_NO_REENTRANCE;

	VA_TRY
	{
		// read configuration
		m_oCoreConfig.Init( oArgs );

		// register core itself as a module
		SetObjectName( "VACore" );
		m_oModules.RegisterObject( this );
		VA_VERBOSE( "Core", "Registered core module with name '" << GetObjectName() << "'" );

		// Der Event-Manager muss immer verfgbar sein,
		// unabhnging davon ob der Core initialisiert wurde oder nicht.
		m_pCoreEventMan = new CVACoreEventManager;

		m_iState = VA_CORESTATE_CREATED;

		VA_TRACE( "Core", "CVACoreImpl instance created [" << this << "]" );

	}
	VA_RETHROW;
}

CVACoreImpl::~CVACoreImpl()
{
	VA_NO_REENTRANCE;

	// Implizit finalisieren, falls dies nicht durch den Benutzer geschah
	if( m_iState == VA_CORESTATE_READY )
	{
		VA_TRY
		{
			Finalize();
		}
			VA_FINALLY
		{
			// Fehler beim Finalisieren ignorieren
		};
	}

	// Nachricht senden [blocking], das die Kerninstanz gelscht wird.
	CVAEvent ev;
	ev.iEventType = CVAEvent::VA_EVENT_DESTROY;
	ev.pSender = this;
	m_pCoreEventMan->BroadcastEvent( ev );

	// Module deregistrieren
	m_oModules.Clear();

	// Nachrichten-Manager freigeben
	VA_TRY
	{
		delete m_pCoreEventMan;
	}
	VA_RETHROW;

	VA_TRACE( "Core", "CVACoreImpl instance deleted [" << this << "]" );

	// Profiling ausgeben
	VA_VERBOSE( "Core", m_pmCoreThreadLoopTotalDuration.ToString() );
}

void CVACoreImpl::SetDebugStream( std::ostream* posDebug )
{
	VALog_setOutputStream( posDebug );
	VALog_setErrorStream( posDebug );
}

void CVACoreImpl::GetVersionInfo( CVAVersionInfo* pVersionInfo ) const
{
	if( !pVersionInfo )
		return;

	std::stringstream ss;
	ss << VACORE_VERSION_MAJOR << "." << VACORE_VERSION_MINOR;
	pVersionInfo->sVersion = ss.str();
	ss.clear();
#ifdef VACORE_CMAKE_DATE
	ss << VACORE_CMAKE_DATE;
#else
	ss << "Unkown date";
#endif
	pVersionInfo->sDate = ss.str();
	pVersionInfo->sFlags = "";

#ifdef DEBUG
	pVersionInfo->sComments = "debug";
#else
	pVersionInfo->sComments = "release";
#endif
}

void CVACoreImpl::AttachEventHandler( IVAEventHandler* pCoreEventHandler )
{
	VA_TRY
	{
		// Immer mglich. Unabhngig vom Zustand. Thread-safety wird im Manager geregelt.
		m_pCoreEventMan->AttachHandler( pCoreEventHandler );
	}
	VA_RETHROW;
}

void CVACoreImpl::DetachEventHandler( IVAEventHandler* pCoreEventHandler )
{
	VA_TRY
	{
		// Immer mglich. Unabhngig vom Zustand. Thread-safety wird im Manager geregelt.
		m_pCoreEventMan->DetachHandler( pCoreEventHandler );
	}
	VA_RETHROW;
}

int CVACoreImpl::GetState() const
{
	VA_VERBOSE( "Core", "Core state requested, current state is " << m_iState );
	return m_iState;
}

void CVACoreImpl::Initialize() {
	VA_NO_REENTRANCE;

	// TODO: Prfen ob im Fehlerfall zurck in den sauberen Grundzustand [WICHTIG!]

	VA_VERBOSE( "Core", "Initializing core" );

	VA_TRY
	{
		if( m_iState == VA_CORESTATE_READY )
		VA_EXCEPT2( MODAL_ERROR, "Core already initialized." );

		if( m_iState == VA_CORESTATE_FAIL )
			VA_EXCEPT2( MODAL_ERROR, "Core corrupted, reinitialization impossible" );

		m_pCoreThread = new CVACoreThread( this );

		SetProgress( "Setting up audio hardware", "", 1 );
		InitializeAudioDriver();

		m_pR2RPatchbay = new ITAStreamPatchbay( m_oCoreConfig.oAudioDriverConfig.dSampleRate, m_oCoreConfig.oAudioDriverConfig.iBuffersize );

		// Create output patch bay with a single output that uses all available physical audio outputs from sound card
		m_pOutputPatchbay = new ITAStreamPatchbay( m_oCoreConfig.oAudioDriverConfig.dSampleRate, m_oCoreConfig.oAudioDriverConfig.iBuffersize );
		int iPhysicalHardwareOutput = m_pOutputPatchbay->AddOutput( m_oCoreConfig.oAudioDriverConfig.iOutputChannels );
		m_pOutputPatchbay->SetOutputGain( iPhysicalHardwareOutput, m_dOutputGain );

		m_iGlobalAuralizationMode = VA_AURAMODE_ALL;

		// Set up input stream network
		ITADatasource* pInputTail = nullptr;
		if( m_oCoreConfig.oAudioDriverConfig.iInputChannels > 0 )
		{
			pInputTail = m_pAudioDriverBackend->getInputStreamDatasource();
			if( pInputTail )
			{
				m_pInputAmp = new ITAStreamAmplifier( pInputTail, ( float ) m_dInputGain );
				m_pInputStreamDetector = new ITAStreamDetector( m_pInputAmp );
				pInputTail = m_pInputStreamDetector;

				if( m_oCoreConfig.bRecordDeviceInputEnabled )
				{
					m_pStreamProbeDeviceInput = new ITAStreamProbe( pInputTail, m_oCoreConfig.sRecordDeviceInputFilePath );
					pInputTail = m_pStreamProbeDeviceInput;
				}
			}
		}

		SetProgress( "Setting up resource managers", "", 2 );

		m_pSignalSourceMan = new CVAAudioSignalSourceManager( this, m_oCoreConfig.oAudioDriverConfig, pInputTail );
		m_pGlobalSamplePool = ITASoundSamplePool::Create( 1, m_oCoreConfig.oAudioDriverConfig.dSampleRate );
		m_pGlobalSampler = ITASoundSampler::Create( 1, m_oCoreConfig.oAudioDriverConfig.dSampleRate, m_oCoreConfig.oAudioDriverConfig.iBuffersize, m_pGlobalSamplePool );
		m_pGlobalSampler->AddMonoTrack();

		m_pDirMan = new CVADirectivityManager( this, m_oCoreConfig.oAudioDriverConfig.dSampleRate );
		m_pDirMan->Initialize();

		SetProgress( "Setting up scene management", "", 3 );

		m_pSceneMan = new CVASceneManager( m_pClock );
		m_pSceneMan->Initialize();
		m_pCurSceneState = m_pSceneMan->GetHeadSceneState();

		// Register all renderers and initialize
		CVAAudioRendererRegistry::GetInstance()->RegisterInternalCoreFactoryMethods();
		InitializeAudioRenderers();

		if( m_voRenderers.empty() )
			VA_EXCEPT1( "No audio renderers created" );

		SetProgress( "Initializing reproduction modules", "", 6 );

		// Register all reproductions and initialize
		CVAAudioReproductionModuleRegistry::GetInstance()->RegisterInternalCoreFactoryMethods();
		InitializeReproductionModules();

		if( m_voReproductionModules.empty() )
			VA_EXCEPT1( "No audio reproduction modules created" );

		// Patch renderer and reproduction modules
		PatchRendererToReproductionModules();

		// Patch audio reproduction to output
		// TODO:
		//SetProgress( "Patching audio modules", "", 7 );
		PatchReproductionModulesToOutput();

		/* Wire the global sampler (1:N)
		int iGlobalSamplerInput = m_pOutputPatchbay->AddInput( m_pGlobalSampler );
		int iNumPhysicalOutputChannels = m_pOutputPatchbay->GetOutputNumChannels( iPhysicalHardwareOutput );
		for( int i=0; i<iNumPhysicalOutputChannels; i++ )
		m_pOutputPatchbay->ConnectChannels( iGlobalSamplerInput, 0, iPhysicalHardwareOutput, i );
		*/

		// Create output peak detector that uses patch bay output stream
		m_pOutputStreamDetector = new ITAStreamDetector( m_pOutputPatchbay->GetOutputDatasource( iPhysicalHardwareOutput ) );

		// Setup output dump (if set)
		ITADatasource* pOutputTail = m_pOutputStreamDetector;
		if( m_oCoreConfig.bRecordDeviceOutputEnabled )
		{
			m_pStreamProbeFinal = new ITAStreamProbe( pOutputTail, m_oCoreConfig.sRecordFinalOutputFilePath );
			pOutputTail = m_pStreamProbeFinal;
		}

		// Attach the stream tracker
		m_pOutputTracker = new CVAAudiostreamTracker( pOutputTail, m_pClock, &m_fCoreClockOffset, &m_lSyncModOwner, m_pSignalSourceMan );
		pOutputTail = m_pOutputTracker;

		// Give output stream datasource to audio driver
		m_pAudioDriverBackend->setOutputStreamDatasource( pOutputTail );

		// Core-Clock auf 0 initialisieren
		double dNow = m_pClock->getTime();
		m_fCoreClockOffset = ( float ) dNow;
		m_dStreamClockOffset = -1;

		// Timer erzeugen und konfigurieren (wird fr Peak-Events benutzt)
		m_pTicker = new VistaTicker();
		m_pTicker->AddTrigger( new VistaTicker::TriggerContext( m_oCoreConfig.iTriggerUpdateMilliseconds, true ) );
		m_pTicker->SetAfterPulseFunctor( this );

		// Audio-Streaming starten
		SetProgress( "Starting audio streaming", "", 7 );
		m_pAudioDriverBackend->startStreaming();

		// Timer fr Peak-Events starten
		m_pTicker->StartTicker();

		// Initialisierung erfolgreich!
		m_iState = VA_CORESTATE_READY;

		SetProgress( "Initialization finished", "", 8 );
		FinishProgress();

	}
		VA_FINALLY
	{
		// Aufrumen und Exception weiterwerfen
		Tidyup();
		throw;
	}
}

void CVACoreImpl::Reset()
{
	VA_CHECK_INITIALIZED;

	// Wait for core thread
	while( !m_pCoreThread->TryBreak() )
		VASleep( 20 );

	VA_NO_REENTRANCE;

	if( GetUpdateLocked() )
	{
		VA_WARN( "Core", "Encountered locked scene during reset. Please unlock before resetting, skipping." );
		m_pCoreThread->Continue();
	}

	VA_TRY
	{
		VA_INFO( "Core", "Resetting core" );

		// Reset audio renderers
		std::vector< CVAAudioRendererDesc >::iterator it = m_voRenderers.begin();
		while( it != m_voRenderers.end() )
		{
			CVAAudioRendererDesc& oRend( *it++ );
			oRend.pInstance->Reset();
		}

		if( m_pCurSceneState )
		{
			// Referenz entfernen welche in CoreThreadLoop hinzugefgt wurde
			m_pCurSceneState->RemoveReference();
			m_pCurSceneState = nullptr;
		}

		// Alle Szenenobjekte lschen
		m_pSceneMan->Reset();
		m_pSignalSourceMan->Reset();
		m_pDirMan->Reset();

		// TODO: Check if the pool and sampler must really be recreated
		/*
		delete m_pGlobalSamplePool;
		m_pGlobalSamplePool = nullptr;
		m_pGlobalSamplePool = ITASoundSamplePool::Create(1, m_oCoreConfig.oAudioDriverConfig.dSamplerate);

		// This causes a crash in patch bay
		delete m_pGlobalSampler;
		m_pGlobalSampler = nullptr;
		m_pGlobalSampler = ITASoundSampler::Create(1, m_oCoreConfig.oAudioDriverConfig.dSamplerate, m_oCoreConfig.oAudioDriverConfig.iBuffersize, m_pGlobalSamplePool);
		m_pGlobalSampler->AddMonoTrack();
		*/
		//m_pGlobalSampler->RemoveAllPlaybacks();

		// Werte neusetzen
		m_pCurSceneState = m_pSceneMan->GetHeadSceneState();
		m_iCurActiveListener = -1;
		m_iNewActiveListener = -1;

		m_pCoreThread;

		// Core-Thread fortsetzen
		m_pCoreThread->Continue();

		// Ereignis generieren, wenn Operation erfolgreich
		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_RESET;
		ev.pSender = this;
		m_pCoreEventMan->BroadcastEvent( ev );

	}
		VA_FINALLY
	{
		Tidyup();
		throw;
	}
}

void CVACoreImpl::Tidyup() {
	/*
	 *  Hinweis: Diese Hilfsmethode wird nur innerhalb des Reentrance-Locks
	 *           aufgerufen - daher keine weiter Absicherung ntig.
	 */

	VA_TRY
	{
		if( m_pTicker )
		{
			m_pTicker->StopTicker();
			m_pTicker->SetAfterPulseFunctor( NULL );
		}

		FinalizeAudioDriver();
		FinalizeRenderingModules();
		FinalizeReproductionModules();

		delete m_pTicker;
		m_pTicker = nullptr;

		delete m_pCoreThread;
		m_pCoreThread = nullptr;

		delete m_pInputAmp;
		m_pInputAmp = nullptr;

		delete m_pInputStreamDetector;
		m_pInputStreamDetector = nullptr;

		delete m_pR2RPatchbay;
		m_pR2RPatchbay = nullptr;

		delete m_pOutputPatchbay;
		m_pOutputPatchbay = nullptr;

		delete m_pOutputStreamDetector;
		m_pOutputStreamDetector = nullptr;

		delete m_pOutputTracker;
		m_pOutputTracker = nullptr;

		delete m_pStreamProbeDeviceInput;
		m_pStreamProbeDeviceInput = nullptr;

		delete m_pStreamProbeFinal;
		m_pStreamProbeFinal = nullptr;

		delete m_pSignalSourceMan;
		m_pSignalSourceMan = nullptr;

		delete m_pGlobalSampler;
		m_pGlobalSampler = nullptr;

		delete m_pGlobalSamplePool;
		m_pGlobalSamplePool = nullptr;

		if( m_pDirMan )
			m_pDirMan->Finalize();
		delete m_pDirMan;
		m_pDirMan = nullptr;


		if( m_pSceneMan )
			m_pSceneMan->Finalize();
		delete m_pSceneMan;
		m_pSceneMan = nullptr;

		m_iState = VA_CORESTATE_CREATED;

	}
		VA_FINALLY
	{
		m_iState = VA_CORESTATE_FAIL;
	}
}

void CVACoreImpl::Finalize()
{
	VA_NO_REENTRANCE;

	//VA_TRACE("Core", __FUNCTION__ << " entry");
	VA_INFO( "Core", "Finalizing core" );

	VA_TRY
	{
		// Mehrfaches Finialisieren fhrt nicht zu Fehlern
		if( m_iState == VA_CORESTATE_CREATED ) return;

		if( m_iState == VA_CORESTATE_FAIL )
			VA_EXCEPT2( MODAL_ERROR, "Core corrupted, finalization impossible" );

		// Core-Thread anhalten (wenn frei ist)
		while( !m_pCoreThread->TryBreak() )
			VASleep( 10 );
		//m_pCoreThread->Break(); << deadlock

		// Alle Filterketten lschen und warten bis Zustand sicher bernommen
		// Wichtig: Dies muss vor dem Beenden des Streamings geschehen

		// Reset audio renderers
		for( std::vector<CVAAudioRendererDesc>::iterator it = m_voRenderers.begin(); it != m_voRenderers.end(); ++it )
			it->pInstance->Reset();

		// Peak-Nachrichten stoppen
		m_pTicker->StopTicker();

		// Audio-Streaming beenden
		m_pAudioDriverBackend->stopStreaming();

		InitProgress( "Stopping auralization threads", "", 2 );

		// Stop and delete ticker
		m_pTicker->SetAfterPulseFunctor( NULL );
		delete m_pTicker;
		m_pTicker = NULL;

		// Hauptthread beenden und freigeben
		delete m_pCoreThread;
		m_pCoreThread = nullptr;

		SetProgress( "Releasing audio hardware", "", 1 );
		FinalizeAudioDriver();
		FinalizeRenderingModules();
		FinalizeReproductionModules();

		SetProgress( "Cleaning up resources", "", 2 );
		delete m_pInputAmp;
		m_pInputAmp = nullptr;

		delete m_pInputStreamDetector;
		m_pInputStreamDetector = nullptr;

		m_voReproductionModules.clear();

		delete m_pR2RPatchbay;
		m_pR2RPatchbay = nullptr;

		delete m_pOutputPatchbay;
		m_pOutputPatchbay = nullptr;

		delete m_pOutputStreamDetector;
		m_pOutputStreamDetector = nullptr;

		delete m_pOutputTracker;
		m_pOutputTracker = nullptr;

		delete m_pStreamProbeDeviceInput;
		m_pStreamProbeDeviceInput = nullptr;

		delete m_pStreamProbeFinal;
		m_pStreamProbeFinal = nullptr;

		delete m_pSignalSourceMan;
		m_pSignalSourceMan = nullptr;

		delete m_pGlobalSampler;
		m_pGlobalSampler = nullptr;

		delete m_pGlobalSamplePool;
		m_pGlobalSamplePool = nullptr;

		m_pDirMan->Finalize();
		delete m_pDirMan;
		m_pDirMan = nullptr;

		m_pSceneMan->Finalize();
		delete m_pSceneMan;
		m_pSceneMan = nullptr;

		// Finalisierung erfolgreich. Nun wieder im Grundzustand!
		m_iState = VA_CORESTATE_CREATED;

		FinishProgress();

	}
		VA_FINALLY
	{
		// Nochmals versuchen aufzurumen
		Tidyup();

		// Allgemein: Fehler beim Finalisieren? => Core im Sack
		m_iState = VA_CORESTATE_FAIL;

		// VAExceptions unverndert nach aussen leiten
		throw;
	}
}


void CVACoreImpl::RegisterModule( CVAObject* pModule )
{
	m_oModules.RegisterObject( pModule );
}

void CVACoreImpl::GetModules( std::vector< CVAModuleInfo >& viModuleInfos ) const
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

#if ( VACORE_MODULE_INTERFACE_ENABLED == 1 )
	VA_TRY
	{
		std::vector<CVAObjectInfo> v;
		m_oModules.GetObjectInfos( v );

		VA_PRINT( "Available modules (" << v.size() << ")" );

		viModuleInfos.clear();
		viModuleInfos.resize( v.size() );
		for( size_t i = 0; i < v.size(); i++ )
		{
			VA_PRINT( "'" << v[ i ].sName << "'\t\t\t" << v[ i ].sDesc );
			viModuleInfos[ i ].sName = v[ i ].sName;
			viModuleInfos[ i ].sDesc = v[ i ].sDesc;
		}
	}
	VA_RETHROW;

#else // VACORE_MODULE_INTERFACE_ENABLED

	VA_EXCEPT1( "This VACore version does not provide modules" );

#endif // VACORE_MODULE_INTERFACE_ENABLED

}

CVAStruct CVACoreImpl::CallModule( const std::string& sModuleName, const CVAStruct& oArgs )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

#if ( VACORE_MODULE_INTERFACE_ENABLED == 1 )

	VA_TRY
	{
		CVAObject* pModule = m_oModules.FindObjectByName( sModuleName );
		if( !pModule )
		{
			VA_EXCEPT2( INVALID_PARAMETER, "Module '" + sModuleName + "' not found" );
		}

#ifdef VACORE_MODULE_INTERFACE_MECHANISM_EVENT_BASED

		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_SIGNALSOURCE_STATE_CHANGED;
		ev.pSender = this;
		ev.sObjectID = sModuleName;
		ev;
		m_pCoreEventMan->BroadcastEvent( ev );
		m_pCoreEventMan->

#else // not VACORE_MODULE_INTERFACE_MECHANISM_EVENT_BASED

		return pModule->CallObject( oArgs );

#endif // VACORE_MODULE_INTERFACE_MECHANISM_EVENT_BASED

	}
	VA_RETHROW;

#else // VACORE_MODULE_INTERFACE_ENABLED

#if ( VACORE_NO_MODULE_INTERFACE_THROW_EXCEPTION == 1 )
	VA_EXCEPT1( "This VACore version does not provide modules" );
#endif // VACORE_NO_MODULE_INTERFACE_THROW_EXCEPTION

#endif // VACORE_MODULE_INTERFACE_ENABLED
}

CVAStruct CVACoreImpl::GetSearchPaths() const
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	CVAStruct oSearchPaths;
	for( size_t i = 0; i < m_oCoreConfig.vsSearchPaths.size(); i++ )
		oSearchPaths[ "path_" + std::to_string( long( i ) ) ] = m_oCoreConfig.vsSearchPaths[ i ];

	return oSearchPaths;
}

int CVACoreImpl::CreateDirectivityFromParameters( const CVAStruct& oParams, const std::string& sName )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		int iDirID = m_pDirMan->CreateDirectivity( oParams, sName );

		assert( iDirID != -1 );

		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_DIRECTIVITY_LOADED;
		ev.pSender = this;
		ev.iObjectID = iDirID;
		m_pCoreEventMan->BroadcastEvent( ev );

		VA_INFO( "Core", "Directivity successfully loaded, assigned directivity ID " << iDirID );

		return iDirID;

	} VA_RETHROW;
}

bool CVACoreImpl::DeleteDirectivity( const int iDirID )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		bool bSuccess = m_pDirMan->DeleteDirectivity( iDirID );
		//assert( bSuccess );

		// Ereignis generieren, wenn Operation erfolgreich
		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_DIRECTIVITY_FREED;
		ev.pSender = this;
		ev.iObjectID = iDirID;
		m_pCoreEventMan->BroadcastEvent( ev );

		VA_INFO( "Core", "FreeDirectivity successful, freed directivity " << iDirID );

		return bSuccess;

	} VA_RETHROW;
}

CVADirectivityInfo CVACoreImpl::GetDirectivityInfo( int iDirID ) const {
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY{
		return m_pDirMan->GetDirectivityInfo( iDirID );
	} VA_RETHROW;
}

void CVACoreImpl::GetDirectivityInfos( std::vector<CVADirectivityInfo>& vdiDest ) const
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		m_pDirMan->GetDirectivityInfos( vdiDest );
	}
	VA_RETHROW;
}

void CVACoreImpl::SetDirectivityName( const int iID, const std::string& sName )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

std::string CVACoreImpl::GetDirectivityName( const int iID ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::SetDirectivityParameters( const int iID, const CVAStruct& oParams )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		VA_EXCEPT_NOT_IMPLEMENTED;
	}
	VA_RETHROW;
}

CVAStruct CVACoreImpl::GetDirectivityParameters( const int iID, const CVAStruct& oParams ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

int CVACoreImpl::CreateAcousticMaterial( const CVAAcousticMaterial& oMaterial, const std::string& sName )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

int CVACoreImpl::CreateAcousticMaterialFromParameters( const CVAStruct& oParams, const std::string& sName )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

bool CVACoreImpl::DeleteAcousticMaterial( const int iID )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

CVAAcousticMaterial CVACoreImpl::GetAcousticMaterialInfo( const int iID ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::GetAcousticMaterialInfos( std::vector< CVAAcousticMaterial >& voDest ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::SetAcousticMaterialName( const int iID, const std::string& sName )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

std::string CVACoreImpl::GetAcousticMaterialName( const int iID ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::SetAcousticMaterialParameters( const int iID, const CVAStruct& oParams )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

CVAStruct CVACoreImpl::GetAcousticMaterialParameters( const int iID, const CVAStruct& oParams ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

int CVACoreImpl::CreateGeometryMesh( const CVAGeometryMesh& oMesh, const std::string& sName )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

int CVACoreImpl::CreateGeometryMeshFromParameters( const CVAStruct& oParams, const std::string& sName )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

bool CVACoreImpl::DeleteGeometryMesh( const int iID )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

CVAGeometryMesh CVACoreImpl::GetGeometryMesh( const int iID ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::GetGeometryMeshIDs( std::vector< int >& viIDs ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::SetGeometryMeshName( const int iID, const std::string& sName )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

std::string CVACoreImpl::GetGeometryMeshName( const int iID ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::SetGeometryMeshParameters( const int iID, const CVAStruct& oParams )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

CVAStruct CVACoreImpl::GetGeometryMeshParameters( const int iID, const CVAStruct& oParams ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

void CVACoreImpl::SetGeometryMeshEnabled( const int iID, const bool bEnabled )
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

bool CVACoreImpl::GetGeometryMeshEnabled( const int iID ) const
{
	VA_EXCEPT_NOT_IMPLEMENTED;
}

std::string CVACoreImpl::CreateSignalSourceBufferFromParameters( const CVAStruct& oParams, const std::string& sName )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		if( oParams.HasKey( "filepath" ) )
		{
			const std::string sFilePath = oParams[ "filepath" ];
			const std::string sDestFilePath = FindFilePath( sFilePath );
			if( sDestFilePath.empty() )
				VA_EXCEPT2( INVALID_PARAMETER, "Looked everywhere, but could not find file '" + sFilePath + "'" );

			std::string sID = m_pSignalSourceMan->CreateAudiofileSignalSource( sDestFilePath, sName );
			assert( !sID.empty() );

			CVAEvent ev;
			ev.iEventType = CVAEvent::VA_EVENT_SIGNALSOURCE_CREATED;
			ev.pSender = this;
			ev.sObjectID = sID;
			m_pCoreEventMan->BroadcastEvent( ev );

			VA_INFO( "Core", "Created audiofile signal source (ID=" << sID << ", Name=\"" << sName << "\", Filename=\"" << sDestFilePath << "\")" );

			return sID;
		}
		else
		{
			VA_EXCEPT2( INVALID_PARAMETER, "Could not interpret parameter arguments to create a buffer signal source" );
		}
	}
	VA_RETHROW;
}

std::string CVACoreImpl::CreateSignalSourceTextToSpeech( const std::string& sName /*= "" */ )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		std::string sID = m_pSignalSourceMan->CreateTextToSpeechSignalSource( sName );
		assert( !sID.empty() );

		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_SIGNALSOURCE_CREATED;
		ev.pSender = this;
		ev.sObjectID = sID;
		m_pCoreEventMan->BroadcastEvent( ev );

		VA_INFO( "Core", "Created text-to-speech signal source ( ID=" << sID << ", Name=\"" << sName << "\" )" );

		return sID;
	}
	VA_RETHROW;
}

std::string CVACoreImpl::CreateSignalSourceSequencer( const std::string& sName )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		std::string sID = m_pSignalSourceMan->CreateSequencerSignalSource( sName );

		// Ereignis generieren, wenn Operation erfolgreich
		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_SIGNALSOURCE_CREATED;
		ev.pSender = this;
		ev.sObjectID = sID;
		m_pCoreEventMan->BroadcastEvent( ev );

		VA_INFO( "Core", "Created sequencer signal source (ID=" << sID << ", Name=\"" << sName << "\")" );

		return sID;
	}
	VA_RETHROW;
}

std::string CVACoreImpl::CreateSignalSourceNetworkStream( const std::string& sInterface, const int iPort, const std::string& sName )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		VA_TRACE( "Core", "Attempting to connect to a netstream signal source on " << sInterface << " with port " << iPort );
		std::string sID = m_pSignalSourceMan->CreateNetstreamSignalSource( sInterface, iPort, sName );
		assert( !sID.empty() );

		// Ereignis generieren, wenn Operation erfolgreich
		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_SIGNALSOURCE_CREATED;
		ev.pSender = this;
		ev.sObjectID = sID;
		m_pCoreEventMan->BroadcastEvent( ev );

		VA_INFO( "Core", "Created network stream signal source (ID=" << sID << ", Name='" << sName << "', Interface=" << sInterface << ":" << iPort << ")" );

		return sID;
	}
	VA_RETHROW;
}

std::string CVACoreImpl::CreateSignalSourceEngine( const CVAStruct&, const std::string& sName )
{
	VA_NO_REENTRANCE;
	VA_CHECK_INITIALIZED;

	VA_TRY
	{
		std::string sID = m_pSignalSourceMan->CreateEngineSignalSource( sName );

		// Ereignis generieren, wenn Operation erfolgreich
		CVAEvent ev;
		ev.iEventType = CVAEvent::VA_EVENT_SIGNALSOURCE_CREATED;
		ev.pSender = this;
		ev.sObjectID = sID;
		m_pCoreEventMan->BroadcastEvent( ev );

		VA_INFO( "Core", "Created engine signal source (ID=" << sID << ", Name=\"" << sName << "\")" );

		return sID;
	}
	VA_RETHROW;
}