XN_C_API XnStatus xnOSWaitForThreadExit(XN_THREAD_HANDLE ThreadHandle, XnUInt32 nMilliseconds)
{
int rc = 0;
// Make sure the actual thread handle isn't NULL
XN_RET_IF_NULL(ThreadHandle, XN_STATUS_OS_INVALID_THREAD);
if (nMilliseconds == XN_WAIT_INFINITE)
{
// join via the OS
void* pReturnValue;
rc = pthread_join(*ThreadHandle, &pReturnValue);
}
else
{
// calculate timeout absolute time. First we take current time
struct timespec time;
XnStatus nRetVal = xnOSGetAbsTimeout(&time, nMilliseconds);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_THREAD_TERMINATION_FAILED;
}
// join via the OS
void* pReturnValue;
#ifndef XN_PLATFORM_HAS_NO_TIMED_OPS
rc = pthread_timedjoin_np(*ThreadHandle, &pReturnValue, &time);
#else
rc = pthread_join(*ThreadHandle, &pReturnValue);
#endif
}
// check for failures
if (rc == ETIMEDOUT)
{
return (XN_STATUS_OS_THREAD_TIMEOUT);
}
else if (rc != 0)
{
return (XN_STATUS_OS_THREAD_TERMINATION_FAILED);
}
// All is good...
return (XN_STATUS_OK);
}
XnStatus XnLinuxPosixEvent::Wait(XnUInt32 nMilliseconds)
{
XnStatus nRetVal = XN_STATUS_OK;
struct timespec time = {0};
if (nMilliseconds != XN_WAIT_INFINITE)
{
nRetVal = xnOSGetAbsTimeout(&time, nMilliseconds);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_EVENT_WAIT_FAILED;
}
}
// lock the mutex
if (0 != pthread_mutex_lock(&m_mutex))
{
return (XN_STATUS_OS_EVENT_WAIT_FAILED);
}
// wait for the condition to become signaled (or a failure)
int rc;
while (nRetVal == XN_STATUS_OK && !m_bSignaled)
{
if (nMilliseconds != XN_WAIT_INFINITE)
{
rc = pthread_cond_timedwait(&m_cond, &m_mutex, &time);
}
else // infinite
{
rc = pthread_cond_wait(&m_cond, &m_mutex);
}
if (rc == ETIMEDOUT)
{
nRetVal = XN_STATUS_OS_EVENT_TIMEOUT;
}
else if (rc != 0)
{
nRetVal = XN_STATUS_OS_EVENT_WAIT_FAILED;
}
}
// check all went well
if (nRetVal != XN_STATUS_OK)
{
pthread_mutex_unlock(&m_mutex);
return nRetVal;
}
if (!m_bManualReset)
{
// auto-reset the event
m_bSignaled = FALSE;
}
// unlock the mutex
if (0 != pthread_mutex_unlock(&m_mutex))
{
return (XN_STATUS_OS_EVENT_WAIT_FAILED);
}
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSLockMutex(const XN_MUTEX_HANDLE MutexHandle, XnUInt32 nMilliseconds)
{
// Local function variables
XnStatus nRetVal = XN_STATUS_OK;
int rc = 0;
// Make sure the actual mutex handle isn't NULL
XN_RET_IF_NULL(MutexHandle, XN_STATUS_OS_INVALID_MUTEX);
#ifndef XN_PLATFORM_LINUX_NO_SYSV
struct sembuf op;
// try to decrease it by 1 (if it's 0, we'll wait)
op.sem_num = 0;
op.sem_op = -1;
op.sem_flg = SEM_UNDO;
#endif
if (nMilliseconds == XN_WAIT_INFINITE)
{
// lock via the OS
if (MutexHandle->bIsNamed)
{
#ifndef XN_PLATFORM_LINUX_NO_SYSV
if (0 != semop(MutexHandle->NamedSem, &op, 1))
{
rc = errno;
}
#endif
}
else
{
rc = pthread_mutex_lock(&MutexHandle->ThreadMutex);
}
}
else
{
struct timespec time;
// lock via the OS
if (MutexHandle->bIsNamed)
{
#ifndef XN_PLATFORM_LINUX_NO_SYSV
nRetVal = xnOSGetTimeout(&time, nMilliseconds);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_MUTEX_LOCK_FAILED;
}
#ifndef XN_PLATFORM_HAS_NO_TIMED_OPS
if (0 != semtimedop(MutexHandle->NamedSem, &op, 1, &time))
#else
if (0 != semop(MutexHandle->NamedSem, &op, 1))
#endif
{
rc = errno;
}
#endif
}
else
{
// calculate timeout absolute time. First we take current time
nRetVal = xnOSGetAbsTimeout(&time, nMilliseconds);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_MUTEX_LOCK_FAILED;
}
#ifndef XN_PLATFORM_HAS_NO_TIMED_OPS
rc = pthread_mutex_timedlock(&MutexHandle->ThreadMutex, &time);
#else
rc = pthread_mutex_lock(&MutexHandle->ThreadMutex);
#endif
}
}
// check for failures
if (rc == ETIMEDOUT)
{
return (XN_STATUS_OS_MUTEX_TIMEOUT);
}
else if (rc != 0)
{
return (XN_STATUS_OS_MUTEX_LOCK_FAILED);
}
// All is good...
return (XN_STATUS_OK);
}
