XnStatus XnBufferPool::GetBuffer(XnBuffer** ppBuffer)
{
XnStatus nRetVal = XN_STATUS_OK;
xnOSEnterCriticalSection(&m_hLock);
XnBuffersList::Iterator it = m_FreeBuffers.begin();
if (it == m_FreeBuffers.end())
{
xnOSLeaveCriticalSection(&m_hLock);
return XN_STATUS_ALLOC_FAILED;
}
XnBufferInPool* pBuffer = *it;
// remove from list
nRetVal = m_FreeBuffers.Remove(it);
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(&m_hLock);
return XN_STATUS_ALLOC_FAILED;
}
pBuffer->m_nRefCount = 1;
xnDumpWriteString(m_dump, "%u taken from pool\n", pBuffer->m_nID);
xnOSLeaveCriticalSection(&m_hLock);
*ppBuffer = pBuffer;
return (XN_STATUS_OK);
}
XnStatus XnSensorDepthStream::SetMirror(XnBool bIsMirrored)
{
XnStatus nRetVal = XN_STATUS_OK;
xnOSEnterCriticalSection(GetLock());
// set firmware mirror
XnBool bFirmwareMirror = (bIsMirrored == TRUE && m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_0);
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareMirror, (XnUInt16)bFirmwareMirror);
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
// update prop
nRetVal = XnDepthStream::SetMirror(bIsMirrored);
xnOSLeaveCriticalSection(GetLock());
XN_IS_STATUS_OK(nRetVal);
if (m_depthUtilsHandle != NULL)
{
nRetVal = DepthUtilsSetDepthConfiguration(m_depthUtilsHandle, GetXRes(), GetYRes(), GetOutputFormat(), IsMirrored());
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnSensorAudioStream::ReadImpl(XnStreamData *pStreamOutput)
{
XnStatus nRetVal = XN_STATUS_OK;
XnDevicePrivateData* pDevicePrivateData = m_Helper.GetPrivateData();
pStreamOutput->nDataSize = 0;
XN_AUDIO_TYPE* pAudioBuf = (XN_AUDIO_TYPE*)pStreamOutput->pData;
xnOSEnterCriticalSection(&pDevicePrivateData->hAudioBufferCriticalSection);
// check how many buffers we have
XnInt32 nAvailbalePackets = pDevicePrivateData->nAudioWriteIndex - pDevicePrivateData->nAudioReadIndex;
if (nAvailbalePackets < 0)
nAvailbalePackets += pDevicePrivateData->nAudioBufferNumOfPackets;
// now check if stream frame buffer has enough space
if (GetRequiredDataSize() < (XnUInt32)nAvailbalePackets * pDevicePrivateData->nAudioPacketSize)
{
xnOSLeaveCriticalSection(&pDevicePrivateData->hAudioBufferCriticalSection);
return (XN_STATUS_IO_INVALID_STREAM_AUDIO_BUFFER_SIZE);
}
// take first packet timestamp
pStreamOutput->nTimestamp = pDevicePrivateData->pAudioPacketsTimestamps[pDevicePrivateData->nAudioReadIndex];
XnUChar* pPacketData = pDevicePrivateData->pAudioBuffer + (pDevicePrivateData->nAudioReadIndex * pDevicePrivateData->nAudioPacketSize);
// copy
while (pDevicePrivateData->nAudioReadIndex != pDevicePrivateData->nAudioWriteIndex)
{
xnOSMemCopy(pAudioBuf, pPacketData, pDevicePrivateData->nAudioPacketSize);
pAudioBuf += pDevicePrivateData->nAudioPacketSize;
pStreamOutput->nDataSize += pDevicePrivateData->nAudioPacketSize;
pDevicePrivateData->nAudioReadIndex++;
pPacketData += pDevicePrivateData->nAudioPacketSize;
if (pDevicePrivateData->nAudioReadIndex == pDevicePrivateData->nAudioBufferNumOfPackets)
{
pDevicePrivateData->nAudioReadIndex = 0;
pPacketData = pDevicePrivateData->pAudioBuffer;
}
}
xnOSLeaveCriticalSection(&pDevicePrivateData->hAudioBufferCriticalSection);
++m_nFrameID;
pStreamOutput->nFrameID = m_nFrameID;
return (XN_STATUS_OK);
}
XnNode* XnNodeManager::Allocate()
{
XnNode* pResult = NULL;
xnOSEnterCriticalSection(&m_hCriticalSection);
if (m_eInitializationState == XN_NM_INIT_STATE_CREATE_INTERNAL_LIST)
{
pResult = &(m_InitialNodes[0]);
}
else if (m_eInitializationState == XN_NM_INIT_STATE_CREATE_FIRST_LINK)
{
pResult = &(m_InitialNodes[1]);
}
if (pResult != NULL)
{
xnOSLeaveCriticalSection(&m_hCriticalSection);
return pResult;
}
// Check if resize is in order
if (m_nCurrentAvailability == 1 ||
XnFloat(m_nCurrentOccupancy)/m_nCurrentCapacity > 0.75)
{
XnStatus rc = Resize((XnUInt32)(m_nCurrentCapacity*0.5));
if (rc != XN_STATUS_OK && m_nCurrentAvailability == 1)
{
// Couldn't resize, and there is only one node available
// We'll need that one node to add to the list, to contain all new nodes
// So there are actually no available nodes....
xnOSLeaveCriticalSection(&m_hCriticalSection);
return NULL;
}
}
m_nCurrentOccupancy++;
m_nCurrentAvailability--;
// Return the first available
XnNode* pOut = m_pFirstAvailable;
m_pFirstAvailable = m_pFirstAvailable->Next();
pOut->Next() = NULL;
xnOSLeaveCriticalSection(&m_hCriticalSection);
return pOut;
}
void XnAudioProcessor::ProcessWholePacket(const XnSensorProtocolResponseHeader* pHeader, const XnUChar* pData)
{
xnOSEnterCriticalSection(&m_pDevicePrivateData->hAudioBufferCriticalSection);
// take write packet
XnUChar* pWritePacket = m_pDevicePrivateData->pAudioBuffer + (m_pDevicePrivateData->nAudioWriteIndex * m_pDevicePrivateData->nAudioPacketSize);
if (m_bDeleteChannel)
{
XnUInt16* pSamples = (XnUInt16*)pData;
XnUInt16* pSamplesEnd = (XnUInt16*)(pData + pHeader->nBufSize);
XnUInt16* pOutput = (XnUInt16*)pWritePacket;
while (pSamples < pSamplesEnd)
{
*pOutput = *pSamples;
pOutput++;
// skip a sample
pSamples += 2;
}
}
else
{
// copy data
xnOSMemCopy(pWritePacket, pData, pHeader->nBufSize);
}
// mark timestamp
m_pDevicePrivateData->pAudioPacketsTimestamps[m_pDevicePrivateData->nAudioWriteIndex] = GetTimeStamp(pHeader->nTimeStamp);
if (m_nLastPacketID % 10 == 0)
{
XnUInt64 nSysTime;
xnOSGetTimeStamp(&nSysTime);
xnDumpFileWriteString(m_pDevicePrivateData->BandwidthDump, "%llu,%s,%d,%d\n",
nSysTime, "Audio", -1, m_nBytesReceived);
m_nBytesReceived = 0;
}
// move write index forward
m_pDevicePrivateData->nAudioWriteIndex = (m_pDevicePrivateData->nAudioWriteIndex + 1) % m_pDevicePrivateData->nAudioBufferNumOfPackets;
// if write index got to read index (end of buffer), move read index forward (and loose a packet)
if (m_pDevicePrivateData->nAudioWriteIndex == m_pDevicePrivateData->nAudioReadIndex)
{
m_pDevicePrivateData->nAudioReadIndex = (m_pDevicePrivateData->nAudioReadIndex + 1) % m_pDevicePrivateData->nAudioBufferNumOfPackets;
}
xnOSLeaveCriticalSection(&m_pDevicePrivateData->hAudioBufferCriticalSection);
xnDumpFileWriteBuffer(m_AudioInDump, pData, pHeader->nBufSize);
if (m_pDevicePrivateData->pAudioCallback != NULL)
{
m_pDevicePrivateData->pAudioCallback(m_pDevicePrivateData->pAudioCallbackCookie);
}
}
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);
}
XnStatus XnFrameBufferManager::CopyLastStableBuffer(void* pDest, XnUInt32 nDestSize, XnUInt32* pnWritten)
{
// do this inside a lock (so we won't erase memory during copy)
xnOSEnterCriticalSection(&m_hLock);
// check size
if (nDestSize < m_pStableBuffer->GetSize())
{
xnOSLeaveCriticalSection(&m_hLock);
return (XN_STATUS_OUTPUT_BUFFER_OVERFLOW);
}
// copy
m_pStableBuffer->UnsafeCopy(pDest);
*pnWritten = m_pStableBuffer->GetSize();
xnOSLeaveCriticalSection(&m_hLock);
return XN_STATUS_OK;
}
XnStatus XnFrameBufferManager::Reallocate(XnUInt32 nBufferSize)
{
XnStatus nRetVal = XN_STATUS_OK;
xnOSEnterCriticalSection(&m_hLock);
nRetVal = m_pBufferPool->ChangeBufferSize(nBufferSize);
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(&m_hLock);
return (nRetVal);
}
// release current ones
if (m_pWorkingBuffer != NULL)
{
m_pBufferPool->DecRef(m_pWorkingBuffer);
}
if (m_pStableBuffer != NULL)
{
m_pBufferPool->DecRef(m_pStableBuffer);
}
// and take one
if (nBufferSize == 0)
{
m_pWorkingBuffer = NULL;
m_pStableBuffer = NULL;
}
else
{
// take working buffer
nRetVal = m_pBufferPool->GetBuffer(&m_pWorkingBuffer);
XN_IS_STATUS_OK(nRetVal);
}
xnOSLeaveCriticalSection(&m_hLock);
return (XN_STATUS_OK);
}
XnBool LinkContInputStream::IsNewDataAvailable() const
{
xnOSEnterCriticalSection(&m_hCriticalSection);
if (!m_bInitialized)
{
return FALSE;
}
XnBool bNewDataAvailable = m_bNewDataAvailable;
xnOSLeaveCriticalSection(&m_hCriticalSection);
return bNewDataAvailable;
}
XnStatus XnBufferPool::ChangeBufferSize(XnUInt32 nBufferSize)
{
XnStatus nRetVal = XN_STATUS_OK;
xnDumpWriteString(m_dump, "changing buffer size to %d\n", nBufferSize);
xnOSEnterCriticalSection(&m_hLock);
m_nBufferSize = nBufferSize;
nRetVal = AllocateBuffers();
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(&m_hLock);
return (nRetVal);
}
xnOSLeaveCriticalSection(&m_hLock);
return (XN_STATUS_OK);
}
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);
}
void XnNodeManager::Deallocate(XnNode *pNode)
{
xnOSEnterCriticalSection(&m_hCriticalSection);
m_nCurrentOccupancy--;
m_nCurrentAvailability++;
// Add the returned node as the first available
pNode->Next() = m_pFirstAvailable;
pNode->Previous() = NULL;
m_pFirstAvailable = pNode;
xnOSLeaveCriticalSection(&m_hCriticalSection);
}
XnStatus XnDeviceModule::SetLockState(XnBool bLocked)
{
XnStatus nRetVal = XN_STATUS_OK;
if (bLocked && m_Lock.GetValue() == TRUE)
{
return XN_STATUS_NODE_IS_LOCKED;
}
xnOSEnterCriticalSection(&m_hLockCS);
// check again
if (bLocked && m_Lock.GetValue() == TRUE)
{
xnOSLeaveCriticalSection(&m_hLockCS);
return XN_STATUS_NODE_IS_LOCKED;
}
nRetVal = m_Lock.UnsafeUpdateValue(bLocked);
xnOSLeaveCriticalSection(&m_hLockCS);
return (nRetVal);
}
XnStatus XnSensorDepthStream::SetMirror(XnBool bIsMirrored)
{
XnStatus nRetVal = XN_STATUS_OK;
xnOSEnterCriticalSection(GetLock());
// set firmware mirror
XnBool bFirmwareMirror = (bIsMirrored == TRUE && m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_0);
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareMirror, (XnUInt16)bFirmwareMirror);
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
// update prop
nRetVal = XnDepthStream::SetMirror(bIsMirrored);
xnOSLeaveCriticalSection(GetLock());
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
void XnBufferPool::AddRef(XnBuffer* pBuffer)
{
if (pBuffer == NULL)
{
return;
}
xnOSEnterCriticalSection(&m_hLock);
XnBufferInPool* pBufferInPool = (XnBufferInPool*)pBuffer;
++pBufferInPool->m_nRefCount;
xnDumpWriteString(m_dump, "%u add ref (%d)\n", pBufferInPool->m_nID, pBufferInPool->m_nRefCount);
xnOSLeaveCriticalSection(&m_hLock);
}
void LinkContInputStream::Shutdown()
{
if (!m_bInitialized)
return;
xnOSEnterCriticalSection(&m_hCriticalSection);
XN_ALIGNED_FREE_AND_NULL(m_pUserBuffer);
XN_ALIGNED_FREE_AND_NULL(m_pWorkingBuffer);
m_bInitialized = FALSE;
m_bNewDataAvailable = FALSE;
LinkInputStream::Shutdown();
xnOSLeaveCriticalSection(&m_hCriticalSection);
}
void XnFrameBufferManager::MarkWriteBufferAsStable(XnUInt64 nTimestamp, XnUInt32* pnFrameID)
{
xnOSEnterCriticalSection(&m_hLock);
// lock buffer pool (for rollback option)
m_pBufferPool->Lock();
XnBuffer* pPrevStable = m_pStableBuffer;
// release previous stable
if (m_pStableBuffer != NULL)
{
m_pBufferPool->DecRef(m_pStableBuffer);
}
// mark working as stable
m_nStableFrameID++;
m_nStableTimestamp = nTimestamp;
*pnFrameID = m_nStableFrameID;
m_pStableBuffer = m_pWorkingBuffer; // no need to add ref, working buffer will be replaced in a moment
// take a new working buffer
XnStatus nRetVal = m_pBufferPool->GetBuffer(&m_pWorkingBuffer);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_DDK, "Failed to get new working buffer!");
// we'll return back to our old working one
m_pWorkingBuffer->Reset();
m_pStableBuffer = pPrevStable;
m_pBufferPool->AddRef(m_pStableBuffer);
m_pBufferPool->Unlock();
return;
}
m_pBufferPool->Unlock();
xnOSLeaveCriticalSection(&m_hLock);
// reset new working
m_pWorkingBuffer->Reset();
// notify stream that new data is available
m_NewFrameEvent.Raise(this, m_nStableTimestamp);
}
void XnFrameBufferManager::ReadLastStableBuffer(XnBuffer** ppBuffer, XnUInt64* pnTimestamp, XnUInt32* pnFrameID)
{
xnOSEnterCriticalSection(&m_hLock);
// take a pointer to stable one
*ppBuffer = m_pStableBuffer;
// and add ref to it (so it wouldn't be deleted)
if (m_pStableBuffer != NULL)
{
m_pBufferPool->AddRef(m_pStableBuffer);
}
// take props
*pnTimestamp = m_nStableTimestamp;
*pnFrameID = m_nStableFrameID;
xnOSLeaveCriticalSection(&m_hLock);
}
void XnFrameBufferManager::MarkWriteBufferAsStable(XnUInt32* pnFrameID)
{
xnOSEnterCriticalSection(&m_hLock);
OniFrame* pStableBuffer = m_pWorkingBuffer;
pStableBuffer->dataSize = m_writeBuffer.GetSize();
// lock buffer pool (for rollback option)
m_pBufferPool->Lock();
// mark working as stable
m_nStableFrameID++;
*pnFrameID = m_nStableFrameID;
pStableBuffer->frameIndex = m_nStableFrameID;
// take a new working buffer
m_pWorkingBuffer = m_pBufferPool->Acquire();
if (m_pWorkingBuffer == NULL)
{
xnLogError(XN_MASK_DDK, "Failed to get new working buffer!");
// we'll return back to our old working one
m_pWorkingBuffer = pStableBuffer;
m_pWorkingBuffer->dataSize = 0;
m_pBufferPool->Unlock();
XN_ASSERT(FALSE);
return;
}
m_writeBuffer.SetExternalBuffer((XnUChar*)m_pWorkingBuffer->data, m_pBufferPool->GetFrameSize());
m_pBufferPool->Unlock();
xnOSLeaveCriticalSection(&m_hLock);
// reset new working
m_pWorkingBuffer->dataSize = 0;
// notify stream that new data is available
NewFrameEventArgs args;
args.pFrame = pStableBuffer;
m_NewFrameEvent.Raise(args);
}
void XnPixelStream::NewDataAvailable(OniFrame* pFrame)
{
// crop
xnOSEnterCriticalSection(GetLock());
OniCropping cropping = *GetCropping();
xnOSLeaveCriticalSection(GetLock());
if (cropping.enabled)
{
XnStatus nRetVal = CropImpl(pFrame, &cropping);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_DDK, "Failed to crop! Frame will be dropped");
return;
}
}
XnFrameStream::NewDataAvailable(pFrame);
}
XnStatus XnFrameBufferManager::Reallocate(XnUInt32 nBufferSize)
{
xnOSEnterCriticalSection(&m_hLock);
// release current ones
if (m_pWorkingBuffer != NULL)
{
m_pBufferPool->DecRef(m_pWorkingBuffer);
m_pWorkingBuffer = NULL;
}
// Change the buffer size.
m_pBufferPool->SetFrameSize(nBufferSize);
// TODO: validate all is OK
/*if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(&m_hLock);
return (nRetVal);
}*/
// and take one
if (nBufferSize == 0)
{
m_pWorkingBuffer = NULL;
}
else
{
// take working buffer
m_pWorkingBuffer = m_pBufferPool->Acquire();
if (m_pWorkingBuffer == NULL)
{
XN_ASSERT(FALSE);
return XN_STATUS_ERROR;
}
m_writeBuffer.SetExternalBuffer((XnUChar*)m_pWorkingBuffer->data, nBufferSize);
}
xnOSLeaveCriticalSection(&m_hLock);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnProfilingSectionStart(const char* csSectionName, XnBool bMT, XnProfilingHandle* pHandle)
{
if (!g_ProfilingData.bInitialized)
return XN_STATUS_OK;
if (*pHandle == INVALID_PROFILING_HANDLE)
{
xnOSEnterCriticalSection(&g_ProfilingData.hCriticalSection);
if (*pHandle == INVALID_PROFILING_HANDLE)
{
XnUInt32 nIndex = g_ProfilingData.nSectionCount;
g_ProfilingData.nSectionCount++;
XnProfiledSection* pSection = &g_ProfilingData.aSections[nIndex];
pSection->nIndentation = gt_nStackDepth;
XnUInt32 nChar = 0;
for (nChar = 0; nChar < gt_nStackDepth*2; ++nChar)
pSection->csName[nChar] = ' ';
strncpy(pSection->csName + nChar, csSectionName, MAX_SECTION_NAME);
if (strlen(pSection->csName) > g_ProfilingData.nMaxSectionName)
g_ProfilingData.nMaxSectionName = strlen(pSection->csName);
if (bMT)
{
pSection->bMultiThreaded = TRUE;
xnOSCreateCriticalSection(&pSection->hLock);
}
*pHandle = nIndex;
}
xnOSLeaveCriticalSection(&g_ProfilingData.hCriticalSection);
}
gt_nStackDepth++;
XnProfiledSection* pSection = &g_ProfilingData.aSections[*pHandle];
xnOSGetHighResTimeStamp(&pSection->nCurrStartTime);
return XN_STATUS_OK;
}
XnStatus XnPixelStream::ReadImpl(XnStreamData* pStreamOutput)
{
XnStatus nRetVal = XN_STATUS_OK;
// first read
nRetVal = XnFrameStream::ReadImpl(pStreamOutput);
XN_IS_STATUS_OK(nRetVal);
// now crop
xnOSEnterCriticalSection(GetLock());
XnCropping cropping = *GetCropping();
xnOSLeaveCriticalSection(GetLock());
if (cropping.bEnabled)
{
nRetVal = CropImpl(pStreamOutput, &cropping);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
void XnBufferPool::DecRef(XnBuffer* pBuffer)
{
if (pBuffer == NULL)
{
return;
}
XnBufferInPool* pBufInPool = (XnBufferInPool*)pBuffer;
xnOSEnterCriticalSection(&m_hLock);
xnDumpWriteString(m_dump, "%u dec ref (%d)", pBufInPool->m_nID, pBufInPool->m_nRefCount-1);
if (--pBufInPool->m_nRefCount == 0)
{
if (pBufInPool->m_bDestroy)
{
// remove it from all buffers pool
XnBuffersList::ConstIterator it = m_AllBuffers.Find(pBufInPool);
XN_ASSERT(it != m_AllBuffers.end());
m_AllBuffers.Remove(it);
// and free it
DestroyBuffer(pBufInPool);
xnDumpWriteString(m_dump, "destroy!\n");
}
else
{
// return it to free buffers list
m_FreeBuffers.AddLast(pBufInPool);
xnDumpWriteString(m_dump, "return to pool!\n");
}
}
else
{
xnDumpWriteString(m_dump, "\n");
}
xnOSLeaveCriticalSection(&m_hLock);
}
XnStatus XnDeviceStream::Read(XnStreamData* pStreamOutput)
{
XnStatus nRetVal = XN_STATUS_OK;
// check the size of the stream output object
nRetVal = XnStreamDataCheckSize(pStreamOutput, GetRequiredDataSize());
XN_IS_STATUS_OK(nRetVal);
// first mark old data as old
pStreamOutput->bIsNew = FALSE;
// now check if we have some new data
if (m_bNewDataAvailable)
{
// copy data
nRetVal = ReadImpl(pStreamOutput);
XN_IS_STATUS_OK(nRetVal);
xnOSEnterCriticalSection(&m_hCriticalSection);
XnBool bMirror = IsMirrored();
xnOSLeaveCriticalSection(&m_hCriticalSection);
// mirror it if needed
if (bMirror)
{
nRetVal = Mirror(pStreamOutput);
XN_IS_STATUS_OK(nRetVal);
}
// mark that data is new
pStreamOutput->bIsNew = TRUE;
// and that we don't have new info
m_bNewDataAvailable = FALSE;
}
return (XN_STATUS_OK);
}
void XnVMessageListener::BaseUpdate(XnVMessage* pMessage)
{
if (!m_bThreadProtectionQueueMode || IsInActivityThread())
{
xnLogVerbose(XNV_NITE_MASK_FLOW, "Listener %s [0x%08x]: Update (%s)",
GetListenerName(), this, pMessage->GetType());
HandleCCMessages(pMessage);
xnOSEnterCriticalSection(&m_hListenerCS);
Update(pMessage);
xnOSLeaveCriticalSection(&m_hListenerCS);
m_pUpdateCBs->Raise(pMessage);
}
else
{
xnLogVerbose(XNV_NITE_MASK_MT_QUEUE, "Listener %s [%08x]: Adding to queue (%s)",
GetListenerName(), this, pMessage->GetType());
XnVMessage* pNewMessage = pMessage->Clone();
m_pMessageQueue->Push(pNewMessage);
}
} // XnVMessageListener::BaseUpdate
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);
}
XN_C_API XnStatus xnProfilingSectionEnd(XnProfilingHandle* pHandle)
{
if (!g_ProfilingData.bInitialized)
return XN_STATUS_OK;
XnUInt64 nNow;
xnOSGetHighResTimeStamp(&nNow);
XnProfiledSection* pSection = &g_ProfilingData.aSections[*pHandle];
if (pSection->bMultiThreaded)
{
xnOSEnterCriticalSection(&pSection->hLock);
}
pSection->nTimesExecuted++;
pSection->nTotalTime += nNow - pSection->nCurrStartTime;
if (pSection->bMultiThreaded)
{
xnOSLeaveCriticalSection(&pSection->hLock);
}
gt_nStackDepth--;
return XN_STATUS_OK;
}
XnStatus XnSensorDepthStream::SetCropping(const XnCropping* pCropping)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = ValidateCropping(pCropping);
XN_IS_STATUS_OK(nRetVal);
xnOSEnterCriticalSection(GetLock());
if (m_Helper.GetFirmwareVersion() > XN_SENSOR_FW_VER_3_0)
{
nRetVal = m_Helper.StartFirmwareTransaction();
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
if (pCropping->bEnabled)
{
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeX, pCropping->nXSize);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeY, pCropping->nYSize);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetX, pCropping->nXOffset);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetY, pCropping->nYOffset);
}
if (nRetVal == XN_STATUS_OK)
{
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropEnabled, (XnUInt16)pCropping->bEnabled);
}
if (nRetVal != XN_STATUS_OK)
{
m_Helper.RollbackFirmwareTransaction();
m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY);
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
nRetVal = m_Helper.CommitFirmwareTransactionAsBatch();
if (nRetVal != XN_STATUS_OK)
{
m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY);
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
}
nRetVal = XnDepthStream::SetCropping(pCropping);
xnOSLeaveCriticalSection(GetLock());
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
/* This is the actual scheduler function. It is being run in its own thread. */
XN_THREAD_PROC xnSchedulerThreadFunc(XN_THREAD_PARAM pThreadParam)
{
XnScheduler* pScheduler = (XnScheduler*)pThreadParam;
XnUInt64 nNow;
while (!pScheduler->bStopThread)
{
// check when next task should be executed
XnUInt64 nWait = XN_WAIT_INFINITE;
XnScheduledTask* pTask = NULL;
XnTaskCallbackFuncPtr pCallback = NULL;
void* pCallbackArg = NULL;
// check if something is in the list
if (pScheduler->pFirst != NULL)
{
// enter critical section
xnOSEnterCriticalSection(&pScheduler->hCriticalSection);
pTask = pScheduler->pFirst;
if (pTask != NULL)
{
xnOSGetTimeStamp(&nNow);
if (pTask->nNextTime < nNow)
{
// task should be executed
pCallback = pTask->pCallback;
pCallbackArg = pTask->pCallbackArg;
// remove it from the list
pScheduler->pFirst = pTask->pNextTask;
// calculate next time
pTask->nNextTime += pTask->nInterval;
// add it to the list again
xnSchedulerAddTaskInternal(pScheduler, pTask);
}
else
{
nWait = pTask->nNextTime - nNow;
}
}
// leave critical section
xnOSLeaveCriticalSection(&pScheduler->hCriticalSection);
if (pCallback != NULL)
{
// execute task (outside critical section)
pCallback(pCallbackArg);
// no need to wait (we don't know how much time did callback take)
nWait = 0;
}
}
// wait for a change of the list, or the time of the next task
xnOSWaitEvent(pScheduler->hWakeThreadEvent, (XnUInt32)nWait);
}
XN_THREAD_PROC_RETURN(XN_STATUS_OK);
}
