XnStatus XnSensor::Destroy()
{
XnStatus nRetVal = XN_STATUS_OK;
XnDevicePrivateData* pDevicePrivateData = GetDevicePrivateData();
// if needed, close the streams
if (m_bInitialized && m_CloseStreamsOnShutdown.GetValue() == TRUE && m_ReadData.GetValue() == TRUE)
{
nRetVal = m_Firmware.GetParams()->m_Stream0Mode.SetValue(XN_VIDEO_STREAM_OFF);
nRetVal = m_Firmware.GetParams()->m_Stream1Mode.SetValue(XN_VIDEO_STREAM_OFF);
nRetVal = m_Firmware.GetParams()->m_Stream2Mode.SetValue(XN_AUDIO_STREAM_OFF);
}
// close IO (including all reading threads)
m_SensorIO.CloseDevice();
m_bInitialized = FALSE;
// close critical sections
if (pDevicePrivateData->hAudioBufferCriticalSection != NULL)
{
xnOSCloseCriticalSection(&pDevicePrivateData->hAudioBufferCriticalSection);
pDevicePrivateData->hAudioBufferCriticalSection = NULL;
}
if (pDevicePrivateData->hEndPointsCS != NULL)
{
xnOSCloseCriticalSection(&pDevicePrivateData->hEndPointsCS);
pDevicePrivateData->hEndPointsCS = NULL;
}
// free buffers
XnDeviceSensorFreeBuffers(pDevicePrivateData);
if (pDevicePrivateData->hExecuteMutex != NULL)
{
xnOSCloseMutex(&pDevicePrivateData->hExecuteMutex);
pDevicePrivateData->hExecuteMutex = NULL;
}
// Register USB event callback
#if WIN32
nRetVal = m_SensorIO.SetCallback(NULL, this);
XN_IS_STATUS_OK(nRetVal);
#endif
XnDeviceBase::Destroy();
// close dumps
xnDumpClose(&pDevicePrivateData->TimestampsDump);
xnDumpClose(&pDevicePrivateData->BandwidthDump);
xnDumpClose(&pDevicePrivateData->MiniPacketsDump);
xnDumpClose(&m_FrameSyncDump);
m_Firmware.Free();
return (XN_STATUS_OK);
}
XnStatus xnOSNamedMutexCreate(XnMutex* pMutex, const XnChar* csMutexName)
{
XnStatus nRetVal = XN_STATUS_OK;
int rc;
// tanslate mutex name to key file name
XnUInt32 nBytesWritten;
xnOSStrFormat(pMutex->csSemFileName, XN_FILE_MAX_PATH, &nBytesWritten, "/tmp/XnCore.Mutex.%s.key", csMutexName);
// open this file (we hold it open until mutex is closed. That way it cannot be deleted as long
// as any process is holding the mutex, and the mutex can be destroyed if the file can be deleted).
pMutex->hSemFile = open(pMutex->csSemFileName, O_CREAT | O_RDONLY, S_IRWXU | S_IRWXG | S_IRWXO);
if (pMutex->hSemFile == -1)
{
return XN_STATUS_OS_FILE_OPEN_FAILED;
}
// create the key
key_t key = ftok(pMutex->csSemFileName, 1);
// first we try to create it. If we fail, we'll know it already existed
XnBool bCreated = TRUE;
// we created a set of 2 sems - first is the lock, second counts processes
pMutex->NamedSem = semget(key, 2, IPC_CREAT | IPC_EXCL | 0666);
if (pMutex->NamedSem == -1 && errno == EEXIST)
{
// get existing one
pMutex->NamedSem = semget(key, 2, IPC_CREAT | 0666);
if (pMutex->NamedSem == -1)
{
close(pMutex->hSemFile);
return (XN_STATUS_OS_MUTEX_CREATION_FAILED);
}
bCreated = FALSE;
}
if (bCreated)
{
union semun
{
int val; /* Value for SETVAL */
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* Array for GETALL, SETALL */
struct seminfo *__buf; /* Buffer for IPC_INFO
(Linux-specific) */
} init;
// init lock semaphore to 1 (not locked)
init.val = 1;
rc = semctl(pMutex->NamedSem, 0, SETVAL, init);
if (rc != 0)
{
semctl(pMutex->NamedSem, 0, IPC_RMID);
return (XN_STATUS_OS_MUTEX_CREATION_FAILED);
}
// init process counter to 0
init.val = 0;
rc = semctl(pMutex->NamedSem, 1, SETVAL, init);
if (rc != 0)
{
semctl(pMutex->NamedSem, 0, IPC_RMID);
return (XN_STATUS_OS_MUTEX_CREATION_FAILED);
}
}
// increment second sem
struct sembuf op;
op.sem_num = 1;
op.sem_op = 1;
op.sem_flg = SEM_UNDO; // mark it to be decreased when process terminates
rc = semop(pMutex->NamedSem, &op, 1);
if (rc != 0)
{
xnOSCloseMutex(&pMutex);
return (XN_STATUS_OS_MUTEX_CREATION_FAILED);
}
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);
}
XN_C_API XnStatus xnOSCloseCriticalSection(XN_CRITICAL_SECTION_HANDLE* pCriticalSectionHandle)
{
return xnOSCloseMutex(pCriticalSectionHandle);
}
