XnStatus XnFrameStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnDeviceStream::Init();
XN_IS_STATUS_OK(nRetVal);
XN_VALIDATE_ADD_PROPERTIES(this, &m_IsFrameStream, &m_FPS, &m_LastRawFrame);
XnCallbackHandle hDummy;
// be notified when required size changes
nRetVal = RequiredSizeProperty().OnChangeEvent().Register(RequiredSizeChangedCallback, this, &hDummy);
XN_IS_STATUS_OK(nRetVal);
if (m_pBufferPool == NULL)
{
XN_VALIDATE_NEW(m_pBufferPool, XnSimpleBufferPool, 3);
m_bPoolAllocated = TRUE;
}
// allocate buffer manager
XN_VALIDATE_NEW(m_pBufferManager, XnFrameBufferManager, m_pBufferPool);
nRetVal = m_pBufferManager->Init(GetRequiredDataSize());
XN_IS_STATUS_OK(nRetVal);
// register for new data events
nRetVal = m_pBufferManager->OnNewFrameEvent().Register(OnTripleBufferNewData, this, &hDummy);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnShiftToDepthStreamHelper::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// old depth streams did not have S2D tables as actual properties. Add these properties
XnBool bDoesExist = FALSE;
nRetVal = m_pModule->DoesPropertyExist(XN_STREAM_PROPERTY_S2D_TABLE, &bDoesExist);
XN_IS_STATUS_OK(nRetVal);
if (!bDoesExist)
{
// add properties to the module
XN_VALIDATE_ADD_PROPERTIES(m_pModule, &m_ShiftToDepthTable, &m_DepthToShiftTable);
m_bPropertiesAdded = TRUE;
// now create tables and register to properties
nRetVal = InitShiftToDepth();
XN_IS_STATUS_OK(nRetVal);
}
else
{
m_ShiftToDepthTables.pShiftToDepthTable = (XnDepthPixel*)m_ShiftToDepthTable.GetValue().pData;
m_ShiftToDepthTables.pDepthToShiftTable = (XnUInt16*)m_DepthToShiftTable.GetValue().pData;
}
return (XN_STATUS_OK);
}
XnStatus XnSensorIRStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// nRetVal = SetBufferPool(&m_BufferPool);
// XN_IS_STATUS_OK(nRetVal);
// init base
nRetVal = XnIRStream::Init();
XN_IS_STATUS_OK(nRetVal);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_InputFormat, &m_ActualRead, &m_CroppingMode);
// set base properties default values
nRetVal = ResolutionProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_RESOLUTION);
XN_IS_STATUS_OK(nRetVal);
nRetVal = FPSProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_FPS);
XN_IS_STATUS_OK(nRetVal);
nRetVal = OutputFormatProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_OUTPUT_FORMAT);
XN_IS_STATUS_OK(nRetVal);
// init helper
nRetVal = m_Helper.Init(this, this);
XN_IS_STATUS_OK(nRetVal);
// register supported modes
XnCmosPreset* pSupportedModes = m_Helper.GetPrivateData()->FWInfo.irModes.GetData();
XnUInt32 nSupportedModes = m_Helper.GetPrivateData()->FWInfo.irModes.GetSize();
nRetVal = AddSupportedModes(pSupportedModes, nSupportedModes);
XN_IS_STATUS_OK(nRetVal);
// data processor
nRetVal = m_Helper.RegisterDataProcessorProperty(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);
// register for mirror
XnCallbackHandle hCallbackDummy;
nRetVal = IsMirroredProperty().OnChangeEvent().Register(IsMirroredChangedCallback, this, hCallbackDummy);
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);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_InputFormat, &m_AntiFlicker, &m_ImageQuality,
&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);
return (XN_STATUS_OK);
}
XnStatus XnFrameStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnDeviceStream::Init();
XN_IS_STATUS_OK(nRetVal);
XN_VALIDATE_ADD_PROPERTIES(this, &m_IsFrameStream, &m_FPS, &m_LastRawFrame, &m_externalBufferPool );
XnCallbackHandle hDummy;
// be notified when required size changes
nRetVal = RequiredSizeProperty().OnChangeEvent().Register(RequiredSizeChangedCallback, this, hDummy);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDepthStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnPixelStream::Init();
XN_IS_STATUS_OK(nRetVal);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_MinDepth, &m_MaxDepth, &m_ConstShift, &m_PixelSizeFactor,
&m_MaxShift, &m_ParamCoefficient, &m_ShiftScale, &m_ZeroPlaneDistance, &m_ZeroPlanePixelSize,
&m_EmitterDCmosDistance, &m_NoDepthValue, &m_ShadowValue, &m_DeviceMaxDepth);
nRetVal = m_S2DHelper.Init();
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnFrameStream::Init();
XN_IS_STATUS_OK(nRetVal);
// update set callbacks
m_Resolution.UpdateSetCallback(SetResolutionCallback, this);
m_XRes.UpdateSetCallback(SetXResCallback, this);
m_YRes.UpdateSetCallback(SetYResCallback, this);
m_Cropping.UpdateSetCallback(SetCroppingCallback, this);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_IsPixelStream, &m_Resolution, &m_XRes, &m_YRes,
&m_BytesPerPixel, &m_Cropping, &m_SupportedModesCount, &m_SupportedModes);
// register required size properties
nRetVal = RegisterRequiredSizeProperty(&m_XRes);
XN_IS_STATUS_OK(nRetVal);
nRetVal = RegisterRequiredSizeProperty(&m_YRes);
XN_IS_STATUS_OK(nRetVal);
nRetVal = RegisterRequiredSizeProperty(&m_BytesPerPixel);
XN_IS_STATUS_OK(nRetVal);
// register for important properties
XnCallbackHandle hDummyCallback;
nRetVal = m_Resolution.OnChangeEvent().Register(ResolutionValueChangedCallback, this, &hDummyCallback);
XN_IS_STATUS_OK(nRetVal);
nRetVal = OutputFormatProperty().OnChangeEvent().Register(OutputFormatValueChangedCallback, this, &hDummyCallback);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_XRes.OnChangeEvent().Register(FixCroppingCallback, this, &hDummyCallback);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_YRes.OnChangeEvent().Register(FixCroppingCallback, this, &hDummyCallback);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnAudioStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnStreamingStream::Init();
XN_IS_STATUS_OK(nRetVal);
m_SampleRate.UpdateSetCallback(SetSampleRateCallback, this);
m_NumberOfChannels.UpdateSetCallback(SetNumberOfChannelsCallback, this);
XN_VALIDATE_ADD_PROPERTIES(this, &m_SampleRate, &m_NumberOfChannels);
// required size
nRetVal = RegisterRequiredSizeProperty(&m_SampleRate);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnDeviceStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init module
nRetVal = XnDeviceModule::Init();
XN_IS_STATUS_OK(nRetVal);
// cs
nRetVal = xnOSCreateCriticalSection(&m_hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
m_IsOpen.UpdateSetCallback(SetIsOpenCallback, this);
m_OutputFormat.UpdateSetCallback(SetOutputFormatCallback, this);
m_IsMirrored.UpdateSetCallback(SetIsMirrorCallback, this);
XN_VALIDATE_ADD_PROPERTIES(this, &m_IsStream, &m_Type, &m_IsOpen, &m_OutputFormat, &m_RequiredSize, &m_IsMirrored);
return (XN_STATUS_OK);
}
XnStatus XnDepthStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnPixelStream::Init();
XN_IS_STATUS_OK(nRetVal);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_MinDepth, &m_MaxDepth, &m_ConstShift, &m_PixelSizeFactor,
&m_MaxShift, &m_ParamCoefficient, &m_ShiftScale, &m_ZeroPlaneDistance, &m_ZeroPlanePixelSize,
&m_EmitterDCmosDistance, &m_GetDCmosRCmosDistance, &m_DeviceMaxDepth);
nRetVal = OutputFormatProperty().UnsafeUpdateValue(ONI_PIXEL_FORMAT_DEPTH_1_MM);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_S2DHelper.Init(this);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnSensorAudioStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnAudioStream::Init();
XN_IS_STATUS_OK(nRetVal);
// init helper
nRetVal = m_Helper.Init(this, this);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_buffer.hLock);
XN_IS_STATUS_OK(nRetVal);
nRetVal = SetReadChunkSize(XN_AUDIO_STREAM_DEFAULT_CHUNK_SIZE);
XN_IS_STATUS_OK(nRetVal);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_LeftChannelVolume, &m_RightChannelVolume, &m_ActualRead);
// check what's the firmware audio packet size
if (m_Helper.GetPrivateData()->SensorHandle.MiscConnection.bIsISO)
m_nOrigAudioPacketSize = XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_ISO;
else
m_nOrigAudioPacketSize = XN_SENSOR_PROTOCOL_AUDIO_PACKET_SIZE_BULK;
// alloc buffer
nRetVal = ReallocBuffer();
XN_IS_STATUS_OK(nRetVal);
m_buffer.pAudioCallback = NewDataCallback;
m_buffer.pAudioCallbackCookie = this;
// data processor
nRetVal = m_Helper.RegisterDataProcessorProperty(NumberOfChannelsProperty());
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnStreamDeviceStreamHolder::Init(const XnActualPropertiesHash* pProps)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_ADD_PROPERTIES(GetStream(), &m_Compression);
nRetVal = XnDeviceModuleHolder::Init(pProps);
XN_IS_STATUS_OK(nRetVal);
// create codec
nRetVal = m_CodecProperties.Set(&m_Compression, &m_Compression);
XN_IS_STATUS_OK(nRetVal);
XnCallbackHandle hDummy;
nRetVal = m_Compression.OnChangeEvent().Register(CodecPropertyChangedCallback, this, hDummy);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ChooseCodec();
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnSensorIRStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = SetBufferPool(&m_BufferPool);
XN_IS_STATUS_OK(nRetVal);
// init base
nRetVal = XnIRStream::Init();
XN_IS_STATUS_OK(nRetVal);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_SharedBufferName, &m_ActualRead);
// set base properties default values
nRetVal = ResolutionProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_RESOLUTION);
XN_IS_STATUS_OK(nRetVal);
nRetVal = FPSProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_FPS);
XN_IS_STATUS_OK(nRetVal);
nRetVal = OutputFormatProperty().UnsafeUpdateValue(XN_IR_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(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);
// register for mirror
XnCallbackHandle hCallbackDummy;
nRetVal = IsMirroredProperty().OnChangeEvent().Register(IsMirroredChangedCallback, this, &hCallbackDummy);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnShiftToDepthStreamHelper::Init(XnDeviceModule* pModule)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pModule);
m_pModule = pModule;
// old depth streams did not have S2D tables as actual properties. Add these properties
XnBool bDoesExist = FALSE;
nRetVal = m_pModule->DoesPropertyExist(XN_STREAM_PROPERTY_S2D_TABLE, &bDoesExist);
XN_IS_STATUS_OK(nRetVal);
if (!bDoesExist)
{
// add properties to the module
XN_VALIDATE_ADD_PROPERTIES(m_pModule, &m_ShiftToDepthTable, &m_DepthToShiftTable);
m_bPropertiesAdded = TRUE;
// now create tables and register to properties
XnIntProperty* pDeviceIDProperty;
XnUInt64* pDeviceID = 0;
pModule->GetProperty(XN_MODULE_PROPERTY_SERIAL_NUMBER, &pDeviceIDProperty);
pDeviceIDProperty->GetValue(pDeviceID);
xnLogVerbose("S2D", "S2D table init for sensor ID %d.", pDeviceID);
nRetVal = InitShiftToDepth();
XN_IS_STATUS_OK(nRetVal);
}
else
{
m_ShiftToDepthTables.pShiftToDepthTable = (OniDepthPixel*)m_ShiftToDepthTable.GetValue().data;
m_ShiftToDepthTables.pDepthToShiftTable = (XnUInt16*)m_DepthToShiftTable.GetValue().data;
}
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);
if (m_Helper.GetPrivateData()->pSensor->IsLowBandwidth())
{
nRetVal = m_InputFormat.UnsafeUpdateValue(XN_IO_DEPTH_FORMAT_COMPRESSED_PS);
XN_IS_STATUS_OK(nRetVal);
}
// 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);
nRetVal = GetDCmosRCmosDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetDCmosRCmosDistance());
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)
{
nRetVal = m_GMCMode.UnsafeUpdateValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
}
if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_4_0)
{
nRetVal = m_WhiteBalance.UnsafeUpdateValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
}
// 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);
// register supported modes
XnCmosPreset aSupportedModes[] =
{
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_QVGA, 30 },
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_QVGA, 60 },
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_VGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_QVGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_QVGA, 60 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_VGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_QVGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_QVGA, 60 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_VGA, 30 },
};
nRetVal = AddSupportedModes(aSupportedModes, sizeof(aSupportedModes)/sizeof(aSupportedModes[0]));
XN_IS_STATUS_OK(nRetVal);
if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2)
{
XnCmosPreset aSupportedModes25[] =
{
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_QVGA, 25 },
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_VGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_QVGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_VGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_QVGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_VGA, 25 },
};
nRetVal = AddSupportedModes(aSupportedModes25, sizeof(aSupportedModes25)/sizeof(aSupportedModes25[0]));
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnSensorIRStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = SetBufferPool(&m_BufferPool);
XN_IS_STATUS_OK(nRetVal);
// init base
nRetVal = XnIRStream::Init();
XN_IS_STATUS_OK(nRetVal);
// add properties
XN_VALIDATE_ADD_PROPERTIES(this, &m_InputFormat, &m_SharedBufferName, &m_ActualRead);
// set base properties default values
nRetVal = ResolutionProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_RESOLUTION);
XN_IS_STATUS_OK(nRetVal);
nRetVal = FPSProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_FPS);
XN_IS_STATUS_OK(nRetVal);
nRetVal = OutputFormatProperty().UnsafeUpdateValue(XN_IR_STREAM_DEFAULT_OUTPUT_FORMAT);
XN_IS_STATUS_OK(nRetVal);
// init helper
nRetVal = m_Helper.Init(this, this);
XN_IS_STATUS_OK(nRetVal);
// register supported modes
XnCmosPreset aSupportedModes[] =
{
{ 0, XN_RESOLUTION_QVGA, 30 },
{ 0, XN_RESOLUTION_QVGA, 60 },
{ 0, XN_RESOLUTION_VGA, 30 },
{ 0, XN_RESOLUTION_SXGA, 30 },
};
nRetVal = AddSupportedModes(aSupportedModes, sizeof(aSupportedModes)/sizeof(aSupportedModes[0]));
XN_IS_STATUS_OK(nRetVal);
if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_1)
{
XnCmosPreset aSupportedModesSXGA[] =
{
{ 0, XN_RESOLUTION_SXGA, 30 },
};
nRetVal = AddSupportedModes(aSupportedModesSXGA, sizeof(aSupportedModesSXGA)/sizeof(aSupportedModesSXGA[0]));
XN_IS_STATUS_OK(nRetVal);
}
if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2)
{
XnCmosPreset aSupportedModes25[] =
{
{ 0, XN_RESOLUTION_QVGA, 25 },
{ 0, XN_RESOLUTION_VGA, 25 },
};
nRetVal = AddSupportedModes(aSupportedModes25, sizeof(aSupportedModes25)/sizeof(aSupportedModes25[0]));
XN_IS_STATUS_OK(nRetVal);
}
// data processor
nRetVal = m_Helper.RegisterDataProcessorProperty(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);
// register for mirror
XnCallbackHandle hCallbackDummy;
nRetVal = IsMirroredProperty().OnChangeEvent().Register(IsMirroredChangedCallback, this, &hCallbackDummy);
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);
}
