void XnFileDevice::Free()
{
for (XnNodeInfoMap::Iterator it = m_nodeInfoMap.begin(); it != m_nodeInfoMap.end(); ++it)
{
XnNodeInfo& nodeInfo = it.Value();
XN_DELETE(nodeInfo.pXnCodec);
}
m_nodeInfoMap.Clear();
if (m_ShiftToDepth.bIsInitialized)
{
XnShiftToDepthFree(&m_ShiftToDepth);
}
if (m_pInputStream != NULL)
{
XN_DELETE(m_pInputStream);
m_pInputStream = NULL;
}
if (m_pDataPacker != NULL)
{
m_pDataPacker->Free();
XN_DELETE(m_pDataPacker);
m_pDataPacker = NULL;
}
if (m_pStreamData != NULL)
{
XnStreamDataDestroy(&m_pStreamData);
m_pStreamData = NULL;
}
}
XnStatus XnFrameStream::CreateStreamData(XnStreamData** ppStreamData)
{
XnStatus nRetVal = XN_STATUS_OK;
XnStreamData* pStreamData;
// we create a StreamData object with no buffer allocated. The buffer will just be
// a pointer to the triple buffer
nRetVal = XnStreamDataCreateNoBuffer(&pStreamData, GetName());
XN_IS_STATUS_OK(nRetVal);
// However, we don't want the user to get a null pointer, even if no new frame yet,
// so we'll initialize the data with one of the buffers
nRetVal = m_pBufferPool->GetBuffer(&pStreamData->pInternal->pLockedBuffer);
if (nRetVal != XN_STATUS_OK)
{
XnStreamDataDestroy(&pStreamData);
return (nRetVal);
}
pStreamData->pData = (void*)pStreamData->pInternal->pLockedBuffer->GetData();
*ppStreamData = pStreamData;
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XN_DDK_API XnStatus XnStreamDataCreateNoBuffer(XnStreamData** ppStreamOutput, const XnChar* StreamName)
{
XN_VALIDATE_OUTPUT_PTR(ppStreamOutput);
// allocate struct
XN_VALIDATE_CALLOC(*ppStreamOutput, XnStreamData, 1);
XnStreamData* pStreamOutput = *ppStreamOutput;
// allocate internal data
pStreamOutput->pInternal = (XnStreamDataInternal*)xnOSCalloc(1, sizeof(XnStreamDataInternal));
if (pStreamOutput->pInternal == NULL)
{
XnStreamDataDestroy(ppStreamOutput);
return (XN_STATUS_ALLOC_FAILED);
}
// fill internal data
pStreamOutput->pInternal->bAllocated = FALSE;
pStreamOutput->pInternal->nAllocSize = 0;
pStreamOutput->pInternal->UpdateMode = XN_STREAM_DATA_UPDATE_AUTOMATICALLY;
pStreamOutput->pInternal->Callback = NULL;
pStreamOutput->pInternal->pLockedBuffer = NULL;
// take name
xnOSStrCopy(pStreamOutput->StreamName, StreamName, XN_DEVICE_MAX_STRING_LENGTH);
return (XN_STATUS_OK);
}
XnStatus XnStreamReaderStream::Free()
{
if (m_pLastData != NULL)
{
XnStreamDataDestroy(&m_pLastData);
m_pLastData = NULL;
}
return (XN_STATUS_OK);
}
XN_DDK_API XnStatus XnStreamDataCreate(XnStreamData** ppStreamOutput, const XnChar* StreamName, XnUInt32 nAllocSize)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = XnStreamDataCreateNoBuffer(ppStreamOutput, StreamName);
XN_IS_STATUS_OK(nRetVal);
XnStreamData* pStreamOutput = *ppStreamOutput;
// allocate buffer
nRetVal = XnStreamDataUpdateSize(pStreamOutput, nAllocSize);
if (nRetVal != XN_STATUS_OK)
{
XnStreamDataDestroy(ppStreamOutput);
return nRetVal;
}
return (XN_STATUS_OK);
}
XnStatus XnServerSession::RemoveStreamImpl(const XnChar* strName)
{
XnStatus nRetVal = XN_STATUS_OK;
SessionStream* pStream = NULL;
nRetVal = m_streamsHash.Get(strName, pStream);
XN_IS_STATUS_OK(nRetVal);
// first close it (so that ref count will be consistent)
if (pStream->bIsOpen)
{
nRetVal = CloseStreamImpl(strName);
XN_IS_STATUS_OK(nRetVal);
pStream->bIsOpen = FALSE;
}
// release that stream
nRetVal = m_pSensor->ReleaseStream(pStream->strStreamName);
XN_IS_STATUS_OK(nRetVal);
// if client had a buffer of this stream, release it
XnStreamData* pStreamData = NULL;
nRetVal = XnStreamDataSetGet(m_pStreamDataSet, pStream->strStreamName, &pStreamData);
if (nRetVal == XN_STATUS_OK)
{
if (pStreamData->pInternal->pLockedBuffer != NULL)
{
m_pSensor->ReleaseFrameBuffer(pStream->strStreamName, pStreamData->pInternal->pLockedBuffer);
}
// free data
XnStreamDataSetRemove(m_pStreamDataSet, pStreamData);
XnStreamDataDestroy(&pStreamData);
}
// now remove it from client
nRetVal = RemoveSessionModule(strName);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
void XnFileDevice::Free()
{
for (XnNodeInfoMap::Iterator it = m_nodeInfoMap.Begin(); it != m_nodeInfoMap.End(); ++it)
{
XnNodeInfo& nodeInfo = it->Value();
XN_DELETE(nodeInfo.pXnCodec);
if (nodeInfo.codec.IsValid())
{
xnRemoveNeededNode(GetSelfNodeHandle(), nodeInfo.codec);
nodeInfo.codec.Release();
}
}
m_nodeInfoMap.Clear();
if (m_ShiftToDepth.bIsInitialized)
{
XnShiftToDepthFree(&m_ShiftToDepth);
}
if (m_pInputStream != NULL)
{
XN_DELETE(m_pInputStream);
m_pInputStream = NULL;
}
if (m_pDataPacker != NULL)
{
m_pDataPacker->Free();
XN_DELETE(m_pDataPacker);
m_pDataPacker = NULL;
}
if (m_pStreamData != NULL)
{
XnStreamDataDestroy(&m_pStreamData);
m_pStreamData = NULL;
}
}
XN_DDK_API XnStatus XnStreamDataSetDestroy(XnStreamDataSet** ppStreamOutputSet)
{
XN_VALIDATE_INPUT_PTR(ppStreamOutputSet);
XnStreamDataSet* pSet = (*ppStreamOutputSet);
if (pSet != NULL)
{
for (XnStreamDataHash::Iterator it = pSet->pHash->begin(); it != pSet->pHash->end(); ++it)
{
XnStreamData* pStreamData = it.Value();
XnStreamDataDestroy(&pStreamData);
}
// free hash table
XN_DELETE(pSet->pHash);
// free struct
XN_FREE_AND_NULL(*ppStreamOutputSet);
}
return XN_STATUS_OK;
}
XnStatus XnFrameStream::CreateStreamData(XnStreamData** ppStreamData)
{
XnStatus nRetVal = XN_STATUS_OK;
XnStreamData* pStreamData;
// NOTE: in any case, we must make sure data is not null, because some old applications
// counts on it (they might read the data before the first frame).
// check if the buffer pool has been set yet
if (m_pBufferPool == NULL)
{
// Create it with a buffer. This buffer will be later on freed when buffers from
// the buffer pool will be used.
nRetVal = XnStreamDataCreate(&pStreamData, GetName(), GetRequiredDataSize());
XN_IS_STATUS_OK(nRetVal);
}
else
{
// we create a StreamData object with no buffer allocated. The buffer will just be
// a pointer from the buffer pool
nRetVal = XnStreamDataCreateNoBuffer(&pStreamData, GetName());
XN_IS_STATUS_OK(nRetVal);
// take a buffer from the pool
nRetVal = m_pBufferPool->GetBuffer(&pStreamData->pInternal->pLockedBuffer);
if (nRetVal != XN_STATUS_OK)
{
XnStreamDataDestroy(&pStreamData);
return (nRetVal);
}
pStreamData->pData = (void*)pStreamData->pInternal->pLockedBuffer->GetData();
}
*ppStreamData = pStreamData;
return (XN_STATUS_OK);
}
XnStatus XnDeviceBase::DestroyStreamData(XnStreamData** ppStreamData)
{
XN_VALIDATE_INPUT_PTR(ppStreamData);
return XnStreamDataDestroy(ppStreamData);
}
