XN_C_API XnStatus xnOSAcceptSocket(XN_SOCKET_HANDLE ListenSocket, XN_SOCKET_HANDLE* AcceptSocketPtr, XnUInt32 nMillisecondsTimeout)
{
// Local function variables
XnInt32 nRetVal = 0;
struct timeval selectTimeOut;
struct timeval* pTimeout = xnOSMillisecsToTimeVal(nMillisecondsTimeout, &selectTimeOut);
fd_set fdReadHandles;
XN_SOCKET_HANDLE AcceptSocket = NULL;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(ListenSocket);
XN_VALIDATE_OUTPUT_PTR(AcceptSocketPtr);
// Make sure the actual socket handle isn't NULL
XN_RET_IF_INVALID(ListenSocket->Socket, XN_STATUS_OS_INVALID_SOCKET);
// Wait for connection request
FD_ZERO(&fdReadHandles);
FD_SET(ListenSocket->Socket, &fdReadHandles);
nRetVal = select(ListenSocket->Socket + 1, &fdReadHandles, NULL, NULL, pTimeout);
if (nRetVal == 0)
{
return (XN_STATUS_OS_NETWORK_TIMEOUT);
}
else if (nRetVal == -1)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_NETWORK_SOCKET_ACCEPT_FAILED, XN_MASK_OS, "select() returned error: %d", errno);
}
// Allocate a new socket
XN_VALIDATE_ALIGNED_CALLOC(*AcceptSocketPtr, xnOSSocket, 1, XN_DEFAULT_MEM_ALIGN);
AcceptSocket = *AcceptSocketPtr;
// Accept the socket and make sure it succeeded
AcceptSocket->nSocketAddressLen = sizeof(AcceptSocket->SocketAddress);
AcceptSocket->Socket = accept(ListenSocket->Socket, (sockaddr*)&AcceptSocket->SocketAddress, &AcceptSocket->nSocketAddressLen);
if (AcceptSocket->Socket== -1)
{
xnOSCloseSocket(AcceptSocket);
xnOSFreeAligned(*AcceptSocketPtr);
return(XN_STATUS_OS_NETWORK_SOCKET_ACCEPT_FAILED);
}
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSGetHighResTimeStamp(XnUInt64* nTimeStamp)
{
// Local function variables
XnStatus nRetVal = XN_STATUS_OK;
// TODO: Check if the core subsystem is initialized
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_OUTPUT_PTR(nTimeStamp);
// Get the high resolution global timer value
nRetVal = xnOSQueryTimer(g_xnOSHighResGlobalTimer, nTimeStamp);
XN_IS_STATUS_OK(nRetVal);
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnUSBIsDevicePresent(XnUInt16 /*nVendorID*/, XnUInt16 /*nProductID*/, void* pExtraParam, XnBool* pbDevicePresent)
{
// Local variables
LPGUID pInterfaceGuid = NULL;
HDEVINFO deviceInfo;
SP_DEVICE_INTERFACE_DATA interfaceData;
BOOL bResult = FALSE;
// Validate the input/output pointers
XN_VALIDATE_INPUT_PTR(pExtraParam);
XN_VALIDATE_OUTPUT_PTR(pbDevicePresent);
// Init the driver GUID
pInterfaceGuid = (LPGUID)pExtraParam;
// Let's assume the device is not present for now
*pbDevicePresent = FALSE;
// See if the driver is installed
deviceInfo = SetupDiGetClassDevs(pInterfaceGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
if (deviceInfo == INVALID_HANDLE_VALUE)
{
// No devices are present...
return (XN_STATUS_OK);
}
// See if any devices are attached
interfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
bResult = SetupDiEnumDeviceInterfaces(deviceInfo, NULL, pInterfaceGuid, 0, &interfaceData);
if (bResult == FALSE)
{
SetupDiDestroyDeviceInfoList(deviceInfo);
// No devices are present...
return (XN_STATUS_OK);
}
SetupDiDestroyDeviceInfoList(deviceInfo);
// Yay! We found at least one device
*pbDevicePresent = TRUE;
// All is good...
return (XN_STATUS_OK);
}
XN_DDK_API XnStatus XnStreamDataSetCreate(XnStreamDataSet** ppStreamOutputSet)
{
XN_VALIDATE_OUTPUT_PTR(ppStreamOutputSet);
// allocate struct
XN_VALIDATE_CALLOC(*ppStreamOutputSet, XnStreamDataSet, 1);
XnStreamDataSet* pSet = (*ppStreamOutputSet);
// allocate hash table
pSet->pHash = XN_NEW(XnStreamDataHash);
if (pSet->pHash == NULL)
{
XnStreamDataSetDestroy(ppStreamOutputSet);
return XN_STATUS_ALLOC_FAILED;
}
return XN_STATUS_OK;
}
XN_DDK_API XnStatus XnPropertySetCreate(XnPropertySet** ppSet)
{
XN_VALIDATE_OUTPUT_PTR(ppSet);
XnPropertySet* pSet;
XN_VALIDATE_ALLOC(pSet, XnPropertySet);
pSet->pData = XN_NEW(XnPropertySetData);
if (pSet->pData == NULL)
{
xnOSFree(pSet);
return XN_STATUS_ALLOC_FAILED;
}
*ppSet = pSet;
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSGetProcAddress(const XN_LIB_HANDLE LibHandle, const XnChar* cpProcName, XnFarProc* pProcAddr)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpProcName);
XN_VALIDATE_OUTPUT_PTR(pProcAddr);
// Make sure the actual shared library handle isn't NULL
XN_RET_IF_NULL(LibHandle, XN_STATUS_OS_INVALID_LIBRARY);
// Get the requested procedure address from the shared library via the OS
*pProcAddr = GetProcAddress(LibHandle, cpProcName);
// Make sure it succeeded (return value is not NULL). If not return an error....
XN_VALIDATE_PTR(*pProcAddr, XN_STATUS_OS_PROC_NOT_FOUND);
// All is good...
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::CreateStreamData(const XnChar* StreamName, XnStreamData** ppStreamData)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(StreamName);
XN_VALIDATE_OUTPUT_PTR(ppStreamData);
// find stream
XnDeviceStream* pStream;
nRetVal = FindStream(StreamName, &pStream);
XN_IS_STATUS_OK(nRetVal);
// and create stream output
nRetVal = pStream->CreateStreamData(ppStreamData);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSDoesFileExist(const XnChar* cpFileName, XnBool* pbResult)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pbResult);
// Reset the output result
*pbResult = FALSE;
// Check if the file exists and update the result accordingly
if ((access(cpFileName, F_OK)) != -1)
{
*pbResult = TRUE;
}
// All is good...
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XN_C_API XnStatus xnOSLoadLibrary(const XnChar* cpFileName, XN_LIB_HANDLE* pLibHandle)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pLibHandle);
// Load the requested shared library via the OS
*pLibHandle = dlopen(cpFileName, RTLD_NOW);
// Make sure it succeeded (return value is not NULL). If not return an error....
if (*pLibHandle == NULL)
{
xnLogWarning(XN_MASK_OS, "Failed loading lib: %s\n", dlerror());
return XN_STATUS_OS_CANT_LOAD_LIB;
}
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnUSBOpenDevice(XnUInt16 nVendorID, XnUInt16 nProductID, void* pExtraParam, void* pExtraParam2, XN_USB_DEV_HANDLE* pDevHandlePtr)
{
XnStatus nRetVal = XN_STATUS_OK;
// make sure library was initialized
XN_VALIDATE_USB_INIT();
// Validate parameters
XN_VALIDATE_OUTPUT_PTR(pDevHandlePtr);
libusb_device* pDevice;
nRetVal = FindDevice(nVendorID, nProductID, pExtraParam, &pDevice);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnUSBOpenDeviceImpl(pDevice, pDevHandlePtr);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XN_C_API XnStatus xnOSLoadLibrary(const XnChar* cpFileName, XN_LIB_HANDLE* pLibHandle)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pLibHandle);
// Load the requested shared library via the OS
*pLibHandle = LoadLibraryEx(cpFileName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
// Make sure it succeeded (return value is not NULL). If not return an error....
if (*pLibHandle == NULL)
{
xnLogWarning(XN_MASK_OS, "Failed to load library '%s'. Error code: %d", cpFileName, GetLastError());
return (XN_STATUS_OS_CANT_LOAD_LIB);
}
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus XN_C_DECL xnOSCreateNamedEventEx(XN_EVENT_HANDLE* pEventHandle, const XnChar* cpEventName, XnBool bManualReset, XnBool bAllowOtherUsers)
{
// Local function variables
XnStatus nRetVal = XN_STATUS_OK;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_OUTPUT_PTR(pEventHandle);
XnChar strEventOSName[MAX_PATH];
XnChar* pEventOSName = NULL;
SECURITY_ATTRIBUTES* pSecurityAttributes = NULL;
if (cpEventName != NULL)
{
nRetVal = XnWin32CreateKernelObjectName(strEventOSName, MAX_PATH, cpEventName, bAllowOtherUsers);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_EVENT_CREATION_FAILED;
}
pEventOSName = strEventOSName;
nRetVal = XnWin32GetSecurityAttributes(bAllowOtherUsers, &pSecurityAttributes);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_MUTEX_CREATION_FAILED;
}
}
// Create a named event via the OS
*pEventHandle = CreateEvent(pSecurityAttributes, bManualReset, FALSE, pEventOSName);
// Make sure it succeeded (return value is not null)
if (*pEventHandle == NULL)
{
xnLogError(XN_MASK_OS, "CreateEvent() failed with error %u", GetLastError());
return XN_STATUS_OS_EVENT_CREATION_FAILED;
}
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSQueryTimer(XnOSTimer Timer, XnUInt64* pnTimeSinceStart)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_OUTPUT_PTR(pnTimeSinceStart);
struct timespec now;
if (XN_STATUS_OK != xnOSGetMonoTime(&now))
{
return XN_STATUS_OS_TIMER_QUERY_FAILED;
}
*pnTimeSinceStart = ((now.tv_sec - Timer.tStartTime.tv_sec) * 1E6 + (now.tv_nsec - Timer.tStartTime.tv_nsec) / 1E3);
if (!Timer.bHighRes)
{
*pnTimeSinceStart /= 1000;
}
return XN_STATUS_OK;
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XN_C_API XnStatus xnOSCreateThread(XN_THREAD_PROC_PROTO pThreadProc, const XN_THREAD_PARAM pThreadParam, XN_THREAD_HANDLE* pThreadHandle)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(pThreadProc);
XN_VALIDATE_OUTPUT_PTR(pThreadHandle);
// allocate thread handle
XN_VALIDATE_ALLOC(*pThreadHandle, pthread_t);
// Create a thread via the OS
int rc = pthread_create(*pThreadHandle, NULL, pThreadProc, pThreadParam);
if (rc != 0)
{
XN_FREE_AND_NULL(*pThreadHandle);
return (XN_STATUS_OS_THREAD_CREATION_FAILED);
}
// All is good...
return (XN_STATUS_OK);
}
XnStatus XnCodec::CompressData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pSrc);
XN_VALIDATE_INPUT_PTR(pDst);
XN_VALIDATE_OUTPUT_PTR(pnBytesWritten);
if ((nSrcSize * GetWorseCompressionRatio() + GetOverheadSize()) > nDstSize)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OUTPUT_BUFFER_OVERFLOW, XN_MASK_OPEN_NI, "Can't compress data - destination buffer is not large enough");
}
nRetVal = CompressImpl((const XnUChar*)pSrc, nSrcSize, (XnUChar*)pDst, &nDstSize);
XN_IS_STATUS_OK(nRetVal);
*pnBytesWritten = nDstSize;
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSWriteFile(const XN_FILE_HANDLE File, const void* pBuffer, const XnUInt32 nBufferSize)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_OUTPUT_PTR(pBuffer);
// Make sure the actual file handle isn't NULL
XN_RET_IF_NULL(File, XN_STATUS_OS_INVALID_FILE);
// Write a buffer to a file handle via the OS
XnUInt32 nBytesWritten = fwrite(pBuffer, 1, nBufferSize, File);
// Make sure it succeeded (return value is true) and that the correct number of bytes were written
if (nBufferSize != nBytesWritten)
{
return (XN_STATUS_OS_FILE_WRITE_FAILED);
}
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSFileExists(const XnChar* cpFileName, XnBool* bResult)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(bResult);
// Reset the output result
*bResult = FALSE;
// try to open it
FILE* pFile = fopen(cpFileName, "r");
if (pFile != NULL)
{
fclose(pFile);
*bResult = TRUE;
}
// All is good...
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnStatus xnFPSInit(XnFPSData* pFPS, XnUInt32 nSamplesCount)
{
XN_VALIDATE_OUTPUT_PTR(pFPS);
// make sure xnOS is init
XnStatus nRetVal = xnOSInit();
if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_OS_ALREADY_INIT)
return nRetVal;
// Allocate struct
XN_VALIDATE_CALLOC(*pFPS, XnFPSDataImpl, 1);
XnFPSDataImpl* pData = *pFPS;
// Allocate array
XN_VALIDATE_ALIGNED_CALLOC(pData->anTimes, XnUInt64, nSamplesCount, XN_DEFAULT_MEM_ALIGN);
pData->nArraySize = nSamplesCount;
return XN_STATUS_OK;
}
XnStatus ExportedRecorder::Create(xn::Context& context, const XnChar* strInstanceName, const XnChar* strCreationInfo, xn::NodeInfoList* pNeededTrees, const XnChar* strConfigurationDir, xn::ModuleProductionNode** ppInstance)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(strInstanceName);
XN_VALIDATE_INPUT_PTR(strCreationInfo);
XN_VALIDATE_OUTPUT_PTR(ppInstance);
nRetVal = xnOSStrCopy(m_strInstanceName, strInstanceName, sizeof(m_strInstanceName));
XN_IS_STATUS_OK(nRetVal);
if (strcmp(strCreationInfo, CREATION_INFO) != 0)
{
//This is not the creation info we gave in EnumerateProductionTrees
XN_LOG_ERROR_RETURN(XN_STATUS_NO_MATCH, XN_MASK_OPEN_NI, "Invalid creation info");
}
RecorderNode *pRecorderNode;
XN_VALIDATE_NEW_AND_INIT(pRecorderNode, RecorderNode, context);
*ppInstance = pRecorderNode;
return XN_STATUS_OK;
}
XN_C_API XnStatus xnOSGetFileName(const XnChar* cpFilePath, XnChar* cpFileName, const XnUInt32 nBufferSize)
{
XnChar ext[XN_FILE_MAX_PATH];
XN_VALIDATE_INPUT_PTR(cpFilePath);
XN_VALIDATE_OUTPUT_PTR(cpFileName);
errno_t err = _splitpath_s(cpFilePath, NULL, 0, NULL, 0, cpFileName, nBufferSize, ext, sizeof(ext));
if (err == ERANGE)
{
return XN_STATUS_OUTPUT_BUFFER_OVERFLOW;
}
else if (err != 0)
{
return XN_STATUS_ERROR;
}
XnStatus nRetVal = xnOSStrAppend(cpFileName, ext, nBufferSize);
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
XN_C_API XnStatus XN_C_DECL xnOSOpenNamedEventEx(XN_EVENT_HANDLE* pEventHandle, const XnChar* cpEventName, XnBool bAllowOtherUsers)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(cpEventName);
XN_VALIDATE_OUTPUT_PTR(pEventHandle);
XnChar strEventOSName[MAX_PATH];
nRetVal = XnWin32CreateKernelObjectName(strEventOSName, MAX_PATH, cpEventName, bAllowOtherUsers);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_EVENT_CREATION_FAILED;
}
*pEventHandle = OpenEvent(EVENT_MODIFY_STATE | SYNCHRONIZE, FALSE, cpEventName);
if (*pEventHandle == NULL)
{
return XN_STATUS_OS_EVENT_OPEN_FAILED;
}
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSCreateNamedEvent(XN_EVENT_HANDLE* pEventHandle, const XnChar* cpEventName, XnBool bManualReset)
{
// Local function variables
XnStatus nRetVal = XN_STATUS_OK;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_OUTPUT_PTR(pEventHandle);
// Create a named event via the OS
*pEventHandle = CreateEvent(NULL, bManualReset, FALSE, cpEventName);
// Make sure it succeeded (return value is not null)
if (*pEventHandle == NULL)
{
xnLogError(XN_MASK_OS, "CreateEvent() failed with error %u", GetLastError());
return XN_STATUS_OS_EVENT_CREATION_FAILED;
}
// All is good...
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::DoesModuleExist(const XnChar* ModuleName, XnBool* pbDoesExist)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(ModuleName);
XN_VALIDATE_OUTPUT_PTR(pbDoesExist);
*pbDoesExist = FALSE;
XnDeviceModuleHolder* pModuleHolder;
nRetVal = FindModule(ModuleName, &pModuleHolder);
if (nRetVal == XN_STATUS_OK)
{
*pbDoesExist = TRUE;
}
else if (nRetVal != XN_STATUS_DEVICE_MODULE_NOT_FOUND)
{
return nRetVal;
}
return XN_STATUS_OK;
}
XN_C_API XnStatus xnOSQueryTimer(XnOSTimer Timer, XnUInt64* pnTimeSinceStart)
{
// Local function variables
XnBool bRetVal = FALSE;
LARGE_INTEGER nCurrTick;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_OUTPUT_PTR(pnTimeSinceStart);
if (Timer.dTicksPerTimeUnit == 0)
{
return (XN_STATUS_OS_INVALID_TIMER);
}
bRetVal = QueryPerformanceCounter(&nCurrTick);
XN_IS_BOOL_OK_RET(bRetVal, XN_STATUS_OS_TIMER_QUERY_FAILED);
*pnTimeSinceStart = XnUInt64((nCurrTick.QuadPart - Timer.nStartTick.QuadPart) / Timer.dTicksPerTimeUnit);
// All is good...
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSLoadLibrary(const XnChar* cpFileName, XN_LIB_HANDLE* pLibHandle)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pLibHandle);
// Load the requested shared library via the OS (set error mode before, because otherwise, if a dependency DLL is missing,
// Windows will pop a message box)
DWORD prevMode = SetErrorMode(SEM_FAILCRITICALERRORS);
*pLibHandle = LoadLibraryEx(cpFileName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
SetErrorMode(prevMode);
// Make sure it succeeded (return value is not NULL). If not return an error....
if (*pLibHandle == NULL)
{
xnLogWarning(XN_MASK_OS, "Failed to load library '%s'. Error code: %d", cpFileName, GetLastError());
return (XN_STATUS_OS_CANT_LOAD_LIB);
}
// All is good...
return (XN_STATUS_OK);
}
XN_DDK_API XnStatus XnPropertySetDataDetachModule(XnPropertySetData* pSetData, const XnChar* strModuleName, XnActualPropertiesHash** ppModule)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pSetData);
XN_VALIDATE_INPUT_PTR(strModuleName);
XN_VALIDATE_OUTPUT_PTR(ppModule);
// remove it
XnPropertySetDataInternal::Iterator it = pSetData->Find(strModuleName);
if (it == pSetData->End())
{
return XN_STATUS_NO_MATCH;
}
*ppModule = it->Value();
nRetVal = pSetData->Remove(strModuleName);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSReadIntFromINI(const XnChar* cpINIFile, const XnChar* cpSection, const XnChar* cpKey, XnUInt32* nDest)
{
XnStatus nRetVal = XN_STATUS_OK;
XnBool bINIFileExists = FALSE;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpSection);
XN_VALIDATE_INPUT_PTR(cpKey);
XN_VALIDATE_INPUT_PTR(cpINIFile);
XN_VALIDATE_OUTPUT_PTR(nDest);
// Make sure the INI file exists
XN_VALIDATE_FILE_EXISTS_RET(cpINIFile, nRetVal, bINIFileExists, XN_STATUS_OS_INI_FILE_NOT_FOUND);
// find value
XnChar cpValueString[XN_INI_MAX_LEN];
nRetVal = FindEntry(cpINIFile, cpSection, cpKey, cpValueString);
XN_IS_STATUS_OK(nRetVal);
*nDest = atoi(cpValueString);
return XN_STATUS_OK;
}
XN_DDK_API XnStatus XnPropertySetModuleEnumeratorMoveNext(XnPropertySetModuleEnumerator* pEnumerator, XnBool* pbEnd)
{
XN_VALIDATE_INPUT_PTR(pEnumerator);
XN_VALIDATE_OUTPUT_PTR(pbEnd);
if (pEnumerator->bFirst)
{
pEnumerator->it = pEnumerator->pModules->Begin();
pEnumerator->bFirst = FALSE;
}
else if (pEnumerator->it == pEnumerator->pModules->End())
{
return XN_STATUS_ILLEGAL_POSITION;
}
else
{
pEnumerator->it++;
}
*pbEnd = (pEnumerator->it == pEnumerator->pModules->End());
return (XN_STATUS_OK);
}
XN_DDK_API XnStatus XN_DEVICE_PROXY_PROTO(Create)(XnDeviceHandle* pDeviceHandle, const XnDeviceConfig* pDeviceConfig)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pDeviceConfig);
XN_VALIDATE_OUTPUT_PTR(pDeviceHandle);
// get device type from connection string
XN_VALIDATE_INPUT_PTR(pDeviceConfig->cpConnectionString);
// search for separator
const XnChar* pSeparator = strstr(pDeviceConfig->cpConnectionString, XN_DEVICE_PROXY_CONNECTION_STRING_SEPARATOR);
if (pSeparator == NULL)
return (XN_STATUS_IO_INVALID_CONNECTION_STRING);
// copy device name
XnChar csDeviceName[XN_DEVICE_MAX_STRING_LENGTH];
nRetVal = xnOSStrNCopy(csDeviceName, pDeviceConfig->cpConnectionString, (XnUInt32)(pSeparator - pDeviceConfig->cpConnectionString), XN_DEVICE_MAX_STRING_LENGTH);
XN_IS_STATUS_OK(nRetVal);
csDeviceName[pSeparator - pDeviceConfig->cpConnectionString] = '\0';
// create internal device config
XnDeviceConfig InternalConfig = *pDeviceConfig;
// replace internal connection string
XnConnectionString csInternalConnectionString;
nRetVal = xnOSStrCopy(csInternalConnectionString, pSeparator + 1, XN_DEVICE_MAX_STRING_LENGTH);
XN_IS_STATUS_OK(nRetVal);
InternalConfig.cpConnectionString = csInternalConnectionString;
// create the device
nRetVal = XnDeviceProxyCreateDeviceByName(csDeviceName, pDeviceHandle, &InternalConfig);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XN_C_API XnStatus xnOSLoadLibrary(const XnChar* cpFileName, XN_LIB_HANDLE* pLibHandle)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(cpFileName);
XN_VALIDATE_OUTPUT_PTR(pLibHandle);
#ifndef XN_PLATFORM_ANDROID_OS
// Resolve the file name to the absolute path. This is necessary because
// we need to get the absolute path of this library by dladdr() later.
// Note dladdr() seems to return the path specified to dlopen() "as it is".
XnChar* strAbsoluteFileName = realpath(cpFileName, NULL);
if (strAbsoluteFileName == NULL)
{
// error
xnLogWarning(XN_MASK_OS, "Failed to get absolute path for lib: %s\n", cpFileName);
return XN_STATUS_OS_CANT_LOAD_LIB;
}
// Load the requested shared library via the OS
*pLibHandle = dlopen(strAbsoluteFileName, RTLD_NOW);
free(strAbsoluteFileName); // Don't forget to free the memory allocated by realpath().
#else
*pLibHandle = dlopen(cpFileName, RTLD_NOW);
#endif
// Make sure it succeeded (return value is not NULL). If not return an error....
if (*pLibHandle == NULL)
{
xnLogWarning(XN_MASK_OS, "Failed loading lib: %s\n", dlerror());
return XN_STATUS_OS_CANT_LOAD_LIB;
}
// All is good...
return (XN_STATUS_OK);
}
