// Stream
VideoStream::~VideoStream()
{
// Make sure stream is stopped.
stop();
m_device.clearStream(this);
// Detach all recorders from this stream.
xnl::LockGuard< Recorders > guard(m_recorders);
while (m_recorders.Begin() != m_recorders.End())
{
// NOTE: DetachStream has a side effect of modifying m_recorders.
m_recorders.Begin()->Value()->detachStream(*this);
}
// Try to close the thread properly, and forcibly terminate it if failed/timedout.
m_running = false;
xnOSSetEvent(m_newFrameInternalEvent);
xnOSSetEvent(m_newFrameInternalEventForFrameHolder);
XnStatus rc = xnOSWaitForThreadExit(m_newFrameThread, STREAM_DESTROY_THREAD_TIMEOUT);
if (rc != XN_STATUS_OK)
{
xnOSTerminateThread(&m_newFrameThread);
}
m_pFrameHolder->setStreamEnabled(this, FALSE);
m_driverHandler.deviceDestroyStream(m_device.getHandle(), m_streamHandle);
xnOSCloseEvent(&m_newFrameInternalEvent);
xnOSCloseEvent(&m_newFrameInternalEventForFrameHolder);
XN_DELETE_ARR(m_pSensorInfo->pSupportedVideoModes);
XN_DELETE(m_pSensorInfo);
}
//---------------------------------------------------------------------------
// Helper Functions
//---------------------------------------------------------------------------
XnStatus xnUSBInitOvlp(XN_USB_EP_HANDLE pEPHandle)
{
XnStatus nRetVal = XN_STATUS_OK;
if (pEPHandle->hEPHandleOvlp != NULL)
{
CloseHandle(pEPHandle->hEPHandleOvlp);
}
if (pEPHandle->ovlpIO.hEvent != NULL)
{
xnOSCloseEvent(&pEPHandle->ovlpIO.hEvent);
}
// Open the overlapped pipe handle
pEPHandle->hEPHandleOvlp = CreateFile(pEPHandle->cpPipeName, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
if (pEPHandle->hEPHandleOvlp == INVALID_HANDLE_VALUE)
{
return (XN_STATUS_ERROR);
}
// Init the overlapped variables
xnOSMemSet(&pEPHandle->ovlpIO, 0, sizeof(OVERLAPPED));
nRetVal = xnOSCreateEvent(&pEPHandle->ovlpIO.hEvent, FALSE);
if (nRetVal != XN_STATUS_OK)
{
return (XN_STATUS_ERROR);
}
return (XN_STATUS_OK);
}
void XnServerSensorInvoker::Free()
{
m_bShouldRun = FALSE;
if (m_hReaderThread != NULL)
{
xnOSWaitAndTerminateThread(&m_hReaderThread, XN_SENSOR_TERMINATE_READER_THREAD_TIMEOUT);
m_hReaderThread = NULL;
}
XnStatus nRetVal = m_sensor.Destroy();
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_SENSOR_SERVER, "Failed to destroy sensor: %s", xnGetStatusString(nRetVal));
XN_ASSERT(FALSE);
}
if (m_hNewDataEvent != NULL)
{
xnOSCloseEvent(&m_hNewDataEvent);
m_hNewDataEvent = NULL;
}
if (m_hSensorLock != NULL)
{
xnOSCloseCriticalSection(&m_hSensorLock);
m_hSensorLock = NULL;
}
}
void SocketInConnection::Shutdown()
{
xnLogVerbose(XN_MASK_LINK, "Socket in connection %u shutting down", m_nPort);
Disconnect();
xnOSFreeAligned(m_pBuffer);
m_pBuffer = NULL;
xnOSCloseEvent(&m_hConnectEvent);
}
XnStatus XnSensorClient::Destroy()
{
XnStatus nRetVal = XN_STATUS_OK;
if (m_hSocket != NULL)
{
nRetVal = SendBye();
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_SENSOR_CLIENT, "Failed to send BYE to the server - %s", xnGetStatusString(nRetVal));
//But we keep going - we must destroy our object.
}
//Signal to the listener thread that it should stop running
m_bShouldRun = FALSE;
m_bConnected = FALSE;
}
if (m_hListenThread != NULL)
{
xnOSWaitAndTerminateThread(&m_hListenThread, XN_SENSOR_CLIENT_TERMINATE_THREAD_TIMEOUT);
m_hListenThread = NULL;
}
// now destroy it all
XnStreamReaderDevice::Destroy();
if (m_hReplyEvent != NULL)
{
xnOSCloseEvent(&m_hReplyEvent);
m_hReplyEvent = NULL;
}
XN_DELETE(m_pOutgoingPacker);
if (m_hLock != NULL)
{
xnOSCloseCriticalSection(&m_hLock);
m_hLock = NULL;
}
return XN_STATUS_OK;
}
void XnSensorServer::Free()
{
if (m_hServerRunningEvent != NULL)
{
xnOSCloseEvent(&m_hServerRunningEvent);
m_hServerRunningEvent = NULL;
}
if (m_hListenSocket != NULL)
{
xnOSCloseSocket(m_hListenSocket);
m_hListenSocket = NULL;
}
if (m_hSessionsLock != NULL)
{
xnOSCloseCriticalSection(&m_hSessionsLock);
m_hSessionsLock = NULL;
}
}
void XnSensorServer::ShutdownServer()
{
XnStatus nRetVal = XN_STATUS_OK;
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...
xnLogWarning(XN_MASK_SENSOR_SERVER, "Failed to lock server mutex: %s - proceeding with shutdown.", xnGetStatusString(nRetVal));
XN_ASSERT(FALSE);
}
if (m_hServerRunningEvent != NULL)
{
nRetVal = xnOSResetEvent(m_hServerRunningEvent);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_SENSOR_SERVER, "Failed to reset sensor server event: %s - proceeding with shutdown.", xnGetStatusString(nRetVal));
XN_ASSERT(FALSE);
}
xnOSCloseEvent(&m_hServerRunningEvent);
m_hServerRunningEvent = NULL;
}
XN_ASSERT(m_sessions.IsEmpty());
if (m_hListenSocket != NULL)
{
xnOSCloseSocket(m_hListenSocket);
m_hListenSocket = NULL;
}
if (m_hSessionsLock != NULL)
{
xnOSCloseCriticalSection(&m_hSessionsLock);
m_hSessionsLock = NULL;
}
}
void FreeScheduler(XnScheduler* pScheduler)
{
// stop thread
if (pScheduler->hThread)
{
// mark for thread to stop
pScheduler->bStopThread = TRUE;
if (pScheduler->hWakeThreadEvent)
{
xnOSSetEvent(pScheduler->hWakeThreadEvent);
}
// now wait for it to exit
xnLogVerbose(XN_MASK_SCHEDULER, "Shutting down Scheduler thread...");
xnOSWaitAndTerminateThread(&pScheduler->hThread, XN_SCHEDULER_WAIT_THREAD_EXIT_TIMEOUT);
}
if (pScheduler->hWakeThreadEvent)
{
xnOSCloseEvent(&pScheduler->hWakeThreadEvent);
}
if (pScheduler->hCriticalSection)
{
xnOSCloseCriticalSection(&pScheduler->hCriticalSection);
}
while (pScheduler->pFirst != NULL)
{
XnScheduledTask* pTask = pScheduler->pFirst;
pScheduler->pFirst = pTask->pNextTask;
xnOSFree(pTask);
}
xnOSFree(pScheduler);
}
XnStatus XnDeviceBase::Destroy()
{
XnStatus nRetVal = XN_STATUS_OK;
// free all modules
while (m_Modules.Size() != 0)
{
XnDeviceModuleHolder* pModuleHolder = (XnDeviceModuleHolder*)m_Modules.begin().Value();
if (IsStream(pModuleHolder->GetModule()))
{
XnChar strName[XN_DEVICE_MAX_STRING_LENGTH];
strcpy(strName, pModuleHolder->GetModule()->GetName());
nRetVal = DestroyStream(strName);
XN_IS_STATUS_OK(nRetVal);
}
else
{
// free memory of registered properties to this module
FreeModuleRegisteredProperties(m_Modules.begin().Key());
pModuleHolder->GetModule()->Free();
DestroyModule(pModuleHolder);
m_Modules.Remove(m_Modules.begin());
}
}
m_pDevicePropertiesHolder = NULL;
m_Modules.Clear();
// close event
xnOSCloseEvent(&m_hNewDataEvent);
// close dump
xnDumpFileClose(m_StreamsDataDump);
return XN_STATUS_OK;
}
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);
}