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); }