XN_C_API XnStatus xnLogInitFromINIFile(const XnChar* cpINIFileName, const XnChar* cpSectionName)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nTemp;
xnLogReadMasksFromINI(cpINIFileName, cpSectionName, "LogMasks", &g_xnLoggerData.m_nLogFilteringType, &g_xnLoggerData.m_LogMasks);
xnLogReadMasksFromINI(cpINIFileName, cpSectionName, "DumpMasks", &g_xnLoggerData.m_nDumpFilteringType, &g_xnLoggerData.m_DumpMasks);
g_xnLoggerData.m_nFilterSeverity = XN_LOG_ERROR;
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogLevel", &nTemp);
if (nRetVal == XN_STATUS_OK)
g_xnLoggerData.m_nFilterSeverity = (XnLogSeverity)nTemp;
g_xnLoggerData.m_bWriteToConsole = FALSE;
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogWriteToConsole", &nTemp);
if (nRetVal == XN_STATUS_OK)
g_xnLoggerData.m_bWriteToConsole = nTemp;
g_xnLoggerData.m_bWriteToFile = TRUE;
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogWriteToFile", &nTemp);
if (nRetVal == XN_STATUS_OK)
g_xnLoggerData.m_bWriteToFile = nTemp;
g_xnLoggerData.m_bWriteLineInfo = TRUE;
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogWriteLineInfo", &nTemp);
if (nRetVal == XN_STATUS_OK)
g_xnLoggerData.m_bWriteLineInfo = nTemp;
return xnLogInitSystem();
}
XnStatus LinkOniMapStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = LinkOniStream::Init();
XN_IS_STATUS_OK(nRetVal);
nRetVal = FillSupportedVideoModes();
XN_IS_STATUS_OK(nRetVal);
// read video mode
XnChar videoModeSection[255];
sprintf(videoModeSection, "%s.VideoMode", m_configSection);
OniVideoMode videoMode;
GetVideoMode(&videoMode);
// override with streams default values
GetDefaultVideoMode(&videoMode);
// override with INI config
XnInt32 temp32;
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "XResolution", &temp32))
{
videoMode.resolutionX = (int)temp32;
}
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "YResolution", &temp32))
{
videoMode.resolutionY = (int)temp32;
}
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "FPS", &temp32))
{
videoMode.fps = (int)temp32;
}
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, videoModeSection, "PixelFormat", &temp32))
{
videoMode.pixelFormat = (OniPixelFormat)temp32;
}
nRetVal = SetVideoMode(&videoMode);
XN_IS_STATUS_OK(nRetVal);
nRetVal = setIntPropertyFromINI("LinkPixelFormat", LINK_PROP_PIXEL_FORMAT);
XN_IS_STATUS_OK(nRetVal);
nRetVal = setIntPropertyFromINI("Compression", LINK_PROP_COMPRESSION);
XN_IS_STATUS_OK(nRetVal);
OniBool bMirror = TRUE;
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, m_configSection, "Mirror", &temp32))
{
bMirror = (temp32 == 1);
}
nRetVal = SetMirror(bMirror);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnLogInitFromINIFile(const XnChar* cpINIFileName, const XnChar* cpSectionName)
{
XnStatus nRetVal = XN_STATUS_OK;
XnInt32 nTemp;
// read filters
xnLogReadMasksFromINI(cpINIFileName, cpSectionName, "LogMasks", xnLogBCSetMaskState);
xnLogReadMasksFromINI(cpINIFileName, cpSectionName, "DumpMasks", xnDumpSetMaskState);
//Test if log redirection is needed
XnChar strLogPath[XN_FILE_MAX_PATH] = {0};
nRetVal = xnOSReadStringFromINI(cpINIFileName, cpSectionName, "LogPath", strLogPath, XN_FILE_MAX_PATH);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetOutputFolder(strLogPath);
XN_IS_STATUS_OK(nRetVal);
}
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "Verbosity", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetMaskMinSeverity(XN_LOG_MASK_ALL, (XnLogSeverity)nTemp);
XN_IS_STATUS_OK(nRetVal);
}
// configure writers
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogToConsole", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetConsoleOutput(nTemp);
XN_IS_STATUS_OK(nRetVal);
}
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogToFile", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetFileOutput(nTemp);
XN_IS_STATUS_OK(nRetVal);
}
#if XN_PLATFORM == XN_PLATFORM_ANDROID_ARM
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogToAndroidLog", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetAndroidOutput(nTemp);
XN_IS_STATUS_OK(nRetVal);
}
#endif
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogLineInfo", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetLineInfo(nTemp);
XN_IS_STATUS_OK(nRetVal);
}
return XN_STATUS_OK;
}
XnStatus XN_CALLBACK_TYPE XnSensorDepthStream::ReadAGCBinsFromFile(XnGeneralProperty* pSender, const XnChar* csINIFile, const XnChar* csSection)
{
XnStatus nRetVal = XN_STATUS_OK;
for (XnUInt32 nBin = 0; nBin < XN_DEPTH_STREAM_AGC_NUMBER_OF_BINS; ++nBin)
{
XnChar csKey[XN_INI_MAX_LEN];
XnUInt32 nValue;
XnDepthAGCBin bin;
bin.nBin = (XnUInt16)nBin;
XnBool bHasMin = FALSE;
XnBool bHasMax = FALSE;
sprintf(csKey, "AGCBin%uMinDepth", nBin);
nRetVal = xnOSReadIntFromINI(csINIFile, csSection, csKey, &nValue);
if (nRetVal == XN_STATUS_OK)
{
bin.nMin = (XnUInt16)nValue;
bHasMin = TRUE;
}
sprintf(csKey, "AGCBin%uMaxDepth", nBin);
nRetVal = xnOSReadIntFromINI(csINIFile, csSection, csKey, &nValue);
if (nRetVal == XN_STATUS_OK)
{
bin.nMax = (XnUInt16)nValue;
bHasMax = TRUE;
}
if (bHasMax && bHasMin)
{
nRetVal = pSender->SetValue(XN_PACK_GENERAL_BUFFER(bin));
XN_IS_STATUS_OK(nRetVal);
}
else if (bHasMin || bHasMax)
{
// we have only one
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Bin %d should have both min and max values!", nBin);
}
}
return XN_STATUS_OK;
}
XN_C_API XnStatus xnLogInitFromINIFile(const XnChar* cpINIFileName, const XnChar* cpSectionName)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nTemp;
nRetVal = xnLogInitSystem();
XN_IS_STATUS_OK(nRetVal);
// read filters
xnLogReadMasksFromINI(cpINIFileName, cpSectionName, "LogMasks", xnLogSetMaskState);
xnLogReadMasksFromINI(cpINIFileName, cpSectionName, "DumpMasks", xnDumpSetMaskState);
g_logData.m_nFilterSeverity = XN_LOG_ERROR;
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogLevel", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetSeverityFilter((XnLogSeverity)nTemp);
XN_IS_STATUS_OK(nRetVal);
}
// configure writers
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogWriteToConsole", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetConsoleOutput(nTemp);
XN_IS_STATUS_OK(nRetVal);
}
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogWriteToFile", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetFileOutput(nTemp);
XN_IS_STATUS_OK(nRetVal);
}
nRetVal = xnOSReadIntFromINI(cpINIFileName, cpSectionName, "LogWriteLineInfo", &nTemp);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = xnLogSetLineInfo(nTemp);
XN_IS_STATUS_OK(nRetVal);
}
return XN_STATUS_OK;
}
XN_C_API XnStatus xnProfilingInitFromINI(const XnChar* cpINIFileName, const XnChar* cpSectionName)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nProfilingInterval = 0;
xnOSReadIntFromINI(cpINIFileName, cpSectionName, "ProfilingInterval", &nProfilingInterval);
nRetVal = xnProfilingInit(nProfilingInterval);
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
XnStatus LinkOniStream::setIntPropertyFromINI(const char* key, int propertyId)
{
XnInt32 value;
if (XN_STATUS_OK == xnOSReadIntFromINI(m_configFile, m_configSection, key, &value))
{
if (ONI_STATUS_OK != setProperty(propertyId, &value, sizeof(value)))
{
return XN_STATUS_ERROR;
}
}
return XN_STATUS_OK;
}
XnStatus XN_CALLBACK_TYPE XnPixelStream::ReadCroppingFromFileCallback(XnGeneralProperty* pSender, const XnChar* csINIFile, const XnChar* csSection)
{
XnStatus nRetVal = XN_STATUS_OK;
// read section name
XnChar csCroppingSection[XN_FILE_MAX_PATH];
sprintf(csCroppingSection, "%s.Cropping", csSection);
// read cropping values
XnUInt32 nOffsetX;
XnUInt32 nOffsetY;
XnUInt32 nSizeX;
XnUInt32 nSizeY;
XnUInt32 bEnabled;
// only if all values are here
if (XN_STATUS_OK == xnOSReadIntFromINI(csINIFile, csCroppingSection, "OffsetX", &nOffsetX) &&
XN_STATUS_OK == xnOSReadIntFromINI(csINIFile, csCroppingSection, "OffsetY", &nOffsetY) &&
XN_STATUS_OK == xnOSReadIntFromINI(csINIFile, csCroppingSection, "SizeX", &nSizeX) &&
XN_STATUS_OK == xnOSReadIntFromINI(csINIFile, csCroppingSection, "SizeY", &nSizeY) &&
XN_STATUS_OK == xnOSReadIntFromINI(csINIFile, csCroppingSection, "Enabled", &bEnabled))
{
XnCropping Cropping;
Cropping.nXOffset = nOffsetX;
Cropping.nYOffset = nOffsetY;
Cropping.nXSize = nSizeX;
Cropping.nYSize = nSizeY;
Cropping.bEnabled = bEnabled;
// set value
nRetVal = pSender->SetValue(XN_PACK_GENERAL_BUFFER(Cropping));
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnIntProperty::ReadValueFromFile(const XnChar* csINIFile, const XnChar* csSection)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nValue;
nRetVal = xnOSReadIntFromINI(csINIFile, csSection, GetName(), &nValue);
if (nRetVal == XN_STATUS_OK)
{
nRetVal = SetValue(nValue);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnExportedSensorDevice::Create(xn::Context& context, const XnChar* strInstanceName, const XnChar* strCreationInfo, xn::NodeInfoList* pNeededTrees, const XnChar* strConfigurationDir, xn::ModuleProductionNode** ppInstance)
{
XnStatus nRetVal = XN_STATUS_OK;
XnChar strGlobalConfigFile[XN_FILE_MAX_PATH];
nRetVal = XnSensor::ResolveGlobalConfigFileName(strGlobalConfigFile, XN_FILE_MAX_PATH, strConfigurationDir);
XN_IS_STATUS_OK(nRetVal);
XnBool bEnableMultiProcess = TRUE;
XnUInt32 nValue;
if (XN_STATUS_OK == xnOSReadIntFromINI(strGlobalConfigFile, XN_CONFIG_FILE_SERVER_SECTION, XN_MODULE_PROPERTY_ENABLE_MULTI_PROCESS, &nValue))
{
bEnableMultiProcess = (nValue == TRUE);
}
XnDeviceBase* pSensor = NULL;
if (bEnableMultiProcess)
{
XN_VALIDATE_NEW(pSensor, XnSensorClient);
}
else
{
XN_VALIDATE_NEW(pSensor, XnSensor);
}
XnDeviceConfig config;
config.DeviceMode = XN_DEVICE_MODE_READ;
config.cpConnectionString = strCreationInfo;
config.SharingMode = XN_DEVICE_EXCLUSIVE;
config.pInitialValues = NULL;
if (strConfigurationDir != NULL)
{
if (bEnableMultiProcess)
{
XnSensorClient* pClient = (XnSensorClient*)pSensor;
pClient->SetConfigDir(strConfigurationDir);
}
else
{
XnSensor* pActualSensor = (XnSensor*)pSensor;
pActualSensor->SetGlobalConfigFile(strGlobalConfigFile);
}
}
nRetVal = pSensor->Init(&config);
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pSensor);
return (nRetVal);
}
XnSensorDevice* pDevice = XN_NEW(XnSensorDevice, context, pSensor, strInstanceName);
if (pDevice == NULL)
{
XN_DELETE(pSensor);
return (XN_STATUS_ALLOC_FAILED);
}
nRetVal = pDevice->Init();
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pSensor);
return (nRetVal);
}
*ppInstance = pDevice;
return (XN_STATUS_OK);
}
OniStatus Context::initialize()
{
XnBool repositoryOverridden = FALSE;
XnChar repositoryFromINI[XN_FILE_MAX_PATH] = {0};
m_initializationCounter++;
if (m_initializationCounter > 1)
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Initialize: Already initialized");
return ONI_STATUS_OK;
}
XnStatus rc;
XnChar strModulePath[XN_FILE_MAX_PATH];
rc = xnOSGetModulePathForProcAddress(reinterpret_cast<void*>(&dummyFunctionToTakeAddress), strModulePath);
if (rc != XN_STATUS_OK)
{
m_errorLogger.Append("Couldn't get the OpenNI shared library module's path: %s", xnGetStatusString(rc));
return OniStatusFromXnStatus(rc);
}
XnChar strBaseDir[XN_FILE_MAX_PATH];
rc = xnOSGetDirName(strModulePath, strBaseDir, XN_FILE_MAX_PATH);
if (rc != XN_STATUS_OK)
{
// Very unlikely to happen, but just in case.
m_errorLogger.Append("Couldn't get the OpenNI shared library module's directory: %s", xnGetStatusString(rc));
return OniStatusFromXnStatus(rc);
}
s_valid = TRUE;
// Read configuration file
XnChar strOniConfigurationFile[XN_FILE_MAX_PATH];
XnBool configurationFileExists = FALSE;
// Search the module directory for OpenNI.ini.
xnOSStrCopy(strOniConfigurationFile, strBaseDir, XN_FILE_MAX_PATH);
rc = xnOSAppendFilePath(strOniConfigurationFile, ONI_CONFIGURATION_FILE, XN_FILE_MAX_PATH);
if (rc == XN_STATUS_OK)
{
xnOSDoesFileExist(strOniConfigurationFile, &configurationFileExists);
}
#ifdef ONI_PLATFORM_ANDROID_OS
xnLogSetMaskMinSeverity(XN_LOG_MASK_ALL, (XnLogSeverity)0);
xnLogSetAndroidOutput(TRUE);
#endif
if (configurationFileExists)
{
// First, we should process the log related configuration as early as possible.
XnInt32 nValue;
XnChar strLogPath[XN_FILE_MAX_PATH] = {0};
//Test if log redirection is needed
rc = xnOSReadStringFromINI(strOniConfigurationFile, "Log", "LogPath", strLogPath, XN_FILE_MAX_PATH);
if (rc == XN_STATUS_OK)
{
rc = xnLogSetOutputFolder(strLogPath);
if (rc != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_ONI_CONTEXT, "Failed to set log output folder: %s", xnGetStatusString(rc));
}
else
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Log directory redirected to: %s", strLogPath);
}
}
rc = xnOSReadIntFromINI(strOniConfigurationFile, "Log", "Verbosity", &nValue);
if (rc == XN_STATUS_OK)
{
xnLogSetMaskMinSeverity(XN_LOG_MASK_ALL, (XnLogSeverity)nValue);
}
rc = xnOSReadIntFromINI(strOniConfigurationFile, "Log", "LogToConsole", &nValue);
if (rc == XN_STATUS_OK)
{
xnLogSetConsoleOutput(nValue == 1);
}
rc = xnOSReadIntFromINI(strOniConfigurationFile, "Log", "LogToFile", &nValue);
if (rc == XN_STATUS_OK)
{
xnLogSetFileOutput(nValue == 1);
}
// Then, process the other device configurations.
rc = xnOSReadStringFromINI(strOniConfigurationFile, "Device", "Override", m_overrideDevice, XN_FILE_MAX_PATH);
if (rc != XN_STATUS_OK)
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "No override device in configuration file");
}
rc = xnOSReadStringFromINI(strOniConfigurationFile, "Drivers", "Repository", repositoryFromINI, XN_FILE_MAX_PATH);
if (rc == XN_STATUS_OK)
{
repositoryOverridden = TRUE;
}
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Configuration has been read from '%s'", strOniConfigurationFile);
}
else
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Couldn't find configuration file '%s'", strOniConfigurationFile);
}
xnLogVerbose(XN_MASK_ONI_CONTEXT, "OpenNI %s", ONI_VERSION_STRING);
// Resolve the drive path based on the module's directory.
XnChar strDriverPath[XN_FILE_MAX_PATH];
xnOSStrCopy(strDriverPath, strBaseDir, XN_FILE_MAX_PATH);
if (repositoryOverridden)
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Extending the driver path by '%s', as configured in file '%s'", repositoryFromINI, strOniConfigurationFile);
rc = xnOSAppendFilePath(strDriverPath, repositoryFromINI, XN_FILE_MAX_PATH);
}
else
{
rc = xnOSAppendFilePath(strDriverPath, ONI_DEFAULT_DRIVERS_REPOSITORY, XN_FILE_MAX_PATH);
}
if (rc != XN_STATUS_OK)
{
m_errorLogger.Append("The driver path gets too long");
return OniStatusFromXnStatus(rc);
}
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Using '%s' as driver path", strDriverPath);
rc = loadLibraries(strDriverPath);
if (rc == XN_STATUS_OK)
{
m_errorLogger.Clear();
}
return OniStatusFromXnStatus(rc);
}
OniStatus Context::initialize()
{
XnBool repositoryOverridden = FALSE;
XnChar repositoryFromINI[XN_FILE_MAX_PATH] = {0};
m_initializationCounter++;
if (m_initializationCounter > 1)
{
xnLogVerbose(XN_LOG_MASK_ALL, "Initialize: Already initialized");
return ONI_STATUS_OK;
}
XnStatus rc;
rc = m_newFrameAvailableEvent.Create(FALSE);
if (rc != XN_STATUS_OK)
{
m_errorLogger.Append("Couldn't create event for new frames: %s", xnGetStatusString(rc));
return ONI_STATUS_ERROR;
}
s_valid = TRUE;
// Read configuration file
XnBool configurationFileExists = FALSE;
rc = xnOSDoesFileExist(ONI_CONFIGURATION_FILE, &configurationFileExists);
if (configurationFileExists)
{
rc = xnOSReadStringFromINI(ONI_CONFIGURATION_FILE, "Device", "Override", m_overrideDevice, XN_FILE_MAX_PATH);
if (rc != XN_STATUS_OK)
{
xnLogVerbose(XN_LOG_MASK_ALL, "No override device in configuration file");
}
XnInt32 nValue;
rc = xnOSReadIntFromINI(ONI_CONFIGURATION_FILE, "Log", "Verbosity", &nValue);
if (rc == XN_STATUS_OK)
{
xnLogSetMaskMinSeverity(XN_LOG_MASK_ALL, (XnLogSeverity)nValue);
}
rc = xnOSReadIntFromINI(ONI_CONFIGURATION_FILE, "Log", "LogToConsole", &nValue);
if (rc == XN_STATUS_OK)
{
xnLogSetConsoleOutput(nValue == 1);
}
rc = xnOSReadIntFromINI(ONI_CONFIGURATION_FILE, "Log", "LogToFile", &nValue);
if (rc == XN_STATUS_OK)
{
xnLogSetFileOutput(nValue == 1);
}
rc = xnOSReadStringFromINI(ONI_CONFIGURATION_FILE, "Drivers", "Repository", repositoryFromINI, XN_FILE_MAX_PATH);
if (rc == XN_STATUS_OK)
{
repositoryOverridden = TRUE;
}
}
else
{
xnLogVerbose(XN_LOG_MASK_ALL, "Couldn't find configuration file '%s'", ONI_CONFIGURATION_FILE);
}
xnLogVerbose(XN_LOG_MASK_ALL, "OpenNI %s", ONI_VERSION_STRING);
// Use path specified in ini file
if (repositoryOverridden)
{
xnLogVerbose(XN_LOG_MASK_ALL, "Using '%s' as driver path, as configured in file '%s'", repositoryFromINI, ONI_CONFIGURATION_FILE);
rc = loadLibraries(repositoryFromINI);
return OniStatusFromXnStatus(rc);
}
xnLogVerbose(XN_LOG_MASK_ALL, "Using '%s' as driver path", ONI_DEFAULT_DRIVERS_REPOSITORY);
// Use default path
rc = loadLibraries(ONI_DEFAULT_DRIVERS_REPOSITORY);
if (rc != XN_STATUS_OK)
{
// Can't find through default - try environment variable
xnLogVerbose(XN_LOG_MASK_ALL, "Can't load drivers from default directory '%s'.", ONI_DEFAULT_DRIVERS_REPOSITORY);
char dirName[XN_FILE_MAX_PATH];
XnStatus envrc = xnOSGetEnvironmentVariable(ONI_ENV_VAR_DRIVERS_REPOSITORY, dirName, XN_FILE_MAX_PATH);
if (envrc == XN_STATUS_OK)
{
xnLogVerbose(XN_LOG_MASK_ALL, "Using '%s' as driver path, as configured by environment variable '%s'", dirName, ONI_ENV_VAR_DRIVERS_REPOSITORY);
rc = loadLibraries(dirName);
}
}
if (rc == XN_STATUS_OK)
{
m_errorLogger.Clear();
}
return OniStatusFromXnStatus(rc);
}
XnStatus XnSensorServer::InitServer()
{
XnStatus nRetVal = XN_STATUS_OK;
XnBool bEnableMultiUsers = FALSE;
XnUInt32 nValue;
if (XN_STATUS_OK == xnOSReadIntFromINI(m_strConfigFile, XN_SENSOR_SERVER_CONFIG_FILE_SECTION, XN_MODULE_PROPERTY_ENABLE_MULTI_USERS, &nValue))
{
bEnableMultiUsers = (nValue == TRUE);
}
nRetVal = xnOSCreateNamedMutexEx(&m_hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_NAME, bEnableMultiUsers);
XN_IS_STATUS_OK(nRetVal);
XnAutoMutexLocker serverRunningLock(m_hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_TIMEOUT);
nRetVal = serverRunningLock.GetStatus();
if (nRetVal != XN_STATUS_OK)
{
//This could mean there's another server/client that's frozen and they're jamming the mutex...
xnLogError(XN_MASK_SENSOR_SERVER, "Failed to lock server mutex: %s - exiting.", xnGetStatusString(nRetVal));
XN_ASSERT(FALSE);
return XN_STATUS_OS_MUTEX_TIMEOUT;
}
//From now on we're protected by m_hServerRunningMutex until we return from this function
/*Create the Server Running event.
This is created as a manual-reset event, because only the server resets it when it's shutting down. */
nRetVal = xnOSOpenNamedEventEx(&m_hServerRunningEvent, XN_SENSOR_SERVER_RUNNING_EVENT_NAME, bEnableMultiUsers);
if (nRetVal != XN_STATUS_OK)
{
nRetVal = xnOSCreateNamedEventEx(&m_hServerRunningEvent, XN_SENSOR_SERVER_RUNNING_EVENT_NAME, TRUE, bEnableMultiUsers);
XN_IS_STATUS_OK(nRetVal);
}
if (IsServerRunning())
{
//Another server is already running.
xnLogInfo(XN_MASK_SENSOR_SERVER, "Detected another server running - exiting.");
xnOSCloseEvent(&m_hServerRunningEvent);
m_hServerRunningEvent = NULL;
return XN_STATUS_DEVICE_SERVER_ALREADY_RUNNING;
}
nRetVal = m_sensorsManager.Init();
XN_IS_STATUS_OK(nRetVal);
// init network
nRetVal = xnOSInitNetwork();
XN_IS_STATUS_OK(nRetVal);
// create lock
nRetVal = xnOSCreateCriticalSection(&m_hSessionsLock);
XN_IS_STATUS_OK(nRetVal);
// create the listen socket
nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, XN_SENSOR_SERVER_IP_ADDRESS, XN_SENSOR_SERVER_PORT, &m_hListenSocket);
XN_IS_STATUS_OK(nRetVal);
// bind it
nRetVal = xnOSBindSocket(m_hListenSocket);
XN_IS_STATUS_OK(nRetVal);
// start listening
nRetVal = xnOSListenSocket(m_hListenSocket);
XN_IS_STATUS_OK(nRetVal);
xnLogVerbose(XN_MASK_SENSOR_SERVER, "Server is now listening");
/*Set the event to signal that the server is ready for requests. We do this AFTER we start listening so
the clients can wait on the event and then connect to the server socket. */
nRetVal = xnOSSetEvent(m_hServerRunningEvent);
XN_IS_STATUS_OK(nRetVal);
xnOSGetTimeStamp(&m_nLastSessionActivity);
return (XN_STATUS_OK);
}
