Skip to content
Snippets Groups Projects
Select Git revision
  • v1.1-rc0
  • master default
  • sp/trace-zero-ranges
  • stable-2.5
  • stable-2.4
  • stable-2.3
  • stable-2.2
  • stable-2.1
  • stable-2.0
  • stable-1.7
  • stable-1.6
  • stable-1.5
  • stable-1.4
  • stable-1.3
  • stable-1.2
  • stable-1.1
  • stable-1.0
  • stable-0.15
  • stable-0.14
  • stable-0.13
  • stable-0.12
  • v2.7.0-rc1
  • v2.7.0-rc0
  • v2.6.0
  • v2.5.1.1
  • v2.6.0-rc5
  • v2.6.0-rc4
  • v2.6.0-rc3
  • v2.6.0-rc2
  • v2.6.0-rc1
  • v2.6.0-rc0
  • v2.5.1
  • v2.5.0
  • v2.5.0-rc4
  • v2.5.0-rc3
  • v2.5.0-rc2
  • v2.5.0-rc1
  • v2.5.0-rc0
  • v2.4.1
  • v2.4.0.1
  • v2.3.1
41 results

bt-host.h

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    vasingletonmethods.hpp 79.97 KiB
    #include <Python.h>
    
    #include <VA.h>
    #include <VANet.h>
    
    #include <string.h>
    
    // If you want to extend the va Python pSelf interface, also add
    // the function to the va_methods table in vasingleton.cpp - otherwise they will not show up.
    // Documentation goes into vasingletondoc.hpp
    
    static IVANetClient* g_pVANetClient = nullptr; //!< Static pointer to VANetClient instance
    static PyObject* g_pVAError = nullptr; //!< Static pointer to error instance
    
    // Ugly definitions to ease try-catching VA exceptions
    #define VAPY_REQUIRE_CONN_TRY try { RequireCoreAvailable();
    #define VAPY_CATCH_RETURN } catch (const CVAException& oError) { PyErr_SetString(PyExc_Exception, oError.ToString().c_str()); return NULL; }
    
    //! Helper for API dev
    static PyObject* not_implemented( PyObject*, PyObject* )
    {
    	VA_EXCEPT_NOT_IMPLEMENTED;
    };
    
    //! Raises an exception if core is not available
    static void RequireCoreAvailable()
    {
    	if( !g_pVANetClient )
    		VA_EXCEPT2( NETWORK_ERROR, "VA client not available, please connect first" );
    
    	if( !g_pVANetClient->GetCoreInstance() )
    		VA_EXCEPT2( NETWORK_ERROR, "VA client available, but access to VA interface failed. Please reconnect." );
    };
    
    std::string SaveStringToUnicodeConversion( const std::string& sInputString )
    {
    	std::string sOutputString = sInputString;
    	const Py_ssize_t iLength = sInputString.length();
    	char* pcBuffer( &sOutputString[ 0 ] );
    	for( Py_ssize_t i = 0; i < iLength; i++ )
    		if( pcBuffer[ i ] < 0 )
    			pcBuffer[ i ] = '_';
    	return &sOutputString[ 0 ];
    };
    
    //! Helper to convert recursively from VAStruct to Python dict
    PyObject* ConvertVAStructToPythonDict( const CVAStruct& oInStruct )
    {
    	PyObject* pOutDict = PyDict_New();
    
    	CVAStruct::const_iterator cit = oInStruct.Begin();
    	while( cit != oInStruct.End() )
    	{
    		const std::string sKey( ( *cit++ ).first );
    		const CVAStructValue& oValue( oInStruct[ sKey ] );
    
    		PyObject* pNewValue = nullptr;
    		if( oValue.IsBool() )
    		{
    			pNewValue = PyBool_FromLong( bool( oValue ) );
    		}
    		else if( oValue.IsInt() )
    		{
    			pNewValue = PyLong_FromLong( int( oValue ) );
    		}
    		else if( oValue.IsDouble() )
    		{
    			pNewValue = PyFloat_FromDouble( double( oValue ) );
    		}
    		else if( oValue.IsString() )
    		{
    			pNewValue = PyUnicode_FromString( SaveStringToUnicodeConversion( std::string( oValue ) ).c_str() );
    		}
    		else if( oValue.IsStruct() )
    		{
    			pNewValue = ConvertVAStructToPythonDict( oValue );
    		}
    		else if( oValue.IsData() )
    		{
    			pNewValue = PyByteArray_FromStringAndSize( ( char* ) oValue.GetData(), oValue.GetDataSize() );
    			Py_INCREF( pNewValue );
    		}
    		else if( oValue.IsSampleBuffer() )
    		{
    			const CVASampleBuffer& oSampleBuffer( oValue );
    			pNewValue = PyList_New( oSampleBuffer.GetNumSamples() );
    			Py_INCREF( pNewValue );
    			for( int i = 0; i < oSampleBuffer.GetNumSamples(); i++ )
    				PyList_SetItem( pNewValue, i, PyFloat_FromDouble( oSampleBuffer.GetDataReadOnly()[ i ] ) );
    		}
    		else
    		{
    			VA_EXCEPT2( INVALID_PARAMETER, "Could not interpret value of key '" + sKey + "' as a supported python dict type. Value was" + oValue.ToString() );
    		}
    
    		if( !pNewValue )
    			VA_EXCEPT2( INVALID_PARAMETER, "Could not create python object from value of key '" + sKey + "'. Value was" + oValue.ToString() );
    
    		if( PyDict_SetItemString( pOutDict, sKey.c_str(), pNewValue ) == -1 )
    			VA_EXCEPT2( INVALID_PARAMETER, "Could not create python object from value of key '" + sKey + "'. Value was" + oValue.ToString() );
    	}
    
    	return pOutDict;
    };
    
    //! Helper to convert recursively from Python dict to VAStruct
    CVAStruct ConvertPythonDictToVAStruct( PyObject* pInDict )
    {
    	CVAStruct oReturn;
    
    	PyObject* pKeyList = PyDict_Keys( pInDict );
    	PyObject* pValueList = PyDict_Values( pInDict );
    
    	for( Py_ssize_t i = 0; i < PyList_Size( pKeyList ); i++ )
    	{
    		PyObject* pKey = PyList_GetItem( pKeyList, i );
    		PyObject* pValue = PyList_GetItem( pValueList, i );
    		char* pcKeyName = nullptr;
    		if( !PyArg_Parse( pKey, "s", &pcKeyName ) )
    			VA_EXCEPT2( INVALID_PARAMETER, "Invalid key '" + std::string( pcKeyName ) + "'" );
    
    		if( Py_None == pValue )
    		{
    			oReturn[ pcKeyName ] = false;
    		}
    		else if( PyBool_Check( pValue ) )
    		{
    			oReturn[ pcKeyName ] = ( PyLong_AsLong( pValue ) != 0 );
    		}
    		else if( PyLong_Check( pValue ) )
    		{
    			oReturn[ pcKeyName ] = PyLong_AsLong( pValue );
    		}
    		else if( PyFloat_Check( pValue ) )
    		{
    			oReturn[ pcKeyName ] = PyFloat_AsDouble( pValue );
    		}
    		else if( PyUnicode_Check( pValue ) )
    		{
    			char* pcStringValue = nullptr;
    			if( !PyArg_Parse( pValue, "s", &pcStringValue ) )
    				VA_EXCEPT2( INVALID_PARAMETER, "Invalid string value at key '" + std::string( pcKeyName ) + "': " + std::string( pcStringValue ) );
    			oReturn[ pcKeyName ] = std::string( pcStringValue );
    		}
    		else if( PyDict_Check( pValue ) )
    		{
    			oReturn[ pcKeyName ] = ConvertPythonDictToVAStruct( pValue );
    		}
    		else if( PyList_Check( pValue ) )
    		{
    			// Sample buffer
    			CVASampleBuffer oBuffer( int( PyList_Size( pValue ) ) );
    			for( int n = 0; n < oBuffer.GetNumSamples(); n++ )
    			{
    				PyObject* pSample = PyList_GetItem( pValue, n );
    				if( !PyFloat_Check( pSample ) )
    				{
    					VA_EXCEPT2( INVALID_PARAMETER, "Samples must be floating point values" );
    				}
    				else
    				{
    					oBuffer.vfSamples[ n ] = float( PyFloat_AsDouble( pSample ) );
    				}
    			}
    			oReturn[ pcKeyName ] = oBuffer;
    		}
    		else if( PyBytes_Check( pValue ) )
    		{
    			// Data blob
    			size_t iBytes = PyBytes_Size( pValue );
    			char* pcData = PyBytes_AsString( pValue );
    			oReturn[ pcKeyName ] = CVAStructValue( pcData, int( iBytes ) );
    		}
    		else
    		{
    			VA_EXCEPT2( INVALID_PARAMETER, "Could not interpret value of key '" + std::string( pcKeyName ) + "' as a supported VAStruct type." )
    		}
    	}
    
    	return oReturn;
    };
    
    
    // ------------------------------- Python module extension methods
    
    static PyObject* connect( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	if( !g_pVANetClient )
    		g_pVANetClient = IVANetClient::Create();
    
    	if( g_pVANetClient->IsConnected() )
    	{
    		PyErr_WarnEx( NULL, "Was still connected, forced disconnect.", 1 );
    		g_pVANetClient->Disconnect();
    	}
    
    	static const char * const _keywords[] = { "server", "port", NULL };
    	static _PyArg_Parser _parser = { "|si:connect", _keywords, 0 };
    	char* pcServerIP = nullptr;
    	int iServerPort = 12340;
    
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcServerIP, &iServerPort ) )
    		return NULL;
    
    	std::string sServerIP = pcServerIP ? std::string( pcServerIP ) : "localhost";
    
    	if( IVANetClient::VA_NO_ERROR == g_pVANetClient->Initialize( sServerIP, iServerPort ) )
    		return PyBool_FromLong( 1 );
    
    	PyErr_SetString( PyExc_ConnectionError, std::string( "Could not connect to " + sServerIP + " on " + std::to_string( ( long ) iServerPort ) ).c_str() );
    	return NULL;
    };
    
    static PyObject* disconnect( PyObject*, PyObject* )
    {
    	if( !g_pVANetClient )
    		return PyBool_FromLong( 0 );
    
    	return PyBool_FromLong( g_pVANetClient->Disconnect() );
    };
    
    static PyObject* is_connected( PyObject*, PyObject* )
    {
    	if( !g_pVANetClient )
    		return PyBool_FromLong( 0 );
    	else
    		return PyBool_FromLong( g_pVANetClient->IsConnected() );
    };
    
    static PyObject* reset( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	g_pVANetClient->GetCoreInstance()->Reset();
    	Py_INCREF( Py_None );
    	return Py_None;
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_modules( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	std::vector< CVAModuleInfo > voModuleInfos;
    	g_pVANetClient->GetCoreInstance()->GetModules( voModuleInfos );
    
    	PyObject* pModuleList = PyList_New( voModuleInfos.size() );
    
    	for( size_t i = 0; i < voModuleInfos.size(); i++ )
    	{
    		CVAModuleInfo& oModule( voModuleInfos[ i ] );
    		PyObject* pModuleInfo = Py_BuildValue( "{s:i,s:s,s:s}", "index", i, "name", SaveStringToUnicodeConversion( oModule.sName ).c_str(), "description", SaveStringToUnicodeConversion( oModule.sDesc ).c_str() );
    		PyList_SetItem( pModuleList, i, pModuleInfo ); // steals reference
    	}
    
    	return pModuleList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* call_module( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "module_name", "arguments_dict", NULL };
    	static _PyArg_Parser _parser = { "sO!:call_module", _keywords, 0 };
    	char* pcModuleName = nullptr;
    	PyObject* pArgumentsDict = nullptr;
    
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcModuleName, &PyDict_Type, &pArgumentsDict ) )
    		return NULL;
    
    	std::string sModuleName = std::string( pcModuleName );
    	CVAStruct oInArgs = ConvertPythonDictToVAStruct( pArgumentsDict );
    	CVAStruct oOutArgs;
    
    	oOutArgs = g_pVANetClient->GetCoreInstance()->CallModule( sModuleName, oInArgs );
    
    	return ConvertVAStructToPythonDict( oOutArgs );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* add_search_path( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "directory_path", NULL };
    	static _PyArg_Parser _parser = { "s:add_search_path", _keywords, 0 };
    	char* pcPath = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcPath ) )
    		return NULL;
    
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->AddSearchPath( std::string( pcPath ) ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_update_locked( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetUpdateLocked() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* lock_update( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	g_pVANetClient->GetCoreInstance()->LockUpdate();
    	Py_INCREF( Py_None );
    	return Py_None;
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* unlock_update( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->UnlockUpdate() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_directivity_from_file( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "path", "name", NULL };
    	static _PyArg_Parser _parser = { "s|s:create_directivity_from_file", _keywords, 0 };
    	char* pcPath = nullptr;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcPath, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "";
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->CreateDirectivityFromFile( std::string( pcPath ), sName ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* delete_directivity( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:delete_directivity", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->DeleteDirectivity( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_directivity_info( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_directivity_info", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	CVADirectivityInfo oInfo = g_pVANetClient->GetCoreInstance()->GetDirectivityInfo( iID );
    
    	PyObject* pInfo = Py_BuildValue( "{s:i,s:s,s:i,s:i,s:s}",
    		"id", oInfo.iID,
    		"name", SaveStringToUnicodeConversion( oInfo.sName ).c_str(),
    		"class", oInfo.iClass,
    		"references", oInfo.iReferences,
    		"description", SaveStringToUnicodeConversion( oInfo.sDesc ).c_str() );
    
    	return pInfo;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_directivity_infos( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	std::vector< CVADirectivityInfo > voInfos;
    	g_pVANetClient->GetCoreInstance()->GetDirectivityInfos( voInfos );
    
    	PyObject* pInfoList = PyList_New( voInfos.size() );
    
    	for( size_t i = 0; i < voInfos.size(); i++ )
    	{
    		CVADirectivityInfo& oInfo( voInfos[ i ] );
    		PyObject* pInfo = Py_BuildValue( "{s:i,s:s,s:i,s:i,s:s}",
    			"id", oInfo.iID,
    			"name", SaveStringToUnicodeConversion( oInfo.sName ).c_str(),
    			"class", oInfo.iClass,
    			"references", oInfo.iReferences,
    			"description", SaveStringToUnicodeConversion( oInfo.sDesc ).c_str() );
    		PyList_SetItem( pInfoList, i, pInfo ); // steals reference
    	}
    
    	return pInfoList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_ids( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	std::vector< int > viIDs;
    	g_pVANetClient->GetCoreInstance()->GetSoundSourceIDs( viIDs );
    
    	PyObject* pIDList = PyList_New( viIDs.size() );
    	for( Py_ssize_t i = 0; i < PyList_GET_SIZE( pIDList ); i++ )
    		PyList_SetItem( pIDList, i, PyLong_FromLong( viIDs[ i ] ) );
    
    	return pIDList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_sound_source( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "name", NULL };
    	static _PyArg_Parser _parser = { "s:create_sound_source", _keywords, 0 };
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "PySoundSource";
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->CreateSoundSource( sName ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    
    static PyObject* create_sound_source_explicit_renderer( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "renderer", "name", NULL };
    	static _PyArg_Parser _parser = { "ss:create_sound_source_explicit_renderer", _keywords, 0 };
    	char* pcRenderer = nullptr;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcRenderer, &pcName ) )
    		return NULL;
    
    	std::string sRenderer = pcRenderer ? std::string( pcRenderer ) : "Unspecified";
    	std::string sName = pcName ? std::string( pcName ) : "PySoundSource_" + sRenderer;
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->CreateSoundSourceExplicitRenderer( sRenderer, sName ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* delete_sound_source( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:delete_sound_source", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->DeleteSoundSource( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_enabled( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "enabled", NULL };
    	static _PyArg_Parser _parser = { "i|b:set_sound_source_enabled", _keywords, 0 };
    	long iID = -1;
    	bool bEnabled = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &bEnabled ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceEnabled( iID, bEnabled );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_enabled( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_enabled", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetSoundSourceEnabled( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_name( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_name", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( g_pVANetClient->GetCoreInstance()->GetSoundSourceName( iID ) ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_signal_source( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_signal_source", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( g_pVANetClient->GetCoreInstance()->GetSoundSourceSignalSource( iID ) ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_signal_source( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "signalsource", NULL };
    	static _PyArg_Parser _parser = { "is:set_sound_source_signal_source", _keywords, 0 };
    	long iID = -1;
    	char* pcSignalSourceID;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &pcSignalSourceID ) )
    		return NULL;
    
    	std::string sSIgnalSourceID = pcSignalSourceID ? std::string( pcSignalSourceID ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceSignalSource( iID, sSIgnalSourceID );
    
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* remove_sound_source_signal_source( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:remove_sound_source_signal_source", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->RemoveSoundSourceSignalSource( iID );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_auralization_mode( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_auralization_mode", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetSoundSourceAuralizationMode( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_auralization_mode( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "auralizationmode", NULL };
    	static _PyArg_Parser _parser = { "ii:set_sound_source_auralization_mode", _keywords, 0 };
    	long iID = -1;
    	long iAuralizationMode = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &iAuralizationMode ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceAuralizationMode( iID, iAuralizationMode );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_parameters( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "parameters", NULL };
    	static _PyArg_Parser _parser = { "iO!:set_sound_source_parameters", _keywords, 0 };
    	long iID = -1;
    	PyObject* pParameters = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &pParameters ) )
    		return NULL;
    
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceParameters( iID, oParameters );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    
    static PyObject* get_sound_source_parameters( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "io!:get_sound_source_parameters", _keywords, 0 };
    	long iID = -1;
    	PyObject* pParameters = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &pParameters ) )
    		return NULL;
    
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	CVAStruct oReturn = g_pVANetClient->GetCoreInstance()->GetSoundSourceParameters( iID, oParameters );
    	return ConvertVAStructToPythonDict( oReturn );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_directivity( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_directivity", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetSoundSourceDirectivity( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_directivity( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "directivity", NULL };
    	static _PyArg_Parser _parser = { "ii:set_sound_source_directivity", _keywords, 0 };
    	long iID = -1;
    	long iDirectivityID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &iDirectivityID ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceDirectivity( iID, iDirectivityID );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_sound_power( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_sound_power", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyFloat_FromDouble( g_pVANetClient->GetCoreInstance()->GetSoundSourceSoundPower( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_sound_power( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "gain", NULL };
    	static _PyArg_Parser _parser = { "id:set_sound_source_sound_power", _keywords, 0 };
    	long iID = -1;
    	double dPower = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &dPower ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceSoundPower( iID, dPower );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "muted", NULL };
    	static _PyArg_Parser _parser = { "i|b:set_sound_source_muted", _keywords, 0 };
    	long iID = -1;
    	bool bMuted = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &bMuted ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceMuted( iID, bMuted );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_muted", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetSoundSourceMuted( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_source_position( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_position", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	VAVec3 v3Pos = g_pVANetClient->GetCoreInstance()->GetSoundSourcePosition( iID );
    
    	PyObject* pPosList = PyList_New( 3 );
    	PyList_SetItem( pPosList, 0, PyFloat_FromDouble( v3Pos.x ) );
    	PyList_SetItem( pPosList, 1, PyFloat_FromDouble( v3Pos.y ) );
    	PyList_SetItem( pPosList, 2, PyFloat_FromDouble( v3Pos.z ) );
    
    	return pPosList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_position( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "pos", NULL };
    	static _PyArg_Parser _parser = { "i(ddd):set_sound_source_position", _keywords, 0 };
    	long iID = -1;
    	VAVec3 v3Pos;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &v3Pos.x, &v3Pos.y, &v3Pos.z ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundSourcePosition( iID, v3Pos );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    
    static PyObject* get_sound_source_orientation_vu( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_source_orientation_vu", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	VAVec3 v3View, v3Up;
    	g_pVANetClient->GetCoreInstance()->GetSoundSourceOrientationVU( iID, v3View, v3Up );
    
    	return Py_BuildValue( "(ddd)(ddd)", v3View.x, v3View.y, v3View.z, v3Up.x, v3Up.y, v3Up.z );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_source_orientation_vu( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "view", "up", NULL };
    	static _PyArg_Parser _parser = { "i(ddd)(ddd):set_sound_source_orientation_vu", _keywords, 0 };
    	long iID = -1;
    	VAVec3 v3View, v3Up;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &v3View.x, &v3View.y, &v3View.z, &v3Up.x, &v3Up.y, &v3Up.z ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundSourceOrientationVU( iID, v3View, v3Up );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_receiver_ids( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	std::vector< int > viIDs;
    	g_pVANetClient->GetCoreInstance()->GetSoundReceiverIDs( viIDs );
    
    	PyObject* pIDList = PyList_New( viIDs.size() );
    	for( Py_ssize_t i = 0; i < PyList_GET_SIZE( pIDList ); i++ )
    		PyList_SetItem( pIDList, i, PyLong_FromLong( viIDs[ i ] ) );
    
    	return pIDList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_sound_receiver( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "name", NULL };
    	static _PyArg_Parser _parser = { "s:create_sound_receiver", _keywords, 0 };
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "PySoundReceiver";
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->CreateSoundReceiver( sName ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_sound_receiver_explicit_renderer( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "renderer", "name", NULL };
    	static _PyArg_Parser _parser = { "ss:create_sound_receiver_explicit_renderer", _keywords, 0 };
    	char* pcRenderer = nullptr;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcRenderer, &pcName ) )
    		return NULL;
    
    	std::string sRenderer = pcRenderer ? std::string( pcRenderer ) : "Unspecified";
    	std::string sName = pcName ? std::string( pcName ) : "PySoundReceiver_" + sRenderer;
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->CreateSoundReceiverExplicitRenderer( sRenderer, sName ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* delete_sound_receiver( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:delete_sound_receiver", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->DeleteSoundReceiver( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_enabled( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "enabled", NULL };
    	static _PyArg_Parser _parser = { "i|b:set_sound_receiver_enabled", _keywords, 0 };
    	long iID = -1;
    	bool bEnabled = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &bEnabled ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverEnabled( iID, bEnabled );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_receiver_enabled( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_enabled", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetSoundReceiverEnabled( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_receiver_name( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_name", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( g_pVANetClient->GetCoreInstance()->GetSoundReceiverName( iID ) ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_receiver_auralization_mode( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_auralization_mode", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetSoundReceiverAuralizationMode( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_auralization_mode( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "auralizationmode", NULL };
    	static _PyArg_Parser _parser = { "ii:set_sound_receiver_auralization_mode", _keywords, 0 };
    	long iID = -1;
    	long iAuralizationMode = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &iAuralizationMode ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverAuralizationMode( iID, iAuralizationMode );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_parameters( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "parameters", NULL };
    	static _PyArg_Parser _parser = { "iO!:set_sound_receiver_parameters", _keywords, 0 };
    	long iID = -1;
    	PyObject* pParameters = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &pParameters ) )
    		return NULL;
    
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverParameters( iID, oParameters );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    
    static PyObject* get_sound_receiver_parameters( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "io!:get_sound_receiver_parameters", _keywords, 0 };
    	long iID = -1;
    	PyObject* pParameters = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &pParameters ) )
    		return NULL;
    
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	CVAStruct oReturn = g_pVANetClient->GetCoreInstance()->GetSoundReceiverParameters( iID, oParameters );
    	return ConvertVAStructToPythonDict( oReturn );
    
    	VAPY_CATCH_RETURN;
    };
    
    
    static PyObject* get_sound_receiver_directivity( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_directivity", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetSoundReceiverDirectivity( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_directivity( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "directivity", NULL };
    	static _PyArg_Parser _parser = { "ii:set_sound_receiver_directivity", _keywords, 0 };
    	long iID = -1;
    	long iDirectivityID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &iDirectivityID ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverDirectivity( iID, iDirectivityID );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    
    static PyObject* get_sound_receiver_position( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_position", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	VAVec3 v3Pos = g_pVANetClient->GetCoreInstance()->GetSoundReceiverPosition( iID );
    
    	PyObject* pPosList = PyList_New( 3 );
    	PyList_SetItem( pPosList, 0, PyFloat_FromDouble( v3Pos.x ) );
    	PyList_SetItem( pPosList, 1, PyFloat_FromDouble( v3Pos.y ) );
    	PyList_SetItem( pPosList, 2, PyFloat_FromDouble( v3Pos.z ) );
    
    	return pPosList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_position( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "pos", NULL };
    	static _PyArg_Parser _parser = { "i(ddd):set_sound_receiver_position", _keywords, 0 };
    	long iID = -1;
    	VAVec3 v3Pos;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &v3Pos.x, &v3Pos.y, &v3Pos.z ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverPosition( iID, v3Pos );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_receiver_orientation_vu( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_orientation_vu", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	VAVec3 v3View, v3Up;
    	g_pVANetClient->GetCoreInstance()->GetSoundReceiverOrientationVU( iID, v3View, v3Up );
    
    	return Py_BuildValue( "(ddd)(ddd)", v3View.x, v3View.y, v3View.z, v3Up.x, v3Up.y, v3Up.z );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_orientation_vu( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "view", "up", NULL };
    	static _PyArg_Parser _parser = { "i(ddd)(ddd):set_sound_receiver_orientation_vu", _keywords, 0 };
    	long iID = -1;
    	VAVec3 v3View, v3Up;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &v3View.x, &v3View.y, &v3View.z, &v3Up.x, &v3Up.y, &v3Up.z ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverOrientationVU( iID, v3View, v3Up );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_receiver_real_world_position( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_real_world_position", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	VAVec3 v3Pos, vView, vUp;
    	g_pVANetClient->GetCoreInstance()->GetSoundReceiverRealWorldPositionOrientationVU( iID, v3Pos, vView, vUp );
    
    	PyObject* pPosList = PyList_New( 3 );
    	PyList_SetItem( pPosList, 0, PyFloat_FromDouble( v3Pos.x ) );
    	PyList_SetItem( pPosList, 1, PyFloat_FromDouble( v3Pos.y ) );
    	PyList_SetItem( pPosList, 2, PyFloat_FromDouble( v3Pos.z ) );
    
    	return pPosList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_real_world_position( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "pos", NULL };
    	static _PyArg_Parser _parser = { "i(ddd):set_sound_receiver_real_world_position", _keywords, 0 };
    	long iID = -1;
    	VAVec3 v3Pos;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &v3Pos.x, &v3Pos.y, &v3Pos.z ) )
    		return NULL;
    
    	VAVec3 v3PosDummy, v3View, v3Up;
    	g_pVANetClient->GetCoreInstance()->GetSoundReceiverRealWorldPositionOrientationVU( iID, v3PosDummy, v3View, v3Up );
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverRealWorldPositionOrientationVU( iID, v3Pos, v3View, v3Up );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_receiver_real_world_orientation_vu( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_receiver_real_world_orientation_vu", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	VAVec3 v3Pos, v3View, v3Up;
    	g_pVANetClient->GetCoreInstance()->GetSoundReceiverRealWorldPositionOrientationVU( iID, v3Pos, v3View, v3Up );
    
    	return Py_BuildValue( "(ddd)(ddd)", v3View.x, v3View.y, v3View.z, v3Up.x, v3Up.y, v3Up.z );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_receiver_real_world_orientation_vu( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "view", "up", NULL };
    	static _PyArg_Parser _parser = { "i(ddd)(ddd):set_sound_receiver_real_world_orientation_vu", _keywords, 0 };
    	long iID = -1;
    	VAVec3 v3View, v3Up;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &v3View.x, &v3View.y, &v3View.z, &v3Up.x, &v3Up.y, &v3Up.z ) )
    		return NULL;
    
    	VAVec3 v3Pos, v3View_dummy, v3Up_dummy;
    	g_pVANetClient->GetCoreInstance()->GetSoundReceiverRealWorldPositionOrientationVU( iID, v3Pos, v3View_dummy, v3Up_dummy );
    	g_pVANetClient->GetCoreInstance()->SetSoundReceiverRealWorldPositionOrientationVU( iID, v3Pos, v3View, v3Up );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_signal_source_buffer_from_file( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "path", "name", NULL };
    	static _PyArg_Parser _parser = { "s|s:create_signal_source_buffer_from_file", _keywords, 0 };
    	char* pcPath = nullptr;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcPath, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "";
    	std::string sSignalSource = g_pVANetClient->GetCoreInstance()->CreateSignalSourceBufferFromFile( std::string( pcPath ), sName );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSignalSource ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_signal_source_text_to_speech( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "name", NULL };
    	static _PyArg_Parser _parser = { "|s:create_signal_source_text_to_speech", _keywords, 0 };
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "";
    	std::string sSignalSource = g_pVANetClient->GetCoreInstance()->CreateSignalSourceTextToSpeech( sName );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSignalSource ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_signal_source_sequencer( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "name", NULL };
    	static _PyArg_Parser _parser = { "|s:create_signal_source_sequencer", _keywords, 0 };
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "";
    	std::string sSignalSource = g_pVANetClient->GetCoreInstance()->CreateSignalSourceSequencer( sName );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSignalSource ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_signal_source_network_stream( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "interface", "port", "name", NULL };
    	static _PyArg_Parser _parser = { "si|s:create_signal_source_network_stream", _keywords, 0 };
    	char* pcInterface = nullptr;
    	int iPort = -1;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcInterface, &iPort, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "";
    	std::string sInterface = pcInterface ? std::string( pcInterface ) : "";
    	std::string sSignalSource = g_pVANetClient->GetCoreInstance()->CreateSignalSourceNetworkStream( sInterface, iPort, sName );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSignalSource ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_signal_source_engine( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "name", NULL };
    	static _PyArg_Parser _parser = { "O!|s:create_signal_source_engine", _keywords, 0 };
    	PyObject* pParameters = nullptr;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pParameters ,&pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "";
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	std::string sSignalSource = g_pVANetClient->GetCoreInstance()->CreateSignalSourceEngine( oParameters, sName );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSignalSource ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* create_signal_source_machine( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "name", NULL };
    	static _PyArg_Parser _parser = { "O!|s:create_signal_source_machine", _keywords, 0 };
    	PyObject* pParameters = nullptr;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pParameters, &pcName ) )
    		return NULL;
    
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	std::string sName = pcName ? std::string( pcName ) : "";
    	std::string sSignalSource = g_pVANetClient->GetCoreInstance()->CreateSignalSourceMachine( oParameters, sName );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSignalSource ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* delete_signal_source( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signal_source", NULL };
    	static _PyArg_Parser _parser = { "s:delete_signal_source", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	bool bRet = g_pVANetClient->GetCoreInstance()->DeleteSignalSource( sSignalSource );
    	return PyBool_FromLong( bRet );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_info( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:get_signal_source_info", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	CVASignalSourceInfo oInfo = g_pVANetClient->GetCoreInstance()->GetSignalSourceInfo( sSignalSource );
    
    	PyObject* pInfo = Py_BuildValue( "{s:s,s:s,s:s,s:i,s:i,s:s}",
    		"id", SaveStringToUnicodeConversion( oInfo.sID ).c_str(),
    		"name", SaveStringToUnicodeConversion( oInfo.sName ).c_str(),
    		"state", SaveStringToUnicodeConversion( oInfo.sState ).c_str(),
    		"type", oInfo.iType,
    		"references", oInfo.iReferences,
    		"description", SaveStringToUnicodeConversion( oInfo.sDesc ).c_str() );
    
    	return pInfo;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_infos( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	std::vector< CVASignalSourceInfo > voInfos;
    	g_pVANetClient->GetCoreInstance()->GetSignalSourceInfos( voInfos );
    
    	PyObject* pInfoList = PyList_New( voInfos.size() );
    
    	for( size_t i = 0; i < voInfos.size(); i++ )
    	{
    		CVASignalSourceInfo& oInfo( voInfos[ i ] );
    		PyObject* pInfo = Py_BuildValue( "{s:s,s:s,s:s,s:i,s:i,s:s}",
    			"id", SaveStringToUnicodeConversion( oInfo.sID ).c_str(),
    			"name", SaveStringToUnicodeConversion( oInfo.sName ).c_str(),
    			"state", SaveStringToUnicodeConversion( oInfo.sState ).c_str(),
    			"type", oInfo.iType,
    			"references", oInfo.iReferences,
    			"description", SaveStringToUnicodeConversion( oInfo.sDesc ).c_str() );
    		PyList_SetItem( pInfoList, i, pInfo ); // steals reference
    	}
    
    	return pInfoList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_buffer_playback_state( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:get_signal_source_buffer_playback_state", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	int iState = g_pVANetClient->GetCoreInstance()->GetSignalSourceBufferPlaybackState( sSignalSource );
    	return PyLong_FromLong( iState );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_buffer_playback_state_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:get_signal_source_buffer_playback_state_str", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	int iState = g_pVANetClient->GetCoreInstance()->GetSignalSourceBufferPlaybackState( sSignalSource );
    	std::string sState = g_pVANetClient->GetCoreInstance()->GetPlaybackStateStr( iState );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sState ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_buffer_playback_action( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "action", NULL };
    	static _PyArg_Parser _parser = { "si:va_set_signal_source_buffer_playback_action", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	int iAction = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &iAction ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceBufferPlaybackAction( sSignalSource, iAction );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_buffer_playback_action_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "action_string", NULL };
    	static _PyArg_Parser _parser = { "ss:set_signal_source_buffer_playback_action_str", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	char* pcAction = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &pcAction ) )
    		return NULL;
    
    	std::string sAction = pcAction ? std::string( pcAction ) : "";
    	int iAction = g_pVANetClient->GetCoreInstance()->ParsePlaybackAction( sAction );
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceBufferPlaybackAction( sSignalSource, iAction );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_buffer_playback_position( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "playback_position", NULL };
    	static _PyArg_Parser _parser = { "si:set_signal_source_buffer_playback_position", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	int iPosition = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &iPosition ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceBufferPlaybackPosition( sSignalSource, iPosition );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_buffer_looping( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:get_signal_source_buffer_looping", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetSignalSourceBufferLooping( sSignalSource ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_buffer_looping( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "enabled", NULL };
    	static _PyArg_Parser _parser = { "s|b:set_signal_source_buffer_looping", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	bool bEnabled = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &bEnabled ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceBufferLooping( sSignalSource, bEnabled );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_machine_start_machine( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:set_signal_source_machine_start_machine", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceMachineStartMachine( sSignalSource );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_machine_halt_machine( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:set_signal_source_machine_halt_machine", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceMachineHaltMachine( sSignalSource );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_machine_state_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:get_signal_source_machine_state_str", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	std::string sState = g_pVANetClient->GetCoreInstance()->GetSignalSourceMachineStateStr( sSignalSource );
    
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sState ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_machine_speed( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "speed", NULL };
    	static _PyArg_Parser _parser = { "sd:set_signal_source_machine_speed", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	double dSpeed;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &dSpeed ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceMachineSpeed( sSignalSource, dSpeed );
    
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_machine_speed( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", NULL };
    	static _PyArg_Parser _parser = { "s:get_signal_source_machine_speed", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	double dSpeed = g_pVANetClient->GetCoreInstance()->GetSignalSourceMachineSpeed( sSignalSource );
    
    	return PyFloat_FromDouble( dSpeed );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_machine_start_file( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "filepath", NULL };
    	static _PyArg_Parser _parser = { "ss:set_signal_source_machine_start_file", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	char* pcPath = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &pcPath ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	std::string sPath = pcPath ? std::string( pcPath ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceMachineStartFile( sSignalSource, sPath );
    
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_machine_idle_file( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "filepath", NULL };
    	static _PyArg_Parser _parser = { "ss:set_signal_source_machine_idle_file", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	char* pcPath = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &pcPath ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	std::string sPath = pcPath ? std::string( pcPath ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceMachineIdleFile( sSignalSource, sPath );
    
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_machine_stop_file( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "filepath", NULL };
    	static _PyArg_Parser _parser = { "ss:vset_signal_source_machine_stop_file", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	char* pcPath = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &pcPath ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	std::string sPath = pcPath ? std::string( pcPath ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceMachineStopFile( sSignalSource, sPath );
    
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_signal_source_parameters( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "signalsource", "parameters", NULL };
    	static _PyArg_Parser _parser = { "iO!:get_signal_source_parameters", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	PyObject* pParameters = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &pParameters ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	CVAStruct oReturn = g_pVANetClient->GetCoreInstance()->GetSignalSourceParameters( sSignalSource, oParameters );
    	return ConvertVAStructToPythonDict( oReturn );;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_signal_source_parameters( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "io!:set_signal_source_parameters", _keywords, 0 };
    	char* pcSignalSource = nullptr;
    	PyObject* pParameters = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcSignalSource, &pParameters ) )
    		return NULL;
    
    	std::string sSignalSource = pcSignalSource ? std::string( pcSignalSource ) : "";
    	CVAStruct oParameters = ConvertPythonDictToVAStruct( pParameters );
    	g_pVANetClient->GetCoreInstance()->SetSignalSourceParameters( sSignalSource, oParameters );
    
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_portal_ids( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	std::vector< int > viIDs;
    	g_pVANetClient->GetCoreInstance()->GetSoundPortalIDs( viIDs );
    
    	PyObject* pIDList = PyList_New( viIDs.size() );
    	for( Py_ssize_t i = 0; i < PyList_GET_SIZE( pIDList ); i++ )
    		PyList_SetItem( pIDList, i, PyLong_FromLong( viIDs[ i ] ) );
    
    	return pIDList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_portal_name( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_portal_name", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( g_pVANetClient->GetCoreInstance()->GetSoundPortalName( iID ) ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_portal_name( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "name", NULL };
    	static _PyArg_Parser _parser = { "is:set_sound_portal_name", _keywords, 0 };
    	long iID = -1;
    	char* pcName = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &pcName ) )
    		return NULL;
    
    	std::string sName = pcName ? std::string( pcName ) : "";
    	g_pVANetClient->GetCoreInstance()->SetSoundPortalName( iID, sName );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_sound_portal_enabled( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:get_sound_portal_enabled", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	return PyFloat_FromDouble( g_pVANetClient->GetCoreInstance()->GetSoundPortalEnabled( iID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_sound_portal_enabled( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "name", NULL };
    	static _PyArg_Parser _parser = { "i|b:set_sound_portal_enabled", _keywords, 0 };
    	long iID = -1;
    	bool bEnabled = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &bEnabled ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetSoundPortalEnabled( iID, bEnabled );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_rendering_modules( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	std::vector< CVAAudioRendererInfo > voInfos;
    	g_pVANetClient->GetCoreInstance()->GetRenderingModules( voInfos );
    
    	PyObject* pList = PyList_New( voInfos.size() );
    
    	for( size_t i = 0; i < voInfos.size(); i++ )
    	{
    		CVAAudioRendererInfo& oInfo( voInfos[ i ] );
    		PyObject* pInfo = Py_BuildValue( "{s:b,s:s,s:s, s:s}",
    			"enabled", oInfo.bEnabled,
    			"class", SaveStringToUnicodeConversion( oInfo.sClass ).c_str(),
    			"description", SaveStringToUnicodeConversion( oInfo.sDescription ).c_str(),
    			"id", SaveStringToUnicodeConversion( oInfo.sID ).c_str() );
    		PyList_SetItem( pList, i, pInfo ); // steals reference
    	}
    
    	return pList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_rendering_module_gain( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "s:get_rendering_module_gain", _keywords, 0 };
    	char* pcID = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	return PyFloat_FromDouble( g_pVANetClient->GetCoreInstance()->GetRenderingModuleGain( sID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_rendering_module_gain( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "gain", NULL };
    	static _PyArg_Parser _parser = { "sd:set_rendering_module_gain", _keywords, 0 };
    	char* pcID = nullptr;
    	double dGain = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID, &dGain ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	g_pVANetClient->GetCoreInstance()->SetRenderingModuleGain( sID, dGain );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_rendering_module_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "muted", NULL };
    	static _PyArg_Parser _parser = { "s|b:set_rendering_module_muted", _keywords, 0 };
    	char* pcID = nullptr;
    	bool bMuted = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID, &bMuted ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	g_pVANetClient->GetCoreInstance()->SetRenderingModuleMuted( sID, bMuted );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_rendering_module_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "s:get_rendering_module_muted", _keywords, 0 };
    	char* pcID = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetRenderingModuleMuted( sID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_reproduction_modules( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	std::vector< CVAAudioReproductionInfo > voInfos;
    	g_pVANetClient->GetCoreInstance()->GetReproductionModules( voInfos );
    
    	PyObject* pList = PyList_New( voInfos.size() );
    
    	for( size_t i = 0; i < voInfos.size(); i++ )
    	{
    		CVAAudioReproductionInfo& oInfo( voInfos[ i ] );
    		PyObject* pInfo = Py_BuildValue( "{s:b,s:s,s:s,s:s}",
    			"enabled", oInfo.bEnabled,
    			"class", SaveStringToUnicodeConversion( oInfo.sClass ).c_str(),
    			"description", SaveStringToUnicodeConversion( oInfo.sDescription ).c_str(),
    			"id", SaveStringToUnicodeConversion( oInfo.sID ).c_str() );
    		PyList_SetItem( pList, i, pInfo ); // steals reference
    	}
    
    	return pList;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_reproduction_module_gain( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "s:get_reproduction_module_gain", _keywords, 0 };
    	char* pcID = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	return PyFloat_FromDouble( g_pVANetClient->GetCoreInstance()->GetReproductionModuleGain( sID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_reproduction_module_gain( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "gain", NULL };
    	static _PyArg_Parser _parser = { "sd:set_reproduction_module_gain", _keywords, 0 };
    	char* pcID = nullptr;
    	double dGain = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID, &dGain ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	g_pVANetClient->GetCoreInstance()->SetReproductionModuleGain( sID, dGain );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_reproduction_module_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "muted", NULL };
    	static _PyArg_Parser _parser = { "s|b:set_reproduction_module_muted", _keywords, 0 };
    	char* pcID = nullptr;
    	bool bMuted = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID, &bMuted ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	g_pVANetClient->GetCoreInstance()->SetReproductionModuleMuted( sID, bMuted );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_reproduction_module_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "s:get_reproduction_module_muted", _keywords, 0 };
    	char* pcID = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetReproductionModuleMuted( sID ) );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_input_gain( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyFloat_FromDouble( g_pVANetClient->GetCoreInstance()->GetInputGain() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_input_gain( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "gain", NULL };
    	static _PyArg_Parser _parser = { "d:set_input_gain", _keywords, 0 };
    	double dGain = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &dGain ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetInputGain( dGain );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_input_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "muted", NULL };
    	static _PyArg_Parser _parser = { "|b:set_input_muted", _keywords, 0 };
    	bool bMuted = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &bMuted ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetInputMuted( bMuted );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_input_muted( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetInputMuted() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_output_gain( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyFloat_FromDouble( g_pVANetClient->GetCoreInstance()->GetInputGain() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_output_gain( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "gain", NULL };
    	static _PyArg_Parser _parser = { "d:set_output_gain", _keywords, 0 };
    	double dGain = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &dGain ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetOutputGain( dGain );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_output_muted( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "muted", NULL };
    	static _PyArg_Parser _parser = { "|b:set_output_muted", _keywords, 0 };
    	bool bMuted = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &bMuted ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetOutputMuted( bMuted );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_output_muted( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyBool_FromLong( g_pVANetClient->GetCoreInstance()->GetOutputMuted() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_global_auralization_mode( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetGlobalAuralizationMode() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_global_auralization_mode( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "auralization_mode", NULL };
    	static _PyArg_Parser _parser = { "i:set_global_auralization_mode", _keywords, 0 };
    	long iAM = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iAM ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetGlobalAuralizationMode( iAM );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_active_sound_receiver( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetActiveSoundReceiver() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_active_sound_receiver( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "i:set_active_sound_receiver", _keywords, 0 };
    	long iID = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetActiveSoundReceiver( iID );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_active_sound_receiver_explicit_renderer( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	static const char * const _keywords[] = { "id", NULL };
    	static _PyArg_Parser _parser = { "s:set_active_sound_receiver_explicit_renderer", _keywords, 0 };
    	char* pcID = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcID ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	return PyLong_FromLong( g_pVANetClient->GetCoreInstance()->GetActiveSoundReceiverExplicitRenderer( sID ) );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_active_sound_receiver_explicit_renderer( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "id", "renderer", NULL };
    	static _PyArg_Parser _parser = { "is:set_active_sound_receiver_explicit_renderer", _keywords, 0 };
    	long iID = -1;
    	char* pcID = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iID, &pcID ) )
    		return NULL;
    
    	std::string sID = pcID ? std::string( pcID ) : "";
    	g_pVANetClient->GetCoreInstance()->SetActiveSoundReceiverExplicitRenderer( iID, sID );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_core_clock( PyObject*, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    	return PyFloat_FromDouble( g_pVANetClient->GetCoreInstance()->GetCoreClock() );
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* set_core_clock( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "time", NULL };
    	static _PyArg_Parser _parser = { "d:set_core_clock", _keywords, 0 };
    	double dTime = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &dTime ) )
    		return NULL;
    
    	g_pVANetClient->GetCoreInstance()->SetCoreClock( dTime );
    	return Py_None;
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* substitute_macro( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "rawstring", NULL };
    	static _PyArg_Parser _parser = { "s:substitute_macro", _keywords, 0 };
    	char* pcRawString = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcRawString ) )
    		return NULL;
    
    	std::string sSubstitutedString = g_pVANetClient->GetCoreInstance()->SubstituteMacros( std::string( pcRawString ) );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSubstitutedString ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* find_file_path( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "rawpath", NULL };
    	static _PyArg_Parser _parser = { "s:find_file_path", _keywords, 0 };
    	char* pcRawFilePath = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcRawFilePath ) )
    		return NULL;
    
    	std::string sSubstitutedPath = g_pVANetClient->GetCoreInstance()->FindFilePath( std::string( pcRawFilePath ) );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sSubstitutedPath ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_core_configuration( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "filter_enabled", NULL };
    	static _PyArg_Parser _parser = { "|b:get_core_configuration", _keywords, 0 };
    	bool bFilterEnabled = true;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &bFilterEnabled ) )
    		return NULL;
    
    	CVAStruct oCoreConfig = g_pVANetClient->GetCoreInstance()->GetCoreConfiguration( bFilterEnabled );
    	return ConvertVAStructToPythonDict( oCoreConfig );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_hardware_configuration( PyObject*, PyObject**, Py_ssize_t, PyObject* )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	CVAStruct oHWConfig = g_pVANetClient->GetCoreInstance()->GetHardwareConfiguration();
    	return ConvertVAStructToPythonDict( oHWConfig );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_file_list( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "recursive", "filter_suffix_mask", NULL };
    	static _PyArg_Parser _parser = { "|bs:get_file_list", _keywords, 0 };
    	bool bFilterEnabled = true;
    	char* pcFilterSuffixMask = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &bFilterEnabled, &pcFilterSuffixMask ) )
    		return NULL;
    
    	std::string sFilterSuffixMask = pcFilterSuffixMask ? std::string( pcFilterSuffixMask ) : "*";
    	CVAStruct oFileList = g_pVANetClient->GetCoreInstance()->GetFileList( bFilterEnabled, sFilterSuffixMask );
    	return ConvertVAStructToPythonDict( oFileList );
    
    	VAPY_CATCH_RETURN;
    };
    
    
    static PyObject* get_log_level_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "loglevel", NULL };
    	static _PyArg_Parser _parser = { "i:get_log_level_str", _keywords, 0 };
    	int iLogLevel = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iLogLevel ) )
    		return NULL;
    
    	std::string sLogLevel = g_pVANetClient->GetCoreInstance()->GetLogLevelStr( iLogLevel );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sLogLevel ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* parse_auralization_mode_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "auralization_mode_string", NULL };
    	static _PyArg_Parser _parser = { "s:parse_auralization_mode_str", _keywords, 0 };
    	char* pcAM = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcAM ) )
    		return NULL;
    
    	int iAM = g_pVANetClient->GetCoreInstance()->ParseAuralizationModeStr( std::string( pcAM ) );
    	return PyLong_FromLong( iAM );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_auralization_mode_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "auralization_mode", NULL };
    	static _PyArg_Parser _parser = { "i:get_auralization_mode_str", _keywords, 0 };
    	int iAM = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iAM ) )
    		return NULL;
    
    	std::string sAM = g_pVANetClient->GetCoreInstance()->GetAuralizationModeStr( iAM );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sAM ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_volume_str_decibel( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "gain", NULL };
    	static _PyArg_Parser _parser = { "d:get_volume_str_decibel", _keywords, 0 };
    	double dGain = -1.0f;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &dGain ) )
    		return NULL;
    
    	std::string sGainDB = g_pVANetClient->GetCoreInstance()->GetVolumeStrDecibel( dGain );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sGainDB ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* parse_playback_state_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "state_string", NULL };
    	static _PyArg_Parser _parser = { "s:parse_playback_state_str", _keywords, 0 };
    	char* pcState = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcState ) )
    		return NULL;
    
    	int iState = g_pVANetClient->GetCoreInstance()->ParsePlaybackState( std::string( pcState ) );
    	return PyLong_FromLong( iState );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* parse_playback_action_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "action_string", NULL };
    	static _PyArg_Parser _parser = { "s:parse_playback_action_str", _keywords, 0 };
    	char* pcAction = nullptr;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &pcAction ) )
    		return NULL;
    
    	int iState = g_pVANetClient->GetCoreInstance()->ParsePlaybackState( std::string( pcAction ) );
    	return PyLong_FromLong( iState );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_playback_state_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "state", NULL };
    	static _PyArg_Parser _parser = { "i:get_playback_state_str", _keywords, 0 };
    	int iState = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iState ) )
    		return NULL;
    
    	std::string sState = g_pVANetClient->GetCoreInstance()->GetPlaybackStateStr( iState );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sState ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };
    
    static PyObject* get_playback_action_str( PyObject*, PyObject** ppArgs, Py_ssize_t nArgs, PyObject* pKeywordNames )
    {
    	VAPY_REQUIRE_CONN_TRY;
    
    	static const char * const _keywords[] = { "state", NULL };
    	static _PyArg_Parser _parser = { "i:get_playback_action_str", _keywords, 0 };
    	int iAction = -1;
    	if( !_PyArg_ParseStack( ppArgs, nArgs, pKeywordNames, &_parser, &iAction ) )
    		return NULL;
    
    	std::string sAction = g_pVANetClient->GetCoreInstance()->GetPlaybackActionStr( iAction );
    	return PyUnicode_FromString( SaveStringToUnicodeConversion( sAction ).c_str() );
    
    	VAPY_CATCH_RETURN;
    };