XN_C_API void xnFreeMapMetaData(const XnMapMetaData* pMetaData)
{
if (pMetaData != NULL)
{
xnFreeOutputMetaData(pMetaData->pOutput);
xnOSFree(pMetaData);
}
}
XN_C_API void xnFreeDepthMetaData(const XnDepthMetaData* pMetaData)
{
if (pMetaData != NULL)
{
xnFreeMapMetaData(pMetaData->pMap);
xnOSFree(pMetaData);
}
}
XnStatus XnExportedSensorDevice::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* /*pErrors*/)
{
XnStatus nRetVal = XN_STATUS_OK;
// enumerate connected sensors
XnUInt32 nCount = 0;
// check if sensor is connected
nRetVal = XnSensor::Enumerate(NULL, &nCount);
if (nRetVal != XN_STATUS_OUTPUT_BUFFER_OVERFLOW)
{
// no sensor connected
return XN_STATUS_DEVICE_NOT_CONNECTED;
}
// allocate according to count
XnConnectionString* pConnStrings;
XN_VALIDATE_CALLOC(pConnStrings, XnConnectionString, nCount);
nRetVal = XnSensor::Enumerate(pConnStrings, &nCount);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(pConnStrings);
return (nRetVal);
}
XnProductionNodeDescription Description;
GetDescription(&Description);
for (XnUInt32 i = 0; i < nCount; ++i)
{
// Each connection string is a sensor. Return it if it wasn't created already.
if (FindCreatedDevice(context.GetUnderlyingObject(), pConnStrings[i]) == m_createdDevices.End())
{
nRetVal = TreesList.Add(Description, pConnStrings[i], NULL);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(pConnStrings);
return (nRetVal);
}
}
}
xnOSFree(pConnStrings);
return (XN_STATUS_OK);
}
XnStatus XnExportedSensorDevice::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors)
{
XnStatus nRetVal = XN_STATUS_OK;
// enumerate connected sensors
XnUInt32 nCount = 0;
// check if sensor is connected
nRetVal = XnSensor::Enumerate(NULL, &nCount);
if (nRetVal != XN_STATUS_OUTPUT_BUFFER_OVERFLOW)
{
// no sensor connected
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_NOT_CONNECTED, XN_MASK_DEVICE_SENSOR, "No PS sensor is connected!");
}
// allocate according to count
XnConnectionString* pConnStrings;
XN_VALIDATE_CALLOC(pConnStrings, XnConnectionString, nCount);
nRetVal = XnSensor::Enumerate(pConnStrings, &nCount);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(pConnStrings);
return (nRetVal);
}
XnProductionNodeDescription Description;
GetDescription(&Description);
// each connection string is a sensor. return it
for (XnUInt32 i = 0; i < nCount; ++i)
{
nRetVal = TreesList.Add(Description, pConnStrings[i], NULL);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(pConnStrings);
return (nRetVal);
}
}
xnOSFree(pConnStrings);
return (XN_STATUS_OK);
}
XnStatus XnFileDevice::BCDestroy()
{
if (m_pBCData != NULL)
{
xnOSFreeAligned(m_pBCData->pPackedStreamBuffer);
xnOSFree(m_pBCData);
}
return XN_STATUS_OK;
}
XN_C_API void xnEnumerationErrorsFree(const XnEnumerationErrors* pError)
{
if (pError != NULL)
{
// object will be freed in a second, it's OK to const_cast it.
xnEnumerationErrorsClear(const_cast<XnEnumerationErrors*>(pError));
xnOSFree(pError);
}
}
XN_C_API XnStatus xnOSCloseEvent(XN_EVENT_HANDLE* pEventHandle)
{
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(pEventHandle);
xnOSFree(*pEventHandle);
*pEventHandle = NULL;
// All is good...
return (XN_STATUS_OK);
}
XnStatus XnActualPropertyFactory::FreeProperty(XnProperty* pProperty)
{
if (pProperty->GetType() == XN_PROPERTY_TYPE_GENERAL)
{
XnActualGeneralProperty* pGenProp = (XnActualGeneralProperty*)pProperty;
xnOSFree(pGenProp->GetValue().pData);
}
XN_DELETE(pProperty);
return (XN_STATUS_OK);
}
MockProductionNode::~MockProductionNode()
{
for (StringProps::Iterator it = m_stringProps.begin(); it != m_stringProps.end(); it++)
{
xnOSFree(it.Value());
}
for (GeneralProps::Iterator it2 = m_generalProps.begin(); it2 != m_generalProps.end(); it2++)
{
XnGeneralBufferFree(&(it2.Value()));
}
}
void FreeScheduler(XnScheduler* pScheduler)
{
// stop thread
if (pScheduler->hThread)
{
// mark for thread to stop
pScheduler->bStopThread = TRUE;
if (pScheduler->hWakeThreadEvent)
{
xnOSSetEvent(pScheduler->hWakeThreadEvent);
}
// now wait for it to exit
xnLogVerbose(XN_MASK_SCHEDULER, "Shutting down Scheduler thread...");
xnOSWaitAndTerminateThread(&pScheduler->hThread, XN_SCHEDULER_WAIT_THREAD_EXIT_TIMEOUT);
}
if (pScheduler->hWakeThreadEvent)
{
xnOSCloseEvent(&pScheduler->hWakeThreadEvent);
}
if (pScheduler->hCriticalSection)
{
xnOSCloseCriticalSection(&pScheduler->hCriticalSection);
}
while (pScheduler->pFirst != NULL)
{
XnScheduledTask* pTask = pScheduler->pFirst;
pScheduler->pFirst = pTask->pNextTask;
xnOSFree(pTask);
}
xnOSFree(pScheduler);
}
XN_C_API XnStatus xnEnumerationErrorsClear(XnEnumerationErrors* pError)
{
XN_VALIDATE_INPUT_PTR(pError);
XnModuleError* pModuleError = pError->pFirst;
while (pModuleError != NULL)
{
XnModuleError* pNext = pModuleError->pNext;
xnOSFree(pModuleError);
pModuleError = pNext;
}
pError->pFirst = NULL;
return (XN_STATUS_OK);
}
void PlayerNode::PlayerNodeInfo::Reset()
{
xnOSMemSet(strName, 0, sizeof(strName));
nLastDataPos = 0;
compression = XN_CODEC_NULL;
nFrames = 0;
nCurFrame = 0;
nMaxTimeStamp = 0;
bStateReady = FALSE;
bIsGenerator = FALSE;
recordUndoInfoMap.Clear();
newDataUndoInfo.Reset();
bValid = FALSE;
xnOSFree(pDataIndex);
pDataIndex = NULL;
}
XN_C_API XnStatus xnOSCloseSharedMemory(XN_SHARED_MEMORY_HANDLE hSharedMem)
{
XN_VALIDATE_INPUT_PTR(hSharedMem);
if (!UnmapViewOfFile(hSharedMem->pAddress))
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_FAILED_TO_CLOSE_SHARED_MEMORY, XN_MASK_OS, "Could not unmap view of file (%d).", GetLastError());
}
if (!CloseHandle(hSharedMem->hMapFile))
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_FAILED_TO_CLOSE_SHARED_MEMORY, XN_MASK_OS, "Could not close shared memory handle (%d).", GetLastError());
}
xnOSFree(hSharedMem);
return (XN_STATUS_OK);
}
XN_DDK_API XnStatus XnPropertySetCreate(XnPropertySet** ppSet)
{
XN_VALIDATE_OUTPUT_PTR(ppSet);
XnPropertySet* pSet;
XN_VALIDATE_ALLOC(pSet, XnPropertySet);
pSet->pData = XN_NEW(XnPropertySetData);
if (pSet->pData == NULL)
{
xnOSFree(pSet);
return XN_STATUS_ALLOC_FAILED;
}
*ppSet = pSet;
return (XN_STATUS_OK);
}
XnStatus MockProductionNode::SetStringProperty(const XnChar* strName, const XnChar* strValue)
{
const XnChar* strOldVal = NULL;
if (m_stringProps.Get(strName, strOldVal) == XN_STATUS_OK)
{
xnOSFree(strOldVal);
}
XnStatus nRetVal = m_stringProps.Set(strName, xnOSStrDup(strValue));
XN_IS_STATUS_OK(nRetVal);
if (m_pNotifications != NULL)
{
nRetVal = m_pNotifications->OnNodeStringPropChanged(m_pNotificationsCookie, m_strName, strName, strValue);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XN_DDK_API XnStatus XnPropertySetDestroy(XnPropertySet** ppSet)
{
XN_VALIDATE_INPUT_PTR(ppSet);
XN_VALIDATE_INPUT_PTR(*ppSet);
XnPropertySet* pSet = (*ppSet);
if (pSet->pData != NULL)
{
XnPropertySetClear(pSet);
XN_DELETE(pSet->pData);
}
xnOSFree(pSet);
*ppSet = NULL;
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnOSCloseSharedMemory(XN_SHARED_MEMORY_HANDLE hSharedMem)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(hSharedMem);
// unmap
munmap(hSharedMem->pAddress, hSharedMem->nSize);
if (hSharedMem->bCreate)
{
// remove the file
shm_unlink(hSharedMem->strFileName);
}
xnOSFree(hSharedMem);
return (XN_STATUS_OK);
}
XN_C_API void xnOSLogMemFree(const void* pMemBlock)
{
if (pMemBlock == NULL)
return;
XnMemBlockDataNode* pPrev = NULL;
XnAutoCSLocker lock(g_hCS);
XnMemBlockDataNode* pNode = g_allocatedMemory.pFirst;
while (pNode != NULL)
{
if (pNode->Data.pMemBlock == pMemBlock)
{
// found. Remove it from the list
if (pPrev == NULL) // no previous
g_allocatedMemory.pFirst = pNode->pNext;
else
pPrev->pNext = pNode->pNext;
// if it was last, update last
if (g_allocatedMemory.pLast == pNode)
g_allocatedMemory.pLast = pPrev;
xnDumpFileWriteString(g_dump, "Free,0x%x\n", pMemBlock);
// deallocate memory
xnOSFree(pNode);
return;
}
// move to next
pPrev = pNode;
pNode = pNode->pNext;
}
// if we got here then we're trying to free a non-allocated memory
XN_ASSERT(FALSE);
}
void XnDumpFileWriter::CloseFile(XnDumpWriterFileHandle hFile)
{
XN_FILE_HANDLE* phFileOS = (XN_FILE_HANDLE*)hFile.pInternal;
xnOSCloseFile(phFileOS);
xnOSFree(phFileOS);
}
XnStatus XnFileDevice::BCReadInitialState(XnPropertySet* pSet)
{
// Local function variables
XnStatus nRetVal = XN_STATUS_OK;
XnDeviceFileHeader DeviceFileHeader;
XN_STREAM_FLAGS_TYPE nStreamFlags = 0;
m_pBCData->nFramePos = 1;
m_pBCData->pPackedStreamBuffer = NULL;
m_pBCData->nPackedStreamBufferSize = 0;
// read StreamProperties
if (m_nFileVersion == 3)
{
// Current Version
nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.nMajorVersion, sizeof(XnUInt16));
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.nMinorVersion, sizeof(XnUInt16));
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.StreamProperties, sizeof(XnStreamPropertiesV3));
XN_IS_STATUS_OK(nRetVal);
DeviceFileHeader.nMajorVersion = XN_PREPARE_VAR16_IN_BUFFER(DeviceFileHeader.nMajorVersion);
DeviceFileHeader.nMinorVersion = XN_PREPARE_VAR16_IN_BUFFER(DeviceFileHeader.nMinorVersion);
nRetVal = XnIOAdjustStreamPropertiesV3(&DeviceFileHeader.StreamProperties, &DeviceFileHeader.StreamProperties);
XN_IS_STATUS_OK(nRetVal);
}
else if (m_nFileVersion == 2)
{
// Version 2
DeviceFileHeader.nMajorVersion = 0;
DeviceFileHeader.nMinorVersion = 0;
XnStreamPropertiesV2 StreamPropertiesV2;
nRetVal = m_pInputStream->ReadData((XnUChar*)&StreamPropertiesV2, sizeof(XnStreamPropertiesV2));
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnIOAdjustStreamPropertiesV2(&StreamPropertiesV2, &DeviceFileHeader.StreamProperties);
XN_IS_STATUS_OK(nRetVal);
}
else if (m_nFileVersion == 1)
{
// Version 1
DeviceFileHeader.nMajorVersion = 0;
DeviceFileHeader.nMinorVersion = 0;
XnStreamPropertiesV1 StreamPropertiesV1;
nRetVal = m_pInputStream->ReadData((XnUChar*)&StreamPropertiesV1, sizeof(XnStreamPropertiesV1));
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnIOAdjustStreamPropertiesV1(&StreamPropertiesV1, &DeviceFileHeader.StreamProperties);
XN_IS_STATUS_OK(nRetVal);
}
else
{
// Bad Magic
return XN_STATUS_IO_INVALID_STREAM_HEADER;
}
// read packed stream properties
switch (m_nFileVersion)
{
case 3:
{
nRetVal = m_pInputStream->ReadData((XnUChar*)&DeviceFileHeader.PackedStreamProperties, sizeof(XnPackedStreamProperties));
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnIOAdjustPackedStreamPropertiesV3(&DeviceFileHeader.PackedStreamProperties, &DeviceFileHeader.PackedStreamProperties);
XN_IS_STATUS_OK(nRetVal);
}
break;
case 2:
{
XnPackedStreamPropertiesV2 PackedStreamPropertiesV2;
nRetVal = m_pInputStream->ReadData((XnUChar*)&PackedStreamPropertiesV2, sizeof(XnPackedStreamPropertiesV2));
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnIOAdjustPackedStreamPropertiesV2(&PackedStreamPropertiesV2, &DeviceFileHeader.PackedStreamProperties);
XN_IS_STATUS_OK(nRetVal);
}
break;
case 1:
{
XnPackedStreamPropertiesV1 PackedStreamPropertiesV1;
nRetVal = m_pInputStream->ReadData((XnUChar*)&PackedStreamPropertiesV1, sizeof(XnPackedStreamPropertiesV1));
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnIOAdjustPackedStreamPropertiesV1(&PackedStreamPropertiesV1, &DeviceFileHeader.PackedStreamProperties);
XN_IS_STATUS_OK(nRetVal);
}
break;
default:
return XN_STATUS_IO_INVALID_STREAM_HEADER;
}
// Save the stream properties into the private data (but keep the original stream flags)
nStreamFlags = m_pBCData->StreamProperties.nStreamFlags;
xnOSMemCopy(&m_pBCData->StreamProperties, &DeviceFileHeader.StreamProperties, sizeof(XnStreamProperties));
m_pBCData->StreamProperties.nStreamFlags = nStreamFlags;
if (m_pBCData->StreamProperties.Shift2DepthData.bShift2DepthData)
{
m_pBCData->StreamProperties.Shift2DepthData.nMaxDepthValue = 10000;
m_pBCData->StreamProperties.nDepthMaxValue = 10000;
}
// Save the packed stream properties into the private data
xnOSMemCopy(&m_pBCData->PackedStreamProperties, &DeviceFileHeader.PackedStreamProperties, sizeof(XnPackedStreamProperties));
XnUInt32 nBufferSize = BCCalculatePackedBufferSize();
if (nBufferSize != m_pBCData->nPackedStreamBufferSize)
{
xnOSFree(m_pBCData->pPackedStreamBuffer);
XN_VALIDATE_ALIGNED_CALLOC(m_pBCData->pPackedStreamBuffer, XnUChar, nBufferSize, XN_DEFAULT_MEM_ALIGN);
m_pBCData->nPackedStreamBufferSize = nBufferSize;
}
nRetVal = ConvertStreamPropertiesToPropertySet(&m_pBCData->StreamProperties, &m_pBCData->PackedStreamProperties, pSet);
XN_IS_STATUS_OK(nRetVal);
// All is good...
return (XN_STATUS_OK);
}
XnVBuiltInGesture::~XnVBuiltInGesture()
{
m_GestureGenerator.UnregisterGestureCallbacks(m_hCallbacks);
xnOSFree(m_strGesturesList);
}
XN_C_API void xnUSBFreeDevicesList(const XnUSBConnectionString* astrDevicePaths)
{
xnOSFree(astrDevicePaths);
}
void Recorder::messagePump()
{
XnStatus nRetVal = XN_STATUS_OK;
Message msg = { Message::MESSAGE_NO_OPERATION, 0, NULL, {NULL}, 0, 0 };
{
xnl::LockGuard<MessageQueue> guard(m_queue);
nRetVal = m_queue.Pop(msg);
}
if (XN_STATUS_OK == nRetVal)
{
switch (msg.type)
{
case Message::MESSAGE_INITIALIZE:
{
onInitialize();
}
break;
case Message::MESSAGE_TERMINATE:
{
onTerminate();
m_running = FALSE;
}
break;
case Message::MESSAGE_ATTACH:
{
xnl::LockGuard<AttachedStreams> streamsGuard(m_streams);
AttachedStreams::Iterator i = m_streams.Find(msg.pStream);
if (i != m_streams.End())
{
onAttach(i->Value().nodeId, msg.pStream);
}
}
break;
case Message::MESSAGE_DETACH:
{
xnl::LockGuard<AttachedStreams> streamsGuard(m_streams);
AttachedStreams::Iterator i = m_streams.Find(msg.pStream);
if (i != m_streams.End())
{
onDetach(i->Value().nodeId);
XN_DELETE(m_streams[msg.pStream].pCodec);
m_streams.Remove(msg.pStream);
}
}
break;
case Message::MESSAGE_START:
{
xnl::LockGuard<AttachedStreams> streamsGuard(m_streams);
for (AttachedStreams::Iterator
i = m_streams.Begin(),
e = m_streams.End();
i != e; ++i)
{
onStart(i->Value().nodeId);
}
m_started = true;
}
break;
case Message::MESSAGE_RECORD:
{
xnl::LockGuard<AttachedStreams> streamsGuard(m_streams);
AttachedStreams::Iterator i = m_streams.Find(msg.pStream);
if (i != m_streams.End())
{
XnCodecBase* pCodec = m_streams[msg.pStream].pCodec;
XnUInt32 frameId = ++m_streams[msg.pStream].frameId;
XnUInt64 timestamp = 0;
if (frameId > 1)
{
timestamp = m_streams[msg.pStream].lastOutputTimestamp + (msg.pFrame->timestamp - m_streams[msg.pStream].lastInputTimestamp);
}
m_streams[msg.pStream].lastInputTimestamp = msg.pFrame->timestamp;
m_streams[msg.pStream].lastOutputTimestamp = timestamp;
onRecord(i->Value().nodeId, pCodec, msg.pFrame, frameId, timestamp);
msg.pStream->frameRelease(msg.pFrame);
}
}
break;
case Message::MESSAGE_RECORDPROPERTY:
{
xnl::LockGuard<AttachedStreams> streamsGuard(m_streams);
AttachedStreams::Iterator i = m_streams.Find(msg.pStream);
if (i != m_streams.End())
{
onRecordProperty(
i->Value().nodeId,
msg.propertyId,
msg.pData,
msg.dataSize);
}
// free the temporary buffer allocated earlier
xnOSFree((void*)msg.pData);
}
break;
default:
;
}
}
}
XN_C_API void xnNodeQueryFree(XnNodeQuery* pQuery)
{
xnOSFree(pQuery);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnStatus FindEntry(const XnChar* cpINIFile, const XnChar* cpSection, const XnChar* cpKey, XnChar* cpDest)
{
XnStatus nRetVal = XN_STATUS_OK;
// get file size
XnUInt32 nFileSize;
nRetVal = xnOSGetFileSize(cpINIFile, &nFileSize);
XN_IS_STATUS_OK(nRetVal);
// read entire file to memory
XnChar* csFileData = (XnChar*)xnOSMalloc(sizeof(XnChar)*nFileSize + 1);
XN_VALIDATE_ALLOC_PTR(csFileData);
nRetVal = xnOSLoadFile(cpINIFile, csFileData, nFileSize);
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(csFileData);
return nRetVal;
}
// place NULL at the end
csFileData[nFileSize] = '\0';
// now parse file
XnChar* pCurPos = csFileData;
XnBool bIsInRequestedSection = FALSE;
XnChar csTempString[XN_INI_MAX_LEN];
XnUInt32 nTempStringLength = 0;
while (TRUE)
{
// ignore spaces
while (*pCurPos && XN_IS_SPACE(pCurPos))
{
pCurPos++;
}
// check we haven't reached the end
if (!*pCurPos)
{
break;
}
if (*pCurPos == ';' || *pCurPos == '#') // comment
{
XN_SKIP_LINE(pCurPos);
continue;
}
if (*pCurPos == '[') // start of section
{
pCurPos++;
XN_READ_TILL(pCurPos, *pCurPos == ']' || XN_IS_NEWLINE(pCurPos), csTempString, nTempStringLength);
if (*pCurPos == ']') // valid section name
{
if (bIsInRequestedSection)
{
// we're leaving the requested section, and string wasn't found
xnOSFree(csFileData);
return XN_STATUS_OS_INI_READ_FAILED;
}
if (strcmp(csTempString, cpSection) == 0)
{
bIsInRequestedSection = TRUE;
}
}
// in any case, move to the next line
XN_SKIP_LINE(pCurPos);
continue;
} // section
// if we're not in the right section, we don't really care what's written in this line. Just skip it.
if (!bIsInRequestedSection)
{
XN_SKIP_LINE(pCurPos);
continue;
}
// regular line. check if this is a key (look for the '=' sign)
XN_READ_TILL(pCurPos, *pCurPos == '=' || XN_IS_NEWLINE(pCurPos), csTempString, nTempStringLength);
if (*pCurPos == '=') // we found a key
{
if (strcmp(csTempString, cpKey) == 0)
{
// we found our key. The value is the rest of the line
pCurPos++;
XN_READ_TILL(pCurPos, XN_IS_NEWLINE(pCurPos), cpDest, nTempStringLength);
xnOSFree(csFileData);
return XN_STATUS_OK;
}
}
// if we got here, skip to the next line
XN_SKIP_LINE(pCurPos);
} // while loop
xnOSFree(csFileData);
return (XN_STATUS_OS_INI_READ_FAILED);
}
XN_C_API void xnFreeLicensesList(XnLicense* aLicenses)
{
xnOSFree(aLicenses);
}
XN_C_API XnStatus xnUSBOpenDeviceImpl(libusb_device* pDevice, XN_USB_DEV_HANDLE* pDevHandlePtr)
{
XnStatus nRetVal = XN_STATUS_OK;
if (pDevice == NULL)
{
return (XN_STATUS_USB_DEVICE_NOT_FOUND);
}
// allocate device handle
libusb_device_handle* handle;
// open device
int rc = libusb_open(pDevice, &handle);
// in any case, unref the device (we don't need it anymore)
libusb_unref_device(pDevice);
pDevice = NULL;
// now check if open failed
if (rc != 0)
{
return (XN_STATUS_USB_DEVICE_OPEN_FAILED);
}
/*
// set for the first (and only) configuration (this will perform a light-weight reset)
rc = libusb_set_configuration(handle, 1);
if (rc != 0)
{
libusb_close(handle);
return (XN_STATUS_USB_SET_CONFIG_FAILED);
}
*/
// claim the interface (you cannot open any end point before claiming the interface)
rc = libusb_claim_interface(handle, 0);
if (rc != 0)
{
libusb_close(handle);
return (XN_STATUS_USB_SET_INTERFACE_FAILED);
}
/*
// set the alternate setting to default
rc = libusb_set_interface_alt_setting(handle, 0, 0);
if (rc != 0)
{
libusb_close(handle);
return (XN_STATUS_USB_SET_INTERFACE_FAILED);
}
*/
XN_VALIDATE_ALLOC(*pDevHandlePtr, XnUSBDeviceHandle);
XN_USB_DEV_HANDLE pDevHandle = *pDevHandlePtr;
pDevHandle->hDevice = handle;
pDevHandle->nInterface = 0;
pDevHandle->nAltSetting = 0;
// mark the device is of high-speed
pDevHandle->nDevSpeed = XN_USB_DEVICE_HIGH_SPEED;
nRetVal = xnUSBAsynchThreadAddRef();
if (nRetVal != XN_STATUS_OK)
{
xnOSFree(*pDevHandlePtr);
return (nRetVal);
}
return (XN_STATUS_OK);
}
XnVMessage::~XnVMessage()
{
xnOSFree(m_strType);
} // XnVMessage::~XnVMessage
static XnStatus OpenSharedMemoryImpl(const XnChar* strName, XnUInt32 nAccessFlags, XN_SHARED_MEMORY_HANDLE* phSharedMem, XnUInt32 nSize)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(strName);
XN_VALIDATE_OUTPUT_PTR(phSharedMem);
// if (nSize) is a number - create, otherwise - open
XnBool bCreate = (nSize != 0);
// convert to local OS types
int prot = 0;
int nCreateFlags = 0;
int nMode = 0;
nRetVal = AccessFlagsToMMapProt(nAccessFlags, &prot);
XN_IS_STATUS_OK(nRetVal);
nRetVal = AccessFlagsToOpenFlags(nAccessFlags, &nCreateFlags);
XN_IS_STATUS_OK(nRetVal);
// allocate handle
XnOSSharedMemory* pHandle;
XN_VALIDATE_CALLOC(pHandle, XnOSSharedMemory, 1);
pHandle->bCreate = bCreate;
NameToFileName(strName, pHandle->strFileName);
if (bCreate)
{
nCreateFlags |= O_CREAT;
nMode |= S_IRWXU | S_IRWXG | S_IRWXO;
}
// open file
int fd = shm_open(pHandle->strFileName, nCreateFlags, nMode);
if (fd == -1)
{
xnOSFree(pHandle);
XN_LOG_WARNING_RETURN(XN_STATUS_OS_FAILED_TO_CREATE_SHARED_MEMORY, XN_MASK_OS, "Could not create file '%s' for shared memory (%d).", pHandle->strFileName, errno);
}
if (bCreate)
{
// set it to the right size
if (-1 == ftruncate(fd, nSize))
{
close(fd);
shm_unlink(pHandle->strFileName);
xnOSFree(pHandle);
XN_LOG_WARNING_RETURN(XN_STATUS_OS_FAILED_TO_CREATE_SHARED_MEMORY, XN_MASK_OS, "Could not seek to position (%d).", pHandle->strFileName, errno);
}
pHandle->nSize = nSize;
}
else
{
// read shared object size
pHandle->nSize = lseek(fd, 0, SEEK_END);
}
// and map it
pHandle->pAddress = mmap(NULL, pHandle->nSize, prot, MAP_SHARED, fd, 0);
if (pHandle->pAddress == MAP_FAILED)
{
close(fd);
shm_unlink(pHandle->strFileName);
xnOSFree(pHandle);
XN_LOG_WARNING_RETURN(XN_STATUS_OS_FAILED_TO_CREATE_SHARED_MEMORY, XN_MASK_OS, "Could not create file mapping object (%d).", errno);
}
close(fd);
*phSharedMem = pHandle;
return (XN_STATUS_OK);
}
Link24zYuv422Parser::~Link24zYuv422Parser()
{
xnOSFree(m_dataFromPrevPacket);
xnOSFree(m_tempYuvImage);
}
