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;
}
XN_C_API XnStatus xnOSCreateSharedMemory(const XnChar* strName, XnUInt32 nSize, XnUInt32 nAccessFlags, XN_SHARED_MEMORY_HANDLE* phSharedMem)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(strName);
XN_VALIDATE_OUTPUT_PTR(phSharedMem);
DWORD mapflags;
nRetVal = AccessFlagsToWin32MapFlags(nAccessFlags, &mapflags);
XN_IS_STATUS_OK(nRetVal);
DWORD viewflags;
nRetVal = AccessFlagsToWin32ViewFlags(nAccessFlags, &viewflags);
XN_IS_STATUS_OK(nRetVal);
XnChar strWinName[XN_FILE_MAX_PATH];
nRetVal = NameToWin32Name(strName, strWinName);
XN_IS_STATUS_OK(nRetVal);
// allocate handle
XnOSSharedMemory* pHandle;
XN_VALIDATE_CALLOC(pHandle, XnOSSharedMemory, 1);
// create file mapping
pHandle->hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE, // use paging file
NULL, // default security
mapflags, // read/write access
0, // max. object size
nSize, // buffer size
strWinName); // name of mapping object
if (pHandle->hMapFile == NULL)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_FAILED_TO_CREATE_SHARED_MEMORY, XN_MASK_OS, "Could not create file mapping object (%d).", GetLastError());
}
// map it to the process
pHandle->pAddress = MapViewOfFile(
pHandle->hMapFile, // handle to map object
viewflags, // read/write permission
0,
0,
nSize);
if (pHandle->pAddress == NULL)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_FAILED_TO_CREATE_SHARED_MEMORY, XN_MASK_OS, "Could not map view of file (%d).", GetLastError());
}
*phSharedMem = pHandle;
return (XN_STATUS_OK);
}
XN_C_API XnStatus XN_C_DECL xnOSOpenSharedMemoryEx(const XnChar* strName, XnUInt32 nAccessFlags, XnBool bAllowOtherUsers, XN_SHARED_MEMORY_HANDLE* phSharedMem)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(strName);
XN_VALIDATE_OUTPUT_PTR(phSharedMem);
DWORD flags;
nRetVal = AccessFlagsToWin32ViewFlags(nAccessFlags, &flags);
XN_IS_STATUS_OK(nRetVal);
XnChar strWinName[XN_FILE_MAX_PATH];
nRetVal = XnWin32CreateKernelObjectName(strWinName, MAX_PATH, strName, bAllowOtherUsers);
if (nRetVal != XN_STATUS_OK)
{
return XN_STATUS_OS_FAILED_TO_OPEN_SHARED_MEMORY;
}
// allocate handle
XnOSSharedMemory* pHandle;
XN_VALIDATE_CALLOC(pHandle, XnOSSharedMemory, 1);
// create file mapping
pHandle->hMapFile = OpenFileMapping(
flags, // read/write access
FALSE, // do not inherit the name
strWinName); // name of mapping object
if (pHandle->hMapFile == NULL)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_FAILED_TO_OPEN_SHARED_MEMORY, XN_MASK_OS, "Could not open file mapping object (%d).", GetLastError());
}
// map it to the process
pHandle->pAddress = MapViewOfFile(
pHandle->hMapFile, // handle to map object
flags, // read/write permission
0,
0,
0);
if (pHandle->pAddress == NULL)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_FAILED_TO_OPEN_SHARED_MEMORY, XN_MASK_OS, "Could not map view of file (%d).", GetLastError());
}
*phSharedMem = pHandle;
return (XN_STATUS_OK);
}
XnStatus PlayerNode::OpenStream()
{
XN_VALIDATE_INPUT_PTR(m_pInputStream);
XnStatus nRetVal = m_pInputStream->Open(m_pStreamCookie);
XN_IS_STATUS_OK(nRetVal);
RecordingHeader header;
XnUInt32 nBytesRead = 0;
nRetVal = m_pInputStream->Read(m_pStreamCookie, &header, sizeof(header), &nBytesRead);
XN_IS_STATUS_OK(nRetVal);
if (nBytesRead < sizeof(header))
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Not enough bytes read");
}
/* Check header */
if (xnOSMemCmp(header.headerMagic, DEFAULT_RECORDING_HEADER.headerMagic, sizeof(header.headerMagic)) != 0)
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Invalid header magic");
}
if ((xnVersionCompare(&header.version, &OLDEST_SUPPORTED_FILE_FORMAT_VERSION) < 0) || //File format is too old
(xnVersionCompare(&header.version, &DEFAULT_RECORDING_HEADER.version) > 0)) //File format is too new
{
XN_LOG_ERROR_RETURN(XN_STATUS_UNSUPPORTED_VERSION, XN_MASK_OPEN_NI, "Unsupported file format version: %u.%u.%u.%u", header.version.nMajor, header.version.nMinor, header.version.nMaintenance, header.version.nBuild);
}
m_nGlobalMaxTimeStamp = header.nGlobalMaxTimeStamp;
m_nMaxNodes = header.nMaxNodeID + 1;
XN_ASSERT(m_nMaxNodes > 0);
XN_DELETE_ARR(m_pNodeInfoMap);
xnOSFree(m_aSeekTempArray);
m_pNodeInfoMap = XN_NEW_ARR(PlayerNodeInfo, m_nMaxNodes);
XN_VALIDATE_ALLOC_PTR(m_pNodeInfoMap);
XN_VALIDATE_CALLOC(m_aSeekTempArray, DataIndexEntry*, m_nMaxNodes);
m_bOpen = TRUE;
nRetVal = ProcessUntilFirstData();
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE_ARR(m_pNodeInfoMap);
m_pNodeInfoMap = NULL;
xnOSFree(m_aSeekTempArray);
m_aSeekTempArray = NULL;
return nRetVal;
}
return XN_STATUS_OK;
}
XnStatus PlayerNode::ReadRecordHeader(Record &record)
{
XnUInt32 nBytesRead = 0;
XnStatus nRetVal = Read(record.GetData(), Record::HEADER_SIZE, nBytesRead);
if (nBytesRead != Record::HEADER_SIZE)
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Incorrect number of bytes read");
}
if (!record.IsHeaderValid())
{
XN_ASSERT(FALSE);
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Invalid record header");
}
return XN_STATUS_OK;
}
XnStatus xnConfigureRecorderDestination(XnNodeHandle hNode, const TiXmlElement* pOpcode)
{
XnStatus nRetVal = XN_STATUS_OK;
XnRecordMedium medium = XN_RECORD_MEDIUM_FILE; // default
if (pOpcode->Attribute("medium") != NULL)
{
const XnChar* strMedium;
nRetVal = xnXmlReadStringAttribute(pOpcode, "medium", &strMedium);
XN_IS_STATUS_OK(nRetVal);
if (strcmp(strMedium, "File") == 0)
{
medium = XN_RECORD_MEDIUM_FILE;
}
else
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Unknown recording medium: '%s'", strMedium);
}
}
const XnChar* strName;
nRetVal = xnXmlReadStringAttribute(pOpcode, "name", &strName);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnSetRecorderDestination(hNode, XN_RECORD_MEDIUM_FILE, strName);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus xnConfigureAddNodeToRecording(XnNodeHandle hNode, const TiXmlElement* pOpcode)
{
XnStatus nRetVal = XN_STATUS_OK;
const XnChar* strName;
nRetVal = xnXmlReadStringAttribute(pOpcode, "name", &strName);
XN_IS_STATUS_OK(nRetVal);
const XnChar* strCodec;
nRetVal = xnXmlReadStringAttribute(pOpcode, "codec", &strCodec);
XN_IS_STATUS_OK(nRetVal);
// find node
XnContext* pContext = hNode->pContext;
XnNodeHandle hOther = NULL;
nRetVal = xnGetRefNodeHandleByName(pContext, strName, &hOther);
XN_IS_STATUS_OK(nRetVal);
// find codec
if (strlen(strCodec) != sizeof(XnCodecID))
{
xnProductionNodeRelease(hOther);
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "'%s' is not a valid codec ID!", strCodec);
}
XnCodecID codecID;
xnOSMemCopy(&codecID, strCodec, sizeof(codecID));
nRetVal = xnAddNodeToRecording(hNode, hOther, codecID);
xnProductionNodeRelease(hOther);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceFileReader::ReadFileVersion()
{
XnStatus nRetVal = XN_STATUS_OK;
// read magic from file
XnChar csFileMagic[XN_DEVICE_FILE_MAGIC_LEN];
nRetVal = GetIOStream()->ReadData((XnUChar*)csFileMagic, XN_DEVICE_FILE_MAGIC_LEN);
XN_IS_STATUS_OK(nRetVal);
if (strncmp(csFileMagic, XN_DEVICE_FILE_MAGIC_V4, XN_DEVICE_FILE_MAGIC_LEN) == 0)
{
m_nFileVersion = 4;
}
else if (strncmp(csFileMagic, XN_DEVICE_FILE_MAGIC_V3, XN_DEVICE_FILE_MAGIC_LEN) == 0)
{
m_nFileVersion = 3;
}
else if (strncmp(csFileMagic, XN_DEVICE_FILE_MAGIC_V2, XN_DEVICE_FILE_MAGIC_LEN) == 0)
{
m_nFileVersion = 2;
}
else if (strncmp(csFileMagic, XN_DEVICE_FILE_MAGIC_V1, XN_DEVICE_FILE_MAGIC_LEN) == 0)
{
m_nFileVersion = 1;
}
else
{
XN_LOG_ERROR_RETURN(XN_STATUS_DEVICE_FILE_CORRUPTED, XN_MASK_FILE, "Invalid file magic!");
}
return (XN_STATUS_OK);
}
XnStatus TypeManager::RegisterNewType(const XnChar* strName, XnProductionNodeType baseType, XnProductionNodeType* pNewType)
{
XnStatus nRetVal = XN_STATUS_OK;
// we only need to lock when adding a new type
XnAutoCSLocker locker(m_hLock);
// check if type is already registered
XnProductionNodeType type;
if (XN_STATUS_OK == GetTypeByName(strName, &type))
{
*pNewType = type;
}
else
{
if (m_nNextExtendedNodeType >= XN_MAX_TYPES_COUNT)
{
XN_LOG_ERROR_RETURN(XN_STATUS_ERROR, XN_MASK_OPEN_NI, "OpenNI does not support more than %u types!", XN_MAX_TYPES_COUNT);
}
// add the new type
nRetVal = AddNewType(strName, m_nNextExtendedNodeType, baseType);
XN_IS_STATUS_OK(nRetVal);
// take its type id
*pNewType = m_nNextExtendedNodeType;
// increment max type id
++m_nNextExtendedNodeType;
}
return (XN_STATUS_OK);
}
XnStatus PlayerNode::HandleRecord(Record &record, XnBool bHandlePayload)
{
XN_ASSERT(record.IsHeaderValid());
switch (record.GetType())
{
case RECORD_NODE_ADDED:
return HandleNodeAddedRecord(record);
case RECORD_INT_PROPERTY:
return HandleIntPropRecord(record);
case RECORD_REAL_PROPERTY:
return HandleRealPropRecord(record);
case RECORD_STRING_PROPERTY:
return HandleStringPropRecord(record);
case RECORD_GENERAL_PROPERTY:
return HandleGeneralPropRecord(record);
case RECORD_NODE_REMOVED:
return HandleNodeRemovedRecord(record);
case RECORD_NODE_STATE_READY:
return HandleNodeStateReadyRecord(record);
case RECORD_NODE_DATA_BEGIN:
return HandleNodeDataBeginRecord(record);
case RECORD_NEW_DATA:
return HandleNewDataRecord(record, bHandlePayload);
case RECORD_END:
return HandleEndRecord(record);
// BC stuff
case RECORD_NODE_ADDED_1_0_0_4:
return HandleNodeAdded_1_0_0_4_Record(record);
default:
XN_ASSERT(FALSE);
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Unrecognized record type: %u", record.GetType());
}
}
XN_C_API XnStatus xnOSReceiveNetworkBuffer(XN_SOCKET_HANDLE Socket, XnChar* cpBuffer, XnUInt32* pnBufferSize, XnUInt32 nMillisecondsTimeout)
{
// Local function variables
XnInt32 nRetVal = 0;
struct timeval selectTimeOut;
struct timeval* pTimeout = xnOSMillisecsToTimeVal(nMillisecondsTimeout, &selectTimeOut);
fd_set fdReadHandles;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(Socket);
XN_VALIDATE_OUTPUT_PTR(cpBuffer);
XN_VALIDATE_OUTPUT_PTR(pnBufferSize);
// Make sure the actual socket handle isn't NULL
XN_RET_IF_NULL(Socket->Socket, XN_STATUS_OS_INVALID_SOCKET);
XN_PRAGMA_START_DISABLED_WARNING_SECTION(XN_CONDITION_IS_CONST_WARNING_ID);
FD_ZERO(&fdReadHandles);
FD_SET(Socket->Socket, &fdReadHandles);
XN_PRAGMA_STOP_DISABLED_WARNING_SECTION;
nRetVal = select(1 /* ignored */, &fdReadHandles, NULL, NULL, pTimeout);
if (nRetVal == 0)
{
return (XN_STATUS_OS_NETWORK_TIMEOUT);
}
else if (nRetVal != 1)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_NETWORK_RECEIVE_FAILED, XN_MASK_OS, "select() failed with winsock error %d", WSAGetLastError());
}
// Receive the data from our socket to the buffer and make sure it succeeded
*pnBufferSize = recv(Socket->Socket, cpBuffer, *pnBufferSize, 0);
if (*pnBufferSize == 0)
{
xnLogVerbose(XN_MASK_OS, "Socket has been gracefully closed");
return (XN_STATUS_OS_NETWORK_CONNECTION_CLOSED);
}
else if (*pnBufferSize == SOCKET_ERROR)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_NETWORK_RECEIVE_FAILED, XN_MASK_OS, "recv() failed with winsock error %d", WSAGetLastError());
}
// All is good...
return (XN_STATUS_OK);
}
XnStatus xnConfigureProperty(XnNodeHandle hNode, const TiXmlElement* pOpcode)
{
XnStatus nRetVal = XN_STATUS_OK;
const XnChar* strName;
nRetVal = xnXmlReadStringAttribute(pOpcode, "name", &strName);
XN_IS_STATUS_OK(nRetVal);
const XnChar* strType;
nRetVal = xnXmlReadStringAttribute(pOpcode, "type", &strType);
XN_IS_STATUS_OK(nRetVal);
if (strcmp(strType, "int") == 0)
{
XnInt nValue;
nRetVal = xnXmlReadIntAttribute(pOpcode, "value", &nValue);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnSetIntProperty(hNode, strName, nValue);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_OPEN_NI, "Failed to set property '%s' from xml: %s", strName, xnGetStatusString(nRetVal));
return nRetVal;
}
}
else if (strcmp(strType, "real") == 0)
{
XnDouble dValue;
nRetVal = xnXmlReadRealAttribute(pOpcode, "value", &dValue);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnSetRealProperty(hNode, strName, dValue);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_OPEN_NI, "Failed to set property '%s' from xml: %s", strName, xnGetStatusString(nRetVal));
return nRetVal;
}
}
else if (strcmp(strType, "string") == 0)
{
const XnChar* strValue;
nRetVal = xnXmlReadStringAttribute(pOpcode, "value", &strValue);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnSetStringProperty(hNode, strName, strValue);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_OPEN_NI, "Failed to set property '%s' from xml: %s", strName, xnGetStatusString(nRetVal));
return nRetVal;
}
}
else
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Invalid property type: %s", strType);
}
return (XN_STATUS_OK);
}
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);
}
XnStatus PlayerNode::Read(void *pData, XnUInt32 nSize, XnUInt32 &nBytesRead)
{
XN_VALIDATE_INPUT_PTR(m_pInputStream);
if (!m_bOpen)
{
XN_LOG_ERROR_RETURN(XN_STATUS_INVALID_OPERATION, XN_MASK_OPEN_NI, "Stream was not opened");
}
return m_pInputStream->Read(m_pStreamCookie, pData, nSize, &nBytesRead);
}
XnStatus MockDepthGenerator::SetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer)
{
XN_VALIDATE_INPUT_PTR(strName);
XN_VALIDATE_INPUT_PTR(pBuffer);
XnStatus nRetVal = XN_STATUS_OK;
if (strcmp(strName, XN_PROP_FIELD_OF_VIEW) == 0)
{
if (nBufferSize != sizeof(XnFieldOfView))
{
XN_LOG_ERROR_RETURN(XN_STATUS_INVALID_BUFFER_SIZE, XN_MASK_OPEN_NI, "Cannot set XN_PROP_FIELD_OF_VIEW - buffer size is incorrect");
}
const XnFieldOfView* pFOV = (const XnFieldOfView*)pBuffer;
nRetVal = SetFieldOfView(*pFOV);
XN_IS_STATUS_OK(nRetVal);
}
else if (strcmp(strName, XN_PROP_USER_POSITIONS) == 0)
{
if (m_bSupportedUserPositionsCountReceived)
{
m_bSupportedUserPositionsCountReceived = FALSE;
if (nBufferSize != m_nSupportedUserPositionsCount * sizeof(XnBoundingBox3D))
{
XN_LOG_ERROR_RETURN(XN_STATUS_INVALID_BUFFER_SIZE, XN_MASK_OPEN_NI, "Cannot set XN_PROP_USER_POSITIONS - buffer size is incorrect");
}
XN_DELETE_ARR(m_pUserPositions);
m_pUserPositions = XN_NEW_ARR(XnBoundingBox3D, m_nSupportedUserPositionsCount);
XN_VALIDATE_ALLOC_PTR(m_pUserPositions);
xnOSMemCopy(m_pUserPositions, pBuffer, nBufferSize);
}
else
{
/*We got XN_PROP_USER_POSITIONS without
XN_PROP_SUPPORTED_USER_POSITIONS_COUNT before it - that's an error*/
XN_ASSERT(FALSE);
XN_LOG_ERROR_RETURN(XN_STATUS_ERROR, XN_MASK_OPEN_NI, "got XN_PROP_USER_POSITIONS without XN_PROP_SUPPORTED_USER_POSITIONS_COUNT before it.")
}
}
else
{
XnStatus XnXmlScriptNode::LoadScriptFromString(const XnChar* strScript)
{
if (!m_doc.Parse(strScript))
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI,
"Failed loading xml: %s [row %d, column %d]",
m_doc.ErrorDesc(), m_doc.ErrorRow(), m_doc.ErrorCol());
}
return XN_STATUS_OK;
}
XnStatus xnReadVersionFromXml(const TiXmlElement* pElem, XnVersion* pVersion)
{
if (!xnReadVersionFromString(pElem->GetText(), pVersion))
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI,
"Invalid '%s' xml entry - version string is not legal (line %u, col %u)!",
pElem->Value(), pElem->Row(), pElem->Column());
}
return (XN_STATUS_OK);
}
XnStatus PlayerNode::SeekToFrame(const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUInt32 nNodeID = GetPlayerNodeIDByName(strNodeName);
if (nNodeID == INVALID_NODE_ID)
{
XN_LOG_ERROR_RETURN(XN_STATUS_BAD_NODE_NAME, XN_MASK_OPEN_NI, "Bad node name '%s'", strNodeName);
}
PlayerNodeInfo* pPlayerNodeInfo = &m_pNodeInfoMap[nNodeID];
XnInt64 nOriginFrame = 0;
switch (origin)
{
case XN_PLAYER_SEEK_SET:
{
nOriginFrame = 0;
break;
}
case XN_PLAYER_SEEK_CUR:
{
nOriginFrame = pPlayerNodeInfo->nCurFrame;
break;
}
case XN_PLAYER_SEEK_END:
{
nOriginFrame = pPlayerNodeInfo->nFrames;
break;
}
default:
{
XN_ASSERT(FALSE);
XN_LOG_ERROR_RETURN(XN_STATUS_BAD_PARAM, XN_MASK_OPEN_NI, "Invalid seek origin: %u", origin);
}
}
XnUInt32 nDestFrame = (XnUInt32)XN_MIN(XN_MAX(1, nOriginFrame + nFrameOffset), pPlayerNodeInfo->nFrames);
nRetVal = SeekToFrameAbsolute(nNodeID, nDestFrame);
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
XnStatus Record::StartWrite(XnUInt32 nRecordType)
{
XN_VALIDATE_INPUT_PTR(m_pData);
if (m_nMaxSize < HEADER_SIZE)
{
XN_LOG_ERROR_RETURN(XN_STATUS_INPUT_BUFFER_OVERFLOW, XN_MASK_OPEN_NI, "Record buffer too small");
}
m_pHeader->m_nMagic = MAGIC;
m_pHeader->m_nRecordType = nRecordType;
m_pHeader->m_nFieldsSize = HEADER_SIZE;
return XN_STATUS_OK;
}
XnStatus PlayerNode::ReadRecordFields(Record &record)
{
XnUInt32 nBytesToRead = record.GetSize() - Record::HEADER_SIZE;
XnUInt32 nBytesRead = 0;
XnStatus nRetVal = Read(record.GetData() + Record::HEADER_SIZE, nBytesToRead, nBytesRead);
XN_IS_STATUS_OK(nRetVal);
if (nBytesRead < nBytesToRead)
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Incorrect number of bytes read");
}
return XN_STATUS_OK;
}
XnStatus Record::Read(void* pDest, XnUInt32 nSize) const
{
XN_VALIDATE_OUTPUT_PTR(pDest);
if (m_nReadOffset + nSize > m_nMaxSize)
{
XN_LOG_ERROR_RETURN(XN_STATUS_INPUT_BUFFER_OVERFLOW, XN_MASK_OPEN_NI, "Record buffer too small");
}
xnOSMemCopy(pDest, m_pData + m_nReadOffset, nSize);
m_nReadOffset += nSize;
return XN_STATUS_OK;
}
XnStatus MapWatcher::NotifyOutputMode()
{
XnMapOutputMode outputMode;
XnStatus nRetVal = m_mapGenerator.GetMapOutputMode(outputMode);
if (nRetVal != XN_STATUS_OK)
{
XN_LOG_ERROR_RETURN(nRetVal, XN_MASK_OPEN_NI, "Failed to get map output mode: %s", xnGetStatusString(nRetVal));
}
nRetVal = NotifyGeneralPropChanged(XN_PROP_MAP_OUTPUT_MODE, sizeof(outputMode), &outputMode);
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
XnStatus XnSensorDepthStream::DecideFirmwareRegistration(XnBool bRegistration, XnProcessingType registrationType, XnResolutions nRes)
{
XnStatus nRetVal = XN_STATUS_OK;
// start with request
XnBool bFirmwareRegistration = bRegistration;
if (bFirmwareRegistration)
{
// old chip (PS1000) does not support registration for VGA
XnBool bHardwareRegistrationSupported =
m_Helper.GetPrivateData()->ChipInfo.nChipVer != XN_SENSOR_CHIP_VER_PS1000 || nRes == XN_RESOLUTION_QVGA;
switch (registrationType)
{
case XN_PROCESSING_HARDWARE:
if (!bHardwareRegistrationSupported)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Sensor does not support hardware registration for current configuration!");
}
break;
case XN_PROCESSING_SOFTWARE:
if (GetResolution() != XN_RESOLUTION_VGA)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Software registration is only supported for VGA resolution!");
}
bFirmwareRegistration = FALSE;
break;
case XN_PROCESSING_DONT_CARE:
bFirmwareRegistration = bHardwareRegistrationSupported;
break;
default:
XN_LOG_ERROR_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Unknown registration type: %d", registrationType);
}
}
if (bRegistration && !bFirmwareRegistration)
{
// make sure software registration is initialized
if (!m_Registration.IsInitialized())
{
nRetVal = m_Registration.Init(m_Helper.GetPrivateData(), this, GetDepthToShiftTable());
XN_IS_STATUS_OK(nRetVal);
}
}
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareRegistration, (XnUInt16)bFirmwareRegistration);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnContextRunXmlScript(XnContext* pContext, const XnChar* xmlScript, XnEnumerationErrors* pErrors)
{
XnStatus nRetVal = XN_STATUS_OK;
TiXmlDocument doc;
if (!doc.Parse(xmlScript))
{
XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI,
"Failed loading xml: %s [row %d, column %d]",
doc.ErrorDesc(), doc.ErrorRow(), doc.ErrorCol());
}
return RunXmlScriptImpl(pContext, &doc, pErrors);
}
XnStatus XnDeviceFileReader::HandleEndOfStream()
{
XnStatus nRetVal = XN_STATUS_OK;
if (!m_bFileHasData)
{
XN_LOG_ERROR_RETURN(XN_STATUS_DEVICE_FILE_CORRUPTED, XN_MASK_FILE, "File does not contain any data...");
}
nRetVal = Rewind();
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus Record::Write(const void* pData, XnUInt32 nSize)
{
XN_VALIDATE_INPUT_PTR(pData);
XnUInt32 nNewSize = m_pHeader->m_nFieldsSize + nSize;
if (nNewSize > m_nMaxSize)
{
XN_LOG_ERROR_RETURN(XN_STATUS_INPUT_BUFFER_OVERFLOW, XN_MASK_OPEN_NI, "Record buffer too small");
}
xnOSMemCopy(m_pData + m_pHeader->m_nFieldsSize, pData, nSize);
m_pHeader->m_nFieldsSize = nNewSize;
return XN_STATUS_OK;
}
XN_C_API XnStatus xnOSAcceptSocket(XN_SOCKET_HANDLE ListenSocket, XN_SOCKET_HANDLE* AcceptSocketPtr, XnUInt32 nMillisecondsTimeout)
{
// Local function variables
XnInt32 nRetVal = 0;
struct timeval selectTimeOut;
struct timeval* pTimeout = xnOSMillisecsToTimeVal(nMillisecondsTimeout, &selectTimeOut);
fd_set fdReadHandles;
XN_SOCKET_HANDLE AcceptSocket = NULL;
// Validate the input/output pointers (to make sure none of them is NULL)
XN_VALIDATE_INPUT_PTR(ListenSocket);
XN_VALIDATE_OUTPUT_PTR(AcceptSocketPtr);
// Make sure the actual socket handle isn't NULL
XN_RET_IF_NULL(ListenSocket->Socket, XN_STATUS_OS_INVALID_SOCKET);
// Wait for connection request
XN_PRAGMA_START_DISABLED_WARNING_SECTION(XN_CONDITION_IS_CONST_WARNING_ID);
FD_ZERO(&fdReadHandles);
FD_SET(ListenSocket->Socket, &fdReadHandles);
XN_PRAGMA_STOP_DISABLED_WARNING_SECTION;
nRetVal = select(1 /* ignored */, &fdReadHandles, NULL, NULL, pTimeout);
if (nRetVal == 0)
{
return (XN_STATUS_OS_NETWORK_TIMEOUT);
}
else if (nRetVal == SOCKET_ERROR)
{
XN_LOG_ERROR_RETURN(XN_STATUS_OS_NETWORK_SOCKET_ACCEPT_FAILED, XN_MASK_OS, "select() returned WinSock error: %d", WSAGetLastError());
}
// Allocate a new socket
XN_VALIDATE_ALIGNED_CALLOC(*AcceptSocketPtr, xnOSSocket, 1, XN_DEFAULT_MEM_ALIGN);
AcceptSocket = *AcceptSocketPtr;
// Accept the socket and make sure it succeeded
AcceptSocket->nSocketAddressLen = sizeof(AcceptSocket->SocketAddress);
AcceptSocket->Socket = accept(ListenSocket->Socket, (sockaddr*)&AcceptSocket->SocketAddress, &AcceptSocket->nSocketAddressLen);
if (AcceptSocket->Socket == INVALID_SOCKET)
{
xnOSCloseSocket(AcceptSocket);
xnOSFreeAligned(*AcceptSocketPtr);
return(XN_STATUS_OS_NETWORK_SOCKET_ACCEPT_FAILED);
}
// All is good...
return (XN_STATUS_OK);
}
XnStatus Xn16zEmbTablesCodec::Init(const ProductionNode& node)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = XnCodec::Init(node);
XN_IS_STATUS_OK(nRetVal);
if (node.GetInfo().GetDescription().Type != XN_NODE_TYPE_DEPTH)
{
XN_LOG_ERROR_RETURN(XN_STATUS_BAD_PARAM, XN_MASK_OPEN_NI, "Codec 16z with embedded tables requires a depth node!");
}
DepthGenerator depth(node);
m_nMaxValue = depth.GetDeviceMaxDepth();
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnStatus XnBCDepthFormatToOutputFormat(XnStreamDepthFormat nDepthFormat, XnOutputFormats* pnOutputFormat)
{
switch (nDepthFormat)
{
case XN_DEPTH_FORMAT_RAW10:
case XN_DEPTH_FORMAT_RAW12:
*pnOutputFormat = XN_OUTPUT_FORMAT_DEPTH_VALUES;
break;
case XN_DEPTH_FORMAT_SHIFTS:
*pnOutputFormat = XN_OUTPUT_FORMAT_SHIFT_VALUES;
break;
default:
XN_LOG_ERROR_RETURN(XN_STATUS_IO_INVALID_STREAM_DEPTH_FORMAT, XN_MASK_DDK, "Failed to translate depth format %d to output format!", nDepthFormat);
}
return (XN_STATUS_OK);
}
XnStatus Record::ReadString(const XnChar* &strDest) const
{
XnUInt32 nStrSize = 0;
//Get size
XnStatus nRetVal = Read(&nStrSize, sizeof(nStrSize));
XN_IS_STATUS_OK(nRetVal);
//Check size is ok
if (m_nReadOffset + nStrSize > m_nMaxSize)
{
XN_LOG_ERROR_RETURN(XN_STATUS_INPUT_BUFFER_OVERFLOW, XN_MASK_OPEN_NI, "Record buffer too small");
}
//Point destination string to current position
strDest = (const XnChar*)(m_pData + m_nReadOffset);
//Skip string
m_nReadOffset += nStrSize;
return XN_STATUS_OK;
}
