XnStatus XnServerSession::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = m_privateIncomingPacker.Init();
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_privateOutgoingPacker.Init();
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnStreamDataSetCreate(&m_pStreamDataSet);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hCommLock);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hStreamsLock);
XN_IS_STATUS_OK(nRetVal);
// start thread
nRetVal = xnOSCreateThread(ServeThreadCallback, this, &m_hThread);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnSchedulerStart(XnScheduler** ppScheduler)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_OUTPUT_PTR(ppScheduler);
*ppScheduler = NULL;
// allocate handle
XnScheduler* pScheduler = NULL;
XN_VALIDATE_CALLOC(pScheduler, XnScheduler, 1);
// create event
nRetVal = xnOSCreateEvent(&pScheduler->hWakeThreadEvent, FALSE);
XN_CHECK_RC_AND_FREE(nRetVal, pScheduler);
// create critical section
nRetVal = xnOSCreateCriticalSection(&pScheduler->hCriticalSection);
XN_CHECK_RC_AND_FREE(nRetVal, pScheduler);
// start thread
nRetVal = xnOSCreateThread(xnSchedulerThreadFunc, (XN_THREAD_PARAM)pScheduler, &pScheduler->hThread);
XN_CHECK_RC_AND_FREE(nRetVal, pScheduler);
*ppScheduler = pScheduler;
return (XN_STATUS_OK);
}
XnStatus xnUSBPlatformSpecificInit()
{
xnLogVerbose(XN_MASK_USB, "Initializing USB...");
// initialize the library
int rc = libusb_init(&g_InitData.pContext);
if (rc != 0)
{
return (XN_STATUS_USB_INIT_FAILED);
}
XnStatus nRetVal = xnOSCreateCriticalSection(&g_InitData.hLock);
XN_IS_STATUS_OK(nRetVal);
#ifdef XN_USE_UDEV
// initialize the UDEV Events thread
g_bShouldRunUDEVThread = true;
nRetVal = xnOSCreateThread(xnUSBUDEVEventsThread, NULL, &g_hUDEVThread);
if (nRetVal != XN_STATUS_OK)
{
g_hUDEVThread = NULL;
g_bShouldRunUDEVThread = false;
// clean-up
xnUSBPlatformSpecificShutdown();
return nRetVal;
}
#endif
//libusb_set_debug(g_InitData.pContext, 3);
xnLogInfo(XN_MASK_USB, "USB is initialized.");
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnStatus XnDeviceSensorInit(XnDevicePrivateData* pDevicePrivateData)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = XnDeviceSensorAllocateBuffers(pDevicePrivateData);
XN_IS_STATUS_OK(nRetVal);
#if XN_PLATFORM == XN_PLATFORM_ANDROID_ARM
nRetVal = xnOSCreateMutex(&pDevicePrivateData->hExecuteMutex);
XN_IS_STATUS_OK(nRetVal);
#else
XnChar strMutexName[XN_FILE_MAX_PATH];
XnUInt32 nCharsWritten = 0;
nRetVal = xnOSStrFormat(strMutexName, XN_FILE_MAX_PATH, &nCharsWritten, "%s%s", XN_HOST_PROTOCOL_MUTEX_NAME_PREFIX, pDevicePrivateData->pSensor->GetUSBPath());
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateNamedMutex(&pDevicePrivateData->hExecuteMutex, strMutexName);
XN_IS_STATUS_OK(nRetVal);
#endif
nRetVal = XnDeviceSensorConfigureVersion(pDevicePrivateData);
XN_IS_STATUS_OK(nRetVal);
BayerUpdateGamma(1.0);
nRetVal = xnOSCreateCriticalSection(&pDevicePrivateData->hAudioBufferCriticalSection);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnProfilingInit(XnUInt32 nProfilingInterval)
{
XnStatus nRetVal = XN_STATUS_OK;
if (nProfilingInterval == 0)
{
xnProfilingShutdown();
}
else if (!g_ProfilingData.bInitialized)
{
g_ProfilingData.nMaxSectionName = 0;
g_ProfilingData.nSectionCount = 0;
g_ProfilingData.nProfilingInterval = nProfilingInterval;
g_ProfilingData.bKillThread = FALSE;
XN_VALIDATE_CALLOC(g_ProfilingData.aSections, XnProfiledSection, MAX_PROFILED_SECTIONS);
g_ProfilingData.nSectionCount = 0;
nRetVal = xnOSCreateThread(xnProfilingThread, (XN_THREAD_PARAM)NULL, &g_ProfilingData.hThread);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&g_ProfilingData.hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
g_ProfilingData.bInitialized = TRUE;
}
return XN_STATUS_OK;
}
XnNodeManager::XnNodeManager()
{
xnOSCreateCriticalSection(&m_hCriticalSection);
//TODO: Handle critical section creation failure
m_nCurrentAvailability = 0;
m_nCurrentCapacity = 0;
m_nCurrentOccupancy = 0;
m_pFirstAvailable = NULL;
m_eInitializationState = XN_NM_INIT_STATE_CREATE_INTERNAL_LIST;
m_pAllNodes = XN_NEW(XnList, this);
if (m_pAllNodes == NULL)
{
// OZOZ: Allocation failed in ctor...
}
m_eInitializationState = XN_NM_INIT_STATE_CREATE_FIRST_LINK;
XnStatus rc = Resize(nInitialSize);
if (rc != XN_STATUS_OK)
{
// OZOZ: Allocation failed in ctor...
}
m_eInitializationState = XN_NM_INIT_STATE_DONE;
}
XnVMessageListener::XnVMessageListener(const XnChar* strName) :
m_bInternalThreadAlive(false),
m_bInternalThreadKill(false),
m_bThreadProtectionQueueMode(false)
{
xnLogVerbose(XNV_NITE_MASK_CREATE, "Listener %s [0x%08x]: Create", strName, this);
xnOSCreateCriticalSection(&m_hListenerCS);
SetCurrentThread();
m_bThreadProtectionQueueMode = false;
m_strListenerName = (XnChar*)xnOSCalloc(strlen(strName)+1, sizeof(XnChar));
if (m_strListenerName != NULL)
{
xnOSStrCopy(m_strListenerName, strName, strlen(strName)+1);
}
m_pMessageQueue = XN_NEW(XnVMessageQueue);
m_pMessageQueue->Init();
m_pUpdateCBs = XN_NEW(XnVMessageSpecificEvent);
m_pActivateCBs = XN_NEW(XnVEvent);
m_pDeactivateCBs = XN_NEW(XnVEvent);
} // XnVMessageListener::XnVMessageListener
XnStatus XnServerSensorInvoker::Init(const XnChar* strDevicePath, const XnChar* strGlobalConfigFile, XnUInt32 nAdditionalProps, XnProperty** aAdditionalProps)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = m_sensor.SetGlobalConfigFile(strGlobalConfigFile);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hSensorLock);
XN_IS_STATUS_OK(nRetVal);
XnDeviceConfig config;
config.DeviceMode = XN_DEVICE_MODE_READ;
config.cpConnectionString = strDevicePath;
config.pInitialValues = NULL;
config.SharingMode = XN_DEVICE_SHARED;
nRetVal = m_sensor.Init(&config);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_sensor.DeviceModule()->AddProperties(aAdditionalProps, nAdditionalProps);
XN_IS_STATUS_OK(nRetVal);
XnProperty* aInvokerAdditionalProps[] = { &m_numberOfBuffers, &m_allowOtherUsers };
nRetVal = m_sensor.DeviceModule()->AddProperties(aInvokerAdditionalProps, sizeof(aInvokerAdditionalProps) / sizeof(aInvokerAdditionalProps[0]));
XN_IS_STATUS_OK(nRetVal);
// configure from global file
nRetVal = m_sensor.ConfigureModuleFromGlobalFile(XN_MODULE_NAME_DEVICE, XN_SENSOR_SERVER_CONFIG_FILE_SECTION);
XN_IS_STATUS_OK(nRetVal);
// register to events
XnCallbackHandle hDummy = NULL;
nRetVal = m_sensor.OnStreamCollectionChangedEvent().Register(StreamCollectionChangedCallback, this, hDummy);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_sensor.OnNewStreamDataEvent().Register(NewStreamDataCallback, this, hDummy);
XN_IS_STATUS_OK(nRetVal);
// register to all properties
XN_PROPERTY_SET_CREATE_ON_STACK(props);
nRetVal = m_sensor.DeviceModule()->GetAllProperties(&props);
XN_IS_STATUS_OK(nRetVal);
nRetVal = RegisterToProps(&props);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateEvent(&m_hNewDataEvent, FALSE);
XN_IS_STATUS_OK(nRetVal);
// start reader thread
nRetVal = xnOSCreateThread(ReaderThread, this, &m_hReaderThread);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceModule::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = AddProperty(&m_Lock);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hLockCS);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnSensorsManager::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = xnOSCreateCriticalSection(&m_hLock);
XN_IS_STATUS_OK(nRetVal);
// read default timeout from file
nRetVal = m_noClientTimeout.ReadValueFromFile(m_strGlobalConfigFile, XN_SENSOR_SERVER_CONFIG_FILE_SECTION);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
LinkContInputStream::LinkContInputStream()
{
m_bInitialized = FALSE;
m_bStreaming = FALSE;
m_bNewDataAvailable = FALSE;
m_hCriticalSection = NULL;
m_nUserBufferMaxSize = 0;
m_pUserBuffer = NULL;
m_nUserBufferCurrentSize = 0;
xnOSCreateCriticalSection(&m_hCriticalSection);
m_pDumpFile = NULL;
xnOSMemSet(m_strDumpName, 0, sizeof(m_strDumpName));
}
XnStatus XnFrameBufferManager::Init(XnUInt32 nBufferSize)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = xnOSCreateCriticalSection(&m_hLock);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_pBufferPool->Init(nBufferSize);
XN_IS_STATUS_OK(nRetVal);
nRetVal = Reallocate(nBufferSize);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnBufferPool::Init(XnUInt32 nBufferSize)
{
XnStatus nRetVal = XN_STATUS_OK;
xnDumpInit(&m_dump, "BufferPool", "", "bufferpool_%x.txt", this);
nRetVal = xnOSCreateCriticalSection(&m_hLock);
XN_IS_STATUS_OK(nRetVal);
// allocate buffers
nRetVal = ChangeBufferSize(nBufferSize);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus xnUSBPlatformSpecificInit()
{
xnLogVerbose(XN_MASK_USB, "Initializing USB...");
// initialize the library
int rc = libusb_init(&g_InitData.pContext);
if (rc != 0)
{
return (XN_STATUS_USB_INIT_FAILED);
}
XnStatus nRetVal = xnOSCreateCriticalSection(&g_InitData.hLock);
XN_IS_STATUS_OK(nRetVal);
//libusb_set_debug(g_InitData.pContext, 3);
xnLogInfo(XN_MASK_USB, "USB is initialized.");
return (XN_STATUS_OK);
}
XnStatus XnSensor::InitReading()
{
XnStatus nRetVal = XN_STATUS_OK;
// open data endpoints
nRetVal = m_SensorIO.OpenDataEndPoints((XnSensorUsbInterface)m_Interface.GetValue(), *m_Firmware.GetInfo());
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Interface.UnsafeUpdateValue(m_SensorIO.GetCurrentInterface());
XN_IS_STATUS_OK(nRetVal);
// take frequency information
XnFrequencyInformation FrequencyInformation;
nRetVal = XnHostProtocolAlgorithmParams(&m_DevicePrivateData, XN_HOST_PROTOCOL_ALGORITHM_FREQUENCY, &FrequencyInformation, sizeof(XnFrequencyInformation), (XnResolutions)0, 0);
if (nRetVal != XN_STATUS_OK)
return nRetVal;
m_DevicePrivateData.fDeviceFrequency = XN_PREPARE_VAR_FLOAT_IN_BUFFER(FrequencyInformation.fDeviceFrequency);
// Init Dumps
m_DevicePrivateData.BandwidthDump = xnDumpFileOpen(XN_DUMP_BANDWIDTH, "Bandwidth.csv");
xnDumpFileWriteString(m_DevicePrivateData.BandwidthDump, "Timestamp,Frame Type,Frame ID,Size\n");
m_DevicePrivateData.TimestampsDump = xnDumpFileOpen(XN_DUMP_TIMESTAMPS, "Timestamps.csv");
xnDumpFileWriteString(m_DevicePrivateData.TimestampsDump, "Host Time (us),Stream,Device TS,Time (ms),Comments\n");
m_DevicePrivateData.MiniPacketsDump = xnDumpFileOpen(XN_DUMP_MINI_PACKETS, "MiniPackets.csv");
xnDumpFileWriteString(m_DevicePrivateData.MiniPacketsDump, "HostTS,Type,ID,Size,Timestamp\n");
m_DevicePrivateData.nGlobalReferenceTS = 0;
nRetVal = xnOSCreateCriticalSection(&m_DevicePrivateData.hEndPointsCS);
XN_IS_STATUS_OK(nRetVal);
// NOTE: when we go up, some streams might be open, and so we'll receive lots of garbage.
// wait till streams are turned off, and then start reading.
// pDevicePrivateData->bIgnoreDataPackets = TRUE;
// open input threads
nRetVal = XnDeviceSensorOpenInputThreads(GetDevicePrivateData(), (XnBool)m_ReadFromEP1.GetValue(), (XnBool)m_ReadFromEP2.GetValue(), (XnBool)m_ReadFromEP3.GetValue());
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
XN_C_API XnStatus xnProfilingSectionStart(const char* csSectionName, XnBool bMT, XnProfilingHandle* pHandle)
{
if (!g_ProfilingData.bInitialized)
return XN_STATUS_OK;
if (*pHandle == INVALID_PROFILING_HANDLE)
{
xnOSEnterCriticalSection(&g_ProfilingData.hCriticalSection);
if (*pHandle == INVALID_PROFILING_HANDLE)
{
XnUInt32 nIndex = g_ProfilingData.nSectionCount;
g_ProfilingData.nSectionCount++;
XnProfiledSection* pSection = &g_ProfilingData.aSections[nIndex];
pSection->nIndentation = gt_nStackDepth;
XnUInt32 nChar = 0;
for (nChar = 0; nChar < gt_nStackDepth*2; ++nChar)
pSection->csName[nChar] = ' ';
strncpy(pSection->csName + nChar, csSectionName, MAX_SECTION_NAME);
if (strlen(pSection->csName) > g_ProfilingData.nMaxSectionName)
g_ProfilingData.nMaxSectionName = strlen(pSection->csName);
if (bMT)
{
pSection->bMultiThreaded = TRUE;
xnOSCreateCriticalSection(&pSection->hLock);
}
*pHandle = nIndex;
}
xnOSLeaveCriticalSection(&g_ProfilingData.hCriticalSection);
}
gt_nStackDepth++;
XnProfiledSection* pSection = &g_ProfilingData.aSections[*pHandle];
xnOSGetHighResTimeStamp(&pSection->nCurrStartTime);
return XN_STATUS_OK;
}
LogData()
{
// NOTE: as our log implementation returns a pointer directly into this hash, we can't
// free this memory in our dtor (static objects dtors are called in unknown order. modules
// might still access this memory after our dtor is called).
// As in any case, this is a static object which will only be destroyed when the process goes
// down - we can allow this.
this->pMasksHash = XN_NEW(XnLogMasksHash);
XN_ASSERT(this->pMasksHash != NULL);
// We need a critical section to guard the writers list - it is accessed with every log entry written
// and also by the application (mainly, when calling xnStartNewLogFile()).
XnStatus nRetVal = xnOSCreateCriticalSection(&this->hLock);
XN_ASSERT(nRetVal == XN_STATUS_OK);
XN_REFERENCE_VARIABLE(nRetVal);
this->anyWriters = FALSE;
Reset();
}
XnStatus XnFrameBufferManager::Init(XnUInt32 nBufferSize)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_NEW(m_pBufferPool, XnOniFramePool);
m_pBufferPool->SetFrameSize(nBufferSize);
int numFrames = 6; // user, synced frame holder (last+synced), XnSensor frame-sync(last+incoming), working
if (!m_pBufferPool->Initialize(numFrames))
{
return XN_STATUS_ALLOC_FAILED;
}
nRetVal = xnOSCreateCriticalSection(&m_hLock);
XN_IS_STATUS_OK(nRetVal);
nRetVal = Reallocate(nBufferSize);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::Init(const XnDeviceConfig* pDeviceConfig)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = xnOSCreateCriticalSection(&m_hLock);
XN_IS_STATUS_OK(nRetVal);
// first init the device
nRetVal = InitImpl(pDeviceConfig);
XN_IS_STATUS_OK(nRetVal);
// and now create streams
if (pDeviceConfig->pInitialValues != NULL)
{
nRetVal = CreateStreams(pDeviceConfig->pInitialValues);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnDeviceStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init module
nRetVal = XnDeviceModule::Init();
XN_IS_STATUS_OK(nRetVal);
// cs
nRetVal = xnOSCreateCriticalSection(&m_hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
m_IsOpen.UpdateSetCallback(SetIsOpenCallback, this);
m_OutputFormat.UpdateSetCallback(SetOutputFormatCallback, this);
m_IsMirrored.UpdateSetCallback(SetIsMirrorCallback, this);
XN_VALIDATE_ADD_PROPERTIES(this, &m_IsStream, &m_Type, &m_IsOpen, &m_OutputFormat, &m_RequiredSize, &m_IsMirrored);
return (XN_STATUS_OK);
}
XnStatus XnSensorAudioStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnAudioStream::Init();
XN_IS_STATUS_OK(nRetVal);
// init helper
nRetVal = m_Helper.Init(this, this);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_buffer.hLock);
XN_IS_STATUS_OK(nRetVal);
nRetVal = SetReadChunkSize(XN_AUDIO_STREAM_DEFAULT_CHUNK_SIZE);
XN_IS_STATUS_OK(nRetVal);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_LeftChannelVolume, &m_RightChannelVolume, &m_ActualRead);
// check what's the firmware audio packet size
if (m_Helper.GetPrivateData()->SensorHandle.MiscConnection.bIsISO)
m_nOrigAudioPacketSize = XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_ISO;
else
m_nOrigAudioPacketSize = XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_BULK;
// alloc buffer
nRetVal = ReallocBuffer();
XN_IS_STATUS_OK(nRetVal);
m_buffer.pAudioCallback = NewDataCallback;
m_buffer.pAudioCallbackCookie = this;
// data processor
nRetVal = m_Helper.RegisterDataProcessorProperty(NumberOfChannelsProperty());
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
TypeManager::TypeManager()
{
xnOSCreateCriticalSection(&m_hLock);
// create built-in types inheritance graph
NodeTypeInfo productionNodeInfo("ProductionNode", XN_NODE_TYPE_PRODUCTION_NODE);
AddType(productionNodeInfo);
// Production Nodes
AddNewType("Device", XN_NODE_TYPE_DEVICE, XN_NODE_TYPE_PRODUCTION_NODE);
AddNewType("Recorder", XN_NODE_TYPE_RECORDER, XN_NODE_TYPE_PRODUCTION_NODE);
AddNewType("Player", XN_NODE_TYPE_PLAYER, XN_NODE_TYPE_PRODUCTION_NODE);
AddNewType("Codec", XN_NODE_TYPE_CODEC, XN_NODE_TYPE_PRODUCTION_NODE);
AddNewType("Script", XN_NODE_TYPE_SCRIPT, XN_NODE_TYPE_PRODUCTION_NODE);
AddNewType("Generator", XN_NODE_TYPE_GENERATOR, XN_NODE_TYPE_PRODUCTION_NODE);
// Generators
AddNewType("User", XN_NODE_TYPE_USER, XN_NODE_TYPE_GENERATOR);
AddNewType("Hands", XN_NODE_TYPE_HANDS, XN_NODE_TYPE_GENERATOR);
AddNewType("Gesture", XN_NODE_TYPE_GESTURE, XN_NODE_TYPE_GENERATOR);
AddNewType("Audio", XN_NODE_TYPE_AUDIO, XN_NODE_TYPE_GENERATOR);
AddNewType("MapGenerator", XN_NODE_TYPE_MAP_GENERATOR, XN_NODE_TYPE_GENERATOR);
// Map Generators
AddNewType("Depth", XN_NODE_TYPE_DEPTH, XN_NODE_TYPE_MAP_GENERATOR);
AddNewType("Image", XN_NODE_TYPE_IMAGE, XN_NODE_TYPE_MAP_GENERATOR);
AddNewType("IR", XN_NODE_TYPE_IR, XN_NODE_TYPE_MAP_GENERATOR);
AddNewType("Scene", XN_NODE_TYPE_SCENE, XN_NODE_TYPE_MAP_GENERATOR);
m_nNextExtendedNodeType = XN_NODE_TYPE_FIRST_EXTENSION;
// make sure all types are registered
for (XnInt32 i = 1; i < m_nNextExtendedNodeType; ++i)
{
XN_ASSERT(m_pTypesArray[i] != NULL);
}
}
XnStatus XnSensorClient::InitImpl(const XnDeviceConfig* pDeviceConfig)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_MUTEX_HANDLE hServerRunningMutex = NULL;
XnOSEvent serverRunningEvent;
nRetVal = serverRunningEvent.Open(XN_SENSOR_SERVER_RUNNING_EVENT_NAME);
if (nRetVal != XN_STATUS_OK)
{
nRetVal = serverRunningEvent.Create(XN_SENSOR_SERVER_RUNNING_EVENT_NAME, TRUE);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Failed to create server running event: %s", xnGetStatusString(nRetVal));
return nRetVal;
}
}
nRetVal = xnOSCreateNamedMutex(&hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_NAME);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSLockMutex(hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_TIMEOUT);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseMutex(&hServerRunningMutex);
return nRetVal;
}
XnBool bServerRunning = (serverRunningEvent.Wait(1) == XN_STATUS_OK);
nRetVal = xnOSUnLockMutex(hServerRunningMutex);
xnOSCloseMutex(&hServerRunningMutex);
XN_IS_STATUS_OK(nRetVal);
if (!bServerRunning)
{
nRetVal = StartServerProcess();
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Failed to start server process: %s", xnGetStatusString(nRetVal));
return nRetVal;
}
}
nRetVal = serverRunningEvent.Wait(XN_SENSOR_CLIENT_WAIT_FOR_SERVER);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Failed to wait for server to start: %s", xnGetStatusString(nRetVal));
return nRetVal;
}
// init network
nRetVal = xnOSInitNetwork();
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hLock);
XN_IS_STATUS_OK(nRetVal);
// now init
nRetVal = XnStreamReaderDevice::InitImpl(pDeviceConfig);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseCriticalSection(&m_hLock);
return nRetVal;
}
m_bConnected = TRUE;
nRetVal = xnOSCreateEvent(&m_hReplyEvent, FALSE);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseCriticalSection(&m_hLock);
return nRetVal;
}
nRetVal = xnOSCreateThread(ListenThread, this, &m_hListenThread);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseEvent(&m_hReplyEvent);
xnOSCloseCriticalSection(&m_hLock);
return nRetVal;
}
return (XN_STATUS_OK);
}
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);
}
XN_C_API void* xnOSLogMemAlloc(void* pMemBlock, XnAllocationType nAllocType, XnUInt32 nBytes, const XnChar* csFunction, const XnChar* csFile, XnUInt32 nLine, const XnChar* csAdditional)
{
static XnBool bFirstTime = TRUE;
static XnBool bReentrent = FALSE;
if (bFirstTime)
{
bFirstTime = FALSE;
printf("************************************************************\n");
printf("** WARNING: Memory Profiling is on! **\n");
printf("************************************************************\n");
bReentrent = TRUE;
xnOSCreateCriticalSection(&g_hCS);
#ifdef XN_MEMORY_PROFILING_DUMP
xnDumpSetMaskState("MemProf", TRUE);
#endif
g_dump = xnDumpFileOpen("MemProf", "MemProfiling.log");
xnDumpFileWriteString(g_dump, "Entry,Address,AllocType,Bytes,Function,File,Line,AdditionalInfo\n");
bReentrent = FALSE;
}
// ignore stuff that is being allocated during "first time"
if (bReentrent)
{
return pMemBlock;
}
XnMemBlockDataNode* pNode;
pNode = (XnMemBlockDataNode*)xnOSMalloc(sizeof(XnMemBlockDataNode));
pNode->Data.pMemBlock = pMemBlock;
pNode->Data.nAllocType = nAllocType;
pNode->Data.nBytes = nBytes;
pNode->Data.csFunction = csFunction;
pNode->Data.csFile = csFile;
pNode->Data.nLine = nLine;
pNode->Data.csAdditional = csAdditional;
pNode->Data.nFrames = XN_MEM_PROF_MAX_FRAMES;
xnDumpFileWriteString(g_dump, "Alloc,0x%x,%s,%u,%s,%s,%u,%s\n", pMemBlock, XnGetAllocTypeString(nAllocType), nBytes, csFunction, csFile, nLine, csAdditional);
// try to get call stack (skip 2 frames - this one and the alloc func)
XnChar* pstrFrames[XN_MEM_PROF_MAX_FRAMES];
for (XnUInt32 i = 0; i < XN_MEM_PROF_MAX_FRAMES; ++i)
{
pstrFrames[i] = pNode->Data.aFrames[i];
}
if (XN_STATUS_OK != xnOSGetCurrentCallStack(2, pstrFrames, XN_MEM_PROF_MAX_FRAME_LEN, &pNode->Data.nFrames))
{
pNode->Data.nFrames = 0;
}
pNode->pNext = NULL;
XnAutoCSLocker lock(g_hCS);
if (g_allocatedMemory.pLast == NULL)
{
g_allocatedMemory.pFirst = g_allocatedMemory.pLast = pNode;
}
else
{
g_allocatedMemory.pLast->pNext = pNode;
g_allocatedMemory.pLast = pNode;
}
return pMemBlock;
}
