XnStatus PlayerNode::HandleDataIndexRecord(DataIndexRecordHeader record, XnBool bReadPayload)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(m_pNodeNotifications);
nRetVal = record.Decode();
XN_IS_STATUS_OK(nRetVal);
DEBUG_LOG_RECORD(record, "DataIndex");
XN_ASSERT(record.GetNodeID() != INVALID_NODE_ID);
PlayerNodeInfo* pPlayerNodeInfo = GetPlayerNodeInfo(record.GetNodeID());
XN_VALIDATE_PTR(pPlayerNodeInfo, XN_STATUS_CORRUPT_FILE);
XnUInt32 nRecordTotalSize = record.GetSize() + record.GetPayloadSize();
if (nRecordTotalSize > RECORD_MAX_SIZE)
{
XN_ASSERT(FALSE);
XN_LOG_ERROR_RETURN(XN_STATUS_INTERNAL_BUFFER_TOO_SMALL, XN_MASK_OPEN_NI, "Record size %u is larger than player internal buffer", nRecordTotalSize);
}
if (bReadPayload)
{
// make sure node exists
if (!pPlayerNodeInfo->bValid)
{
XN_ASSERT(FALSE);
return XN_STATUS_CORRUPT_FILE;
}
if (record.GetPayloadSize() != (pPlayerNodeInfo->nFrames+1) * sizeof(DataIndexEntry))
{
XN_ASSERT(FALSE);
XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Seek table has %u entries, but node has %u frames!", record.GetPayloadSize() / sizeof(DataIndexEntry), pPlayerNodeInfo->nFrames);
}
// allocate our data index
pPlayerNodeInfo->pDataIndex = (DataIndexEntry*)xnOSCalloc(pPlayerNodeInfo->nFrames+1, sizeof(DataIndexEntry));
XN_VALIDATE_ALLOC_PTR(pPlayerNodeInfo->pDataIndex);
//Now read the actual data
XnUInt32 nBytesRead = 0;
nRetVal = Read(pPlayerNodeInfo->pDataIndex, record.GetPayloadSize(), nBytesRead);
XN_IS_STATUS_OK(nRetVal);
if (nBytesRead < record.GetPayloadSize())
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Not enough bytes read");
}
}
else
{
//Just skip the data
nRetVal = SkipRecordPayload(record);
XN_IS_STATUS_OK(nRetVal);
}
return XN_STATUS_OK;
}
static XnBool xnIsMapOutputModeSupported(XnNodeHandle hNode, const XnMapOutputMode* pQuery)
{
XnUInt32 nModes = xnGetSupportedMapOutputModesCount(hNode);
if (nModes == 0)
{
return (FALSE);
}
XnMapOutputMode* aModes = (XnMapOutputMode*)xnOSCalloc(nModes, sizeof(XnMapOutputMode));
if (aModes == NULL)
{
return (FALSE);
}
if (XN_STATUS_OK != xnGetSupportedMapOutputModes(hNode, aModes, &nModes))
{
xnOSFree(aModes);
return (FALSE);
}
for (XnUInt i = 0; i < nModes; ++i)
{
if (pQuery->nXRes != (XnUInt32)(-1) && pQuery->nXRes == aModes[i].nXRes &&
pQuery->nYRes != (XnUInt32)(-1) && pQuery->nYRes == aModes[i].nYRes &&
pQuery->nFPS != (XnUInt32)(-1) && pQuery->nFPS == aModes[i].nFPS)
{
xnOSFree(aModes);
return (TRUE);
}
}
xnOSFree(aModes);
return (FALSE);
}
//---------------------------------------------------------------------------
// 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);
}
XnVMessageListener::XnVMessageListener(const XnChar* strName) :
m_bInternalThreadAlive(false),
m_bInternalThreadKill(false),
m_bThreadProtectionQueueMode(false)
{
xnLogVerbose(XNV_NITE_MASK_CREATE, "Listener %s [0x%08x]: Create", strName, this);
xnOSCreateCriticalSection(&m_hListenerCS);
SetCurrentThread();
m_bThreadProtectionQueueMode = false;
m_strListenerName = (XnChar*)xnOSCalloc(strlen(strName)+1, sizeof(XnChar));
if (m_strListenerName != NULL)
{
xnOSStrCopy(m_strListenerName, strName, strlen(strName)+1);
}
m_pMessageQueue = XN_NEW(XnVMessageQueue);
m_pMessageQueue->Init();
m_pUpdateCBs = XN_NEW(XnVMessageSpecificEvent);
m_pActivateCBs = XN_NEW(XnVEvent);
m_pDeactivateCBs = XN_NEW(XnVEvent);
} // XnVMessageListener::XnVMessageListener
XN_C_API XnSceneMetaData* xnAllocateSceneMetaData()
{
XnSceneMetaData* pResult = (XnSceneMetaData*)xnOSCalloc(1, sizeof(XnSceneMetaData));
if (pResult == NULL)
{
return (NULL);
}
pResult->pMap = xnAllocateMapMetaData();
if (pResult->pMap == NULL)
{
xnFreeSceneMetaData(pResult);
return (NULL);
}
return (pResult);
}
XN_C_API XnAudioMetaData* xnAllocateAudioMetaData()
{
XnAudioMetaData* pResult = (XnAudioMetaData*)xnOSCalloc(1, sizeof(XnAudioMetaData));
if (pResult == NULL)
{
return (NULL);
}
pResult->pOutput = xnAllocateOutputMetaData();
if (pResult->pOutput == NULL)
{
xnFreeAudioMetaData(pResult);
return (NULL);
}
return (pResult);
}
XN_C_API XnStatus xnUSBEnumerateDevices(XnUInt16 nVendorID, XnUInt16 nProductID, const XnUSBConnectionString** pastrDevicePaths, XnUInt32* pnCount)
{
// get device list
libusb_device** ppDevices;
ssize_t nDeviceCount = libusb_get_device_list(g_InitData.pContext, &ppDevices);
// first enumeration - count
XnUInt32 nCount = 0;
for (ssize_t i = 0; i < nDeviceCount; ++i)
{
libusb_device* pDevice = ppDevices[i];
// get device descriptor
libusb_device_descriptor desc;
int rc = libusb_get_device_descriptor(pDevice, &desc);
if (rc != 0)
{
libusb_free_device_list(ppDevices, 1);
return (XN_STATUS_USB_ENUMERATE_FAILED);
}
// check if this is the requested device
if (desc.idVendor == nVendorID && desc.idProduct == nProductID)
{
++nCount;
}
}
// allocate array
XnUSBConnectionString* aResult = (XnUSBConnectionString*)xnOSCalloc(nCount, sizeof(XnUSBConnectionString));
if (aResult == NULL)
{
libusb_free_device_list(ppDevices, 1);
return XN_STATUS_ALLOC_FAILED;
}
// second enumeration - fill
XnUInt32 nCurrent = 0;
for (ssize_t i = 0; i < nDeviceCount; ++i)
{
libusb_device* pDevice = ppDevices[i];
// get device descriptor
libusb_device_descriptor desc;
int rc = libusb_get_device_descriptor(pDevice, &desc);
if (rc != 0)
{
libusb_free_device_list(ppDevices, 1);
return (XN_STATUS_USB_ENUMERATE_FAILED);
}
// check if this is the requested device
if (desc.idVendor == nVendorID && desc.idProduct == nProductID)
{
sprintf(aResult[nCurrent], "%04hx/%04hx@%hhu/%hhu", nVendorID, nProductID, libusb_get_bus_number(pDevice), libusb_get_device_address(pDevice));
nCurrent++;
}
}
*pastrDevicePaths = aResult;
*pnCount = nCount;
// free the list (also dereference each device)
libusb_free_device_list(ppDevices, 1);
return XN_STATUS_OK;
}
XnVMessage::XnVMessage(const XnChar* strType, void* pData) :
m_pData(pData), m_bFreeOnDestruction(false)
{
m_strType = (XnChar*)xnOSCalloc(strlen(strType)+1, sizeof(XnChar));
xnOSStrCopy(m_strType, strType, strlen(strType)+1);
} // XnVMessage::XnVMessage
XN_C_API XnOutputMetaData* xnAllocateOutputMetaData()
{
return (XnOutputMetaData*)xnOSCalloc(1, sizeof(XnOutputMetaData));
}