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; }