////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016-2017 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  g_camxsettings.h
/// @brief Hardware Independent Settings definitions.
///
///             !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
///             !!!!!!! AUTO-GENERATED FILE! DO NOT EDIT! Make all changes in camxsettings.xml. !!!!!!!
///             !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef G_CAMXSETTINGS_H
#define G_CAMXSETTINGS_H

#include "camxdefs.h"
#include "camxtypes.h"

CAMX_NAMESPACE_BEGIN

// Setting string hash constant definitions
static const UINT32 StringHashCameraHardware            = 0x856028BD;   ///< cameraHardware
static const UINT32 PropStringHashCameraHardware        = 0x4EC6B195;   ///< cameraHardware
static const UINT32 StringHashMFHDRHWEnable             = 0xEE7DF4BE;   ///< MFHDRHWEnable
static const UINT32 PropStringHashMFHDRHWEnable         = 0xA820C077;   ///< MFHDRHWEnable
static const UINT32 StringHashExtendedMaxZoomRatio      = 0x04FC4DD3;   ///< extendedMaxZoomRatio
static const UINT32 PropStringHashExtendedMaxZoomRatio  = 0x3615EB99;   ///< extendedMaxZoomRatio
static const UINT32 StringHashEnableFastZoomOut         = 0xABB50AE8;   ///< enableFastZoomOut
static const UINT32 PropStringHashEnableFastZoomOut     = 0xE7216F3B;   ///< enableFastZoomOut
static const UINT32 StringHashBLStretchEnable           = 0xC715CAB8;   ///< BLStretchEnable
static const UINT32 PropStringHashBLStretchEnable       = 0xD021FDCA;   ///< BLStretchEnable
static const UINT32 StringHashEnableMCTF                = 0x5E6BCFF6;   ///< enableMCTF
static const UINT32 PropStringHashEnableMCTF            = 0x37F9434C;   ///< enableMCTF
static const UINT32 StringHashEnableVIULLProcessing     = 0xE2996BF4;   ///< enableVIULLProcessing
static const UINT32 StringHashEnableVIULLPlus           = 0xBE45721C;   ///< enableVIULLPlus
static const UINT32 StringHashEnableCascade2DLut        = 0xA5D4AE9B;   ///< enableCascade2DLut
static const UINT32 PropStringHashEnableCascade2DLut    = 0xBE6DA501;   ///< enableCascade2DLut
static const UINT32 StringHashEnableSHDR1ExpInlineSFE   = 0x4B74E909;   ///< enableSHDR1ExpInlineSFE
static const UINT32 PropStringHashEnableSHDR1ExpInlineSFE  = 0x2710BB75;   ///< enableSHDR1ExpInlineSFE
static const UINT32 StringHashEnableOfflineFS           = 0x7E1A4D00;   ///< enableOfflineFS
static const UINT32 PropStringHashEnableOfflineFS       = 0x692E7A72;   ///< enableOfflineFS
static const UINT32 StringHashEnableAWBR                = 0x5E6D9D22;   ///< enableAWBR
static const UINT32 StringHashOutputFormat              = 0xFC924BE1;   ///< outputFormat
static const UINT32 PropStringHashOutputFormat          = 0xB6A0A247;   ///< outputFormat
static const UINT32 StringHashOverrideVideoOutputFormat  = 0x7CEEB938;   ///< overrideVideoOutputFormat
static const UINT32 PropStringHashOverrideVideoOutputFormat  = 0xE88B6A74;   ///< overrideVideoOutputFormat
static const UINT32 StringHashIsStrideSettingEnable     = 0x4D7EB8E9;   ///< IsStrideSettingEnable
static const UINT32 StringHashNumMetadataResults        = 0x31A11A6A;   ///< numMetadataResults
static const UINT32 PropStringHashNumMetadataResults    = 0xA32DA003;   ///< numMetadataResults
static const UINT32 StringHashMaxHalRequests            = 0x88CF0DA6;   ///< maxHalRequests
static const UINT32 PropStringHashMaxHalRequests        = 0x4369948E;   ///< maxHalRequests
static const UINT32 StringHashWaitAllResultsTimeout     = 0x9658B9F2;   ///< waitAllResultsTimeout
static const UINT32 PropStringHashWaitAllResultsTimeout  = 0xCB6C70B4;   ///< waitAllResultsTimeout
static const UINT32 StringHashEnableEGLCache            = 0xCF04E798;   ///< enableEGLCache
static const UINT32 PropStringHashEnableEGLCache        = 0x04A27EB0;   ///< enableEGLCache
static const UINT32 StringHashEnableDMAFence            = 0x5556D2F2;   ///< enableDMAFence
static const UINT32 PropStringHashEnableDMAFence        = 0x9EF04BDA;   ///< enableDMAFence
static const UINT32 StringHashEnableDMAFenceHighFPS     = 0x7EF301FB;   ///< enableDMAFenceHighFPS
static const UINT32 PropStringHashEnableDMAFenceHighFPS  = 0x23C7C8BD;   ///< enableDMAFenceHighFPS
static const UINT32 StringHashEnableSynxFence           = 0x56EFFD4C;   ///< enableSynxFence
static const UINT32 PropStringHashEnableSynxFence       = 0x223CD855;   ///< enableSynxFence
static const UINT32 StringHashEnableInitDepBatchProcessing  = 0x60B96763;   ///< enableInitDepBatchProcessing
static const UINT32 PropStringHashEnableInitDepBatchProcessing  = 0x891F2D51;   ///< enableInitDepBatchProcessing
static const UINT32 StringHashEnableSynxCrossNodePropagation  = 0x58BF4CFB;   ///< enableSynxCrossNodePropagation
static const UINT32 PropStringHashEnableSynxCrossNodePropagation  = 0xC197875D;   ///< enableSynxCrossNodePropagation
static const UINT32 StringHashNumWorkerThreads          = 0x915563E3;   ///< numWorkerThreads
static const UINT32 PropStringHashNumWorkerThreads      = 0x0B31C0CD;   ///< numWorkerThreads
static const UINT32 StringHashChiOverrideEnable         = 0xDFF77545;   ///< chiOverrideEnable
static const UINT32 PropStringHashChiOverrideEnable     = 0x93631096;   ///< chiOverrideEnable
static const UINT32 StringHashMultiCameraEnable         = 0x2CB67083;   ///< multiCameraEnable
static const UINT32 PropStringHashMultiCameraEnable     = 0xB1EF679B;   ///< multiCameraEnable
static const UINT32 StringHashEnableAuxSensorStandby    = 0x28F649D3;   ///< enableAuxSensorStandby
static const UINT32 PropStringHashEnableAuxSensorStandby  = 0x8E6F6118;   ///< enableAuxSensorStandby
static const UINT32 StringHashMinAuxFPS                 = 0x456DF820;   ///< minAuxFPS
static const UINT32 PropStringHashMinAuxFPS             = 0x96216C45;   ///< minAuxFPS
static const UINT32 StringHashEnableDelaySubmitAuxRequest  = 0x362604A0;   ///< enableDelaySubmitAuxRequest
static const UINT32 PropStringHashEnableDelaySubmitAuxRequest  = 0xA16B36F1;   ///< enableDelaySubmitAuxRequest
static const UINT32 StringHashMultiCameraUseLegacyTables  = 0x2714FF79;   ///< multiCameraUseLegacyTables
static const UINT32 PropStringHashMultiCameraUseLegacyTables  = 0xAE22E29A;   ///< multiCameraUseLegacyTables
static const UINT32 StringHashAllowPartialDataToBeSent  = 0xBEA09F41;   ///< allowPartialDataToBeSent
static const UINT32 PropStringHashAllowPartialDataToBeSent  = 0xDA03B1DB;   ///< allowPartialDataToBeSent
static const UINT32 StringHashEnableAsymmetricBokehInput  = 0x0DF8CD57;   ///< enableAsymmetricBokehInput
static const UINT32 PropStringHashEnableAsymmetricBokehInput  = 0x8142A4C5;   ///< enableAsymmetricBokehInput
static const UINT32 StringHashMultiCameraJPEG           = 0x598CD51A;   ///< multiCameraJPEG
static const UINT32 PropStringHashMultiCameraJPEG       = 0x798FD231;   ///< multiCameraJPEG
static const UINT32 StringHashMultiCameraLogicalXMLFile  = 0x79AFCDA5;   ///< multiCameraLogicalXMLFile
static const UINT32 PropStringHashMultiCameraLogicalXMLFile  = 0x7E1253CE;   ///< multiCameraLogicalXMLFile
static const UINT32 StringHashMultiCameraEnableFront    = 0x0001DD55;   ///< multiCameraEnableFront
static const UINT32 PropStringHashMultiCameraEnableFront  = 0xB6236852;   ///< multiCameraEnableFront
static const UINT32 StringHashMultiCameraVREnable       = 0xD1049DC8;   ///< multiCameraVREnable
static const UINT32 PropStringHashMultiCameraVREnable   = 0xB3CD6E45;   ///< multiCameraVREnable
static const UINT32 StringHashMultiCameraHWSyncMask     = 0xCC6478FA;   ///< multiCameraHWSyncMask
static const UINT32 PropStringHashMultiCameraHWSyncMask  = 0x576A893E;   ///< multiCameraHWSyncMask
static const UINT32 StringHashMultiCameraFrameSyncMask  = 0xC1B567BC;   ///< multiCameraFrameSyncMask
static const UINT32 PropStringHashMultiCameraFrameSyncMask  = 0xB9572A3B;   ///< multiCameraFrameSyncMask
static const UINT32 StringHashMultiCameraFPSMatchMask   = 0x4A60D947;   ///< multiCameraFPSMatchMask
static const UINT32 PropStringHashMultiCameraFPSMatchMask  = 0x71A7CB2B;   ///< multiCameraFPSMatchMask
static const UINT32 StringHashMultiCameraExposureTimeMatch  = 0x34B36438;   ///< multiCameraExposureTimeMatch
static const UINT32 PropStringHashMultiCameraExposureTimeMatch  = 0xECC4EA1C;   ///< multiCameraExposureTimeMatch
static const UINT32 StringHashMultiCameraSWFrameSyncInterval  = 0x044A164F;   ///< multiCameraSWFrameSyncInterval
static const UINT32 PropStringHashMultiCameraSWFrameSyncInterval  = 0xDA72852E;   ///< multiCameraSWFrameSyncInterval
static const UINT32 StringHashMultiCameraSWFrameSyncType  = 0x2C2EECC7;   ///< multiCameraSWFrameSyncType
static const UINT32 PropStringHashMultiCameraSWFrameSyncType  = 0xA518F124;   ///< multiCameraSWFrameSyncType
static const UINT32 StringHashEnableSATAlgoMasterSwitch  = 0x8070DA07;   ///< enableSATAlgoMasterSwitch
static const UINT32 PropStringHashEnableSATAlgoMasterSwitch  = 0x87CD446C;   ///< enableSATAlgoMasterSwitch
static const UINT32 StringHashEnableSWMFHDR             = 0x4E6A83C0;   ///< enableSWMFHDR
static const UINT32 PropStringHashEnableSWMFHDR         = 0x35B36570;   ///< enableSWMFHDR
static const UINT32 StringHashEnableHWMFHDRSnapshot     = 0x2FBBE899;   ///< enableHWMFHDRSnapshot
static const UINT32 PropStringHashEnableHWMFHDRSnapshot  = 0x728F21DF;   ///< enableHWMFHDRSnapshot
static const UINT32 StringHashEnableSHDRawOutSFE        = 0x7D8A21EE;   ///< enableSHDRawOutSFE
static const UINT32 PropStringHashEnableSHDRawOutSFE    = 0x66332A74;   ///< enableSHDRawOutSFE
static const UINT32 StringHashEnableOfflineIFE          = 0xC3499ECA;   ///< enableOfflineIFE
static const UINT32 PropStringHashEnableOfflineIFE      = 0x592D3DE4;   ///< enableOfflineIFE
static const UINT32 StringHashMultiCameraDetectFrameSync  = 0x01C649EA;   ///< multiCameraDetectFrameSync
static const UINT32 PropStringHashMultiCameraDetectFrameSync  = 0x88F05409;   ///< multiCameraDetectFrameSync
static const UINT32 StringHashEnableMinimumStartupExposure  = 0x26B952AF;   ///< enableMinimumStartupExposure
static const UINT32 PropStringHashEnableMinimumStartupExposure  = 0xCF1F189D;   ///< enableMinimumStartupExposure
static const UINT32 StringHashNumberOfAELockFrames      = 0x83C9E0BF;   ///< numberOfAELockFrames
static const UINT32 PropStringHashNumberOfAELockFrames  = 0x37F7665E;   ///< numberOfAELockFrames
static const UINT32 StringHashEnableBayerSAT            = 0x656D2690;   ///< enableBayerSAT
static const UINT32 PropStringHashEnableBayerSAT        = 0xAECBBFB8;   ///< enableBayerSAT
static const UINT32 StringHashEnableBayerTMCStats       = 0x09C15085;   ///< enableBayerTMCStats
static const UINT32 PropStringHashEnableBayerTMCStats   = 0x58561DB7;   ///< enableBayerTMCStats
static const UINT32 StringHashEnableScreenGrab          = 0x9B4B778F;   ///< enableScreenGrab
static const UINT32 PropStringHashEnableScreenGrab      = 0x012FD4A1;   ///< enableScreenGrab
static const UINT32 StringHashEnableCaptureHalt         = 0x5103B2CB;   ///< enableCaptureHalt
static const UINT32 PropStringHashEnableCaptureHalt     = 0x012FD4A1;   ///< enableCaptureHalt
static const UINT32 StringHashExportSecureCamera        = 0xF4E4978B;   ///< exportSecureCamera
static const UINT32 PropStringHashExportSecureCamera    = 0x66682DE2;   ///< exportSecureCamera
static const UINT32 StringHashEnableRAWProcessing       = 0x85F8530B;   ///< enableRAWProcessing
static const UINT32 PropStringHashEnableRAWProcessing   = 0xD46F1E39;   ///< enableRAWProcessing
static const UINT32 StringHashMaxRAWSizes               = 0xA8BD3F5B;   ///< maxRAWSizes
static const UINT32 PropStringHashMaxRAWSizes           = 0x9AECA816;   ///< maxRAWSizes
static const UINT32 StringHashCustomCapResolution       = 0x9CF53410;   ///< CustomCapResolution
static const UINT32 PropStringHashCustomCapResolution   = 0xCD627922;   ///< CustomCapResolution
static const UINT32 StringHashEnableInternalHALPixelStreamConfig  = 0x07BEC896;   ///< enableInternalHALPixelStreamConfig
static const UINT32 PropStringHashEnableInternalHALPixelStreamConfig  = 0xBDD75A1A;   ///< enableInternalHALPixelStreamConfig
static const UINT32 StringHashEnableNCSService          = 0x1A803BC5;   ///< enableNCSService
static const UINT32 PropStringHashEnableNCSService      = 0x80E498EB;   ///< enableNCSService
static const UINT32 StringHashEnablePeripheralService   = 0x844A240C;   ///< enablePeripheralService
static const UINT32 PropStringHashEnablePeripheralService  = 0x576F3D78;   ///< enablePeripheralService
static const UINT32 StringHashReconnectCountOfHeartBeatMgr  = 0x944EF061;   ///< reconnectCountOfHeartBeatMgr
static const UINT32 PropStringHashReconnectCountOfHeartBeatMgr  = 0x7DE8BA53;   ///< reconnectCountOfHeartBeatMgr
static const UINT32 StringHashEnableNCSDataDump         = 0x5D71A16A;   ///< enableNCSDataDump
static const UINT32 PropStringHashEnableNCSDataDump     = 0x11E5C4B9;   ///< enableNCSDataDump
static const UINT32 StringHashEnableNCSQSEE2            = 0xF02DFE36;   ///< enableNCSQSEE2
static const UINT32 PropStringHashEnableNCSQSEE2        = 0x3B8B671E;   ///< enableNCSQSEE2
static const UINT32 StringHashEnableNCSOFD              = 0xA93C71DD;   ///< enableNCSOFD
static const UINT32 PropStringHashEnableNCSOFD          = 0xE30E987B;   ///< enableNCSOFD
static const UINT32 StringHashEnableNCSOFDImageDump     = 0x06580687;   ///< enableNCSOFDImageDump
static const UINT32 PropStringHashEnableNCSOFDImageDump  = 0x5B6CCFC1;   ///< enableNCSOFDImageDump
static const UINT32 StringHashEnableDepth               = 0xCDEAECE3;   ///< enableDepth
static const UINT32 PropStringHashEnableDepth           = 0xFFBB7BAE;   ///< enableDepth
static const UINT32 StringHashEnableDepthFrameSync      = 0xC1F47596;   ///< enableDepthFrameSync
static const UINT32 PropStringHashEnableDepthFrameSync  = 0x1F3B4015;   ///< enableDepthFrameSync
static const UINT32 StringHashDepthSWFrameSyncType      = 0x58F570F8;   ///< DepthSWFrameSyncType
static const UINT32 PropStringHashDepthSWFrameSyncType  = 0x863A457B;   ///< DepthSWFrameSyncType
static const UINT32 StringHashMaxNumOfCamerasForFrameSync  = 0x45F9E514;   ///< maxNumOfCamerasForFrameSync
static const UINT32 PropStringHashMaxNumOfCamerasForFrameSync  = 0xD2B4D745;   ///< maxNumOfCamerasForFrameSync
static const UINT32 StringHashOISThreadSchedMode        = 0xD2F54530;   ///< OISThreadSchedMode
static const UINT32 PropStringHashOISThreadSchedMode    = 0x4079FF59;   ///< OISThreadSchedMode
static const UINT32 StringHashEnableSpectralSensor      = 0xE7254913;   ///< enableSpectralSensor
static const UINT32 PropStringHashEnableSpectralSensor  = 0xD5CCEF59;   ///< enableSpectralSensor
static const UINT32 StringHashEnableALSLightSensor      = 0x2C1AFC78;   ///< enableALSLightSensor
static const UINT32 PropStringHashEnableALSLightSensor  = 0x1EF35A32;   ///< enableALSLightSensor
static const UINT32 StringHashEnableMCXSPMActiveCamStateOpt  = 0xF4849E14;   ///< enableMCXSPMActiveCamStateOpt
static const UINT32 PropStringHashEnableMCXSPMActiveCamStateOpt  = 0xC04DD849;   ///< enableMCXSPMActiveCamStateOpt
static const UINT32 StringHashMCXPrimaryRearCameraIndex  = 0x3A71E1B5;   ///< MCXPrimaryRearCameraIndex
static const UINT32 PropStringHashMCXPrimaryRearCameraIndex  = 0xE7B9BD65;   ///< MCXPrimaryRearCameraIndex
static const UINT32 StringHashMinReprocessInputWidth    = 0x03D704D3;   ///< minReprocessInputWidth
static const UINT32 PropStringHashMinReprocessInputWidth  = 0xA54E2C18;   ///< minReprocessInputWidth
static const UINT32 StringHashMinReprocessInputHeight   = 0x44265614;   ///< minReprocessInputHeight
static const UINT32 PropStringHashMinReprocessInputHeight  = 0x97034F60;   ///< minReprocessInputHeight
static const UINT32 StringHashMinInOutResolution        = 0xD9FFE597;   ///< minInOutResolution
static const UINT32 PropStringHashMinInOutResolution    = 0xC246EE0D;   ///< minInOutResolution
static const UINT32 StringHashMaxInOutResolution        = 0xD9F75597;   ///< maxInOutResolution
static const UINT32 PropStringHashMaxInOutResolution    = 0xC24E5E0D;   ///< maxInOutResolution
static const UINT32 StringHashEnableTOFInterface        = 0xAA6F3236;   ///< enableTOFInterface
static const UINT32 PropStringHashEnableTOFInterface    = 0x38E3885F;   ///< enableTOFInterface
static const UINT32 StringHashEnableThermalMitigation   = 0xD5D8A0B6;   ///< enableThermalMitigation
static const UINT32 PropStringHashEnableThermalMitigation  = 0xF6BDA3B6;   ///< enableThermalMitigation
static const UINT32 StringHashMaxBuffersSecureCamera    = 0x0EFAF926;   ///< maxBuffersSecureCamera
static const UINT32 PropStringHashMaxBuffersSecureCamera  = 0xA863D1ED;   ///< maxBuffersSecureCamera
static const UINT32 StringHashEnableNativeHEIF          = 0xBDFF08B8;   ///< enableNativeHEIF
static const UINT32 PropStringHashEnableNativeHEIF      = 0x279BAB96;   ///< enableNativeHEIF
static const UINT32 StringHashInduceSleepInChiNode      = 0xD14ADB18;   ///< induceSleepInChiNode
static const UINT32 PropStringHashInduceSleepInChiNode  = 0xE3A37D52;   ///< induceSleepInChiNode
static const UINT32 StringHashEnableHALFormatOverride   = 0x3972766A;   ///< enableHALFormatOverride
static const UINT32 PropStringHashEnableHALFormatOverride  = 0xEA576F1E;   ///< enableHALFormatOverride
static const UINT32 StringHashMaxNumberOfAcceptedErrors  = 0xA7C57F21;   ///< maxNumberOfAcceptedErrors
static const UINT32 PropStringHashMaxNumberOfAcceptedErrors  = 0x33A0AC6D;   ///< maxNumberOfAcceptedErrors
static const UINT32 StringHashEnableResourceManager     = 0x0AA402CA;   ///< enableResourceManager
static const UINT32 PropStringHashEnableResourceManager  = 0x5790CB8C;   ///< enableResourceManager
static const UINT32 StringHashEnableStreamCropZoom      = 0x15E5861B;   ///< enableStreamCropZoom
static const UINT32 PropStringHashEnableStreamCropZoom  = 0x270C2051;   ///< enableStreamCropZoom
static const UINT32 StringHashEnablePopulateRequestCropInfo  = 0x614AA855;   ///< enablePopulateRequestCropInfo
static const UINT32 PropStringHashEnablePopulateRequestCropInfo  = 0x5583EE08;   ///< enablePopulateRequestCropInfo
static const UINT32 StringHashBpsRealtimeSensorId       = 0xE6DF0A40;   ///< bpsRealtimeSensorId
static const UINT32 PropStringHashBpsRealtimeSensorId   = 0xB7484772;   ///< bpsRealtimeSensorId
static const UINT32 StringHashEnableBLMClient           = 0xA049C155;   ///< enableBLMClient
static const UINT32 PropStringHashEnableBLMClient       = 0xD49AE44C;   ///< enableBLMClient
static const UINT32 StringHashOverrideDeviceMemType     = 0x658FFD50;   ///< overrideDeviceMemType
static const UINT32 PropStringHashOverrideDeviceMemType  = 0x38BB3416;   ///< overrideDeviceMemType
static const UINT32 StringHashEnableFeature2CTS         = 0x513A28CC;   ///< enableFeature2CTS
static const UINT32 PropStringHashEnableFeature2CTS     = 0x1DAE4D1F;   ///< enableFeature2CTS
static const UINT32 StringHashEnableFeature2BinaryGraphDump  = 0x82E73FAF;   ///< enableFeature2BinaryGraphDump
static const UINT32 PropStringHashEnableFeature2BinaryGraphDump  = 0xB62E79F2;   ///< enableFeature2BinaryGraphDump
static const UINT32 StringHashEnableFeature2PrunedGraphDump  = 0x35389B18;   ///< enableFeature2PrunedGraphDump
static const UINT32 PropStringHashEnableFeature2PrunedGraphDump  = 0x01F1DD45;   ///< enableFeature2PrunedGraphDump
static const UINT32 StringHashEnableModifiedCTSResolution  = 0xABE713FC;   ///< enableModifiedCTSResolution
static const UINT32 PropStringHashEnableModifiedCTSResolution  = 0x3CAA21AD;   ///< enableModifiedCTSResolution
static const UINT32 StringHashIsSHDRFusionOffline       = 0xFB06BC2D;   ///< isSHDRFusionOffline
static const UINT32 PropStringHashIsSHDRFusionOffline   = 0xAA91F11F;   ///< isSHDRFusionOffline
static const UINT32 StringHashSetHDRMode                = 0xCF19365F;   ///< setHDRMode
static const UINT32 PropStringHashSetHDRMode            = 0xA68BBAE5;   ///< setHDRMode
static const UINT32 StringHashSelectSHDRAutoExposureUsecase  = 0xDC4EAFC3;   ///< selectSHDRAutoExposureUsecase
static const UINT32 PropStringHashSelectSHDRAutoExposureUsecase  = 0xE887E99E;   ///< selectSHDRAutoExposureUsecase
static const UINT32 StringHashDisable60FPS2EXPSHDRSupport  = 0x085B1E23;   ///< disable60FPS2EXPSHDRSupport
static const UINT32 PropStringHashDisable60FPS2EXPSHDRSupport  = 0x9F162C72;   ///< disable60FPS2EXPSHDRSupport
static const UINT32 StringHashMaxSHDRSnapshotFPS        = 0x63C8E8F9;   ///< maxSHDRSnapshotFPS
static const UINT32 PropStringHashMaxSHDRSnapshotFPS    = 0xF1445290;   ///< maxSHDRSnapshotFPS
static const UINT32 StringHashExposeSHDRRAWSize         = 0x466F9070;   ///< exposeSHDRRAWSize
static const UINT32 PropStringHashExposeSHDRRAWSize     = 0x0AFBF5A3;   ///< exposeSHDRRAWSize
static const UINT32 StringHashEnableAFB                 = 0x82F36ECA;   ///< enableAFB
static const UINT32 PropStringHashEnableAFB             = 0x51BFFAAF;   ///< enableAFB
static const UINT32 StringHashSetAutoHDRMode            = 0xA49DE767;   ///< setAutoHDRMode
static const UINT32 PropStringHashSetAutoHDRMode        = 0x6F3B7E4F;   ///< setAutoHDRMode
static const UINT32 StringHashEnableAutoHDRCapability   = 0x8DB88799;   ///< enableAutoHDRCapability
static const UINT32 PropStringHashEnableAutoHDRCapability  = 0x5E9D9EED;   ///< enableAutoHDRCapability
static const UINT32 StringHashEnableSATPreviewEISV2     = 0x598EA5C0;   ///< enableSATPreviewEISV2
static const UINT32 PropStringHashEnableSATPreviewEISV2  = 0x04BA6C86;   ///< enableSATPreviewEISV2
static const UINT32 StringHashEnablePostZoomFOV         = 0xABECEDAA;   ///< enablePostZoomFOV
static const UINT32 StringHashEnableQSATWithSPM         = 0xE659A852;   ///< enableQSATWithSPM
static const UINT32 StringHashEnableMFLOEMCustomization  = 0xE7AEA693;   ///< enableMFLOEMCustomization
static const UINT32 PropStringHashEnableMFLOEMCustomization  = 0x73CB75DF;   ///< enableMFLOEMCustomization
static const UINT32 StringHashThrottleRequestForLookAheadNodes  = 0x56785D00;   ///< throttleRequestForLookAheadNodes
static const UINT32 PropStringHashThrottleRequestForLookAheadNodes  = 0xF556C764;   ///< throttleRequestForLookAheadNodes
static const UINT32 StringHashHalBufferMgrMode          = 0x9200CEF0;   ///< halBufferMgrMode
static const UINT32 PropStringHashHalBufferMgrMode      = 0x08646DDE;   ///< halBufferMgrMode
static const UINT32 StringHashHalBufferCacheMin         = 0xE24CFB8D;   ///< halBufferCacheMin
static const UINT32 PropStringHashHalBufferCacheMin     = 0xAED89E5E;   ///< halBufferCacheMin
static const UINT32 StringHashHalBufferCacheMax         = 0xE24CFA9B;   ///< halBufferCacheMax
static const UINT32 PropStringHashHalBufferCacheMax     = 0xAED89F48;   ///< halBufferCacheMax
static const UINT32 StringHashHALOutputBufferCombined   = 0x246894F2;   ///< HALOutputBufferCombined
static const UINT32 PropStringHashHALOutputBufferCombined  = 0xF74D8D86;   ///< HALOutputBufferCombined
static const UINT32 StringHashFPSForHALOutputBufferCombined  = 0x88FECD32;   ///< FPSForHALOutputBufferCombined
static const UINT32 PropStringHashFPSForHALOutputBufferCombined  = 0xBC378B6F;   ///< FPSForHALOutputBufferCombined
static const UINT32 StringHashEnableCustomHFRConfig     = 0xC3586820;   ///< enableCustomHFRConfig
static const UINT32 PropStringHashEnableCustomHFRConfig  = 0x9E6CA166;   ///< enableCustomHFRConfig
static const UINT32 StringHashHFRMaxBatchFPS            = 0xF6BDCDAD;   ///< HFRMaxBatchFPS
static const UINT32 PropStringHashHFRMaxBatchFPS        = 0x3D1B5485;   ///< HFRMaxBatchFPS
static const UINT32 StringHashPreviewFPSOnHFRMode       = 0x47FF9603;   ///< PreviewFPSOnHFRMode
static const UINT32 PropStringHashPreviewFPSOnHFRMode   = 0x1668DB31;   ///< PreviewFPSOnHFRMode
static const UINT32 StringHashEnableDSM                 = 0x82F37865;   ///< enableDSM
static const UINT32 PropStringHashEnableDSM             = 0x1C987FD8;   ///< enableDSM
static const UINT32 StringHashEnableAI                  = 0x44179B7A;   ///< enableAI
static const UINT32 PropStringHashEnableAI              = 0x6A8DFFD9;   ///< enableAI
static const UINT32 StringHashEnableAISegOnly           = 0x2CFAEE37;   ///< enableAISegOnly
static const UINT32 PropStringHashEnableAISegOnly       = 0x5829CB2E;   ///< enableAISegOnly
static const UINT32 StringHashEnableBackPropagateAIHSVStats  = 0x61897AAB;   ///< enableBackPropagateAIHSVStats
static const UINT32 PropStringHashEnableBackPropagateAIHSVStats  = 0x55403CF6;   ///< enableBackPropagateAIHSVStats
static const UINT32 StringHashEnableAIDLOffline         = 0xF938865C;   ///< enableAIDLOffline
static const UINT32 PropStringHashEnableAIDLOffline     = 0xB5ACE38F;   ///< enableAIDLOffline
static const UINT32 StringHashEnableBubbleRecovery      = 0xD40E0500;   ///< enableBubbleRecovery
static const UINT32 PropStringHashEnableBubbleRecovery  = 0xE6E7A34A;   ///< enableBubbleRecovery
static const UINT32 StringHashOverrideVideoDataspace    = 0x20BAEFE9;   ///< overrideVideoDataspace
static const UINT32 PropStringHashOverrideVideoDataspace  = 0x8623C722;   ///< overrideVideoDataspace
static const UINT32 StringHashStreamBufferWait          = 0x2C21BA9F;   ///< streamBufferWait
static const UINT32 PropStringHashStreamBufferWait      = 0xB64519B1;   ///< streamBufferWait
static const UINT32 StringHashStreamBufferStall         = 0x847DF089;   ///< streamBufferStall
static const UINT32 PropStringHashStreamBufferStall     = 0xC8E9955A;   ///< streamBufferStall
static const UINT32 StringHashSkipSBMOneBufferRequest   = 0x960DCF7D;   ///< skipSBMOneBufferRequest
static const UINT32 PropStringHashSkipSBMOneBufferRequest  = 0x4528D609;   ///< skipSBMOneBufferRequest
static const UINT32 StringHashEnableDisplaySmomo        = 0xDA6032E9;   ///< EnableDisplaySmomo
static const UINT32 PropStringHashEnableDisplaySmomo    = 0x48EC8880;   ///< EnableDisplaySmomo
static const UINT32 StringHashEnableMapBufferOptimization  = 0x4A58A7C9;   ///< enableMapBufferOptimization
static const UINT32 PropStringHashEnableMapBufferOptimization  = 0xDD159598;   ///< enableMapBufferOptimization
static const UINT32 StringHashOverrideImmediateImageBufferCountRealTimeVideo  = 0x8E3047A2;   ///< overrideImmediateImageBufferCountRealTimeVideo
static const UINT32 PropStringHashOverrideImmediateImageBufferCountRealTimeVideo  = 0xDA2F0067;   ///< overrideImmediateImageBufferCountRealTimeVideo
static const UINT32 StringHashEnableDedicatedCameraHeap  = 0xAB9648D7;   ///< enableDedicatedCameraHeap
static const UINT32 PropStringHashEnableDedicatedCameraHeap  = 0x3FF39B9B;   ///< enableDedicatedCameraHeap
static const UINT32 StringHashEnableDisplayPortToPOSTPROC  = 0x09C3F252;   ///< enableDisplayPortToPOSTPROC
static const UINT32 PropStringHashEnableDisplayPortToPOSTPROC  = 0x9E8EC003;   ///< enableDisplayPortToPOSTPROC
static const UINT32 StringHashAECGainThresholdForOfflineIFE  = 0x9AC883F8;   ///< AECGainThresholdForOfflineIFE
static const UINT32 StringHashExposeRecommendedConfig   = 0x6717B558;   ///< exposeRecommendedConfig
static const UINT32 PropStringHashExposeRecommendedConfig  = 0xB432AC2C;   ///< exposeRecommendedConfig
static const UINT32 StringHashEnableDepthProvider       = 0xB3B9FC83;   ///< enableDepthProvider
static const UINT32 PropStringHashEnableDepthProvider   = 0xE22EB1B1;   ///< enableDepthProvider
static const UINT32 StringHashTofOutputType             = 0x9B6E7CDE;   ///< TofOutputType
static const UINT32 PropStringHashTofOutputType         = 0xDD334817;   ///< TofOutputType
static const UINT32 StringHashOfflineFDSupport          = 0xD80E1642;   ///< offlineFDSupport
static const UINT32 PropStringHashOfflineFDSupport      = 0x426AB56C;   ///< offlineFDSupport
static const UINT32 StringHashHwlDebugDataBinaryDumpMask  = 0x5F2644A2;   ///< hwlDebugDataBinaryDumpMask
static const UINT32 PropStringHashHwlDebugDataBinaryDumpMask  = 0xD39C2D30;   ///< hwlDebugDataBinaryDumpMask
static const UINT32 StringHashAssertMask                = 0xA37B5A8A;   ///< assertMask
static const UINT32 PropStringHashAssertMask            = 0xCAE9D630;   ///< assertMask
static const UINT32 StringHashLogWarningMask            = 0x58175BBF;   ///< logWarningMask
static const UINT32 PropStringHashLogWarningMask        = 0x93B1C297;   ///< logWarningMask
static const UINT32 StringHashLogEntryExitMask          = 0xB3AA4B35;   ///< logEntryExitMask
static const UINT32 PropStringHashLogEntryExitMask      = 0x29CEE81B;   ///< logEntryExitMask
static const UINT32 StringHashLogCoreCfgMask            = 0xC8469BE5;   ///< logCoreCfgMask
static const UINT32 PropStringHashLogCoreCfgMask        = 0x03E002CD;   ///< logCoreCfgMask
static const UINT32 StringHashLogConfigMask             = 0xA2570664;   ///< logConfigMask
static const UINT32 PropStringHashLogConfigMask         = 0xE40A32AD;   ///< logConfigMask
static const UINT32 StringHashLogDumpMask               = 0x9C8A8E36;   ///< logDumpMask
static const UINT32 PropStringHashLogDumpMask           = 0xAEDB197B;   ///< logDumpMask
static const UINT32 StringHashLogInfoMask               = 0x4B7A8E58;   ///< logInfoMask
static const UINT32 PropStringHashLogInfoMask           = 0x792B1915;   ///< logInfoMask
static const UINT32 StringHashLogPerfInfoMask           = 0x035D3480;   ///< logPerfInfoMask
static const UINT32 PropStringHashLogPerfInfoMask       = 0x778E1199;   ///< logPerfInfoMask
static const UINT32 StringHashLogVerboseMask            = 0xE233DBDE;   ///< logVerboseMask
static const UINT32 PropStringHashLogVerboseMask        = 0x299542F6;   ///< logVerboseMask
static const UINT32 StringHashLogDRQEnable              = 0xBB618269;   ///< logDRQEnable
static const UINT32 PropStringHashLogDRQEnable          = 0xF1536BCF;   ///< logDRQEnable
static const UINT32 StringHashLogMetaEnable             = 0x7AC0C35B;   ///< logMetaEnable
static const UINT32 PropStringHashLogMetaEnable         = 0x3C9DF792;   ///< logMetaEnable
static const UINT32 StringHashLogRequestMapping         = 0xEC0E183E;   ///< logRequestMapping
static const UINT32 PropStringHashLogRequestMapping     = 0xA09A7DED;   ///< logRequestMapping
static const UINT32 StringHashTraceErrorEnable          = 0x4FC888C5;   ///< traceErrorEnable
static const UINT32 PropStringHashTraceErrorEnable      = 0xD5AC2BEB;   ///< traceErrorEnable
static const UINT32 StringHashSystemLogEnable           = 0x0748D6B1;   ///< systemLogEnable
static const UINT32 PropStringHashSystemLogEnable       = 0x739BF3A8;   ///< systemLogEnable
static const UINT32 StringHashEnablePipelineFlush       = 0xE0B91E97;   ///< enablePipelineFlush
static const UINT32 PropStringHashEnablePipelineFlush   = 0xB12E53A5;   ///< enablePipelineFlush
static const UINT32 StringHashEnableMCXPipelineFlushMask  = 0x9BE0C5D1;   ///< enableMCXPipelineFlushMask
static const UINT32 PropStringHashEnableMCXPipelineFlushMask  = 0x175AAC43;   ///< enableMCXPipelineFlushMask
static const UINT32 StringHashEnableParallelPipelineDeactivate  = 0xE7947C01;   ///< enableParallelPipelineDeactivate
static const UINT32 PropStringHashEnableParallelPipelineDeactivate  = 0x44BAE665;   ///< enableParallelPipelineDeactivate
static const UINT32 StringHashEnableTuningStreamConfigDump  = 0xDDA6CC09;   ///< enableTuningStreamConfigDump
static const UINT32 PropStringHashEnableTuningStreamConfigDump  = 0x3400863B;   ///< enableTuningStreamConfigDump
static const UINT32 StringHashEnablePerRequestSync      = 0xFDFDC287;   ///< enablePerRequestSync
static const UINT32 PropStringHashEnablePerRequestSync  = 0xCF1464CD;   ///< enablePerRequestSync
static const UINT32 StringHashEnableEarlyPipelineActivate  = 0xAEF27BAB;   ///< enableEarlyPipelineActivate
static const UINT32 PropStringHashEnableEarlyPipelineActivate  = 0x39BF49FA;   ///< enableEarlyPipelineActivate
static const UINT32 StringHashEnableUpdateTransitionTableDynamically  = 0x479F86BF;   ///< enableUpdateTransitionTableDynamically
static const UINT32 PropStringHashEnableUpdateTransitionTableDynamically  = 0x6F542026;   ///< enableUpdateTransitionTableDynamically
static const UINT32 StringHashDebugLogFilename          = 0xFC58346C;   ///< debugLogFilename
static const UINT32 PropStringHashDebugLogFilename      = 0x663C9742;   ///< debugLogFilename
static const UINT32 StringHashTraceGroupsEnable         = 0x6EE31BF9;   ///< traceGroupsEnable
static const UINT32 PropStringHashTraceGroupsEnable     = 0x22777E2A;   ///< traceGroupsEnable
static const UINT32 StringHashEnableFPSLog              = 0xB80C7CFE;   ///< enableFPSLog
static const UINT32 PropStringHashEnableFPSLog          = 0xF23E9558;   ///< enableFPSLog
static const UINT32 StringHashMaxMemSpyStats            = 0xD8B344AB;   ///< maxMemSpyStats
static const UINT32 PropStringHashMaxMemSpyStats        = 0x1315DD83;   ///< maxMemSpyStats
static const UINT32 StringHashMemSpyRequestRate         = 0x9C526BF5;   ///< memSpyRequestRate
static const UINT32 PropStringHashMemSpyRequestRate     = 0xD0C60E26;   ///< memSpyRequestRate
static const UINT32 StringHashEnableMallopt             = 0xE27F9D41;   ///< enableMallopt
static const UINT32 PropStringHashEnableMallopt         = 0x3EFA504C;   ///< enableMallopt
static const UINT32 StringHashDynamicPropertiesEnabled  = 0xD9D0EB44;   ///< dynamicPropertiesEnabled
static const UINT32 PropStringHashDynamicPropertiesEnabled  = 0xBD73C5DE;   ///< dynamicPropertiesEnabled
static const UINT32 StringHashPDebugProcess             = 0xD1582C30;   ///< pDebugProcess
static const UINT32 PropStringHashPDebugProcess         = 0x0DDDE13D;   ///< pDebugProcess
static const UINT32 StringHashEnableSensorBitSwitch     = 0xB1584F37;   ///< enableSensorBitSwitch
static const UINT32 PropStringHashEnableSensorBitSwitch  = 0xEC6C8671;   ///< enableSensorBitSwitch
static const UINT32 StringHashForceRaw16FormatForRDIPort  = 0x59683887;   ///< forceRaw16FormatForRDIPort
static const UINT32 PropStringHashForceRaw16FormatForRDIPort  = 0xD5D25115;   ///< forceRaw16FormatForRDIPort
static const UINT32 StringHashCSLMode                   = 0x20F730FD;   ///< CSLMode
static const UINT32 PropStringHashCSLMode               = 0x52E004CA;   ///< CSLMode
static const UINT32 StringHashEnableIFHPatternGeneration  = 0x12FC6460;   ///< enableIFHPatternGeneration
static const UINT32 PropStringHashEnableIFHPatternGeneration  = 0xABF7FE7B;   ///< enableIFHPatternGeneration
static const UINT32 StringHashIFHPlaformFamily          = 0xBDACD425;   ///< IFHPlaformFamily
static const UINT32 PropStringHashIFHPlaformFamily      = 0x5B2A3A67;   ///< IFHPlaformFamily
static const UINT32 StringHashIFHPlaformMajorVersion    = 0x67F3FA74;   ///< IFHPlaformMajorVersion
static const UINT32 PropStringHashIFHPlaformMajorVersion  = 0xDE5241E4;   ///< IFHPlaformMajorVersion
static const UINT32 StringHashIFHPlaformMinorVersion    = 0x67D37A74;   ///< IFHPlaformMinorVersion
static const UINT32 PropStringHashIFHPlaformMinorVersion  = 0xDE72C1E4;   ///< IFHPlaformMinorVersion
static const UINT32 StringHashIFHPlaformRevVersion      = 0x90D1779C;   ///< IFHPlaformRevVersion
static const UINT32 PropStringHashIFHPlaformRevVersion  = 0x74FF1FF2;   ///< IFHPlaformRevVersion
static const UINT32 StringHashIFHCPASMajorVersion       = 0xE2BA01C7;   ///< IFHCPASMajorVersion
static const UINT32 PropStringHashIFHCPASMajorVersion   = 0x959B7284;   ///< IFHCPASMajorVersion
static const UINT32 StringHashIFHCPASMinorVersion       = 0xE29A81C7;   ///< IFHCPASMinorVersion
static const UINT32 PropStringHashIFHCPASMinorVersion   = 0x95BBF284;   ///< IFHCPASMinorVersion
static const UINT32 StringHashIFHCPASRevVersion         = 0x7C3025E2;   ///< IFHCPASRevVersion
static const UINT32 PropStringHashIFHCPASRevVersion     = 0xACEDEDBE;   ///< IFHCPASRevVersion
static const UINT32 StringHashIFHCPASHardwareCaps       = 0x0F412917;   ///< IFHCPASHardwareCaps
static const UINT32 PropStringHashIFHCPASHardwareCaps   = 0x78605A54;   ///< IFHCPASHardwareCaps
static const UINT32 StringHashIFHCPASFuseInfoNumFuses   = 0xB5254BAE;   ///< IFHCPASFuseInfoNumFuses
static const UINT32 PropStringHashIFHCPASFuseInfoNumFuses  = 0x811239B9;   ///< IFHCPASFuseInfoNumFuses
static const UINT32 StringHashNumOfSensorOnIFH          = 0xE00508B7;   ///< numOfSensorOnIFH
static const UINT32 PropStringHashNumOfSensorOnIFH      = 0x0683E6F5;   ///< numOfSensorOnIFH
static const UINT32 StringHashEnableSensorEmulation     = 0xCE36BD91;   ///< enableSensorEmulation
static const UINT32 PropStringHashEnableSensorEmulation  = 0x4BFBB04D;   ///< enableSensorEmulation
static const UINT32 StringHashEnableExternalSensorModule  = 0x072CBCAA;   ///< enableExternalSensorModule
static const UINT32 PropStringHashEnableExternalSensorModule  = 0xBE2726B1;   ///< enableExternalSensorModule
static const UINT32 StringHashEnableDebugSensorExposure  = 0xFAA0F8C0;   ///< enableDebugSensorExposure
static const UINT32 PropStringHashEnableDebugSensorExposure  = 0x2768A410;   ///< enableDebugSensorExposure
static const UINT32 StringHashSensorExposureTime        = 0xBF03A959;   ///< sensorExposureTime
static const UINT32 PropStringHashSensorExposureTime    = 0xA4BAA2C3;   ///< sensorExposureTime
static const UINT32 StringHashGain                      = 0x0032094E;   ///< gain
static const UINT32 PropStringHashGain                  = 0x685CED60;   ///< gain
static const UINT32 StringHashSensorShortExposureTime   = 0xE32992BB;   ///< sensorShortExposureTime
static const UINT32 PropStringHashSensorShortExposureTime  = 0xD71EE0AC;   ///< sensorShortExposureTime
static const UINT32 StringHashShortGain                 = 0x23727915;   ///< shortGain
static const UINT32 PropStringHashShortGain             = 0x7FA2A4DD;   ///< shortGain
static const UINT32 StringHashSensorMiddleExposureTime  = 0x874E6798;   ///< sensorMiddleExposureTime
static const UINT32 PropStringHashSensorMiddleExposureTime  = 0x01A0257E;   ///< sensorMiddleExposureTime
static const UINT32 StringHashMiddleGain                = 0xDE6FC377;   ///< middleGain
static const UINT32 PropStringHashMiddleGain            = 0x44747A7C;   ///< middleGain
static const UINT32 StringHashDisableSensorSubModules   = 0x9BC27E42;   ///< disableSensorSubModules
static const UINT32 PropStringHashDisableSensorSubModules  = 0xAFF50C55;   ///< disableSensorSubModules
static const UINT32 StringHashIgnoreSensorSubModuleFail  = 0xBF899F41;   ///< ignoreSensorSubModuleFail
static const UINT32 PropStringHashIgnoreSensorSubModuleFail  = 0x6241C391;   ///< ignoreSensorSubModuleFail
static const UINT32 StringHashDumpSensorEmulationOutput  = 0x6F5E0A29;   ///< dumpSensorEmulationOutput
static const UINT32 PropStringHashDumpSensorEmulationOutput  = 0xB29656F9;   ///< dumpSensorEmulationOutput
static const UINT32 StringHashSensorEmulator            = 0xCA30CC41;   ///< sensorEmulator
static const UINT32 PropStringHashSensorEmulator        = 0x5A896DFA;   ///< sensorEmulator
static const UINT32 StringHashSensorEmulatorPath        = 0xC42529E4;   ///< sensorEmulatorPath
static const UINT32 PropStringHashSensorEmulatorPath    = 0xDF9C227E;   ///< sensorEmulatorPath
static const UINT32 StringHashPresilPlatformVersion     = 0xFC87C31D;   ///< presilPlatformVersion
static const UINT32 PropStringHashPresilPlatformVersion  = 0x794ACEC1;   ///< presilPlatformVersion
static const UINT32 StringHashPresilSocId               = 0x9EC827C6;   ///< presilSocId
static const UINT32 PropStringHashPresilSocId           = 0xDDBF06B5;   ///< presilSocId
static const UINT32 StringHashPresilPCRTimeOut          = 0xD1DECE14;   ///< presilPCRTimeOut
static const UINT32 PropStringHashPresilPCRTimeOut      = 0x37582056;   ///< presilPCRTimeOut
static const UINT32 StringHashPresilMetadataPoolTimeOut  = 0x6EF00FCB;   ///< presilMetadataPoolTimeOut
static const UINT32 PropStringHashPresilMetadataPoolTimeOut  = 0xB338531B;   ///< presilMetadataPoolTimeOut
static const UINT32 StringHashPresilNodeRequestDoneTimeout  = 0x950BC96B;   ///< presilNodeRequestDoneTimeout
static const UINT32 PropStringHashPresilNodeRequestDoneTimeout  = 0xBB63A78F;   ///< presilNodeRequestDoneTimeout
static const UINT32 StringHashPresilFlushTimeOut        = 0x282CD69D;   ///< presilFlushTimeOut
static const UINT32 PropStringHashPresilFlushTimeOut    = 0x3395DD07;   ///< presilFlushTimeOut
static const UINT32 StringHashDualLEDCalibrationMode    = 0x5037E53A;   ///< dualLEDCalibrationMode
static const UINT32 PropStringHashDualLEDCalibrationMode  = 0xE9965EAA;   ///< dualLEDCalibrationMode
static const UINT32 StringHashDynamicInlineCalibration  = 0x9A1F172D;   ///< dynamicInlineCalibration
static const UINT32 PropStringHashDynamicInlineCalibration  = 0x1CF155CB;   ///< dynamicInlineCalibration
static const UINT32 StringHashDynamicCalibrationMaxSize  = 0xF3345928;   ///< dynamicCalibrationMaxSize
static const UINT32 PropStringHashDynamicCalibrationMaxSize  = 0x2EFC05F8;   ///< dynamicCalibrationMaxSize
static const UINT32 StringHashDualLEDCalibrationPath    = 0x50395F37;   ///< dualLEDCalibrationPath
static const UINT32 PropStringHashDualLEDCalibrationPath  = 0xE998E4A7;   ///< dualLEDCalibrationPath
static const UINT32 StringHashDisableADRC               = 0x5FFC4E33;   ///< disableADRC
static const UINT32 PropStringHashDisableADRC           = 0x1C8B6F40;   ///< disableADRC
static const UINT32 StringHashDisablePreviewManualISO   = 0x3CC26D50;   ///< disablePreviewManualISO
static const UINT32 PropStringHashDisablePreviewManualISO  = 0x08F51F47;   ///< disablePreviewManualISO
static const UINT32 StringHashDisablePreviewManualExpTime  = 0xC2C865E0;   ///< disablePreviewManualExpTime
static const UINT32 PropStringHashDisablePreviewManualExpTime  = 0xE3BB2697;   ///< disablePreviewManualExpTime
static const UINT32 StringHashDisablePreviewManualFull  = 0x984A320B;   ///< disablePreviewManualFull
static const UINT32 PropStringHashDisablePreviewManualFull  = 0x1EA470ED;   ///< disablePreviewManualFull
static const UINT32 StringHashDisableSpeckleDetection   = 0xCDC83F76;   ///< disableSpeckleDetection
static const UINT32 PropStringHashDisableSpeckleDetection  = 0xF9FF4D61;   ///< disableSpeckleDetection
static const UINT32 StringHashDisableAFStatsProcessing  = 0x9932D4C9;   ///< disableAFStatsProcessing
static const UINT32 PropStringHashDisableAFStatsProcessing  = 0x1FDC962F;   ///< disableAFStatsProcessing
static const UINT32 StringHashDisableAFAlgoCHIOverload  = 0xB4EE529F;   ///< disableAFAlgoCHIOverload
static const UINT32 PropStringHashDisableAFAlgoCHIOverload  = 0x32001079;   ///< disableAFAlgoCHIOverload
static const UINT32 StringHashDisableAWBStatsProcessing  = 0xD9CA50FE;   ///< disableAWBStatsProcessing
static const UINT32 PropStringHashDisableAWBStatsProcessing  = 0x04020C2E;   ///< disableAWBStatsProcessing
static const UINT32 StringHashDisableAWBAlgoCHIOverload  = 0xF416D6A8;   ///< disableAWBAlgoCHIOverload
static const UINT32 PropStringHashDisableAWBAlgoCHIOverload  = 0x29DE8A78;   ///< disableAWBAlgoCHIOverload
static const UINT32 StringHashDisableAFDStatsProcessing  = 0xD9DB60FE;   ///< disableAFDStatsProcessing
static const UINT32 PropStringHashDisableAFDStatsProcessing  = 0x04133C2E;   ///< disableAFDStatsProcessing
static const UINT32 StringHashDisableAFDAlgoCHIOverload  = 0xF407E6A8;   ///< disableAFDAlgoCHIOverload
static const UINT32 PropStringHashDisableAFDAlgoCHIOverload  = 0x29CFBA78;   ///< disableAFDAlgoCHIOverload
static const UINT32 StringHashDisableASDStatsProcessing  = 0xD9CE60FE;   ///< disableASDStatsProcessing
static const UINT32 PropStringHashDisableASDStatsProcessing  = 0x04063C2E;   ///< disableASDStatsProcessing
static const UINT32 StringHashDisableASDAlgoCHIOverload  = 0xF412E6A8;   ///< disableASDAlgoCHIOverload
static const UINT32 PropStringHashDisableASDAlgoCHIOverload  = 0x29DABA78;   ///< disableASDAlgoCHIOverload
static const UINT32 StringHashEnableMotionAssisted3A    = 0x02A1F97C;   ///< enableMotionAssisted3A
static const UINT32 PropStringHashEnableMotionAssisted3A  = 0xBB0042EC;   ///< enableMotionAssisted3A
static const UINT32 StringHashDebugBufferRegDumpEnable  = 0xDA3D5950;   ///< debugBufferRegDumpEnable
static const UINT32 PropStringHashDebugBufferRegDumpEnable  = 0xBE9E77CA;   ///< debugBufferRegDumpEnable
static const UINT32 StringHashDebugBufferRegDumpSizeInBytes  = 0xF1F1DD58;   ///< debugBufferRegDumpSizeInBytes
static const UINT32 PropStringHashDebugBufferRegDumpSizeInBytes  = 0xC5389B05;   ///< debugBufferRegDumpSizeInBytes
static const UINT32 StringHashDebugBufferRegDumpFileNamePrefix  = 0xECD602F5;   ///< debugBufferRegDumpFileNamePrefix
static const UINT32 PropStringHashDebugBufferRegDumpFileNamePrefix  = 0x4FF89891;   ///< debugBufferRegDumpFileNamePrefix
static const UINT32 StringHashKpiDebug                  = 0xD4730583;   ///< kpiDebug
static const UINT32 PropStringHashKpiDebug              = 0xC93FFA38;   ///< kpiDebug
static const UINT32 StringHashEnableQTimer              = 0x964179AB;   ///< enableQTimer
static const UINT32 PropStringHashEnableQTimer          = 0xCDBE9E4B;   ///< enableQTimer
static const UINT32 StringHashEnableHALAPITimer         = 0x263F1F44;   ///< enableHALAPITimer
static const UINT32 PropStringHashEnableHALAPITimer     = 0x6AAB7A97;   ///< enableHALAPITimer
static const UINT32 StringHashEnableTPG                 = 0x82F3380F;   ///< enableTPG
static const UINT32 PropStringHashEnableTPG             = 0xDE23E5C7;   ///< enableTPG
static const UINT32 StringHashDebugTPGbpp               = 0x2EAEC7C1;   ///< debugTPGbpp
static const UINT32 PropStringHashDebugTPGbpp           = 0x6DD9E6B2;   ///< debugTPGbpp
static const UINT32 StringHashEnableTPGProbe            = 0x183D5655;   ///< enableTPGProbe
static const UINT32 PropStringHashEnableTPGProbe        = 0x8884F7EE;   ///< enableTPGProbe
static const UINT32 StringHashEnableCSIDBinning         = 0xA7B2CB1D;   ///< enableCSIDBinning
static const UINT32 PropStringHashEnableCSIDBinning     = 0x776F0341;   ///< enableCSIDBinning
static const UINT32 StringHashCSIDBinningMode           = 0x39C265AF;   ///< CSIDBinningMode
static const UINT32 PropStringHashCSIDBinningMode       = 0x2EF652DD;   ///< CSIDBinningMode
static const UINT32 StringHashForce3ALockedResult       = 0x504950E4;   ///< force3ALockedResult
static const UINT32 PropStringHashForce3ALockedResult   = 0x276823A7;   ///< force3ALockedResult
static const UINT32 StringHashForceDisableUBWCOnIfeIpeLink  = 0x8585BB42;   ///< forceDisableUBWCOnIfeIpeLink
static const UINT32 PropStringHashForceDisableUBWCOnIfeIpeLink  = 0x6C23F170;   ///< forceDisableUBWCOnIfeIpeLink
static const UINT32 StringHashEnableUBWCNV124ROnIFEFullOutIPELink  = 0x7600C890;   ///< enableUBWCNV124ROnIFEFullOutIPELink
static const UINT32 PropStringHashEnableUBWCNV124ROnIFEFullOutIPELink  = 0x3B329907;   ///< enableUBWCNV124ROnIFEFullOutIPELink
static const UINT32 StringHashEnableUBWCP               = 0xCCF9721B;   ///< enableUBWCP
static const UINT32 PropStringHashEnableUBWCP           = 0xFEA8E556;   ///< enableUBWCP
static const UINT32 StringHashEnableBayerAlignment      = 0x918C427F;   ///< enableBayerAlignment
static const UINT32 PropStringHashEnableBayerAlignment  = 0xA365E435;   ///< enableBayerAlignment
static const UINT32 StringHashCapResolutionForSingleIFE  = 0xCBA34006;   ///< capResolutionForSingleIFE
static const UINT32 PropStringHashCapResolutionForSingleIFE  = 0x5FC6934A;   ///< capResolutionForSingleIFE
static const UINT32 StringHashSingleIFESupportedWidth   = 0xDA5EB222;   ///< singleIFESupportedWidth
static const UINT32 PropStringHashSingleIFESupportedWidth  = 0x097BAB56;   ///< singleIFESupportedWidth
static const UINT32 StringHashSingleIFESupportedHeight  = 0x7510882F;   ///< singleIFESupportedHeight
static const UINT32 PropStringHashSingleIFESupportedHeight  = 0x11B3A6B5;   ///< singleIFESupportedHeight
static const UINT32 StringHashCapResolutionForSingleTFE  = 0xCBA33406;   ///< capResolutionForSingleTFE
static const UINT32 PropStringHashCapResolutionForSingleTFE  = 0x5FC6E74A;   ///< capResolutionForSingleTFE
static const UINT32 StringHashSingleTFESupportedWidth   = 0xDA43B222;   ///< singleTFESupportedWidth
static const UINT32 PropStringHashSingleTFESupportedWidth  = 0x0966AB56;   ///< singleTFESupportedWidth
static const UINT32 StringHashSingleTFESupportedHeight  = 0x76B0882F;   ///< singleTFESupportedHeight
static const UINT32 PropStringHashSingleTFESupportedHeight  = 0x1213A6B5;   ///< singleTFESupportedHeight
static const UINT32 StringHashEnableFlashDebug          = 0x01E89A97;   ///< enableFlashDebug
static const UINT32 PropStringHashEnableFlashDebug      = 0x9B8C39B9;   ///< enableFlashDebug
static const UINT32 StringHashDumpSensorEEPROMData      = 0x8774CDD5;   ///< dumpSensorEEPROMData
static const UINT32 PropStringHashDumpSensorEEPROMData  = 0x635AA5BB;   ///< dumpSensorEEPROMData
static const UINT32 StringHashDumpSensorMetaData        = 0xC4146F70;   ///< dumpSensorMetaData
static const UINT32 PropStringHashDumpSensorMetaData    = 0xDFAD64EA;   ///< dumpSensorMetaData
static const UINT32 StringHashReadSensorTemperature     = 0x620720CF;   ///< readSensorTemperature
static const UINT32 PropStringHashReadSensorTemperature  = 0xDD7D01EA;   ///< readSensorTemperature
static const UINT32 StringHashEnableOfflineDump         = 0x69351428;   ///< enableOfflineDump
static const UINT32 PropStringHashEnableOfflineDump     = 0x25A171FB;   ///< enableOfflineDump
static const UINT32 StringHashOfflineDumpBufSize        = 0xB2C3CE69;   ///< offlineDumpBufSize
static const UINT32 PropStringHashOfflineDumpBufSize    = 0x204F7400;   ///< offlineDumpBufSize
static const UINT32 StringHashOfflineDumpQueueDepth     = 0x7ED77790;   ///< offlineDumpQueueDepth
static const UINT32 PropStringHashOfflineDumpQueueDepth  = 0x23E3BED6;   ///< offlineDumpQueueDepth
static const UINT32 StringHashOfflineDumpAutoStopOffset  = 0x473FFDD3;   ///< offlineDumpAutoStopOffset
static const UINT32 PropStringHashOfflineDumpAutoStopOffset  = 0xD35A2E9F;   ///< offlineDumpAutoStopOffset
static const UINT32 StringHashAutoImageDump             = 0xA33E53A6;   ///< autoImageDump
static const UINT32 PropStringHashAutoImageDump         = 0xE563676F;   ///< autoImageDump
static const UINT32 StringHashDumpInputatOutput         = 0x7FC2AA67;   ///< dumpInputatOutput
static const UINT32 PropStringHashDumpInputatOutput     = 0x3356CFB4;   ///< dumpInputatOutput
static const UINT32 StringHashAutoInputImageDumpMask    = 0x8B72D4F3;   ///< autoInputImageDumpMask
static const UINT32 PropStringHashAutoInputImageDumpMask  = 0x2DEBFC38;   ///< autoInputImageDumpMask
static const UINT32 StringHashIFERegDumpMask            = 0xCE73CEE2;   ///< IFERegDumpMask
static const UINT32 PropStringHashIFERegDumpMask        = 0x8742AF41;   ///< IFERegDumpMask
static const UINT32 StringHashSFERegDumpMask            = 0xCE73CED6;   ///< SFERegDumpMask
static const UINT32 PropStringHashSFERegDumpMask        = 0xEF42AF41;   ///< SFERegDumpMask
static const UINT32 StringHashTFERegDumpMask            = 0xCE73CED8;   ///< TFERegDumpMask
static const UINT32 PropStringHashTFERegDumpMask        = 0xF342AF41;   ///< TFERegDumpMask
static const UINT32 StringHashAutoImageDumpMask         = 0x3A5D39EE;   ///< autoImageDumpMask
static const UINT32 PropStringHashAutoImageDumpMask     = 0x76C95C3D;   ///< autoImageDumpMask
static const UINT32 StringHashAutoImageDumpIFEoutputPortMask  = 0x3C0793C3;   ///< autoImageDumpIFEoutputPortMask
static const UINT32 PropStringHashAutoImageDumpIFEoutputPortMask  = 0xA52F5865;   ///< autoImageDumpIFEoutputPortMask
static const UINT32 StringHashAutoImageDumpIFEVirtualOutputPortMask  = 0xABBDBD4F;   ///< autoImageDumpIFEVirtualOutputPortMask
static const UINT32 PropStringHashAutoImageDumpIFEVirtualOutputPortMask  = 0x62FBE07B;   ///< autoImageDumpIFEVirtualOutputPortMask
static const UINT32 StringHashAutoImageDumpIFEVirtualOutputPortExtendedMask  = 0x75AEA8C9;   ///< autoImageDumpIFEVirtualOutputPortExtendedMask
static const UINT32 PropStringHashAutoImageDumpIFEVirtualOutputPortExtendedMask  = 0x33F39C00;   ///< autoImageDumpIFEVirtualOutputPortExtendedMask
static const UINT32 StringHashAutoImageDumpIFEVirtualRawOutputPortMask  = 0x78CBB90B;   ///< autoImageDumpIFEVirtualRawOutputPortMask
static const UINT32 PropStringHashAutoImageDumpIFEVirtualRawOutputPortMask  = 0x5651DDA8;   ///< autoImageDumpIFEVirtualRawOutputPortMask
static const UINT32 StringHashAutoImageDumpIFEinputPortMask  = 0xD61C2FE2;   ///< autoImageDumpIFEinputPortMask
static const UINT32 PropStringHashAutoImageDumpIFEinputPortMask  = 0xE2D569BF;   ///< autoImageDumpIFEinputPortMask
static const UINT32 StringHashAutoImageDumpIFEoutputBatchNum  = 0xB1752F96;   ///< autoImageDumpIFEoutputBatchNum
static const UINT32 PropStringHashAutoImageDumpIFEoutputBatchNum  = 0x285DE430;   ///< autoImageDumpIFEoutputBatchNum
static const UINT32 StringHashAutoImageDumpIFEInstanceMask  = 0xD7CC328B;   ///< autoImageDumpIFEInstanceMask
static const UINT32 PropStringHashAutoImageDumpIFEInstanceMask  = 0x3E6A78B9;   ///< autoImageDumpIFEInstanceMask
static const UINT32 StringHashAutoImageDumpTFEoutputPortMask  = 0x3C1A93C3;   ///< autoImageDumpTFEoutputPortMask
static const UINT32 PropStringHashAutoImageDumpTFEoutputPortMask  = 0xA5325865;   ///< autoImageDumpTFEoutputPortMask
static const UINT32 StringHashAutoImageDumpTFEVirtualOutputPortMask  = 0xAB55BD4F;   ///< autoImageDumpTFEVirtualOutputPortMask
static const UINT32 PropStringHashAutoImageDumpTFEVirtualOutputPortMask  = 0x6213E07B;   ///< autoImageDumpTFEVirtualOutputPortMask
static const UINT32 StringHashAutoImageDumpTFEVirtualRawOutputPortMask  = 0x78CBB97F;   ///< autoImageDumpTFEVirtualRawOutputPortMask
static const UINT32 PropStringHashAutoImageDumpTFEVirtualRawOutputPortMask  = 0x5651DDDC;   ///< autoImageDumpTFEVirtualRawOutputPortMask
static const UINT32 StringHashAutoImageDumpTFEoutputBatchNum  = 0xB1682F96;   ///< autoImageDumpTFEoutputBatchNum
static const UINT32 PropStringHashAutoImageDumpTFEoutputBatchNum  = 0x2840E430;   ///< autoImageDumpTFEoutputBatchNum
static const UINT32 StringHashAutoImageDumpTFEInstanceMask  = 0xD7CC35CB;   ///< autoImageDumpTFEInstanceMask
static const UINT32 PropStringHashAutoImageDumpTFEInstanceMask  = 0x3E6A7FF9;   ///< autoImageDumpTFEInstanceMask
static const UINT32 StringHashAutoImageDumpIPEoutputPortMask  = 0x3C0723C3;   ///< autoImageDumpIPEoutputPortMask
static const UINT32 PropStringHashAutoImageDumpIPEoutputPortMask  = 0xA52FE865;   ///< autoImageDumpIPEoutputPortMask
static const UINT32 StringHashAutoImageDumpIPEVirtualOutputPortMask  = 0xABB83D4F;   ///< autoImageDumpIPEVirtualOutputPortMask
static const UINT32 PropStringHashAutoImageDumpIPEVirtualOutputPortMask  = 0x62FE607B;   ///< autoImageDumpIPEVirtualOutputPortMask
static const UINT32 StringHashAutoImageDumpIPEinputPortMask  = 0xD61C2A62;   ///< autoImageDumpIPEinputPortMask
static const UINT32 PropStringHashAutoImageDumpIPEinputPortMask  = 0xE2D56C3F;   ///< autoImageDumpIPEinputPortMask
static const UINT32 StringHashAutoImageDumpIPEVirtualInputPortMask  = 0xB2A1D296;   ///< autoImageDumpIPEVirtualInputPortMask
static const UINT32 PropStringHashAutoImageDumpIPEVirtualInputPortMask  = 0x14EBE07F;   ///< autoImageDumpIPEVirtualInputPortMask
static const UINT32 StringHashAutoImageDumpIPEInstanceMask  = 0xD7CC32A7;   ///< autoImageDumpIPEInstanceMask
static const UINT32 PropStringHashAutoImageDumpIPEInstanceMask  = 0x3E6A7895;   ///< autoImageDumpIPEInstanceMask
static const UINT32 StringHashAutoImageDumpOPEoutputPortMask  = 0x3C0123C3;   ///< autoImageDumpOPEoutputPortMask
static const UINT32 PropStringHashAutoImageDumpOPEoutputPortMask  = 0xA529E865;   ///< autoImageDumpOPEoutputPortMask
static const UINT32 StringHashAutoImageDumpOPEinputPortMask  = 0xD61C1A62;   ///< autoImageDumpOPEinputPortMask
static const UINT32 PropStringHashAutoImageDumpOPEinputPortMask  = 0xE2D55C3F;   ///< autoImageDumpOPEinputPortMask
static const UINT32 StringHashAutoImageDumpOPEInstanceMask  = 0xD7CC3327;   ///< autoImageDumpOPEInstanceMask
static const UINT32 PropStringHashAutoImageDumpOPEInstanceMask  = 0x3E6A7915;   ///< autoImageDumpOPEInstanceMask
static const UINT32 StringHashAutoImageDumpBPSoutputPortMask  = 0x3C0C2643;   ///< autoImageDumpBPSoutputPortMask
static const UINT32 PropStringHashAutoImageDumpBPSoutputPortMask  = 0xA524EDE5;   ///< autoImageDumpBPSoutputPortMask
static const UINT32 StringHashAutoImageDumpBPSinputPortMask  = 0xD61C724E;   ///< autoImageDumpBPSinputPortMask
static const UINT32 PropStringHashAutoImageDumpBPSinputPortMask  = 0xE2D53413;   ///< autoImageDumpBPSinputPortMask
static const UINT32 StringHashAutoImageDumpBPSInstanceMask  = 0xB7CC3066;   ///< autoImageDumpBPSInstanceMask
static const UINT32 PropStringHashAutoImageDumpBPSInstanceMask  = 0x5E6A7A54;   ///< autoImageDumpBPSInstanceMask
static const UINT32 StringHashAutoImageDumpJpegHwoutputPortMask  = 0xB798BAD7;   ///< autoImageDumpJpegHwoutputPortMask
static const UINT32 PropStringHashAutoImageDumpJpegHwoutputPortMask  = 0xD24BF643;   ///< autoImageDumpJpegHwoutputPortMask
static const UINT32 StringHashAutoImageDumpJpegHwinputPortMask  = 0x7240D6AA;   ///< autoImageDumpJpegHwinputPortMask
static const UINT32 PropStringHashAutoImageDumpJpegHwinputPortMask  = 0xD16E4CCE;   ///< autoImageDumpJpegHwinputPortMask
static const UINT32 StringHashAutoImageDumpJpegHwInstanceMask  = 0x92EED541;   ///< autoImageDumpJpegHwInstanceMask
static const UINT32 PropStringHashAutoImageDumpJpegHwInstanceMask  = 0xB7F7A192;   ///< autoImageDumpJpegHwInstanceMask
static const UINT32 StringHashAutoImageDumpFDHwoutputPortMask  = 0xDE9279C7;   ///< autoImageDumpFDHwoutputPortMask
static const UINT32 PropStringHashAutoImageDumpFDHwoutputPortMask  = 0xFB8B0D14;   ///< autoImageDumpFDHwoutputPortMask
static const UINT32 StringHashAutoImageDumpFDHwinputPortMask  = 0xF10880B2;   ///< autoImageDumpFDHwinputPortMask
static const UINT32 PropStringHashAutoImageDumpFDHwinputPortMask  = 0x68204B14;   ///< autoImageDumpFDHwinputPortMask
static const UINT32 StringHashAutoImageDumpFDHwInstanceMask  = 0x56F497F1;   ///< autoImageDumpFDHwInstanceMask
static const UINT32 PropStringHashAutoImageDumpFDHwInstanceMask  = 0x623DD1AC;   ///< autoImageDumpFDHwInstanceMask
static const UINT32 StringHashAutoImageDumpLRMEoutputPortMask  = 0xDFC45547;   ///< autoImageDumpLRMEoutputPortMask
static const UINT32 PropStringHashAutoImageDumpLRMEoutputPortMask  = 0xFADD2194;   ///< autoImageDumpLRMEoutputPortMask
static const UINT32 StringHashAutoImageDumpLRMEinputPortMask  = 0xF10231D6;   ///< autoImageDumpLRMEinputPortMask
static const UINT32 PropStringHashAutoImageDumpLRMEinputPortMask  = 0x682AFA70;   ///< autoImageDumpLRMEinputPortMask
static const UINT32 StringHashAutoImageDumpLRMEInstanceMask  = 0x76F4C27A;   ///< autoImageDumpLRMEInstanceMask
static const UINT32 PropStringHashAutoImageDumpLRMEInstanceMask  = 0x423D8427;   ///< autoImageDumpLRMEInstanceMask
static const UINT32 StringHashAutoImageDumpRANSACoutputPortMask  = 0xF2ECF7DB;   ///< autoImageDumpRANSACoutputPortMask
static const UINT32 PropStringHashAutoImageDumpRANSACoutputPortMask  = 0x973FBB4F;   ///< autoImageDumpRANSACoutputPortMask
static const UINT32 StringHashAutoImageDumpRANSACinputPortMask  = 0x106B74C2;   ///< autoImageDumpRANSACinputPortMask
static const UINT32 PropStringHashAutoImageDumpRANSACinputPortMask  = 0xB345EEA6;   ///< autoImageDumpRANSACinputPortMask
static const UINT32 StringHashAutoImageDumpRANSACInstanceMask  = 0xD1FF8852;   ///< autoImageDumpRANSACInstanceMask
static const UINT32 PropStringHashAutoImageDumpRANSACInstanceMask  = 0xF4E6FC81;   ///< autoImageDumpRANSACInstanceMask
static const UINT32 StringHashAutoImageDumpCHINodeoutputPortMask  = 0x9DB2AF4A;   ///< autoImageDumpCHINodeoutputPortMask
static const UINT32 PropStringHashAutoImageDumpCHINodeoutputPortMask  = 0x27DB3DC6;   ///< autoImageDumpCHINodeoutputPortMask
static const UINT32 StringHashAutoImageDumpCHINodeinputPortMask  = 0x9B118606;   ///< autoImageDumpCHINodeinputPortMask
static const UINT32 PropStringHashAutoImageDumpCHINodeinputPortMask  = 0xFEC2CA92;   ///< autoImageDumpCHINodeinputPortMask
static const UINT32 StringHashAutoImageDumpCHINodeInstanceMask  = 0xF5A45FC4;   ///< autoImageDumpCHINodeInstanceMask
static const UINT32 PropStringHashAutoImageDumpCHINodeInstanceMask  = 0x568AC5A0;   ///< autoImageDumpCHINodeInstanceMask
static const UINT32 StringHashAutoImageDumpCVPoutputPortMask  = 0x3C0D1683;   ///< autoImageDumpCVPoutputPortMask
static const UINT32 PropStringHashAutoImageDumpCVPoutputPortMask  = 0xA525DD25;   ///< autoImageDumpCVPoutputPortMask
static const UINT32 StringHashAutoImageDumpCVPinputPortMask  = 0xD61C7BC8;   ///< autoImageDumpCVPinputPortMask
static const UINT32 PropStringHashAutoImageDumpCVPinputPortMask  = 0xE2D53D95;   ///< autoImageDumpCVPinputPortMask
static const UINT32 StringHashAutoImageDumpCVPInstanceMask  = 0x87CC302A;   ///< autoImageDumpCVPInstanceMask
static const UINT32 PropStringHashAutoImageDumpCVPInstanceMask  = 0x6E6A7A18;   ///< autoImageDumpCVPInstanceMask
static const UINT32 StringHashAutoImageDumpQSAToutputPortMask  = 0xDC653107;   ///< autoImageDumpQSAToutputPortMask
static const UINT32 PropStringHashAutoImageDumpQSAToutputPortMask  = 0xF97C45D4;   ///< autoImageDumpQSAToutputPortMask
static const UINT32 StringHashAutoImageDumpQSATinputPortMask  = 0xF11F3AF4;   ///< autoImageDumpQSATinputPortMask
static const UINT32 PropStringHashAutoImageDumpQSATinputPortMask  = 0x6837F152;   ///< autoImageDumpQSATinputPortMask
static const UINT32 StringHashAutoImageDumpQSATInstanceMask  = 0x66F42A23;   ///< autoImageDumpQSATInstanceMask
static const UINT32 PropStringHashAutoImageDumpQSATInstanceMask  = 0x523D6C7E;   ///< autoImageDumpQSATInstanceMask
static const UINT32 StringHashAutoImageDumpITOFoutputPortMask  = 0xDF624587;   ///< autoImageDumpITOFoutputPortMask
static const UINT32 PropStringHashAutoImageDumpITOFoutputPortMask  = 0xFA7B3154;   ///< autoImageDumpITOFoutputPortMask
static const UINT32 StringHashAutoImageDumpITOFinputPortMask  = 0xF1070150;   ///< autoImageDumpITOFinputPortMask
static const UINT32 PropStringHashAutoImageDumpITOFinputPortMask  = 0x682FCAF6;   ///< autoImageDumpITOFinputPortMask
static const UINT32 StringHashAutoImageDumpITOFInstanceMask  = 0x46F4EBFE;   ///< autoImageDumpITOFInstanceMask
static const UINT32 PropStringHashAutoImageDumpITOFInstanceMask  = 0x723DADA3;   ///< autoImageDumpITOFInstanceMask
static const UINT32 StringHashAutoImageDumpCREoutputPortMask  = 0x3C0D33C3;   ///< autoImageDumpCREoutputPortMask
static const UINT32 PropStringHashAutoImageDumpCREoutputPortMask  = 0xA525F865;   ///< autoImageDumpCREoutputPortMask
static const UINT32 StringHashAutoImageDumpCREinputPortMask  = 0xD61C7AE2;   ///< autoImageDumpCREinputPortMask
static const UINT32 PropStringHashAutoImageDumpCREinputPortMask  = 0xE2D53CBF;   ///< autoImageDumpCREinputPortMask
static const UINT32 StringHashAutoImageDumpCREInstanceMask  = 0xD7CC3023;   ///< autoImageDumpCREInstanceMask
static const UINT32 PropStringHashAutoImageDumpCREInstanceMask  = 0x3E6A7A11;   ///< autoImageDumpCREInstanceMask
static const UINT32 StringHashDynamicImageDump          = 0xAF48ED3A;   ///< dynamicImageDump
static const UINT32 PropStringHashDynamicImageDump      = 0x352C4E14;   ///< dynamicImageDump
static const UINT32 StringHashDynamicImageDumpTrigger   = 0x98E5791A;   ///< dynamicImageDumpTrigger
static const UINT32 PropStringHashDynamicImageDumpTrigger  = 0x4BC0606E;   ///< dynamicImageDumpTrigger
static const UINT32 StringHashWatermarkImage            = 0x7B3D2679;   ///< watermarkImage
static const UINT32 PropStringHashWatermarkImage        = 0xB09BBF51;   ///< watermarkImage
static const UINT32 StringHashWatermarkOffset           = 0x6B171F5B;   ///< watermarkOffset
static const UINT32 PropStringHashWatermarkOffset       = 0x1FC43A42;   ///< watermarkOffset
static const UINT32 StringHashReprocessDump             = 0xB24DF5D6;   ///< reprocessDump
static const UINT32 PropStringHashReprocessDump         = 0xF410C11F;   ///< reprocessDump
static const UINT32 StringHashInputDumpOnOutputFenceError  = 0xC90CC89B;   ///< inputDumpOnOutputFenceError
static const UINT32 PropStringHashInputDumpOnOutputFenceError  = 0x309BBF02;   ///< inputDumpOnOutputFenceError
static const UINT32 StringHashOfflineImageDumpOnly      = 0x2E91E0BE;   ///< offlineImageDumpOnly
static const UINT32 PropStringHashOfflineImageDumpOnly  = 0x1C7846F4;   ///< offlineImageDumpOnly
static const UINT32 StringHashMetadataDumpDuringSystemEvents  = 0x6BAB4FB5;   ///< metadataDumpDuringSystemEvents
static const UINT32 PropStringHashMetadataDumpDuringSystemEvents  = 0xF2838413;   ///< metadataDumpDuringSystemEvents
static const UINT32 StringHashForceMaxFPS               = 0x9DB80772;   ///< forceMaxFPS
static const UINT32 PropStringHashForceMaxFPS           = 0xAFE9903F;   ///< forceMaxFPS
static const UINT32 StringHashPerFrameSensorMode        = 0x306BBFEB;   ///< perFrameSensorMode
static const UINT32 PropStringHashPerFrameSensorMode    = 0xA2E70582;   ///< perFrameSensorMode
static const UINT32 StringHashEnablePN9PatternTest      = 0x6BD6B438;   ///< enablePN9PatternTest
static const UINT32 PropStringHashEnablePN9PatternTest  = 0x593F1272;   ///< enablePN9PatternTest
static const UINT32 StringHashEnableDynamicModeSwitchVCUpdate  = 0xB7EADCB5;   ///< enableDynamicModeSwitchVCUpdate
static const UINT32 PropStringHashEnableDynamicModeSwitchVCUpdate  = 0x92F3A866;   ///< enableDynamicModeSwitchVCUpdate
static const UINT32 StringHashCdrTolerance              = 0xFD0F0366;   ///< cdrTolerance
static const UINT32 PropStringHashCdrTolerance          = 0xB73DEAC0;   ///< cdrTolerance
static const UINT32 StringHashCdrToleranceType          = 0x36543A95;   ///< cdrToleranceType
static const UINT32 PropStringHashCdrToleranceType      = 0xAC3099BB;   ///< cdrToleranceType
static const UINT32 StringHashCdrLaneValue              = 0x7D4F11D6;   ///< cdrLaneValue
static const UINT32 PropStringHashCdrLaneValue          = 0x377DF870;   ///< cdrLaneValue
static const UINT32 StringHashEnableCDRSweepTest        = 0xE1E8BAEB;   ///< enableCDRSweepTest
static const UINT32 PropStringHashEnableCDRSweepTest    = 0x73640082;   ///< enableCDRSweepTest
static const UINT32 StringHashCSIPHYAuxDatarateMax      = 0x69BC31F9;   ///< CSIPHYAuxDatarateMax
static const UINT32 PropStringHashCSIPHYAuxDatarateMax  = 0x5B5597B3;   ///< CSIPHYAuxDatarateMax
static const UINT32 StringHashEnableCSIPHYAuxDatarateMap  = 0xA4AC6FAD;   ///< EnableCSIPHYAuxDatarateMap
static const UINT32 PropStringHashEnableCSIPHYAuxDatarateMap  = 0x2816063F;   ///< EnableCSIPHYAuxDatarateMap
static const UINT32 StringHashDisablePDAF               = 0x5FF4CC56;   ///< disablePDAF
static const UINT32 PropStringHashDisablePDAF           = 0x6DA55B1B;   ///< disablePDAF
static const UINT32 StringHashDisablePDAFInit           = 0xC550CA18;   ///< disablePDAFInit
static const UINT32 PropStringHashDisablePDAFInit       = 0xB183EF01;   ///< disablePDAFInit
static const UINT32 StringHashDisablePreProcessedOutputPorts  = 0x26FEEF2F;   ///< disablePreProcessedOutputPorts
static const UINT32 PropStringHashDisablePreProcessedOutputPorts  = 0xBFD62489;   ///< disablePreProcessedOutputPorts
static const UINT32 StringHashEnableRDIPorts            = 0x0433A0B6;   ///< enableRDIPorts
static const UINT32 PropStringHashEnableRDIPorts        = 0xCF95399E;   ///< enableRDIPorts
static const UINT32 StringHashEnablePDAFConfigurationChecks  = 0x86866953;   ///< enablePDAFConfigurationChecks
static const UINT32 PropStringHashEnablePDAFConfigurationChecks  = 0xB24F2F0E;   ///< enablePDAFConfigurationChecks
static const UINT32 StringHashEnableSensorDebugMask     = 0x3C5A1F51;   ///< enableSensorDebugMask
static const UINT32 PropStringHashEnableSensorDebugMask  = 0x616ED617;   ///< enableSensorDebugMask
static const UINT32 StringHashEnableTouchToTrack        = 0xBE075808;   ///< enableTouchToTrack
static const UINT32 PropStringHashEnableTouchToTrack    = 0x2C8BE261;   ///< enableTouchToTrack
static const UINT32 StringHashEnableDRV                 = 0x82F3785E;   ///< enableDRV
static const UINT32 PropStringHashEnableDRV             = 0x51BFEC3B;   ///< enableDRV
static const UINT32 StringHashEnablePerFrameDRVUpdate   = 0xC0C1E303;   ///< enablePerFrameDRVUpdate
static const UINT32 PropStringHashEnablePerFrameDRVUpdate  = 0x13E4FA77;   ///< enablePerFrameDRVUpdate
static const UINT32 StringHashDRVTimeOutValue           = 0xF4F8E143;   ///< DRVTimeOutValue
static const UINT32 PropStringHashDRVTimeOutValue       = 0x802BC45A;   ///< DRVTimeOutValue
static const UINT32 StringHashDRVBlankingThreshold      = 0x0E905E11;   ///< DRVBlankingThreshold
static const UINT32 PropStringHashDRVBlankingThreshold  = 0x3C79F85B;   ///< DRVBlankingThreshold
static const UINT32 StringHashUseDefaultFrameDurationForDRV  = 0x524FC139;   ///< useDefaultFrameDurationForDRV
static const UINT32 PropStringHashUseDefaultFrameDurationForDRV  = 0x66868764;   ///< useDefaultFrameDurationForDRV
static const UINT32 StringHashEnableInitRegDump         = 0xBF0C1BEE;   ///< enableInitRegDump
static const UINT32 PropStringHashEnableInitRegDump     = 0xF3987E3D;   ///< enableInitRegDump
static const UINT32 StringHashInitRegDumpMask           = 0x36F3D4AC;   ///< initRegDumpMask
static const UINT32 PropStringHashInitRegDumpMask       = 0x4220F1B5;   ///< initRegDumpMask
static const UINT32 StringHashEnableSALINet             = 0x627D1BE6;   ///< enableSALINet
static const UINT32 PropStringHashEnableSALINet         = 0x24202F2F;   ///< enableSALINet
static const UINT32 StringHashEnableSALINetProfile      = 0xF12A76CA;   ///< enableSALINetProfile
static const UINT32 PropStringHashEnableSALINetProfile  = 0x0ECD9691;   ///< enableSALINetProfile
static const UINT32 StringHashEnableSALINetDump         = 0xBE55FE01;   ///< enableSALINetDump
static const UINT32 PropStringHashEnableSALINetDump     = 0x7EE201CE;   ///< enableSALINetDump
static const UINT32 StringHashEnablePDNet               = 0xCCAA16DF;   ///< enablePDNet
static const UINT32 PropStringHashEnablePDNet           = 0xFEFB8192;   ///< enablePDNet
static const UINT32 StringHashEnablePDNetProfile        = 0x87921F07;   ///< enablePDNetProfile
static const UINT32 PropStringHashEnablePDNetProfile    = 0x916DE6FF;   ///< enablePDNetProfile
static const UINT32 StringHashEnablePDNetDump           = 0x6DCF1371;   ///< enablePDNetDump
static const UINT32 PropStringHashEnablePDNetDump       = 0x9E3F3E8E;   ///< enablePDNetDump
static const UINT32 StringHashDefaultMaxFPS             = 0xAF39C008;   ///< defaultMaxFPS
static const UINT32 PropStringHashDefaultMaxFPS         = 0xE964F4C1;   ///< defaultMaxFPS
static const UINT32 StringHashDisableDRQPreemptionOnStopRecord  = 0xD0A91874;   ///< disableDRQPreemptionOnStopRecord
static const UINT32 PropStringHashDisableDRQPreemptionOnStopRecord  = 0x7D1A750A;   ///< disableDRQPreemptionOnStopRecord
static const UINT32 StringHashDisableVideoPerfModeSetting  = 0xE73415A9;   ///< disableVideoPerfModeSetting
static const UINT32 PropStringHashDisableVideoPerfModeSetting  = 0x707927F8;   ///< disableVideoPerfModeSetting
static const UINT32 StringHashEnableSensorAcquireOptimization  = 0x95DEB12A;   ///< enableSensorAcquireOptimization
static const UINT32 PropStringHashEnableSensorAcquireOptimization  = 0xB0C7C5F9;   ///< enableSensorAcquireOptimization
static const UINT32 StringHashCamVersionOverride        = 0x593350CD;   ///< camVersionOverride
static const UINT32 PropStringHashCamVersionOverride    = 0xCBBFEAA4;   ///< camVersionOverride
static const UINT32 StringHashOverrideOPPCLOCK          = 0xFEAC3322;   ///< overrideOPPCLOCK
static const UINT32 PropStringHashOverrideOPPCLOCK      = 0x64C8900C;   ///< overrideOPPCLOCK
static const UINT32 StringHashEnablepGeolibOffCenterZoom  = 0x52549307;   ///< enablepGeolibOffCenterZoom
static const UINT32 PropStringHashEnablepGeolibOffCenterZoom  = 0xDEEEFA95;   ///< enablepGeolibOffCenterZoom
static const UINT32 StringHashTfTestMode                = 0xA179D55C;   ///< tfTestMode
static const UINT32 PropStringHashTfTestMode            = 0xC8EB59E6;   ///< tfTestMode
static const UINT32 StringHashInvalidSOFThreshold       = 0x9C80156D;   ///< invalidSOFThreshold
static const UINT32 PropStringHashInvalidSOFThreshold   = 0xCD17585F;   ///< invalidSOFThreshold
static const UINT32 StringHashDump3AStats               = 0x0495447F;   ///< dump3AStats
static const UINT32 PropStringHashDump3AStats           = 0x36C4D332;   ///< dump3AStats
static const UINT32 StringHashDump3AStatsNum            = 0xA23E3487;   ///< dump3AStatsNum
static const UINT32 PropStringHashDump3AStatsNum        = 0x6998ADAF;   ///< dump3AStatsNum
static const UINT32 StringHashEnableHJAF                = 0x5E696956;   ///< enableHJAF
static const UINT32 PropStringHashEnableHJAF            = 0x3B8C5D99;   ///< enableHJAF
static const UINT32 StringHashEnableSPD                 = 0x82F3240C;   ///< enableSPD
static const UINT32 PropStringHashEnableSPD             = 0xF9DC0DAA;   ///< enableSPD
static const UINT32 StringHashSpdStatsType              = 0x97471ADD;   ///< spdStatsType
static const UINT32 PropStringHashSpdStatsType          = 0x0394274A;   ///< spdStatsType
static const UINT32 StringHashDisableFocusIndication    = 0x83451B44;   ///< disableFocusIndication
static const UINT32 PropStringHashDisableFocusIndication  = 0xB3BFD081;   ///< disableFocusIndication
static const UINT32 StringHashSpotlightFallbackToCAF    = 0x1DA1228E;   ///< spotlightFallbackToCAF
static const UINT32 PropStringHashSpotlightFallbackToCAF  = 0xEBFF71C2;   ///< spotlightFallbackToCAF
static const UINT32 StringHashAfLog                     = 0x0622BD87;   ///< afLog
static const UINT32 PropStringHashAfLog                 = 0xECBD1B1E;   ///< afLog
static const UINT32 StringHashFovcEnable                = 0x0CDDA94D;   ///< fovcEnable
static const UINT32 PropStringHashFovcEnable            = 0x7F1507BB;   ///< fovcEnable
static const UINT32 StringHashGyroDataReportRate        = 0x04682770;   ///< gyroDataReportRate
static const UINT32 PropStringHashGyroDataReportRate    = 0x409D9052;   ///< gyroDataReportRate
static const UINT32 StringHashGyroSensorSamplingRate    = 0x3047FC2E;   ///< gyroSensorSamplingRate
static const UINT32 PropStringHashGyroSensorSamplingRate  = 0xBD8DB4BD;   ///< gyroSensorSamplingRate
static const UINT32 StringHashGravityDataReportRate     = 0x825814B8;   ///< gravityDataReportRate
static const UINT32 PropStringHashGravityDataReportRate  = 0xC1530342;   ///< gravityDataReportRate
static const UINT32 StringHashGravitySensorSamplingRate  = 0x0CCF9F2D;   ///< gravitySensorSamplingRate
static const UINT32 PropStringHashGravitySensorSamplingRate  = 0x3C4327AD;   ///< gravitySensorSamplingRate
static const UINT32 StringHashTOFDataReportRate         = 0x0885CD30;   ///< TOFDataReportRate
static const UINT32 PropStringHashTOFDataReportRate     = 0x2B6835B8;   ///< TOFDataReportRate
static const UINT32 StringHashTOFSensorSamplingRate     = 0x944732F0;   ///< TOFSensorSamplingRate
static const UINT32 PropStringHashTOFSensorSamplingRate  = 0xD6781157;   ///< TOFSensorSamplingRate
static const UINT32 StringHashCustomTOFSensorLib        = 0x876E88A9;   ///< customTOFSensorLib
static const UINT32 PropStringHashCustomTOFSensorLib    = 0x9CD78333;   ///< customTOFSensorLib
static const UINT32 StringHashSensorTypeTof             = 0xF605510C;   ///< SensorTypeTof
static const UINT32 PropStringHashSensorTypeTof         = 0xBAE65503;   ///< SensorTypeTof
static const UINT32 StringHashMwEnable                  = 0x0CD10690;   ///< mwEnable
static const UINT32 PropStringHashMwEnable              = 0x9F9DFF33;   ///< mwEnable
static const UINT32 StringHashAdaptLensMap              = 0xFDC46BEB;   ///< adaptLensMap
static const UINT32 PropStringHashAdaptLensMap          = 0x6917567C;   ///< adaptLensMap
static const UINT32 StringHashEnableAFAlgo              = 0xB7657DF6;   ///< enableAFAlgo
static const UINT32 PropStringHashEnableAFAlgo          = 0xE71AF209;   ///< enableAFAlgo
static const UINT32 StringHashAfFullsweep               = 0xDE82BD63;   ///< afFullsweep
static const UINT32 PropStringHashAfFullsweep           = 0x80F3930B;   ///< afFullsweep
static const UINT32 StringHashManualAf                  = 0x9B613F36;   ///< manualAf
static const UINT32 PropStringHashManualAf              = 0x00F667BF;   ///< manualAf
static const UINT32 StringHashLensPos                   = 0xCCD84D88;   ///< lensPos
static const UINT32 PropStringHashLensPos               = 0x0BB24F04;   ///< lensPos
static const UINT32 StringHashVmDebugMask               = 0x6D92CD3B;   ///< vmDebugMask
static const UINT32 PropStringHashVmDebugMask           = 0xA08BD2A5;   ///< vmDebugMask
static const UINT32 StringHashAFRecorderMode            = 0x958F3CA8;   ///< AFRecorderMode
static const UINT32 PropStringHashAFRecorderMode        = 0x615C01FB;   ///< AFRecorderMode
static const UINT32 StringHashEnableLensSagComp         = 0xF71A94D6;   ///< enableLensSagComp
static const UINT32 PropStringHashEnableLensSagComp     = 0xD83332AD;   ///< enableLensSagComp
static const UINT32 StringHashActiveNodeMask            = 0x05CDACA4;   ///< activeNodeMask
static const UINT32 PropStringHashActiveNodeMask        = 0xCF8FC490;   ///< activeNodeMask
static const UINT32 StringHashApiMask                   = 0xA6A70A13;   ///< apiMask
static const UINT32 PropStringHashApiMask               = 0x856E7C37;   ///< apiMask
static const UINT32 StringHashManualExposureType        = 0x5CC7EB64;   ///< manualExposureType
static const UINT32 PropStringHashManualExposureType    = 0xC6312754;   ///< manualExposureType
static const UINT32 StringHashDualBHistSupport          = 0xDD97DF0C;   ///< dualBHistSupport
static const UINT32 PropStringHashDualBHistSupport      = 0x21F7B753;   ///< dualBHistSupport
static const UINT32 StringHashDisableBGStatsForAF       = 0x1D94430C;   ///< disableBGStatsForAF
static const UINT32 PropStringHashDisableBGStatsForAF   = 0x29BBBD3C;   ///< disableBGStatsForAF
static const UINT32 StringHashEnableCustomAlgoAEC       = 0x0CA6EF7E;   ///< enableCustomAlgoAEC
static const UINT32 PropStringHashEnableCustomAlgoAEC   = 0x3889114E;   ///< enableCustomAlgoAEC
static const UINT32 StringHashDisableAECStatsProcessing  = 0xD9D858FE;   ///< disableAECStatsProcessing
static const UINT32 PropStringHashDisableAECStatsProcessing  = 0x4DBD8BB2;   ///< disableAECStatsProcessing
static const UINT32 StringHashDisableAFAWBpreFlash      = 0xC4DF006B;   ///< disableAFAWBpreFlash
static const UINT32 PropStringHashDisableAFAWBpreFlash  = 0x4120C66D;   ///< disableAFAWBpreFlash
static const UINT32 StringHashYuvPlaneAlignment         = 0x79996EA8;   ///< yuvPlaneAlignment
static const UINT32 PropStringHashYuvPlaneAlignment     = 0x350D0B7B;   ///< yuvPlaneAlignment
static const UINT32 StringHashPreFlashMaxFrameWaitLimitAF  = 0xA9C5FE72;   ///< preFlashMaxFrameWaitLimitAF
static const UINT32 PropStringHashPreFlashMaxFrameWaitLimitAF  = 0x01090FAD;   ///< preFlashMaxFrameWaitLimitAF
static const UINT32 StringHashPreFlashMaxFrameWaitLimitAWB  = 0x38BFCC17;   ///< preFlashMaxFrameWaitLimitAWB
static const UINT32 PropStringHashPreFlashMaxFrameWaitLimitAWB  = 0x2121F7E2;   ///< preFlashMaxFrameWaitLimitAWB
static const UINT32 StringHashDisablePreFlashOnForTouchAE  = 0xFB81A79C;   ///< disablePreFlashOnForTouchAE
static const UINT32 PropStringHashDisablePreFlashOnForTouchAE  = 0x7E9CCE67;   ///< disablePreFlashOnForTouchAE
static const UINT32 StringHashNumberOfFramesToSkip      = 0xA5CD5B0A;   ///< numberOfFramesToSkip
static const UINT32 PropStringHashNumberOfFramesToSkip  = 0x33EF774A;   ///< numberOfFramesToSkip
static const UINT32 StringHashCustomAlgoAECName         = 0x4B6FD98B;   ///< customAlgoAECName
static const UINT32 PropStringHashCustomAlgoAECName     = 0x9BB211D7;   ///< customAlgoAECName
static const UINT32 StringHashCustomAlgoAECPath         = 0x4B60DAA6;   ///< customAlgoAECPath
static const UINT32 PropStringHashCustomAlgoAECPath     = 0x9BBD12FA;   ///< customAlgoAECPath
static const UINT32 StringHashEnableCustomAlgoAWB       = 0x0CA6ED3F;   ///< enableCustomAlgoAWB
static const UINT32 PropStringHashEnableCustomAlgoAWB   = 0x3889371F;   ///< enableCustomAlgoAWB
static const UINT32 StringHashCustomAlgoAWBName         = 0x6F7FD98B;   ///< customAlgoAWBName
static const UINT32 PropStringHashCustomAlgoAWBName     = 0xBFA211D7;   ///< customAlgoAWBName
static const UINT32 StringHashCustomAlgoAWBPath         = 0x6F70DAA6;   ///< customAlgoAWBPath
static const UINT32 PropStringHashCustomAlgoAWBPath     = 0xBFAD12FA;   ///< customAlgoAWBPath
static const UINT32 StringHashEnableCustomAlgoAF        = 0xE865377B;   ///< enableCustomAlgoAF
static const UINT32 PropStringHashEnableCustomAlgoAF    = 0xD5A83C84;   ///< enableCustomAlgoAF
static const UINT32 StringHashCustomAlgoAFName          = 0x726DC347;   ///< customAlgoAFName
static const UINT32 PropStringHashCustomAlgoAFName      = 0x94EB2D05;   ///< customAlgoAFName
static const UINT32 StringHashCustomAlgoAFPath          = 0x7262C06A;   ///< customAlgoAFPath
static const UINT32 PropStringHashCustomAlgoAFPath      = 0x94E42E28;   ///< customAlgoAFPath
static const UINT32 StringHashEnableCustomHAFAlgo       = 0x56B1DB30;   ///< enableCustomHAFAlgo
static const UINT32 PropStringHashEnableCustomHAFAlgo   = 0xEF10A4D7;   ///< enableCustomHAFAlgo
static const UINT32 StringHashCustomHAFAlgoName         = 0x0F8A78F8;   ///< customHAFAlgoName
static const UINT32 PropStringHashCustomHAFAlgoName     = 0x8BF00595;   ///< customHAFAlgoName
static const UINT32 StringHashCustomHAFAlgoPath         = 0x0F857BD5;   ///< customHAFAlgoPath
static const UINT32 PropStringHashCustomHAFAlgoPath     = 0xDF58B389;   ///< customHAFAlgoPath
static const UINT32 StringHashOverrideHAFAlgoMask       = 0x094DC34D;   ///< overrideHAFAlgoMask
static const UINT32 PropStringHashOverrideHAFAlgoMask   = 0xD841730A;   ///< overrideHAFAlgoMask
static const UINT32 StringHashEnableStatsExposureSetting  = 0xAA7EA740;   ///< enableStatsExposureSetting
static const UINT32 PropStringHashEnableStatsExposureSetting  = 0x13753D5B;   ///< enableStatsExposureSetting
static const UINT32 StringHashExposureGain              = 0x910C65CB;   ///< exposureGain
static const UINT32 PropStringHashExposureGain          = 0xA55E64F9;   ///< exposureGain
static const UINT32 StringHashExposureTime              = 0x9105C540;   ///< exposureTime
static const UINT32 PropStringHashExposureTime          = 0x81E07B6A;   ///< exposureTime
static const UINT32 StringHashPredictiveGain            = 0xB97F4913;   ///< predictiveGain
static const UINT32 PropStringHashPredictiveGain        = 0x97085C14;   ///< predictiveGain
static const UINT32 StringHashPredictiveGainSFE         = 0xA4881C1A;   ///< predictiveGainSFE
static const UINT32 PropStringHashPredictiveGainSFE     = 0x2E0B8B21;   ///< predictiveGainSFE
static const UINT32 StringHashLuxIndex                  = 0xB6A69FA5;   ///< luxIndex
static const UINT32 PropStringHashLuxIndex              = 0x6DDCC963;   ///< luxIndex
static const UINT32 StringHashExtendedTimeForLongExposure  = 0x5B0480B2;   ///< extendedTimeForLongExposure
static const UINT32 PropStringHashExtendedTimeForLongExposure  = 0x74FAB086;   ///< extendedTimeForLongExposure
static const UINT32 StringHashManualWhiteBalanceType    = 0xEB20DB85;   ///< manualWhiteBalanceType
static const UINT32 PropStringHashManualWhiteBalanceType  = 0xC631355C;   ///< manualWhiteBalanceType
static const UINT32 StringHashRGain                     = 0x0712094E;   ///< rGain
static const UINT32 PropStringHashRGain                 = 0x8A1FBFBB;   ///< rGain
static const UINT32 StringHashGGain                     = 0x0642094E;   ///< gGain
static const UINT32 PropStringHashGGain                 = 0x8B4FBFBB;   ///< gGain
static const UINT32 StringHashBGain                     = 0x0612094E;   ///< BGain
static const UINT32 PropStringHashBGain                 = 0x8B1FBFBB;   ///< BGain
static const UINT32 StringHashColorTemp                 = 0xD91BF9B3;   ///< colorTemp
static const UINT32 PropStringHashColorTemp             = 0xB6432968;   ///< colorTemp
static const UINT32 StringHashIgnoreSceneMode           = 0x4C23FA6C;   ///< ignoreSceneMode
static const UINT32 PropStringHashIgnoreSceneMode       = 0x9737C75F;   ///< ignoreSceneMode
static const UINT32 StringHashEnableCustomAlgoASD       = 0x0CA6EDB9;   ///< enableCustomAlgoASD
static const UINT32 PropStringHashEnableCustomAlgoASD   = 0x6BFA7111;   ///< enableCustomAlgoASD
static const UINT32 StringHashCustomAlgoASDName         = 0x671FD98B;   ///< customAlgoASDName
static const UINT32 PropStringHashCustomAlgoASDName     = 0xB772270D;   ///< customAlgoASDName
static const UINT32 StringHashCustomAlgoASDPath         = 0x6710DAA6;   ///< customAlgoASDPath
static const UINT32 PropStringHashCustomAlgoASDPath     = 0xB77D2420;   ///< customAlgoASDPath
static const UINT32 StringHashEnableCustomAlgoAFD       = 0x0CA6EF19;   ///< enableCustomAlgoAFD
static const UINT32 PropStringHashEnableCustomAlgoAFD   = 0x3FFA7111;   ///< enableCustomAlgoAFD
static const UINT32 StringHashCustomAlgoAFDName         = 0x4D1FD98B;   ///< customAlgoAFDName
static const UINT32 PropStringHashCustomAlgoAFDName     = 0xB767270D;   ///< customAlgoAFDName
static const UINT32 StringHashCustomAlgoAFDPath         = 0x4D10DAA6;   ///< customAlgoAFDPath
static const UINT32 PropStringHashCustomAlgoAFDPath     = 0xB7682420;   ///< customAlgoAFDPath
static const UINT32 StringHashIhistStatsOffset          = 0x139370BD;   ///< ihistStatsOffset
static const UINT32 PropStringHashIhistStatsOffset      = 0x89F7D393;   ///< ihistStatsOffset
static const UINT32 StringHashRsStatsOffset             = 0x0010226F;   ///< rsStatsOffset
static const UINT32 PropStringHashRsStatsOffset         = 0x464D16A6;   ///< rsStatsOffset
static const UINT32 StringHashFdVendorTagReadOffset     = 0x7D8DDBB5;   ///< fdVendorTagReadOffset
static const UINT32 PropStringHashFdVendorTagReadOffset  = 0x20B912F3;   ///< fdVendorTagReadOffset
static const UINT32 StringHashEnableCustom3AData        = 0x4CB48DDC;   ///< enableCustom3AData
static const UINT32 PropStringHashEnableCustom3AData    = 0xDE3837B5;   ///< enableCustom3AData
static const UINT32 StringHashEnableVSR                 = 0x82F3307A;   ///< enableVSR
static const UINT32 StringHashOverrideEnableVSR         = 0x978339D9;   ///< overrideEnableVSR
static const UINT32 PropStringHashOverrideEnableVSR     = 0x946BE5B8;   ///< overrideEnableVSR
static const UINT32 StringHashEnableBDSSplitFeature     = 0xCC4906B5;   ///< enableBDSSplitFeature
static const UINT32 StringHashEnableQSAT                = 0x5E658D44;   ///< enableQSAT
static const UINT32 PropStringHashEnableQSAT            = 0x37F701FE;   ///< enableQSAT
static const UINT32 StringHashSetVideoBokehMode         = 0xAF5E846D;   ///< setVideoBokehMode
static const UINT32 PropStringHashSetVideoBokehMode     = 0xE3CAE1BE;   ///< setVideoBokehMode
static const UINT32 StringHashEnableVBSEBasedVideoBokeh  = 0xA9503847;   ///< enableVBSEBasedVideoBokeh
static const UINT32 PropStringHashEnableVBSEBasedVideoBokeh  = 0x3D35EB0B;   ///< enableVBSEBasedVideoBokeh
static const UINT32 StringHashSegMode                   = 0x0C4730F9;   ///< segMode
static const UINT32 PropStringHashSegMode               = 0x1533E3DC;   ///< segMode
static const UINT32 StringHashBypassSegmentationProcessing  = 0xF177F0E1;   ///< bypassSegmentationProcessing
static const UINT32 PropStringHashBypassSegmentationProcessing  = 0x18D1BAD3;   ///< bypassSegmentationProcessing
static const UINT32 StringHashAllowDelaySegMemAllocation  = 0x90324F02;   ///< allowDelaySegMemAllocation
static const UINT32 PropStringHashAllowDelaySegMemAllocation  = 0x1C882690;   ///< allowDelaySegMemAllocation
static const UINT32 StringHashEnableAIStatsMetadata     = 0x2D864C63;   ///< enableAIStatsMetadata
static const UINT32 PropStringHashEnableAIStatsMetadata  = 0x70B28525;   ///< enableAIStatsMetadata
static const UINT32 StringHashDisableCVPDriver          = 0xEFAAAEDE;   ///< disableCVPDriver
static const UINT32 PropStringHashDisableCVPDriver      = 0x75CE0DF0;   ///< disableCVPDriver
static const UINT32 StringHashEnableEVAiTOF             = 0xCCAD72B1;   ///< enableEVAiTOF
static const UINT32 StringHashDebugDataHeaderString     = 0x4224D04E;   ///< debugDataHeaderString
static const UINT32 PropStringHashDebugDataHeaderString  = 0xCAFE1DF8;   ///< debugDataHeaderString
static const UINT32 StringHashEnable3ADebugData         = 0x9E65A553;   ///< enable3ADebugData
static const UINT32 PropStringHashEnable3ADebugData     = 0xAB2128D3;   ///< enable3ADebugData
static const UINT32 StringHashDebugDataSizeAEC          = 0x778C6654;   ///< debugDataSizeAEC
static const UINT32 PropStringHashDebugDataSizeAEC      = 0x1AEABD10;   ///< debugDataSizeAEC
static const UINT32 StringHashDebugDataSizeAWB          = 0x778C6415;   ///< debugDataSizeAWB
static const UINT32 PropStringHashDebugDataSizeAWB      = 0x1AEABF51;   ///< debugDataSizeAWB
static const UINT32 StringHashDebugDataSizeAF           = 0xBBBC6332;   ///< debugDataSizeAF
static const UINT32 PropStringHashDebugDataSizeAF       = 0x98D755E8;   ///< debugDataSizeAF
static const UINT32 StringHashDebugDataSizeAFD          = 0x778C6633;   ///< debugDataSizeAFD
static const UINT32 PropStringHashDebugDataSizeAFD      = 0x1AEABD77;   ///< debugDataSizeAFD
static const UINT32 StringHashDebugDataSizeAFC          = 0x778C6634;   ///< debugDataSizeAFC
static const UINT32 PropStringHashDebugDataSizeAFC      = 0x1AEABD70;   ///< debugDataSizeAFC
static const UINT32 StringHashEnableConcise3ADebugData  = 0xF53CE1D3;   ///< enableConcise3ADebugData
static const UINT32 PropStringHashEnableConcise3ADebugData  = 0x19A104F7;   ///< enableConcise3ADebugData
static const UINT32 StringHashConciseDebugDataSizeAEC   = 0x5D917E84;   ///< conciseDebugDataSizeAEC
static const UINT32 PropStringHashConciseDebugDataSizeAEC  = 0xC256AA33;   ///< conciseDebugDataSizeAEC
static const UINT32 StringHashConciseDebugDataSizeAF    = 0x3AEC8BF4;   ///< conciseDebugDataSizeAF
static const UINT32 PropStringHashConciseDebugDataSizeAF  = 0x8612B551;   ///< conciseDebugDataSizeAF
static const UINT32 StringHashConciseDebugDataSizeAWB   = 0x5D917CC5;   ///< conciseDebugDataSizeAWB
static const UINT32 PropStringHashConciseDebugDataSizeAWB  = 0xC256A872;   ///< conciseDebugDataSizeAWB
static const UINT32 StringHashEnable3ADebugDataCustomFilter  = 0x831B91E4;   ///< enable3ADebugDataCustomFilter
static const UINT32 PropStringHashEnable3ADebugDataCustomFilter  = 0xEE68523A;   ///< enable3ADebugDataCustomFilter
static const UINT32 StringHashEnable3ADebugDataDump     = 0x550A3F8A;   ///< enable3ADebugDataDump
static const UINT32 PropStringHashEnable3ADebugDataDump  = 0x8D096BC2;   ///< enable3ADebugDataDump
static const UINT32 StringHashEnableTuningMetadata      = 0xFCCB570C;   ///< enableTuningMetadata
static const UINT32 PropStringHashEnableTuningMetadata  = 0xE2383C92;   ///< enableTuningMetadata
static const UINT32 StringHashTuningDumpDataSizeIFE     = 0xC9425926;   ///< tuningDumpDataSizeIFE
static const UINT32 PropStringHashTuningDumpDataSizeIFE  = 0x172F2AE5;   ///< tuningDumpDataSizeIFE
static const UINT32 StringHashTuningDumpDataSizeTFE     = 0xC9422D26;   ///< tuningDumpDataSizeTFE
static const UINT32 PropStringHashTuningDumpDataSizeTFE  = 0x172F5EE5;   ///< tuningDumpDataSizeTFE
static const UINT32 StringHashTuningDumpDataSizeIPE     = 0xC9425BE6;   ///< tuningDumpDataSizeIPE
static const UINT32 PropStringHashTuningDumpDataSizeIPE  = 0x172F2825;   ///< tuningDumpDataSizeIPE
static const UINT32 StringHashTuningDumpDataSizeMFHDR   = 0x0924A3D7;   ///< tuningDumpDataSizeMFHDR
static const UINT32 PropStringHashTuningDumpDataSizeMFHDR  = 0xBCEBACAE;   ///< tuningDumpDataSizeMFHDR
static const UINT32 StringHashTuningDumpDataSizeOPE     = 0xC94243E6;   ///< tuningDumpDataSizeOPE
static const UINT32 PropStringHashTuningDumpDataSizeOPE  = 0x172F3025;   ///< tuningDumpDataSizeOPE
static const UINT32 StringHashEnablePreviewLTMDCStatsUsageOPE  = 0x942D390F;   ///< enablePreviewLTMDCStatsUsageOPE
static const UINT32 PropStringHashEnablePreviewLTMDCStatsUsageOPE  = 0xA91EDAFC;   ///< enablePreviewLTMDCStatsUsageOPE
static const UINT32 StringHashTuningDumpDataSizeBPS     = 0xC94277F0;   ///< tuningDumpDataSizeBPS
static const UINT32 PropStringHashTuningDumpDataSizeBPS  = 0x172F0433;   ///< tuningDumpDataSizeBPS
static const UINT32 StringHashEnableDebugDataNewMemAllocation  = 0xB75BC3A2;   ///< enableDebugDataNewMemAllocation
static const UINT32 PropStringHashEnableDebugDataNewMemAllocation  = 0x9242B771;   ///< enableDebugDataNewMemAllocation
static const UINT32 StringHashDumpDebugDataEveryProcessResult  = 0x4A508CB2;   ///< dumpDebugDataEveryProcessResult
static const UINT32 PropStringHashDumpDebugDataEveryProcessResult  = 0x7D229B86;   ///< dumpDebugDataEveryProcessResult
static const UINT32 StringHashDebugDataOfflineAlloc     = 0x6CF72C0D;   ///< debugDataOfflineAlloc
static const UINT32 PropStringHashDebugDataOfflineAlloc  = 0xB29A5FCE;   ///< debugDataOfflineAlloc
static const UINT32 StringHashDRCGainThresholdForSWTLBEStatsGen  = 0xD1A0D7CD;   ///< DRCGainThresholdForSWTLBEStatsGen
static const UINT32 PropStringHashDRCGainThresholdForSWTLBEStatsGen  = 0xC48AB32F;   ///< DRCGainThresholdForSWTLBEStatsGen
static const UINT32 StringHashDisablePDLibCHIOverload   = 0xE86996FE;   ///< disablePDLibCHIOverload
static const UINT32 PropStringHashDisablePDLibCHIOverload  = 0xDC5EE4E9;   ///< disablePDLibCHIOverload
static const UINT32 StringHashEnableCustomPDLib         = 0xEE57057B;   ///< enableCustomPDLib
static const UINT32 PropStringHashEnableCustomPDLib     = 0x30AED2FA;   ///< enableCustomPDLib
static const UINT32 StringHashCustomPDLibName           = 0xDFA742D3;   ///< customPDLibName
static const UINT32 PropStringHashCustomPDLibName       = 0xC89375A1;   ///< customPDLibName
static const UINT32 StringHashCustomPDLibPath           = 0xDFA841FE;   ///< customPDLibPath
static const UINT32 PropStringHashCustomPDLibPath       = 0xC89C768C;   ///< customPDLibPath
static const UINT32 StringHashTintlessEnable            = 0xAA0CE38F;   ///< tintlessEnable
static const UINT32 PropStringHashTintlessEnable        = 0x3AB54234;   ///< tintlessEnable
static const UINT32 StringHashEnablePDLibLog            = 0x0FA55BD2;   ///< enablePDLibLog
static const UINT32 PropStringHashEnablePDLibLog        = 0xABEC84E2;   ///< enablePDLibLog
static const UINT32 StringHashEnablePDLibTestMode       = 0x0B687A90;   ///< enablePDLibTestMode
static const UINT32 PropStringHashEnablePDLibTestMode   = 0x5A877D49;   ///< enablePDLibTestMode
static const UINT32 StringHashEnablePDLibProfiling      = 0x494EE3B9;   ///< enablePDLibProfiling
static const UINT32 PropStringHashEnablePDLibProfiling  = 0xB012A3E2;   ///< enablePDLibProfiling
static const UINT32 StringHashEnhancePDLibDump          = 0xF29039BD;   ///< enhancePDLibDump
static const UINT32 PropStringHashEnhancePDLibDump      = 0x941D4829;   ///< enhancePDLibDump
static const UINT32 StringHashEnablePDLibDump           = 0xF4AF1371;   ///< enablePDLibDump
static const UINT32 PropStringHashEnablePDLibDump       = 0x5A8F3E8D;   ///< enablePDLibDump
static const UINT32 StringHashDisablePDLibLCR           = 0xDFA5435E;   ///< disablePDLibLCR
static const UINT32 PropStringHashDisablePDLibLCR       = 0xE6EC81C1;   ///< disablePDLibLCR
static const UINT32 StringHashIfeSWCDMEnable            = 0xDF93850A;   ///< ifeSWCDMEnable
static const UINT32 PropStringHashIfeSWCDMEnable        = 0x4F2A24B1;   ///< ifeSWCDMEnable
static const UINT32 StringHashTfeSWCDMEnable            = 0xDF938530;   ///< tfeSWCDMEnable
static const UINT32 PropStringHashTfeSWCDMEnable        = 0x4F2A248B;   ///< tfeSWCDMEnable
static const UINT32 StringHashLuxThresholdForTintless   = 0xC6DF64CA;   ///< luxThresholdForTintless
static const UINT32 PropStringHashLuxThresholdForTintless  = 0xF2E816DD;   ///< luxThresholdForTintless
static const UINT32 StringHashEnableAEScan              = 0xB75C4137;   ///< enableAEScan
static const UINT32 PropStringHashEnableAEScan          = 0x2DF6CAE7;   ///< enableAEScan
static const UINT32 StringHashChiLogWarningMask         = 0x587701FF;   ///< chiLogWarningMask
static const UINT32 PropStringHashChiLogWarningMask     = 0x14E3642C;   ///< chiLogWarningMask
static const UINT32 StringHashChiLogCoreCfgMask         = 0xC826C1A5;   ///< chiLogCoreCfgMask
static const UINT32 PropStringHashChiLogCoreCfgMask     = 0x84B2A476;   ///< chiLogCoreCfgMask
static const UINT32 StringHashChiLogConfigMask          = 0xA25404B6;   ///< chiLogConfigMask
static const UINT32 PropStringHashChiLogConfigMask      = 0x3830A798;   ///< chiLogConfigMask
static const UINT32 StringHashChiLogInfoMask            = 0xFFFA8E98;   ///< chiLogInfoMask
static const UINT32 PropStringHashChiLogInfoMask        = 0x345C17B0;   ///< chiLogInfoMask
static const UINT32 StringHashChiLogDumpMask            = 0x280A8EF6;   ///< chiLogDumpMask
static const UINT32 PropStringHashChiLogDumpMask        = 0xE3AC17DE;   ///< chiLogDumpMask
static const UINT32 StringHashChiLogVerboseMask         = 0xE253819E;   ///< chiLogVerboseMask
static const UINT32 PropStringHashChiLogVerboseMask     = 0xAEC7E44D;   ///< chiLogVerboseMask
static const UINT32 StringHashChiLogFullMask            = 0x2BCA8EE6;   ///< chiLogFullMask
static const UINT32 PropStringHashChiLogFullMask        = 0xE06C17CE;   ///< chiLogFullMask
static const UINT32 StringHashChiLogTraceMask           = 0x27D78595;   ///< chiLogTraceMask
static const UINT32 PropStringHashChiLogTraceMask       = 0x5304A08C;   ///< chiLogTraceMask
static const UINT32 StringHashOverrideDisableZSL        = 0x2CFEB8EE;   ///< overrideDisableZSL
static const UINT32 PropStringHashOverrideDisableZSL    = 0x3747B374;   ///< overrideDisableZSL
static const UINT32 StringHashEnableLRMEDS2             = 0x846B3167;   ///< enableLRMEDS2
static const UINT32 PropStringHashEnableLRMEDS2         = 0x58EEFC6A;   ///< enableLRMEDS2
static const UINT32 StringHashOverrideEnableMFNR        = 0xF06AECC0;   ///< overrideEnableMFNR
static const UINT32 PropStringHashOverrideEnableMFNR    = 0xEBD3E75A;   ///< overrideEnableMFNR
static const UINT32 StringHashAnchorSelectionAlgoForMFNR  = 0xCB7A2D13;   ///< anchorSelectionAlgoForMFNR
static const UINT32 PropStringHashAnchorSelectionAlgoForMFNR  = 0x7271B708;   ///< anchorSelectionAlgoForMFNR
static const UINT32 StringHashAnchorAlgoSelectionType   = 0x29DDC9C3;   ///< anchorAlgoSelectionType
static const UINT32 PropStringHashAnchorAlgoSelectionType  = 0x1DEABBD4;   ///< anchorAlgoSelectionType
static const UINT32 StringHashAdvanceFeatureMask        = 0xAD34602C;   ///< advanceFeatureMask
static const UINT32 PropStringHashAdvanceFeatureMask    = 0xD9AD79CF;   ///< advanceFeatureMask
static const UINT32 StringHashManualBlurConfig          = 0x21F9CA68;   ///< manualBlurConfig
static const UINT32 PropStringHashManualBlurConfig      = 0xC77F242A;   ///< manualBlurConfig
static const UINT32 StringHashEnableOfflineNoiseReprocess  = 0x10616FE6;   ///< enableOfflineNoiseReprocess
static const UINT32 PropStringHashEnableOfflineNoiseReprocess  = 0x31122C91;   ///< enableOfflineNoiseReprocess
static const UINT32 StringHashEnableGamma15PreCalculate  = 0xDE85B824;   ///< enableGamma15PreCalculate
static const UINT32 PropStringHashEnableGamma15PreCalculate  = 0x034DE4F4;   ///< enableGamma15PreCalculate
static const UINT32 StringHashOverrideForceUsecaseId    = 0x0E822F1C;   ///< overrideForceUsecaseId
static const UINT32 PropStringHashOverrideForceUsecaseId  = 0xB723948C;   ///< overrideForceUsecaseId
static const UINT32 StringHashOverrideForceLiveshot     = 0x661D7CE8;   ///< overrideForceLiveshot
static const UINT32 PropStringHashOverrideForceLiveshot  = 0xE3D07134;   ///< overrideForceLiveshot
static const UINT32 StringHashOverrideForceFullSizeLiveshot  = 0x271220BC;   ///< overrideForceFullSizeLiveshot
static const UINT32 PropStringHashOverrideForceFullSizeLiveshot  = 0xEA1FFC39;   ///< overrideForceFullSizeLiveshot
static const UINT32 StringHashOverrideForceEISSupport   = 0xF87D6381;   ///< overrideForceEISSupport
static const UINT32 PropStringHashOverrideForceEISSupport  = 0xCC4A1196;   ///< overrideForceEISSupport
static const UINT32 StringHashOverrideForceFDRendering  = 0xE6FF3EAE;   ///< overrideForceFDRendering
static const UINT32 PropStringHashOverrideForceFDRendering  = 0x60117C48;   ///< overrideForceFDRendering
static const UINT32 StringHashOverrideForceBurstShot    = 0xEFD20CF9;   ///< overrideForceBurstShot
static const UINT32 PropStringHashOverrideForceBurstShot  = 0x5673B769;   ///< overrideForceBurstShot
static const UINT32 StringHashOverrideForceCameraFDRendering  = 0xF55C9297;   ///< overrideForceCameraFDRendering
static const UINT32 PropStringHashOverrideForceCameraFDRendering  = 0x54E7022E;   ///< overrideForceCameraFDRendering
static const UINT32 StringHashOverrideForceSensorMode   = 0xCC512DB8;   ///< overrideForceSensorMode
static const UINT32 PropStringHashOverrideForceSensorMode  = 0xF8665FAF;   ///< overrideForceSensorMode
static const UINT32 StringHashShdr_line_offset0         = 0xCD81E4B2;   ///< shdr_line_offset0
static const UINT32 PropStringHashShdr_line_offset0     = 0x1D5C2CEE;   ///< shdr_line_offset0
static const UINT32 StringHashShdr_line_offset1         = 0xCD81E4B3;   ///< shdr_line_offset1
static const UINT32 PropStringHashShdr_line_offset1     = 0x1D5C2CEF;   ///< shdr_line_offset1
static const UINT32 StringHashOverrideForceSensorModeMultiCam  = 0xCE58BBF4;   ///< overrideForceSensorModeMultiCam
static const UINT32 PropStringHashOverrideForceSensorModeMultiCam  = 0xF92AACC0;   ///< overrideForceSensorModeMultiCam
static const UINT32 StringHashOverrideHideSensorModeMultiCam  = 0x38A34FC4;   ///< overrideHideSensorModeMultiCam
static const UINT32 PropStringHashOverrideHideSensorModeMultiCam  = 0x9918DF7D;   ///< overrideHideSensorModeMultiCam
static const UINT32 StringHashOverrideForceFSCapable    = 0x8B9B20BC;   ///< overrideForceFSCapable
static const UINT32 PropStringHashOverrideForceFSCapable  = 0x323A9B2C;   ///< overrideForceFSCapable
static const UINT32 StringHashExposeInternalModeForMultiCamUsecaseMask  = 0xAEA1F705;   ///< exposeInternalModeForMultiCamUsecaseMask
static const UINT32 PropStringHashExposeInternalModeForMultiCamUsecaseMask  = 0xEC4771EB;   ///< exposeInternalModeForMultiCamUsecaseMask
static const UINT32 StringHashOverrideGPURotationUsecase  = 0xDC9A909F;   ///< overrideGPURotationUsecase
static const UINT32 PropStringHashOverrideGPURotationUsecase  = 0x65910A84;   ///< overrideGPURotationUsecase
static const UINT32 StringHashOverrideGPUDownscaleUsecase  = 0xCC9A2BD9;   ///< overrideGPUDownscaleUsecase
static const UINT32 PropStringHashOverrideGPUDownscaleUsecase  = 0xEDE968AE;   ///< overrideGPUDownscaleUsecase
static const UINT32 StringHashJpegswContiguousOutput    = 0x7E6DD248;   ///< jpegswContiguousOutput
static const UINT32 PropStringHashJpegswContiguousOutput  = 0xC7CC69D8;   ///< jpegswContiguousOutput
static const UINT32 StringHashSetMaxNoOfCoresJpegsw     = 0x8C705F78;   ///< setMaxNoOfCoresJpegsw
static const UINT32 PropStringHashSetMaxNoOfCoresJpegsw  = 0x09BD52A4;   ///< setMaxNoOfCoresJpegsw
static const UINT32 StringHashEnableDSPJpegsw           = 0xF38FCC09;   ///< enableDSPJpegsw
static const UINT32 PropStringHashEnableDSPJpegsw       = 0xE4BBFB7B;   ///< enableDSPJpegsw
static const UINT32 StringHashOverwriteJpegswOrientation  = 0xADE4732C;   ///< overwriteJpegswOrientation
static const UINT32 PropStringHashOverwriteJpegswOrientation  = 0x14EFE937;   ///< overwriteJpegswOrientation
static const UINT32 StringHashOverrideHFRNo3AUseCase    = 0xBEFF3AD5;   ///< overrideHFRNo3AUseCase
static const UINT32 PropStringHashOverrideHFRNo3AUseCase  = 0x075E8145;   ///< overrideHFRNo3AUseCase
static const UINT32 StringHashOverrideCameraClose       = 0x85A17064;   ///< overrideCameraClose
static const UINT32 PropStringHashOverrideCameraClose   = 0xF2800327;   ///< overrideCameraClose
static const UINT32 StringHashOverrideCameraOpen        = 0x0C2B7ADD;   ///< overrideCameraOpen
static const UINT32 PropStringHashOverrideCameraOpen    = 0x17927147;   ///< overrideCameraOpen
static const UINT32 StringHashAllowForceCloseOfCameraAfterDeviceError  = 0x6E4D168D;   ///< allowForceCloseOfCameraAfterDeviceError
static const UINT32 PropStringHashAllowForceCloseOfCameraAfterDeviceError  = 0x1C5A22BA;   ///< allowForceCloseOfCameraAfterDeviceError
static const UINT32 StringHashOverridePDLibClose        = 0x2C08E11D;   ///< overridePDLibClose
static const UINT32 PropStringHashOverridePDLibClose    = 0x37B1EA87;   ///< overridePDLibClose
static const UINT32 StringHashOverridePDLibOpen         = 0xC1663656;   ///< overridePDLibOpen
static const UINT32 PropStringHashOverridePDLibOpen     = 0x11BBFE0A;   ///< overridePDLibOpen
static const UINT32 StringHashOverrideAIStrengthControlFactor  = 0x54C174E9;   ///< overrideAIStrengthControlFactor
static const UINT32 PropStringHashOverrideAIStrengthControlFactor  = 0x63B363DD;   ///< overrideAIStrengthControlFactor
static const UINT32 StringHashEISV2Enable               = 0x4D485559;   ///< EISV2Enable
static const UINT32 PropStringHashEISV2Enable           = 0x0E3F742A;   ///< EISV2Enable
static const UINT32 StringHashEISV3Enable               = 0x0D485559;   ///< EISV3Enable
static const UINT32 PropStringHashEISV3Enable           = 0x4E3F742A;   ///< EISV3Enable
static const UINT32 StringHashSFEAlignmentMargin        = 0x701867BD;   ///< SFEAlignmentMargin
static const UINT32 PropStringHashSFEAlignmentMargin    = 0x6BA16C27;   ///< SFEAlignmentMargin
static const UINT32 StringHashEISInputDumpEnable        = 0xFB47710A;   ///< EISInputDumpEnable
static const UINT32 PropStringHashEISInputDumpEnable    = 0xE0FE7A90;   ///< EISInputDumpEnable
static const UINT32 StringHashEISOutputDumpEnable       = 0x6EDD963F;   ///< EISOutputDumpEnable
static const UINT32 PropStringHashEISOutputDumpEnable   = 0x19FCE57C;   ///< EISOutputDumpEnable
static const UINT32 StringHashEISDumpForceFlush         = 0x6B7D228F;   ///< EISDumpForceFlush
static const UINT32 PropStringHashEISDumpForceFlush     = 0xBBA0EAD3;   ///< EISDumpForceFlush
static const UINT32 StringHashMagEnable                 = 0x0CD16BF4;   ///< MagEnable
static const UINT32 PropStringHashMagEnable             = 0x5001B63C;   ///< MagEnable
static const UINT32 StringHashAccelEnable               = 0xCD5905D6;   ///< AccelEnable
static const UINT32 PropStringHashAccelEnable           = 0x8E2E24A5;   ///< AccelEnable
static const UINT32 StringHashOISEnable                 = 0x0CD169B1;   ///< OISEnable
static const UINT32 PropStringHashOISEnable             = 0x5001B479;   ///< OISEnable
static const UINT32 StringHashOffsetToProduceBayerAlignGrid  = 0x13857D12;   ///< OffsetToProduceBayerAlignGrid
static const UINT32 PropStringHashOffsetToProduceBayerAlignGrid  = 0xDE88A197;   ///< OffsetToProduceBayerAlignGrid
static const UINT32 StringHashEISV2Margin               = 0x5DB1C1F2;   ///< EISV2Margin
static const UINT32 PropStringHashEISV2Margin           = 0x1EC6E081;   ///< EISV2Margin
static const UINT32 StringHashEISV2FrameDelay           = 0x87B794DF;   ///< EISV2FrameDelay
static const UINT32 PropStringHashEISV2FrameDelay       = 0x9083A3AD;   ///< EISV2FrameDelay
static const UINT32 StringHashEISV3Margin               = 0x1DB1C1F2;   ///< EISV3Margin
static const UINT32 PropStringHashEISV3Margin           = 0x5EC6E081;   ///< EISV3Margin
static const UINT32 StringHashEISv3FrameDelay           = 0x87B394DF;   ///< EISv3FrameDelay
static const UINT32 PropStringHashEISv3FrameDelay       = 0x9087A3AD;   ///< EISv3FrameDelay
static const UINT32 StringHashEISHorizonLevelEnable     = 0x4B015C01;   ///< EISHorizonLevelEnable
static const UINT32 PropStringHashEISHorizonLevelEnable  = 0xCECC51DD;   ///< EISHorizonLevelEnable
static const UINT32 StringHashEISHorizonLevelMaxDeg     = 0x5BFDC523;   ///< EISHorizonLevelMaxDeg
static const UINT32 PropStringHashEISHorizonLevelMaxDeg  = 0xDE30C8FF;   ///< EISHorizonLevelMaxDeg
static const UINT32 StringHashNumPCRsBeforeStreamOn     = 0xBAB395D2;   ///< numPCRsBeforeStreamOn
static const UINT32 PropStringHashNumPCRsBeforeStreamOn  = 0x3F7E980E;   ///< numPCRsBeforeStreamOn
static const UINT32 StringHashMaxImageBufferTimeoutCount  = 0x6F432AB3;   ///< maxImageBufferTimeoutCount
static const UINT32 PropStringHashMaxImageBufferTimeoutCount  = 0xD648B0A8;   ///< maxImageBufferTimeoutCount
static const UINT32 StringHashImageBufferWaitTime       = 0x5E2D59E7;   ///< imageBufferWaitTime
static const UINT32 PropStringHashImageBufferWaitTime   = 0x290C2AA4;   ///< imageBufferWaitTime
static const UINT32 StringHashOverrideMaxImageBufferCountRealTime  = 0x53617233;   ///< overrideMaxImageBufferCountRealTime
static const UINT32 PropStringHashOverrideMaxImageBufferCountRealTime  = 0x20220512;   ///< overrideMaxImageBufferCountRealTime
static const UINT32 StringHashOverrideMaxImageBufferCountNonRealTime  = 0xE971CF81;   ///< overrideMaxImageBufferCountNonRealTime
static const UINT32 PropStringHashOverrideMaxImageBufferCountNonRealTime  = 0x52E17620;   ///< overrideMaxImageBufferCountNonRealTime
static const UINT32 StringHashStatsProcessingSkipFactor  = 0xD98ACEEF;   ///< statsProcessingSkipFactor
static const UINT32 PropStringHashStatsProcessingSkipFactor  = 0x68754FC9;   ///< statsProcessingSkipFactor
static const UINT32 StringHashMaxNonHfrFps              = 0x6153FB10;   ///< maxNonHfrFps
static const UINT32 PropStringHashMaxNonHfrFps          = 0x0FB7D578;   ///< maxNonHfrFps
static const UINT32 StringHashMinFrameRateBound         = 0xDD40DBFA;   ///< minFrameRateBound
static const UINT32 PropStringHashMinFrameRateBound     = 0x0D9D13A6;   ///< minFrameRateBound
static const UINT32 StringHashEnableOISOptimization     = 0x3C4A768F;   ///< enableOISOptimization
static const UINT32 PropStringHashEnableOISOptimization  = 0xB9877B53;   ///< enableOISOptimization
static const UINT32 StringHashOISCalibrationMode        = 0x605B925B;   ///< OISCalibrationMode
static const UINT32 PropStringHashOISCalibrationMode    = 0x7BE299C1;   ///< OISCalibrationMode
static const UINT32 StringHashEnableSensorCaching       = 0x9E91AEE3;   ///< enableSensorCaching
static const UINT32 PropStringHashEnableSensorCaching   = 0xE9B0DDA0;   ///< enableSensorCaching
static const UINT32 StringHashEnableCSIPHYCaching       = 0x958DC9BA;   ///< enableCSIPHYCaching
static const UINT32 PropStringHashEnableCSIPHYCaching   = 0xE2ACBAF9;   ///< enableCSIPHYCaching
static const UINT32 StringHashEnableCHIPartialData      = 0x05FEA2E8;   ///< enableCHIPartialData
static const UINT32 PropStringHashEnableCHIPartialData  = 0xE1D0CA86;   ///< enableCHIPartialData
static const UINT32 StringHashEnableCHIPartialDataRecovery  = 0x7E6871B5;   ///< enableCHIPartialDataRecovery
static const UINT32 PropStringHashEnableCHIPartialDataRecovery  = 0x50001F51;   ///< enableCHIPartialDataRecovery
static const UINT32 StringHashDumpMetadata              = 0x9DFA5990;   ///< dumpMetadata
static const UINT32 PropStringHashDumpMetadata          = 0xD7C8B036;   ///< dumpMetadata
static const UINT32 StringHashEnableVendorTagDump       = 0x0ED53E91;   ///< enableVendorTagDump
static const UINT32 PropStringHashEnableVendorTagDump   = 0x5F4273A3;   ///< enableVendorTagDump
static const UINT32 StringHashDumpCHIMetadata           = 0x47A2F97C;   ///< dumpCHIMetadata
static const UINT32 PropStringHashDumpCHIMetadata       = 0x3371DC65;   ///< dumpCHIMetadata
static const UINT32 StringHashDumpCHIMetadataToFile     = 0xFF2A17BA;   ///< dumpCHIMetadataToFile
static const UINT32 PropStringHashDumpCHIMetadataToFile  = 0xA21EDEFC;   ///< dumpCHIMetadataToFile
static const UINT32 StringHashDumpCHIImageBuffer        = 0x3ABD2233;   ///< dumpCHIImageBuffer
static const UINT32 PropStringHashDumpCHIImageBuffer    = 0x06330B26;   ///< dumpCHIImageBuffer
static const UINT32 StringHashChifeature2PortDump       = 0xD95D61CF;   ///< chifeature2PortDump
static const UINT32 PropStringHashChifeature2PortDump   = 0x88CA2CFD;   ///< chifeature2PortDump
static const UINT32 StringHashMemsetInputMeta           = 0x056DEB01;   ///< memsetInputMeta
static const UINT32 PropStringHashMemsetInputMeta       = 0x088FC8BB;   ///< memsetInputMeta
static const UINT32 StringHashEnableLinearMetaLUT       = 0xE1E7F792;   ///< enableLinearMetaLUT
static const UINT32 PropStringHashEnableLinearMetaLUT   = 0xB070BAA0;   ///< enableLinearMetaLUT
static const UINT32 StringHashEnableFDStreamInRealTime  = 0x7E5625B9;   ///< enableFDStreamInRealTime
static const UINT32 PropStringHashEnableFDStreamInRealTime  = 0xF8B8675F;   ///< enableFDStreamInRealTime
static const UINT32 StringHashSelectInSensorHDR3ExpUsecase  = 0x2615590F;   ///< selectInSensorHDR3ExpUsecase
static const UINT32 PropStringHashSelectInSensorHDR3ExpUsecase  = 0x087D37EB;   ///< selectInSensorHDR3ExpUsecase
static const UINT32 StringHashEnableInSensorZoom        = 0x70E7A7BF;   ///< enableInSensorZoom
static const UINT32 PropStringHashEnableInSensorZoom    = 0x6B5EAC25;   ///< enableInSensorZoom
static const UINT32 StringHashEnableSnapshotOnlyInSensorZoom  = 0x77F24083;   ///< enableSnapshotOnlyInSensorZoom
static const UINT32 PropStringHashEnableSnapshotOnlyInSensorZoom  = 0xD649D03A;   ///< enableSnapshotOnlyInSensorZoom
static const UINT32 StringHashEnableInSensorZoomForOnlyPhysicalStream  = 0xD6FBDE4F;   ///< enableInSensorZoomForOnlyPhysicalStream
static const UINT32 PropStringHashEnableInSensorZoomForOnlyPhysicalStream  = 0xA4ECEA78;   ///< enableInSensorZoomForOnlyPhysicalStream
static const UINT32 StringHashEnableDummyRequestOptimization  = 0x6646BFB5;   ///< enableDummyRequestOptimization
static const UINT32 PropStringHashEnableDummyRequestOptimization  = 0xC7FD2F0C;   ///< enableDummyRequestOptimization
static const UINT32 StringHashEnableSensorRemosaic      = 0xCE48E159;   ///< enableSensorRemosaic
static const UINT32 PropStringHashEnableSensorRemosaic  = 0x2A668937;   ///< enableSensorRemosaic
static const UINT32 StringHashEnableFastShutter         = 0xE419E4EC;   ///< enableFastShutter
static const UINT32 PropStringHashEnableFastShutter     = 0x34C42CB0;   ///< enableFastShutter
static const UINT32 StringHashDisableIQThreshold        = 0xB2C5663A;   ///< disableIQThreshold
static const UINT32 PropStringHashDisableIQThreshold    = 0x2049DC53;   ///< disableIQThreshold
static const UINT32 StringHashEnableFrameworkHDR10P     = 0xB94C79FE;   ///< enableFrameworkHDR10P
static const UINT32 PropStringHashEnableFrameworkHDR10P  = 0x3C817422;   ///< enableFrameworkHDR10P
static const UINT32 StringHashEnableDolbyVisionHDR      = 0xE700801B;   ///< enableDolbyVisionHDR
static const UINT32 PropStringHashEnableDolbyVisionHDR  = 0x032EE875;   ///< enableDolbyVisionHDR
static const UINT32 StringHashEnableEOSWithRRE          = 0x02EE39E4;   ///< enableEOSWithRRE
static const UINT32 PropStringHashEnableEOSWithRRE      = 0xE468D7A6;   ///< enableEOSWithRRE
static const UINT32 StringHashEnableFWColorSpace        = 0x4D149420;   ///< enableFWColorSpace
static const UINT32 PropStringHashEnableFWColorSpace    = 0x56AD9FBA;   ///< enableFWColorSpace
static const UINT32 StringHashEnableP3HDRModes          = 0xF57F1FCE;   ///< enableP3HDRModes
static const UINT32 PropStringHashEnableP3HDRModes      = 0x13F9F18C;   ///< enableP3HDRModes
static const UINT32 StringHashEnableUnifiedBufferManager  = 0x6790B9B0;   ///< enableUnifiedBufferManager
static const UINT32 PropStringHashEnableUnifiedBufferManager  = 0xDE9B23AB;   ///< enableUnifiedBufferManager
static const UINT32 StringHashEnableCHIImageBufferLateBinding  = 0xF56EFB80;   ///< enableCHIImageBufferLateBinding
static const UINT32 PropStringHashEnableCHIImageBufferLateBinding  = 0xE747216E;   ///< enableCHIImageBufferLateBinding
static const UINT32 StringHashEnableFeature2Dump        = 0x27469E3A;   ///< enableFeature2Dump
static const UINT32 PropStringHashEnableFeature2Dump    = 0x3CFF95A0;   ///< enableFeature2Dump
static const UINT32 StringHashForceHWMFFixedNumOfFrames  = 0x9C069C61;   ///< forceHWMFFixedNumOfFrames
static const UINT32 PropStringHashForceHWMFFixedNumOfFrames  = 0x41CEC0B1;   ///< forceHWMFFixedNumOfFrames
static const UINT32 StringHashForceSWMFFixedNumOfFrames  = 0x1C069C6C;   ///< forceSWMFFixedNumOfFrames
static const UINT32 PropStringHashForceSWMFFixedNumOfFrames  = 0xC1CEC0BC;   ///< forceSWMFFixedNumOfFrames
static const UINT32 StringHashEnableTBMChiFence         = 0x27697285;   ///< enableTBMChiFence
static const UINT32 PropStringHashEnableTBMChiFence     = 0xF7B4BAD9;   ///< enableTBMChiFence
static const UINT32 StringHashEnableMFSRChiFence        = 0xBF883559;   ///< enableMFSRChiFence
static const UINT32 PropStringHashEnableMFSRChiFence    = 0xA4313EC3;   ///< enableMFSRChiFence
static const UINT32 StringHashEnableRawHDR              = 0x911E6D8B;   ///< enableRawHDR
static const UINT32 PropStringHashEnableRawHDR          = 0xFFFA43E3;   ///< enableRawHDR
static const UINT32 StringHashEnableFDFullStreamDimension  = 0xAB155F38;   ///< enableFDFullStreamDimension
static const UINT32 PropStringHashEnableFDFullStreamDimension  = 0x8F6740C5;   ///< enableFDFullStreamDimension
static const UINT32 StringHashEnableResolutionUpscale   = 0xE095EBB0;   ///< enableResolutionUpscale
static const UINT32 PropStringHashEnableResolutionUpscale  = 0xD4A299A7;   ///< enableResolutionUpscale
static const UINT32 StringHashEnableChiMetadataSigAbort  = 0xCCA8A3EB;   ///< enableChiMetadataSigAbort
static const UINT32 PropStringHashEnableChiMetadataSigAbort  = 0x1160FF3B;   ///< enableChiMetadataSigAbort
static const UINT32 StringHashDisableWaitForPipelinesDestroy  = 0x10C8551D;   ///< disableWaitForPipelinesDestroy
static const UINT32 PropStringHashDisableWaitForPipelinesDestroy  = 0xB173C5A4;   ///< disableWaitForPipelinesDestroy
static const UINT32 StringHashInduceDelayIFENodeDestroy  = 0xE898B83F;   ///< induceDelayIFENodeDestroy
static const UINT32 PropStringHashInduceDelayIFENodeDestroy  = 0x3550E4EF;   ///< induceDelayIFENodeDestroy
static const UINT32 StringHashForceToSelectUserTransitionTable  = 0x5CA71001;   ///< forceToSelectUserTransitionTable
static const UINT32 PropStringHashForceToSelectUserTransitionTable  = 0xB2E5F687;   ///< forceToSelectUserTransitionTable
static const UINT32 StringHashShdrModeType              = 0x36471B16;   ///< shdrModeType
static const UINT32 PropStringHashShdrModeType          = 0x7C75F2B0;   ///< shdrModeType
static const UINT32 StringHashShdrWidth                 = 0xE3456EB1;   ///< shdrWidth
static const UINT32 PropStringHashShdrWidth             = 0x3009FAD4;   ///< shdrWidth
static const UINT32 StringHashShdrHeight                = 0x566B1A48;   ///< shdrHeight
static const UINT32 PropStringHashShdrHeight            = 0x3FF996F2;   ///< shdrHeight
static const UINT32 StringHashFDProcessingControl       = 0xE46903AD;   ///< FDProcessingControl
static const UINT32 PropStringHashFDProcessingControl   = 0xCB9734D1;   ///< FDProcessingControl
static const UINT32 StringHashDisableFDHWProcessing     = 0x389B2738;   ///< disableFDHWProcessing
static const UINT32 PropStringHashDisableFDHWProcessing  = 0x65AFEE7E;   ///< disableFDHWProcessing
static const UINT32 StringHashIgnoreEVATAloadingForSecureCase  = 0x9841272B;   ///< ignoreEVATAloadingForSecureCase
static const UINT32 PropStringHashIgnoreEVATAloadingForSecureCase  = 0xBD5853F8;   ///< ignoreEVATAloadingForSecureCase
static const UINT32 StringHashEnableFDManagerThreading  = 0xF5ADAA76;   ///< enableFDManagerThreading
static const UINT32 PropStringHashEnableFDManagerThreading  = 0x7343E890;   ///< enableFDManagerThreading
static const UINT32 StringHashFDBaseResolution          = 0x3772A6CF;   ///< FDBaseResolution
static const UINT32 PropStringHashFDBaseResolution      = 0xAD1605E1;   ///< FDBaseResolution
static const UINT32 StringHashFDUseCAMIFMapFromSensor   = 0x59314D13;   ///< FDUseCAMIFMapFromSensor
static const UINT32 PropStringHashFDUseCAMIFMapFromSensor  = 0x8A145467;   ///< FDUseCAMIFMapFromSensor
static const UINT32 StringHashFDConfigSource            = 0x50FAE19E;   ///< FDConfigSource
static const UINT32 PropStringHashFDConfigSource        = 0x9B5C78B6;   ///< FDConfigSource
static const UINT32 StringHashFDConfigPreviewBin        = 0x0DDF7761;   ///< FDConfigPreviewBin
static const UINT32 PropStringHashFDConfigPreviewBin    = 0x9F53CD08;   ///< FDConfigPreviewBin
static const UINT32 StringHashFDConfigVideoBin          = 0x48F06824;   ///< FDConfigVideoBin
static const UINT32 PropStringHashFDConfigVideoBin      = 0xD294CB0A;   ///< FDConfigVideoBin
static const UINT32 StringHashFDConfigSecureBin         = 0xFFDEAD66;   ///< FDConfigSecureBin
static const UINT32 PropStringHashFDConfigSecureBin     = 0xB34AC8B5;   ///< FDConfigSecureBin
static const UINT32 StringHashEnableDynamicFDConfig     = 0x99D0E2FC;   ///< enableDynamicFDConfig
static const UINT32 PropStringHashEnableDynamicFDConfig  = 0xC4E42BBA;   ///< enableDynamicFDConfig
static const UINT32 StringHashFDFLSolution              = 0x2DF7060D;   ///< FDFLSolution
static const UINT32 PropStringHashFDFLSolution          = 0x67C5EFAB;   ///< FDFLSolution
static const UINT32 StringHashCamXFL115Indices          = 0x28C010FC;   ///< CamXFL115Indices
static const UINT32 PropStringHashCamXFL115Indices      = 0xB2A4B3D2;   ///< CamXFL115Indices
static const UINT32 StringHashCamXFL300v1Indices        = 0x4F31018B;   ///< CamXFL300v1Indices
static const UINT32 PropStringHashCamXFL300v1Indices    = 0xDDBDBBE2;   ///< CamXFL300v1Indices
static const UINT32 StringHashCamXFL300v2Indices        = 0x4F310193;   ///< CamXFL300v2Indices
static const UINT32 PropStringHashCamXFL300v2Indices    = 0xDDBDBBFA;   ///< CamXFL300v2Indices
static const UINT32 StringHashFLCustomContourPointBin   = 0x8D9C7AC6;   ///< FLCustomContourPointBin
static const UINT32 PropStringHashFLCustomContourPointBin  = 0x5EB963B2;   ///< FLCustomContourPointBin
static const UINT32 StringHashFDMultiCamProcess         = 0x190D23CB;   ///< FDMultiCamProcess
static const UINT32 PropStringHashFDMultiCamProcess     = 0x55994618;   ///< FDMultiCamProcess
static const UINT32 StringHashUseAlternateFrameSkip     = 0x557B5A12;   ///< useAlternateFrameSkip
static const UINT32 PropStringHashUseAlternateFrameSkip  = 0x084F9354;   ///< useAlternateFrameSkip
static const UINT32 StringHashUseDeviceOrientationInFD  = 0x6D17E94F;   ///< useDeviceOrientationInFD
static const UINT32 PropStringHashUseDeviceOrientationInFD  = 0x09B4C7D5;   ///< useDeviceOrientationInFD
static const UINT32 StringHashGetAccelInfoUsingVendorTag  = 0xF009E256;   ///< getAccelInfoUsingVendorTag
static const UINT32 PropStringHashGetAccelInfoUsingVendorTag  = 0x7CB38BC4;   ///< getAccelInfoUsingVendorTag
static const UINT32 StringHashAccelVendorTagSection     = 0x7A82E410;   ///< accelVendorTagSection
static const UINT32 PropStringHashAccelVendorTagSection  = 0x27B62D56;   ///< accelVendorTagSection
static const UINT32 StringHashAccelVendorTagName        = 0x9B3264D7;   ///< accelVendorTagName
static const UINT32 PropStringHashAccelVendorTagName    = 0x09BEDEBE;   ///< accelVendorTagName
static const UINT32 StringHashFDClient                  = 0xC0F51A9D;   ///< FDClient
static const UINT32 PropStringHashFDClient              = 0xE3D50C92;   ///< FDClient
static const UINT32 StringHashDisablePostingResults     = 0xC5170C04;   ///< disablePostingResults
static const UINT32 PropStringHashDisablePostingResults  = 0x862D03FA;   ///< disablePostingResults
static const UINT32 StringHashEnableOfflineFD           = 0x7E1A4D17;   ///< enableOfflineFD
static const UINT32 PropStringHashEnableOfflineFD       = 0x0AC9680E;   ///< enableOfflineFD
static const UINT32 StringHashEnableMLInference         = 0xBE4CB6EE;   ///< enableMLInference
static const UINT32 PropStringHashEnableMLInference     = 0xF2D8D33D;   ///< enableMLInference
static const UINT32 StringHashMetadataVisibility        = 0xA4EBB8F5;   ///< MetadataVisibility
static const UINT32 PropStringHashMetadataVisibility    = 0x3667029C;   ///< MetadataVisibility
static const UINT32 StringHashUseDifferentTuningForFrontCamera  = 0xC39EB12A;   ///< useDifferentTuningForFrontCamera
static const UINT32 PropStringHashUseDifferentTuningForFrontCamera  = 0x60B02B4E;   ///< useDifferentTuningForFrontCamera
static const UINT32 StringHashUseFDInternalBuffers      = 0x5FD202EB;   ///< useFDInternalBuffers
static const UINT32 PropStringHashUseFDInternalBuffers  = 0x6D3BA4A1;   ///< useFDInternalBuffers
static const UINT32 StringHashUseFDUseCasePool          = 0xF3B00380;   ///< useFDUseCasePool
static const UINT32 PropStringHashUseFDUseCasePool      = 0x1536EDC2;   ///< useFDUseCasePool
static const UINT32 StringHashFastFDMetadata            = 0x867F2D5A;   ///< fastFDMetadata
static const UINT32 PropStringHashFastFDMetadata        = 0x16C68CE1;   ///< fastFDMetadata
static const UINT32 StringHashMinReqFdDependency        = 0xB525BECD;   ///< minReqFdDependency
static const UINT32 PropStringHashMinReqFdDependency    = 0x27A904A4;   ///< minReqFdDependency
static const UINT32 StringHashFDInputDumpControl        = 0x7FE25873;   ///< FDInputDumpControl
static const UINT32 PropStringHashFDInputDumpControl    = 0x800B7BE3;   ///< FDInputDumpControl
static const UINT32 StringHashFDInputDumpControlTrigger  = 0x1DB0D354;   ///< FDInputDumpControlTrigger
static const UINT32 PropStringHashFDInputDumpControlTrigger  = 0x89D50018;   ///< FDInputDumpControlTrigger
static const UINT32 StringHashEnableEarlyBitMLSkelLoad  = 0x825BB025;   ///< enableEarlyBitMLSkelLoad
static const UINT32 PropStringHashEnableEarlyBitMLSkelLoad  = 0xBDA1F8C1;   ///< enableEarlyBitMLSkelLoad
static const UINT32 StringHashEnableFDDynamicInputPortDisable  = 0x5B2F1356;   ///< enableFDDynamicInputPortDisable
static const UINT32 PropStringHashEnableFDDynamicInputPortDisable  = 0xA4FD5477;   ///< enableFDDynamicInputPortDisable
static const UINT32 StringHashAcceptAppUIFacialAttrSettings  = 0xA53740AD;   ///< acceptAppUIFacialAttrSettings
static const UINT32 PropStringHashAcceptAppUIFacialAttrSettings  = 0x6D48B43C;   ///< acceptAppUIFacialAttrSettings
static const UINT32 StringHashEnableMaskDetection       = 0xB4E8A576;   ///< enableMaskDetection
static const UINT32 PropStringHashEnableMaskDetection   = 0x49CCD769;   ///< enableMaskDetection
static const UINT32 StringHashEnableUpperBodyDetection  = 0x43F4330E;   ///< enableUpperBodyDetection
static const UINT32 PropStringHashEnableUpperBodyDetection  = 0x7C0E7BEA;   ///< enableUpperBodyDetection
static const UINT32 StringHashEnableGBDetection         = 0x3F7DE639;   ///< enableGBDetection
static const UINT32 PropStringHashEnableGBDetection     = 0xB882AF25;   ///< enableGBDetection
static const UINT32 StringHashEnableCTDetection         = 0x3F6F2639;   ///< enableCTDetection
static const UINT32 PropStringHashEnableCTDetection     = 0xB8906F25;   ///< enableCTDetection
static const UINT32 StringHashEnableExpressionDetection  = 0xB42105E9;   ///< enableExpressionDetection
static const UINT32 PropStringHashEnableExpressionDetection  = 0x4B68196E;   ///< enableExpressionDetection
static const UINT32 StringHashEnableGenderDetection     = 0x97BEB9D1;   ///< enableGenderDetection
static const UINT32 PropStringHashEnableGenderDetection  = 0x0676C625;   ///< enableGenderDetection
static const UINT32 StringHashFDMinFaceSize             = 0xD3D1660B;   ///< FDMinFaceSize
static const UINT32 PropStringHashFDMinFaceSize         = 0x958C52C2;   ///< FDMinFaceSize
static const UINT32 StringHashFDMaxFPS                  = 0xDC2D955A;   ///< FDMaxFPS
static const UINT32 PropStringHashFDMaxFPS              = 0xF2B7F1F9;   ///< FDMaxFPS
static const UINT32 StringHashEnableFDSpecificToneMapping  = 0x4509EBD4;   ///< enableFDSpecificToneMapping
static const UINT32 PropStringHashEnableFDSpecificToneMapping  = 0xD244D985;   ///< enableFDSpecificToneMapping
static const UINT32 StringHashDisableDynamicFPSControl  = 0x42260568;   ///< disableDynamicFPSControl
static const UINT32 PropStringHashDisableDynamicFPSControl  = 0x26852BF2;   ///< disableDynamicFPSControl
static const UINT32 StringHashEnablePublishProjectedFDResults  = 0xA2C8C797;   ///< enablePublishProjectedFDResults
static const UINT32 PropStringHashEnablePublishProjectedFDResults  = 0x87D1B344;   ///< enablePublishProjectedFDResults
static const UINT32 StringHashEnableSwHME               = 0xCC938FCE;   ///< enableSwHME
static const UINT32 PropStringHashEnableSwHME           = 0x8FE4AEBD;   ///< enableSwHME
static const UINT32 StringHashEnableDSPSwHME            = 0xF60FCB35;   ///< enableDSPSwHME
static const UINT32 PropStringHashEnableDSPSwHME        = 0x66B66A8E;   ///< enableDSPSwHME
static const UINT32 StringHashEnableSwCacVersion4       = 0x30A77A91;   ///< enableSwCacVersion4
static const UINT32 PropStringHashEnableSwCacVersion4   = 0x478609D2;   ///< enableSwCacVersion4
static const UINT32 StringHashEnableSwCacBloomFilter    = 0xAF447960;   ///< enableSwCacBloomFilter
static const UINT32 PropStringHashEnableSwCacBloomFilter  = 0x16E5C2F0;   ///< enableSwCacBloomFilter
static const UINT32 StringHashEnableSwCac               = 0xCC93A248;   ///< enableSwCac
static const UINT32 PropStringHashEnableSwCac           = 0x8FE4833B;   ///< enableSwCac
static const UINT32 StringHashAECGainThresholdForQCFA   = 0x3861B978;   ///< AECGainThresholdForQCFA
static const UINT32 StringHashRemosaicType              = 0xAC9226E5;   ///< remosaicType
static const UINT32 PropStringHashRemosaicType          = 0xC276088D;   ///< remosaicType
static const UINT32 StringHashForceNumberOfPixelsPerColorForXCFASWRemosaic  = 0x4DD4305A;   ///< forceNumberOfPixelsPerColorForXCFASWRemosaic
static const UINT32 PropStringHashForceNumberOfPixelsPerColorForXCFASWRemosaic  = 0x23301E32;   ///< forceNumberOfPixelsPerColorForXCFASWRemosaic
static const UINT32 StringHashForceToOverrideSettingsForInstantZoom  = 0x19EE9214;   ///< forceToOverrideSettingsForInstantZoom
static const UINT32 PropStringHashForceToOverrideSettingsForInstantZoom  = 0x143217D9;   ///< forceToOverrideSettingsForInstantZoom
static const UINT32 StringHashMaxOptimizationVariationForInstantZoom  = 0x9AEA0440;   ///< maxOptimizationVariationForInstantZoom
static const UINT32 PropStringHashMaxOptimizationVariationForInstantZoom  = 0x217ABDE1;   ///< maxOptimizationVariationForInstantZoom
static const UINT32 StringHashRuleToApplyRealTimeZoomRatio  = 0x31C38953;   ///< ruleToApplyRealTimeZoomRatio
static const UINT32 PropStringHashRuleToApplyRealTimeZoomRatio  = 0x1FABE7B7;   ///< ruleToApplyRealTimeZoomRatio
static const UINT32 StringHashDisableFlash              = 0xFFFD8803;   ///< disableFlash
static const UINT32 PropStringHashDisableFlash          = 0x9119A66B;   ///< disableFlash
static const UINT32 StringHashTorchCurrent              = 0x16AAB9EC;   ///< torchCurrent
static const UINT32 PropStringHashTorchCurrent          = 0x784E9784;   ///< torchCurrent
static const UINT32 StringHashNodeResponseTime          = 0x08F2D1A8;   ///< nodeResponseTime
static const UINT32 PropStringHashNodeResponseTime      = 0x41F9CC0C;   ///< nodeResponseTime
static const UINT32 StringHashSessionResponseTimePadding  = 0x057A6840;   ///< sessionResponseTimePadding
static const UINT32 PropStringHashSessionResponseTimePadding  = 0xBC71F25B;   ///< sessionResponseTimePadding
static const UINT32 StringHashSessionMaxFlushWaitTime   = 0xEB30DFDB;   ///< sessionMaxFlushWaitTime
static const UINT32 PropStringHashSessionMaxFlushWaitTime  = 0xDF07ADCC;   ///< sessionMaxFlushWaitTime
static const UINT32 StringHashSessionFallbackWaitTime   = 0x4C6284F3;   ///< sessionFallbackWaitTime
static const UINT32 PropStringHashSessionFallbackWaitTime  = 0x7855F6E4;   ///< sessionFallbackWaitTime
static const UINT32 StringHashFeature1                  = 0x857B47B8;   ///< feature1
static const UINT32 PropStringHashFeature1              = 0xC79DC156;   ///< feature1
static const UINT32 StringHashFeature2                  = 0x857B47BB;   ///< feature2
static const UINT32 PropStringHashFeature2              = 0xC79DC155;   ///< feature2
static const UINT32 StringHashRaisesigabrt              = 0x2CC85600;   ///< raisesigabrt
static const UINT32 PropStringHashRaisesigabrt          = 0x66FABFA6;   ///< raisesigabrt
static const UINT32 StringHashEnablechirecovery         = 0x73AD9832;   ///< enablechirecovery
static const UINT32 PropStringHashEnablechirecovery     = 0x9A69E554;   ///< enablechirecovery
static const UINT32 StringHashEnableHwBinary            = 0xD3A36CA8;   ///< enableHwBinary
static const UINT32 PropStringHashEnableHwBinary        = 0x1805F580;   ///< enableHwBinary
static const UINT32 StringHashEnableHwBinaryDump        = 0xCABEE3E6;   ///< enableHwBinaryDump
static const UINT32 PropStringHashEnableHwBinaryDump    = 0x5832598F;   ///< enableHwBinaryDump
static const UINT32 StringHashDisableMMF                = 0x82FFD346;   ///< disableMMF
static const UINT32 PropStringHashDisableMMF            = 0xEB6D5FFC;   ///< disableMMF
static const UINT32 StringHashEnableVideoRetouch        = 0x2B13AE32;   ///< enableVideoRetouch
static const UINT32 PropStringHashEnableVideoRetouch    = 0xB99F145B;   ///< enableVideoRetouch
static const UINT32 StringHashEnableEISAllPhysicalStream  = 0xBB2BFDD7;   ///< enableEISAllPhysicalStream
static const UINT32 PropStringHashEnableEISAllPhysicalStream  = 0x022067CC;   ///< enableEISAllPhysicalStream
static const UINT32 StringHashIsWarpOnPostIPE           = 0x984DDCA8;   ///< isWarpOnPostIPE
static const UINT32 PropStringHashIsWarpOnPostIPE       = 0xEC9EF9B1;   ///< isWarpOnPostIPE
static const UINT32 StringHashRaiserecoverysigabrt      = 0x9B45E394;   ///< raiserecoverysigabrt
static const UINT32 PropStringHashRaiserecoverysigabrt  = 0xA9AC45DE;   ///< raiserecoverysigabrt
static const UINT32 StringHashEnableSignal35Tombstone   = 0x1908ADFC;   ///< enableSignal35Tombstone
static const UINT32 PropStringHashEnableSignal35Tombstone  = 0xCA2DB488;   ///< enableSignal35Tombstone
static const UINT32 StringHashEnableSelectiveRecovery   = 0x37A9955C;   ///< enableSelectiveRecovery
static const UINT32 PropStringHashEnableSelectiveRecovery  = 0xE48C8C28;   ///< enableSelectiveRecovery
static const UINT32 StringHashDisableFDSegment          = 0x2CF8E628;   ///< disableFDSegment
static const UINT32 PropStringHashDisableFDSegment      = 0xB69C4506;   ///< disableFDSegment
static const UINT32 StringHashEnableAsciiLogging        = 0xB5CF33AA;   ///< enableAsciiLogging
static const UINT32 PropStringHashEnableAsciiLogging    = 0x274389C3;   ///< enableAsciiLogging
static const UINT32 StringHashEnableBinaryLogging       = 0x54D473B9;   ///< enableBinaryLogging
static const UINT32 PropStringHashEnableBinaryLogging   = 0x05433E8B;   ///< enableBinaryLogging
static const UINT32 StringHashOfflineLoggerMinFlushCnt  = 0xB212E762;   ///< offlineLoggerMinFlushCnt
static const UINT32 PropStringHashOfflineLoggerMinFlushCnt  = 0xD6B1C9F8;   ///< offlineLoggerMinFlushCnt
static const UINT32 StringHashOfflineLoggerMaxAllLogSize  = 0x818B9122;   ///< offlineLoggerMaxAllLogSize
static const UINT32 PropStringHashOfflineLoggerMaxAllLogSize  = 0x0D31F8B0;   ///< offlineLoggerMaxAllLogSize
static const UINT32 StringHashOfflineLoggerEnableBackupLog  = 0x8E008FEF;   ///< offlineLoggerEnableBackupLog
static const UINT32 PropStringHashOfflineLoggerEnableBackupLog  = 0x67A6C5DD;   ///< offlineLoggerEnableBackupLog
static const UINT32 StringHashEnableCoredumpOfflineTextLogging  = 0x79564134;   ///< enableCoredumpOfflineTextLogging
static const UINT32 PropStringHashEnableCoredumpOfflineTextLogging  = 0xDA78DB50;   ///< enableCoredumpOfflineTextLogging
static const UINT32 StringHashEnableCoredumpOfflineBinaryLogging  = 0xEFBADAF1;   ///< enableCoredumpOfflineBinaryLogging
static const UINT32 PropStringHashEnableCoredumpOfflineBinaryLogging  = 0x55D3487D;   ///< enableCoredumpOfflineBinaryLogging
static const UINT32 StringHashOfflineLoggerBackupFileNumber  = 0xEA95FA7C;   ///< offlineLoggerBackupFileNumber
static const UINT32 PropStringHashOfflineLoggerBackupFileNumber  = 0xDE5CBC21;   ///< offlineLoggerBackupFileNumber
static const UINT32 StringHashOfflineLoggerMinBackupRequire  = 0xA6941274;   ///< offlineLoggerMinBackupRequire
static const UINT32 PropStringHashOfflineLoggerMinBackupRequire  = 0x925D5429;   ///< offlineLoggerMinBackupRequire
static const UINT32 StringHashOfflineLoggerEnableDebugDump  = 0xF32AED98;   ///< offlineLoggerEnableDebugDump
static const UINT32 PropStringHashOfflineLoggerEnableDebugDump  = 0x1A8CA7AA;   ///< offlineLoggerEnableDebugDump
static const UINT32 StringHashEnableErrorInducerFramework  = 0x9BEA891D;   ///< enableErrorInducerFramework
static const UINT32 PropStringHashEnableErrorInducerFramework  = 0x0CA7BB4C;   ///< enableErrorInducerFramework
static const UINT32 StringHashInducerErrorType          = 0x39029FA6;   ///< inducerErrorType
static const UINT32 PropStringHashInducerErrorType      = 0xA3663C88;   ///< inducerErrorType
static const UINT32 StringHashInducerKMDEventType       = 0x26E4BCC0;   ///< inducerKMDEventType
static const UINT32 PropStringHashInducerKMDEventType   = 0x7773F1F2;   ///< inducerKMDEventType
static const UINT32 StringHashInducerKMDErrorType       = 0xE484BCE5;   ///< inducerKMDErrorType
static const UINT32 PropStringHashInducerKMDErrorType   = 0xB513F1D7;   ///< inducerKMDErrorType
static const UINT32 StringHashInducerKMDErrorCode       = 0xE48F6665;   ///< inducerKMDErrorCode
static const UINT32 PropStringHashInducerKMDErrorCode   = 0xB5182B57;   ///< inducerKMDErrorCode
static const UINT32 StringHashInducerRequestId          = 0xCC713F3F;   ///< inducerRequestId
static const UINT32 PropStringHashInducerRequestId      = 0x56159C11;   ///< inducerRequestId
static const UINT32 StringHashInducerPipelineName       = 0x2A6B5FB3;   ///< inducerPipelineName
static const UINT32 PropStringHashInducerPipelineName   = 0x7BFC1281;   ///< inducerPipelineName
static const UINT32 StringHashInducerNodeName           = 0x75664234;   ///< inducerNodeName
static const UINT32 PropStringHashInducerNodeName       = 0x01B5672D;   ///< inducerNodeName
static const UINT32 StringHashInducerPortId             = 0xC0561D76;   ///< inducerPortId
static const UINT32 PropStringHashInducerPortId         = 0x860B29BF;   ///< inducerPortId
static const UINT32 StringHashInducerSystemEventErrorCodes  = 0xF03D2ACB;   ///< inducerSystemEventErrorCodes
static const UINT32 PropStringHashInducerSystemEventErrorCodes  = 0x199B60F9;   ///< inducerSystemEventErrorCodes
static const UINT32 StringHashInducerSystemEventRequestId  = 0x32F9934C;   ///< inducerSystemEventRequestId
static const UINT32 PropStringHashInducerSystemEventRequestId  = 0xA5B4A11D;   ///< inducerSystemEventRequestId
static const UINT32 StringHashInducerSystemEventSessionName  = 0xDFEAAB3D;   ///< inducerSystemEventSessionName
static const UINT32 PropStringHashInducerSystemEventSessionName  = 0xEB23ED60;   ///< inducerSystemEventSessionName
static const UINT32 StringHashInducerSystemEventPipelineName  = 0x7C52A0F7;   ///< inducerSystemEventPipelineName
static const UINT32 PropStringHashInducerSystemEventPipelineName  = 0xE57A6B51;   ///< inducerSystemEventPipelineName
static const UINT32 StringHashInducerSystemEventNodeName  = 0xEA920757;   ///< inducerSystemEventNodeName
static const UINT32 PropStringHashInducerSystemEventNodeName  = 0x66286EC5;   ///< inducerSystemEventNodeName
static const UINT32 StringHashInducerSystemEventPortId  = 0x98B1E067;   ///< inducerSystemEventPortId
static const UINT32 PropStringHashInducerSystemEventPortId  = 0xFC12CEFD;   ///< inducerSystemEventPortId
static const UINT32 StringHashInduceFeature2ErrorType   = 0x3156663D;   ///< induceFeature2ErrorType
static const UINT32 PropStringHashInduceFeature2ErrorType  = 0xE2737F49;   ///< induceFeature2ErrorType
static const UINT32 StringHashInducerFeature2RequestId  = 0xDD8C13BF;   ///< inducerFeature2RequestId
static const UINT32 PropStringHashInducerFeature2RequestId  = 0xB92F3D25;   ///< inducerFeature2RequestId
static const UINT32 StringHashInducerFeatureGraphName   = 0xDD39FEB3;   ///< inducerFeatureGraphName
static const UINT32 PropStringHashInducerFeatureGraphName  = 0x0E1CE7C7;   ///< inducerFeatureGraphName
static const UINT32 StringHashInducerFeatureName        = 0xC7BF76F8;   ///< inducerFeatureName
static const UINT32 PropStringHashInducerFeatureName    = 0x5533CC91;   ///< inducerFeatureName
static const UINT32 StringHashInducerFROProcessSeqId    = 0x30C094C1;   ///< inducerFROProcessSeqId
static const UINT32 PropStringHashInducerFROProcessSeqId  = 0x9659BC0A;   ///< inducerFROProcessSeqId
static const UINT32 StringHashInducerFeaturePortName    = 0xD0AAF2C1;   ///< inducerFeaturePortName
static const UINT32 PropStringHashInducerFeaturePortName  = 0x7633DA0A;   ///< inducerFeaturePortName
static const UINT32 StringHashSessionDumpForFlush       = 0x315E8BBA;   ///< sessionDumpForFlush
static const UINT32 PropStringHashSessionDumpForFlush   = 0x60C9C688;   ///< sessionDumpForFlush
static const UINT32 StringHashEnableCameraCoreDumpBinary  = 0xCEE8AAA1;   ///< enableCameraCoreDumpBinary
static const UINT32 PropStringHashEnableCameraCoreDumpBinary  = 0x4252C333;   ///< enableCameraCoreDumpBinary
static const UINT32 StringHashEnableCameraCoreDumpText  = 0x263888FC;   ///< enableCameraCoreDumpText
static const UINT32 PropStringHashEnableCameraCoreDumpText  = 0x429BA666;   ///< enableCameraCoreDumpText
static const UINT32 StringHashEnableCameraSessionDump   = 0x354A80FF;   ///< enableCameraSessionDump
static const UINT32 PropStringHashEnableCameraSessionDump  = 0xE66F998B;   ///< enableCameraSessionDump
static const UINT32 StringHashOverrideCameraCoreDumpLogging  = 0xC2DAF1BE;   ///< overrideCameraCoreDumpLogging
static const UINT32 PropStringHashOverrideCameraCoreDumpLogging  = 0xF613B7E3;   ///< overrideCameraCoreDumpLogging
static const UINT32 StringHashEnableFwkDump             = 0x0E0BF6E7;   ///< enableFwkDump
static const UINT32 PropStringHashEnableFwkDump         = 0x4856C22E;   ///< enableFwkDump
static const UINT32 StringHashDumpNodeProcessingInfo    = 0xC1E912ED;   ///< dumpNodeProcessingInfo
static const UINT32 PropStringHashDumpNodeProcessingInfo  = 0x67703A26;   ///< dumpNodeProcessingInfo
static const UINT32 StringHashDumpSessionProcessingInfo  = 0xA9FC2049;   ///< dumpSessionProcessingInfo
static const UINT32 PropStringHashDumpSessionProcessingInfo  = 0x3D99F305;   ///< dumpSessionProcessingInfo
static const UINT32 StringHashEnableCameraCoreDumpRecycle  = 0xC5C912F8;   ///< enableCameraCoreDumpRecycle
static const UINT32 PropStringHashEnableCameraCoreDumpRecycle  = 0x528420A9;   ///< enableCameraCoreDumpRecycle
static const UINT32 StringHashNumCameraCoreDumpReserved  = 0xB4208448;   ///< numCameraCoreDumpReserved
static const UINT32 PropStringHashNumCameraCoreDumpReserved  = 0x20455704;   ///< numCameraCoreDumpReserved
static const UINT32 StringHashMaxNumCameraCoreDump      = 0x0E144864;   ///< maxNumCameraCoreDump
static const UINT32 PropStringHashMaxNumCameraCoreDump  = 0x3CFDEE2E;   ///< maxNumCameraCoreDump
static const UINT32 StringHashEnableCameraOfflinelogRecycle  = 0x81EEA6F4;   ///< enableCameraOfflinelogRecycle
static const UINT32 PropStringHashEnableCameraOfflinelogRecycle  = 0xB527E0A9;   ///< enableCameraOfflinelogRecycle
static const UINT32 StringHashNumCameraOfflinelogReserved  = 0x34D0E647;   ///< numCameraOfflinelogReserved
static const UINT32 PropStringHashNumCameraOfflinelogReserved  = 0xA39DD416;   ///< numCameraOfflinelogReserved
static const UINT32 StringHashSizeTrigOfflinelogRecycling  = 0x3A27A16E;   ///< sizeTrigOfflinelogRecycling
static const UINT32 PropStringHashSizeTrigOfflinelogRecycling  = 0xAD6A933F;   ///< sizeTrigOfflinelogRecycling
static const UINT32 StringHashEnableHealthMonitor       = 0xB27EA104;   ///< enableHealthMonitor
static const UINT32 PropStringHashEnableHealthMonitor   = 0xE3E9EC36;   ///< enableHealthMonitor
static const UINT32 StringHashHMSTimeInterval           = 0x65C108C2;   ///< HMSTimeInterval
static const UINT32 PropStringHashHMSTimeInterval       = 0x11122DDB;   ///< HMSTimeInterval
static const UINT32 StringHashHMSMaxDelayedJobCount     = 0xB2AC4184;   ///< HMSMaxDelayedJobCount
static const UINT32 PropStringHashHMSMaxDelayedJobCount  = 0xEF9888C2;   ///< HMSMaxDelayedJobCount
static const UINT32 StringHashHMSSystemEventDelayCountFactor  = 0x2EF98648;   ///< HMSSystemEventDelayCountFactor
static const UINT32 PropStringHashHMSSystemEventDelayCountFactor  = 0xB7D14DEE;   ///< HMSSystemEventDelayCountFactor
static const UINT32 StringHashHMSEnableAuxJobMonitoring  = 0x565F7CAA;   ///< HMSEnableAuxJobMonitoring
static const UINT32 PropStringHashHMSEnableAuxJobMonitoring  = 0xC23AAFE6;   ///< HMSEnableAuxJobMonitoring
static const UINT32 StringHashNumberOfCHIThreads        = 0xCCB173EB;   ///< numberOfCHIThreads
static const UINT32 StringHashNumberOfAuxThreadMgrThreads  = 0xF2DCD5E8;   ///< numberOfAuxThreadMgrThreads
static const UINT32 StringHashUseVFETPG                 = 0xAA5328E6;   ///< useVFETPG
static const UINT32 PropStringHashUseVFETPG             = 0x95693EF9;   ///< useVFETPG
static const UINT32 StringHashIFEBufDoneTimeout         = 0xB6149662;   ///< IFEBufDoneTimeout
static const UINT32 PropStringHashIFEBufDoneTimeout     = 0xFA1A6AD2;   ///< IFEBufDoneTimeout
static const UINT32 StringHashIFEInputWidth             = 0x0DDC5373;   ///< IFEInputWidth
static const UINT32 PropStringHashIFEInputWidth         = 0xE21757B3;   ///< IFEInputWidth
static const UINT32 StringHashIFEInputHeight            = 0x854CA215;   ///< IFEInputHeight
static const UINT32 PropStringHashIFEInputHeight        = 0x7C2C3A08;   ///< IFEInputHeight
static const UINT32 StringHashIPEBufDoneTimeout         = 0xB6142662;   ///< IPEBufDoneTimeout
static const UINT32 PropStringHashIPEBufDoneTimeout     = 0xFA1ADAD2;   ///< IPEBufDoneTimeout
static const UINT32 StringHashIPEUnitTestIQBypassNumOfIteration  = 0x50508738;   ///< IPEUnitTestIQBypassNumOfIteration
static const UINT32 PropStringHashIPEUnitTestIQBypassNumOfIteration  = 0xACE0CB36;   ///< IPEUnitTestIQBypassNumOfIteration
static const UINT32 StringHashEnableImageBufferLateBinding  = 0x6DD7E808;   ///< enableImageBufferLateBinding
static const UINT32 PropStringHashEnableImageBufferLateBinding  = 0xD8C03068;   ///< enableImageBufferLateBinding
static const UINT32 StringHashMPMEnable                 = 0x8CD16B7E;   ///< MPMEnable
static const UINT32 PropStringHashMPMEnable             = 0x5F9DFF1B;   ///< MPMEnable
static const UINT32 StringHashMPMValidateMemPoolGroup   = 0xF0A0FFF7;   ///< MPMValidateMemPoolGroup
static const UINT32 PropStringHashMPMValidateMemPoolGroup  = 0x3981ECC3;   ///< MPMValidateMemPoolGroup
static const UINT32 StringHashMPMDoNotGroupBufferManagers  = 0x04A164F1;   ///< MPMDoNotGroupBufferManagers
static const UINT32 PropStringHashMPMDoNotGroupBufferManagers  = 0xB5A9DE2B;   ///< MPMDoNotGroupBufferManagers
static const UINT32 StringHashMPMKeepMinNumFreeBuffers  = 0x125E33DB;   ///< MPMKeepMinNumFreeBuffers
static const UINT32 PropStringHashMPMKeepMinNumFreeBuffers  = 0x74634925;   ///< MPMKeepMinNumFreeBuffers
static const UINT32 StringHashMPMAllocateBuffersOnRegister  = 0x7ED38F5D;   ///< MPMAllocateBuffersOnRegister
static const UINT32 PropStringHashMPMAllocateBuffersOnRegister  = 0x9775C56F;   ///< MPMAllocateBuffersOnRegister
static const UINT32 StringHashMPMGroupIfExactDeviceMatch  = 0x99499D5A;   ///< MPMGroupIfExactDeviceMatch
static const UINT32 PropStringHashMPMGroupIfExactDeviceMatch  = 0x15F3F4C8;   ///< MPMGroupIfExactDeviceMatch
static const UINT32 StringHashMPMMinSizeForSharing      = 0xF77E567C;   ///< MPMMinSizeForSharing
static const UINT32 PropStringHashMPMMinSizeForSharing  = 0xC597F036;   ///< MPMMinSizeForSharing
static const UINT32 StringHashMPMSizeDiffAllowedToGroup  = 0xD98BBD05;   ///< MPMSizeDiffAllowedToGroup
static const UINT32 PropStringHashMPMSizeDiffAllowedToGroup  = 0xD40A3981;   ///< MPMSizeDiffAllowedToGroup
static const UINT32 StringHashMPMLargeGroupSizeDefinition  = 0x4A6758BD;   ///< MPMLargeGroupSizeDefinition
static const UINT32 PropStringHashMPMLargeGroupSizeDefinition  = 0x08F0386F;   ///< MPMLargeGroupSizeDefinition
static const UINT32 StringHashMPMSizeDiffAllowedToGroupOverride  = 0xC6A5AE59;   ///< MPMSizeDiffAllowedToGroupOverride
static const UINT32 PropStringHashMPMSizeDiffAllowedToGroupOverride  = 0x47212A54;   ///< MPMSizeDiffAllowedToGroupOverride
static const UINT32 StringHashMPMBufferAddressAlignment  = 0x61DF8963;   ///< MPMBufferAddressAlignment
static const UINT32 PropStringHashMPMBufferAddressAlignment  = 0xB5E86705;   ///< MPMBufferAddressAlignment
static const UINT32 StringHashForceCHIBufferManagerHeap  = 0x2D88246B;   ///< forceCHIBufferManagerHeap
static const UINT32 PropStringHashForceCHIBufferManagerHeap  = 0x81C3C1E8;   ///< forceCHIBufferManagerHeap
static const UINT32 StringHashMPMSelfTuneImmediateCount  = 0xD3737A52;   ///< MPMSelfTuneImmediateCount
static const UINT32 PropStringHashMPMSelfTuneImmediateCount  = 0x4716A91E;   ///< MPMSelfTuneImmediateCount
static const UINT32 StringHashEnableMPMMonitorThread    = 0x8D6B772D;   ///< enableMPMMonitorThread
static const UINT32 PropStringHashEnableMPMMonitorThread  = 0x2BF25FE6;   ///< enableMPMMonitorThread
static const UINT32 StringHashMPMMonitorTimeInterval    = 0x4C4C9AF1;   ///< MPMMonitorTimeInterval
static const UINT32 PropStringHashMPMMonitorTimeInterval  = 0xEAD5B23A;   ///< MPMMonitorTimeInterval
static const UINT32 StringHashMPMMonitorSelfShrinkSizeLimit  = 0x55634264;   ///< MPMMonitorSelfShrinkSizeLimit
static const UINT32 PropStringHashMPMMonitorSelfShrinkSizeLimit  = 0x61AA0439;   ///< MPMMonitorSelfShrinkSizeLimit
static const UINT32 StringHashEnableMPMStatelogging     = 0xB8314B54;   ///< enableMPMStatelogging
static const UINT32 PropStringHashEnableMPMStatelogging  = 0xE5058212;   ///< enableMPMStatelogging
static const UINT32 StringHashEnableMemoryStats         = 0x86552C15;   ///< enableMemoryStats
static const UINT32 PropStringHashEnableMemoryStats     = 0xCAC149C6;   ///< enableMemoryStats
static const UINT32 StringHashMPMMinSizeToFreeOnDeactivate  = 0x1C211758;   ///< MPMMinSizeToFreeOnDeactivate
static const UINT32 PropStringHashMPMMinSizeToFreeOnDeactivate  = 0xF5875D6A;   ///< MPMMinSizeToFreeOnDeactivate
static const UINT32 StringHashValidateImageBufferUsageState  = 0x11D9CAE4;   ///< validateImageBufferUsageState
static const UINT32 PropStringHashValidateImageBufferUsageState  = 0x25108CB9;   ///< validateImageBufferUsageState
static const UINT32 StringHashMPMSizeThresToDisableDelayedUnmap  = 0x8186475D;   ///< MPMSizeThresToDisableDelayedUnmap
static const UINT32 PropStringHashMPMSizeThresToDisableDelayedUnmap  = 0xE4550BC9;   ///< MPMSizeThresToDisableDelayedUnmap
static const UINT32 StringHashMPMForceDisableDelayedUnmap  = 0x9F846966;   ///< MPMForceDisableDelayedUnmap
static const UINT32 PropStringHashMPMForceDisableDelayedUnmap  = 0x08C95B37;   ///< MPMForceDisableDelayedUnmap
static const UINT32 StringHashMPMSizeThresToDelayedMap  = 0xD870DF60;   ///< MPMSizeThresToDelayedMap
static const UINT32 PropStringHashMPMSizeThresToDelayedMap  = 0xE4550BC9;   ///< MPMSizeThresToDelayedMap
static const UINT32 StringHashMaxDedicatedCameraMemory  = 0xF25E570E;   ///< maxDedicatedCameraMemory
static const UINT32 PropStringHashMaxDedicatedCameraMemory  = 0x96FD7994;   ///< maxDedicatedCameraMemory
static const UINT32 StringHashSizeThresToUseChiGrallocBuffer  = 0xFA84748A;   ///< sizeThresToUseChiGrallocBuffer
static const UINT32 PropStringHashSizeThresToUseChiGrallocBuffer  = 0x63ACBF2C;   ///< sizeThresToUseChiGrallocBuffer
static const UINT32 StringHashMPMCheckActivity          = 0x2B31D635;   ///< MPMCheckActivity
static const UINT32 PropStringHashMPMCheckActivity      = 0xB155751B;   ///< MPMCheckActivity
static const UINT32 StringHashDumpAF                    = 0xCF674C46;   ///< dumpAF
static const UINT32 StringHashDumpAEC                   = 0xECE988DA;   ///< dumpAEC
static const UINT32 StringHashDumpAWB                   = 0xECE98A9B;   ///< dumpAWB
static const UINT32 StringHashDumpAFDRowsum             = 0x99F020E2;   ///< dumpAFDRowsum
static const UINT32 StringHashEnableQLLProcessing       = 0xB314530B;   ///< enableQLLProcessing
static const UINT32 StringHashForceQLLTriggered         = 0xE11BD70E;   ///< forceQLLTriggered
static const UINT32 StringHashBypassQLLMLProcess        = 0xE7C76CCE;   ///< BypassQLLMLProcess
static const UINT32 StringHashFeatureBETMode            = 0x2C29E11F;   ///< FeatureBETMode
static const UINT32 StringHashDumpQLLLogsMask           = 0xE0CEFC9C;   ///< dumpQLLLogsMask
static const UINT32 StringHashEnableMCXHardTransition   = 0xF4E2C46B;   ///< enableMCXHardTransition
static const UINT32 PropStringHashEnableMCXHardTransition  = 0x27C7DD1F;   ///< enableMCXHardTransition
static const UINT32 StringHashEnableHDR10PlibLogs       = 0xFE7BA8C5;   ///< enableHDR10PlibLogs
static const UINT32 StringHashDumpHDR10pLogsMask        = 0x7C330DA6;   ///< dumpHDR10pLogsMask
static const UINT32 StringHashDumpAFCData               = 0x8B9D4479;   ///< dumpAFCData
static const UINT32 StringHashProfile3A                 = 0x0AA7E18A;   ///< profile3A
static const UINT32 PropStringHashProfile3A             = 0x56773C42;   ///< profile3A
static const UINT32 StringHashLuxIndexThresholdForAIDenoiser  = 0xF163EA34;   ///< luxIndexThresholdForAIDenoiser
static const UINT32 PropStringHashLuxIndexThresholdForAIDenoiser  = 0x684B2192;   ///< luxIndexThresholdForAIDenoiser
static const UINT32 StringHashADRCGainThresholdForAIDenoiser  = 0xD41D7F1D;   ///< ADRCGainThresholdForAIDenoiser
static const UINT32 PropStringHashADRCGainThresholdForAIDenoiser  = 0x4D35B4BB;   ///< ADRCGainThresholdForAIDenoiser
static const UINT32 StringHashTrackerRoiMixer           = 0x34C5A0BB;   ///< trackerRoiMixer
static const UINT32 PropStringHashTrackerRoiMixer       = 0x401685A2;   ///< trackerRoiMixer
static const UINT32 StringHashAecGainThresholdForCDS    = 0xC9C3453D;   ///< aecGainThresholdForCDS
static const UINT32 PropStringHashAecGainThresholdForCDS  = 0x6F5A6DF6;   ///< aecGainThresholdForCDS
static const UINT32 StringHashFpsChangeInterval         = 0xDF39CE1F;   ///< fpsChangeInterval
static const UINT32 PropStringHashFpsChangeInterval     = 0x93ADABCC;   ///< fpsChangeInterval
static const UINT32 StringHashMaxStatsFps               = 0xC4C04DF6;   ///< maxStatsFps
static const UINT32 PropStringHashMaxStatsFps           = 0xF691DABB;   ///< maxStatsFps
static const UINT32 StringHashEnableSWPDPC              = 0x927DDF1A;   ///< enableSWPDPC
static const UINT32 PropStringHashEnableSWPDPC          = 0xD84F36BC;   ///< enableSWPDPC
static const UINT32 StringHashEnableShadingCorrection   = 0x565267AC;   ///< enableShadingCorrection
static const UINT32 PropStringHashEnableShadingCorrection  = 0x85777ED8;   ///< enableShadingCorrection
static const UINT32 StringHashQCCompanionSensor         = 0x899D6BE9;   ///< QCCompanionSensor
static const UINT32 PropStringHashQCCompanionSensor     = 0xC5090E3A;   ///< QCCompanionSensor
static const UINT32 StringHashInSensorSHDRMode          = 0xA9D5F207;   ///< inSensorSHDRMode
static const UINT32 PropStringHashInSensorSHDRMode      = 0x33B15129;   ///< inSensorSHDRMode
static const UINT32 StringHashEnablePipelineSplit       = 0xE1E779CB;   ///< enablePipelineSplit
static const UINT32 PropStringHashEnablePipelineSplit   = 0xB07034F9;   ///< enablePipelineSplit
static const UINT32 StringHashEnableAONUsecase          = 0xB7FB752C;   ///< enableAONUsecase
static const UINT32 PropStringHashEnableAONUsecase      = 0x2D9FD602;   ///< enableAONUsecase
static const UINT32 StringHashAonControlReleaseDelay    = 0x7567A2D3;   ///< aonControlReleaseDelay
static const UINT32 PropStringHashAonControlReleaseDelay  = 0xD3FE8A18;   ///< aonControlReleaseDelay
static const UINT32 StringHashEnableHDRMaxResolutionCheck  = 0x7BF25E3F;   ///< enableHDRMaxResolutionCheck
static const UINT32 PropStringHashEnableHDRMaxResolutionCheck  = 0xECBF6C6E;   ///< enableHDRMaxResolutionCheck
static const UINT32 StringHashEnableAONAECWarmStartUp   = 0xF2A376C0;   ///< enableAONAECWarmStartUp
static const UINT32 PropStringHashEnableAONAECWarmStartUp  = 0x21866FB4;   ///< enableAONAECWarmStartUp
static const UINT32 StringHashEnableSnapshotAEBTesting  = 0xE269BF5D;   ///< enableSnapshotAEBTesting
static const UINT32 PropStringHashEnableSnapshotAEBTesting  = 0x6487FDBB;   ///< enableSnapshotAEBTesting
static const UINT32 StringHashEnableNonHDRAEBSnapshot   = 0x81641561;   ///< enableNonHDRAEBSnapshot
static const UINT32 PropStringHashEnableNonHDRAEBSnapshot  = 0xB5536776;   ///< enableNonHDRAEBSnapshot
static const UINT32 StringHashEnableSingleExposureAEBSwitching  = 0x985C155D;   ///< enableSingleExposureAEBSwitching
static const UINT32 PropStringHashEnableSingleExposureAEBSwitching  = 0x761EF3DB;   ///< enableSingleExposureAEBSwitching
static const UINT32 StringHashEnablePreviewCBInMultiPreview  = 0xB2D5DB35;   ///< enablePreviewCBInMultiPreview
static const UINT32 PropStringHashEnablePreviewCBInMultiPreview  = 0x7FD807B0;   ///< enablePreviewCBInMultiPreview
static const UINT32 StringHashDisableStatsPorts         = 0xF6CB05E2;   ///< disableStatsPorts
static const UINT32 PropStringHashDisableStatsPorts     = 0xBA5F6031;   ///< disableStatsPorts
static const UINT32 StringHashEnable3expSHDRSnapshot    = 0x78F09171;   ///< enable3expSHDRSnapshot
static const UINT32 PropStringHashEnable3expSHDRSnapshot  = 0xC1512AE1;   ///< enable3expSHDRSnapshot
static const UINT32 StringHashThumbnailThreshold        = 0x92C7F53A;   ///< thumbnailThreshold
static const UINT32 PropStringHashThumbnailThreshold    = 0x004B4F53;   ///< thumbnailThreshold
static const UINT32 StringHashEnableThumbRetry          = 0x948A86CE;   ///< enableThumbRetry
static const UINT32 PropStringHashEnableThumbRetry      = 0x0EEE25E0;   ///< enableThumbRetry
static const UINT32 StringHashEnableMLAWBSnapshot       = 0x3B10A7DA;   ///< enableMLAWBSnapshot
static const UINT32 PropStringHashEnableMLAWBSnapshot   = 0x6A87EAE8;   ///< enableMLAWBSnapshot
static const UINT32 StringHashEnableGTMChannelToggle    = 0xEEAD55DB;   ///< enableGTMChannelToggle
static const UINT32 PropStringHashEnableGTMChannelToggle  = 0x48347D10;   ///< enableGTMChannelToggle
static const UINT32 StringHashInternalMultiresolutionMode  = 0xFD1D2773;   ///< internalMultiresolutionMode
static const UINT32 PropStringHashInternalMultiresolutionMode  = 0x6A501522;   ///< internalMultiresolutionMode
static const UINT32 StringHashNoRemosaicCaptureMode     = 0x46A9018A;   ///< noRemosaicCaptureMode
static const UINT32 PropStringHashNoRemosaicCaptureMode  = 0x1B9DC8CC;   ///< noRemosaicCaptureMode
static const UINT32 StringHashEnabledMultiCameraZSLOffForAux  = 0x28FC6AAD;   ///< enabledMultiCameraZSLOffForAux
static const UINT32 PropStringHashEnabledMultiCameraZSLOffForAux  = 0xB1D4A10B;   ///< enabledMultiCameraZSLOffForAux
static const UINT32 StringHashIsSkipStatsNZSLSnapshot   = 0x69B43BBC;   ///< isSkipStatsNZSLSnapshot
static const UINT32 PropStringHashIsSkipStatsNZSLSnapshot  = 0xBA9122C8;   ///< isSkipStatsNZSLSnapshot
static const UINT32 StringHashEISWidthMargin            = 0x7479D638;   ///< EISWidthMargin
static const UINT32 PropStringHashEISWidthMargin        = 0xBFDF4F10;   ///< EISWidthMargin
static const UINT32 StringHashEISHeightMargin           = 0xD9B1CC86;   ///< EISHeightMargin
static const UINT32 PropStringHashEISHeightMargin       = 0xAD62E99F;   ///< EISHeightMargin
static const UINT32 StringHashEISGyroConf               = 0xA3596180;   ///< EISGyroConf
static const UINT32 PropStringHashEISGyroConf           = 0x9108F6CD;   ///< EISGyroConf
static const UINT32 StringHashEISLDCGridEnabled         = 0xEA54C2E3;   ///< EISLDCGridEnabled
static const UINT32 PropStringHashEISLDCGridEnabled     = 0xA6C0A730;   ///< EISLDCGridEnabled
static const UINT32 StringHashEISv2GyroDumpEnabled      = 0xA629FB5B;   ///< EISv2GyroDumpEnabled
static const UINT32 PropStringHashEISv2GyroDumpEnabled  = 0x94C05D11;   ///< EISv2GyroDumpEnabled
static const UINT32 StringHashEISv2InputDumpLogcatEnabled  = 0xE66B589B;   ///< EISv2InputDumpLogcatEnabled
static const UINT32 PropStringHashEISv2InputDumpLogcatEnabled  = 0x71266ACA;   ///< EISv2InputDumpLogcatEnabled
static const UINT32 StringHashEISv2OutputDumpEnabled    = 0xAF920B12;   ///< EISv2OutputDumpEnabled
static const UINT32 PropStringHashEISv2OutputDumpEnabled  = 0x090B23D9;   ///< EISv2OutputDumpEnabled
static const UINT32 StringHashEISv2OutputDumpLogcatEnabled  = 0xA15C1388;   ///< EISv2OutputDumpLogcatEnabled
static const UINT32 PropStringHashEISv2OutputDumpLogcatEnabled  = 0x48FA59BA;   ///< EISv2OutputDumpLogcatEnabled
static const UINT32 StringHashEISv2OperationMode        = 0x5D8797BD;   ///< EISv2OperationMode
static const UINT32 PropStringHashEISv2OperationMode    = 0xCF0B2DD4;   ///< EISv2OperationMode
static const UINT32 StringHashEISv2DefaultGridTransformEnable  = 0xC78633B3;   ///< EISv2DefaultGridTransformEnable
static const UINT32 PropStringHashEISv2DefaultGridTransformEnable  = 0xE29F4760;   ///< EISv2DefaultGridTransformEnable
static const UINT32 StringHashEISv2DumpForceFlush       = 0xF24BCACE;   ///< EISv2DumpForceFlush
static const UINT32 PropStringHashEISv2DumpForceFlush   = 0xA3DC87FC;   ///< EISv2DumpForceFlush
static const UINT32 StringHashEISOISMode                = 0x150BFA66;   ///< EISOISMode
static const UINT32 PropStringHashEISOISMode            = 0x7C9976DC;   ///< EISOISMode
static const UINT32 StringHashEISv2DisableOIS           = 0x8937C246;   ///< EISv2DisableOIS
static const UINT32 PropStringHashEISv2DisableOIS       = 0xFDE4E75F;   ///< EISv2DisableOIS
static const UINT32 StringHashEISv2DisableMag           = 0x8937CB52;   ///< EISv2DisableMag
static const UINT32 PropStringHashEISv2DisableMag       = 0xFDE4EE4B;   ///< EISv2DisableMag
static const UINT32 StringHashEISv2DisableAccel         = 0xDFEC56E8;   ///< EISv2DisableAccel
static const UINT32 PropStringHashEISv2DisableAccel     = 0x9378333B;   ///< EISv2DisableAccel
static const UINT32 StringHashEISv2DisableGravity       = 0x13723987;   ///< EISv2DisableGravity
static const UINT32 PropStringHashEISv2DisableGravity   = 0x42E574B5;   ///< EISv2DisableGravity
static const UINT32 StringHashEISv2iFOVCEnable          = 0x747A9BEC;   ///< EISv2iFOVCEnable
static const UINT32 PropStringHashEISv2iFOVCEnable      = 0xEE1E38C2;   ///< EISv2iFOVCEnable
static const UINT32 StringHashFDEnableInEIS             = 0x9F3F3B5E;   ///< FDEnableInEIS
static const UINT32 PropStringHashFDEnableInEIS         = 0xD9620F97;   ///< FDEnableInEIS
static const UINT32 StringHashEISv3GyroDumpEnabled      = 0xA629F35B;   ///< EISv3GyroDumpEnabled
static const UINT32 PropStringHashEISv3GyroDumpEnabled  = 0x94C05511;   ///< EISv3GyroDumpEnabled
static const UINT32 StringHashEISv3InputDumpLogcatEnabled  = 0xE66B189B;   ///< EISv3InputDumpLogcatEnabled
static const UINT32 PropStringHashEISv3InputDumpLogcatEnabled  = 0x71262ACA;   ///< EISv3InputDumpLogcatEnabled
static const UINT32 StringHashEISv3OutputDumpEnabled    = 0xAFB20B12;   ///< EISv3OutputDumpEnabled
static const UINT32 PropStringHashEISv3OutputDumpEnabled  = 0x092B23D9;   ///< EISv3OutputDumpEnabled
static const UINT32 StringHashEISv3OutputDumpLogcatEnabled  = 0xA1541388;   ///< EISv3OutputDumpLogcatEnabled
static const UINT32 PropStringHashEISv3OutputDumpLogcatEnabled  = 0x48F259BA;   ///< EISv3OutputDumpLogcatEnabled
static const UINT32 StringHashEISv3OperationMode        = 0x5D8797BF;   ///< EISv3OperationMode
static const UINT32 PropStringHashEISv3OperationMode    = 0xCF0B2DD6;   ///< EISv3OperationMode
static const UINT32 StringHashEISv3DefaultGridTransformEnable  = 0xC78633B7;   ///< EISv3DefaultGridTransformEnable
static const UINT32 PropStringHashEISv3DefaultGridTransformEnable  = 0xE29F4764;   ///< EISv3DefaultGridTransformEnable
static const UINT32 StringHashEISv3DumpForceFlush       = 0xF24BCA8E;   ///< EISv3DumpForceFlush
static const UINT32 PropStringHashEISv3DumpForceFlush   = 0xA3DC87BC;   ///< EISv3DumpForceFlush
static const UINT32 StringHashEISv3DisableDIS           = 0x8933EE46;   ///< EISv3DisableDIS
static const UINT32 PropStringHashEISv3DisableDIS       = 0xFDE0CB5F;   ///< EISv3DisableDIS
static const UINT32 StringHashDisableMOFAlignment       = 0x72B7AB91;   ///< disableMOFAlignment
static const UINT32 PropStringHashDisableMOFAlignment   = 0x2320E6A3;   ///< disableMOFAlignment
static const UINT32 StringHashEISv3DisableOIS           = 0x8933C246;   ///< EISv3DisableOIS
static const UINT32 PropStringHashEISv3DisableOIS       = 0xFDE0E75F;   ///< EISv3DisableOIS
static const UINT32 StringHashEISv3DisableMag           = 0x8933CB52;   ///< EISv3DisableMag
static const UINT32 PropStringHashEISv3DisableMag       = 0xFDE0EE4B;   ///< EISv3DisableMag
static const UINT32 StringHashEISv3DisableAccel         = 0xCFEC56E8;   ///< EISv3DisableAccel
static const UINT32 PropStringHashEISv3DisableAccel     = 0x8378333B;   ///< EISv3DisableAccel
static const UINT32 StringHashEISv3DisableGravity       = 0x137239C7;   ///< EISv3DisableGravity
static const UINT32 PropStringHashEISv3DisableGravity   = 0x42E574F5;   ///< EISv3DisableGravity
static const UINT32 StringHashEnableLegacyStopRecording  = 0x480D4A51;   ///< enableLegacyStopRecording
static const UINT32 PropStringHashEnableLegacyStopRecording  = 0xDC68991D;   ///< enableLegacyStopRecording
static const UINT32 StringHashEISv3iFOVCEnable          = 0x74FA9BEC;   ///< EISv3iFOVCEnable
static const UINT32 PropStringHashEISv3iFOVCEnable      = 0xEE9E38C2;   ///< EISv3iFOVCEnable
static const UINT32 StringHashEnableDistortionCorrOptimization  = 0xD4298E5F;   ///< EnableDistortionCorrOptimization
static const UINT32 PropStringHashEnableDistortionCorrOptimization  = 0x7707143B;   ///< EnableDistortionCorrOptimization
static const UINT32 StringHashEnableFCG                 = 0x82F3726F;   ///< enableFCG
static const UINT32 PropStringHashEnableFCG             = 0x51BFE60A;   ///< enableFCG
static const UINT32 StringHashDisableSR                 = 0x0417FD46;   ///< disableSR
static const UINT32 PropStringHashDisableSR             = 0xD75B6923;   ///< disableSR
static const UINT32 StringHashNoCameraMode              = 0x94973294;   ///< noCameraMode
static const UINT32 PropStringHashNoCameraMode          = 0xDEA5DB32;   ///< noCameraMode
static const UINT32 StringHashPartialCameraMode         = 0x036826FA;   ///< partialCameraMode
static const UINT32 PropStringHashPartialCameraMode     = 0x4FFC4329;   ///< partialCameraMode
static const UINT32 StringHashLimitedCameraMode         = 0xD1546101;   ///< limitedCameraMode
static const UINT32 PropStringHashLimitedCameraMode     = 0x9DC004D2;   ///< limitedCameraMode
static const UINT32 StringHashEnableCSLHwCapabilityDetection  = 0xDFCF3150;   ///< enableCSLHwCapabilityDetection
static const UINT32 PropStringHashEnableCSLHwCapabilityDetection  = 0x46E7FAF6;   ///< enableCSLHwCapabilityDetection
static const UINT32 StringHashEnableSWMLRemosaic        = 0xF854D694;   ///< enableSWMLRemosaic
static const UINT32 PropStringHashEnableSWMLRemosaic    = 0x6AD86CFD;   ///< enableSWMLRemosaic
static const UINT32 StringHashEnableBroadcast           = 0x24CCD205;   ///< enableBroadcast
static const UINT32 PropStringHashEnableBroadcast       = 0x501FF71C;   ///< enableBroadcast

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Type Definitions
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Enumerates CSL mode types
enum CSLModeType
{
    CSLModeHardware,                        ///< Hardware CSL implementation, using the standard CamX KMD and hardware
    CSLModeIFH,                             ///< Infinitely Fast Hardware CSL implementation, bypassing the KMD
    CSLModePresil,                          ///< Presil CSIM CSL Implementation
    CSLModePresilRUMI,                      ///< Presil RUMI CSL Implementation
};

/// CSL Camera family type
enum CSLCameraFamilyType
{
    CSLCameraFamilyTypeCameraSS,            ///< Camera Subsystem present in Bear, Badger and HoneyBadger.
    CSLCameraFamilyTypeTitan,               ///< Titan camera architecture.
};

/// List of HAF algorithm that can be enabled overriding tuning
enum EnableAFAlgoType
{
    EnableAFAlgoDisabled,                   ///< AF algorithm tuning override is disabled
    EnableAFAlgoPDAF,                       ///< Override tuning and enable only PDAF
    EnableAFAlgoTOF,                        ///< Override tuning and enable only TOF
    EnableAFAlgoDCIAF,                      ///< Override tuning and enable only DCIAF
    EnableAFAlgoCAF,                        ///< Override tuning and enable only CAF
};

/// Enumerates AF fullsweep types
enum AFFullsweepType
{
    AFFullsweepDisabled,                    ///< AF fullsweep is disabled
    AFFullsweepInfinityToMacro,             ///< Performs fullsweep starting from Infinity to Macro
    AFFullsweepMacroToInfinity,             ///< Performs fullsweep starting from Macro to Infinity
    AFFullsweepBothDirection,               ///< Performs fullsweep starting from Infinity to Macro and back
};

/// Enumerates type of AF manual lens control
enum AFManualLensControlType
{
    AFManualLensControlDisabled,            ///< Manual lens control is disabled
    AFManualLensControlDAC,                 ///< Move lens manually using DAC value
    AFManualLensControlLogical,             ///< Move lens manually giving logical lens position
};

/// Enumerates output format types
enum OutputFormatType
{
    OutputFormatYUV420NV12,                 ///< Linear NV12 format
    OutputFormatUBWCNV12,                   ///< UBWC NV12 format
    OutputFormatUBWCTP10,                   ///< UBWC TP10 format
    OutputFormatRAWPLAIN16,                 ///< Raw Plain16 format
    OutputFormatPD10,                       ///< PD10 format
    OutputFormatP010,                       ///< LinerP010 format
    OutputFormatYUV420NV21,                 ///< Linear NV21 format
    OutputFormatRAWPLAIN64,                 ///< Raw Plain64 format
};

/// Enumerates video output format types
enum OverrideVideoOutputFormatType
{
    OverrideVideoOutputFormatDefault,       ///< Default
    OverrideVideoOutputFormatUBWCTP10,      ///< UBWC TP10 format
    OverrideVideoOutputFormatUBWCTP10Lossy, ///< UBWC TP10 Lossy format
    OverrideVideoOutputFormatUBWCNV12,      ///< UBWC NV12 format
    OverrideVideoOutputFormatUBWCNV12Lossy, ///< UBWC NV12 Lossy format
    OverrideVideoOutputFormatP010,          ///< Linear P010 format
    OverrideVideoOutputFormatNV12Venus,     ///< NV12 Venus format
};

/// Enumerates video dataspace types
enum overrideVideoDataspaceType
{
    overrideVideoDataspaceUnknown,          ///< Dataspace Unknown
    overrideVideoDataspaceBT601_625,        ///< Dataspace BT601_625
    overrideVideoDataspaceBT709,            ///< Dataspace BT709
};

/// Enumerates FD processing controls
enum FDProcessingControlType
{
    FDProcessingControlForceDisable,        ///< Force disable FD processing
    FDProcessingControlForceEnable,         ///< Force enable FD processing
    FDProcessingControlAutoEnable,          ///< Enable FD processing in auto control mode
    FDProcessingControlAppRequest,          ///< Enable/Disable FD processing based on App request
};

/// FD base resolutions, 0:15 width 16:32 height
enum FDBaseResolutionType
{
    FDBaseResolution640x480 = 31457920,     ///< FD base resolution width 640 height 480
    FDBaseResolution854x480 = 31458134,     ///< FD base resolution width 854 height 480
    FDBaseResolution320x240 = 15728960,     ///< FD base resolution width 320 height 240
    FDBaseResolution427x240 = 15729067,     ///< FD base resolution width 427 height 240
    FDBaseResolution384x288 = 18874752,     ///< FD base resolution width 384 height 288
};

/// Enumerates FD config source types
enum FDConfigSourceType
{
    FDConfigDefault,                        ///< Fetch default configuration
    FDConfigVendorTag,                      ///< Fetch configuration from vendor tag
    FDConfigBinary,                         ///< Fetch configuration from tunning binary
};

/// Enumerates FD FL types
enum FDFLType
{
    EVAFL,                                  ///< Use EVA HW based FL solution
    DLFL,                                   ///< Use DL based FL solution
};

/// Processing criteria in multi-cam when both running
enum FDMultiCamProcessingType
{
    FDMultiCamProcessMasterOnly,            ///< Process only master requests at full fps
    FDMultiCamProcessAuxOnly,               ///< Process only aux requests at full fps
    FDMultiCamProcessBoth,                  ///< Process both master and aux at half fps
};

/// Enumerates FD Client types
enum FDClientType
{
    FDHWHybrid,                             ///< Use FD HW as FD Client
    FDSWOnly,                               ///< Use FD SW as FD Client
    FDDLDSP,                                ///< Use FD DL as FD Client
    FDDLCPU,                                ///< Use FD DL as FD Client, CPU based
    FDUsecaseDependent,                     ///< Use HW EVAFD or SW DLFD as FD Client based on usecase
};

/// Enumerates SW frame sync type
enum SWFrameSyncType
{
    SOFSync,                                ///< Sync the frames SOF
    MidOfFrameSync,                         ///< Sync the middle of active frame
};

/// Enumerates FD min face size setting
enum FDMinFaceSizeSetting
{
    MinFaceSizeNone,                        ///< No min face size
    MinFaceSize20x20,                       ///< Min face size 20x20
    MinFaceSize25x25,                       ///< Min face size 25x25
    MinFaceSize32x32,                       ///< Min face size 32x32
    MinFaceSize40x40,                       ///< Min face size 40x40
};

/// Enumerates FD max frame rate setting
enum FDMaxFPSSetting
{
    NoForce,                                ///< Use max frame rate setting in FD configuration
    Force15FPS,                             ///< Force 15FPS max frame rate
    Force30FPS,                             ///< Force 30FPS max frame rate
};

/// Used as a mask to enable image dumps for specific nodes
enum ImageDumpType
{
    ImageDumpNone = 0x0,                    ///< No dumps
    ImageDumpIFE = 0x1,                     ///< All output ports for IFE
    ImageDumpIPE = 0x2,                     ///< All output ports for IPE
    ImageDumpBPS = 0x4,                     ///< All output ports for BPS
    ImageDumpJPEG = 0x8,                    ///< All JPEG output ports for all JPEG nodes
    ImageDumpFDHw = 0x10,                   ///< All output ports for FDHw
    ImageDumpLRME = 0x20,                   ///< All output ports for LRME
    ImageDumpRANSAC = 0x40,                 ///< All output ports for RANSAC
    ImageDumpChiNode = 0x80,                ///< All output ports for all ChiNodes
    ImageDumpCVP = 0x100,                   ///< All output ports for CVP
    ImageDumpTFE = 0x200,                   ///< All output ports for TFE
    ImageDumpOPE = 0x400,                   ///< All output ports for OPE
    ImageDumpQSAT = 0x800,                  ///< All output ports for QSAT
    ImageDumpITOF = 0x1000,                 ///< All output ports for ITOF
    ImageDumpCRE = 0x2000,                  ///< All output ports for CRE
    ImageDumpMisc = 0x40000000,             ///< All other nodes not explicitly listed above
};

/// Dual LED Calibration modes
enum DualLEDCalibrationType
{
    DualLEDCalibrationDisabled,             ///< Dual LED Calibration is disabled
    DualLEDCalibrationTuning,               ///< Dual LED is being tuned for the golden module
    DualLEDCalibrationCalibration,          ///< Dual LED is being calibrated
};

/// Enumerates CHI Partial Data types
enum CHIPartialDataType
{
    CHIPartialDataDisable,                  ///< CHI Partial Data will be disabled
    CHIPartialDataSeparate,                 ///< CHI Partial Data will be sent separately
    CHIPartialDataCombined,                 ///< CHI Partial Data will be sent along with Core Partial Data
};

/// Enumerates thread scheduling modes
enum ThreadSchedulingMode
{
    NormalSched,                            ///< Normal scheduling
    RealtimeMinPrioritySched,               ///< Realtime scheduling but min priority
    RealtimeMaxPrioritySched,               ///< Realtime scheduling and max priority
};

/// Enumerates depth SW frame sync type
enum DepthSWFrameSyncType
{
    DepthSOESync,                           ///< Sync the frames SOE
    DepthSOFSync,                           ///< Sync the frames SOF
    DepthMidOfFrameSync,                    ///< Sync the middle of active frame
};

/// Enumerates sensor sub modules
enum SensorSubModule
{
    ActuatorDriver = 1,                     ///< Actuator Driver module 
    EEPROMDriver = 2,                       ///< EEPROM Driver module
    FlashDriver = 4,                        ///< Flash Driver module
    OISDriver = 8,                          ///< OIS Driver module
};

/// Indicates source of OIS calibration
enum OISCalibrationType
{
    NoCalibration = 0,                      ///< Disable calibration 
    OISXML = 1,                             ///< OIS calibration Data from OIS driver XML
    OTP = 2,                                ///< OIS calibration Data from EEPROM/OTP
};

/// @brief Maps an enumerator to its hash value
struct EnumeratorToHashMap
{
    UINT32  enumeratorStringHash;   ///< The hash value used for obfuscation
    INT     enumerator;             ///< The numerical value of the enumerator
};

/// @brief Encapsulates all  static settings values
struct StaticSettings
{
    AFFullsweepType         afFullsweep;                        ///< Enable/Disable Full-sweep Mode
                                                                ///< Disabled:         FullSweep mode is off,
                                                                ///< InfinityToMacro:  FullSweep mode is far to near end,
                                                                ///< MacroToInfinity:  FullSweep mode is near to far end,
                                                                ///< BothDirection:    Fullsweep mode is dual direction
    AFManualLensControlType manualAf;                           ///< Enable/Disable Manual Lens Control
                                                                ///< Disabled: Disable Manual Lens Movement,
                                                                ///< DAC:      Enable Control via DAC,
                                                                ///< Logical:  Enable Control via Logical Position
    BIT                     BLStretchEnable:1;                  ///< Enables BL Stretch for IFE Stats before BLS IQ block
    BIT                     BypassQLLMLProcess:1;               ///< Bypass/Pass QLL ML process
    BIT                     EISLDCGridEnabled:1;                ///< Flag for LDC grid enable
    BIT                     EISv2DefaultGridTransformEnable:1;  ///< Calibration mode
    BIT                     EISv2DisableAccel:1;                ///< Flag to disable Accel
    BIT                     EISv2DisableGravity:1;              ///< Flag to disable Gravity
    BIT                     EISv2DisableMag:1;                  ///< Flag to disable Mag
    BIT                     EISv2DisableOIS:1;                  ///< Flag to disable OIS
    BIT                     EISv2DumpForceFlush:1;              ///< Flag to indicate if node will be forced to call algorithm log flush API each iteration
    BIT                     EISv2GyroDumpEnabled:1;             ///< Flag to indicate if Gyro Dump enabled
    BIT                     EISv2InputDumpLogcatEnabled:1;      ///< Flag to indicate if algorithm output to file is enabled
    BIT                     EISv2OutputDumpEnabled:1;           ///< Flag to indicate if algorithm output to file is enabled
    BIT                     EISv2OutputDumpLogcatEnabled:1;     ///< Flag to indicate if algorithm output to file is enabled
    BIT                     EISv3DefaultGridTransformEnable:1;  ///< Flag for default grid/transform
    BIT                     EISv3DisableAccel:1;                ///< Flag to disable Accel
    BIT                     EISv3DisableDIS:1;                  ///< Flag to disable DIS
    BIT                     EISv3DisableGravity:1;              ///< Flag to disable Gravity
    BIT                     EISv3DisableMag:1;                  ///< Flag to disable Mag
    BIT                     EISv3DisableOIS:1;                  ///< Flag to disable OIS
    BIT                     EISv3DumpForceFlush:1;              ///< Flag to indicate if node will be forced to call algorithm log flush API each iteration
    BIT                     EISv3GyroDumpEnabled:1;             ///< Flag to indicate if Gyro Dump enabled
    BIT                     EISv3InputDumpLogcatEnabled:1;      ///< Flag to indicate if algorithm output to file is enabled
    BIT                     EISv3OutputDumpEnabled:1;           ///< Flag to indicate if algorithm output to file is enabled
    BIT                     EISv3OutputDumpLogcatEnabled:1;     ///< Flag to indicate if algorithm output to file is enabled
    BIT                     EISv3iFOVCEnable:1;                 ///< Flag to indicate if iFOVC is
    BIT                     EnableCSIPHYAuxDatarateMap:1;       ///< This setting Controls enabling/disabling generating CSIPHY
                                                                ///< Aux data rate mapping table and saving to a file.
    BIT                     EnableDisplaySmomo:1;               ///< Enable/Disable preview smomo for display hal
    BIT                     EnableDistortionCorrOptimization:1; ///< Enable Distortion correction optimization
    BIT                     FDEnableInEIS:1;                    ///< Flag to indicate if iFOVC is
    BIT                     FDInputDumpControl:1;               ///< Control FD input images dump
                                                                ///< TRUE  - Enable FD frame dumping, when FDInputDumpControlTrigger is TRUE begin to dump
                                                                ///< FALSE - Disable
    BIT                     FDInputDumpControlTrigger:1;        ///< If FDInputDumpControl == TRUE, FD input images would be dumped when this property
                                                                ///< is set to TRUE
    BIT                     FDUseCAMIFMapFromSensor:1;          ///< Use CAMIF map from sensor for FD face ROI translation
                                                                ///< TRUE  - Yes
                                                                ///< FALSE - No
    BIT                     FeatureBETMode:1;                   ///< Enable/disable OTP Data
                                                                ///< Disable OTP for feature BET
    BIT                     HALOutputBufferCombined:1;          ///< Enable HAL output buffer combined mode for HFR
    BIT                     HMSEnableAuxJobMonitoring:1;        ///< Enable HMSJobClient to monitor non core auxiliary jobs
    BIT                     IsStrideSettingEnable:1;            ///< Use the Stride Configuration data provided by OEM
    BIT                     MPMAllocateBuffersOnRegister:1;     ///< Allocates buffers at the time of register
    BIT                     MPMCheckActivity:1;                 ///< When enabled, IdleTime thread goes through all groups and all Buffer Managers in it and checks
                                                                ///< whether BufferManager is regularly doing GetBufferFromPool and ReleaseBufferToPool. This helps in
                                                                ///< identifying such BufferManagers who did Get and holding the buffers with themseleves. Mostly
                                                                ///< helpful in identifying CHI BufferManagers who are holding buffers in CHI or TBM.
    BIT                     MPMDoNotGroupBufferManagers:1;      ///< Each Buffer manager will have its own group, no sharing of buffers among Buffer Managers
    BIT                     MPMEnable:1;                        ///< Whether to use Memory Pool Manager for image buffer allocations
    BIT                     MPMForceDisableDelayedUnmap:1;      ///< Disable Delayed Unamp feature while mapping to SMMU for all buffers
    BIT                     MPMGroupIfExactDeviceMatch:1;       ///< Share buffers among Buffer Managers having exact list of devices to map.
                                                                ///< Valid only if MPMDoNotGroupBufferManagers is FALSE
                                                                ///< If Grouping and MPMGroupIfExactDeviceMatch is enabled : Buffer managers will share buffers only if
                                                                ///< the Buffer Managers needs buffers that needs to be mapped to exact same devices.
                                                                ///< If Grouping is enabled and MPMGroupIfExactDeviceMatch is disabled : Device list is not considered to
                                                                ///< decide whether Buffer Managers can share buffers. Buffers will be mapped to all devices that are
                                                                ///< required by both the Buffer Managers.
    BIT                     MPMSelfTuneImmediateCount:1;        ///< When enabled, immediate count configured in Buffer Manager create data is ignored and self tuned
                                                                ///< based on different link properties (node type, real time/offline pipeline, etc)
    BIT                     MPMValidateMemPoolGroup:1;          ///< Verifies whether input MemPoolGroup handle exists in the list
    BIT                     MetadataVisibility:1;               ///< Enable/Disable framework metadata optimization
    BIT                     QCCompanionSensor:1;                ///< Enable if sensor is companion chip
    BIT                     acceptAppUIFacialAttrSettings:1;    ///< Whether to accept App UI settings of facial atttibutes detection or not
                                                                ///< Valid only when FD is enabled
                                                                ///< TRUE  - Accept App UI settings
                                                                ///< FALSE - Ignore App UI settings
    BIT                     allowDelaySegMemAllocation:1;       ///< This is to allow delayed Segmentation memory allocation
                                                                ///< FALSE - Disabled
                                                                ///< TRUE - Enabled,
                                                                ///< Applicable for snapshot usecase
    BIT                     allowPartialDataToBeSent:1;         ///< Enable/Disable partial metadata to be sent
    BIT                     autoImageDump:1;                    ///< Dumps output images for all enabled nodes. This will run extremely slow
    BIT                     capResolutionForSingleIFE:1;        ///< When enabled, available stream resolution will be cap within single IFE supported range
    BIT                     capResolutionForSingleTFE:1;        ///< When enabled, available stream resolution will be cap within single TFE supported range
    BIT                     chiOverrideEnable:1;                ///< Enable/Disable CHI Override path
    BIT                     debugBufferRegDumpEnable:1;         ///< Whether or not UMD sends a buffer to KMD for resgister dump logging
    BIT                     debugDataOfflineAlloc:1;            ///< Setting this to TRUE will allocate debug-data for offline sessions.
                                                                ///< Disabling allocation for offline sessions, reduce memory usage. For usecases where realtime session is available,
                                                                ///< offline debug-data is not required in the metadata. Deep-copy and allocation takes place already by the framework
    BIT                     disable60FPS2EXPSHDRSupport:1;      ///< Disable 60FPS 2 exposure SHDR Support
    BIT                     disableADRC:1;                      ///< Enables/Disables ADRC
    BIT                     disableAECStatsProcessing:1;        ///< Enable/Disable AEC Stats Processing
    BIT                     disableAFAWBpreFlash:1;             ///< Flag to disable AF and AWB preflash states
    BIT                     disableAFAlgoCHIOverload:1;         ///< Enables/Disables  Algo CHI Overload
    BIT                     disableAFDAlgoCHIOverload:1;        ///< Enables/Disables AFD Algo CHI Overload
    BIT                     disableAFDStatsProcessing:1;        ///< Enables/Disables AFD Stats Processing
    BIT                     disableAFStatsProcessing:1;         ///< Enables/Disables AF Stats Processing
    BIT                     disableASDAlgoCHIOverload:1;        ///< Enables/Disables ASD Algo CHI Overload
    BIT                     disableAWBAlgoCHIOverload:1;        ///< Enables/Disables AWB Algo CHI Overload
    BIT                     disableAWBStatsProcessing:1;        ///< Enables/Disables AWB Stats Processing
    BIT                     disableBGStatsForAF:1;              ///< Disable Reading BG Stats for AF
    BIT                     disableCVPDriver:1;                 ///< This is to disable CVP driver
    BIT                     disableDRQPreemptionOnStopRecord:1; ///< Disables DRQ preemption on stop record
    BIT                     disableDynamicFPSControl:1;         ///< Override the FD configuration to disable dynamic FPS control
                                                                ///< TRUE:   Disables the tracker with dynamic FPS control and enables the fallback tracker
                                                                ///< FALSE:  Fallbacks to the default configuration setting
    BIT                     disableFDHWProcessing:1;            ///< Disable FD HW processing in case of an FD HW node
    BIT                     disableFDSegment:1;                 ///< This setting is used to force disable FD Segment
    BIT                     disableFlash:1;                     ///< Disables Flash
    BIT                     disableFocusIndication:1;           ///< Enable/Disable Focus Circle for Depth Based Algorithm
    BIT                     disableIQThreshold:1;               ///< Enable/Disable IQ Trigger Threshold
    BIT                     disableMMF:1;                       ///< Override setting to disable MMF
    BIT                     disableMOFAlignment:1;              ///< Flag indicating MOF alignement disabled
    BIT                     disablePDAF:1;                      ///< Completely disable PDAF
    BIT                     disablePDAFInit:1;                  ///< disable PDAF for IFE init packet
    BIT                     disablePDLibCHIOverload:1;          ///< Enables/Disables Library CHI Overload
    BIT                     disablePDLibLCR:1;                  ///< Enable/Disable PD Library LCR
    BIT                     disablePostingResults:1;            ///< Enable/Disable posting FD results to metadata, property
    BIT                     disablePreFlashOnForTouchAE:1;      ///< Turn on preflash over touch AE in always flash or auto flash mode
    BIT                     disablePreProcessedOutputPorts:1;   ///< disable PDAF preprocessed output port
    BIT                     disablePreviewManualExpTime:1;      ///< Enables/Disables Exposure Time Priority
    BIT                     disablePreviewManualFull:1;         ///< Complete Manual
    BIT                     disablePreviewManualISO:1;          ///< Enables/Disables ISO Priority
    BIT                     disableSR:1;                        ///< Disable SR scaling
    BIT                     disableSpeckleDetection:1;          ///< Enables/Disables Speckle Detection
    BIT                     disableVideoPerfModeSetting:1;      ///< Disables video perf mode setting
    BIT                     disableWaitForPipelinesDestroy:1;   ///< Disable/Enable waiting indefinitely for pipelines destroy
    BIT                     dualBHistSupport:1;                 ///< Enable Dual BHist Support
    BIT                     dumpAFCData:1;                      ///< If flag is enabled then data needed for AFC will be dumped into mobile device.
                                                                ///< To enable/disable dump, use below flag values.
                                                                ///< TRUE:  Enable dump
                                                                ///< FALSE: Disable dump
    BIT                     dumpAFDRowsum:1;                    ///< If flag is enabled then row sum stats will be dumped into mobile device.
                                                                ///< To enable/disable dump, use below flag values.
                                                                ///< TRUE:  Enable dump
                                                                ///< FALSE: Disable dump
    BIT                     dumpCHIMetadataToFile:1;            ///< Dump entire metadata buffer to file system.on per Frame basis.
                                                                ///< Refer to variable dumpCHIMetadata for the feature(s) list which enable this.
    BIT                     dumpInputatOutput:1;                ///< Dumps input port when output port is dumped. This will run extremely slow
    BIT                     dumpNodeProcessingInfo:1;           ///< Dumps basic stats about node processing time to logcat
    BIT                     dumpSensorEEPROMData:1;             ///< Enables/Disables dumping of EEPROM data
    BIT                     dumpSensorEmulationOutput:1;        ///< Enables/Disables dumping of emulated sensor output
    BIT                     dumpSensorMetaData:1;               ///< Enable/Disable sensor Metadata dump
    BIT                     dumpSessionProcessingInfo:1;        ///< Dumps basic stats about session request processing time to logcat
    BIT                     dynamicImageDump:1;                 ///< Triggers an image dump only when org.codeaurora.qcamera3.hal_private_data.debug_image_dump is TRUE
                                                                ///< in a request, or if the dynamicImageDumpTrigger property is toggled to TRUE.  This Setting must be
                                                                ///< set to TRUE to enable debug_image_dump, or dynamicImageDumpTrigger to dump images per request.
    BIT                     dynamicImageDumpTrigger:1;          ///< If dynamicImageDump == TRUE, a set of images per request is dumped when this property is toggled to TRUE.
                                                                ///< For now, dumps continue until it is reset to FALSE.  In the future, this may be a true trigger which
                                                                ///< resets itself
    BIT                     dynamicInlineCalibration:1;         ///< Enables/Disables dynamic inline LED Calibration
    BIT                     dynamicPropertiesEnabled:1;         ///< Properties can be dynamically updated and read per processRequest
    BIT                     enable3ADebugData:1;                ///< General switch to enable 3A debug data. See size settings to set a new size or use default.
    BIT                     enable3ADebugDataCustomFilter:1;    ///< General switch to enable customized 3A debug data filter
    BIT                     enable3ADebugDataDump:1;            ///< Enables 3A debug data dump
    BIT                     enable3expSHDRSnapshot:1;           ///< A setting to force 3exp SHDR snapshot
    BIT                     enableAIDLOffline:1;                ///< Enable/Disable OFFLINE AIDL SERVICE
    BIT                     enableAISegOnly:1;                  ///< True means enabling AI segment standalone
                                                                ///< False means disabling AI segment standalone
    BIT                     enableAIStatsMetadata:1;            ///< This is to enable AI stats metadata publish
                                                                ///< FALSE - Disabled
                                                                ///< TRUE - Enabled,
    BIT                     enableALSLightSensor:1;             ///< Enables/Disable ALS Sensor in AEC
    BIT                     enableAONAECWarmStartUp:1;          ///< Enable/Disable AON AEC warm start-up
    BIT                     enableAONUsecase:1;                 ///< Enable/Disable always on camera usecase and functionality
    BIT                     enableAWBR:1;                       ///< Enable/disable AWB Refinement(Low light feature) link
    BIT                     enableAuxSensorStandby:1;           ///< Enable/Disable standby sensor of aux session
    BIT                     enableBDSSplitFeature:1;            ///< Enable BDS (Bayer down scaling) Split Feature
                                                                ///< FALSE - Disabled
                                                                ///< TRUE - Enabled,
                                                                ///< Applicable only in video usecase
    BIT                     enableBackPropagateAIHSVStats:1;    ///< Merges AI HSV Metadata to Realtime 
    BIT                     enableBayerAlignment:1;             ///< Enable SFE alignment
    BIT                     enableBayerSAT:1;                   ///< Enable/Disable Bayer SAT, for SAT to work with bayer data
    BIT                     enableBayerTMCStats:1;              ///< Enable/Disable Bayer TMC stats of LTMDC to work with bayer LTM
    BIT                     enableBroadcast:1;                  ///< Enable broadcast functionality
    BIT                     enableBubbleRecovery:1;             ///< Enable/Disable Bubble Recovery
    BIT                     enableCDRSweepTest:1;               ///< Set this to TRUE to enable CDR Sweep Test using the camx
                                                                ///< override settings: cdrLaneValue, cdrTolerance and cdrToleranceType.
    BIT                     enableCSIDBinning:1;                ///< Enables/Disables CSID binning
    BIT                     enableCSIPHYCaching:1;              ///<  Enable CSIPHY device caching
    BIT                     enableCTDetection:1;                ///< Enable/Disable facial contour detection (AKA dense landmark)
                                                                ///< Valid only when FD and facial parts detection are enabled
                                                                ///< TRUE  - Enable facial contour detection
                                                                ///< FALSE - Disable
    BIT                     enableCameraCoreDumpBinary:1;       ///< Flag to enable entire camera core dump to binary file
    BIT                     enableCameraCoreDumpRecycle:1;      ///< Flag to enable camera core dump recycle
    BIT                     enableCameraCoreDumpText:1;         ///< Flag to enable entire camera core dump to text file
    BIT                     enableCameraOfflinelogRecycle:1;    ///< Flag to enable camera offlinelog recycle
    BIT                     enableCameraSessionDump:1;          ///< Flag to enable camera session dump
    BIT                     enableCaptureHalt:1;                ///< Enable/Disable Capture Halt
    BIT                     enableCascade2DLut:1;               ///< Enable/disable Cascade 2D LUT processing
    BIT                     enableChiMetadataSigAbort:1;        ///< Enable/Disable raising sigabort when no free meta buffer available in ChiMetadata client
                                                                ///< 0 for FALSE, Disable
                                                                ///< 1 for TRUE, Enable
    BIT                     enableConcise3ADebugData:1;         ///< General switch to enable Concise 3A debug data. See size settings to set a new size or use default.
    BIT                     enableCustom3AData:1;               ///<  Enable Custom 3A input by OEM 
    BIT                     enableCustomAlgoAEC:1;              ///< Enable/Disable custom AEC algo
    BIT                     enableCustomAlgoAF:1;               ///< Enable/Disable custom AF algo
    BIT                     enableCustomAlgoAFD:1;              ///< Enable/Disable custom AFD algo
    BIT                     enableCustomAlgoASD:1;              ///< Enable/Disable custom ASD algo
    BIT                     enableCustomAlgoAWB:1;              ///< Enable/Disable custom AWB algo
    BIT                     enableCustomHAFAlgo:1;              ///< Enable/Disable custom HAF algo
    BIT                     enableCustomHFRConfig:1;            ///< Enable custom HFR Configurations to support both batch mode and output buffer combined mode
    BIT                     enableCustomPDLib:1;                ///< Enable/Disable custom PD Library
    BIT                     enableDRV:1;                        ///< This is to use configure IFE DRV Module
    BIT                     enableDSM:1;                        ///< Enable/Disable Dynamic Stream Mapping by this setting
                                                                ///< TRUE  - DSM enable
                                                                ///< FALSE - DSM disable
    BIT                     enableDebugDataNewMemAllocation:1;  ///< DebugData new memory allocation approach
    BIT                     enableDebugSensorExposure:1;        ///< Enable setting exposure settings manually to sensor driver for debugging purpose
    BIT                     enableDedicatedCameraHeap:1;        ///< This setting enables dedicated camera heap allocation. When enabled
                                                                ///< all the buffers will be allocated from the system heap except those specified as camera heap.
    BIT                     enableDelaySubmitAuxRequest:1;      ///< Enable/Disable delay submit aux request
    BIT                     enableDepth:1;                      ///< Enables/Disable Depth
    BIT                     enableDepthFrameSync:1;             ///< Enables/Disable Depth Frame Sync
    BIT                     enableDepthProvider:1;              ///< Enable depthProvider to support depth16 stream
    BIT                     enableDisplayPortToPOSTPROC:1;      ///< Enable MCX RT display port to POSTPROC for additional preview output
    BIT                     enableDolbyVisionHDR:1;             ///< Settings to enable Dolby Vision dynamic range feature.
    BIT                     enableDummyRequestOptimization:1;   ///< Settings to remove dummy request during sensor mode switch.
    BIT                     enableDynamicFDConfig:1;            ///< Dynamic FD configuration
                                                                ///< TRUE  - Enable
                                                                ///< FALSE - Disable
    BIT                     enableDynamicModeSwitchVCUpdate:1;  ///< Update VC during dynamic mode switch
    BIT                     enableEGLCache:1;                   ///< Enables/Disable EGL Buffers Cache
    BIT                     enableEISAllPhysicalStream:1;       ///< Enable EIS
                                                                ///< FALSE: Disable EIS
                                                                ///< TRUE:  Enable EIS
    BIT                     enableEOSWithRRE:1;                 ///< Settings to enable EOS handling through repeating_request_end API.
                                                                ///< 0 for FALSE, Disable
                                                                ///< 1 for TRUE,  Enable
    BIT                     enableEVAiTOF:1;                    ///< Enable/disable EVA iTOF processing
                                                                ///< TRUE : Enable EVA iTOF processing
                                                                ///< FALSE: Disable EVA iTOF and use software based depth processing flow
    BIT                     enableEarlyBitMLSkelLoad:1;         ///< Early BitmL skel loading
                                                                ///< TRUE  - Enable early skel loading
                                                                ///< FALSE - Disable
    BIT                     enableEarlyPipelineActivate:1;      ///< Static policy will early pipeline activation
    BIT                     enableErrorInducerFramework:1;      ///< Enable error inducement framework
                                                                ///< Note: This flag is mandatory to enable error inducement framework at CAMX
                                                                ///< or CHI feature2 level using overridesettings or vendor tags.
    BIT                     enableExpressionDetection:1;        ///< Enable/Disable facial expression detection
                                                                ///< Valid only when FD is enabled
                                                                ///< TRUE  - Enable facial expression detection
                                                                ///< FALSE - Disable
    BIT                     enableExternalSensorModule:1;       ///< Enables/Disables external sensor module
    BIT                     enableFCG:1;                        ///< Enable Flicker Gain Correction IQ Module
    BIT                     enableFDDynamicInputPortDisable:1;  ///< Dynamic input port disablement
                                                                ///< TRUE  - Enable dynamic input port
                                                                ///< FALSE - Disable
    BIT                     enableFDFullStreamDimension:1;      ///< Enable setting of FD full stream dimension
    BIT                     enableFDManagerThreading:1;         ///< Enable/Disable FD Manager threading
    BIT                     enableFDSpecificToneMapping:1;      ///< Set tuning type feature1 to FDProcess if enabled
                                                                ///< TRUE:   Read tuning with feature1 = FDProcess
                                                                ///< FALSE:  Fallback to the default tuning type
    BIT                     enableFPSLog:1;                     ///< Enables printing of FPS to logs
    BIT                     enableFWColorSpace:1;               ///< Setting to enable new API for color space profiles.
    BIT                     enableFastShutter:1;                ///< Settings to enable fast shutter mode
    BIT                     enableFastZoomOut:1;                ///< Indicates if fast zoom out is enabled
    BIT                     enableFlashDebug:1;                 ///< Bypass 3A block so flash always fire base on the captureIntent from application
    BIT                     enableFrameworkHDR10P:1;            ///< Settings to enable new API for HDR10P.
    BIT                     enableFwkDump:1;                    ///< Enable/Disable framework core dump
    BIT                     enableGBDetection:1;                ///< Enable/Disable gaze and blink detection
                                                                ///< Valid only when FD and facial parts detection are enabled
                                                                ///< TRUE  - Enable gaze and blink detection
                                                                ///< FALSE - Disable
    BIT                     enableGTMChannelToggle:1;           ///< Enable Color Channel Toggling for AECBhist and GTMBhist
    BIT                     enableGenderDetection:1;            ///< Enable/Disable face Gender detection
                                                                ///< Valid only when FD is enabled
                                                                ///< TRUE  - Enable facial Gender detection
                                                                ///< FALSE - Disable
    BIT                     enableHALAPITimer:1;                ///< Enable/Disable timer for HAL APIs
    BIT                     enableHALFormatOverride:1;          ///< Enable/Disable HAL format override
    BIT                     enableHDR10PlibLogs:1;              ///< Enable/Disable HDR10+ Library Logs
    BIT                     enableHDRMaxResolutionCheck:1;      ///< Enable/Disable HDR Max Resolution Check
    BIT                     enableHJAF:1;                       ///< Enable HJ AF
    BIT                     enableHWMFHDRSnapshot:1;            ///< Enable HWMFHDR Snapshot by this setting.
                                                                ///< TRUE  - enable  HWMFHDR Snapshot
                                                                ///< FALSE - disable HWMFHDR Snapshot
    BIT                     enableHealthMonitor:1;              ///< Enable the monitoring of jobs in camX and CHI
    BIT                     enableHwBinary:1;                   ///< Enable Hardware Binary framework
    BIT                     enableHwBinaryDump:1;               ///< Enable Hardware Binary framework data dump
    BIT                     enableIFHPatternGeneration:1;       ///< Enable and disable IFH output pattern generation
    BIT                     enableImageBufferLateBinding:1;     ///< Wheter to enable late bind of memory/buffers to ImageBuffer
    BIT                     enableInSensorZoom:1;               ///< Settings to enable In sensor Zoom
    BIT                     enableInSensorZoomForOnlyPhysicalStream:1; ///< Settings to enable in sensor zoom in only physical stream case.
    BIT                     enableInitDepBatchProcessing:1;     ///< Enable initial dependency (sequence 0) batch processing 
    BIT                     enableInitRegDump:1;                ///< This is used to dump only the init frame
    BIT                     enableInternalHALPixelStreamConfig:1; ///< Enables/Disables Internal HAL Pixel Stream Configuration
    BIT                     enableLRMEDS2:1;                    ///< Enable LRME DS2 link.  FALSE to disable, TRUE to enable
    BIT                     enableLegacyStopRecording:1;        ///< Flag to indicate if Legacy stop recording is enabled.
    BIT                     enableLensSagComp:1;                ///< Enable Lens Sag Compensation
    BIT                     enableLinearMetaLUT:1;              ///< Enable linear LUT for metadata operations
    BIT                     enableMCTF:1;                       ///< This is to enable LRME/Ransac dependancies for MCTF
    BIT                     enableMCXHardTransition:1;          ///< Enable/Disable Multicamera hard transition
    BIT                     enableMFLOEMCustomization:1;        ///< OEM can customize some special functions in MFL
    BIT                     enableMLAWBSnapshot:1;              ///< Picks Feature Graph with ML AWB feature for snapshot processing
    BIT                     enableMLInference:1;                ///< Enable/Disable MLInference
    BIT                     enableMPMMonitorThread:1;           ///< Whether to enable Memory Pool Manager monitor thread
    BIT                     enableMPMStatelogging:1;            ///< Whether to enable more debug logging printing state of Buffers, Buffer Managers, Groups
                                                                ///< at different stages of their lifecycle.
    BIT                     enableMapBufferOptimization:1;      ///< Enable map buffer optimization
    BIT                     enableMaskDetection:1;              ///< Enable/Disable face mask detection
                                                                ///< Valid only when FD are enabled
                                                                ///< TRUE  - Enable face mask detection. This is to enable FD Engine
                                                                ///< post-processing and result-publishing to internal pool.
                                                                ///< App needs to set a session parameter in addition to the
                                                                ///< static setting to enable result-publishing to vendor tag and access the results.
                                                                ///< FALSE - Disable face mask detection.
                                                                ///< All-zero results would be published to internal pool, and no results to vendor tag.
    BIT                     enableMemoryStats:1;                ///< When enabled, memory statistics are tracked and printed for CmdBuffers, Memory Pool Manager
    BIT                     enableMinimumStartupExposure:1;     ///< Use minimum startup exposure time to get the first valid frame earlier
    BIT                     enableNCSDataDump:1;                ///< Enables/Disable NCS data dump
    BIT                     enableNCSOFD:1;                     ///< True means enabling offline dependencies
                                                                ///< False means disabling offline dependencies
    BIT                     enableNCSOFDImageDump:1;            ///< True means enabling offline dependencies Image Dumping
                                                                ///< False means disabling offline dependencies Image Dumping
    BIT                     enableNCSQSEE2:1;                   ///< True means using QSEE2
                                                                ///< False means using QSEE1
    BIT                     enableNCSService:1;                 ///< Enables/Disable NCS service
    BIT                     enableNativeHEIF:1;                 ///< Enable/Disable native HEIF
    BIT                     enableNonHDRAEBSnapshot:1;          ///< A setting to allow testing of NonHDR Snapshot AEB
    BIT                     enableOISOptimization:1;            ///<  Enable OIS Optimization
    BIT                     enableOfflineFD:1;                  ///< Enable/Disable offline FD processing
    BIT                     enableOfflineFS:1;                  ///< Enable SFE for offline FS
    BIT                     enableOfflineIFE:1;                 ///< Enable Offline IFE by this setting.
    BIT                     enableP3HDRModes:1;                 ///< Enables HDR modes for P3 color space
    BIT                     enablePDAFConfigurationChecks:1;    ///< Enables PDAF Mode Configuration Checks
    BIT                     enablePDLibProfiling:1;             ///< Enable/Disable PD Library Profiling
    BIT                     enablePDNet:1;                      ///< Enable/Disable PDNet node
    BIT                     enablePDNetProfile:1;               ///< Enable profiling for PDNet algos
    BIT                     enablePN9PatternTest:1;             ///< Enable PN9 Pattern Test
    BIT                     enableParallelPipelineDeactivate:1; ///< Deactivate pipelines in parallel for MCX Preview
    BIT                     enablePerFrameDRVUpdate:1;          ///< This is used to send configure DRV Module per frame
    BIT                     enablePerRequestSync:1;             ///< Enable Sync on a Per Frame Basis
    BIT                     enablePeripheralService:1;          ///< Enables/Disable Peripheral service
    BIT                     enablePipelineFlush:1;              ///< Flush a given pipeline in the Session
    BIT                     enablePopulateRequestCropInfo:1;    ///< Enable/Disable to populate PSM stream crop info with ancestor stream crop info
    BIT                     enablePreviewCBInMultiPreview:1;    ///< A setting to link PreviewCB port to MCReprocRT
    BIT                     enablePreviewLTMDCStatsUsageOPE:1;  ///< Used to control use of Preview OPE LTMDC stats in RT/NRT pipelines
    BIT                     enablePublishProjectedFDResults:1;  ///< Override FD frame skip logic
                                                                ///< TRUE:   Enable publish projected results
                                                                ///< FALSE:  Disable publish projected results
    BIT                     enableQLLProcessing:1;              ///< Enable/disable QLL(low light) algo processing
    BIT                     enableQSAT:1;                       ///< Enable/Disable QSAT
    BIT                     enableQTimer:1;                     ///< Enable/Disable QTimer for SOF timestamps
    BIT                     enableRAWProcessing:1;              ///< Enables/Disables RAW Processing
    BIT                     enableRDIPorts:1;                   ///< Enable AF and IFE RDIRaw and RDIPDAF ports
    BIT                     enableResolutionUpscale:1;          ///< Enable/Disable resolution upscale.
                                                                ///< 0 for FALSE, Disable
                                                                ///< 1 for TRUE, Enable
    BIT                     enableSALINet:1;                    ///< Enable/Disable salinet node
    BIT                     enableSALINetProfile:1;             ///< Enable profiling for SALINet algos
    BIT                     enableSATAlgoMasterSwitch:1;        ///< Master Switch can be controlled in two ways. One way is
                                                                ///< based on SAT algorithm output and second way is from the
                                                                ///< multi camera xml file.
                                                                ///< TRUE  - switch master camera based on SAT algorithm
                                                                ///< FALSE - switch master camera based on multi camera xml file
    BIT                     enableSHDR1ExpInlineSFE:1;          ///< SFE Raw will be used for SHDR 1 exp usecase
    BIT                     enableSHDRawOutSFE:1;               ///< SFE Raw will be used for SHDR usecase
    BIT                     enableSPD:1;                        ///< Disable Spotlight Detection
    BIT                     enableSWMFHDR:1;                    ///< Enable SWMFHDR by this setting.
                                                                ///< TRUE  - SWMFHDR enable
                                                                ///< FALSE - SWMFHDR disable
    BIT                     enableSWMLRemosaic:1;               ///< This setting is used to force enable SWMLRemosaic
    BIT                     enableSWPDPC:1;                     ///< PDPC node enable for PDAF sensor
    BIT                     enableScreenGrab:1;                 ///< Enable/Disable Screengrab, Use video stream for live snapshots
    BIT                     enableSelectiveRecovery:1;          ///< Enable Selective Pipeline/Session/Feature Recovery
    BIT                     enableSensorAcquireOptimization:1;  ///< Enables optimization during sensor acquire by offloading the call
    BIT                     enableSensorBitSwitch:1;            ///< enable sensor bit switch
    BIT                     enableSensorCaching:1;              ///<  Enable Sensor Handle Caching
    BIT                     enableSensorEmulation:1;            ///< Enables/Disables sensor emulation
    BIT                     enableShadingCorrection:1;          ///< Enable stats in B2Y
    BIT                     enableSignal35Tombstone:1;          ///< Enable Signal 35 Tombstone without process crash for Callstacks
    BIT                     enableSingleExposureAEBSwitching:1; ///< Single exposure applied for non-master AEB cameras when switching
    BIT                     enableSnapshotAEBTesting:1;         ///< A setting to allow testing of Snapshot AEB
    BIT                     enableSnapshotOnlyInSensorZoom:1;   ///< Settings to enable Snapshot Only In sensor Zoom.
                                                                ///< Need to enable both enableInSensorZoom and enableSnapshotOnlyInSensorZoom.
    BIT                     enableSpectralSensor:1;             ///< Enables/Disable Spectral Sensor
    BIT                     enableStatsExposureSetting:1;       ///< Enable setting exposure settings from 3A for debugging purpose
    BIT                     enableStreamCropZoom:1;             ///< Enable/Disable zoom to use PSM stream crop info
    BIT                     enableSwCac:1;                      ///< Enable swcac feature
                                                                ///< FALSE: swcac  Disable
                                                                ///< TRUE : swcac  Enable
    BIT                     enableSwCacBloomFilter:1;           ///< Enable CAC with BloomFilter
                                                                ///< FALSE: Disable bloomfilter
                                                                ///< TRUE : Enable bloomfilter
    BIT                     enableSwCacVersion4:1;              ///< Enable CAC version 4.0 feature
                                                                ///< FALSE: Disable cac4 and call cac3
                                                                ///< TRUE : Enable cac4
    BIT                     enableSynxCrossNodePropagation:1;   ///< Enable synx fence propogation from output port of a node to input port of "source" nodes
    BIT                     enableTOFInterface:1;               ///< Enables/Disable TOF interface
    BIT                     enableTPG:1;                        ///< Enables/Disables IFE or CSID TPG
    BIT                     enableTPGProbe:1;                   ///< Enables/Disables TPG probe
    BIT                     enableThermalMitigation:1;          ///< Enables/Disable thermal mitigation
    BIT                     enableThumbRetry:1;                 ///< JPEG Thumbnail Retry Enable
    BIT                     enableTouchToTrack:1;               ///< Enable Touch to Track feature
    BIT                     enableTuningMetadata:1;             ///< General switch to enable tuning data dump. See size settings to set a new size or use default.
    BIT                     enableTuningStreamConfigDump:1;     ///< Enable live tuning dump
    BIT                     enableUBWCNV124ROnIFEFullOutIPELink:1; ///< When enabled, will always use UBWCNV124R (8 bit) on IFE FullOut --> IPE link
    BIT                     enableUpdateTransitionTableDynamically:1; ///< Update transition table at configure stage
    BIT                     enableUpperBodyDetection:1;         ///< Enable/Disable upper body detection
                                                                ///< Valid only when FD are enabled
                                                                ///< TRUE  - Enable upper body detection. This is to enable FD Engine
                                                                ///< post-processing and result-publishing to internal pool.
                                                                ///< App needs to set a session parameter in addition to the
                                                                ///< static setting to enable result-publishing to vendor tag and access the results.
                                                                ///< FALSE - Disable upper body detection.
                                                                ///< All-zero results would be published to internal pool, and no results to vendor tag.
    BIT                     enableVBSEBasedVideoBokeh:1;        ///< Enable/Disable VBSE Video Bokeh
    BIT                     enableVIULLPlus:1;                  ///< Enable/disable VIULL(low light) algo processing
    BIT                     enableVIULLProcessing:1;            ///< Enable/disable VIULL(low light) algo processing
    BIT                     enableVideoRetouch:1;               ///< This setting is used to force enable video retouch
    BIT                     enablechirecovery:1;                ///< Trigger Chi Recovery for any incomplete URO in CHI
    BIT                     enabledMultiCameraZSLOffForAux:1;   ///< Enable ZSL Off for Aux
    BIT                     enablepGeolibOffCenterZoom:1;       ///< enable offcenter zoom in geolib
    BIT                     exportSecureCamera:1;               ///< Export the secure camera for IR camera application
    BIT                     exposeRecommendedConfig:1;          ///< Use to expose recommended stream configuration as capabilities
    BIT                     exposeSHDRRAWSize:1;                ///< Expose SHDR RAW size
    BIT                     extendedTimeForLongExposure:1;      ///< Enable/Disable extended timeout for Long Exposure
    BIT                     fastFDMetadata:1;                   ///< Determine when the FD metadata is returned
                                                                ///< TRUE  - Return metadata after IFE completes hw submission
                                                                ///< FALSE - Defer to the point when buffers return for the request
    BIT                     force3ALockedResult:1;              ///< Always returns locked in results, regardless of the actual algo state
    BIT                     forceDisableUBWCOnIfeIpeLink:1;     ///< When enabled, YUV420NV12 will replace UBWC and be the primary format on IFE's and Chi node's output
    BIT                     forceQLLTriggered:1;                ///< Enable/disable force QLL(low light) algo processing
    BIT                     forceRaw16FormatForRDIPort:1;       ///< force Raw16 format for RDI port
    BIT                     getAccelInfoUsingVendorTag:1;       ///< Get Accelerometer info using vendor tag
    BIT                     ifeSWCDMEnable:1;                   ///< Enables SW CDM for IFE
    BIT                     ignoreEVATAloadingForSecureCase:1;  ///< In secure usecase, if TA loading is failed return success.
                                                                ///< As FD is part of pipeline, for secure FD to work, need to copy EVA TA from vendor/firmware_mnt_image to
                                                                ///< vendor/firmware. If FD is off, there is need for OME's to follow these steps, but TA loading will fail.
                                                                ///< So ignore TA loading status and return Success. EPR will take care of actual error handling.
    BIT                     ignoreSceneMode:1;                  ///< If true, InputControlSceneMode is ignored, and scene mode is reported as disabled
    BIT                     ignoreSensorSubModuleFail:1;        ///< Enables/Disables ignoring sensor sub module creation fail, if enabled, sensor initialization will move on.
                                                                ///< Ignored modules are Actuator, OIS, Flash.
    BIT                     inSensorSHDRMode:1;                 ///< Enable if sensor supports insensor SHDR
    BIT                     induceDelayIFENodeDestroy:1;        ///< Induce delay if True
    BIT                     inputDumpOnOutputFenceError:1;      ///< Dumps reprocess input image and metadata when fence error is received
    BIT                     isSHDRFusionOffline:1;              ///< SHDR HW PreviewVideo Fusion is offline or not
    BIT                     isSkipStatsNZSLSnapshot:1;          ///< Is skip stats in ZSL snapshot
    BIT                     isWarpOnPostIPE:1;                  ///< Is warping on post IPE
    BIT                     kpiDebug:1;                         ///< Enable/Disable Systrace Logs
    BIT                     logDRQEnable:1;                     ///< Enable DRQ logging
    BIT                     logMetaEnable:1;                    ///< Enable Metadata logging
    BIT                     logRequestMapping:1;                ///< Write request mappings to the log
    BIT                     manualBlurConfig:1;                 ///< manually set blur configuration if enable this setting
    BIT                     manualExposureType:1;               ///< Enable/Disable Manual Exposure Control
    BIT                     manualWhiteBalanceType:1;           ///< Enable/Disable Manual White Balance Control
    BIT                     metadataDumpDuringSystemEvents:1;   ///< Dumps metadata for all outstanding request in the pipeline Every metadata dump costs 2 seconds
    BIT                     multiCameraDetectFrameSync:1;       ///< Enable frame sync status detection by this setting.
    BIT                     multiCameraEnable:1;                ///< Enable/Disable multi camera framework with Back Aux camera
    BIT                     multiCameraEnableFront:1;           ///< Enable/Disable multi camera framework with Front Main camera
    BIT                     multiCameraExposureTimeMatch:1;     ///< This is a sub setting for FPS match, we will use same exposure time
                                                                ///< for the multi cameras if this setting is TRUE.
    BIT                     mwEnable:1;                         ///< Enable/Disable Multi-window PDAF
    BIT                     offlineFDSupport:1;                 ///< FD node is in offline pipeline
    BIT                     offlineImageDumpOnly:1;             ///< Dumps offline processing output images for all enabled nodes. This will run extremely slow
    BIT                     overrideCameraCoreDumpLogging:1;    ///< Flag to disable entire camera core dump
    BIT                     overrideEnableVSR:1;                ///< Used to override App enabled VSR option
    BIT                     overrideForceEISSupport:1;          ///< this setting helps to forcely enable EIS regardless of any target-based mitigations
    BIT                     overrideForceFDRendering:1;         ///< this setting helps to forcely enable FD rendering in UI
    BIT                     overrideForceFSCapable:1;           ///< Mark the sensor as FS capable inspite of having no explicit FS mode
    BIT                     overrideForceFullSizeLiveshot:1;    ///< this setting helps to force full size liveshot regardless of any target-based mitigations
    BIT                     overrideForceLiveshot:1;            ///< this setting helps to forcely enable liveshot regardless of any target-based mitigations
    BIT                     perFrameSensorMode:1;               ///< Update the sensor mode index per frame
    BIT                     raiserecoverysigabrt:1;             ///< Raise recovery sigabrt for debug builds to track critical failures
    BIT                     raisesigabrt:1;                     ///< Raise sigabrt for debug builds to track critical failures
    BIT                     reprocessDump:1;                    ///< Dumps reprocess input image and metadata
    BIT                     sessionDumpForFlush:1;              ///< Dumps session info if in error state at Flush
    BIT                     skipSBMOneBufferRequest:1;          ///< Enable/Disable Skip SBM one buffer request
    BIT                     spotlightFallbackToCAF:1;           ///< Enable/Disable Fallback to Contrast AF for Spotlight Scene
    BIT                     systemLogEnable:1;                  ///< Controls if CamX logs are output to the system logging mechanism
    BIT                     tfeSWCDMEnable:1;                   ///< Enables SW CDM for TFE
    BIT                     throttleRequestForLookAheadNodes:1; ///< Throttle requests for look ahead nodes to optimize buffer consumption
    BIT                     tintlessEnable:1;                   ///< Enables tintless algorithm
    BIT                     traceErrorEnable:1;                 ///< Enable error logging in trace logs
    BIT                     useAlternateFrameSkip:1;            ///< FD frame skip
    BIT                     useDefaultFrameDurationForDRV:1;    ///< This is used to calculate DRV timeout based on default frame duration
    BIT                     useDeviceOrientationInFD:1;         ///< Use device orienation to improve FD
    BIT                     useDifferentTuningForFrontCamera:1; ///< Enable/Disable different tuning for front camera for processing
    BIT                     useFDInternalBuffers:1;             ///< Enable/Disable using internal buffers and copy frames for processing
    BIT                     useFDUseCasePool:1;                 ///< Use UseCase Pool for FD data
    BIT                     useVFETPG:1;                        ///< Use VFE_TPG: Valid for presil test modes (CSIM against RUMI)
    BIT                     validateImageBufferUsageState:1;    ///< Check whether ImageBuffer object is in a state where clients can access it legally
    BIT                     watermarkImage:1;                   ///< Watermark request id onto frame. Only support YUV format
    CHAR                    CamXFL115Indices[MaxStringLength];  ///< Binary configuration file of point indices for 115-point DLFL face contour
    CHAR                    CamXFL300v1Indices[MaxStringLength]; ///< Binary configuration file of point indices for 300-point v1 DLFL face contour
    CHAR                    CamXFL300v2Indices[MaxStringLength]; ///< Binary configuration file of point indices for 300-point v2 DLFL face contour
    CHAR                    CustomCapResolution[MaxStringLength]; ///< Add custom resolution to the static caps.
                                                                ///< example:- 2000X1500, 3000X2500
    CHAR                    FDConfigPreviewBin[MaxStringLength]; ///< Binary file for FD preview configuration
    CHAR                    FDConfigSecureBin[MaxStringLength]; ///< Binary file for FD secure mode configuration
    CHAR                    FDConfigVideoBin[MaxStringLength];  ///< Binary bin file for FD video configuration
    CHAR                    FLCustomContourPointBin[MaxStringLength]; ///< Binary configuration file of point indices for custom DLFL face contour
    CHAR                    accelVendorTagName[MaxStringLength]; ///< Vendor tag to read accelerometer information
    CHAR                    accelVendorTagSection[MaxStringLength]; ///< Vendor tag to read accelerometer information
    CHAR                    activeNodeMask[MaxStringLength];    ///< Used to create debug probes for active node mask
                                                                ///< String value for this property should be Active Node names delimited
                                                                ///< with any delimiter or none to enable corresponding Node logs. Default is ""
                                                                ///< Ex: 1. PDAF: Create debug probe for PDAF Node
                                                                ///< 2. TOF: Create debug probe for TOF Node
                                                                ///< 3. CAF: Create debug probe for CAF Node
                                                                ///< 4. FOLLOWER: Create debug probe for FOLLOWER Node
                                                                ///< 5. MAIN: Create debug probe for algo
    CHAR                    customAlgoAECName[MaxStringLength]; ///< Custom AEC Algo library name
    CHAR                    customAlgoAECPath[MaxStringLength]; ///< Custom AEC Algo library path
    CHAR                    customAlgoAFDName[MaxStringLength]; ///< Custom AFD Algo Library Name
    CHAR                    customAlgoAFDPath[MaxStringLength]; ///< Custom AFD Algo Library Path
    CHAR                    customAlgoAFName[MaxStringLength];  ///< Custom AF Algo library name
    CHAR                    customAlgoAFPath[MaxStringLength];  ///< Custom AF Algo Library path
    CHAR                    customAlgoASDName[MaxStringLength]; ///< Custom ASD Algo Library Name
    CHAR                    customAlgoASDPath[MaxStringLength]; ///< Custom ASD Algo Library Path
    CHAR                    customAlgoAWBName[MaxStringLength]; ///< Custom AWB Algo library name
    CHAR                    customAlgoAWBPath[MaxStringLength]; ///< Custom AWB Algo Library path
    CHAR                    customHAFAlgoName[MaxStringLength]; ///< Custom HAF Algo library name
    CHAR                    customHAFAlgoPath[MaxStringLength]; ///< Custom HAF Algo Library path
    CHAR                    customPDLibName[MaxStringLength];   ///< Custom PD library name
    CHAR                    customPDLibPath[MaxStringLength];   ///< Custom PD Library path
    CHAR                    customTOFSensorLib[MaxStringLength]; ///< TOF sensor default library
                                                                ///< Update the lib path in DefaultValue section below
                                                                ///< e.g. /system/lib/sensors.hal.tof.so
    CHAR                    debugBufferRegDumpFileNamePrefix[MaxStringLength]; ///< Name of the register dump file
    CHAR                    debugDataHeaderString[MaxStringLength]; ///< Set header string needed by parser to know the type of debug data
    CHAR                    debugLogFilename[MaxStringLength];  ///< Controls if CamX logs are output to the filename provided (NULL to disable)
    CHAR                    disableStatsPorts[MaxStringLength]; ///< Mask Format: bitX.........bit1.bit0
                                                                ///< Each bit corresponds to ISPStatsType Enum defined in chiispstatsdefs.h
                                                                ///< To Disable a StatsType port from IFE to [AF, AWB, Stats, StatsParse] nodes
                                                                ///< make the bit 0. e.g. To disable ISPStatsTypeBF(value 1) mask is "01" in binary
                                                                ///< To disable ISPStatsTypeShortAECBHist(value 63) mask will be
                                                                ///< "0(followed by 62 '1's)"
    CHAR                    dualLEDCalibrationPath[MaxStringLength]; ///< Location of the dual LED calibration output file
    CHAR                    inducerFeatureGraphName[MaxStringLength]; ///< Which Feature Graph need to be trigger by inducer
                                                                ///< Note: FeatureGraphName is optional. If graph name is not provided, then
                                                                ///< it will induce error in the selected graph for that requestId.
    CHAR                    inducerFeatureName[MaxStringLength]; ///< Which Feature need to be trigger by inducer
                                                                ///< Note: FeatureName is optional. If feature name is not provided, then it
                                                                ///< will induce error in all the features of that requestId.
    CHAR                    inducerFeaturePortName[MaxStringLength]; ///< Which Feature Port need to be trigger by inducer. This settings is only
                                                                ///< valid for buffer error and we can skip this for metadata and request errors.
                                                                ///< Note: Port name is optional. If port name is not provided, then it will induce
                                                                ///< error for all the output ports.
    CHAR                    inducerNodeName[MaxStringLength];   ///< Which node need to be trigger by inducer. For Metadata and request
                                                                ///< errors we can skip this setting as they are induced at pipeline level.
                                                                ///< The string format for node name will be "Nodename + InstanceId"
                                                                ///< For example : "IPE2"
                                                                ///< Note: NodeName is optional. If node name is not provided, it will
                                                                ///< induce error for all nodes in the pipeline.
    CHAR                    inducerPipelineName[MaxStringLength]; ///< Which pipeline need to be trigger by inducer
                                                                ///< Note: PipelineName is optional. If pipeline name is not provided,
                                                                ///< it will induce error for all piplines in that request
    CHAR                    inducerSystemEventErrorCodes[MaxStringLength]; ///< Inducer will trigger for these error codes. Each error code is associated with node/pipeline/session/requestId
                                                                ///< positionally, i.e:
                                                                ///< CamxResultEInducedErrorBase1(1st error code), CamxResultEInducedErrorBase6(2nd error code)
                                                                ///< 1st session, 2nd session
                                                                ///< 1st node, 2nd Node
                                                                ///< ...
                                                                ///< Note: Error Code takes precedence over request id (over session/pipeline/node)
    CHAR                    inducerSystemEventNodeName[MaxStringLength]; ///< Which node need to be trigger by inducer. For Metadata and request
                                                                ///< errors we can skip this setting as they are induced at pipeline level.
                                                                ///< The string format for node name will be "Nodename + InstanceId"
                                                                ///< For example : "IPE2"
                                                                ///< Note: NodeName is optional. If node name is not provided, it will
                                                                ///< induce error for all nodes in the pipeline.
    CHAR                    inducerSystemEventPipelineName[MaxStringLength]; ///< Which pipeline need to be trigger by inducer
    CHAR                    inducerSystemEventRequestId[MaxStringLength]; ///< For this reqId will trigger inducer
    CHAR                    inducerSystemEventSessionName[MaxStringLength]; ///< The session needed to be trigger by inducer
    CHAR                    multiCameraLogicalXMLFile[MaxStringLength]; ///< Use this xml file when building the logical cam info. This must exist under
                                                                ///< chi-cdk/oem/qcom/multicamera/logical_cam_info/TARGET_BOARD_PLATFORM_
    CHAR                    pDebugProcess[MaxStringLength];     ///< Debug settings are only applied to the given process (no process by default)
    CHAR                    sensorEmulatorPath[MaxStringLength]; ///< Sensor emulator application path
    CHAR                    sensorEmulator[MaxStringLength];    ///< Sensor emulator application name
    CHAR                    vmDebugMask[MaxStringLength];       ///< Used to control VM logs for visualizing VM using tool
                                                                ///< String value for this property should be "ALL" or VM topology names delimited
                                                                ///< with ',' to enable corresponding topology's VM logs. Default is ""
                                                                ///< Ex: 1. PDAF: Enables VM logs only under PDAF topology
                                                                ///< 2. CAF,PDAF: Enables VM logs under CAF and PDAF
                                                                ///< 3. FD,PDAF,ToF : Enables VM logs for FD, PDAF and ToF topologies
                                                                ///< 4. ALL : Enable VM logs under all topologies
    CHAR                    watermarkOffset[MaxStringLength];   ///< Pass the x and y offsets to offset the location of the watermark.
                                                                ///< Example to offset x position by 40 and y position by 220:
                                                                ///< 40x220
    CHIPartialDataType      enableCHIPartialData;               ///< Enable Partial Data Support from CHI:
                                                                ///< CHIPartialDataDisable for no CHI Partial Data,
                                                                ///< CHIPartialDataSeparate to send CHI Partial Data independently,
                                                                ///< CHIPartialDataCombined to send it along with Core Driver.
    CSLCameraFamilyType     IFHPlaformFamily;                   ///< Platform family from CSLQueryCameraPlatformIFH
    CSLModeType             CSLMode;                            ///< Selects run-time CSL mode
    DepthSWFrameSyncType    DepthSWFrameSyncType;               ///< Indicat the type of depth SW frame sync.
                                                                ///< DepthSOESync        - SOE timestamp as reference point
                                                                ///< DepthSOFSync        - SOF timestamp as reference point
                                                                ///< DepthMidOfFrameSync - MidOfFrame timestamp as reference point
    DualLEDCalibrationType  dualLEDCalibrationMode;             ///< Enables/Disables Dual LED Calibration or Tuning
    EnableAFAlgoType        enableAFAlgo;                       ///< Override Tuning Enabled Algorithm,
                                                                ///< Disabled: No Override,
                                                                ///< PDAF:     Enable only PDAF,
                                                                ///< TOF:      Enable only TOF,
                                                                ///< DCIAF:    Enable only DCIAF,
                                                                ///< CAF:      Enabled only CAF
    FDBaseResolutionType    FDBaseResolution;                   ///< Select one of the following base resolutions
                                                                ///< 640x480,
                                                                ///< 854x480,
                                                                ///< 320x240,
                                                                ///< 427x240,
                                                                ///< 384x288
    FDClientType            FDClient;                           ///< Override to control FD client type
                                                                ///< FDHWHybrid        : Use HW Hybrid FD as client type
                                                                ///< FDSWOnly          : Use SW FD only as client type
                                                                ///< FDDLDSP           : Use DL FD as client type
                                                                ///< FDDLCPU           : Use FD DL as client type, CPU based
                                                                ///< FDUsecaseDependent: Use HW EVA FD or SW DL FD as FD client type based on usecase
    FDConfigSourceType      FDConfigSource;                     ///< Override to control source for FD configuration,
                                                                ///< Default:   Default config populated by driver
                                                                ///< VendorTag: Config fetched from vendor tag
                                                                ///< Binary:    Config fetched from tuning binary
    FDFLType                FDFLSolution;                       ///< Override to control source for FD FL
                                                                ///< EVAFL: EVA HW landmark based solution
                                                                ///< DLFL:  DL landmark based Solution
    FDMaxFPSSetting         FDMaxFPS;                           ///< Override FD max frame rate setting in FD configuration
                                                                ///< NoForce:       Use max frame rate setting in FD configuration
                                                                ///< Force15FPS:    Force 15FPS max frame rate
                                                                ///< Force30FPS:    Force 30FPS max frame rate
    FDMinFaceSizeSetting    FDMinFaceSize;                      ///< Override FD min face size setting in FD configuration
                                                                ///< MinFaceSizeNone:  Use min face size setting in FD configuration
                                                                ///< MinFaceSize20x20: Set min face size to 20x20
                                                                ///< MinFaceSize25x25: Set min face size to 25x25
                                                                ///< MinFaceSize32x32: Set min face size to 32x32
                                                                ///< MinFaceSize40x40: Set min face size to 40x40
    FDMultiCamProcessingType FDMultiCamProcess;                 ///< Criteria to select which camera to run when both running,
                                                                ///< ProcessMasterOnly: Process only master requests at full fps
                                                                ///< ProcessAuxOnly:    Process only aux requests at full fps
                                                                ///< ProcessBoth:       Process both master and aux at half fps
    FDProcessingControlType FDProcessingControl;                ///< Override to control FD processing,
                                                                ///< ForceDisable:   Force disable FD processing eventhough App requests for processing. Android tests will fail
                                                                ///< ForceEnable:    Force enbale FD processing eventhough App doesn't enable FD. Android tests still pass
                                                                ///< AutoEnable:     Enbale FD processing in auto control mode even though App doesn't request. Android tests still pass
                                                                ///< AppRequest:     Enable/Disable based on App request. Android tests pass
    FLOAT                   ADRCGainThresholdForAIDenoiser;     ///< ADRC Gain Threshold for SWMF+AIDenoiser Feature
    FLOAT                   AECGainThresholdForOfflineIFE;      ///< AEC Gain Threshold for OfflineIFE Feature
    FLOAT                   AECGainThresholdForQCFA;            ///< AEC Gain Threshold for Quad CFA Feature
    FLOAT                   BGain;                              ///< Value of White Balance B Gain
    FLOAT                   DRCGainThresholdForSWTLBEStatsGen;  ///< If DRC Gain is higher that this threshold, Tintless BE stats are generated from SW ALgo for snapshot
    FLOAT                   EISHeightMargin;                    ///< Request margins on the height in percentage (Eg. 0.1 for 10%)
    FLOAT                   EISHorizonLevelMaxDeg;              ///< Set EIS Horizon Leveling max degree
    FLOAT                   EISV2Margin;                        ///< Set EIS V2 Margin
    FLOAT                   EISV3Margin;                        ///< Set EIS V3 Margin
    FLOAT                   EISWidthMargin;                     ///< Request margins in float on the width in percentage (Eg. 0.2 for 20%)
    FLOAT                   SFEAlignmentMargin;                 ///< SFEAlignment Margin
    FLOAT                   TOFSensorSamplingRate;              ///< Sampling rate for TOF sensor in hertz
    FLOAT                   aecGainThresholdForCDS;             ///< AEC Gain Threshold for Bayer2YUV+CDS Feature
    FLOAT                   exposureGain;                       ///< Value of Exposure Gain
    FLOAT                   extendedMaxZoomRatio;               ///< Indicates the extended max zoomratio
    FLOAT                   gGain;                              ///< Value of White Balance G Gain
    FLOAT                   gain;                               ///< Sensor Gain
    FLOAT                   gravitySensorSamplingRate;          ///< Sampling rate for gravity sensor in hertz
    FLOAT                   gyroSensorSamplingRate;             ///< Sampling rate for gyro sensor in hertz
    FLOAT                   luxIndex;                           ///< Value of Lux Index
    FLOAT                   luxIndexThresholdForAIDenoiser;     ///< Lux Index Threshold for SWMF+AIDenoiser Feature
    FLOAT                   luxThresholdForTintless;            ///< Percentage difference lux threshold value to
                                                                ///< override the skipping of alternate frame during
                                                                ///< tintless processing.
    FLOAT                   maxStatsFps;                        ///< The maximal frame rate that stats/3A could run.
    FLOAT                   middleGain;                         ///< camera sensor middle gain
    FLOAT                   predictiveGain;                     ///< Value of Predictive Gain
    FLOAT                   predictiveGainSFE;                  ///< Value of Predictive Gain
    FLOAT                   rGain;                              ///< Value of White Balance R Gain
    FLOAT                   shortGain;                          ///< camera sensor short gain
    INT                     EISHorizonLevelEnable;              ///< Set EIS Horizon Leveling
    INT                     EISOISMode;                         ///< Override algorithm's ois_mode output. If 0 then doesn't override (uses algorithm's ois_mode).
    INT                     EISv2OperationMode;                 ///< Flag for default grid/transform
    INT                     EISv3OperationMode;                 ///< Calibration mode
    INT                     SensorTypeTof;                      ///< The value represents the TOF (Time of folight) sensor type
                                                                ///< and should be the same as the sensor type set in sensor_t object of TOF sensor
                                                                ///< If the sensor is changed, update the value through the camx override setting
    INT                     camVersionOverride;                 ///< Camera HW version override useful for testing purpose
    INT                     inducerFROProcessSeqId;             ///< Which FRO process sequence Id need to be trigger by inducer
                                                                ///< Note: Process SeqId is optional. If sequence id is not provided, then it
                                                                ///< will induce error for all the process seqId.
    INT                     inducerPortId;                      ///< Which port need to be trigger by inducer. For Metadata and request
                                                                ///< errors we can skip this setting as they are induced at pipeline level.
                                                                ///< Note: PortId is optional. If portId is not provided, it will induce
                                                                ///< error for all output ports in the node.
    INT                     inducerSystemEventPortId;           ///< Which port need to be trigger by inducer.
                                                                ///< Note: PortId is optional. If portId is not provided, it will induce
                                                                ///< error for all output ports in the node.
    INT                     maxSHDRSnapshotFPS;                 ///< Max FPS support for SHDR snapshot
    INT                     remosaicType;                       ///< -1 = UnKnown
                                                                ///< 0  = SW Remosaic
                                                                ///< 1  = HW Remosaic
                                                                ///< 2  = No/SFE Remosaic
    INT                     singleIFESupportedHeight;           ///< The max height supported by single IFE
    INT                     singleIFESupportedWidth;            ///< The max width supported by single IFE
    INT                     singleTFESupportedHeight;           ///< The max height supported by single TFE
    INT                     singleTFESupportedWidth;            ///< The max width supported by single TFE
    INT                     torchCurrent;                       ///< Torch Led Currents. This will be used in torch mode
    OISCalibrationType      OISCalibrationMode;                 ///< Indicates source of OIS calibration data
    OutputFormatType        outputFormat;                       ///< Output format for IPE Preview and Video output (if no override)
    OverrideVideoOutputFormatType overrideVideoOutputFormat;    ///< Output format for Video output
    SWFrameSyncType         multiCameraSWFrameSyncType;         ///< Indicat the type of SW frame sync.
                                                                ///< SOFSync        - SOF timestamp as reference point
                                                                ///< MidOfFrameSync - MidOfFrame timestamp as reference point
    ThreadSchedulingMode    OISThreadSchedMode;                 ///< OIS polling thread operating mode
    UINT                    AFRecorderMode;                     ///< AF Core Recorder Mode:
                                                                ///< 0. Diable AF Core Recorder Mode
                                                                ///< 1. Enable AF Core Recorder Mode
                                                                ///< 2. Enable AF Core Recorder Mode and Print Set/Input Parameter as well
    UINT                    AccelEnable;                        ///< Accelerometer enablement in EIS 0x1000 for SFE alignment, 0x100 for GME,
                                                                ///< 0x10 for EISv2, 0x1 for EISv3
    UINT                    CSIDBinningMode;                    ///< This setting is valid only if CSID Binning is enable: enableCSIDBinning=TRUE
                                                                ///< Set binning mode:
                                                                ///< 0: Bayer Binning mode
                                                                ///< 1: QCFA Binning mode
    UINT                    DRVBlankingThreshold;               ///< This is to use configure the threshold to enable/disable DRV
                                                                ///< 0 - Disable DRV for non FS usecases
                                                                ///< 4 - Enable DRV for non FS usecase with threshold set to 4ms
    UINT                    DRVTimeOutValue;                    ///< This is used to overwrite DRV timeout Value
    UINT                    EISDumpForceFlush;                  ///< EIS force flush 0x1000 for SFE alignment, 0x100 for GME, 0x10 for EISv2, 0x1 for EISv3
    UINT                    EISGyroConf;                        ///< Gyro confidence override
    UINT                    EISInputDumpEnable;                 ///< EIS input dump enable in file 0x1000 for SFE alignment, 0x100 for GME, 0x10 for EISv2, 0x1 for EISv3
    UINT                    EISOutputDumpEnable;                ///< EIS output dump enable in file 0x1000 for SFE alignment, 0x100 for GME, 0x10 for EISv2, 0x1 for EISv3
    UINT                    EISV2Enable;                        ///< Enable EIS V2. 0 for Disable, 1 for VendorTag match, 2 for force select
    UINT                    EISV2FrameDelay;                    ///< Set EIS V2 Frame Delay
    UINT                    EISV3Enable;                        ///< Enable EIS V3. 0 for Disable, 1 for VendorTag match, 2 for force select
    UINT                    EISv2iFOVCEnable;                   ///< Flag to indicate if iFOVC is
    UINT                    EISv3FrameDelay;                    ///< Set EIS V3 Frame Delay
    UINT                    FPSForHALOutputBufferCombined;      ///< Use combined output buffer for the specified FPS and higher in HFR mode
    UINT                    HFRMaxBatchFPS;                     ///< Maximum fps supported in HFR batch mode if enableCustomHFRConfig is TRUE
    UINT                    HMSMaxDelayedJobCount;              ///< Health Monitor max delayed count if a particular job failed
                                                                ///< count is equal to max delayed count system event
                                                                ///< will be triggered
    UINT                    HMSSystemEventDelayCountFactor;     ///< Count factor for system event error path
    UINT                    HMSTimeInterval;                    ///< The time interval (in milliseconds) of HMS thread that wakes up
                                                                ///< periodically to perform certain tasks
    UINT                    IFEBufDoneTimeout;                  ///< IFE Buf-done fence wait timeout in millisecond
    UINT                    IFEInputHeight;                     ///< IFE input height in pixel
    UINT                    IFEInputWidth;                      ///< IFE input width in pixel
    UINT                    IFHCPASFuseInfoNumFuses;            ///< IFHCPASFuseInfoNumFuses from CSLQueryCameraPlatformIFH
    UINT                    IFHCPASHardwareCaps;                ///< IFHCPASHardwareCaps from CSLQueryCameraPlatformIFH
    UINT                    IFHCPASMajorVersion;                ///< CPASMajorVersion from CSLQueryCameraPlatformIFH
    UINT                    IFHCPASMinorVersion;                ///< IFHCPASMinorVersion from CSLQueryCameraPlatformIFH
    UINT                    IFHCPASRevVersion;                  ///< IFHCPASRevVersion from CSLQueryCameraPlatformIFH
    UINT                    IFHPlaformMajorVersion;             ///< Platform major version from CSLQueryCameraPlatformIFH
    UINT                    IFHPlaformMinorVersion;             ///< Platform minor version from CSLQueryCameraPlatformIFH
    UINT                    IFHPlaformRevVersion;               ///< Platform reserved version from CSLQueryCameraPlatformIFH
    UINT                    IPEBufDoneTimeout;                  ///< IPE Buf-done fence wait timeout in millisecond
    UINT                    IPEUnitTestIQBypassNumOfIteration;  ///< A setting to IPE IQ bypass unit test to specify number of iterations to run.
    UINT                    MCXPrimaryRearCameraIndex;          ///< Settings to forcefully choose the primary rear camera for MCX session
    UINT                    MFHDRHWEnable;                      ///< Indicates if MFHDR HW is available
    UINT                    MPMBufferAddressAlignment;          ///< Address alignment with which all buffers are allocated, valid only for CSL allocations
    UINT                    MPMKeepMinNumFreeBuffers;           ///< These many buffer will always be there in free list of a specific group
    UINT                    MPMLargeGroupSizeDefinition;        ///< Groups above this defined size will use MPMSizeDiffAllowedToGroupOverride to define difference
                                                                ///< allowed when matching buffer managers' required size
    UINT                    MPMMinSizeForSharing;               ///< Buffer Managers with size less than this value will have dedicated groups, i.e no sharing
    UINT                    MPMMinSizeToFreeOnDeactivate;       ///< If the buffer size in the current group is more than this threshold, we free the buffers
                                                                ///< immediately on Deactivate, keeping max 1 buffer in free list for any immediate usage.
                                                                ///< Current value 50MB
    UINT                    MPMMonitorSelfShrinkSizeLimit;      ///< The advantages we get with self shrinking on small buffers may be less than the costs of allocating
                                                                ///< those buffers again when needed. Hence MPM monitor thread won't free up idle buffers of sizes less
                                                                ///< than this pre-defined size in bytes.
    UINT                    MPMMonitorTimeInterval;             ///< The time interval (in milliseconds) of MPM monitor thread that wakes up
                                                                ///< periodically to perform certain tasks
    UINT                    MPMSizeDiffAllowedToGroup;          ///< Buffer Managers are attached to same Group if buffer size difference (in bytes) is within
                                                                ///< this range
    UINT                    MPMSizeDiffAllowedToGroupOverride;  ///< This byte range is used when a group size is larger than the defined large group size
                                                                ///< (MPMLargeGroupSizeDefinition) to determine if buffer managers should have a different group
    UINT                    MPMSizeThresToDelayedMap;           ///< Size threshold above which a gralloc buffer may be delayed to be mapped to smmu.
                                                                ///< Delay mapping depends on few other condition apart from size threshold.
                                                                ///< Default value of 35MB allows upto 4K resolution buffers to be mapped immediately (not delayed map)
    UINT                    MPMSizeThresToDisableDelayedUnmap;  ///< Disable Delayed Unamp feature while mapping to SMMU for buffers of size more than this threshold.
                                                                ///< Current threshold is 35MB
    UINT                    MagEnable;                          ///< Magnetometer enablement in EIS 0x1000 for SFE alignment, 0x100 for GME,
                                                                ///< 0x10 for EISv2, 0x1 for EISv3
    UINT                    OISEnable;                          ///< OIS enablement in EIS 0x1000 for SFE alignment, 0x100 for GME,
                                                                ///< 0x10 for EISv2, 0x1 for EISv3
    UINT                    OffsetToProduceBayerAlignGrid;      ///< Offset to Produce Bayer Alignment Grid
    UINT                    PreviewFPSOnHFRMode;                ///< Preview FPS On HFR Mode
    UINT                    SFERegDumpMask;                     ///< SFETopReg            = 0x1
                                                                ///< SFECommonReg         = 0x2
                                                                ///< SFEQCFADemuxReg      = 0x4
                                                                ///< SFEHDRRemosiacBinReg = 0x8
                                                                ///< SFELCRReg            = 0x10
                                                                ///< SFEChannel0Reg       = 0x20
                                                                ///< SFEChannel1Reg       = 0x40
                                                                ///< SFEChannel2Reg       = 0x80
                                                                ///< SFEPreviewPathReg    = 0x100
                                                                ///< SFESnapshotPathReg   = 0x200
                                                                ///< AllModules           = 0x3ff
    UINT                    TFERegDumpMask;                     ///< No dumps           = 0x0
                                                                ///< TFETop             = 0x1
                                                                ///< ChannelGain        = 0x2
                                                                ///< BPCPDPC            = 0x4
                                                                ///< LensRolloff        = 0x8
                                                                ///< BDSpath            = 0x10
                                                                ///< BLS                = 0x20
                                                                ///< BayerGamma         = 0x40
                                                                ///< BDS4               = 0x80
                                                                ///< ColorXformDS4      = 0x100
                                                                ///< ChromaDS2          = 0x200
                                                                ///< DS4path            = 0x400
                                                                ///< DS16path           = 0x800
                                                                ///< WB                 = 0x1000
                                                                ///< BDS2               = 0x2000
                                                                ///< GTMDMI             = 0x4000
                                                                ///< ColorXformAI       = 0x8000
                                                                ///< AIpath             = 0x10000
                                                                ///< PixelRaw           = 0x20000
                                                                ///< ABF                = 0x40000
                                                                ///< Stats              = 0x80000
                                                                ///< common             = 0x100000
    UINT                    TOFDataReportRate;                  ///< Report rate for TOF data in microsecs
    UINT                    TofOutputType;                      ///< Enable different TOF sensor mode, this type match to sensor mode index
                                                                ///< 0:TofOutputTypeDefault   - 30fps 4Tap, Dual Frequency, Interleaving
                                                                ///< 1:TofOutputType4DualIn   - 60fps 4Tap, Dual Frequency, Interleaving
                                                                ///< 2:TofOutputType4DualNon  - 120fps 4Tap, Dual Frequency, Non-Interleaving
                                                                ///< 3:TofOutputType4Single   - 60fps 4Tap, Single Frequency
    UINT                    adaptLensMap;                       ///< Adaptive LensMap Feature Control:
                                                                ///< 0x00: Feature off,
                                                                ///< 0x01: Feature on
                                                                ///< 0x02: Feature on, show comparison with OTP prediction
                                                                ///< 0x04: Feature on, with extra debug information
                                                                ///< 0x08: Feature on, prediction on but learning off
    UINT                    advanceFeatureMask;                 ///< Mask to enable Advance Features in AdvancedCameraUsecase
                                                                ///< No extra features enabled               = 0x0
                                                                ///< Enable FeatureZSL (by default)          = 0x1
                                                                ///< Enable FeatureMFNR (HW multi frame)     = 0x2
                                                                ///< Enable FeatureHDR/AE_Bracket            = 0x4
                                                                ///< Enable FeatureSWMF (SW multi frame)     = 0x8
                                                                ///< Enable FeatureMFSR (HW multi frame)     = 0x10
                                                                ///< Enable FeatureQCFA                      = 0x20
                                                                ///< Enable Feature2 Wrapper                 = 0x40
                                                                ///< Enable FeatureAIDE                      = 0x80
    UINT                    afLog;                              ///< Set AF log levels [0-7]
    UINT                    allowForceCloseOfCameraAfterDeviceError; ///< Allow Force-Close  0 for FALSE, 1 for TRUE
    UINT                    anchorAlgoSelectionType;            ///< Select Anchor Algorithm Selection Type for MFNR
                                                                ///< Timestamp        = 0.
                                                                ///< Sharpness        = 1,
                                                                ///< Lighting         = 2
    UINT                    anchorSelectionAlgoForMFNR;         ///< Select Anchor Selection Algorithm for MFNR
                                                                ///< NONE        = 0.
                                                                ///< FIXED       = 1,
                                                                ///< NON-FIXED   = 2
    UINT                    aonControlReleaseDelay;             ///< Delay milliseconds before sending control release message to AON FW
    UINT                    apiMask;                            ///< Used to set API mask
                                                                ///< Ex: 0. Process Monitor
                                                                ///< 1. Process Search
                                                                ///< 2. Set Parameters
                                                                ///< 3. Set Inputs
                                                                ///< 4. Set Tuning
                                                                ///< 5. Set Mode
                                                                ///< 6. Set Camera Mode
                                                                ///< 7. Set ROI
                                                                ///< 8. Set Range
                                                                ///< 9. Get Debug Data
                                                                ///< 10. Rebase
                                                                ///< 11. Destroy
                                                                ///< 12. Set Sensitivity
                                                                ///< 13. Get Parameters
                                                                ///< 14. Clear Data
    UINT                    assertMask;                         ///< Mask of asserts which will trigger the runtime assert code
    UINT                    autoImageDumpBPSInstanceMask;       ///< Instance mask BPS:
                                                                ///< BPSInstanceName0            = 0x1;
                                                                ///< BPSInstanceName1            = 0x2;
                                                                ///< BPSInstanceName2            = 0x4;
                                                                ///< BPSInstanceName3            = 0x8;
                                                                ///< ALLInstances                = 0xFFFFFFFF
    UINT                    autoImageDumpBPSinputPortMask;      ///< Input port mask BPS:
                                                                ///< BPSInputPort            = 0x1;
    UINT                    autoImageDumpBPSoutputPortMask;     ///< Output port mask BPS:
                                                                ///< BPSOutputPortFull            = 0x2;
                                                                ///< BPSOutputPortDS4             = 0x4;
                                                                ///< BPSOutputPortDS16            = 0x8;
                                                                ///< BPSOutputPortDS64            = 0x10;
                                                                ///< BPSOutputPortStatsBG         = 0x20;
                                                                ///< BPSOutputPortStatsHDRBHist   = 0x40;
                                                                ///< BPSOutputPortReg1            = 0x80;
                                                                ///< BPSOutputPortReg2            = 0x100;
                                                                ///< ALLports                     = 0x1FE
    UINT                    autoImageDumpCHINodeInstanceMask;   ///< Instance mask ChiNode:
                                                                ///< ChiNodeInstanceName0            = 0x1;
                                                                ///< ChiNodeInstanceName1            = 0x2;
                                                                ///< ChiNodeInstanceName2            = 0x4;
                                                                ///< ChiNodeInstanceName3            = 0x8;
                                                                ///< ChiNodeInstanceName4            = 0x10;
                                                                ///< ChiNodeInstanceName5            = 0x20;
                                                                ///< AllInstances                    = 0x3F
    UINT                    autoImageDumpCHINodeinputPortMask;  ///< Input port mask ChiNode:
                                                                ///< ChiNodeInputPort            = 0x1
    UINT                    autoImageDumpCHINodeoutputPortMask; ///< Output port mask ChiNode:
                                                                ///< ChiNodeOutputFull            = 0x1;
                                                                ///< ChiNodeOutputDS4             = 0x2;
                                                                ///< ChiNodeOutputDS16            = 0x4;
                                                                ///< ChiNodeOutputDS64            = 0x8;
                                                                ///< ChiNodeOutputDS              = 0x10;
                                                                ///< ChiNodeOutputDSb             = 0x20;
                                                                ///< ALLports                     = 0x3F
    UINT                    autoImageDumpCREInstanceMask;       ///< Instance mask CRE:
                                                                ///< CREInstanceName0             = 0x1
                                                                ///< CREInstanceName1             = 0x2
                                                                ///< CREInstanceName2             = 0x4
                                                                ///< CREInstanceName3             = 0x8
                                                                ///< CREInstanceName4             = 0x10
                                                                ///< AllInstances                 = 0x1F
    UINT                    autoImageDumpCREinputPortMask;      ///< Input port mask CRE:
                                                                ///< CREInputPortImage             = 0x2
                                                                ///< ALLports                      = 0x2
    UINT                    autoImageDumpCREoutputPortMask;     ///< Output port mask CRE:
                                                                ///< CREOutputPortImage            = 0x2
                                                                ///< ALLports                      = 0x2
    UINT                    autoImageDumpCVPInstanceMask;       ///< Instance mask CVP:
                                                                ///< CVPInstanceName0             = 0x1;
                                                                ///< CVPInstanceName1             = 0x2;
                                                                ///< CVPInstanceName2             = 0x4;
                                                                ///< CVPInstanceName10            = 0x400;
                                                                ///< CVPInstanceName12            = 0x1000;
                                                                ///< CVPInstanceName13            = 0x2000;
                                                                ///< CVPInstanceName15            = 0x8000;
                                                                ///< AllInstances                 = 0xFFFF
    UINT                    autoImageDumpFDHwInstanceMask;      ///< Instance mask FDHw:
                                                                ///< FDHwInstanceName0             = 0x1;
                                                                ///< FDHwInstanceName1             = 0x2;
                                                                ///< AllInstances                  = 0x3
    UINT                    autoImageDumpFDHwinputPortMask;     ///< Input port mask FDHw:
                                                                ///< FDHwInputPortImage            = 0x1
    UINT                    autoImageDumpFDHwoutputPortMask;    ///< Output port mask FDHw:
                                                                ///< FDHwOutputPortResults         = 0x1;
                                                                ///< FDHwOutputPortRawResults      = 0x2;
                                                                ///< FDHwOutputPortWorkBuffer      = 0x4;
                                                                ///< ALLports                      = 0x7
    UINT                    autoImageDumpIFEInstanceMask;       ///< Instance mask:
                                                                ///< IFE:
                                                                ///< IFEInstanceName0            = 0x1;
                                                                ///< IFEInstanceName1            = 0x2;
                                                                ///< IFEInstanceName2            = 0x4;
                                                                ///< AllInstances                = 0x7
    UINT                    autoImageDumpIFEVirtualOutputPortExtendedMask; ///< Virtual output port mask:
                                                                ///< IFE:
                                                                ///< IFEOutputPortStatsBayerRSExposure3 = 0x1
                                                                ///< IFEOutputPortPDParsedDataExposure1 = 0x2
                                                                ///< IFEOutputPortPDParsedDataExposure2 = 0x4
                                                                ///< IFEOutputPortPDParsedDataExposure3 = 0x8
    UINT                    autoImageDumpIFEVirtualRawOutputPortMask; ///< Raw output port mask:
                                                                ///< IFE:
                                                                ///< IFEOutputPortRAW0 = 0x1
                                                                ///< IFEOutputPortRAW1 = 0x2
                                                                ///< IFEOutputPortRAW2 = 0x4
                                                                ///< IFEOutputPortRAW3 = 0x8
                                                                ///< IFEOutputPortRAW4 = 0x10
                                                                ///< IFEOutputPortRAW5 = 0x20
                                                                ///< IFEOutputPortRAW6 = 0x40
                                                                ///< IFEOutputPortRAW7 = 0x80
                                                                ///< IFEOutputPortRAW8 = 0x100
                                                                ///< IFEOutputPortRAW9 = 0x200
                                                                ///< ALLports          = 0x3FF
    UINT                    autoImageDumpIFEinputPortMask;      ///< Input Port mask:
                                                                ///< IFE:
                                                                ///< IFEInputPortCSIDTPG         = 0x1;
                                                                ///< IFEInputPortCAMIFTPG        = 0x2;
                                                                ///< IFEInputPortSensor          = 0x4;
                                                                ///< IFEInputPortRDI0            = 0x8;
                                                                ///< IFEInputPortRDI1            = 0x10;
                                                                ///< IFEInputPortRDI2            = 0x20;
                                                                ///< IFEInpurPortDualPD          = 0x40;
                                                                ///< ALLports                    = 0x7F;
    UINT                    autoImageDumpIFEoutputBatchNum;     ///< Output IFE batched frames(HFR):
                                                                ///< IFE:
                                                                ///< Dump only ONE frame from  IFE Batch    = 0x1
                                                                ///< Dump only TWO frames from IFE Batch    = 0x2
                                                                ///< Dump only THREE frames from IFE Batch  = 0x3
                                                                ///< Dump only FOUR frames from IFE Batch   = 0x4
                                                                ///< Dump only FIVE frames from IFE Batch   = 0x5
                                                                ///< Dump only SIX frames from IFE Batch    = 0x6
                                                                ///< Dump only SEVEN frames from IFE Batch  = 0x7
                                                                ///< Dump only EIGHT frames from IFE Batch  = 0x8
    UINT                    autoImageDumpIPEInstanceMask;       ///< IPEInstanceName0             = 0x1;
                                                                ///< IPEInstanceName1             = 0x2;
                                                                ///< IPEInstanceName2             = 0x4;
                                                                ///< IPEInstanceName3             = 0x8;
                                                                ///< IPEInstanceName4             = 0x10;
                                                                ///< IPEInstanceName5             = 0x20;
                                                                ///< IPEInstanceName6             = 0x40;
                                                                ///< IPEInstanceName7             = 0x80;
                                                                ///< IPEInstanceName8             = 0x100;
                                                                ///< IPEInstanceName9             = 0x200;
                                                                ///< IPEInstanceName10            = 0x400;
                                                                ///< IPEInstanceName11            = 0x800;
                                                                ///< IPEInstanceName12            = 0x1000;
                                                                ///< IPEInstanceName13            = 0x2000;
                                                                ///< IPEInstanceName14            = 0x4000;
                                                                ///< IPEInstanceName15            = 0x8000;
                                                                ///< IPEInstanceName16            = 0x10000;
                                                                ///< IPEInstanceName17            = 0x20000;
                                                                ///< IPEInstanceName18            = 0x40000;
                                                                ///< IPEInstanceName19            = 0x80000;
                                                                ///< IPEInstanceName20            = 0x100000;
                                                                ///< IPEInstanceName21            = 0x200000;
                                                                ///< AllInstances                 = 0xFFFFFFFF
    UINT                    autoImageDumpIPEVirtualInputPortMask; ///< Virtual Input port mask for IPE:
                                                                ///< IPEShortExposureInputFull   = 0x1
                                                                ///< IPELongExposureInputFull    = 0x2
                                                                ///< IPEMidExposureInputFull     = 0x4
                                                                ///< IPEShortExposureInputDS4    = 0x8
                                                                ///< IPELongExposureInputDS4     = 0x10
                                                                ///< IPEMidExposureInputDS4      = 0x20
                                                                ///< IPEAlgm8BitInput            = 0x40
                                                                ///< IPEAlgm16BitInput           = 0x80
                                                                ///< IPEDMMLMC1InputFull         = 0x100
                                                                ///< IPEDMMLMC1InputDS4          = 0x200
                                                                ///< IPEDMMLMC1InputDS16         = 0x400
                                                                ///< IPEDMMLMC1InputDS64         = 0x800
                                                                ///< IPEDMMLMC2InputFull         = 0x1000
                                                                ///< IPEDMMLMC2InputDS4          = 0x2000
                                                                ///< IPEDMMLMC2InputDS16         = 0x4000
                                                                ///< IPEDMMLMC2InputDS64         = 0x8000
                                                                ///< ALLports                    = 0xFFFF
    UINT                    autoImageDumpIPEinputPortMask;      ///< Input port mask for IPE:
                                                                ///< IPEInputPortFull             = 0x1;
                                                                ///< IPEInputPortDS4              = 0x2;
                                                                ///< IPEInputPortDS16             = 0x4;
                                                                ///< IPEInputPortDS64             = 0x8;
                                                                ///< IPEInputPortFullRef          = 0x10;
                                                                ///< IPEInputPortDS4Ref           = 0x20;
                                                                ///< IPEInputPortDS16Ref          = 0x40;
                                                                ///< IPEInputPortDS64Ref          = 0x80;
                                                                ///< ALLports                     = 0xFF
    UINT                    autoImageDumpITOFInstanceMask;      ///< Instance mask ITOF:
                                                                ///< ITOFInstanceName0             = 0x1;
    UINT                    autoImageDumpITOFinputPortMask;     ///< Input port mask ITOF:
                                                                ///< ITOFInputFreq0ImageI          = 0x0001;
                                                                ///< ITOFInputFreq0ImageQ          = 0x0002;
                                                                ///< ITOFInputFreq1ImageI          = 0x0004;
                                                                ///< ITOFInputFreq1ImageQ          = 0x0008;
                                                                ///< ITOFInputDelayImageI          = 0x0010;
                                                                ///< ITOFInputDelayImageQ          = 0x0020;
                                                                ///< ALLports                      = 0x003F
    UINT                    autoImageDumpITOFoutputPortMask;    ///< Output port mask ITOF:
                                                                ///< ITOFOutputDepthMap            = 0x0100
                                                                ///< ITOFOutputConfidenceMap       = 0x0200
                                                                ///< ITOFOutputIQNRQImage0         = 0x0400
                                                                ///< ITOFOutputIQNRIImage0         = 0x0800
                                                                ///< ITOFOutputIQNRQImage1         = 0x1000
                                                                ///< ITOFOutputIQNRIImage1         = 0x2000
                                                                ///< ALLports                      = 0x3F00
    UINT                    autoImageDumpJpegHwInstanceMask;    ///< Instance mask JpegHw:
                                                                ///< JPEGInstanceName0            = 0x1;
                                                                ///< JPEGInstanceName1            = 0x2;
                                                                ///< JPEGInstanceName2            = 0x4;
                                                                ///< JPEGInstanceName3            = 0x8;
                                                                ///< JPEGInstanceName4            = 0x10;
                                                                ///< ALLInstances                 = 0x2F;
    UINT                    autoImageDumpJpegHwinputPortMask;   ///< Input port mask JpegHw:
                                                                ///< JPEGInputPort0             = 0x1;
                                                                ///< JPEGInputPort1             = 0x2;
                                                                ///< AllPorts                   = 0x3;
    UINT                    autoImageDumpJpegHwoutputPortMask;  ///< Output port mask JpegHw:
                                                                ///< JPEGOutputPort0             = 0x1;
                                                                ///< JPEGOutputPort1             = 0x2;
                                                                ///< JPEGAggregatorOutputPort2   = 0x3;
                                                                ///< AllPorts                    = 0x7;
    UINT                    autoImageDumpLRMEInstanceMask;      ///< Instance mask LRME:
                                                                ///< LRMEInstanceName0            = 0x1;
                                                                ///< LRMEInstanceName1            = 0x2;
                                                                ///< AllInstances                 = 0x3
    UINT                    autoImageDumpLRMEinputPortMask;     ///< Input port mask LRME:
                                                                ///< LRMEInputPortTARIFEFull               = 0x1;
                                                                ///< LRMEInputPortREFIFEFull               = 0x2;
                                                                ///< LRMEInputPortTARIFEDS4                = 0x4;
                                                                ///< LRMEInputPortREFIFEDS4                = 0x8;
                                                                ///< LRMEInputPortTARIFEDS16               = 0x10;
                                                                ///< LRMEInputPortREFIFEDS16               = 0x20;
                                                                ///< LRMEMaxIntputPorts                    = 0x40;
                                                                ///< ALLports                              = 07F
    UINT                    autoImageDumpLRMEoutputPortMask;    ///< Output port mask LRME:
                                                                ///< LRMEOutputPortVector            = 0x1;
                                                                ///< LRMEOutputPortDS2               = 0x2;
                                                                ///< LRMEMaxOutputPorts              = 0x4;
                                                                ///< ALLports                        = 0xF
    UINT                    autoImageDumpMask;                  ///< Will limit dumps to only the specified nodes and ports when autoImageDump is enabled
                                                                ///< Uses ImageDumpType to define the flags
                                                                ///< No dumps                                      = 0x0
                                                                ///< All output ports for IFE                      = 0x1
                                                                ///< All output ports for IPE                      = 0x2
                                                                ///< All output ports for BPS                      = 0x4
                                                                ///< All JPEG output ports for all JPEG nodes      = 0x8
                                                                ///< All output ports for FDHw                     = 0x10
                                                                ///< All output ports for LRME                     = 0x20
                                                                ///< All output ports for RANSAC                   = 0x40
                                                                ///< All output ports for all ChiNodes             = 0x80
                                                                ///< All output ports for CVP                      = 0x100
                                                                ///< All output ports for TFE                      = 0x200
                                                                ///< All output ports for OPE                      = 0x400
                                                                ///< All output ports for QSAT                     = 0x800
                                                                ///< All output ports for ITOF                     = 0x1000
                                                                ///< All output ports for CRE                      = 0x2000
                                                                ///< All other nodes not explicitly listed above   = 0x40000000
    UINT                    autoImageDumpOPEInstanceMask;       ///< OPEInstanceName0             = 0x1;
                                                                ///< OPEInstanceName1             = 0x2;
                                                                ///< OPEInstanceName2             = 0x4;
                                                                ///< OPEInstanceName3             = 0x8;
                                                                ///< OPEInstanceName4             = 0x10;
                                                                ///< OPEInstanceName5             = 0x20;
                                                                ///< OPEInstanceName6             = 0x40;
                                                                ///< OPEInstanceName7             = 0x80;
                                                                ///< OPEInstanceName8             = 0x100;
                                                                ///< OPEInstanceName9             = 0x200;
                                                                ///< OPEInstanceName10            = 0x400;
                                                                ///< OPEInstanceName11            = 0x800;
                                                                ///< OPEInstanceName12            = 0x1000;
                                                                ///< OPEInstanceName13            = 0x2000;
                                                                ///< OPEInstanceName14            = 0x4000;
                                                                ///< OPEInstanceName15            = 0x8000;
                                                                ///< OPEInstanceName16            = 0x10000;
                                                                ///< OPEInstanceName17            = 0x20000;
                                                                ///< OPEInstanceName18            = 0x40000;
                                                                ///< OPEInstanceName19            = 0x80000;
                                                                ///< OPEInstanceName20            = 0x100000;
                                                                ///< OPEInstanceName21            = 0x200000;
                                                                ///< AllInstances                 = 0xFFFFFFFF
    UINT                    autoImageDumpOPEinputPortMask;      ///< Input port mask for OPE:
                                                                ///< OPEInputPortFull             = 0x2;
                                                                ///< ALLports                     = 0xFF
    UINT                    autoImageDumpOPEoutputPortMask;     ///< Output port mask for OPE:
                                                                ///< OPEOutputPortDisplay         = 0x2;
                                                                ///< OPEOutputPortVideo           = 0x4;
                                                                ///< OPEOutputPortARGB            = 0x8;
                                                                ///< OPEOutputPortStatRS          = 0x10;
                                                                ///< OPEOutputPortStatIHIST       = 0x20;
                                                                ///< ALLports                     = 0x3F00
    UINT                    autoImageDumpQSATInstanceMask;      ///< Instance mask QSAT:
                                                                ///< QSATInstanceName0             = 0x1;
    UINT                    autoImageDumpQSATinputPortMask;     ///< Input port mask QSAT:
                                                                ///< QSATInputFullCamera1          = 0x0001;
                                                                ///< QSATInputDS4Camera1           = 0x0002;
                                                                ///< QSATInputDS16Camera1          = 0x0004;
                                                                ///< QSATInputFullCamera2          = 0x0008;
                                                                ///< QSATInputDS4Camera2           = 0x0010;
                                                                ///< QSATInputDS16Camera2          = 0x0020;
                                                                ///< QSATInputFullCamera3          = 0x0040;
                                                                ///< QSATInputDS4Camera3           = 0x0080;
                                                                ///< QSATInputDS16Camera3          = 0x0100;
                                                                ///< QSATInputPortDataCamera1      = 0x0200;
                                                                ///< QSATInputPortDataCamera2      = 0x0400;
                                                                ///< QSATInputPortImageCamera1     = 0x0800;
                                                                ///< QSATInputPortImageCamera2     = 0x1000;
                                                                ///< ALLports                      = 0x1FFF
    UINT                    autoImageDumpQSAToutputPortMask;    ///< Output port mask QSAT:
                                                                ///< QSATOutputFull                = 0x02000
                                                                ///< QSATOutputDS4                 = 0x04000
                                                                ///< QSATOutputDS16                = 0x08000
                                                                ///< QSATOutputPortDataCamera1     = 0x10000
                                                                ///< QSATOutputPortDataCamera2     = 0x20000
                                                                ///< QSATOutputPortImageCamera1    = 0x40000
                                                                ///< QSATOutputPortImageCamera2    = 0x80000
                                                                ///< ALLports                      = 0xFE000
    UINT                    autoImageDumpRANSACInstanceMask;    ///< Instance mask RANSAC:
                                                                ///< RANSACInstanceName0          = 0x1;
                                                                ///< RANSACInstanceName1          = 0x2;
                                                                ///< AllInstances                 = 0x3
    UINT                    autoImageDumpRANSACinputPortMask;   ///< Input port mask RANSAC:
                                                                ///< RANSACInputPort0           = 0x1
    UINT                    autoImageDumpRANSACoutputPortMask;  ///< Output port mask RANSAC:
                                                                ///< RANSACOutputPort0            = 0x1
    UINT                    autoImageDumpTFEInstanceMask;       ///< Instance mask:
                                                                ///< TFE:
                                                                ///< TFEInstanceName0            = 0x1;
                                                                ///< TFEInstanceName1            = 0x2;
                                                                ///< TFEInstanceName2            = 0x4;
                                                                ///< AllInstances                = 0x7
    UINT                    autoImageDumpTFEVirtualRawOutputPortMask; ///< Raw output port mask:
                                                                ///< TFE:
                                                                ///< TFEOutputPortRAW0 = 0x1
                                                                ///< TFEOutputPortRAW1 = 0x2
                                                                ///< TFEOutputPortRAW2 = 0x4
                                                                ///< ALLports          = 0x7
    UINT                    autoImageDumpTFEoutputBatchNum;     ///< Output TFE batched frames(HFR):
                                                                ///< TFE:
                                                                ///< Dump only ONE frame from  TFE Batch    = 0x1
                                                                ///< Dump only TWO frames from TFE Batch    = 0x2
                                                                ///< Dump only THREE frames from TFE Batch  = 0x3
                                                                ///< Dump only FOUR frames from TFE Batch   = 0x4
                                                                ///< Dump only FIVE frames from TFE Batch   = 0x5
                                                                ///< Dump only SIX frames from TFE Batch    = 0x6
                                                                ///< Dump only SEVEN frames from TFE Batch  = 0x7
                                                                ///< Dump only EIGHT frames from TFE Batch  = 0x8
    UINT                    autoImageDumpTFEoutputPortMask;     ///< Output port mask:
                                                                ///< TFE:
                                                                ///< TFEOutputPortFull            = 0x2
                                                                ///< TFEOutputPortIdealRaw        = 0x4
                                                                ///< TFEOutputPortPDAF            = 0x8
                                                                ///< TFEOutputPortRDI0            = 0x10
                                                                ///< TFEOutputPortRDI1            = 0x20
                                                                ///< TFEOutputPortRDI2            = 0x40
                                                                ///< TFEOutputPortStatsAECBG      = 0x80
                                                                ///< TFEOutputPortStatsBHIST      = 0x100
                                                                ///< TFEOutputPortStatsTLBG       = 0x200
                                                                ///< TFEOutputPortStatsBF         = 0x400
                                                                ///< TFEOutputPortStatsAWBBG      = 0x800
                                                                ///< TFEOutputPortStatsRS         = 0x1000
                                                                ///< TFEOutputPortDS4             = 0x2000
                                                                ///< TFEOutputPortDS16            = 0x4000
                                                                ///< TFEOutputPortAI              = 0x8000
                                                                ///< TFEOutputPortStatsDualPD     = 0x10000
                                                                ///< TFEOutputPortPDPreProcessed  = 0x20000
                                                                ///< TFEOutputPortPDparsed        = 0x40000
                                                                ///< ALLports                     = 0xFFFFE
                                                                ///< AllPixelOutput               = 0xF8E
                                                                ///< AllRawOutput                 = 0x7C
                                                                ///< AllRDIOutput                 = 0x70
                                                                ///< AllStatsOutput               = 0x1F80
    UINT                    autoInputImageDumpMask;             ///< Will limit dumps to only the specified nodes when autoInputImageDump is enabled
                                                                ///< Uses ImageDumpType to define the flags
                                                                ///< No dumps                                      = 0x0
                                                                ///< All input ports for IFE                       = 0x1
                                                                ///< All input ports for IPE                       = 0x2
                                                                ///< All input ports for BPS                       = 0x4
                                                                ///< All JPEG input ports for all JPEG nodes       = 0x8
                                                                ///< All input ports for FDHw                      = 0x10
                                                                ///< All input ports for LRME                      = 0x20
                                                                ///< All input ports for RANSAC                    = 0x40
                                                                ///< All input ports for all ChiNodes              = 0x80
                                                                ///< All input ports for CVP                       = 0x100
                                                                ///< All input ports for OPE                       = 0x400
                                                                ///< All input ports for QSAT                      = 0x800
                                                                ///< All input ports for ITOF                      = 0x1000
                                                                ///< All input ports for CRE                       = 0x2000
                                                                ///< All other nodes not explicitly listed above   = 0x40000000
    UINT                    bpsRealtimeSensorId;                ///< Sensor ID for BPS Based Realtime Camera
    UINT                    bypassSegmentationProcessing;       ///< This is to bypass segmentation processing
                                                                ///< BypassEnable            =  0x1,  bypass feature enabled
                                                                ///< BypassAlways            =  0x2,  bypass enabled by force override, this should be 0 by default
                                                                ///< BypassMinAIStrength     =  0x4,  bypass enabled for minimum(0) SWDAS value
                                                                ///< BypassMultiExposureMode =  0x8,  bypass enabled for MFHDR realtime multi exp
                                                                ///< BypassUltralowlightMode =  0x10, bypass enabled for VIULL low light
                                                                ///< BypassSleep             =  0x20, bypass enabled for qseg sleep mode
                                                                ///< BypassQsegInterpolation =  0x40, bypass enabled for qseg interpolation, default 1
    UINT                    cameraHardware;                     ///< This is to indicate Camera Hardware
                                                                ///< TITAN  = 0x1
                                                                ///< MIMAS  = 0x2
                                                                ///< MIMAS2 = 0x3
    UINT                    cdrLaneValue;                       ///< cdr LaneValue is the configured value to HW for that run,
                                                                ///< it will be default +/- tolerance.
                                                                ///< Please check with the HW PHY team for the reference values for specific targets.
    UINT                    cdrTolerance;                       ///< cdr Tolerance is the step value we want to try.
                                                                ///< For a given data rate let's assume the CDR range is [min, default, max],
                                                                ///< tolerance will define the step value we want to go from default +/- max/min.
                                                                ///< Please check with the HW PHY team for the reference values for specific targets.
    UINT                    cdrToleranceType;                   ///< cdr ToleranceType to add or subtract
                                                                ///< 1 = CDR Add Tolerance
                                                                ///< 2 = CDR Subtract Tolerance
    UINT                    colorTemp;                          ///< Value of White Balance color temperature
    UINT                    conciseDebugDataSizeAEC;            ///< Debug-data size reserved for Concise AEC
    UINT                    conciseDebugDataSizeAF;             ///< Debug-data size reserved for Concise AF
    UINT                    conciseDebugDataSizeAWB;            ///< Debug-data size reserved for Concise AWB
    UINT                    debugBufferRegDumpSizeInBytes;      ///< Size in bytes for each register dump buffer
    UINT                    debugDataSizeAEC;                   ///< Debug-data size reserved for AEC
    UINT                    debugDataSizeAF;                    ///< Debug data size reserved for AF
    UINT                    debugDataSizeAFC;                   ///< Debug data size reserved for AFC
    UINT                    debugDataSizeAFD;                   ///< Debug data size reserved for AFD
    UINT                    debugDataSizeAWB;                   ///< Debug data size reserved for AWB
    UINT                    debugTPGbpp;                        ///< This bpp value will input to IFE for TPG mode simulating
    UINT                    defaultMaxFPS;                      ///< Set the default fps for sensor mode pick
    UINT                    disableASDStatsProcessing;          ///< Enables/Disables ASD Stats Processing. 0 for enable, 1 for disable
    UINT                    dump3AStats;                        ///< Mask info (can be dump multiple stats by setting bit position):
                                                                ///< No stats dump        :  0
                                                                ///< dump AEC BE Stats    :  1 (Bit position 1 is set)
                                                                ///< dump AEC BHIST Stats :  2 (Bit position 2 is set)
                                                                ///< dump AWB BG Stats    :  4 (Bit position 3 is set)
    UINT                    dumpAEC;                            ///< Mask info:
                                                                ///< dump AEC Stats: 0x1
                                                                ///< dump AEC Info:  0x2
                                                                ///< dump AEC HAL Data: 0x4
                                                                ///< dump Stats, Info and HAL Data: 0x7
    UINT                    dumpAF;                             ///< Mask info:
                                                                ///< dump AF Stats: 0x1
                                                                ///< dump AF Info:  0x2
                                                                ///< dump AF HWPD Config: 0x4
                                                                ///< dump Stats, Info and HWPD config: 0x7
                                                                ///< dump depthAF data: 0x8
                                                                ///< dump CAFStatsConfig data: 0x10
    UINT                    dumpAWB;                            ///< Mask info:
                                                                ///< dump AWB Stats: 0x1
                                                                ///< dump AWB Info:  0x2
                                                                ///< dump AWB HAL Data: 0x4
                                                                ///< dump Stats, Info and HAL Data: 0x7
    UINT                    dumpDebugDataEveryProcessResult;    ///< Control debug-data dump per process result
                                                                ///< If enable this setting and implemented dump by CHI, debug-data including Tuning metadata will be dump into a file
                                                                ///< on every process result.
                                                                ///< Note that to dump data, debug-data should be also enable using the corresponding settings.
                                                                ///< Values:
                                                                ///< 0: Disable, do not dump any data.
                                                                ///< 1: Enable for multi-frame snapshot.
                                                                ///< 2: Enable only while video port is enable.
                                                                ///< 3: Enable for all processed buffers. This include all preview frames.
    UINT                    dumpHDR10pLogsMask;                 ///< Mask info:
                                                                ///< Dump to file or log: 0th bit
                                                                ///< Dump stats     : 1st bit
                                                                ///< Dump i/p to lib: 2nd bit
                                                                ///< Dump SEI       : 3rd bit
                                                                ///< Dump output repeatation: 4t to 12th bit(1= repeat every frame, 2= alternate frame etc)
    UINT                    dumpMetadata;                       ///< 0 - disable:
                                                                ///< 1 - Enable text metadata dump for offline pipelines,
                                                                ///< 2 - Enable text metadata dump for real-time pipelines,
                                                                ///< 3 - Enable text metadata dump for both offline and real-time pipelines
                                                                ///< 4 - Enable binary metadata dump for offline pipelines,
                                                                ///< 8 - Enable binary metadata dump for real-time pipelines,
                                                                ///< 12 - Enable binary metadata dump for both offline and real-time pipelines
    UINT                    dumpQLLLogsMask;                    ///< Mask info:
                                                                ///< dump QLL Input: 0x1
                                                                ///< dump QLL Output: 0x2
                                                                ///< dump QLL TFI Input: 0x4
                                                                ///< Dump All: 0x7
    UINT                    dynamicCalibrationMaxSize;          ///< max allocated space for dynamic inline LED Calibration data
    UINT                    enableAEScan;                       ///< Enable/Disable AE Scan
                                                                ///< 0  Disable
                                                                ///< 1  Enable AE Scan Time Sweep
                                                                ///< 2  Enable AE Scan Gain Sweep
                                                                ///< 4  Enable AE Scan Toogle
                                                                ///< 8  Enable AE Scan Time Sweep delayed
                                                                ///< 16 Enable AE Scan Gain Sweep delayed
                                                                ///< 32 Enable AE Scan Toogle delayed
                                                                ///< To Enable more then one test case bitwise or the value.
    UINT                    enableAFB;                          ///< Enable AF Bracketing
    UINT                    enableAI;                           ///< Enable/Disable AI Camera on camera preview and snapshot
    UINT                    enableAsciiLogging;                 ///< Set offline ASCII Logging
                                                                ///< Disable = 0,
                                                                ///< Enable  = 1
                                                                ///< Note: The setting is independent from binary logger setting.
                                                                ///< It does not effect binary logging
    UINT                    enableAsymmetricBokehInput;         ///< In case of Bokeh mode, use physical stream as fusion pipeline input if FWK size > RDI size.
                                                                ///< If actual bokeh node is enabled, we can enable it. Otherwise, we need to disable it in case of dummyrtb.
    UINT                    enableAutoHDRCapability;            ///< Enable Auto HDR Capability
    UINT                    enableBLMClient;                    ///< Enables/Disable Bandwidth Limits Manager Client
    UINT                    enableBinaryLogging;                ///< Set offline binary Logging.
                                                                ///< Disable = 0,
                                                                ///< Enable  = 1
                                                                ///< Note: The setting is independent from ASCII logging setting.
                                                                ///< It does not effect ASCII logging.
    UINT                    enableCHIImageBufferLateBinding;    ///< Whether to enable late bind of memory/buffers to ImageBuffer for CHI buffer managers.
                                                                ///< 0 for FALSE, i.e Buffers are allocated/bound at the time of GetImageBufferInfo
                                                                ///< 1 for TRUE, i.e holder ImageBuffer objects are returned in GetImageBufferInfo
    UINT                    enableCHIPartialDataRecovery;       ///< Enable Partial Data Recovery
    UINT                    enableCSLHwCapabilityDetection;     ///< This setting toggles the CSL Hw Capability detection feature on and off.
                                                                ///< This feature is and should remain enabled by default, but scenarios where
                                                                ///< it should be considered in disabling include test platforms which are
                                                                ///< hardware independent.
    UINT                    enableCoredumpOfflineBinaryLogging; ///< Set offline Coredump binary Logging
                                                                ///< Disable = 0,
                                                                ///< Enable  = 1
                                                                ///< Note: The setting is independent from coredump text logger setting.
                                                                ///< It does not effect coredump text logging
    UINT                    enableCoredumpOfflineTextLogging;   ///< Set offline Coredump text Logging
                                                                ///< Disable = 0,
                                                                ///< Enable  = 1
                                                                ///< Note: The setting is independent from coredump binary logger setting.
                                                                ///< It does not effect coredump binary logging
    UINT                    enableDMAFence;                     ///< Enable DMA fence for framework preview buffers
    UINT                    enableDMAFenceHighFPS;              ///< Enable DMA fence for framework preview buffers at 60 fps preview
    UINT                    enableDSPJpegsw;                    ///< Enable HVX core in JPEGSW Lib for encoding image. 0 for FALSE, 1 for TRUE
    UINT                    enableDSPSwHME;                     ///< Enable DSP based SWHME for image transform. 0 for FALSE, 1 for TRUE
    UINT                    enableFDStreamInRealTime;           ///< Enable FD Stream in Real Time from CHI:
                                                                ///< FALSE   = 0,
                                                                ///< TRUE    = 1
    UINT                    enableFeature2BinaryGraphDump;      ///< Allows Binary Dump for graphs at camera boot
    UINT                    enableFeature2CTS;                  ///< Routes CTS through Feature2 path
    UINT                    enableFeature2Dump;                 ///< Flag to enable raw image and/or metadata dump in feature2.
                                                                ///< Disable    = 0,
                                                                ///< Enable     = 1
    UINT                    enableFeature2PrunedGraphDump;      ///< Allows Binary Dump for pruned graphs for debug purpose
    UINT                    enableGamma15PreCalculate;          ///< Flag to enable gamma15 pre-calculation for TMC 1.1
                                                                ///< Disable   = 0,
                                                                ///< Enable    = 1
    UINT                    enableMCXPipelineFlushMask;         ///< Static policy will request pipelines of camera id set by the mask to be flushed
    UINT                    enableMCXSPMActiveCamStateOpt;      ///< Skip multiple active camera in transition zone if zoom is beyond a threshold
    UINT                    enableMFSRChiFence;                 ///< Enable this setting so that CHI fence support is enabled on MFSR CHITargetBufferManager.
                                                                ///< 0 for FALSE, 1 for TRUE.
    UINT                    enableMallopt;                      ///< Enable Releasing Malloc memory  0 for FALSE, 1 for TRUE
    UINT                    enableModifiedCTSResolution;        ///< CTS testcases will use modified resolution combinations
    UINT                    enableMotionAssisted3A;             ///< Enables/Disables motion assited 3a algorithm. 1 for enable, 0 for disable
    UINT                    enableOfflineDump;                  ///< Use offline thread to write dump
    UINT                    enableOfflineNoiseReprocess;        ///< Flag to enable offline noise reprocessing in MFNR
                                                                ///< Disable   = 0,
                                                                ///< Enable    = 1
    UINT                    enablePDLibDump;                    ///< Enable/Disable PD Library Data Dump
                                                                ///< 1 - Single raw input with configuration dump.
                                                                ///< 2 - Raw input dump according to lens position and configuration.
    UINT                    enablePDLibLog;                     ///< Enable/Disable PD Library Logging
                                                                ///< 1 - Enable all PDLib general logging
                                                                ///< 2 - Enable all PDLib general + verbose logging
                                                                ///< 3 - Enable all PDLib general + verbose logging with Adaptive K logging
    UINT                    enablePDLibTestMode;                ///< Enable/Disable PD Library Test Mode
                                                                ///< 1 - General test mode to check gainmap uniformity
    UINT                    enablePDNetDump;                    ///< Enable/Disable dump from PDNet node and algo
                                                                ///< 1 - Enable dump from PDNet algo.
                                                                ///< 2 - Enable dump from PDNet node
                                                                ///< 3 - Enable dump from both algo and node
    UINT                    enablePipelineSplit;                ///< Enables Pipeline Split in Session
    UINT                    enablePostZoomFOV;                  ///< Enable post-zoomed translation for Control Zoom Ratio
    UINT                    enableQSATWithSPM;                  ///< Enable QSAT with static policy manager
    UINT                    enableRawHDR;                       ///< Enable/Disable RAW HDR Snapshot by set this value.
                                                                ///< 0 for FALSE, Disable
                                                                ///< 1 for TRUE, Enable
    UINT                    enableResourceManager;              ///< Enable/Disable CamX Resource Manager
    UINT                    enableSALINetDump;                  ///< Enable/Disable dump from SALINet node and alog
                                                                ///< 1 - Enable dump from saliency algo.
                                                                ///< 2 - Enable dump from SALINet node
                                                                ///< 3 - Enable dump from both algo and node
    UINT                    enableSATPreviewEISV2;              ///< Enable/Disable SAT Preview EISV2, for SAT Preview to work with EIS2
    UINT                    enableSensorRemosaic;               ///< Settings to enable ensor remosaic for insensor zoom
    UINT                    enableSwHME;                        ///< Enable SWHME for image transform. 0 for FALSE, 1 for TRUE
    UINT                    enableSynxFence;                    ///< Enable Synx fence
    UINT                    enableTBMChiFence;                  ///< Enable this setting so that CHI fence support is enabled on CHITargetBufferManager class.
                                                                ///< 0 for FALSE, 1 for TRUE.
    UINT                    enableUBWCP;                        ///< SW Nodes will use UBWC when enabled. Bit Mask are as follows:
                                                                ///< IOCoherency                                                                = 0x1
                                                                ///< IOCoherency + EnableUBWCPOps                                               = 0x3
                                                                ///< IOCoherency + EnableUBWCPOps + DMAUBWCPOpt                                 = 0x7
                                                                ///< IOCoherency + EnableUBWCPOps + DMAUBWCPOpt + DisableUBWCPFormatNegotiation = 0xF
    UINT                    enableUnifiedBufferManager;         ///< Enable this setting so that CHI and CAMX use the unified image buffer manager.
                                                                ///< 0 for FALSE, i.e CHIBufferManager uses Gralloc interface to allocate Buffers
                                                                ///< 1 for TRUE, i.e CHIBufferManager uses CamXBufferManager interface to allocate Buffers
    UINT                    enableVSR;                          ///< Enable VSR Feature
                                                                ///< 0x0 - Disabled
                                                                ///< 0x1 - Video only
                                                                ///< 0x2 - Display and Video
    UINT                    enableVendorTagDump;                ///< 0 - disable
                                                                ///< 1 - enable
    UINT                    enhancePDLibDump;                   ///< Enable/Disable PD Library Data Dump Enhancement
                                                                ///< bit[0] - Enable enhanceDump, dump with ReqId and TimeStamp
                                                                ///< bit[15:1] - provide cameraId control
                                                                ///< sample: 0x9=0b'1001 dumpCameraId 4
    UINT                    exposeInternalModeForMultiCamUsecaseMask; ///< Pass in a mask to expose internal modes for different camera ids and selected usecases.
                                                                ///< The usecases should be specified at 1-nibble offsets in the mask, i.e. the lowest hex digit for
                                                                ///< physical camera ID 0, the next digit for ID 1, etc.
                                                                ///< The max mode index that can be specified by this override is 14 - 0xF (15) will be ignored.
                                                                ///< We can specify usecases for a max of 8 cameras
                                                                ///< Usecases supported:
                                                                ///< PseudoZSLXCFA Snapshot = 0x0
                                                                ///< Max                    = 0x1
                                                                ///< Example:
                                                                ///< Expose internal Mode for Camera id 0 and 1 for usecase PseudoZSLXCFA
                                                                ///< Value = 0xFFFFFF00
    UINT                    exposureTime;                       ///< Value of Exposure Time in nanoseconds
    UINT                    fdVendorTagReadOffset;              ///<  Based on where FD is connected in pipeline, this extra offset
                                                                ///< above pipeline delay can be increased so that 3A reads
                                                                ///< the tag after FD populates it
                                                                ///< FD in Titan:   IFE -> FD               ==> Offset = 1
                                                                ///< FD in Mimas2k: TFE -> OPE -> GPU -> FD ==> Offset = 2
    UINT                    feature1;                           ///< set tuning feature1
                                                                ///< None            = 0,
                                                                ///< ISPHDR          = 1,
                                                                ///< ADRC            = 2,
                                                                ///< InSensorHDR3Exp = 3
    UINT                    feature2;                           ///< set tuning feature2
                                                                ///< None           = 0,
                                                                ///< OISCapture     = 1,
                                                                ///< HLG            = 2,
                                                                ///< HDR10          = 3,
                                                                ///< MFNRBlend      = 4,
                                                                ///< MFNRPostFilter = 5,
                                                                ///< MFSRBlend      = 6,
                                                                ///< MFSRPostFilter = 7
    UINT                    forceCHIBufferManagerHeap;          ///< Force to use CHI Buffer Managers to use a specified heap if bufferHeap field is not explicitly set
                                                                ///< in CHIBufferManagerCreateData.
                                                                ///< 0 - System
                                                                ///< 1 - Ion
                                                                ///< 2 - DSP
                                                                ///< 3 - EGL (Gralloc)
    UINT                    forceHWMFFixedNumOfFrames;          ///< Integer to force HWMF fixed number of frames
                                                                ///< Disable                     = 0,
                                                                ///< Enable and num of frames    > 0
    UINT                    forceMaxFPS;                        ///< Do not pick a sensor mode above forceMaxFPS.  Primarily used for debugging.
                                                                ///< Set to a huge number to disable
    UINT                    forceNumberOfPixelsPerColorForXCFASWRemosaic; ///< Force Enable XCFA and SW Remosaic in Sensor Capability for Debug/Test purposes only
                                                                ///< 0  = NOT SW Remosaic
                                                                ///< 4  = 2x2 Patten SW Remosaic
                                                                ///< 9  = 3x3 patten SW Remosaic
                                                                ///< 16 = 4x4 Patten SW Remosaic
    UINT                    forceSWMFFixedNumOfFrames;          ///< Integer to force SWMF fixed number of frames
                                                                ///< Disable                     = 0,
                                                                ///< Enable and num of frames    > 0
    UINT                    forceToOverrideSettingsForInstantZoom; ///< Force to override the settings for instant zoom
    UINT                    forceToSelectUserTransitionTable;   ///< Force to select user transition table by specifying user transition table Id
                                                                ///< By default (0xFFFFFFFF), the user transition table is selected by static policy manager.
    UINT                    fovcEnable;                         ///< Enable/Disable Field Of View Compensation
    UINT                    fpsChangeInterval;                  ///< The minimal frame interval between fps change. 0 means disable.
                                                                ///< This value should be adjusted according to the requirement from video encoder.
    UINT                    gravityDataReportRate;              ///< Report rate for gravity data in microsecs
    UINT                    gyroDataReportRate;                 ///< Report rate for gyro data in microsecs
    UINT                    halBufferCacheMax;                  ///< The maximum buffer in cached mode when halBufferMgrMode is set to 2(cached mode)
                                                                ///< The value shall >= halBufferCacheMin and less than the max_buffers returned in configure_stream.
    UINT                    halBufferCacheMin;                  ///< The minimum buffer in cached mode when halBufferMgrMode is set to 2(cached mode)
                                                                ///< The value shall be great than 0 and less than the max_buffers returned in configure_stream.
    UINT                    halBufferMgrMode;                   ///< Set Hal Buffer Mgr mode
                                                                ///< 0:Disable hal buffer mgr mode
                                                                ///< 1:Backward compatible
                                                                ///< 2:Cached mode
    UINT                    hwlDebugDataBinaryDumpMask;         ///< NA
    UINT                    ihistStatsOffset;                   ///<  IHist stats will come from OPE in Mimas and Mimas2, So offset is needed in them
                                                                ///< Titan        : 0
                                                                ///< Mimas/Mimas2 : 1
    UINT                    imageBufferWaitTime;                ///< How long to wait for an image buffer to be free when all are busy in milliseconds.
    UINT                    induceFeature2ErrorType;            ///< Error Type need to be triggered by inducer
                                                                ///< 0: None
                                                                ///< 1: Buffer error
                                                                ///< 2: Metadata error
                                                                ///< 3: Request error
    UINT                    induceSleepInChiNode;               ///< Induce additional sleep in millisecond in chi nodes in offline pipeline.
                                                                ///< Induce sleep time more than 500 milliseconds for adversial test.
    UINT                    inducerErrorType;                   ///< Error Type need to be triggered by inducer
                                                                ///< 0: None
                                                                ///< 1: Fence Error
                                                                ///< 2: Fence Drop
                                                                ///< 3: Metadata Error
                                                                ///< 4: SBM Error
                                                                ///< 5: Request Error
                                                                ///< 6: System Event
    UINT                    inducerFeature2RequestId;           ///< For this reqId will trigger inducer
    UINT                    inducerKMDErrorCode;                ///< KMD ErrorCode of specific ErrorType need to be induced
                                                                ///< Sample values of ErrorCode specific to ErrorType
                                                                ///< CAM_REQ_MGR_CSID_FIFO_OVERFLOW_ERROR      - 4
                                                                ///< CAM_REQ_MGR_ISP_UNREPORTED_ERROR          - 0
                                                                ///< CAM_REQ_MGR_CSID_FATAL_ERROR              - 2
                                                                ///< CAM_REQ_MGR_JPEG_THUBNAIL_SIZE_ERROR      - 1
                                                                ///< CAM_SYNC_ICP_EVENT_FRAME_PROCESS_FAILURE  - 103, etc
    UINT                    inducerKMDErrorType;                ///< KMD Error Type need to be triggered by inducer
                                                                ///< Error Type sample values :
                                                                ///< CAM_REQ_MGR_ERROR_TYPE_RECOVERY           - 3
                                                                ///< CAM_REQ_MGR_ERROR_TYPE_SOF_FREEZE         - 4
                                                                ///< CAM_REQ_MGR_ERROR_TYPE_FULL_RECOVERY      - 5
                                                                ///< CAM_REQ_MGR_RETRY_EVENT                   - 1
                                                                ///< CAM_SYNC_STATE_SIGNALED_ERROR             - 3, etc
    UINT                    inducerKMDEventType;                ///< KMD Event Type need to be triggered by inducer
                                                                ///< 0: None
                                                                ///< 1: V4L2_EVENT - CRM Error
                                                                ///< 2: SYNC_EVENT - Sync/Fence Error
    UINT                    internalMultiresolutionMode;        ///< Internal MR Mode
                                                                ///< 0: Disable
                                                                ///< 1: Logical to physical stream for YUV, RAW streams using one buffer
                                                                ///< 2: Logical to physical stream for XCFA streams
    UINT                    invalidSOFThreshold;                ///< Threshold for Invalid SOF count in a pipeline for triggering recovery
                                                                ///< Default value:0 means no change
                                                                ///< Recommended Values: 3 to 16
                                                                ///< [Less than 3 can invoke false alarms, 16 - Twice of requestsQueueDepth]
    UINT                    jpegswContiguousOutput;             ///< JPEGSW node does memmove so that it gives contiguous output.  0 for FALSE, 1 for TRUE
    UINT                    lensPos;                            ///< Lens Position Which Interpreted Based on Manual Lens Control
    UINT                    limitedCameraMode;                  ///< Specify the scenario in which limited camera mode should be exercised
                                                                ///< 0: None
                                                                ///< 1: No EVA: Mark EVA not present in external camera hw
                                                                ///< 2: No GPU: Mark GPU not present in external camera hw
                                                                ///< 3: No NPU: Mark NPU not present in external camera hw
                                                                ///< 4: No External Camera HW: Mark EVA/GPU/NPU as not present in external camera hw
                                                                ///< 5: No External Camera Hw Plus Lesser IFE: Mark EVA/GPU/NP as not present in external camera hw
                                                                ///< and reduce the number of IFE to be within the threshold to stream camera
                                                                ///< 6: No External Camera Hw Plus Lesser SFE: Mark EVA/GPU/NP as not present in external camera hw
                                                                ///< and reduce the number of SFE to be within the threshold to stream camera
                                                                ///< 7: No External Camera Hw Plus Lesser IFE and SFE: Mark EVA/GPU/NP as not present in external camera hw
                                                                ///< and reduce the number of IFE and SFE to be within the threshold to stream camera
    UINT                    maxBuffersSecureCamera;             ///< Limits max_buffers of producer for secure camera usecase
    UINT                    maxDedicatedCameraMemory;           ///< The maximum dedicated memory for camera ImageBuffers is configured in bytes. It is used to release the peak
                                                                ///< memory usage from mempool group free list.this setting can be tune/configure by customer through checking
                                                                ///< different usecase which one has max peak usage.if maxDedicatedCameraMemory set to 0,it means disable release
                                                                ///< free list buffer.
    UINT                    maxHalRequests;                     ///< Max HAL requests the driver accepts before queueing.
    UINT                    maxImageBufferTimeoutCount;         ///< How many times to wait for an image buffer to be free when all are busy.
                                                                ///< Effective wait time = imageBufferWaitTime*MaxImageBufferTimeoutCount.
    UINT                    maxInOutResolution;                 ///< Maximum input output resolution for stream configuration
                                                                ///< Default value is 200MP
    UINT                    maxMemSpyStats;                     ///< The maximum number of MemSpy statistics to report
    UINT                    maxNonHfrFps;                       ///< Maximum fps bound exposed in capability to App in Non HFR mode
    UINT                    maxNumCameraCoreDump;               ///< Max number of camera core dump that system can have 
    UINT                    maxNumOfCamerasForFrameSync;        ///< The Max Num is limited by KMD
    UINT                    maxNumberOfAcceptedErrors;          ///< Limit the max number of duplicate result or notification related errors accepted
    UINT                    maxOptimizationVariationForInstantZoom; ///< Max optimization variation for instant zoom
    UINT                    maxRAWSizes;                        ///< Max RAW sizes exposed in static capability to APP and minimum should be 1
    UINT                    memSpyRequestRate;                  ///< Controls the printing of the Memspy runtime report every N requests (0 to disable)
    UINT                    memsetInputMeta;                    ///< Enable proving memset data to the nodes when input data for tag ID is
                                                                ///< NULL. 0 - disable, 1 - only properties, 2 - all tags.
    UINT                    minAuxFPS;                          ///< Minimum Aux Frame Rate of aux session
    UINT                    minFrameRateBound;                  ///< Minimum fps bound of frame duration for max resolution
    UINT                    minInOutResolution;                 ///< Minimum input output resolution for stream configuration
                                                                ///< Default value is 0MP
    UINT                    minReprocessInputHeight;            ///< Cap minimum reprocess height of input dimension supported by HAL.
                                                                ///< By default all sizes upto 5MP(2592x1944) will be advertised.
                                                                ///< Default value of this is 1944
    UINT                    minReprocessInputWidth;             ///< Cap minimum reprocess width of input dimension supported by HAL.
                                                                ///< By default all sizes upto 5MP(2592x1944) will be advertised.
                                                                ///< Default value of this is 2592
    UINT                    minReqFdDependency;                 ///< Can't set dependency on for FD on req id lesser than 5
    UINT                    multiCameraFPSMatchMask;            ///< Enable multi camera fps match for the specified usecase.
                                                                ///< This works only if multiCameraEnable is set.
                                                                ///< Disabled                                        = 0x0
                                                                ///< Enable FPS match for RTB                        = 0x1
                                                                ///< Enable FPS match for SAT                        = 0x2
                                                                ///< Enable FPS match for VR                         = 0x4
                                                                ///< Enable FPS match for PhyStream                  = 0x8
                                                                ///< Enable FPS match for all the usecae             = 0xF
    UINT                    multiCameraFrameSyncMask;           ///< Enable multi camera framework kernel frame sync for the
                                                                ///< specified usecase.
                                                                ///< This will help to apply both the real time request settings
                                                                ///< as close as possible.
                                                                ///< This works only if multiCameraEnable is set.
                                                                ///< Disabled                                         = 0x0
                                                                ///< Enable frame sync for RTB                        = 0x1
                                                                ///< Enable frame sync for SAT                        = 0x2
                                                                ///< Enable frame sync for VR                         = 0x4
                                                                ///< Enable frame sync for PhyStream                  = 0x8
                                                                ///< Enable frame sync for all the usecae             = 0xF
    UINT                    multiCameraHWSyncMask;              ///< Will limit enable HW sync to only the specified  usecase.
                                                                ///< This works only if multiCameraEnable is set.
                                                                ///< Disabled                                      = 0x0
                                                                ///< Enable HW sync for RTB                        = 0x1
                                                                ///< Enable HW sync for SAT                        = 0x2
                                                                ///< Enable HW sync for VR                         = 0x4
                                                                ///< Enable HW sync for PhyStream                  = 0x8
                                                                ///< Enable HW sync for all the usecae             = 0xF
    UINT                    multiCameraJPEG;                    ///< Enable/Disable JPEG Capture per Physical Camera
    UINT                    multiCameraSWFrameSyncInterval;     ///< Configure the frame interval to do the multi camera SW frame
                                                                ///< sync, the SW frame sync will be disabled if it is configured
                                                                ///< to 0.
                                                                ///< The supported interval is 4~8 to enable the SW frame sync which
                                                                ///< is based on the performance test, the default value is 5, we can
                                                                ///< increase the interval to 8 if we find any performance issues or
                                                                ///< frame drop issues which are caused by this feature.
    UINT                    multiCameraUseLegacyTables;         ///< Whether to use the XML generated tables or the legacy logical camera tables
    UINT                    multiCameraVREnable;                ///< Enable/Disable multi camera framework with VR
    UINT                    noCameraMode;                       ///< Specify the scenario in which no camera mode should be exercised
                                                                ///< 0: None
                                                                ///< 1: No Camera Present: camera is not present from camera enumeration
                                                                ///< 2: Camera Present: camera is present but internal hw does not meet the
                                                                ///< requirement for partial or limited camera
    UINT                    noRemosaicCaptureMode;              ///< NoRemosaic mode (Test purpose)
                                                                ///< 0: Disable
                                                                ///< 1: Force to enable NoRemosaic crop
                                                                ///< 2: Force to enable NoRemosaic XCFA snapshot
    UINT                    nodeResponseTime;                   ///< The time a node needs to process a request in Milliseconds. Used when taking the maximum time a pipeline is
                                                                ///< expected to be done.
    UINT                    numCameraCoreDumpReserved;          ///< The number of core dump reserved after recycling
    UINT                    numCameraOfflinelogReserved;        ///< The number of offlinelog reserved after recycling
    UINT                    numMetadataResults;                 ///< Max number of metadata results supported. Value > 1 means partial metadata results
                                                                ///< are enabled. 2 is the max value supported
    UINT                    numOfSensorOnIFH;                   ///< IFH mode doesn't probe real sensor and need to have limitation
    UINT                    numPCRsBeforeStreamOn;              ///< Set number of PCRs to handle before stream on
    UINT                    numWorkerThreads;                   ///< The number of threads to use in the device's threadpool
    UINT                    numberOfAELockFrames;               ///< Number of Frames where AE is locked for HW sync to latch on
    UINT                    numberOfAuxThreadMgrThreads;        ///< Allows to configure the number of aux thread mgr threads to be used
    UINT                    numberOfCHIThreads;                 ///< Allows to configure the number of CHI Threads to be used
    UINT                    numberOfFramesToSkip;               ///< Number of frames to skip after flash
    UINT                    offlineDumpAutoStopOffset;          ///< Offset of requests to stop dump to allow for flushing
    UINT                    offlineDumpBufSize;                 ///< Buffer Size for offline dump in Bytes
    UINT                    offlineDumpQueueDepth;              ///< Queue depth for offline dump
    UINT                    offlineLoggerBackupFileNumber;      ///< How many recently modify files need
                                                                ///< to be backed-up whenever crash event happens
    UINT                    offlineLoggerEnableBackupLog;       ///< Store a copy of backup log in other folder while crash event happened.
                                                                ///< Suggest enable for stress test.
                                                                ///< Disable = 0,
                                                                ///< Enable  = 1
    UINT                    offlineLoggerEnableDebugDump;       ///< Dump self debug information to file.
                                                                ///< Disable = 0,
                                                                ///< Enable  = 1
    UINT                    offlineLoggerMaxAllLogSize;         ///< Offline Log maximum total log size
    UINT                    offlineLoggerMinBackupRequire;      ///< Minimum requirement of device storage (MB)
                                                                ///< for backed-up the log file whenever crash event happens
    UINT                    offlineLoggerMinFlushCnt;           ///< Offline Log minium flush count
    UINT                    overrideAIStrengthControlFactor;    ///< override AI strenth control factor, including Segmentation Global Confidence and AI strength from UI.
                                                                ///< 0 not override; 1 for segnet out globalconfidence only; 2 for sw AI strength only; 3 for both;
    UINT                    overrideCameraClose;                ///< Camera close status.  0 for FALSE, 1 for TRUE
    UINT                    overrideCameraOpen;                 ///< Camera open status.  0 for FALSE, 1 for TRUE
    UINT                    overrideDeviceMemType;              ///< Device Type Based on Memory Capability
                                                                ///< High Memory (greater than 2GB) Device value is 0x00000001
                                                                ///< Low Memory (Less than 2GB) Device value is 0
    UINT                    overrideDisableZSL;                 ///< Do not select a ZSL usecase.  0 for FALSE, 1 for TRUE
    UINT                    overrideEnableMFNR;                 ///< Enable MFNR selection criteria
                                                                ///< FALSE   = 0,
                                                                ///< TRUE    = 1
    UINT                    overrideForceBurstShot;             ///< this setting helps to forcely enable Burshot
    UINT                    overrideForceCameraFDRendering;     ///< this setting helps to forcely enable FD rendering in Camera UI. When set to FALSE,
                                                                ///< behavior is determined by platform capabilities.
    UINT                    overrideForceSensorMode;            ///< Pass in an ID to force a specific sensor mode to be selected, and bypass the selection logic
    UINT                    overrideForceSensorModeMultiCam;    ///< Pass in a mask to force different sensor modes to be selected for different camera IDs,
                                                                ///< bypassing the selection logic.
                                                                ///< The modes should be specified at 1-nibble offsets in the mask, i.e. the lowest hex digit for
                                                                ///< physical camera ID 0, the next digit for ID 1, etc.
                                                                ///< The max mode index that can be specified by this override is 14 - 0xF (15) will be ignored and the override
                                                                ///< just for that camera ID will be disabled.
                                                                ///< This override will be ignored if it's used together with overrideForceSensorMode.
                                                                ///< Example:
                                                                ///< To force mode 8 (for camera ID 0), mode 4 (for ID 1), mode 0 (for ID 2) and nothing (for ID 3 etc.):
                                                                ///< overrideForceSensorModeMultiCam=0xFFFFF048
    UINT                    overrideForceUsecaseId;             ///< Pass in an ID to force a specific use case to be selected, and bypass the selection logic
    UINT                    overrideGPUDownscaleUsecase;        ///< Select only GPU Node Usecase.  0 for FALSE, 1 for TRUE
    UINT                    overrideGPURotationUsecase;         ///< Select only GPU Node Usecase.  0 for FALSE, 1 for TRUE
    UINT                    overrideHAFAlgoMask;                ///<  Bit Mask to control which HAF algorithm will be override
                                                                ///< Bit 0: Override CAF
                                                                ///< BIT 1: Override PDAF
                                                                ///< BIT 2: Override TOF
                                                                ///< BIT 3: Override default mixer
                                                                ///< BIT 4: Override AF Follower
                                                                ///< BIT 5: Override PDAF+TOF Mixer
    UINT                    overrideHFRNo3AUseCase;             ///< Select HFR without 3A Usecase.  0 for FALSE, 1 for TRUE
    UINT                    overrideImmediateImageBufferCountRealTimeVideo; ///< Number of Image Buffers to allocate for real time nodes. This is done in order to
                                                                ///< preallocate realtime target buffers. This will have an impact on the latency.
                                                                ///< Any positive value can be used as an override.
    UINT                    overrideMaxImageBufferCountNonRealTime; ///< Maximum number of Image Buffers to allocate for non-real time nodes
                                                                ///< 0xffffffff (-1) will completely disable the maximum image buffer count override
                                                                ///< Any positive value can be used as an override.
    UINT                    overrideMaxImageBufferCountRealTime; ///< Maximum number of Image Buffers to allocate for real time nodes
                                                                ///< 0xffffffff (-1) will completely disable the maximum image buffer count override
                                                                ///< Any positive value can be used as an override.
    UINT                    overrideOPPCLOCK;                   ///< Increase the sensor output pixel clock by x %
    UINT                    overridePDLibClose;                 ///< PDLib close status.  0 for FALSE, 1 for TRUE
    UINT                    overridePDLibOpen;                  ///< PDLib open status.  0 for FALSE, 1 for TRUE
    UINT                    overwriteJpegswOrientation;         ///< Orientation value can be 0/90/180/270/0xffffffff(-1).
                                                                ///< 0xffffffff(-1) - Orientation value will not be overwritten.
                                                                ///< If any other value is set JPEGSW node considers it as invalid.
    UINT                    partialCameraMode;                  ///< Specify the scenario in which partial camera mode should be exercised
                                                                ///< 0: None
                                                                ///< 1: Lesser IFE: reduce the number of IFE to be within the threshold to stream camera
                                                                ///< 2: Lesser SFE: reduce the number of SFE to be within the threshold to stream camera
                                                                ///< 3: Lesser IFE and SFE: reduce the number of IFE and SFE to be within the threshold to stream camera
    UINT                    preFlashMaxFrameWaitLimitAF;        ///< Max Frames to wait for AF to settle
    UINT                    preFlashMaxFrameWaitLimitAWB;       ///< Max Frames to wait for AWB to settle
    UINT                    presilFlushTimeOut;                 ///< Override flush timeout for Presil
    UINT                    presilMetadataPoolTimeOut;          ///< Override Metadata Pool timeout in Presil
    UINT                    presilNodeRequestDoneTimeout;       ///< Override Node request done timeout for Presil
    UINT                    presilPCRTimeOut;                   ///< Override Result timeout for PCR in Presil
    UINT                    presilPlatformVersion;              ///< CSL Platform version setting for presil development
    UINT                    presilSocId;                        ///< CSL Soc ID setting for presil development
    UINT                    profile3A;                          ///< Bit mask for profiling
                                                                ///< Bit       0: AEC module (Range- 0:Disable,1:Enable)
                                                                ///< Bit       1: AWB module (Range- 0:Disable,1:Enable)
                                                                ///< Bit       2: AFD module (Range- 0:Disable,1:Enable)
                                                                ///< Bit       3: ASD module (Range- 0:Disable,1:Enable)
                                                                ///< Bit       4: AF module  (Range- 0:Disable,1:Enable)
                                                                ///< Bit       5: PDLIB module (Range- 0:Disable,1:Enable)
                                                                ///< Bit      24: Camera ID based profiling (Range- 0:Disable,1:Enable)
                                                                ///< Bit 25 - 28: Camera ID (Range- 0-15)
                                                                ///< Bit      31: Time/Trace (Range- 0:Time,1:Trace)
                                                                ///< To enable multiple modules, set corresponding bits.
    UINT                    readSensorTemperature;              ///< Enable/Disable reading sensor temperature through I2C
    UINT                    reconnectCountOfHeartBeatMgr;       ///< Set the sample count to trigger HeartBeatMgr reconnect
                                                                ///< For example, 400 means HeartBeatMgr will trigger recovery when doesn't receive 400 sample.
    UINT                    rsStatsOffset;                      ///<  RS stats will come from OPE in Mimas, So offset is needed in Mimas
                                                                ///< Titan/Mimas2 : 0
                                                                ///< Mimas        : 1
    UINT                    ruleToApplyRealTimeZoomRatio;       ///< The zoom ratio from realtime request is considered applicable iff
                                                                ///< such zoom ratio apply to image produced by:
                                                                ///< 0 = any of the active camera
                                                                ///< 1 = all of the active camera
                                                                ///< 2 = realtime master camera
    UINT                    segMode;                            ///< Segmentation mode: 0 for normal mode, 1 for Dump mode
    UINT                    selectInSensorHDR3ExpUsecase;       ///< Select in-Sensor HDR 3 Exposure usecase and sensor mode:
                                                                ///< 0x0  = None
                                                                ///< 0x1  = Preview
                                                                ///< 0x2  = Seamless snapshot
                                                                ///< 0x10 = Force enable seamless snapshot (for debug usage only and please make sure current sensor is supported)
    UINT                    selectSHDRAutoExposureUsecase;      ///< Select SHDR and Auto Exposure usecase
                                                                ///< 0x0  = Disable
                                                                ///< 0x1  = Enable SHDR and run in fixed exposure count, fallback to 1exp for some special cases
                                                                ///< 0x2  = Enable SHDR and run in auto exposure count, fallback to 1exp for some special cases
    UINT                    sessionFallbackWaitTime;            ///< The time flush will wait after it has timed out (Do not factor this in with max flush wait time).
    UINT                    sessionMaxFlushWaitTime;            ///< The maximum amount of time flush should wait for regardless of what the maximum node reported is.
    UINT                    sessionResponseTimePadding;         ///< The padding time in milliseconds added to the maximum time reported by pipelines. Used by flush to let pipelines
                                                                ///< have some room to inject results and do other processing besides the request processing.
    UINT                    setAutoHDRMode;                     ///< Set Auto HDR mode
    UINT                    setHDRMode;                         ///< Set HDR mode
    UINT                    setMaxNoOfCoresJpegsw;              ///< Set Max no of CPU cores to be used by JPEGSW lib while encoding image.
    UINT                    setVideoBokehMode;                  ///< Select video bokeh mode for MCX case
                                                                ///< 1: DummyRTB
                                                                ///< 2: DepthBasedVideoBokeh(VBSE)
                                                                ///< 3: SegmentationBasedVideoBokeh
                                                                ///< 4: DepthBasedVideoBokeh(DFSDPP)
    UINT                    shdrHeight;                         ///< SHDR Height Output
    UINT                    shdrModeType;                       ///< Select between RAW and YUV SHDR
                                                                ///< SHDRLibRAWAlgoLIMode2Frame                    = 1,
                                                                ///< SHDRLibYUVAlgoVCMode2FrameGPUStats            = 2,
                                                                ///< SHDRLibYUVAlgoVCMode2FrameCPUStats            = 3,
                                                                ///< SHDRLibYUVAlgoLIMode3FrameGPUStats            = 4,
                                                                ///< SHDRLibYUVAlgoVCMode3FrameGPUStats            = 5,
    UINT                    shdrWidth;                          ///< SHDR Width Output
    UINT                    shdr_line_offset0;                  ///< It is used to hardcoded shdr_line_offset0 for debugging
    UINT                    shdr_line_offset1;                  ///< It is used to hardcoded shdr_line_offset1 for debugging
    UINT                    sizeThresToUseChiGrallocBuffer;     ///< If RDI resolution more than this threshold,then use chi gralloc interface to alloc buffer.
                                                                ///< Current threshold is 48Mpixels
    UINT                    sizeTrigOfflinelogRecycling;        ///< File system size (MB) less than this number will trigger camera offlinelog recycling 
    UINT                    spdStatsType;                       ///< Spotlight Detection Stats Type
    UINT                    statsProcessingSkipFactor;          ///< Factor to skip stats processing. e.g. 0: invalid. 1: No Skip. 2: skip 1 frame. 3: skip 2 frames
    UINT                    streamBufferStall;                  ///< Modify timeout for stream buffer manager to stall for a buffer
    UINT                    streamBufferWait;                   ///< Modify timeout for stream buffer manager to get a timeout
    UINT                    tfTestMode;                         ///< OVERRIDE_FS_TO_A_MAPPING = 1,
                                                                ///< DISABLE_REFIMEMENT       = 2,
                                                                ///< DISABLE_LMC              = 4,
                                                                ///< TEST_MCTF                = 0x7
    UINT                    thumbnailThreshold;                 ///< JPEG Thumbnail Threshold Size in Bytes
    UINT                    traceGroupsEnable;                  ///< Mask of which traces are enabled
    UINT                    trackerRoiMixer;                    ///< Tracker ROI Mixer Setting :
                                                                ///< 0x00 : Debug Disable
                                                                ///< 0x01 : enable Debug log
                                                                ///< 0x02 : enable Debug Dump
    UINT                    tuningDumpDataSizeBPS;              ///< Tuning data size reserved for BPS
    UINT                    tuningDumpDataSizeIFE;              ///< Tuning data reserved for IFE
    UINT                    tuningDumpDataSizeIPE;              ///< Tuning data size reserved for IPE.
                                                                ///< Size should be divisible without a remainder by the number of partitions and consider MFHDR size:
                                                                ///< i.e. (tuningDumpDataSizeIPE - tuningDumpDataSizeMFHDR) / DebugDataPartitionsIPE
    UINT                    tuningDumpDataSizeMFHDR;            ///< Tuning data size reserved for IPE MFHDR. IMPORTANT: if this value is change,
                                                                ///< must update "IPE tuning data size" tuningDumpDataSizeIPE
    UINT                    tuningDumpDataSizeOPE;              ///< Tuning data reserved for OPE
    UINT                    tuningDumpDataSizeTFE;              ///< Tuning data reserved for TFE
    UINT                    waitAllResultsTimeout;              ///< Timeout value when waiting for all results
    UINT                    yuvPlaneAlignment;                  ///< This is to update plane align value for internal YUV nodes
    UINT64                  CSIPHYAuxDatarateMax;               ///< CSIPHYAuxDatarateMax is the auxiliary datarate mask that specifies
                                                                ///< if we need to use auxiliary settings for a given Physical
    UINT64                  IFERegDumpMask;                     ///< IFETop          = 0x1
                                                                ///< Demux           = 0x2
                                                                ///< ChannelGain     = 0x4
                                                                ///< ChromaUp        = 0x8
                                                                ///< BPC_PDPC        = 0x10
                                                                ///< BinCorrect      = 0x20
                                                                ///< CompDecomp      = 0x40
                                                                ///< WB              = 0x80
                                                                ///< GIC             = 0x100
                                                                ///< BLS             = 0x200
                                                                ///< Bayer_GTM       = 0x400
                                                                ///< Bayer_LTM       = 0x800
                                                                ///< LCAC            = 0x1000
                                                                ///< Demosaic        = 0x2000
                                                                ///< ColorXform      = 0x4000
                                                                ///< UVG             = 0x8000
                                                                ///< Preprocessor    = 0x10000
                                                                ///< SparsePD        = 0x20000
                                                                ///< CompDecompHVXRX = 0x40000
                                                                ///< CompDecompHVXTX = 0x80000
                                                                ///< GTM_FD          = 0x100000
                                                                ///< BPC_ABF         = 0x200000
                                                                ///< LSC             = 0x400000
                                                                ///< ColorCorrect    = 0x800000
                                                                ///< GTMDMI          = 0x1000000
                                                                ///< Gamma           = 0x2000000
                                                                ///< Stats           = 0x4000000
                                                                ///< VidPath         = 0x80000000
                                                                ///< DispPath        = 0x10000000
                                                                ///< FD              = 0x20000000
                                                                ///< PixelRaw        = 0x40000000
                                                                ///< PDAF            = 0x80000000
                                                                ///< PDOUT           = 0x100000000
                                                                ///< LCR             = 0x200000000
                                                                ///< Common          = 0x400000000
                                                                ///< PreLSC1DPDPC    = 0x1000000000
                                                                ///< PostLSC1DPDPC   = 0x2000000000
                                                                ///< FCG             = 0x4000000000
                                                                ///< PostFCG1DPDPC   = 0x8000000000
                                                                ///< AllModule       = 0xF877ffffff
    UINT64                  autoImageDumpCVPinputPortMask;      ///< Input port mask CVP:
                                                                ///< CVPInputPortTARIFEFull               = 0x8;
                                                                ///< CVPInputPortREFIFEFull               = 0x10;
                                                                ///< CVPInputPortTARIFEDS4                = 0x20;
                                                                ///< CVPInputPortREFIFEDS4                = 0x40;
                                                                ///< CVPInputPortTARIFEDS16               = 0x80;
                                                                ///< CVPInputPortREFIFEDS16               = 0x100;
                                                                ///< CVPInputPortData                     = 0x200;
                                                                ///< CVPInputPortIFEDS4DELAY              = 0x200000000;
                                                                ///< CVPInputPortImageWarp                = 0x4000000000;
                                                                ///< ALLports                             = 0x42000003F8;
    UINT64                  autoImageDumpCVPoutputPortMask;     ///< Output port mask CVP:
                                                                ///< CVPOutputPortVector             = 0x1;
                                                                ///< CVPOutputPortData               = 0x2;
                                                                ///< CVPOutputPortImage              = 0x4;
                                                                ///< CVPOutputPortDMM                = 0x1000000000;
                                                                ///< CVPOutputPortSGM                = 0x2000000000;
                                                                ///< CVPOutputPortImageWarpStage1DSX = 0x8000000000;
                                                                ///< CVPOutputPortImageWarpStage1DS4 = 0x10000000000;
                                                                ///< CVPOutputPortImageWarpStage2DSX = 0x20000000000;
                                                                ///< CVPOutputPortImageWarpStage2DS4 = 0x40000000000;
                                                                ///< ALLports                        = 0x7B000000007;
    UINT64                  autoImageDumpIFEVirtualOutputPortMask; ///< Virtual output port mask:
                                                                ///< IFE:
                                                                ///< IFEOutputPortFullExposure1               = 0x1
                                                                ///< IFEOutputPortFullExposure2               = 0x2
                                                                ///< IFEOutputPortFullExposure3               = 0x4
                                                                ///< IFEOutputPortDS4Exposure1                = 0x8
                                                                ///< IFEOutputPortDS4Exposure2                = 0x10
                                                                ///< IFEOutputPortDS4Exposure3                = 0x20
                                                                ///< IFEOutputPortDS16Exposure1               = 0x40
                                                                ///< IFEOutputPortDS16Exposure2               = 0x80
                                                                ///< IFEOutputPortDS16Exposure3               = 0x100
                                                                ///< IFEOutputPortDisplayFullExposure1        = 0x200
                                                                ///< IFEOutputPortDisplayFullExposure2        = 0x400
                                                                ///< IFEOutputPortDisplayFullExposure3        = 0x800
                                                                ///< IFEOutputPortDisplayDS4Exposure1         = 0x1000
                                                                ///< IFEOutputPortDisplayDS4Exposure2         = 0x2000
                                                                ///< IFEOutputPortDisplayDS4Exposure3         = 0x4000
                                                                ///< IFEOutputPortDisplayDS16Exposure1        = 0x8000
                                                                ///< IFEOutputPortDisplayDS16Exposure2        = 0x10000
                                                                ///< IFEOutputPortDisplayDS16Exposure3        = 0x20000
                                                                ///< IFEOutputPortStatsAECBEExposure1         = 0x40000
                                                                ///< IFEOutputPortStatsAECBEExposure2         = 0x80000
                                                                ///< IFEOutputPortStatsAECBEExposure3         = 0x100000
                                                                ///< IFEOutputPortStatsAECBHISTExposure1      = 0x200000
                                                                ///< IFEOutputPortStatsAECBHISTExposure2      = 0x400000
                                                                ///< IFEOutputPortStatsAECBHISTExposure3      = 0x800000
                                                                ///< IFEOutputPortStatsTLBGExposure1          = 0x1000000
                                                                ///< IFEOutputPortStatsTLBGExposure2          = 0x2000000
                                                                ///< IFEOutputPortStatsTLBGExposure3          = 0x4000000
                                                                ///< IFEOutputPortStatsAWBBGExposure1         = 0x80000000
                                                                ///< IFEOutputPortStatsAWBBGExposure2         = 0x10000000
                                                                ///< IFEOutputPortStatsAWBBGExposure3         = 0x20000000
                                                                ///< IFEOutputPortStatsBFWExposure1           = 0x40000000
                                                                ///< IFEOutputPortStatsBFWExposure2           = 0x80000000
                                                                ///< IFEOutputPortStatsBFWExposure3           = 0x100000000
                                                                ///< IFEOutputPortStatsGTMBHISTExposure1      = 0x200000000
                                                                ///< IFEOutputPortStatsGTMBHISTExposure2      = 0x400000000
                                                                ///< IFEOutputPortStatsGTMBHISTExposure3      = 0x800000000
                                                                ///< IFEOutputPortStatsRSExposure1            = 0x1000000000
                                                                ///< IFEOutputPortStatsRSExposure2            = 0x2000000000
                                                                ///< IFEOutputPortStatsRSExposure3            = 0x4000000000
                                                                ///< IFEOutputPortStatsIHISTExposure1         = 0x8000000000
                                                                ///< IFEOutputPortStatsIHISTExposure2         = 0x10000000000
                                                                ///< IFEOutputPortStatsIHISTExposure3         = 0x20000000000
                                                                ///< IFEOutputPortStatsBFExposure1            = 0x40000000000
                                                                ///< IFEOutputPortStatsBFExposure2            = 0x80000000000
                                                                ///< IFEOutputPortStatsBFExposure3            = 0x100000000000
                                                                ///< IFEOutputPortLCRExposure1                = 0x200000000000
                                                                ///< IFEOutputPortLCRExposure2                = 0x400000000000
                                                                ///< IFEOutputPortLCRExposure3                = 0x800000000000
                                                                ///< IFEOutputPortSparsePDOutExposure1        = 0x1000000000000
                                                                ///< IFEOutputPortSparsePDOutExposure2        = 0x2000000000000
                                                                ///< IFEOutputPortSparsePDOutExposure3        = 0x4000000000000
                                                                ///< IFEOutputPortPDHWPreProcessedPDExposure1 = 0x8000000000000
                                                                ///< IFEOutputPortPDHWPreProcessedPDExposure2 = 0x10000000000000
                                                                ///< IFEOutputPortPDHWPreProcessedPDExposure3 = 0x20000000000000
                                                                ///< IFEOutputPortStatsDualPDExposure1        = 0x40000000000000
                                                                ///< IFEOutputPortStatsDualPDExposure2        = 0x80000000000000
                                                                ///< IFEOutputPortStatsDualPDExposure3        = 0x100000000000000
                                                                ///< IFEOutputPortStatsHDRBEExposure1         = 0x200000000000000
                                                                ///< IFEOutputPortStatsHDRBEExposure2         = 0x400000000000000
                                                                ///< IFEOutputPortStatsCAFExposure1           = 0x800000000000000
                                                                ///< IFEOutputPortStatsCAFExposure2           = 0x1000000000000000
                                                                ///< IFEOutputPortStatsCAFExposure3           = 0x2000000000000000
                                                                ///< IFEOutputPortStatsBayerRSExposure1       = 0x4000000000000000
                                                                ///< IFEOutputPortStatsBayerRSExposure2       = 0x8000000000000000
    UINT64                  autoImageDumpIFEoutputPortMask;     ///< Output port mask:
                                                                ///< IFE:
                                                                ///< IFEOutputPortFull                = 0x1
                                                                ///< IFEOutputPortDS4                 = 0x2
                                                                ///< IFEOutputPortDS16                = 0x4
                                                                ///< IFEOutputPortCAMIFRaw            = 0x8
                                                                ///< IFEOutputPortLSCRaw              = 0x10
                                                                ///< IFEOutputPortGTMRaw              = 0x20
                                                                ///< IFEOutputPortFD                  = 0x40
                                                                ///< IFEOutputPortPDAF                = 0x80
                                                                ///< IFEOutputPortRDI0                = 0x100
                                                                ///< IFEOutputPortRDI1                = 0x200
                                                                ///< IFEOutputPortRDI2                = 0x400
                                                                ///< IFEOutputPortRDI3                = 0x800
                                                                ///< IFEOutputPortStatsRS             = 0x1000
                                                                ///< IFEOutputPortStatsCS             = 0x2000
                                                                ///< IFEOutputPortStatsLTMDC          = 0x4000
                                                                ///< IFEOutputPortStatsIHIST          = 0x8000
                                                                ///< IFEOutputPortStatsBHIST          = 0x10000
                                                                ///< IFEOutputPortStatsHDRBE          = 0x20000
                                                                ///< IFEOutputPortStatsHDRBHIST       = 0x40000
                                                                ///< IFEOutputPortStatsTLBG           = 0x80000
                                                                ///< IFEOutputPortStatsBF             = 0x100000
                                                                ///< IFEOutputPortStatsAWBBG          = 0x200000
                                                                ///< IFEOutputPortDisplayFull         = 0x400000
                                                                ///< IFEOutputPortDisplayDS4          = 0x800000
                                                                ///< IFEOutputPortDisplayDS16         = 0x1000000
                                                                ///< IFEOutputPortStatsDualPD         = 0x2000000
                                                                ///< IFEOutputPortRDIRD               = 0x4000000
                                                                ///< IFEOutputPortLCR                 = 0x8000000
                                                                ///< IFEOutputPortPDHWPreProcessedPD  = 0x10000000
                                                                ///< IFEOutputPortStatsBFW            = 0x20000000
                                                                ///< IFEOutputPortStatsAECBE          = 0x40000000
                                                                ///< IFEOutputPortStatsLTMDC          = 0x80000000
                                                                ///< IFEOutputPortStatsGTMBHIST       = 0x100000000
                                                                ///< IFEOutputPortSparsePDOut         = 0x200000000
                                                                ///< IFELITEOutputPortStatsBG         = 0x400000000
                                                                ///< IFELITEOutputPortPreProcessRaw   = 0x800000000
                                                                ///< IFEOutputPortStatsAECBHIST       = 0x1000000000
                                                                ///< ALLports                         = 0x1FFFFFFFFF
                                                                ///< AllPixelOutput                   = 0x1C00047
                                                                ///< AllRawOutput                     = 0xFB8
                                                                ///< AllRDIOutput                     = 0xF00
                                                                ///< AllStatsOutput                   = 0x07FF000
    UINT64                  autoImageDumpIPEVirtualOutputPortMask; ///< Virtual output port mask for IPE:
                                                                ///< IPEExposureFusionOutputFull     = 0x1
                                                                ///< IPEExposureFusionOutputDS4      = 0x2
                                                                ///< IPEAlgm8BitOutput               = 0x4
                                                                ///< IPEAlgm16BitOutput              = 0x8
                                                                ///< ALLports                        = 0xF
    UINT64                  autoImageDumpIPEoutputPortMask;     ///< Output port mask for IPE:
                                                                ///< IPEOutputPortDisplay         = 0x100;
                                                                ///< IPEOutputPortVideo           = 0x200;
                                                                ///< IPEOutputPortFullRef         = 0x400;
                                                                ///< IPEOutputPortDS4Ref          = 0x800;
                                                                ///< IPEOutputPortDS16Ref         = 0x1000;
                                                                ///< IPEOutputPortDS64Ref         = 0x2000;
                                                                ///< IPEOutputPortApp             = 0x8000000000000
                                                                ///< IPEOutputPortHDR10           = 0x80000000000000
                                                                ///< IPEOutputPortImageFullALGM   = 0x100000000000000
                                                                ///< IPEOutputPortImageLTMStats   = 0x1000000000000000
                                                                ///< IPEOutputPortImageIHistStats = 0x2000000000000000
                                                                ///< IPEOutputPortImageGSSTATS    = 0x4000000000000000
                                                                ///< IPEOutputPortImageDS4GSSTATS = 0x8000000000000000
                                                                ///< ALLports                     = 0xF188000000003F00
    UINT64                  autoImageDumpTFEVirtualOutputPortMask; ///< Virtual output port mask:
                                                                ///< TFE:
                                                                ///< TFEOutputPortFullExposure1               = 0x1
                                                                ///< TFEOutputPortFullExposure2               = 0x2
                                                                ///< TFEOutputPortFullExposure3               = 0x4
                                                                ///< TFEOutputPortDS4Exposure1                = 0x8
                                                                ///< TFEOutputPortDS4Exposure2                = 0x10
                                                                ///< TFEOutputPortDS4Exposure3                = 0x20
                                                                ///< TFEOutputPortDS16Exposure1               = 0x40
                                                                ///< TFEOutputPortDS16Exposure2               = 0x80
                                                                ///< TFEOutputPortDS16Exposure3               = 0x100
                                                                ///< TFEOutputPortStatsAECBGExposure1         = 0x200
                                                                ///< TFEOutputPortStatsAECBGExposure2         = 0x400
                                                                ///< TFEOutputPortStatsAECBGExposure3         = 0x800
                                                                ///< TFEOutputPortStatsBHISTExposure1         = 0x1000
                                                                ///< TFEOutputPortStatsBHISTExposure2         = 0x2000
                                                                ///< TFEOutputPortStatsBHISTExposure3         = 0x4000
                                                                ///< TFEOutputPortStatsTLBGExposure1          = 0x8000
                                                                ///< TFEOutputPortStatsTLBGExposure2          = 0x10000
                                                                ///< TFEOutputPortStatsTLBGExposure3          = 0x20000
                                                                ///< TFEOutputPortStatsBAFExposure1           = 0x40000
                                                                ///< TFEOutputPortStatsBAFExposure2           = 0x80000
                                                                ///< TFEOutputPortStatsBAFExposure3           = 0x100000
                                                                ///< TFEOutputPortStatsAWBBGExposure1         = 0x200000
                                                                ///< TFEOutputPortStatsAWBBGExposure2         = 0x400000
                                                                ///< TFEOutputPortStatsAWBBGExposure3         = 0x800000
                                                                ///< TFEOutputPortStatsRSExposure1            = 0x1000000
                                                                ///< TFEOutputPortStatsRSExposure2            = 0x2000000
                                                                ///< TFEOutputPortStatsRSExposure3            = 0x4000000
                                                                ///< TFEOutputPortStatsDualPDExposure1        = 0x8000000
                                                                ///< TFEOutputPortStatsDualPDExposure2        = 0x10000000
                                                                ///< TFEOutputPortStatsDualPDExposure3        = 0x20000000
                                                                ///< TFEOutputPortPDPreProcessedExposure1     = 0x40000000
                                                                ///< TFEOutputPortPDPreProcessedExposure2     = 0x80000000
                                                                ///< TFEOutputPortPDPreProcessedExposure3     = 0x100000000
                                                                ///< TFEOutputPortPDparsedExposure1           = 0x200000000
                                                                ///< TFEOutputPortPDparsedExposure2           = 0x400000000
                                                                ///< TFEOutputPortPDparsedExposure3           = 0x800000000
    UINT64                  chiLogConfigMask;                   ///< Mask of which per frame/request config logs are output
    UINT64                  chiLogCoreCfgMask;                  ///< Mask of which core config logs are output
    UINT64                  chiLogDumpMask;                     ///< Mask of which Dump logs are output
    UINT64                  chiLogFullMask;                     ///< Mask of which Full logs are output
    UINT64                  chiLogInfoMask;                     ///< Mask of which info logs are output
    UINT64                  chiLogTraceMask;                    ///< Mask of which Trace logs are output
    UINT64                  chiLogVerboseMask;                  ///< Mask of which verbose logs are output
    UINT64                  chiLogWarningMask;                  ///< Mask of which warning logs are output
    UINT64                  chifeature2PortDump;                ///< Triggered by Recording start in video or offlineDump vendorTag
    UINT64                  disableSensorSubModules;            ///< Set this variable to disable specific camera sub modules
                                                                ///< Pass in a mask to force disable specific sensor sub module for different camera IDs.
                                                                ///< The sub module(s) mask should be specified at 1-nibble offsets in the mask, i.e. the lowest
                                                                ///< hex digit mask for cameraID/SlotID 0 sub modules, the next digit mask for  cameraID/SlotID 1, etc.
                                                                ///< Example:
                                                                ///< To disable EEPROM (for SlotID 0), Flash (for SlotID 1), Actuator and OIS (for SlotID 2) and nothing (for SlotID 3 etc.):
                                                                ///< disableSensorSubModules=0xA41
    UINT64                  dump3AStatsNum;                     ///< Number of frame need to dump
    UINT64                  dumpCHIImageBuffer;                 ///< 1. This enables dumping chi image buffers into /data/vendor/camera/
                                                                ///< 3. Set bitmask for specific feature(s) [Same as dumpChiMetadata above]
                                                                ///< May slow down FPS if dumping too many images at once
    UINT64                  dumpCHIMetadata;                    ///< 1. This enables printing specific metadata tags(tag Name) listed at /vendor/etc/camera/camxmetatagsfilter.txt
                                                                ///< Fore reference tag name, check list of tags available at /data/vendor/camera/metadata/metadatatable.txt
                                                                ///< 2. To enable entire Metadata Dump, refer to variable dumpCHIMetadataToFile
                                                                ///< 3. Set bitmask for specific feature(s) (Check g_feature2xmltypes.h)
    UINT64                  enableSensorDebugMask;              ///< Mask to enable sensor logs for feature specific debugging
                                                                ///< 0x01 = Mode Switch Logs
                                                                ///< 0x02 = AEB Logs
                                                                ///< 0x04 = CSI PHY Logs
    UINT64                  inducerRequestId;                   ///< For this reqId will trigger inducer
    UINT64                  initRegDumpMask;                    ///< IFETop          = 0x1
                                                                ///< Demux           = 0x2
                                                                ///< ChannelGain     = 0x4
                                                                ///< ChromaUp        = 0x8
                                                                ///< BPC_PDPC        = 0x10
                                                                ///< BinCorrect      = 0x20
                                                                ///< CompDecomp      = 0x40
                                                                ///< WB              = 0x80
                                                                ///< GIC             = 0x100
                                                                ///< BLS             = 0x200
                                                                ///< Bayer_GTM       = 0x400
                                                                ///< Bayer_LTM       = 0x800
                                                                ///< LCAC            = 0x1000
                                                                ///< Demosaic        = 0x2000
                                                                ///< ColorXform      = 0x4000
                                                                ///< UVG             = 0x8000
                                                                ///< Preprocessor    = 0x10000
                                                                ///< SparsePD        = 0x20000
                                                                ///< CompDecompHVXRX = 0x40000
                                                                ///< CompDecompHVXTX = 0x80000
                                                                ///< GTM_FD          = 0x100000
                                                                ///< BPC_ABF         = 0x200000
                                                                ///< LSC             = 0x400000
                                                                ///< ColorCorrect    = 0x800000
                                                                ///< GTMDMI          = 0x1000000
                                                                ///< Gamma           = 0x2000000
                                                                ///< Stats           = 0x4000000
                                                                ///< VidPath         = 0x80000000
                                                                ///< DispPath        = 0x10000000
                                                                ///< FD              = 0x20000000
                                                                ///< PixelRaw        = 0x40000000
                                                                ///< PDAF            = 0x80000000
                                                                ///< PDOUT           = 0x100000000
                                                                ///< LCR             = 0x200000000
                                                                ///< Common          = 0x400000000
                                                                ///< PreLSC1DPDPC    = 0x1000000000
                                                                ///< PostLSC1DPDPC   = 0x2000000000
                                                                ///< AllModule       = 0x3877ffffff
    UINT64                  logConfigMask;                      ///< Mask of which per frame/request config logs are output
    UINT64                  logCoreCfgMask;                     ///< Mask of which core config logs are output
    UINT64                  logDumpMask;                        ///< Mask of which Dump logs are output
    UINT64                  logEntryExitMask;                   ///< Mask of which entry/exit logs are output
    UINT64                  logInfoMask;                        ///< Mask of which info logs are output
    UINT64                  logPerfInfoMask;                    ///< Mask of which perf info logs are output
    UINT64                  logVerboseMask;                     ///< Mask of which verbose logs are output
    UINT64                  logWarningMask;                     ///< Mask of which warning logs are output
    UINT64                  overrideHideSensorModeMultiCam;     ///< Pass in a mask to hide certain sensor modes for different Sensor IDs,
                                                                ///< bypassing the selection logic.
                                                                ///< The modes will be idetnfied with the help of Active Array size and binning factor (override value)
                                                                ///< The binning factor should be specified at 1-nibble offsets in the mask, i.e. the lowest hex digit for
                                                                ///< Sensor ID 0 (Index 0 based), the next digit for ID 1, etc.
                                                                ///< For eg, there is 64MP Sensor and QCFA need to be hidden, then binningFactor=2 will hide any Sensor modes which
                                                                ///< has binning factor 2.
                                                                ///< SensorID value need to be derived from pSensorCaps, since there is no best way to handle this.
                                                                ///< It is tied up with sensorID in that structure.
                                                                ///< This override will be ignored if it's used together with either
                                                                ///< overrideForceSensorMode or overrideForceSensorModeMultiCam.
                                                                ///< Example:
                                                                ///< To force binning 8 (for sensor ID 0), 4 (for ID 1), 2 (for ID 2) and nothing (for ID 3 etc.):
                                                                ///< overrideHideSensorModeMultiCam=0x248
                                                                ///< Usage: First collect CamxLogGroupHWL Info boot up logs to identify which Sensor has what active Array Size.
                                                                ///< After that derive the value to set as override. Add the override and restart camera server or device.
    UINT64                  sensorExposureTime;                 ///< Camera exposure time in nanoseconds
    UINT64                  sensorMiddleExposureTime;           ///< Camera middle exposure time in nanoseconds
    UINT64                  sensorShortExposureTime;            ///< Camera short exposure time in nanoseconds
    overrideVideoDataspaceType overrideVideoDataspace;          ///< Video Dataspace
};

CAMX_NAMESPACE_END

#endif // G_CAMXSETTINGS_H
