// 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);
}
void VideoStream::raiseNewFrameEvent()
{
xnOSSetEvent(m_newFrameInternalEvent);
xnOSSetEvent(m_newFrameInternalEventForFrameHolder);
if (m_pContextNewFrameEvent != NULL)
{
m_pContextNewFrameEvent->Set();
}
}
XN_C_API XnStatus xnSchedulerRemoveTask(XnScheduler* pScheduler, XnScheduledTask** ppTask)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pScheduler);
XN_VALIDATE_INPUT_PTR(ppTask);
XN_VALIDATE_INPUT_PTR(*ppTask);
XnScheduledTask* pTask = *ppTask;
// enter critical section
nRetVal = xnOSEnterCriticalSection(&pScheduler->hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
XnSchedulerRemoveTaskInternal(pScheduler, pTask);
// leave critical section
nRetVal = xnOSLeaveCriticalSection(&pScheduler->hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
// notify that the list has changed
nRetVal = xnOSSetEvent(pScheduler->hWakeThreadEvent);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_SCHEDULER, "Failed setting event when removing task: %s", xnGetStatusString(nRetVal));
}
xnOSFree(pTask);
*ppTask = NULL;
return (XN_STATUS_OK);
}
void XnDeviceBase::OnNewStreamData(XnDeviceStream* pStream, XnUInt64 nTimestamp, XnUInt32 nFrameID)
{
XnUInt64 nNow;
xnOSGetHighResTimeStamp(&nNow);
xnDumpFileWriteString(m_StreamsDataDump, "%llu,%s,%llu,%u\n", nNow, pStream->GetName(), nTimestamp, nFrameID);
if (strcmp(m_PrimaryStream.GetValue(), XN_PRIMARY_STREAM_ANY) == 0 ||
strcmp(m_PrimaryStream.GetValue(), XN_PRIMARY_STREAM_NONE) == 0)
{
// any stream makes us advance
m_nLastTimestamp = XN_MAX(m_nLastTimestamp, nTimestamp);
m_nLastFrameID = XN_MAX(m_nLastFrameID, nFrameID);
}
else if (strcmp(m_PrimaryStream.GetValue(), pStream->GetName()) == 0) // this stream is the primary
{
m_nLastTimestamp = nTimestamp;
m_nLastFrameID = nFrameID;
}
XnStatus nRetVal = xnOSSetEvent(m_hNewDataEvent);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_DDK, "Failed setting the new data event: %s", xnGetStatusString(nRetVal));
}
RaiseNewStreamDataEvent(pStream->GetName());
}
void Context::onNewFrame()
{
m_cs.Lock();
for (xnl::Hash<XN_THREAD_ID, XN_EVENT_HANDLE>::Iterator it = m_waitingThreads.Begin(); it != m_waitingThreads.End(); ++it)
{
xnOSSetEvent(it->Value());
}
m_cs.Unlock();
}
XN_C_API XnStatus xnSchedulerAddTask(XnScheduler* pScheduler, XnUInt64 nInterval, XnTaskCallbackFuncPtr pCallback, void* pCallbackArg, XnScheduledTask** ppTask)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pScheduler);
XN_VALIDATE_INPUT_PTR(pCallback);
XN_VALIDATE_OUTPUT_PTR(ppTask);
// create node
XnScheduledTask* pTask;
XN_VALIDATE_ALLOC(pTask, XnScheduledTask);
pTask->nInterval = nInterval;
pTask->pCallback = pCallback;
pTask->pCallbackArg = pCallbackArg;
// calculate next execution
XnUInt64 nNow;
xnOSGetTimeStamp(&nNow);
pTask->nNextTime = nNow + nInterval;
pTask->pNextTask = NULL;
// enter critical section
nRetVal = xnOSEnterCriticalSection(&pScheduler->hCriticalSection);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(pTask);
return (nRetVal);
}
xnSchedulerAddTaskInternal(pScheduler, pTask);
// leave critical section
nRetVal = xnOSLeaveCriticalSection(&pScheduler->hCriticalSection);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(pTask);
return (nRetVal);
}
// notify that the list has changed
nRetVal = xnOSSetEvent(pScheduler->hWakeThreadEvent);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_SCHEDULER, "Failed setting event when adding task: %s", xnGetStatusString(nRetVal));
}
*ppTask = pTask;
return (XN_STATUS_OK);
}
XnStatus XnSensorClient::HandlePackedObject(XnPackedDataType nObjectType)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nDataSize = sizeof(m_LastReply);
switch (nObjectType)
{
case XN_SENSOR_SERVER_MESSAGE_GENERAL_OP_RESPOND:
case XN_SENSOR_SERVER_MESSAGE_GET_INT_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_GET_REAL_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_GET_STRING_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_GET_GENERAL_PROPERTY:
case XN_SENSOR_SERVER_MESSAGE_READ_STREAM:
case XN_SENSOR_SERVER_MESSAGE_BYE:
{
nRetVal = GetDataPacker()->ReadCustomData(nObjectType, &m_LastReply, &nDataSize);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSSetEvent(m_hReplyEvent);
XN_IS_STATUS_OK(nRetVal);
break;
}
case XN_SENSOR_SERVER_MESSAGE_NEW_STREAM_DATA:
{
XnSensorServerNewStreamData message;
XnUInt32 nDataSize = sizeof(message);
nRetVal = GetDataPacker()->ReadCustomData(nObjectType, &message, &nDataSize);
XN_IS_STATUS_OK(nRetVal);
// find the stream
XnStreamDeviceStreamHolder* pHolder = NULL;
nRetVal = FindStream(message.strStreamName, &pHolder);
XN_IS_STATUS_OK(nRetVal);
pHolder->GetStream()->NewDataAvailable(message.nTimestamp, message.nFrameID);
break;
}
default:
{
nRetVal = XnStreamReaderDevice::HandlePackedObject(nObjectType);
XN_IS_STATUS_OK(nRetVal);
}
}
return (XN_STATUS_OK);
}
XnStatus XnServerSensorInvoker::OnNewStreamData(const XnChar* StreamName)
{
XnStatus nRetVal = XN_STATUS_OK;
// no need to lock the sensor (this might cause a dead lock).
// Instead, only lock the streams collection (so it wouldn't change while we search for the stream)
SensorInvokerStream* pStream = NULL;
nRetVal = m_streams.Get(StreamName, pStream);
XN_IS_STATUS_OK(nRetVal);
pStream->bNewData = TRUE;
nRetVal = xnOSSetEvent(m_hNewDataEvent);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
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);
}
XN_C_API XnStatus xnSchedulerRescheduleTask(XnScheduler* pScheduler, XnScheduledTask* pTask, XnUInt64 nInterval)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pScheduler);
XN_VALIDATE_INPUT_PTR(pTask);
// enter critical section
nRetVal = xnOSEnterCriticalSection(&pScheduler->hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
// remove it from list
XnSchedulerRemoveTaskInternal(pScheduler, pTask);
pTask->nInterval = nInterval;
// update its next execution
XnUInt64 nNow;
xnOSGetTimeStamp(&nNow);
pTask->nNextTime = nNow + nInterval;
// and add it back to the queue
xnSchedulerAddTaskInternal(pScheduler, pTask);
// leave critical section
nRetVal = xnOSLeaveCriticalSection(&pScheduler->hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
// notify that the list has changed
nRetVal = xnOSSetEvent(pScheduler->hWakeThreadEvent);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_SCHEDULER, "Failed setting event when rescheduling task: %s", xnGetStatusString(nRetVal));
}
return (XN_STATUS_OK);
}
void VideoStream::raiseNewFrameEvent()
{
xnOSSetEvent(m_newFrameInternalEvent);
xnOSSetEvent(m_newFrameInternalEventForFrameHolder);
}
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);
}
XnStatus SocketInConnection::ReadThreadProcImpl()
{
XnStatus nRetVal = XN_STATUS_OK;
XN_SOCKET_HANDLE hSocket = NULL;
XnBool bCanceled = FALSE;
XnUInt32 nPacketBytesRead = 0;
XnUInt32 nTotalBytesRead = 0;
m_nConnectionStatus = ConnectSocket(hSocket, m_strIP, m_nPort);
XN_IS_STATUS_OK_LOG_ERROR("Connect socket", m_nConnectionStatus);
nRetVal = xnOSSetEvent(m_hConnectEvent);
XN_IS_STATUS_OK_LOG_ERROR("Set connect event", nRetVal);
while (!m_bStopReadThread)
{
//Fill buffer with received packets
nTotalBytesRead = 0;
for (XnUInt32 nPacket = 0; (nPacket < BUFFER_NUM_PACKETS); nPacket++)
{
nPacketBytesRead = m_nMaxPacketSize;
m_nConnectionStatus = ReceivePacket(hSocket, m_pBuffer + nTotalBytesRead, nPacketBytesRead, bCanceled);
if (m_nConnectionStatus != XN_STATUS_OK)
{
m_pDataDestination->HandleDisconnection();
xnLogError(XN_MASK_LINK, "Failed to receive packet: %s", xnGetStatusString(m_nConnectionStatus));
//XN_ASSERT(FALSE);
return m_nConnectionStatus;
}
if (bCanceled)
{
//Ignore packet and exit loop
break;
}
if (nTotalBytesRead == m_nBufferSize)
{
xnLogError(XN_MASK_LINK, "Read thread buffer overflowed :(");
XN_ASSERT(FALSE);
return XN_STATUS_INTERNAL_BUFFER_TOO_SMALL;
}
nTotalBytesRead += nPacketBytesRead;
}
if (m_pDataDestination != NULL)
{
//Send data in buffer to its destination.
//Even if at this point the read thread should be stopped, first we send all the complete packets we got.
if (nTotalBytesRead > 0)
{
m_pDataDestination->IncomingData(m_pBuffer, nTotalBytesRead);
}
}
}
nRetVal = xnOSCloseSocket(hSocket);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_LINK, "Failed to close input data socket :(");
XN_ASSERT(FALSE);
}
m_nConnectionStatus = XN_STATUS_OS_NETWORK_CONNECTION_CLOSED;
return XN_STATUS_OK;
}
