XnStatus XnSensorServer::RemoveSession(XnSessionsList::ConstIterator it)
{
XnStatus nRetVal = XN_STATUS_OK;
XnServerSession* pSession = *it;
XnUInt32 nID = pSession->ID();
xnLogVerbose(XN_MASK_SENSOR_SERVER, "Removing client %u...", nID);
{
XnAutoCSLocker locker(m_hSessionsLock);
nRetVal = m_sessions.Remove(it);
XN_IS_STATUS_OK(nRetVal);
if (m_sessions.IsEmpty())
{
xnOSGetTimeStamp(&m_nLastSessionActivity);
}
}
pSession->Free();
XN_DELETE(pSession);
xnLogVerbose(XN_MASK_SENSOR_SERVER, "Client %u removed", nID);
return (XN_STATUS_OK);
}
XnStatus XnSensorDepthStream::SetActualRead(XnBool bRead)
{
XnStatus nRetVal = XN_STATUS_OK;
if (m_ActualRead.GetValue() != bRead)
{
if (bRead)
{
xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Creating USB depth read thread...");
XnSpecificUsbDevice* pUSB = GetHelper()->GetPrivateData()->pSpecificDepthUsb;
nRetVal = xnUSBInitReadThread(pUSB->pUsbConnection->UsbEp, pUSB->nChunkReadBytes, XN_SENSOR_USB_DEPTH_BUFFERS, pUSB->nTimeout, XnDeviceSensorProtocolUsbEpCb, pUSB);
XN_IS_STATUS_OK(nRetVal);
}
else
{
xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Shutting down USB depth read thread...");
xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificDepthUsb->pUsbConnection->UsbEp);
}
nRetVal = m_ActualRead.UnsafeUpdateValue(bRead);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus ServerSocketInConnection::ConnectSocket(XN_SOCKET_HANDLE& hSocket, const XnChar* strIP, XnUInt16 nPort)
{
XnStatus nRetVal = XN_STATUS_OK;
(void)strIP; //Ignore IP parameter - accept connections from any IP.
XN_SOCKET_HANDLE hListenSocket = NULL;
nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, "0.0.0.0", nPort, &hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Create data listen socket", nRetVal);
nRetVal = xnOSBindSocket(hListenSocket);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseSocket(hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Bind data listen socket", nRetVal);
}
nRetVal = xnOSListenSocket(hListenSocket);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseSocket(hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Listen to data socket", nRetVal);
}
xnLogVerbose(XN_MASK_SOCKETS, "Server accepting %s:%u...", strIP, nPort);
nRetVal = xnOSAcceptSocket(hListenSocket, &hSocket, XN_WAIT_INFINITE);
xnOSCloseSocket(hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Accept data socket", nRetVal);
xnLogVerbose(XN_MASK_SOCKETS, "Server accepted connection on port %u", nPort);
return XN_STATUS_OK;
}
void Context::shutdown()
{
--m_initializationCounter;
if (m_initializationCounter > 0)
{
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Shutdown: still need %d more shutdown calls (to match initializations)", m_initializationCounter);
return;
}
if (!s_valid)
{
return;
}
s_valid = FALSE;
m_cs.Lock();
// Close all recorders.
while (m_recorders.Begin() != m_recorders.End())
{
Recorder* pRecorder = *m_recorders.Begin();
recorderClose(pRecorder);
}
// Destroy all streams
while (m_streams.Begin() != m_streams.End())
{
VideoStream* pStream = *m_streams.Begin();
streamDestroy(pStream);
}
// Close all devices
while (m_devices.Begin() != m_devices.End())
{
Device* pDevice = *m_devices.Begin();
m_devices.Remove(pDevice);
pDevice->close();
XN_DELETE(pDevice);
}
for (xnl::List<DeviceDriver*>::Iterator iter = m_deviceDrivers.Begin(); iter != m_deviceDrivers.End(); ++iter)
{
DeviceDriver* pDriver = *iter;
XN_DELETE(pDriver);
}
m_deviceDrivers.Clear();
m_cs.Unlock();
xnLogVerbose(XN_MASK_ONI_CONTEXT, "Shutdown: successful.");
xnLogClose();
}
XnStatus ClientSocketInConnection::ConnectSocket(XN_SOCKET_HANDLE& hSocket, const XnChar* strIP, XnUInt16 nPort)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, strIP, nPort, &hSocket);
XN_IS_STATUS_OK_LOG_ERROR("Create input socket", nRetVal);
xnLogVerbose(XN_MASK_SOCKETS, "Client connecting to %s:%u...", strIP, nPort);
nRetVal = xnOSConnectSocket(hSocket, CONNECT_TIMEOUT);
XN_IS_STATUS_OK_LOG_ERROR("Connect input socket", nRetVal);
xnLogVerbose(XN_MASK_SOCKETS, "Client connected to %s:%u", strIP, nPort);
return XN_STATUS_OK;
}
XnBool XnVPushDetector::IsPushDetected(const XnV3DVector& vImmediateVelocity, const XnV3DVector& vPreviousVelocity, XnFloat& fZAngle)
{
// Check if current motion is too slow
if (vImmediateVelocity.Magnitude() < m_fPushImmediateMinVelocity)
{
return false;
}
if (vPreviousVelocity.Magnitude() < m_fPushPreviousMinVelocity)
{
fZAngle = AngleBetweenVectors(vImmediateVelocity, XnV3DVector(0,0,-1));
if (fZAngle < m_fPushMaxAngleFromZ)
{
xnLogVerbose(XNV_NITE_MASK_EVENTS, "Push Detector %s [0x%08x]: "
"Immediate Velocity %5.3f over threshold %5.3f in the last %d ms (%d ms offset), "
"Previous Velocity %5.3f under threshold %5.3f in the last %d ms (%d ms offset), "
"Angle between Immediate and the Z Axis is %5.3f, under the threshold of %5.3f",
GetListenerName(), this,
vImmediateVelocity.Magnitude(), m_fPushImmediateMinVelocity, m_nPushImmediateDuration, m_nPushImmediateOffset,
vPreviousVelocity.Magnitude(), m_fPushPreviousMinVelocity, m_nPushPreviousDuration, m_nPushPreviousOffset,
fZAngle, m_fPushMaxAngleFromZ);
return true;
}
return false;
}
XnFloat fAngle = AngleBetweenVectors(vPreviousVelocity, vImmediateVelocity);
if (fAngle > m_fPushMinAngleImmediateAndPrevious)
{
fZAngle = AngleBetweenVectors(vImmediateVelocity, XnV3DVector(0,0,-1));
if (fZAngle < m_fPushMaxAngleFromZ)
{
xnLogVerbose(XNV_NITE_MASK_EVENTS, "Push Detector %s [0x%08x]: "
"Immediate Velocity %5.3f over threshold %5.3f in the last %d ms (%d ms offset), "
"Previous Velocity %5.3f over threshold %5.3f in the last %d ms (%d ms offset), "
"Angle between Immediate and the Z Axis is %5.3f, under the threshold of %5.3f, "
"Angle between Immediate and Previous direction is %5.3f, over the threshold of %5.3f",
GetListenerName(), this,
vImmediateVelocity.Magnitude(), m_fPushImmediateMinVelocity, m_nPushImmediateDuration, m_nPushImmediateOffset,
vPreviousVelocity.Magnitude(), m_fPushPreviousMinVelocity, m_nPushPreviousDuration, m_nPushPreviousOffset,
fZAngle, m_fPushMaxAngleFromZ,
fAngle, m_fPushMinAngleImmediateAndPrevious);
return true;
}
}
return false;
} // XnVPushDetector::IsPushDetected
XnStatus XnDeviceManagerLoadAllDevices(const XnChar* strDir)
{
XnStatus nRetVal = XN_STATUS_OK;
XnChar cpSearchString[XN_FILE_MAX_PATH] = "";
if (strDir == NULL)
{
strDir = XN_FILE_LOCAL_DIR;
}
// Build the search pattern string
XN_VALIDATE_STR_APPEND(cpSearchString, strDir, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_FILE_DIR_SEP, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_SHARED_LIBRARY_PREFIX, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_DEVICE_FILE_PREFIX, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_FILE_ALL_WILDCARD, XN_FILE_MAX_PATH, nRetVal);
XN_VALIDATE_STR_APPEND(cpSearchString, XN_SHARED_LIBRARY_POSTFIX, XN_FILE_MAX_PATH, nRetVal);
// Get a file list of Xiron devices
XnChar acsFileList[XN_DEVICE_MANAGER_MAX_NUMBER_OF_DEVICES][XN_FILE_MAX_PATH];
XnUInt32 nFileCount = 0;
xnLogVerbose(XN_MASK_DEVICE_MANAGER, "Searching for %s...", cpSearchString);
nRetVal = xnOSGetFileList(cpSearchString, NULL, acsFileList, XN_DEVICE_MANAGER_MAX_NUMBER_OF_DEVICES, &nFileCount);
if ((nRetVal != XN_STATUS_OS_FILE_NOT_FOUND) && (nRetVal != XN_STATUS_OK))
{
return (nRetVal);
}
// now try to load each file
for (XnUInt32 nIndex = 0; nIndex < nFileCount; ++nIndex)
{
xnLogVerbose(XN_MASK_DEVICE_MANAGER, "Trying to load a device '%s'...", acsFileList[nIndex]);
nRetVal = XnDeviceManagerLoadDevice(acsFileList[nIndex], &g_pDeviceManager->aDevices[g_pDeviceManager->nDevicesCount]);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_DEVICE_MANAGER, "'%s' is not a valid device: %s", acsFileList[nIndex], xnGetStatusString(nRetVal));
}
else
{
xnLogInfo(XN_MASK_DEVICE_MANAGER, "device '%s' loaded.", acsFileList[nIndex]);
g_pDeviceManager->nDevicesCount++;
}
}
return (XN_STATUS_OK);
}
XnVideoStream::~XnVideoStream()
{
xnLogVerbose(XN_MASK_FILTER, "Destroying pin...");
CAutoLock cAutoLock(m_pFilter->pStateLock());
m_imageGen.Release();
xnFPSFree(&m_FPS);
}
void XnVFlowRouter::OpenNewSession()
{
if (m_pActive == NULL)
{
return;
}
xnLogVerbose(XNV_NITE_MASK_CONNECT, "Router %s [0x%08x]: Connecting %s [0x%08x] as active",
GetListenerName(), this, m_pActive->GetListenerName(), m_pActive);
XnVMultipleHands newHands;
XnVMultipleHands* pLocalHands;
XnValue value;
m_pProperties->Get(FR_PROPERTY_HANDS, value);
pLocalHands = (XnVMultipleHands*)value;
// Create a Multiple Hands object with the same hands, indicating all of them are new
pLocalHands->Clone(newHands);
newHands.ClearLists();
for (XnVMultipleHands::Iterator iter = newHands.begin(); iter != newHands.end(); ++iter)
{
newHands.MarkActive((*iter)->nID);
newHands.MarkNew((*iter)->nID);
}
// Send an Activation Message
XnVActivationMessage activate(true);
m_pActive->BaseUpdate(&activate);
// Send the 'all-new' Point Message to to listener that's being activated
XnVPointMessage pointMessage(&newHands);
m_pActive->BaseUpdate(&pointMessage);
} // XnVFlowRouter::OpenNewSession
XnVMessageListener::~XnVMessageListener()
{
if (m_bInternalThreadAlive)
{
XnAutoCSLocker local(m_hListenerCS);
m_bInternalThreadKill = true;
XnStatus rc = xnOSWaitForThreadExit(m_hActivityThread, 1000);
if (rc != XN_STATUS_OK)
{
xnOSTerminateThread(&m_hActivityThread);
}
else
{
xnOSCloseThread(&m_hActivityThread);
}
}
xnLogVerbose(XNV_NITE_MASK_CREATE, "Listener %s [0x%08x]: Destroy", m_strListenerName, this);
XnVMessageListener::ClearQueue();
if (m_strListenerName != NULL)
{
xnOSFree(m_strListenerName);
}
XN_DELETE(m_pMessageQueue);
XN_DELETE(m_pUpdateCBs);
XN_DELETE(m_pActivateCBs);
XN_DELETE(m_pDeactivateCBs);
xnOSCloseCriticalSection(&m_hListenerCS);
} // XnVMessageListener::~XnVMessageListener
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 XnDeviceBase::CloseAllStreams()
{
XnStatus nRetVal = XN_STATUS_OK;
xnLogVerbose(XN_MASK_DDK, "Closing all streams...");
// go over modules list, and look for closed streams
for (XnStringsHash::Iterator it = m_Modules.begin(); it != m_Modules.end(); ++it)
{
XnDeviceModuleHolder* pModuleHolder = (XnDeviceModuleHolder*)it.Value();
if (IsStream(pModuleHolder->GetModule()))
{
XnDeviceStream* pStream = (XnDeviceStream*)pModuleHolder->GetModule();
if (pStream->IsOpen())
{
nRetVal = pStream->Close();
XN_IS_STATUS_OK(nRetVal);
}
}
}
xnLogInfo(XN_MASK_DDK, "All streams are closed.");
return XN_STATUS_OK;
}
XnStatus XnDeviceBase::DestroyStream(const XnChar* StreamName)
{
XnStatus nRetVal = XN_STATUS_OK;
xnLogInfo(XN_MASK_DDK, "Destroying stream '%s'...", StreamName);
// keep the stream name (we now delete the module, so the name will be lost)
XnChar strStreamName[XN_DEVICE_MAX_STRING_LENGTH];
strncpy(strStreamName, StreamName, XN_DEVICE_MAX_STRING_LENGTH);
// Find the stream
XnDeviceModuleHolder* pStreamHolder;
nRetVal = FindStream(strStreamName, &pStreamHolder);
XN_IS_STATUS_OK(nRetVal);
// remove it from map
nRetVal = RemoveModule(strStreamName);
XN_IS_STATUS_OK(nRetVal);
// and free it's memory
DestroyStreamModule(pStreamHolder);
// free memory of registered properties to this stream
FreeModuleRegisteredProperties(StreamName);
// raise event
m_OnStreamsChangeEvent.Raise(GetDeviceHandle(), strStreamName, XN_DEVICE_STREAM_DELETED);
xnLogVerbose(XN_MASK_DDK, "'%s' stream destroyed.", strStreamName);
return XN_STATUS_OK;
}
XnStatus XnIONetworkStream::ReadData(XnUChar *pData, XnUInt32 nDataSize)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nTotalRead = 0;
// read until we get all the data we want
while (nTotalRead < nDataSize)
{
XnUInt32 nReadSize = nDataSize - nTotalRead;
nRetVal = xnOSReceiveNetworkBuffer(m_hSocket, (XnChar*)(pData + nTotalRead), &nReadSize, m_nReadTimeout);
if (nRetVal != XN_STATUS_OK)
{
if (nRetVal == XN_STATUS_OS_NETWORK_CONNECTION_CLOSED)
{
xnLogVerbose(XN_MASK_IO_NET_STREAM, "Network connection was closed gracefully");
m_bIsConnected = FALSE;
}
else if (nRetVal != XN_STATUS_OS_NETWORK_TIMEOUT)
{
xnLogError(XN_MASK_IO_NET_STREAM, "Got an error while reading network buffer: %s", xnGetStatusString(nRetVal));
m_bIsConnected = FALSE;
}
return (nRetVal);
}
nTotalRead += nReadSize;
}
return (XN_STATUS_OK);
}
XnStatus XnDeviceModule::LoadConfigFromFile(const XnChar* csINIFilePath, const XnChar* strSectionName /* = NULL */)
{
XnStatus nRetVal = XN_STATUS_OK;
if (strSectionName == NULL)
{
strSectionName = GetName();
}
xnLogVerbose(XN_MASK_DDK, "Configuring module '%s' from section '%s' in file '%s'...", GetName(), strSectionName, csINIFilePath);
for (XnPropertiesHash::Iterator it = m_Properties.Begin(); it != m_Properties.End(); ++it)
{
XnProperty* pProp = it->Value();
// only read writable properties
if (!pProp->IsReadOnly())
{
nRetVal = pProp->ReadValueFromFile(csINIFilePath, strSectionName);
XN_IS_STATUS_OK(nRetVal);
}
}
xnLogInfo(XN_MASK_DDK, "Module '%s' configuration was loaded from file.", GetName());
return (XN_STATUS_OK);
}
XnStatus XnServerSession::HandleOpenSensor()
{
XnStatus nRetVal = XN_STATUS_OK;
// read it
XnChar strConnectionString[XN_DEVICE_MAX_STRING_LENGTH];
XnUInt32 nDataSize = XN_DEVICE_MAX_STRING_LENGTH;
nRetVal = m_privateIncomingPacker.ReadCustomData(XN_SENSOR_SERVER_MESSAGE_OPEN_SENSOR, strConnectionString, &nDataSize);
XN_IS_STATUS_OK(nRetVal);
xnLogVerbose(XN_MASK_SENSOR_SERVER, "Client %u requested to open sensor %s", m_nID, strConnectionString);
XnStatus nActionResult = OpenSensorImpl(strConnectionString);
if (nActionResult == XN_STATUS_OK)
{
// sensor is open. send client its initial state
nActionResult = SendInitialState();
}
// if an error occurred, send it to the client
if (nActionResult != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_SENSOR_SERVER, "Client %u failed to open sensor '%s': %s", m_nID, strConnectionString, xnGetStatusString(nActionResult));
nRetVal = SendReply(XN_SENSOR_SERVER_MESSAGE_GENERAL_OP_RESPOND, nActionResult);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::OpenAllStreams()
{
XnStatus nRetVal = XN_STATUS_OK;
xnLogVerbose(XN_MASK_DDK, "Opening all streams...");
// go over modules list, and look for closed streams
for (ModuleHoldersHash::Iterator it = m_Modules.Begin(); it != m_Modules.End(); ++it)
{
XnDeviceModuleHolder* pModuleHolder = it->Value();
if (IsStream(pModuleHolder->GetModule()))
{
XnDeviceStream* pStream = (XnDeviceStream*)pModuleHolder->GetModule();
if (!pStream->IsOpen())
{
nRetVal = pStream->Open();
XN_IS_STATUS_OK(nRetVal);
}
}
}
xnLogInfo(XN_MASK_DDK, "All streams are open.");
return XN_STATUS_OK;
}
XN_C_API XnStatus xnUSBSetInterface(XN_USB_DEV_HANDLE pDevHandle, XnUInt8 /*nInterface*/, XnUInt8 nAltInterface)
{
// Local variables
XnBool bResult = FALSE;
ULONG nRetBytes = 0;
PSUSBDRV_INTERFACE_PROPERTY InterfaceProp;
// Init the pipe property structure
InterfaceProp.nIF = 0;
InterfaceProp.nAltIF = nAltInterface;
// Do the set interface
bResult = DeviceIoControl(pDevHandle->hUSBDevHandle, IOCTL_PSDRV_SET_INTERFACE, &InterfaceProp, sizeof(PSUSBDRV_INTERFACE_PROPERTY), NULL, NULL, &nRetBytes, NULL);
if (bResult == FALSE)
{
return (XN_STATUS_USB_SET_INTERFACE_FAILED);
}
else
{
xnLogVerbose(XN_MASK_USB, "USB altIF was set to %d", nAltInterface);
}
pDevHandle->nAltInterface = nAltInterface;
return (XN_STATUS_OK);
}
XnStatus PrimeClient::CreateInputStreamImpl(XnLinkStreamType streamType, const XnChar* strCreationInfo, XnUInt16& nStreamID, XnUInt16& nEndpointID)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = m_linkControlEndpoint.CreateInputStream(streamType, strCreationInfo, nStreamID, nEndpointID);
XN_IS_STATUS_OK_LOG_ERROR("Create stream on device", nRetVal);
if (nEndpointID > m_inputDataEndpoints.GetSize())
{
xnLogError(XN_MASK_PRIME_CLIENT, "Stream %u was created on non-existing endpoint %u", nStreamID, nEndpointID);
XN_ASSERT(FALSE);
return XN_STATUS_ERROR;
}
if (!m_inputDataEndpoints[nEndpointID].IsInitialized())
{
xnLogVerbose(XN_MASK_PRIME_CLIENT, "Initializing input data endpoint 0x%X...", nEndpointID);
nRetVal = m_inputDataEndpoints[nEndpointID].Init(nEndpointID,
m_pConnectionFactory,
&m_linkInputStreamsMgr,
this);
XN_IS_STATUS_OK_LOG_ERROR("Init input data endpoint", nRetVal);
}
//Initialize input stream
nRetVal = m_linkInputStreamsMgr.InitInputStream(&m_linkControlEndpoint, streamType, nStreamID, &m_inputDataEndpoints[nEndpointID]);
XN_IS_STATUS_OK_LOG_ERROR("Init input stream", nRetVal);
return XN_STATUS_OK;
}
XnStatus XnSensorClient::GetProperty(const XnChar* ModuleName, const XnChar* PropertyName, XnChar* strValue)
{
XnStatus nRetVal = XN_STATUS_OK;
// check if we have a local copy
nRetVal = XnStreamReaderDevice::GetProperty(ModuleName, PropertyName, strValue);
if (nRetVal == XN_STATUS_DEVICE_PROPERTY_DONT_EXIST)
{
// get from server (virtual property?)
xnLogVerbose(XN_MASK_SENSOR_CLIENT, "Getting property %s.%s from server...", ModuleName, PropertyName);
XnSensorServerMessageGetPropertyRequest request;
strcpy(request.strModuleName, ModuleName);
strcpy(request.strPropertyName, PropertyName);
nRetVal = m_pOutgoingPacker->WriteCustomData(XN_SENSOR_SERVER_MESSAGE_GET_STRING_PROPERTY, &request, sizeof(request));
XN_IS_STATUS_OK(nRetVal);
// wait for reply
nRetVal = WaitForReply(XN_SENSOR_SERVER_MESSAGE_GET_STRING_PROPERTY);
XN_IS_STATUS_OK(nRetVal);
strcpy(strValue, (const XnChar*)m_LastReply.pData);
}
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSWaitEvent(const XN_EVENT_HANDLE EventHandle, XnUInt32 nMilliseconds)
{
// Local function variables
DWORD nRetVal = 0;
// Make sure the actual event handle isn't NULL
XN_RET_IF_NULL(EventHandle, XN_STATUS_OS_INVALID_EVENT);
// Wait for the event for a period if time (can be infinite)
nRetVal = WaitForSingleObject(EventHandle, nMilliseconds);
// Check the return value (WAIT_OBJECT_0 is OK)
if (nRetVal != WAIT_OBJECT_0)
{
// Handle the timeout failure
if (nRetVal == WAIT_TIMEOUT)
{
return (XN_STATUS_OS_EVENT_TIMEOUT);
}
else
{
xnLogVerbose(XN_MASK_OS, "WaitForSingleObject() failed with error %u", GetLastError());
return (XN_STATUS_OS_EVENT_WAIT_FAILED);
}
}
// All is good...
return (XN_STATUS_OK);
}
XnStatus xnUSBAsynchThreadAddRef()
{
XnStatus nRetVal = XN_STATUS_OK;
xnl::AutoCSLocker locker(g_InitData.hLock);
++g_InitData.nOpenDevices;
if (g_InitData.hThread == NULL)
{
xnLogVerbose(XN_MASK_USB, "Starting libusb asynch thread...");
// mark thread should run
g_InitData.bShouldThreadRun = TRUE;
// and start thread
nRetVal = xnOSCreateThread(xnUSBHandleEventsThread, NULL, &g_InitData.hThread);
if (nRetVal != XN_STATUS_OK)
{
// clean-up
xnUSBPlatformSpecificShutdown();
return nRetVal;
}
// set thread priority to critical
nRetVal = xnOSSetThreadPriority(g_InitData.hThread, XN_PRIORITY_CRITICAL);
if (nRetVal != 0)
{
xnLogWarning(XN_MASK_USB, "USB events thread: Failed to set thread priority to critical. This might cause loss of data...");
printf("Warning: USB events thread - failed to set priority. This might cause loss of data...\n");
}
}
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSCloseEvent(XN_EVENT_HANDLE* pEventHandle)
{
// Local function variables
XnBool bRetVal = FALSE;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(pEventHandle);
// Make sure the actual event handle isn't NULL
XN_RET_IF_NULL(*pEventHandle, XN_STATUS_OS_INVALID_EVENT);
// Close the event via the OS
bRetVal = CloseHandle(*pEventHandle);
// Make sure it succeeded (return value is true)
if (bRetVal != TRUE)
{
xnLogVerbose(XN_MASK_OS, "CloseHandle() failed with error %u", GetLastError());
return (XN_STATUS_OS_EVENT_CLOSE_FAILED);
}
// Null the output event
*pEventHandle = NULL;
// All is good...
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);
}
HRESULT STDMETHODCALLTYPE XnVideoSource::SetMode( IPin *pPin, long Mode )
{
XN_METHOD_START;
XN_METHOD_CHECK_POINTER(pPin);
HRESULT hr = S_OK;
// we have only 1 pin, make sure this is it
XnVideoStream* pVideoStream = dynamic_cast<XnVideoStream*>(GetPin(0));
if (pPin != static_cast<IPin*>(pVideoStream))
{
XN_METHOD_RETURN(E_FAIL);
}
xnLogVerbose(XN_MASK_FILTER, "Setting flip mode to %d", Mode);
hr = pVideoStream->SetMirror(Mode & VideoControlFlag_FlipHorizontal);
if (FAILED(hr))
XN_METHOD_RETURN(hr);
hr = pVideoStream->SetVerticalFlip(Mode & VideoControlFlag_FlipVertical);
if (FAILED(hr))
XN_METHOD_RETURN(hr);
XN_METHOD_RETURN(S_OK);
}
inline static void DEBUG_LOG_RECORD(T record, const XnChar* strRecordName)
{
XnChar s[1024];
XnUInt32 nCharsWritten = 0;
XnStatus nRetVal = record.AsString(s, sizeof(s), nCharsWritten);
XN_ASSERT(nRetVal == XN_STATUS_OK);
xnLogVerbose(XN_MASK_OPEN_NI, "--PLAYER--> %s: %s", strRecordName, s);
}
XnStatus XnSensorFirmwareParams::UpdateAllProperties()
{
XnStatus nRetVal = XN_STATUS_OK;
xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Reading all params from firmware...");
for (XnFirmwareParamsHash::Iterator it = m_AllFirmwareParams.begin(); it != m_AllFirmwareParams.end(); ++it)
{
XnFirmwareParam& param = it.Value();
nRetVal = UpdateProperty(¶m);
XN_IS_STATUS_OK(nRetVal);
}
xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Firmware params were updated.");
return (XN_STATUS_OK);
}
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);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XN_THREAD_PROC xnProfilingThread(XN_THREAD_PARAM /*pThreadParam*/)
{
XnChar csReport[4096];
int nReportChars;
XnUInt64 nLastTime;
xnOSGetHighResTimeStamp(&nLastTime);
while (!g_ProfilingData.bKillThread)
{
xnOSSleep(g_ProfilingData.nProfilingInterval);
XnUInt64 nNow;
xnOSGetHighResTimeStamp(&nNow);
// print profiled sections
nReportChars = 0;
nReportChars += sprintf(csReport + nReportChars, "Profiling Report:\n");
nReportChars += sprintf(csReport + nReportChars, "%-*s %-5s %-6s %-9s %-7s\n", (int)g_ProfilingData.nMaxSectionName, "TaskName", "Times", "% Time", "TotalTime", "AvgTime");
nReportChars += sprintf(csReport + nReportChars, "%-*s %-5s %-6s %-9s %-7s\n", (int)g_ProfilingData.nMaxSectionName, "========", "=====", "======", "=========", "=======");
XnUInt64 nTotalTime = 0;
for (XnUInt32 i = 0; i < g_ProfilingData.nSectionCount; ++i)
{
XnProfiledSection* pSection = &g_ProfilingData.aSections[i];
XnUInt64 nAvgTime = 0;
XnDouble dCPUPercentage = ((XnDouble)pSection->nTotalTime) / (nNow - nLastTime) * 100.0;
if (pSection->nTimesExecuted != 0)
{
nAvgTime = pSection->nTotalTime / pSection->nTimesExecuted;
}
nReportChars += sprintf(csReport + nReportChars, "%-*s %5u %6.2f %9llu %7llu\n", (int)g_ProfilingData.nMaxSectionName,
pSection->csName, pSection->nTimesExecuted, dCPUPercentage, pSection->nTotalTime, nAvgTime);
if (pSection->nIndentation == 0)
nTotalTime += pSection->nTotalTime;
// clear accumulated data
pSection->nTotalTime = 0;
pSection->nTimesExecuted = 0;
}
// print total
XnDouble dCPUPercentage = ((XnDouble)nTotalTime) / (nNow - nLastTime) * 100.0;
nReportChars += sprintf(csReport + nReportChars, "%-*s %5s %6.2f %9llu %7s\n",
(int)g_ProfilingData.nMaxSectionName, "*** Total ***", "-", dCPUPercentage, nTotalTime, "-");
xnLogVerbose(XN_MASK_PROFILING, "%s", csReport);
nLastTime = nNow;
}
XN_THREAD_PROC_RETURN(XN_STATUS_OK);
}
XnStatus XnSensorFixedParams::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// get fixed params
XnFixedParams FixedParams;
nRetVal = XnHostProtocolGetFixedParams(m_pDevicePrivateData, FixedParams);
if (nRetVal != XN_STATUS_OK)
{
// Ugly patch since get param is not supported in maintenance mode!
if (nRetVal != XN_STATUS_DEVICE_PROTOCOL_INVALID_COMMAND)
{
return nRetVal;
}
return nRetVal;
}
if (m_pDevicePrivateData->FWInfo.nFWVer < XN_SENSOR_FW_VER_5_4)
{
sprintf(m_strSensorSerial, "%d", FixedParams.nSerialNumber);
}
else
{
nRetVal = XnHostProtocolGetSerialNumber(m_pDevicePrivateData, m_strSensorSerial);
if (nRetVal != XN_STATUS_OK)
{
return nRetVal;
}
}
xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Sensor serial number: %s", m_strSensorSerial);
// fill in properties
m_nZeroPlaneDistance = (OniDepthPixel)FixedParams.fReferenceDistance;
m_dZeroPlanePixelSize = FixedParams.fReferencePixelSize;
m_dEmitterDCmosDistance = FixedParams.fDCmosEmitterDistance;
m_dDCmosRCmosDistance = FixedParams.fDCmosRCmosDistance;
m_nSensorDepthCMOSI2CBus = (XnUInt16)FixedParams.nDepthCmosI2CBus;
m_nSensorDepthCMOSI2CSlaveAddress = (XnUInt16)FixedParams.nDepthCmosI2CAddress;
m_nSensorImageCMOSI2CBus = (XnUInt16)FixedParams.nImageCmosI2CBus;
m_nSensorImageCMOSI2CSlaveAddress = (XnUInt16)FixedParams.nImageCmosI2CAddress;
m_nImageCmosType = (XnUInt32)FixedParams.nImageCmosType;
m_nDepthCmosType = (XnUInt32)FixedParams.nDepthCmosType;
nRetVal = XnHostProtocolAlgorithmParams(m_pDevicePrivateData, XN_HOST_PROTOCOL_ALGORITHM_DEVICE_INFO,
&m_deviceInfo, sizeof(m_deviceInfo), (XnResolutions)0, 0);
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnHostProtocolGetPlatformString(m_pDevicePrivateData, m_strPlatformString);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
