XnStatus XnFileDevice::HandleStreamRemoved(const XnChar* strName) { XnStatus nRetVal = XN_STATUS_OK; // check for specific case: all streams are removed and then end-of-file is reached. // in this case, we don't really want to destroy streams, just wrap around. XnStringsHash StreamsToRemove; nRetVal = StreamsToRemove.Set(strName, NULL); XN_IS_STATUS_OK(nRetVal); XnPackedDataType nType = XN_PACKED_STREAM_REMOVED; XnUInt32 nPositionBefore; while (TRUE) { nRetVal = m_pInputStream->Tell(&nPositionBefore); XN_IS_STATUS_OK(nRetVal); nRetVal = m_pDataPacker->ReadNextObject(&nType); XN_IS_STATUS_OK(nRetVal); if (nType == XN_PACKED_STREAM_REMOVED) { XnChar strTempName[XN_DEVICE_MAX_STRING_LENGTH]; nRetVal = m_pDataPacker->ReadStreamRemoved(strTempName); XN_IS_STATUS_OK(nRetVal); nRetVal = StreamsToRemove.Set(strTempName, NULL); XN_IS_STATUS_OK(nRetVal); } else { break; } } if (nType != XN_PACKED_END) { // Not the case we were looking for. Remove those streams. for (XnStringsHash::Iterator it = StreamsToRemove.begin(); it != StreamsToRemove.end(); ++it) { nRetVal = m_pNotifications->OnNodeRemoved(m_pNotificationsCookie, it.Key()); XN_IS_STATUS_OK(nRetVal); XnNodeInfo* pNodeInfo; m_nodeInfoMap.Get(it.Key(), pNodeInfo); XN_DELETE(pNodeInfo->pXnCodec); m_nodeInfoMap.Remove(it.Key()); m_ignoreNewNodes.Remove(it.Key()); } m_bNodeCollectionChanged = TRUE; } // in any case, the last object we read wasn't handled yet (end-of-stream or another event), so // seek back, so it will be handled. nRetVal = m_pInputStream->Seek(nPositionBefore); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnSensorDepthStream::ConfigureStreamImpl() { XnStatus nRetVal = XN_STATUS_OK; xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificDepthUsb->pUsbConnection->UsbEp); nRetVal = SetActualRead(TRUE); XN_IS_STATUS_OK(nRetVal); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_InputFormat)); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(ResolutionProperty())); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(FPSProperty())); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_HoleFilter)); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_Gain)); // we need to turn decimation on when resolution is QVGA, and FPS is different than 60 // NOTE: this is ugly as hell. This logic should be moved to firmware. XnBool bDecimation = (GetResolution() == XN_RESOLUTION_QVGA && GetFPS() != 60); nRetVal = GetFirmwareParams()->m_DepthDecimation.SetValue(bDecimation); XN_IS_STATUS_OK(nRetVal); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_FirmwareRegistration)); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_FirmwareMirror)); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_GMCMode)); XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_WhiteBalance)); nRetVal = m_Helper.GetCmosInfo()->SetCmosConfig(XN_CMOS_TYPE_DEPTH, GetResolution(), GetFPS()); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
XnStatus XnSensorDepthStream::Init() { XnStatus nRetVal = XN_STATUS_OK; nRetVal = SetBufferPool(&m_BufferPool); XN_IS_STATUS_OK(nRetVal); // init base nRetVal = XnDepthStream::Init(); XN_IS_STATUS_OK(nRetVal); m_InputFormat.UpdateSetCallback(SetInputFormatCallback, this); m_DepthRegistration.UpdateSetCallback(SetRegistrationCallback, this); m_HoleFilter.UpdateSetCallback(SetHoleFilterCallback, this); m_WhiteBalance.UpdateSetCallback(SetWhiteBalanceCallback, this); m_Gain.UpdateSetCallback(SetGainCallback, this); m_RegistrationType.UpdateSetCallback(SetRegistrationTypeCallback, this); m_AGCBin.UpdateSetCallback(SetAGCBinCallback, this); m_AGCBin.UpdateGetCallback(GetAGCBinCallback, this); m_GMCMode.UpdateSetCallback(SetGMCModeCallback, this); XN_VALIDATE_ADD_PROPERTIES(this, &m_InputFormat, &m_DepthRegistration, &m_HoleFilter, &m_WhiteBalance, &m_Gain, &m_AGCBin, &m_SharedBufferName, &m_ActualRead, &m_GMCMode, &m_RegistrationType, ); // set base properties default values nRetVal = ResolutionProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_RESOLUTION); XN_IS_STATUS_OK(nRetVal); nRetVal = FPSProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_FPS); XN_IS_STATUS_OK(nRetVal); nRetVal = OutputFormatProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_OUTPUT_FORMAT); XN_IS_STATUS_OK(nRetVal); nRetVal = ParamCoefficientProperty().UnsafeUpdateValue(XN_SHIFTS_PARAM_COEFFICIENT); XN_IS_STATUS_OK(nRetVal); nRetVal = ShiftScaleProperty().UnsafeUpdateValue(XN_SHIFTS_SHIFT_SCALE); XN_IS_STATUS_OK(nRetVal); // read some data from firmware XnDepthInformation DepthInformation; nRetVal = XnHostProtocolAlgorithmParams(m_Helper.GetPrivateData(), XN_HOST_PROTOCOL_ALGORITHM_DEPTH_INFO, &DepthInformation, sizeof(XnDepthInformation), XN_RESOLUTION_VGA, 30); XN_IS_STATUS_OK(nRetVal); nRetVal = ConstShiftProperty().UnsafeUpdateValue(DepthInformation.nConstShift); XN_IS_STATUS_OK(nRetVal); nRetVal = ZeroPlaneDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetZeroPlaneDistance()); XN_IS_STATUS_OK(nRetVal); nRetVal = ZeroPlanePixelSizeProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetZeroPlanePixelSize()); XN_IS_STATUS_OK(nRetVal); nRetVal = EmitterDCmosDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetEmitterDCmosDistance()); XN_IS_STATUS_OK(nRetVal); // init helper nRetVal = m_Helper.Init(this, this); XN_IS_STATUS_OK(nRetVal); if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_3_0) { XN_IS_STATUS_OK(m_GMCMode.UnsafeUpdateValue(FALSE)); } if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_4_0) { XN_IS_STATUS_OK(m_WhiteBalance.UnsafeUpdateValue(FALSE)); } // on old firmwares, the host decides on the default gain. On new firmwares, we read it from firmware if (m_Helper.GetFirmware()->GetInfo()->nFWVer > XN_SENSOR_FW_VER_1_2) { nRetVal = m_Gain.UnsafeUpdateValue(GetFirmwareParams()->m_DepthGain.GetValue()); XN_IS_STATUS_OK(nRetVal); } // registration XnCallbackHandle hCallbackDummy; nRetVal = ResolutionProperty().OnChangeEvent().Register(DecideFirmwareRegistrationCallback, this, &hCallbackDummy); XN_IS_STATUS_OK(nRetVal); nRetVal = DecideFirmwareRegistration((XnBool)m_DepthRegistration.GetValue(), (XnProcessingType)m_RegistrationType.GetValue(), GetResolution()); XN_IS_STATUS_OK(nRetVal); // data processor nRetVal = m_Helper.RegisterDataProcessorProperty(m_InputFormat); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.RegisterDataProcessorProperty(ResolutionProperty()); XN_IS_STATUS_OK(nRetVal); // pixel size factor nRetVal = GetFirmwareParams()->m_ReferenceResolution.OnChangeEvent().Register(DecidePixelSizeFactorCallback, this, &m_hReferenceSizeChangedCallback); XN_IS_STATUS_OK(nRetVal); nRetVal = DecidePixelSizeFactor(); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus XnStreamReaderDevice::SetInitialState(const XnDeviceConfig* pDeviceConfig, XnPropertySet* pSet) { XnStatus nRetVal = XN_STATUS_OK; // Fix state (remove some properties that we don't wish to reflect in reader device) XnActualPropertiesHash* pDeviceModule = NULL; if (XN_STATUS_OK == pSet->pData->Get(XN_MODULE_NAME_DEVICE, pDeviceModule)) { pDeviceModule->Remove(XN_MODULE_PROPERTY_READ_WRITE_MODE); pDeviceModule->Remove(XN_MODULE_PROPERTY_PRIMARY_STREAM); } // now init base using this state (this will also create module DEVICE) XnDeviceConfig initConfig; initConfig.cpConnectionString = pDeviceConfig->cpConnectionString; initConfig.DeviceMode = pDeviceConfig->DeviceMode; initConfig.pInitialValues = pSet; initConfig.SharingMode = pDeviceConfig->SharingMode; nRetVal = XnStreamDevice::InitImpl(&initConfig); XN_IS_STATUS_OK(nRetVal); // now create the rest of the modules and streams (DEVICE was already created) XnPropertySetData* pPropSetData = pSet->pData; for (XnPropertySetData::ConstIterator it = pPropSetData->begin(); it != pPropSetData->end(); ++it) { // ignore module DEVICE if (strcmp(XN_MODULE_NAME_DEVICE, it.Key()) == 0) { continue; } // check if this is a stream XnActualPropertiesHash::ConstIterator itProp = it.Value()->end(); if (XN_STATUS_OK == it.Value()->Find(XN_STREAM_PROPERTY_TYPE, itProp)) { XnActualStringProperty* pTypeProp = (XnActualStringProperty*)itProp.Value(); nRetVal = HandleNewStream(pTypeProp->GetValue(), it.Key(), it.Value()); XN_IS_STATUS_OK(nRetVal); } else { // this is module. create it XnDeviceModuleHolder* pHolder = NULL; nRetVal = CreateModule(it.Key(), &pHolder); XN_IS_STATUS_OK(nRetVal); // set its props nRetVal = pHolder->Init(it.Value()); if (nRetVal != XN_STATUS_OK) { DestroyModule(pHolder); return (nRetVal); } // and add it nRetVal = AddModule(pHolder); if (nRetVal != XN_STATUS_OK) { DestroyModule(pHolder); return (nRetVal); } } } // modules loop return (XN_STATUS_OK); }
XnStatus XnSensorFirmwareParams::Init() { XnStatus nRetVal = XN_STATUS_OK; /* Property Param MinVersion MaxVersion ValueIfNotSupported */ /* ====================== ======================================= ==================== ==================== =================== */ nRetVal = AddFirmwareParam( m_FrameSyncEnabled, PARAM_GENERAL_FRAME_SYNC); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_RegistrationEnabled, PARAM_GENERAL_REGISTRATION_ENABLE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_Stream0Mode, PARAM_GENERAL_STREAM0_MODE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_Stream1Mode, PARAM_GENERAL_STREAM1_MODE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareAudioParam(m_Stream2Mode, PARAM_GENERAL_STREAM2_MODE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareAudioParam(m_AudioStereo, PARAM_AUDIO_STEREO_MODE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareAudioParam(m_AudioSampleRate, PARAM_AUDIO_SAMPLE_RATE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareAudioParam(m_AudioLeftChannelGain, PARAM_AUDIO_LEFT_CHANNEL_VOLUME_LEVEL); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareAudioParam(m_AudioRightChannelGain, PARAM_AUDIO_RIGHT_CHANNEL_VOLUME_LEVEL); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageFormat, PARAM_IMAGE_FORMAT); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageResolution, PARAM_IMAGE_RESOLUTION); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageFPS, PARAM_IMAGE_FPS); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageQuality, PARAM_IMAGE_QUALITY); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageFlickerDetection, PARAM_IMAGE_FLICKER_DETECTION); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageCropSizeX, PARAM_IMAGE_CROP_SIZE_X, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageCropSizeY, PARAM_IMAGE_CROP_SIZE_Y, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageCropOffsetX, PARAM_IMAGE_CROP_OFFSET_X, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageCropOffsetY, PARAM_IMAGE_CROP_OFFSET_Y, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageCropEnabled, PARAM_IMAGE_CROP_ENABLE, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthFormat, PARAM_DEPTH_FORMAT); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthResolution, PARAM_DEPTH_RESOLUTION); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthFPS, PARAM_DEPTH_FPS); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthGain, PARAM_DEPTH_AGC); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthHoleFilter, PARAM_DEPTH_HOLE_FILTER); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthMirror, PARAM_DEPTH_MIRROR, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthDecimation, PARAM_DEPTH_DECIMATION); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthCropSizeX, PARAM_DEPTH_CROP_SIZE_X, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthCropSizeY, PARAM_DEPTH_CROP_SIZE_Y, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthCropOffsetX, PARAM_DEPTH_CROP_OFFSET_X, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthCropOffsetY, PARAM_DEPTH_CROP_OFFSET_Y, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthCropEnabled, PARAM_DEPTH_CROP_ENABLE, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRFormat, PARAM_IR_FORMAT); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRResolution, PARAM_IR_RESOLUTION); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRFPS, PARAM_IR_FPS); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRCropSizeX, PARAM_IR_CROP_SIZE_X, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRCropSizeY, PARAM_IR_CROP_SIZE_Y, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRCropOffsetX, PARAM_IR_CROP_OFFSET_X, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRCropOffsetY, PARAM_IR_CROP_OFFSET_Y, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRCropEnabled, PARAM_IR_CROP_ENABLE, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_DepthWhiteBalance, PARAM_DEPTH_WHITE_BALANCE_ENABLE, XN_SENSOR_FW_VER_4_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageMirror, PARAM_IMAGE_MIRROR, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_IRMirror, PARAM_IR_MIRROR, XN_SENSOR_FW_VER_5_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_GMCMode, PARAM_DEPTH_GMC_MODE, XN_SENSOR_FW_VER_3_0, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageSharpness, PARAM_IMAGE_SHARPNESS, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, 50); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageAutoWhiteBalance, PARAM_IMAGE_AUTO_WHITE_BALANCE_MODE, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageColorTemperature, PARAM_IMAGE_COLOR_TEMPERATURE, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageBacklightCompensation,PARAM_IMAGE_BACK_LIGHT_COMPENSATION, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageAutoExposure, PARAM_IMAGE_AUTO_EXPOSURE_MODE, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageExposureBar, PARAM_IMAGE_EXPOSURE_BAR, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageLowLightCompensation,PARAM_IMAGE_LOW_LIGHT_COMPENSATION_MODE, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, FALSE); XN_IS_STATUS_OK(nRetVal); nRetVal = AddFirmwareParam( m_ImageGain, PARAM_IMAGE_AGC, XN_SENSOR_FW_VER_5_4, XN_SENSOR_FW_VER_UNKNOWN, 0); XN_IS_STATUS_OK(nRetVal); // override some props m_ImageResolution.UpdateSetCallback(SetImageResolutionCallback, this); m_ImageFormat.UpdateSetCallback(SetImageFormatCallback, this); // register for some interesting changes XnCallbackHandle hCallbackDummy; nRetVal = m_Stream0Mode.OnChangeEvent().Register(ReferenceResolutionPropertyValueChanged, this, &hCallbackDummy); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Stream1Mode.OnChangeEvent().Register(ReferenceResolutionPropertyValueChanged, this, &hCallbackDummy); XN_IS_STATUS_OK(nRetVal); nRetVal = m_IRResolution.OnChangeEvent().Register(ReferenceResolutionPropertyValueChanged, this, &hCallbackDummy); XN_IS_STATUS_OK(nRetVal); nRetVal = m_DepthFPS.OnChangeEvent().Register(ReferenceResolutionPropertyValueChanged, this, &hCallbackDummy); XN_IS_STATUS_OK(nRetVal); nRetVal = RecalculateReferenceResolution(); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus PlayerNode::SeekToTimeStampAbsolute(XnUInt64 nDestTimeStamp) { XnStatus nRetVal = XN_STATUS_OK; XnUInt64 nRecordTimeStamp = 0LL; off_t nStartPos = TellStream(); //We'll revert to this in case nDestTimeStamp is beyond end of stream XN_IS_STATUS_OK(nRetVal); if (nDestTimeStamp < m_nTimeStamp) { nRetVal = Rewind(); } else if (nDestTimeStamp == m_nTimeStamp) { //Nothing to do return XN_STATUS_OK; } else if (nDestTimeStamp > m_nGlobalMaxTimeStamp) { nDestTimeStamp = m_nGlobalMaxTimeStamp; } Record record(m_pRecordBuffer, RECORD_MAX_SIZE); XnBool bEnd = FALSE; XnUInt32 nBytesRead = 0; while ((nRecordTimeStamp < nDestTimeStamp) && !bEnd) { nRetVal = ReadRecordHeader(record); XN_IS_STATUS_OK(nRetVal); switch (record.GetType()) { case RECORD_NEW_DATA: { //We already read Record::HEADER_SIZE, now read the rest of the new data record header nRetVal = Read(m_pRecordBuffer + Record::HEADER_SIZE, NewDataRecordHeader::MAX_SIZE - Record::HEADER_SIZE, nBytesRead); XN_IS_STATUS_OK(nRetVal); if (nBytesRead < NewDataRecordHeader::MAX_SIZE - Record::HEADER_SIZE) { return XN_STATUS_CORRUPT_FILE; } NewDataRecordHeader newDataRecordHeader(record); nRetVal = newDataRecordHeader.Decode(); XN_IS_STATUS_OK(nRetVal); //Save record time stamp nRecordTimeStamp = newDataRecordHeader.GetTimeStamp(); if (nRecordTimeStamp >= nDestTimeStamp) { //We're done - move back to beginning of record nRetVal = SeekStream(XN_OS_SEEK_CUR, -XnInt32(nBytesRead)); XN_IS_STATUS_OK(nRetVal); } else { //Skip to next record nRetVal = SeekStream(XN_OS_SEEK_CUR, newDataRecordHeader.GetSize() - NewDataRecordHeader::MAX_SIZE); XN_IS_STATUS_OK(nRetVal); } break; } case RECORD_END: { bEnd = TRUE; break; } case RECORD_NODE_ADDED_1_0_0_4: case RECORD_NODE_ADDED_1_0_0_5: case RECORD_NODE_ADDED: case RECORD_INT_PROPERTY: case RECORD_REAL_PROPERTY: case RECORD_STRING_PROPERTY: case RECORD_GENERAL_PROPERTY: case RECORD_NODE_REMOVED: case RECORD_NODE_DATA_BEGIN: case RECORD_NODE_STATE_READY: { //Read rest of record and handle it normally nRetVal = Read(m_pRecordBuffer + Record::HEADER_SIZE, record.GetSize() - Record::HEADER_SIZE, nBytesRead); XN_IS_STATUS_OK(nRetVal); Record record(m_pRecordBuffer, RECORD_MAX_SIZE); nRetVal = HandleRecord(record, TRUE); XN_IS_STATUS_OK(nRetVal); break; } default: { XN_ASSERT(FALSE); return XN_STATUS_CORRUPT_FILE; } } //switch } //while if (bEnd) { SeekStream(XN_OS_SEEK_SET, nStartPos); return XN_STATUS_ILLEGAL_POSITION; } return XN_STATUS_OK; }//function
XnStatus PlayerNode::HandleNodeAdded_1_0_0_4_Record(NodeAdded_1_0_0_4_Record record) { XnStatus nRetVal = XN_STATUS_OK; nRetVal = record.Decode(); XN_IS_STATUS_OK(nRetVal); DEBUG_LOG_RECORD(record, "NodeAdded1_0_0_4"); /** BC issue **/ // NOTE: ONI files up to version 1.0.0.4 didn't had a different NodeAdded record. It did // not contain seek data (number of frames and min/max timestamp). Instead, this data was // in the DataBegin record. So we need to also find this record, and read these props from it. XnUInt32 nNodeID = record.GetNodeID(); XnChar strName[XN_MAX_NAME_LENGTH]; nRetVal = xnOSStrCopy(strName, record.GetNodeName(), XN_MAX_NAME_LENGTH); XN_IS_STATUS_OK(nRetVal); XnProductionNodeType type = record.GetNodeType(); XnCodecID compression = record.GetCompression(); XnUInt32 nNumFrames = 0; XnUInt64 nMinTimestamp = 0; XnUInt64 nMaxTimestamp = 0; if (xnIsTypeGenerator(type)) { // we need to look for the DataBegin record to have number of frames, etc. off_t nStartPos = TellStream(); // NOTE: this overwrites the current NodeAdded record buffer!!! nRetVal = SeekToRecordByType(nNodeID, RECORD_NODE_DATA_BEGIN); if (nRetVal == XN_STATUS_OK) { NodeDataBeginRecord dataBeginRecord(m_pRecordBuffer, RECORD_MAX_SIZE); nRetVal = ReadRecord(dataBeginRecord); XN_IS_STATUS_OK(nRetVal); nRetVal = dataBeginRecord.Decode(); XN_IS_STATUS_OK(nRetVal); nNumFrames = dataBeginRecord.GetNumFrames(); nMaxTimestamp = dataBeginRecord.GetMaxTimeStamp(); // also find data record for min timestamp nRetVal = SeekToRecordByType(record.GetNodeID(), RECORD_NEW_DATA); if (nRetVal == XN_STATUS_OK) { NewDataRecordHeader newDataRecord(m_pRecordBuffer, RECORD_MAX_SIZE); nRetVal = ReadRecord(newDataRecord); XN_IS_STATUS_OK(nRetVal); nRetVal = newDataRecord.Decode(); XN_IS_STATUS_OK(nRetVal); nMinTimestamp = newDataRecord.GetTimeStamp(); } // get back to start position nRetVal = SeekStream(XN_OS_SEEK_SET, nStartPos); XN_IS_STATUS_OK(nRetVal); } } nRetVal = HandleNodeAddedImpl(nNodeID, type, strName, compression, nNumFrames, nMinTimestamp, nMaxTimestamp); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
XnStatus XnSensorImageStream::MapPropertiesToFirmware() { XnStatus nRetVal = XN_STATUS_OK; nRetVal = m_Helper.MapFirmwareProperty(m_InputFormat, GetFirmwareParams()->m_ImageFormat, FALSE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(ResolutionProperty(), GetFirmwareParams()->m_ImageResolution, FALSE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(FPSProperty(), GetFirmwareParams()->m_ImageFPS, FALSE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_AntiFlicker, GetFirmwareParams()->m_ImageFlickerDetection, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_ImageQuality, GetFirmwareParams()->m_ImageQuality, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareMirror, GetFirmwareParams()->m_ImageMirror, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareCropSizeX, GetFirmwareParams()->m_ImageCropSizeX, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareCropSizeY, GetFirmwareParams()->m_ImageCropSizeY, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareCropOffsetX, GetFirmwareParams()->m_ImageCropOffsetX, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareCropOffsetY, GetFirmwareParams()->m_ImageCropOffsetY, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareCropEnabled, GetFirmwareParams()->m_ImageCropEnabled, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_Sharpness, GetFirmwareParams()->m_ImageSharpness, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareAutoWhiteBalance, GetFirmwareParams()->m_ImageAutoWhiteBalance, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareColorTemperature, GetFirmwareParams()->m_ImageColorTemperature, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_BackLightCompensation, GetFirmwareParams()->m_ImageBacklightCompensation, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_Gain, GetFirmwareParams()->m_ImageGain, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareExposure, GetFirmwareParams()->m_ImageExposureBar, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_FirmwareAutoExposure, GetFirmwareParams()->m_ImageAutoExposure, TRUE); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.MapFirmwareProperty(m_LowLightCompensation, GetFirmwareParams()->m_ImageLowLightCompensation, TRUE); XN_IS_STATUS_OK(nRetVal);; return (XN_STATUS_OK); }
XnStatus XnSensorImageStream::ConfigureStreamImpl() { XnStatus nRetVal = XN_STATUS_OK; xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificImageUsb->pUsbConnection->UsbEp); nRetVal = SetActualRead(TRUE); XN_IS_STATUS_OK(nRetVal); nRetVal = ValidateMode(); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_InputFormat); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.ConfigureFirmware(ResolutionProperty()); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.ConfigureFirmware(FPSProperty()); XN_IS_STATUS_OK(nRetVal);; nRetVal = m_Helper.ConfigureFirmware(m_AntiFlicker); XN_IS_STATUS_OK(nRetVal);; // image quality is only relevant for JPEG if (m_InputFormat.GetValue() == XN_IO_IMAGE_FORMAT_JPEG) { nRetVal = m_Helper.ConfigureFirmware(m_ImageQuality); XN_IS_STATUS_OK(nRetVal);; } nRetVal = m_Helper.ConfigureFirmware(m_FirmwareMirror); XN_IS_STATUS_OK(nRetVal);; if (GetResolution() != XN_RESOLUTION_UXGA && GetResolution() != XN_RESOLUTION_SXGA) { nRetVal = m_Helper.GetCmosInfo()->SetCmosConfig(XN_CMOS_TYPE_IMAGE, GetResolution(), GetFPS()); XN_IS_STATUS_OK(nRetVal); } if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_4) { nRetVal = m_Helper.ConfigureFirmware(m_Sharpness); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_FirmwareColorTemperature); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_FirmwareAutoWhiteBalance); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_FirmwareExposure); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_FirmwareAutoExposure); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_BackLightCompensation); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_Gain); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.ConfigureFirmware(m_LowLightCompensation); XN_IS_STATUS_OK(nRetVal); } return (XN_STATUS_OK); }
XnStatus xnXmlReadQuery(const TiXmlElement* pQueryElem, XnNodeQuery* pQuery) { XnStatus nRetVal = XN_STATUS_OK; // vendor const TiXmlElement* pVendor = pQueryElem->FirstChildElement("Vendor"); if (pVendor != NULL) { xnNodeQuerySetVendor(pQuery, pVendor->GetText()); } // name const TiXmlElement* pName = pQueryElem->FirstChildElement("Name"); if (pName != NULL) { xnNodeQuerySetName(pQuery, pName->GetText()); } // Min version const TiXmlElement* pMinVersion = pQueryElem->FirstChildElement("MinVersion"); if (pMinVersion != NULL) { XnVersion minVersion; nRetVal = xnReadVersionFromXml(pMinVersion, &minVersion); XN_IS_STATUS_OK(nRetVal); xnNodeQuerySetMinVersion(pQuery, &minVersion); } // Max version const TiXmlElement* pMaxVersion = pQueryElem->FirstChildElement("MaxVersion"); if (pMaxVersion != NULL) { XnVersion maxVersion; nRetVal = xnReadVersionFromXml(pMaxVersion, &maxVersion); XN_IS_STATUS_OK(nRetVal); xnNodeQuerySetMaxVersion(pQuery, &maxVersion); } // Capabilities const TiXmlElement* pCapabilities = pQueryElem->FirstChildElement("Capabilities"); if (pCapabilities != NULL) { const TiXmlElement* pCap = pCapabilities->FirstChildElement("Capability"); while (pCap != NULL) { xnNodeQueryAddSupportedCapability(pQuery, pCap->GetText()); pCap = pCap->NextSiblingElement("Capability"); } } // Map Output Modes const TiXmlElement* pOutputModes = pQueryElem->FirstChildElement("MapOutputModes"); if (pOutputModes != NULL) { const TiXmlElement* pMode = pOutputModes->FirstChildElement("MapOutputMode"); while (pMode != NULL) { XnMapOutputMode Mode; nRetVal = xnXmlReadMapOutputMode(pMode, &Mode); XN_IS_STATUS_OK(nRetVal); xnNodeQueryAddSupportedMapOutputMode(pQuery, &Mode); pMode = pMode->NextSiblingElement("MapOutputMode"); } } // Min User Position const TiXmlElement* pMinUserPositions = pQueryElem->FirstChildElement("MinUserPositions"); if (pMinUserPositions != NULL) { XnInt nMinUserPositions; nRetVal = xnXmlReadTextAsInt(pMinUserPositions, &nMinUserPositions); XN_IS_STATUS_OK(nRetVal); xnNodeQuerySetSupportedMinUserPositions(pQuery, nMinUserPositions); } // Needed Nodes const TiXmlElement* pNeededNodes = pQueryElem->FirstChildElement("NeededNodes"); if (pNeededNodes != NULL) { const TiXmlElement* pNode = pNeededNodes->FirstChildElement("Node"); while (pNode != NULL) { xnNodeQueryAddNeededNode(pQuery, pNode->GetText()); pNode = pNode->NextSiblingElement("Node"); } } // Creation info const TiXmlElement* pCreationInfo = pQueryElem->FirstChildElement("CreationInfo"); if (pCreationInfo != NULL) { xnNodeQuerySetCreationInfo(pQuery, pCreationInfo->GetText()); } return (XN_STATUS_OK); }
XnStatus xnConfigureCreateNodes(XnContext* pContext, const TiXmlElement* pRootElem, XnEnumerationErrors* pErrors) { XnStatus nRetVal = XN_STATUS_OK; const TiXmlElement* pProudctionNodes = pRootElem->FirstChildElement("ProductionNodes"); if (pProudctionNodes == NULL) { return (XN_STATUS_OK); } // global mirror const TiXmlElement* pGlobalMirror = pProudctionNodes->FirstChildElement("GlobalMirror"); if (pGlobalMirror != NULL) { XnBool bOn; nRetVal = xnXmlReadBoolAttribute(pGlobalMirror, "on", &bOn); XN_IS_STATUS_OK(nRetVal); nRetVal = xnSetGlobalMirror(pContext, bOn); XN_IS_STATUS_OK(nRetVal); } // file recordings const TiXmlElement* pRecording = pProudctionNodes->FirstChildElement("Recording"); if (pRecording != NULL) { const XnChar* strFileName; nRetVal = xnXmlReadStringAttribute(pRecording, "file", &strFileName); XN_IS_STATUS_OK(nRetVal); xnLogVerbose(XN_MASK_OPEN_NI, "Opening file recording '%s'...", strFileName); nRetVal = xnContextOpenFileRecording(pContext, strFileName); XN_IS_STATUS_OK(nRetVal); XnDouble dSpeed = 1.0; if (NULL != pRecording->Attribute("playbackSpeed", &dSpeed)) { XnNodeHandle hPlayer; nRetVal = xnFindExistingNodeByType(pContext, XN_NODE_TYPE_PLAYER, &hPlayer); XN_IS_STATUS_OK(nRetVal); nRetVal = xnSetPlaybackSpeed(hPlayer, dSpeed); XN_IS_STATUS_OK(nRetVal); } } const XnChar* strNodeTagName = "Node"; const XnChar* strStartGeneratingAttr = "startGenerating"; XnBool bStartGeneratingAll = TRUE; if (NULL != pProudctionNodes->Attribute(strStartGeneratingAttr)) { nRetVal = xnXmlReadBoolAttribute(pProudctionNodes, strStartGeneratingAttr, &bStartGeneratingAll); XN_IS_STATUS_OK(nRetVal); } // new nodes const TiXmlElement* pNode = pProudctionNodes->FirstChildElement(strNodeTagName); while (pNode != NULL) { // get type const XnChar* strType; nRetVal = xnXmlReadStringAttribute(pNode, "type", &strType); XN_IS_STATUS_OK(nRetVal); xnLogVerbose(XN_MASK_OPEN_NI, "Requested to create a node of type %s...", strType); XnProductionNodeType Type; nRetVal = xnProductionNodeTypeFromString(strType, &Type); XN_IS_STATUS_OK(nRetVal); // check if there is a query XnNodeQuery* pQuery = NULL; const TiXmlElement* pQueryElem = pNode->FirstChildElement("Query"); if (pQueryElem != NULL) { nRetVal = xnNodeQueryAllocate(&pQuery); XN_IS_STATUS_OK(nRetVal); nRetVal = xnXmlReadQuery(pQueryElem, pQuery); XN_IS_STATUS_OK(nRetVal); } // enumerate XnNodeInfoList* pTrees; nRetVal = xnEnumerateProductionTrees(pContext, Type, pQuery, &pTrees, pErrors); XN_IS_STATUS_OK(nRetVal); if (pQuery != NULL) { xnNodeQueryFree(pQuery); pQuery = NULL; } // choose first one XnNodeInfoListIterator itChosen = xnNodeInfoListGetFirst(pTrees); XnNodeInfo* pChosenInfo = xnNodeInfoListGetCurrent(itChosen); // check if a name was requested if (NULL != pNode->Attribute("name")) { const XnChar* strName = NULL; nRetVal = xnXmlReadStringAttribute(pNode, "name", &strName); if (nRetVal != XN_STATUS_OK) { xnNodeInfoListFree(pTrees); return (nRetVal); } nRetVal = xnNodeInfoSetInstanceName(pChosenInfo, strName); if (nRetVal != XN_STATUS_OK) { xnNodeInfoListFree(pTrees); return (nRetVal); } } // create it XnNodeHandle hNode; nRetVal = xnCreateProductionTree(pContext, pChosenInfo, &hNode); if (nRetVal != XN_STATUS_OK) { xnNodeInfoListFree(pTrees); return (nRetVal); } // free the list xnNodeInfoListFree(pTrees); // config it nRetVal = xnConfigureNodeFromXml(hNode, pNode); XN_IS_STATUS_OK(nRetVal); // check if we need to start it (if start generating all is on, it will be started at the end) XnBool bStart = FALSE; if (!bStartGeneratingAll) { if (NULL != pNode->Attribute(strStartGeneratingAttr)) { nRetVal = xnXmlReadBoolAttribute(pNode, strStartGeneratingAttr, &bStart); XN_IS_STATUS_OK(nRetVal); } if (bStart) { nRetVal = xnStartGenerating(hNode); XN_IS_STATUS_OK(nRetVal); } } pNode = pNode->NextSiblingElement(strNodeTagName); } // start generating all if (bStartGeneratingAll) { nRetVal = xnStartGeneratingAll(pContext); XN_IS_STATUS_OK(nRetVal); } return (XN_STATUS_OK); }
XnStatus openDeviceFromXmlWithChoice(const char* csXmlFile, EnumerationErrors& errors) { XnStatus nRetVal = XN_STATUS_OK; xnLogInitFromXmlFile(csXmlFile); nRetVal = g_Context.Init(); XN_IS_STATUS_OK(nRetVal); // find devices NodeInfoList list; nRetVal = g_Context.EnumerateProductionTrees(XN_NODE_TYPE_DEVICE, NULL, list, &errors); XN_IS_STATUS_OK(nRetVal); printf("The following devices were found:\n"); int i = 1; for (NodeInfoList::Iterator it = list.Begin(); it != list.End(); ++it, ++i) { NodeInfo deviceNodeInfo = *it; Device deviceNode; deviceNodeInfo.GetInstance(deviceNode); XnBool bExists = deviceNode.IsValid(); if (!bExists) { g_Context.CreateProductionTree(deviceNodeInfo, deviceNode); // this might fail. } if (deviceNode.IsValid() && deviceNode.IsCapabilitySupported(XN_CAPABILITY_DEVICE_IDENTIFICATION)) { const XnUInt32 nStringBufferSize = 200; XnChar strDeviceName[nStringBufferSize]; XnChar strSerialNumber[nStringBufferSize]; XnUInt32 nLength = nStringBufferSize; deviceNode.GetIdentificationCap().GetDeviceName(strDeviceName, nLength); nLength = nStringBufferSize; deviceNode.GetIdentificationCap().GetSerialNumber(strSerialNumber, nLength); printf("[%d] %s (%s)\n", i, strDeviceName, strSerialNumber); } else { printf("[%d] %s\n", i, deviceNodeInfo.GetCreationInfo()); } // release the device if we created it if (!bExists && deviceNode.IsValid()) { deviceNode.Release(); } } printf("\n"); printf("Choose device to open (1): "); int chosen = 1; scanf("%d", &chosen); // create it NodeInfoList::Iterator it = list.Begin(); for (i = 1; i < chosen; ++i) { it++; } NodeInfo deviceNode = *it; nRetVal = g_Context.CreateProductionTree(deviceNode, g_Device); XN_IS_STATUS_OK(nRetVal); // now run the rest of the XML nRetVal = g_Context.RunXmlScriptFromFile(csXmlFile, g_scriptNode, &errors); XN_IS_STATUS_OK(nRetVal); openCommon(); return (XN_STATUS_OK); }
XnStatus XnSensorAudioStream::ReallocBuffer() { XnStatus nRetVal = XN_STATUS_OK; XnDevicePrivateData* pDevicePrivateData = m_Helper.GetPrivateData(); if (m_hSharedMemory == NULL) { // first time, create shared memory // we allocate enough for 5 seconds of audio XnUInt32 nSampleSize = 2 * 2; // 16-bit per channel (2 bytes) * max number of channels (2) XnUInt32 nSamples = 48000 * 5; // max sample rate * number of seconds XnUInt32 nMaxBufferSize = nSamples * nSampleSize; // find min packet size (so we'll have max packet count) XnUInt32 nMinPacketSize = XN_MIN(XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_BULK, XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_ISO); XnUInt32 nMaxPacketCount = nMaxBufferSize / nMinPacketSize - 1; XnUInt32 nSharedBufferSize = sizeof(XnAudioSharedBuffer) + // header sizeof(XnUInt64) * nMaxPacketCount + // packet timestamps nMaxBufferSize; // to make the name unique, we'll add process ID XN_PROCESS_ID procID; xnOSGetCurrentProcessID(&procID); XnChar strSharedName[XN_DEVICE_MAX_STRING_LENGTH]; sprintf(strSharedName, "%u_%s_%s", (XnUInt32)procID, m_strDeviceName, GetName()); nRetVal = m_SharedBufferName.UnsafeUpdateValue(strSharedName); XN_IS_STATUS_OK(nRetVal); nRetVal = RequiredSizeProperty().UnsafeUpdateValue(nMaxBufferSize); XN_IS_STATUS_OK(nRetVal); nRetVal = xnOSCreateSharedMemoryEx(strSharedName, nSharedBufferSize, XN_OS_FILE_READ | XN_OS_FILE_WRITE, m_bAllowOtherUsers, &m_hSharedMemory); XN_IS_STATUS_OK(nRetVal); XnUChar* pAddress; nRetVal = xnOSSharedMemoryGetAddress(m_hSharedMemory, (void**)&pAddress); XN_IS_STATUS_OK(nRetVal); m_pSharedHeader = (XnAudioSharedBuffer*)pAddress; m_buffer.pAudioPacketsTimestamps = (XnUInt64*)(pAddress + sizeof(XnAudioSharedBuffer)); m_buffer.pAudioBuffer = (XN_AUDIO_TYPE*)(pAddress + sizeof(XnAudioSharedBuffer) + sizeof(XnUInt64) * nMaxPacketCount); m_buffer.nAudioBufferSize = nMaxBufferSize; m_pSharedHeader->nTimestampsListOffset = sizeof(XnAudioSharedBuffer); m_pSharedHeader->nBufferOffset = (XnUInt32)(m_buffer.pAudioBuffer - pAddress); } // calculate current packet size m_buffer.nAudioPacketSize = m_nOrigAudioPacketSize; if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2 && GetNumberOfChannels() == 1) { m_buffer.nAudioPacketSize /= 2; } m_buffer.nAudioBufferNumOfPackets = m_buffer.nAudioBufferSize / m_buffer.nAudioPacketSize; m_buffer.nAudioBufferSize = m_buffer.nAudioBufferNumOfPackets * m_buffer.nAudioPacketSize; m_pSharedHeader->nPacketCount = m_buffer.nAudioBufferNumOfPackets; m_pSharedHeader->nPacketSize = m_buffer.nAudioPacketSize; // set read and write indices m_buffer.nAudioReadIndex = 0; m_buffer.nAudioWriteIndex = 0; return (XN_STATUS_OK); }
XnStatus XnFileDevice::HandleIntProperty(const XnChar *strModule, const XnChar *strName, XnUInt64 nValue) { XnStatus nRetVal = XN_STATUS_OK; // ignore some properties if (strcmp(strModule, XN_MODULE_NAME_DEVICE) == 0 && strcmp(strName, XN_MODULE_PROPERTY_PRIMARY_STREAM) == 0) { return (XN_STATUS_OK); } // OpenNI props if (strcmp(strName, XN_STREAM_PROPERTY_STATE) == 0) { nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_IS_GENERATING, nValue); } else if (strcmp(strName, XN_MODULE_PROPERTY_MIRROR) == 0) { nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_MIRROR, nValue); } else if (strcmp(strName, XN_STREAM_PROPERTY_X_RES) == 0 || strcmp(strName, XN_STREAM_PROPERTY_Y_RES) == 0 || strcmp(strName, XN_STREAM_PROPERTY_FPS) == 0) { xn::MapGenerator node; nRetVal = m_context.GetProductionNodeByName(strModule, node); XN_IS_STATUS_OK(nRetVal); XnMapOutputMode mode; nRetVal = node.GetMapOutputMode(mode); XN_IS_STATUS_OK(nRetVal); if (strcmp(strName, XN_STREAM_PROPERTY_X_RES) == 0) { mode.nXRes = nValue; } else if (strcmp(strName, XN_STREAM_PROPERTY_Y_RES) == 0) { mode.nYRes = nValue; } else if (strcmp(strName, XN_STREAM_PROPERTY_FPS) == 0) { mode.nFPS = nValue; } // change supported modes to this one nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_SUPPORTED_MAP_OUTPUT_MODES_COUNT, 1); XN_IS_STATUS_OK(nRetVal); nRetVal = m_pNotifications->OnNodeGeneralPropChanged(m_pNotificationsCookie, strModule, XN_PROP_SUPPORTED_MAP_OUTPUT_MODES, sizeof(XnMapOutputMode), &mode); XN_IS_STATUS_OK(nRetVal); // and set actual mode nRetVal = m_pNotifications->OnNodeGeneralPropChanged(m_pNotificationsCookie, strModule, XN_PROP_MAP_OUTPUT_MODE, sizeof(mode), &mode); XN_IS_STATUS_OK(nRetVal); } else if (strcmp(strName, XN_STREAM_PROPERTY_OUTPUT_FORMAT) == 0) { switch (nValue) { case XN_OUTPUT_FORMAT_SHIFT_VALUES: case XN_OUTPUT_FORMAT_DEPTH_VALUES: case XN_OUTPUT_FORMAT_GRAYSCALE16: case XN_OUTPUT_FORMAT_PCM: break; case XN_OUTPUT_FORMAT_GRAYSCALE8: nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_PIXEL_FORMAT, XN_PIXEL_FORMAT_GRAYSCALE_8_BIT); break; case XN_OUTPUT_FORMAT_RGB24: nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_PIXEL_FORMAT, XN_PIXEL_FORMAT_RGB24); break; case XN_OUTPUT_FORMAT_YUV422: nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_PIXEL_FORMAT, XN_PIXEL_FORMAT_YUV422); break; default: XN_ASSERT(FALSE); return XN_STATUS_ERROR; } XN_IS_STATUS_OK(nRetVal); // also set property (we need it for IR compatibility) nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, strName, nValue); } else if (strcmp(strName, XN_STREAM_PROPERTY_DEVICE_MAX_DEPTH) == 0) { nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_DEVICE_MAX_DEPTH, nValue); } else if (strcmp(strName, XN_STREAM_PROPERTY_SAMPLE_RATE) == 0 || strcmp(strName, XN_STREAM_PROPERTY_NUMBER_OF_CHANNELS) == 0) { xn::AudioGenerator node; nRetVal = m_context.GetProductionNodeByName(strModule, node); XN_IS_STATUS_OK(nRetVal); XnWaveOutputMode mode; nRetVal = node.GetWaveOutputMode(mode); XN_IS_STATUS_OK(nRetVal); if (strcmp(strName, XN_STREAM_PROPERTY_SAMPLE_RATE) == 0) { mode.nSampleRate = nValue; } else if (strcmp(strName, XN_STREAM_PROPERTY_NUMBER_OF_CHANNELS) == 0) { mode.nChannels = nValue; } // change supported modes to this one nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, XN_PROP_WAVE_SUPPORTED_OUTPUT_MODES_COUNT, 1); XN_IS_STATUS_OK(nRetVal); nRetVal = m_pNotifications->OnNodeGeneralPropChanged(m_pNotificationsCookie, strModule, XN_PROP_WAVE_SUPPORTED_OUTPUT_MODES, sizeof(XnWaveOutputMode), &mode); XN_IS_STATUS_OK(nRetVal); // and set actual mode nRetVal = m_pNotifications->OnNodeGeneralPropChanged(m_pNotificationsCookie, strModule, XN_PROP_WAVE_OUTPUT_MODE, sizeof(mode), &mode); XN_IS_STATUS_OK(nRetVal); } else { nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strModule, strName, nValue); } XN_IS_STATUS_OK(nRetVal); /********************/ // Now for some additional logic... /********************/ xn::ProductionNode node; nRetVal = m_context.GetProductionNodeByName(strModule, node); XN_IS_STATUS_OK(nRetVal); // replace codec? if (strcmp(strName, XN_STREAM_PROPERTY_COMPRESSION) == 0) { nRetVal = CreateCodec(node); XN_IS_STATUS_OK(nRetVal); } else if (strcmp(strName, XN_STREAM_PROPERTY_OUTPUT_FORMAT) == 0) { nRetVal = CheckIRCompatibility(node); XN_IS_STATUS_OK(nRetVal); } else if (strcmp(strModule, XN_MODULE_NAME_DEVICE) == 0 && strcmp(strName, XN_MODULE_PROPERTY_HIGH_RES_TIMESTAMPS) == 0) { // check timestamps resolution m_bHighresTimestamps = (nValue == TRUE); } else if (strcmp(strName, XN_STREAM_PROPERTY_ZERO_PLANE_DISTANCE) == 0 || strcmp(strName, XN_STREAM_PROPERTY_MAX_SHIFT) == 0 || strcmp(strName, XN_STREAM_PROPERTY_DEVICE_MAX_DEPTH) == 0 || strcmp(strName, XN_STREAM_PROPERTY_CONST_SHIFT) == 0 || strcmp(strName, XN_STREAM_PROPERTY_PIXEL_SIZE_FACTOR) == 0 || strcmp(strName, XN_STREAM_PROPERTY_PARAM_COEFF) == 0 || strcmp(strName, XN_STREAM_PROPERTY_SHIFT_SCALE) == 0) { // only after node is ready xn::DepthGenerator depth(node); XnNodeInfo* pNodeInfo; if (m_nodeInfoMap.Get(strModule, pNodeInfo) == XN_STATUS_OK && m_context.GetProductionNodeByName(strModule, depth) == XN_STATUS_OK) { nRetVal = UpdateS2DTables(depth); XN_IS_STATUS_OK(nRetVal); } } if (strcmp(strName, XN_STREAM_PROPERTY_ZERO_PLANE_DISTANCE) == 0 || strcmp(strName, XN_STREAM_PROPERTY_X_RES) == 0) { // only after node is ready XnNodeInfo* pNodeInfo; if (m_nodeInfoMap.Get(strModule, pNodeInfo) == XN_STATUS_OK) { // check this is a depth node if (node.GetInfo().GetDescription().Type == XN_NODE_TYPE_DEPTH) { xn::DepthGenerator depth(node); nRetVal = UpdateRWData(depth); XN_IS_STATUS_OK(nRetVal); } } } return (XN_STATUS_OK); }
XnStatus PlayerNode::HandleGeneralPropRecord(GeneralPropRecord record) { XN_VALIDATE_INPUT_PTR(m_pNodeNotifications); XnStatus nRetVal = record.Decode(); XN_IS_STATUS_OK(nRetVal); DEBUG_LOG_RECORD(record, "GeneralProp"); PlayerNodeInfo* pPlayerNodeInfo = GetPlayerNodeInfo(record.GetNodeID()); XN_VALIDATE_PTR(pPlayerNodeInfo, XN_STATUS_CORRUPT_FILE); if (!pPlayerNodeInfo->bValid) { XN_ASSERT(FALSE); return XN_STATUS_CORRUPT_FILE; } // Fix backwards compatibility issues if (strcmp(record.GetPropName(), XN_PROP_REAL_WORLD_TRANSLATION_DATA) == 0) { // old recordings held the RealWorldTranslationData, but API has changed. Translate // it to Field Of View if (record.GetPropDataSize() != sizeof(XnRealWorldTranslationData)) { return XN_STATUS_CORRUPT_FILE; } const XnRealWorldTranslationData* pTransData = (const XnRealWorldTranslationData*)record.GetPropData(); // we also need resolution for the translation xn::DepthGenerator depthGen; nRetVal = m_context.GetProductionNodeByName(pPlayerNodeInfo->strName, depthGen); XN_IS_STATUS_OK(nRetVal); XnMapOutputMode outputMode; nRetVal = depthGen.GetMapOutputMode(outputMode); XN_IS_STATUS_OK(nRetVal); XnFieldOfView FOV; FOV.fHFOV = 2*atan(pTransData->dPixelSizeAtZeroPlane * pTransData->dSourceToDepthPixelRatio * outputMode.nXRes / 2 / pTransData->dZeroPlaneDistance); FOV.fVFOV = 2*atan(pTransData->dPixelSizeAtZeroPlane * pTransData->dSourceToDepthPixelRatio * outputMode.nYRes / 2 / pTransData->dZeroPlaneDistance); nRetVal = m_pNodeNotifications->OnNodeGeneralPropChanged(m_pNotificationsCookie, pPlayerNodeInfo->strName, XN_PROP_FIELD_OF_VIEW, sizeof(FOV), &FOV); XN_IS_STATUS_OK(nRetVal); } else { nRetVal = m_pNodeNotifications->OnNodeGeneralPropChanged(m_pNotificationsCookie, pPlayerNodeInfo->strName, record.GetPropName(), record.GetPropDataSize(), record.GetPropData()); XN_IS_STATUS_OK(nRetVal); } nRetVal = SaveRecordUndoInfo(pPlayerNodeInfo, record.GetPropName(), TellStream() - record.GetSize(), record.GetUndoRecordPos()); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
XnStatus XnSensorImageStream::Init() { XnStatus nRetVal = XN_STATUS_OK; nRetVal = SetBufferPool(&m_BufferPool); XN_IS_STATUS_OK(nRetVal); // init base nRetVal = XnImageStream::Init(); XN_IS_STATUS_OK(nRetVal); m_InputFormat.UpdateSetCallback(SetInputFormatCallback, this); m_AntiFlicker.UpdateSetCallback(SetAntiFlickerCallback, this); m_ImageQuality.UpdateSetCallback(SetImageQualityCallback, this); m_Brightness.UpdateSetCallbackToDefault(); m_Contrast.UpdateSetCallbackToDefault(); m_Saturation.UpdateSetCallbackToDefault(); m_Zoom.UpdateSetCallbackToDefault(); m_Pan.UpdateSetCallbackToDefault(); m_Tilt.UpdateSetCallbackToDefault(); m_Sharpness.UpdateSetCallback(SetSharpnessCallback, this); m_ColorTemperature.UpdateSetCallback(SetColorTemperatureCallback, this); m_BackLightCompensation.UpdateSetCallback(SetBacklightCompensationCallback, this); m_Gain.UpdateSetCallback(SetGainCallback, this); m_Exposure.UpdateSetCallback(SetExposureCallback, this); m_LowLightCompensation.UpdateSetCallback(SetLowLightCompensationCallback, this); // add properties XN_VALIDATE_ADD_PROPERTIES(this, &m_InputFormat, &m_AntiFlicker, &m_ImageQuality, &m_Brightness, &m_Contrast, &m_Saturation, &m_Sharpness, &m_ColorTemperature, &m_BackLightCompensation, &m_Gain, &m_Zoom, &m_Exposure, &m_Pan, &m_Tilt, &m_LowLightCompensation, &m_SharedBufferName, &m_ActualRead); // set base properties default values nRetVal = ResolutionProperty().UnsafeUpdateValue(XN_IMAGE_STREAM_DEFAULT_RESOLUTION); XN_IS_STATUS_OK(nRetVal); nRetVal = FPSProperty().UnsafeUpdateValue(XN_IMAGE_STREAM_DEFAULT_FPS); XN_IS_STATUS_OK(nRetVal); nRetVal = OutputFormatProperty().UnsafeUpdateValue(XN_IMAGE_STREAM_DEFAULT_OUTPUT_FORMAT); XN_IS_STATUS_OK(nRetVal); // init helper nRetVal = m_Helper.Init(this, this); XN_IS_STATUS_OK(nRetVal); // data processor nRetVal = m_Helper.RegisterDataProcessorProperty(m_InputFormat); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.RegisterDataProcessorProperty(ResolutionProperty()); XN_IS_STATUS_OK(nRetVal); nRetVal = m_Helper.RegisterDataProcessorProperty(ResolutionProperty()); XN_IS_STATUS_OK(nRetVal); // register supported modes if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_4) { // ask the firmware const XnUInt32 nAllocSize = 100; XnUInt32 nCount = nAllocSize; XnCmosPreset aSupportedModes[nAllocSize]; nRetVal = XnHostProtocolGetCmosPresets(m_Helper.GetPrivateData(), XN_CMOS_TYPE_IMAGE, aSupportedModes, nCount); XN_IS_STATUS_OK(nRetVal); if (nCount == 0) { xnLogError(XN_MASK_DEVICE_SENSOR, "Device does not support any image mode!"); return XN_STATUS_DEVICE_UNSUPPORTED_PARAMETER; } // check if our current (default) configuration is valid XnUInt16 nValidInputFormat = XN_IMAGE_STREAM_DEFAULT_INPUT_FORMAT; XnBool bModeFound = FALSE; for (XnUInt32 i = 0; i < nCount; ++i) { if (aSupportedModes[i].nResolution == XN_IMAGE_STREAM_DEFAULT_RESOLUTION && aSupportedModes[i].nFPS == XN_IMAGE_STREAM_DEFAULT_FPS) { // found if (!bModeFound) { bModeFound = TRUE; nValidInputFormat = aSupportedModes[i].nFormat; } if (aSupportedModes[i].nFormat == XN_IMAGE_STREAM_DEFAULT_INPUT_FORMAT) { nValidInputFormat = XN_IMAGE_STREAM_DEFAULT_INPUT_FORMAT; break; } } } if (!bModeFound) { xnLogWarning(XN_MASK_DEVICE_SENSOR, "Default mode (res + FPS) is not supported by device. Changing defaults..."); nRetVal = ResolutionProperty().UnsafeUpdateValue(aSupportedModes[0].nResolution); XN_IS_STATUS_OK(nRetVal); nRetVal = FPSProperty().UnsafeUpdateValue(aSupportedModes[0].nFPS); XN_IS_STATUS_OK(nRetVal); nRetVal = m_InputFormat.UnsafeUpdateValue(aSupportedModes[0].nFormat); XN_IS_STATUS_OK(nRetVal); } else { // just update input format nRetVal = m_InputFormat.UnsafeUpdateValue(nValidInputFormat); XN_IS_STATUS_OK(nRetVal); } nRetVal = AddSupportedModes(aSupportedModes, nCount); XN_IS_STATUS_OK(nRetVal); } else { XnArray<XnCmosPreset> supportedModes(30); // Uncompressed modes are only supported in ISO (not BULK) XnBool bUncompressedAllowed = m_Helper.GetPrivateData()->pSpecificImageUsb->pUsbConnection->bIsISO; // start with common modes supported by all nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_YUV422, XN_RESOLUTION_QVGA, 30); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_YUV422, XN_RESOLUTION_QVGA, 60); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_YUV422, XN_RESOLUTION_VGA, 30); XN_IS_STATUS_OK(nRetVal); // --avin mod-- nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_BAYER, XN_RESOLUTION_SXGA, 15); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_BAYER, XN_RESOLUTION_QVGA, 30); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_BAYER, XN_RESOLUTION_QVGA, 60); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_BAYER, XN_RESOLUTION_VGA, 30); XN_IS_STATUS_OK(nRetVal); // add uncompressed ones if (bUncompressedAllowed) { nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422, XN_RESOLUTION_QVGA, 30); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422, XN_RESOLUTION_QVGA, 60); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422, XN_RESOLUTION_VGA, 30); XN_IS_STATUS_OK(nRetVal); } // starting with FW 5.2, 25 FPS is also supported if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2) { nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_YUV422, XN_RESOLUTION_QVGA, 25); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_YUV422, XN_RESOLUTION_VGA, 25); XN_IS_STATUS_OK(nRetVal); if (bUncompressedAllowed) { nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422, XN_RESOLUTION_QVGA, 25); XN_IS_STATUS_OK(nRetVal); nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422, XN_RESOLUTION_VGA, 25); XN_IS_STATUS_OK(nRetVal); } } // high-res if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_3) { nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_BAYER, XN_RESOLUTION_SXGA, 30); XN_IS_STATUS_OK(nRetVal); // starting with 5.3.28, YUV is also supported in high-res if (m_Helper.GetPrivateData()->Version.nMajor > 5 || (m_Helper.GetPrivateData()->Version.nMajor == 5 && m_Helper.GetPrivateData()->Version.nMinor > 3) || (m_Helper.GetPrivateData()->Version.nMajor == 5 && m_Helper.GetPrivateData()->Version.nMinor == 3 && m_Helper.GetPrivateData()->Version.nBuild >= 28)) { nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_YUV422, XN_RESOLUTION_SXGA, 30); XN_IS_STATUS_OK(nRetVal); if (bUncompressedAllowed) { nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422, XN_RESOLUTION_SXGA, 30); XN_IS_STATUS_OK(nRetVal); } } } else if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2) { // on 5.2, high-res was UXGA nRetVal = AddSupportedMode(supportedModes, XN_IO_IMAGE_FORMAT_BAYER, XN_RESOLUTION_UXGA, 30); XN_IS_STATUS_OK(nRetVal); } // Add all supported modes to the stream nRetVal = AddSupportedModes(supportedModes.GetData(), supportedModes.GetSize()); XN_IS_STATUS_OK(nRetVal); if (!bUncompressedAllowed) { // update default input format nRetVal = m_InputFormat.UnsafeUpdateValue(XN_IO_IMAGE_FORMAT_YUV422); XN_IS_STATUS_OK(nRetVal); } } return (XN_STATUS_OK); }
XnStatus PlayerNode::HandleNewDataRecord(NewDataRecordHeader record, XnBool bReadPayload) { XN_VALIDATE_INPUT_PTR(m_pNodeNotifications); XnStatus nRetVal = record.Decode(); XN_IS_STATUS_OK(nRetVal); DEBUG_LOG_RECORD(record, "NewData"); XN_ASSERT(record.GetNodeID() != INVALID_NODE_ID); PlayerNodeInfo* pPlayerNodeInfo = GetPlayerNodeInfo(record.GetNodeID()); XN_VALIDATE_PTR(pPlayerNodeInfo, XN_STATUS_CORRUPT_FILE); if (!pPlayerNodeInfo->bValid) { XN_ASSERT(FALSE); return 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); } pPlayerNodeInfo->nLastDataPos = TellStream() - record.GetSize(); pPlayerNodeInfo->newDataUndoInfo.nRecordPos = pPlayerNodeInfo->nLastDataPos; pPlayerNodeInfo->newDataUndoInfo.nUndoRecordPos = record.GetUndoRecordPos(); if (record.GetFrameNumber() > pPlayerNodeInfo->nFrames) { XN_ASSERT(FALSE); return XN_STATUS_CORRUPT_FILE; } pPlayerNodeInfo->nCurFrame = record.GetFrameNumber(); if (record.GetTimeStamp() > m_nGlobalMaxTimeStamp) { XN_ASSERT(FALSE); XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Record timestamp for record in position %u is larger than reported max timestamp", pPlayerNodeInfo->nLastDataPos); } m_nTimeStamp = record.GetTimeStamp(); if (bReadPayload) { //Now read the actual data XnUInt32 nBytesRead = 0; nRetVal = Read(record.GetPayload(), 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"); } const XnUInt8* pCompressedData = record.GetPayload(); //The new (compressed) data is right at the end of the header XnUInt32 nCompressedDataSize = record.GetPayloadSize(); const XnUInt8* pUncompressedData = NULL; XnUInt32 nUncompressedDataSize = 0; XnCodecID compression = pPlayerNodeInfo->codec.GetCodecID(); if (compression == XN_CODEC_UNCOMPRESSED) { pUncompressedData = pCompressedData; nUncompressedDataSize = nCompressedDataSize; } else { //Decode data with codec nRetVal = pPlayerNodeInfo->codec.DecodeData(pCompressedData, nCompressedDataSize, m_pUncompressedData, DATA_MAX_SIZE, &nUncompressedDataSize); XN_IS_STATUS_OK(nRetVal); pUncompressedData = m_pUncompressedData; } nRetVal = m_pNodeNotifications->OnNodeNewData(m_pNotificationsCookie, pPlayerNodeInfo->strName, record.GetTimeStamp(), record.GetFrameNumber(), pUncompressedData, nUncompressedDataSize); XN_IS_STATUS_OK(nRetVal); } else { //Just skip the data nRetVal = SkipRecordPayload(record); XN_IS_STATUS_OK(nRetVal); } return XN_STATUS_OK; }
XnStatus XnExportedSensorImageGenerator::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors) { XnStatus nRetVal = XN_STATUS_OK; nRetVal = XnExportedSensorGenerator::EnumerateProductionTrees(context, TreesList, pErrors); XN_IS_STATUS_OK(nRetVal); XnStringToBoolHash Devices; // make sure device has image CMOS xn::NodeInfoList::Iterator it = TreesList.Begin(); while (it != TreesList.End()) { xn::NodeInfoList::Iterator curr = it; it++; xn::NodeInfo node = *curr; // take sensor node xn::NodeInfo sensorNode = *node.GetNeededNodes().Begin(); XnBool bHasImageCMOS = TRUE; if (XN_STATUS_OK != Devices.Get(sensorNode.GetCreationInfo(), bHasImageCMOS)) { // wasn't checked yet. check it now xn::Device sensor; nRetVal = sensorNode.GetInstance(sensor); XN_IS_STATUS_OK(nRetVal); XnBool bShouldCreated = (!sensor.IsValid()); if (bShouldCreated) { nRetVal = context.CreateProductionTree(sensorNode); XN_IS_STATUS_OK(nRetVal); nRetVal = sensorNode.GetInstance(sensor); XN_IS_STATUS_OK(nRetVal); } // This is an ugly patch to find out if this sensor has an image CMOS. It will be fixed // in future firmwares so we can just ask. XnCmosBlankingUnits units; units.nCmosID = XN_CMOS_TYPE_IMAGE; nRetVal = sensor.GetGeneralProperty(XN_MODULE_PROPERTY_CMOS_BLANKING_UNITS, sizeof(units), &units); if (nRetVal != XN_STATUS_OK || units.nUnits == 0) { // Failed. this means no image CMOS bHasImageCMOS = FALSE; } if (bShouldCreated) { sensor.Release(); } // add to checked list Devices.Set(sensorNode.GetCreationInfo(), bHasImageCMOS); } if (!bHasImageCMOS) { // remove it from enumeration nRetVal = TreesList.Remove(curr); XN_IS_STATUS_OK(nRetVal); } } if (TreesList.IsEmpty()) { return XN_STATUS_NO_NODE_PRESENT; } return (XN_STATUS_OK); }
XnStatus PlayerNode::SeekToFrameAbsolute(XnUInt32 nNodeID, XnUInt32 nDestFrame) { XN_ASSERT((nNodeID != INVALID_NODE_ID) && (nNodeID < m_nMaxNodes)); PlayerNodeInfo* pPlayerNodeInfo = &m_pNodeInfoMap[nNodeID]; XN_ASSERT((nDestFrame > 0) && (nDestFrame <= pPlayerNodeInfo->nFrames)); XN_VALIDATE_INPUT_PTR(m_pNodeNotifications); XnStatus nRetVal = XN_STATUS_OK; if (nDestFrame == pPlayerNodeInfo->nCurFrame) { //Just go back to position of current frame nRetVal = SeekStream(XN_OS_SEEK_SET, pPlayerNodeInfo->nLastDataPos); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; } DataIndexEntry** pDataIndex = GetSeekLocationsFromDataIndex(nNodeID, nDestFrame); if (pDataIndex != NULL) { off_t nLastPos = 0; // move each node to its relevant data for (XnUInt32 i = 0; i < m_nMaxNodes; i++) { if (m_aSeekTempArray[i] != NULL) { // read data nRetVal = SeekStream(XN_OS_SEEK_SET, m_aSeekTempArray[i]->nSeekPos); XN_IS_STATUS_OK(nRetVal); nRetVal = ReadNext(); XN_IS_STATUS_OK(nRetVal); // check for latest position. This will be directly after the frame we seeked to. off_t nPos = TellStream(); if (nPos > nLastPos) { nLastPos = nPos; } } } // now seek to directly after last position SeekStream(XN_OS_SEEK_SET, nLastPos); } else { // perform old seek off_t nStartPos = TellStream(); XnUInt32 nNextFrame = pPlayerNodeInfo->nCurFrame + 1; XnUInt32 nFrames = pPlayerNodeInfo->nFrames; XnStatus nRetVal = XN_STATUS_OK; if (nDestFrame == pPlayerNodeInfo->nCurFrame) { //Just go back to position of current frame nRetVal = SeekStream(XN_OS_SEEK_SET, pPlayerNodeInfo->nLastDataPos); XN_IS_STATUS_OK(nRetVal); } else if (nDestFrame < nNextFrame) { //Seek backwards off_t nDestRecordPos = pPlayerNodeInfo->newDataUndoInfo.nRecordPos; off_t nUndoRecordPos = pPlayerNodeInfo->newDataUndoInfo.nUndoRecordPos; NewDataRecordHeader record(m_pRecordBuffer, RECORD_MAX_SIZE); /*Scan back through the frames' undo positions until we get to a frame number that is smaller or equal to nDestFrame. We put the position of the frame we find in nDestRecordPos. */ do { if (nUndoRecordPos == 0) { /* The last frame we encountered doesn't have an undo frame. But this data frame can't be the first, so the file is corrupt */ XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Undo frame not found for frame in position %u", nDestRecordPos); } nRetVal = SeekStream(XN_OS_SEEK_SET, nUndoRecordPos); XN_IS_STATUS_OK(nRetVal); nDestRecordPos = nUndoRecordPos; record.ResetRead(); nRetVal = ReadRecordHeader(record); XN_IS_STATUS_OK(nRetVal); if (record.GetType() != RECORD_NEW_DATA) { XN_ASSERT(FALSE); XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Unexpected record type: %u", record.GetType()); } if (record.GetNodeID() != nNodeID) { XN_ASSERT(FALSE); XN_LOG_ERROR_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_OPEN_NI, "Unexpected node id: %u", record.GetNodeID()); } nRetVal = ReadRecordFields(record); XN_IS_STATUS_OK(nRetVal); nRetVal = record.Decode(); XN_IS_STATUS_OK(nRetVal); nUndoRecordPos = record.GetUndoRecordPos(); } while (record.GetFrameNumber() > nDestFrame); //Now handle the frame nRetVal = HandleNewDataRecord(record, FALSE); XnBool bUndone = FALSE; for (XnUInt32 i = 0; i < m_nMaxNodes; i++) { //Rollback all properties to match the state the stream was in at position nDestRecordPos PlayerNodeInfo &pni = m_pNodeInfoMap[i]; for (RecordUndoInfoMap::Iterator it = pni.recordUndoInfoMap.begin(); it != pni.recordUndoInfoMap.end(); it++) { if ((it.Value().nRecordPos > nDestRecordPos) && (it.Value().nRecordPos < nStartPos)) { //This property was set between nDestRecordPos and our start position, so we need to undo it. nRetVal = UndoRecord(it.Value(), nDestRecordPos, bUndone); XN_IS_STATUS_OK(nRetVal); } } if ((i != nNodeID) && pni.bIsGenerator) { //Undo all other generator nodes' data RecordUndoInfo &undoInfo = pni.newDataUndoInfo; if ((undoInfo.nRecordPos > nDestRecordPos) && (undoInfo.nRecordPos < nStartPos)) { nRetVal = UndoRecord(undoInfo, nDestRecordPos, bUndone); XN_IS_STATUS_OK(nRetVal); if (!bUndone) { //We couldn't find a record that can undo this data record pni.nLastDataPos = 0; pni.newDataUndoInfo.Reset(); } } } } /*Now, for each node, go to the position of the last encountered data record, and process that record (including its payload).*/ /*TODO: Optimization: remember each node's last data pos, and later, see if it changes. Only process data frames of nodes whose last data pos actually changed.*/ nRetVal = ProcessEachNodeLastData(nNodeID); XN_IS_STATUS_OK(nRetVal); } else //(nDestFrame >= nNextFrame) { //Skip all frames until we get to our frame number, but handle any properties we run into. while (pPlayerNodeInfo->nCurFrame < nDestFrame) { nRetVal = ProcessRecord(FALSE); XN_IS_STATUS_OK(nRetVal); } /*Now, for each node, go to the position of the last encountered data record, and process that record (including its payload).*/ /*TODO: Optimization: remember each node's last data pos, and later, see if it changes. Only process data frames of nodes whose last data pos actually changed.*/ nRetVal = ProcessEachNodeLastData(nNodeID); XN_IS_STATUS_OK(nRetVal); } } return XN_STATUS_OK; }
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); }
XnStatus XnSensorIRStream::SetCropping(const XnCropping* pCropping) { XnStatus nRetVal = XN_STATUS_OK; nRetVal = ValidateCropping(pCropping); XN_IS_STATUS_OK(nRetVal); xnOSEnterCriticalSection(GetLock()); if (m_Helper.GetFirmwareVersion() > XN_SENSOR_FW_VER_3_0) { nRetVal = m_Helper.StartFirmwareTransaction(); if (nRetVal != XN_STATUS_OK) { xnOSLeaveCriticalSection(GetLock()); return (nRetVal); } // mirror is done by software (meaning AFTER cropping, which is bad). So we need to flip the cropping area // to match requested area. XnUInt16 nXOffset = pCropping->nXOffset; if (IsMirrored()) { nXOffset = (XnUInt16)(GetXRes() - pCropping->nXOffset - pCropping->nXSize); } if (pCropping->bEnabled) { nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeX, pCropping->nXSize); if (nRetVal == XN_STATUS_OK) nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeY, pCropping->nYSize); if (nRetVal == XN_STATUS_OK) nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetX, nXOffset); if (nRetVal == XN_STATUS_OK) nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetY, pCropping->nYOffset); } if (nRetVal == XN_STATUS_OK) { nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropEnabled, (XnUInt16)pCropping->bEnabled); } if (nRetVal != XN_STATUS_OK) { m_Helper.RollbackFirmwareTransaction(); m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY); xnOSLeaveCriticalSection(GetLock()); return (nRetVal); } nRetVal = m_Helper.CommitFirmwareTransactionAsBatch(); if (nRetVal != XN_STATUS_OK) { m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY); xnOSLeaveCriticalSection(GetLock()); return (nRetVal); } } nRetVal = XnIRStream::SetCropping(pCropping); xnOSLeaveCriticalSection(GetLock()); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
XnStatus PlayerImpl::SetNodeNewData(const XnChar* strNodeName, XnUInt64 nTimeStamp, XnUInt32 nFrame, const void* pData, XnUInt32 nSize) { XnStatus nRetVal = XN_STATUS_OK; XnUInt64 nNow; xnOSGetHighResTimeStamp(&nNow); if (!m_bHasTimeReference) { m_nStartTimestamp = nTimeStamp; m_nStartTime = nNow; m_bHasTimeReference = TRUE; } if (m_dPlaybackSpeed != XN_PLAYBACK_SPEED_FASTEST) { // check this data timestamp compared to when we started XnInt64 nTimestampDiff = nTimeStamp - m_nStartTimestamp; XnInt64 nTimeDiff = nNow - m_nStartTime; // check if we need to wait some time XnInt64 nRequestedTimeDiff = (XnInt64)(nTimestampDiff / m_dPlaybackSpeed); if (nTimeDiff < nRequestedTimeDiff) { xnOSSleep(XnUInt32((nRequestedTimeDiff - nTimeDiff)/1000)); } // update reference to current frame (this will handle cases in which application // stopped reading frames and continued after a while) m_nStartTimestamp = nTimeStamp; xnOSGetHighResTimeStamp(&m_nStartTime); } PlayedNodeInfo playedNode; nRetVal = m_playedNodes.Get(strNodeName, playedNode); XN_IS_STATUS_OK(nRetVal); nRetVal = xnLockedNodeStartChanges(playedNode.hNode, playedNode.hLock); XN_IS_STATUS_OK(nRetVal); nRetVal = xnSetIntProperty(playedNode.hNode, XN_PROP_TIMESTAMP, nTimeStamp); if (nRetVal != XN_STATUS_OK) { xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); return (nRetVal); } nRetVal = xnSetIntProperty(playedNode.hNode, XN_PROP_FRAME_ID, nFrame); if (nRetVal != XN_STATUS_OK) { xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); return (nRetVal); } nRetVal = xnSetGeneralProperty(playedNode.hNode, XN_PROP_NEWDATA, nSize, pData); if (nRetVal != XN_STATUS_OK) { xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); return (nRetVal); } nRetVal = xnLockedNodeEndChanges(playedNode.hNode, playedNode.hLock); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
XnStatus XnSensorFirmwareParams::CommitTransactionAsBatch() { XnStatus nRetVal = XN_STATUS_OK; if (!m_bInTransaction) { return XN_STATUS_ERROR; } // we are no longer in transaction, even if we fail to commit. m_bInTransaction = FALSE; if (m_TransactionOrder.Size() != 0) { XnUInt32 nMaxCount = m_TransactionOrder.Size(); XnInnerParamData* pParams; XN_VALIDATE_CALLOC(pParams, XnInnerParamData, nMaxCount); XnChar strLogMessage[1024]; XnUInt32 nMaxLength = 1024; XnUInt32 nLength = 0; XnUInt32 nChars; xnOSStrFormat(strLogMessage + nLength, nMaxLength - nLength, &nChars, "Setting firmware params:\n\t"); nLength += nChars; XnUInt32 nCount = 0; for (XnActualIntPropertyList::Iterator it = m_TransactionOrder.begin(); it != m_TransactionOrder.end(); ++it) { XnActualIntProperty* pProp = *it; XnUInt32 nValue; nRetVal = m_Transaction.Get(pProp, nValue); if (nRetVal != XN_STATUS_OK) { xnOSFree(pParams); return (nRetVal); } XnFirmwareParam* pParam; nRetVal = CheckFirmwareParam(pProp, nValue, &pParam); if (nRetVal != XN_STATUS_OK) { xnOSFree(pParams); return (nRetVal); } if (pParam != NULL) { xnOSStrFormat(strLogMessage + nLength, nMaxLength - nLength, &nChars, "%s = %u\n\t", pProp->GetName(), nValue); nLength += nChars; pParams[nCount].nParam = pParam->nFirmwareParam; pParams[nCount].nValue = (XnUInt16)nValue; nCount++; } } xnLogVerbose(XN_MASK_SENSOR_PROTOCOL, "%s", strLogMessage); // set all params nRetVal = m_pCommands->SetMultipleFirmwareParams(pParams, nCount); xnOSFree(pParams); XN_IS_STATUS_OK(nRetVal); // and update their props for (XnActualIntPropertyList::Iterator it = m_TransactionOrder.begin(); it != m_TransactionOrder.end(); ++it) { XnActualIntProperty* pProp = *it; XnUInt32 nValue; nRetVal = m_Transaction.Get(pProp, nValue); XN_IS_STATUS_OK(nRetVal); nRetVal = pProp->UnsafeUpdateValue(nValue); XN_IS_STATUS_OK(nRetVal); } } m_Transaction.Clear(); m_TransactionOrder.Clear(); return (XN_STATUS_OK); }
XnStatus XnSensor::InitSensor(const XnDeviceConfig* pDeviceConfig) { XnStatus nRetVal = XN_STATUS_OK; XnDevicePrivateData* pDevicePrivateData = GetDevicePrivateData(); pDevicePrivateData->pSensor = this; pDevicePrivateData->nDepthFramePos = 0; pDevicePrivateData->nImageFramePos = 0; xnOSMemCopy(&pDevicePrivateData->DeviceConfig, pDeviceConfig, sizeof(XnDeviceConfig)); xnOSMemSet(pDevicePrivateData->cpSensorID, 0, XN_SENSOR_PROTOCOL_SENSOR_ID_LENGTH); pDevicePrivateData->bSyncAudio = TRUE; switch (pDeviceConfig->DeviceMode) { case XN_DEVICE_MODE_READ: break; case XN_DEVICE_MODE_WRITE: return (XN_STATUS_IO_DEVICE_MODE_NOT_SUPPORTED); default: return (XN_STATUS_IO_DEVICE_INVALID_MODE); } // Register USB event callback #if WIN32 nRetVal = m_SensorIO.SetCallback(&USBEventCallback, this); XN_IS_STATUS_OK(nRetVal); #endif // open IO nRetVal = m_SensorIO.OpenDevice(pDeviceConfig->cpConnectionString); XN_IS_STATUS_OK(nRetVal); nRetVal = m_USBPath.UnsafeUpdateValue(m_SensorIO.GetDevicePath()); XN_IS_STATUS_OK(nRetVal); // initialize nRetVal = XnDeviceSensorInit(pDevicePrivateData); XN_IS_STATUS_OK(nRetVal); // init firmware nRetVal = m_Firmware.Init((XnBool)m_ResetSensorOnStartup.GetValue()); XN_IS_STATUS_OK(nRetVal); m_bInitialized = TRUE; m_ResetSensorOnStartup.UpdateSetCallback(NULL, NULL); // Init modules nRetVal = m_FixedParams.Init(); XN_IS_STATUS_OK(nRetVal); XnDeviceInformation deviceInfo; strcpy(deviceInfo.strDeviceName, "PrimeSense Sensor"); strcpy(deviceInfo.strVendorData, ""); // try to take device information (only supported from 5.3.25) if (pDevicePrivateData->Version.nMajor > 5 || (pDevicePrivateData->Version.nMajor == 5 && pDevicePrivateData->Version.nMinor > 3) || (pDevicePrivateData->Version.nMajor == 5 && pDevicePrivateData->Version.nMinor == 3 && pDevicePrivateData->Version.nBuild >= 25)) { nRetVal = XnHostProtocolAlgorithmParams(pDevicePrivateData, XN_HOST_PROTOCOL_ALGORITHM_DEVICE_INFO, &deviceInfo, sizeof(deviceInfo), (XnResolutions)0, 0); XN_IS_STATUS_OK(nRetVal); } nRetVal = m_DeviceName.UnsafeUpdateValue(deviceInfo.strDeviceName); XN_IS_STATUS_OK(nRetVal); nRetVal = m_VendorSpecificData.UnsafeUpdateValue(deviceInfo.strVendorData); XN_IS_STATUS_OK(nRetVal); // update serial number nRetVal = m_ID.UnsafeUpdateValue(m_FixedParams.GetSensorSerial()); XN_IS_STATUS_OK(nRetVal); AddSupportedStream(XN_STREAM_TYPE_DEPTH); AddSupportedStream(XN_STREAM_TYPE_IMAGE); AddSupportedStream(XN_STREAM_TYPE_IR); AddSupportedStream(XN_STREAM_TYPE_AUDIO); return XN_STATUS_OK; }
XnStatus XnSensorDepthStream::MapPropertiesToFirmware() { XnStatus nRetVal = XN_STATUS_OK; XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_InputFormat, GetFirmwareParams()->m_DepthFormat, FALSE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(ResolutionProperty(), GetFirmwareParams()->m_DepthResolution, FALSE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(FPSProperty(), GetFirmwareParams()->m_DepthFPS, FALSE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_HoleFilter, GetFirmwareParams()->m_DepthHoleFilter, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_Gain, GetFirmwareParams()->m_DepthGain, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_WhiteBalance, GetFirmwareParams()->m_DepthWhiteBalance, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_FirmwareMirror, GetFirmwareParams()->m_DepthMirror, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_FirmwareRegistration, GetFirmwareParams()->m_RegistrationEnabled, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_FirmwareCropSizeX, GetFirmwareParams()->m_DepthCropSizeX, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_FirmwareCropSizeY, GetFirmwareParams()->m_DepthCropSizeY, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_FirmwareCropOffsetX, GetFirmwareParams()->m_DepthCropOffsetX, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_FirmwareCropOffsetY, GetFirmwareParams()->m_DepthCropOffsetY, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_FirmwareCropEnabled, GetFirmwareParams()->m_DepthCropEnabled, TRUE)); XN_IS_STATUS_OK(m_Helper.MapFirmwareProperty(m_GMCMode, GetFirmwareParams()->m_GMCMode, TRUE)); return (XN_STATUS_OK); }
XnStatus XnSensor::OpenAllStreams() { XnStatus nRetVal = XN_STATUS_OK; xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Opening all streams..."); // take a list of all the streams const XnChar* astrStreams[XN_SENSOR_MAX_STREAM_COUNT]; XnUInt32 nStreamCount = XN_SENSOR_MAX_STREAM_COUNT; XnDeviceStream* apStreams[XN_SENSOR_MAX_STREAM_COUNT]; XnSensorStreamHolder* apSensorStreams[XN_SENSOR_MAX_STREAM_COUNT]; nRetVal = GetStreamNames(astrStreams, &nStreamCount); XN_IS_STATUS_OK(nRetVal); for (XnUInt32 i = 0; i < nStreamCount; ++i) { XnDeviceModuleHolder* pHolder; nRetVal = FindStream(astrStreams[i], &pHolder); XN_IS_STATUS_OK(nRetVal); apSensorStreams[i] = (XnSensorStreamHolder*)(pHolder); apStreams[i] = apSensorStreams[i]->GetStream(); } // NOTE: the following is an ugly patch. When depth and IR both exist, Depth stream MUST be configured // and opened BEFORE IR stream. So, generally, if one of the streams is depth, we move it to be first. for (XnUInt32 i = 1; i < nStreamCount; ++i) { if (strcmp(apStreams[i]->GetType(), XN_STREAM_TYPE_DEPTH) == 0) { // switch it with the one in location 0 const XnChar* strTempName = astrStreams[0]; XnDeviceStream* pTempStream = apStreams[0]; XnSensorStreamHolder* pTempHolder = apSensorStreams[0]; astrStreams[0] = astrStreams[i]; apStreams[0] = apStreams[i]; apSensorStreams[0] = apSensorStreams[i]; astrStreams[i] = strTempName; apStreams[i] = pTempStream; apSensorStreams[i] = pTempHolder; break; } } // now configure them all for (XnUInt32 i = 0; i < nStreamCount; ++i) { if (!apStreams[i]->IsOpen()) { xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Configuring stream %s...", apStreams[i]->GetName()); nRetVal = apSensorStreams[i]->Configure(); XN_IS_STATUS_OK(nRetVal); xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Stream %s is configured", apStreams[i]->GetName()); } else { xnLogVerbose(XN_MASK_DEVICE_SENSOR, "Stream %s is already open.", apStreams[i]->GetName()); } } // and open them all for (XnUInt32 i = 0; i < nStreamCount; ++i) { if (!apStreams[i]->IsOpen()) { nRetVal = apSensorStreams[i]->FinalOpen(); XN_IS_STATUS_OK(nRetVal); } } return (XN_STATUS_OK); }
XnStatus XnSensorDepthStream::SetCropping(const XnCropping* pCropping) { XnStatus nRetVal = XN_STATUS_OK; nRetVal = ValidateCropping(pCropping); XN_IS_STATUS_OK(nRetVal); xnOSEnterCriticalSection(GetLock()); if (m_Helper.GetFirmwareVersion() > XN_SENSOR_FW_VER_3_0) { nRetVal = m_Helper.StartFirmwareTransaction(); if (nRetVal != XN_STATUS_OK) { xnOSLeaveCriticalSection(GetLock()); return (nRetVal); } if (pCropping->bEnabled) { nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeX, pCropping->nXSize); if (nRetVal == XN_STATUS_OK) nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeY, pCropping->nYSize); if (nRetVal == XN_STATUS_OK) nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetX, pCropping->nXOffset); if (nRetVal == XN_STATUS_OK) nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetY, pCropping->nYOffset); } if (nRetVal == XN_STATUS_OK) nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropEnabled, pCropping->bEnabled); if (nRetVal != XN_STATUS_OK) { m_Helper.RollbackFirmwareTransaction(); m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY); xnOSLeaveCriticalSection(GetLock()); return (nRetVal); } nRetVal = m_Helper.CommitFirmwareTransactionAsBatch(); if (nRetVal != XN_STATUS_OK) { m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX); m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX); m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY); xnOSLeaveCriticalSection(GetLock()); return (nRetVal); } } nRetVal = XnDepthStream::SetCropping(pCropping); xnOSLeaveCriticalSection(GetLock()); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
//--------------------------------------------------------------------------- // Code //--------------------------------------------------------------------------- XnStatus XnCodecFactory::Create(XnCompressionFormats nFormat, XnDeviceModule* pStream, const XnChar* /*StreamName*/, XnCodec** ppCodec) { XnStatus nRetVal = XN_STATUS_OK; XnCodec* pCodec = NULL; switch (nFormat) { case XN_COMPRESSION_NONE: { XN_VALIDATE_NEW_AND_INIT(pCodec, XnUncompressedCodec); } break; case XN_COMPRESSION_16Z: { XN_VALIDATE_NEW_AND_INIT(pCodec, Xn16zCodec); } break; case XN_COMPRESSION_16Z_EMB_TABLE: { // first we need to find max depth XnUInt64 nMaxDepth; nRetVal = pStream->GetProperty(XN_STREAM_PROPERTY_MAX_DEPTH, &nMaxDepth); XN_IS_STATUS_OK(nRetVal); XN_VALIDATE_NEW_AND_INIT(pCodec, Xn16zEmbTablesCodec, (XnDepthPixel)nMaxDepth); } break; case XN_COMPRESSION_COLOR_8Z: { XN_VALIDATE_NEW_AND_INIT(pCodec, Xn8zCodec); } break; case XN_COMPRESSION_JPEG: { // check what is the output format XnUInt64 nOutputFormat; nRetVal = pStream->GetProperty(XN_STREAM_PROPERTY_OUTPUT_FORMAT, &nOutputFormat); XN_IS_STATUS_OK(nRetVal); XnBool bRGB = FALSE; switch (nOutputFormat) { case XN_OUTPUT_FORMAT_GRAYSCALE8: bRGB = FALSE; break; case XN_OUTPUT_FORMAT_RGB24: bRGB = TRUE; break; default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Codec factory currently supports JPEG codec only for streams of type Gray8 or RGB24!"); } // take X and Y res XnUInt64 nXRes, nYRes; nRetVal = pStream->GetProperty(XN_STREAM_PROPERTY_X_RES, &nXRes); XN_IS_STATUS_OK(nRetVal); nRetVal = pStream->GetProperty(XN_STREAM_PROPERTY_Y_RES, &nYRes); XN_IS_STATUS_OK(nRetVal); XN_VALIDATE_NEW_AND_INIT(pCodec, XnJpegCodec, bRGB, (XnUInt32)nXRes, (XnUInt32)nYRes); } break; default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DDK, "Codec factory does not support compression type %d", nFormat); } *ppCodec = pCodec; return (XN_STATUS_OK); }
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); }
XnStatus XnFileDevice::HandleNewStream(const XnChar *strType, const XnChar *strName, const XnActualPropertiesHash *pInitialValues) { XnStatus nRetVal = XN_STATUS_OK; // check if we need to ignore that (stream was not removed upon Rewind). XnNodeInfoMap::Iterator it = m_ignoreNewNodes.end(); if (m_ignoreNewNodes.Find(strName, it) == XN_STATUS_OK) { // ignore return (XN_STATUS_OK); } XnProductionNodeType type = GetNodeType(strType); if (type == -1) { XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid node type: %s", strType); } // find compression type XnActualIntProperty* pComp; nRetVal = pInitialValues->Get(XN_STREAM_PROPERTY_COMPRESSION, (XnProperty*&)pComp); XN_IS_STATUS_OK(nRetVal); XnCodecID codecID = XnCodec::GetCodecIDFromCompressionFormat((XnCompressionFormats)pComp->GetValue()); if (codecID == XN_CODEC_NULL) { XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid compression type: %llu", pComp->GetValue()); } // notify we have a new node nRetVal = m_pNotifications->OnNodeAdded(m_pNotificationsCookie, strName, type, codecID); XN_IS_STATUS_OK(nRetVal); // we support the mirror capability nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_MIRROR, 1); XN_IS_STATUS_OK(nRetVal); // we support the extended serialization capability nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_EXTENDED_SERIALIZATION, 1); XN_IS_STATUS_OK(nRetVal); // now write state for (XnActualPropertiesHash::ConstIterator it = pInitialValues->begin(); it != pInitialValues->end(); ++it) { XnProperty* pProp = it.Value(); switch (pProp->GetType()) { case XN_PROPERTY_TYPE_INTEGER: { XnActualIntProperty* pIntProp = (XnActualIntProperty*)pProp; nRetVal = HandleIntProperty(strName, pProp->GetName(), pIntProp->GetValue()); } break; case XN_PROPERTY_TYPE_REAL: { XnActualRealProperty* pRealProp = (XnActualRealProperty*)pProp; nRetVal = HandleRealProperty(strName, pProp->GetName(), pRealProp->GetValue()); } break; case XN_PROPERTY_TYPE_STRING: { XnActualStringProperty* pStrProp = (XnActualStringProperty*)pProp; nRetVal = HandleStringProperty(strName, pProp->GetName(), pStrProp->GetValue()); } break; case XN_PROPERTY_TYPE_GENERAL: { XnActualGeneralProperty* pGenProp = (XnActualGeneralProperty*)pProp; nRetVal = HandleGeneralProperty(strName, pProp->GetName(), pGenProp->GetValue()); } break; default: XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_FILE, "Unknown property type: %d", pProp->GetType()); } XN_IS_STATUS_OK(nRetVal); } // at this stage, a node should exist with this name xn::ProductionNode node; nRetVal = m_context.GetProductionNodeByName(strName, node); XN_IS_STATUS_OK(nRetVal); // S2D & RW if (type == XN_NODE_TYPE_DEPTH) { nRetVal = UpdateS2DTables(xn::DepthGenerator(node)); XN_IS_STATUS_OK(nRetVal); nRetVal = UpdateRWData(xn::DepthGenerator(node)); XN_IS_STATUS_OK(nRetVal); } // notify end-of-state nRetVal = m_pNotifications->OnNodeStateReady(m_pNotificationsCookie, strName); XN_IS_STATUS_OK(nRetVal); // add it to the map XnNodeInfo nodeInfo = {0}; nRetVal = m_nodeInfoMap.Set(strName, nodeInfo); XN_IS_STATUS_OK(nRetVal); // create codec nRetVal = CreateCodec(node); XN_IS_STATUS_OK(nRetVal); // check IR compatibility nRetVal = CheckIRCompatibility(node); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }