Select Git revision
-
Aurelien Jarno authored
Silence compiler warning by providing proper CONFIG_BLUEZ-independent header for the bt-host API. Signed-off-by:
Jan Kiszka <jan.kiszka@siemens.com> Signed-off-by:
Aurelien Jarno <aurelien@aurel32.net> git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6809 c046a42c-6fe2-441c-8c8c-71466251a162
Aurelien Jarno authoredSilence compiler warning by providing proper CONFIG_BLUEZ-independent header for the bt-host API. Signed-off-by:
Jan Kiszka <jan.kiszka@siemens.com> Signed-off-by:
Aurelien Jarno <aurelien@aurel32.net> git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6809 c046a42c-6fe2-441c-8c8c-71466251a162
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;
};