////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: Parameter Parser V5.5.1 (2411131018)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxsensordriver.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXSENSORDRIVER_H
#define CAMXSENSORDRIVER_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "camxsensorcommon.h"

#define CAMX_NAMESPACE_BEGIN namespace CamX {
#define CAMX_NAMESPACE_END }

CAMX_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ModuleType
/// Comments:      Type of sensormodule
///                REAL: A real sensor module
///                VIRTUAL: A virtual sensor module such as Test Pattern Generator(TPG)
///                EXTERNAL: An external sensor module
///                DUPLICATE: A duplicate sensor module
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ModuleType
{
    REAL      = 0,
    VIRTUAL   = 1,
    EXTERNAL  = 2,
    DUPLICATE = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_ModuleType(
    ParameterFileSymbolTableEntry* const entry,
    ModuleType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorFeatureType
/// Comments:      Information about type of the sensor
///                Current Supported types are: NORMAL, AON(Always on sensor)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SensorFeatureType
{
    NORMAL = 0,
    AON    = 1
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_SensorFeatureType(
    ParameterFileSymbolTableEntry* const entry,
    SensorFeatureType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SlaveInformation
/// Comments:      Sensor slave information
///                element for sensorName
///                element for sensorLibName
///                element for sensor module type
///                element for sensorType
///                element for isGlobalShutter
///                element for slaveAddress
///                element for regAddrType
///                element for regDataType
///                element for sensorIdRegAddr
///                element for sensorId
///                element for sensorIdMask
///                element for i2cFrequencyMode
///                element for sensorGmslRealProbeInfo
///                element for sensorRegBankUnlockInfo
///                element for sensorRegBankLockInfo
///                element for powerUpSequence
///                element for powerDownSequence
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SlaveInformation
{
    /// Name of the sensor
    CHAR*                                sensorName;
    /// Name of the sensor library
    /// This sensor library name is optional and used only if sensor name xml differ than sensor library name
    UINT32                               sensorLibNameExists;
    UINT32                               sensorLibNameID;
    CHAR*                                sensorLibName;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// moduleType - Optional
    /// Default Value: REAL
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Type of sensormodule
    ///                REAL: A real sensor module
    ///                VIRTUAL: A virtual sensor module such as Test Pattern Generator(TPG)
    ///                EXTERNAL: An external sensor module
    ///                DUPLICATE: A duplicate sensor module
    ///                module type of the sensor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                               moduleTypeExists;
    UINT32                               moduleTypeID;
    ModuleType                           moduleType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorFeatureType - Optional
    /// Default Value: NORMAL
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Information about type of the sensor
    ///                Current Supported types are: NORMAL, AON(Always on sensor)
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                               sensorFeatureTypeExists;
    UINT32                               sensorFeatureTypeID;
    SensorFeatureType                    sensorFeatureType;
    /// Set the value to TRUE if the shutter type is global
    UINT32                               isGlobalShutterExists;
    UINT32                               isGlobalShutterID;
    BOOL                                 isGlobalShutter;
    /// 8-bit or 10-bit write slave address
    /// For External Sensors for which camx needs not probe the slave address shoule be as 0
    Hex32              slaveAddress;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regAddrType
    ///
    /// Range:         [1,4]
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CRegAddrDataType regAddrType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regDataType
    ///
    /// Range:         [1,4]
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CRegAddrDataType regDataType;
    /// Register address for sensor Id
    Hex32              sensorIdRegAddr;
    /// Sensor Id
    UINT32                               sensorId;
    /// Mask for sensor id. Sensor Id may only be few bits
    Hex32              sensorIdMask;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// i2cFrequencyMode
    /// Default Value: FAST_PLUS
    /// Comments:      I2C frequency mode of slave
    ///                Supported modes are: STANDARD (100 KHz), FAST (400 KHz), FAST_PLUS (1 MHz), CUSTOM (Custom frequency in
    ///                DTSI)
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CFrequencyMode   i2cFrequencyMode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorGmslRealProbeInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                               sensorGmslRealProbeInfoExists;
    UINT32                               sensorGmslRealProbeInfoID;
    SettingsInfo       sensorGmslRealProbeInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorRegBankUnlockInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                               sensorRegBankUnlockInfoExists;
    UINT32                               sensorRegBankUnlockInfoID;
    SettingsInfo       sensorRegBankUnlockInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorRegBankLockInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                               sensorRegBankLockInfoExists;
    UINT32                               sensorRegBankLockInfoID;
    SettingsInfo       sensorRegBankLockInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// powerUpSequence
    /// Comments:      Sequence of power configuration type and configuration value required to control power to the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PowerSequenceInfo  powerUpSequence;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// powerDownSequence
    /// Comments:      Sequence of power configuration type and configuration value required to control power to the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PowerSequenceInfo  powerDownSequence;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TransitionGroupsEnum
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class TransitionGroupsEnum
{
    NONE                 = 0,
    BINCROP43            = 1,
    BINQCFA43            = 2,
    BINHDR43             = 3,
    BINCROP169           = 4,
    BINQCFA169           = 5,
    BINHDR169            = 6,
    SHDR1SHDR243         = 7,
    SHDR1SHDR2169        = 8,
    SHDR2SHDR3           = 9,
    SHDR1SHDR3           = 10,
    SHDRALL              = 11,
    SHDRALL43            = 12,
    SHDRALL169           = 13,
    SHDRQCFA             = 14,
    SHDRBINCROP43        = 15,
    SHDR1SHDR2169FPS3060 = 16,
    SHDR1SHDR2169FPS60   = 17,
    BINIDCG43            = 18,
    TRANSITIONGROUPMAX   = 19
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_TransitionGroupsEnum(
    ParameterFileSymbolTableEntry* const entry,
    TransitionGroupsEnum& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TransitionGroupsList - Array
/// Min Length:    1
/// Max Length:    Unbounded
/// Comments:      List of semaless mode switch usecases that this sensor mode can support
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef TransitionGroupsEnum* TransitionGroupsList;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RegAddrInformation
/// Comments:      Addresses for various sensor registers
///                element for xOutput
///                element for yOutput
///                element for frameLengthLines
///                element for preShutterLengthLinesAddr
///                element for lineLengthPixelClock
///                element for coarseIntgTimeAddr
///                element for middleCoarseIntgTimeAddr
///                element for shortCoarseIntgTimeAddr
///                element for analog globalGainAddr
///                element for analog middleGlobalGainAddr
///                element for analog shortGlobalGainAddr
///                element for digitalGlobalGainAddr
///                element for middleDigitalGlobalGainAddr
///                element for shortDigitalGlobalGainAddr
///                element for digitalGainRedAddr
///                element for digitalGainGreenRedAddr
///                element for digitalGainBlueAddr
///                element for digitalGainGreenBlueAddr
///                element for testPatternRAddr
///                element for testPatternGRAddr
///                element for testPatternBAddr
///                element for testPatternGBAddr
///                element for strobeStartAddr
///                element for strobeWidthAddr
///                element for longCITLShiftAddr
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RegAddrInformation
{
    /// Register address to program width
    UINT32                   xOutput;
    /// Register address to program height
    UINT32                   yOutput;
    /// Register address to program Frame length lines
    UINT32                   frameLengthLines;
    /// Register address to program pre shutter length lines
    UINT32                   preShutterLengthLinesAddrExists;
    UINT32                   preShutterLengthLinesAddrID;
    UINT32                   preShutterLengthLinesAddr;
    /// Register address to program Line length pixel clock
    UINT32                   lineLengthPixelClock;
    /// Register address to program coarse integration time
    Hex32  coarseIntgTimeAddr;
    /// Register address to program middle coarse integration time
    /// This address is optional and must be provided if supported by sensor
    UINT32                   middleCoarseIntgTimeAddrExists;
    UINT32                   middleCoarseIntgTimeAddrID;
    UINT32                   middleCoarseIntgTimeAddr;
    /// Register address to program short coarse integration time
    /// This address is optional and must be provided if supported by sensor
    UINT32                   shortCoarseIntgTimeAddrExists;
    UINT32                   shortCoarseIntgTimeAddrID;
    UINT32                   shortCoarseIntgTimeAddr;
    /// Register address to program analog global gain channel
    Hex32  globalGainAddr;
    /// Register address to program middle global analog gain channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   middleGlobalGainAddrExists;
    UINT32                   middleGlobalGainAddrID;
    UINT32                   middleGlobalGainAddr;
    /// Register address to program short global analog gain channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   shortGlobalGainAddrExists;
    UINT32                   shortGlobalGainAddrID;
    UINT32                   shortGlobalGainAddr;
    /// Register address to program digital global gain channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   digitalGlobalGainAddrExists;
    UINT32                   digitalGlobalGainAddrID;
    Hex32  digitalGlobalGainAddr;
    /// Register address to program middle digital global gain channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   middleDigitalGlobalGainAddrExists;
    UINT32                   middleDigitalGlobalGainAddrID;
    UINT32                   middleDigitalGlobalGainAddr;
    /// Register address to program short digital global gain channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   shortDigitalGlobalGainAddrExists;
    UINT32                   shortDigitalGlobalGainAddrID;
    UINT32                   shortDigitalGlobalGainAddr;
    /// Register address to program digital gain for Red channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   digitalGainRedAddrExists;
    UINT32                   digitalGainRedAddrID;
    UINT32                   digitalGainRedAddr;
    /// Register address to program digital gain for green red channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   digitalGainGreenRedAddrExists;
    UINT32                   digitalGainGreenRedAddrID;
    UINT32                   digitalGainGreenRedAddr;
    /// Register address to program digital gain for blue channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   digitalGainBlueAddrExists;
    UINT32                   digitalGainBlueAddrID;
    UINT32                   digitalGainBlueAddr;
    /// Register address to program digital gain for green blue channel
    /// This address is optional and must be provided if supported by sensor
    UINT32                   digitalGainGreenBlueAddrExists;
    UINT32                   digitalGainGreenBlueAddrID;
    UINT32                   digitalGainGreenBlueAddr;
    /// Register address to program manual test pattern value for Red channel
    UINT32                   testPatternRAddr;
    /// Register address to program manual test pattern value for Green Red channel
    UINT32                   testPatternGRAddr;
    /// Register address to program manual test pattern value for Blue channel
    UINT32                   testPatternBAddr;
    /// Register address to program manual test pattern value for Green Blue channel
    UINT32                   testPatternGBAddr;
    /// Register address for strobe start time for IR LED only
    /// This address is optional and can be provided if supported by sensor
    UINT32                   strobeStartAddrExists;
    UINT32                   strobeStartAddrID;
    UINT32                   strobeStartAddr;
    /// Register address for strobe active time for IR LED only
    /// This address is optional and can be provided if supported by sensor
    UINT32                   strobeWidthAddrExists;
    UINT32                   strobeWidthAddrID;
    UINT32                   strobeWidthAddr;
    /// Register address to expand line length for long exposure mode
    /// This address is optional and can be provided if supported by sensor
    UINT32                   longCITLShiftAddrExists;
    UINT32                   longCITLShiftAddrID;
    UINT32                   longCITLShiftAddr;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ResolutionExposureInformation
/// Comments:      Resolution specific exposure control information
///                Update if its different than the common to common resolution exposure control information
///                if this information is not available, then info from common exposure control will be used
///                element for exposure type for which this information is being updated
///                element for coarseIntgTimeAddr
///                element for analog globalGainAddr
///                element for digitalGlobalGainAddr
///                element for maxAnalogGain
///                element for minAnalogGain
///                element for maxDigitalGain
///                element for minAnalogGain
///                element for maximum linecount
///                element for minimum linecount
///                element for verticalOffset
///                element for frameLengthLines
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ResolutionExposureInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// exposureType
    /// Default Value: DEFAULT
    /// Comments:      Information about exposure type
    ///                Supported types are DEFAULT, SHORT, MIDDLE
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExposureType exposureType;
    /// Register address to program coarse integration time in this resolution
    UINT32                         coarseIntgTimeAddrExists;
    UINT32                         coarseIntgTimeAddrID;
    UINT32                         coarseIntgTimeAddr;
    /// Register address to program analog global gain in this resolution
    UINT32                         globalGainAddrExists;
    UINT32                         globalGainAddrID;
    UINT32                         globalGainAddr;
    /// Register address to program digital gloabl gain in this resolution
    UINT32                         digitalGlobalGainAddrExists;
    UINT32                         digitalGlobalGainAddrID;
    UINT32                         digitalGlobalGainAddr;
    /// Maximum analog again supported by sensor in this resolution
    UINT32                         maxAnalogGainExists;
    UINT32                         maxAnalogGainID;
    double                         maxAnalogGain;
    /// Minimum analog again supported by sensor in this resolution
    UINT32                         minAnalogGainExists;
    UINT32                         minAnalogGainID;
    double                         minAnalogGain;
    /// Maximum digital again supported by sensor in this resolution
    UINT32                         maxDigitalGainExists;
    UINT32                         maxDigitalGainID;
    double                         maxDigitalGain;
    /// Minimum digital again supported by sensor in this resolution
    UINT32                         minDigitalGainExists;
    UINT32                         minDigitalGainID;
    double                         minDigitalGain;
    /// Maximum line count supported by sensor in this resolution
    UINT32                         maxLineCountExists;
    UINT32                         maxLineCountID;
    UINT32                         maxLineCount;
    /// Minimum line count supported by sensor in this resolution
    UINT32                         minLineCountExists;
    UINT32                         minLineCountID;
    UINT32                         minLineCount;
    /// Minimum offset to be maintained between
    /// line count and frame length lines in this resolution
    UINT32                         verticalOffsetExists;
    UINT32                         verticalOffsetID;
    UINT32                         verticalOffset;
    /// Register address to program frame length lines supported
    UINT32                         frameLengthLinesAddrExists;
    UINT32                         frameLengthLinesAddrID;
    UINT32                         frameLengthLinesAddr;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FrameOffsetInformation
/// Comments:      Addresses for various frame offset registers
///                This is optional and must be filled if sensor has frame offset regsiters
///                element for middleFrameOffsetAddr
///                element for shortFrameOffsetAddr
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FrameOffsetInformation
{
    /// Register address to program Frame Offset of Middle Exposure Frame
    /// This address is optional and must be provided if supported by sensor
    UINT32  middleFrameOffsetAddrExists;
    UINT32  middleFrameOffsetAddrID;
    UINT32  middleFrameOffsetAddr;
    /// Register address to program Frame Offset of Short Exposure Frame
    /// This address is optional and must be provided if supported by sensor
    UINT32  shortFrameOffsetAddrExists;
    UINT32  shortFrameOffsetAddrID;
    UINT32  shortFrameOffsetAddr;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// HDRExposureTypeInfo
/// Comments:      Information about HDR exposure
///                Supported types are ONEEXPOSURE, TWOEXPOSURE, THREEEXPOSURE
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class HDRExposureTypeInfo
{
    ONEEXPOSURE   = 0,
    TWOEXPOSURE   = 1,
    THREEEXPOSURE = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_HDRExposureTypeInfo(
    ParameterFileSymbolTableEntry* const entry,
    HDRExposureTypeInfo& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// QCFAHDRTypeInfo
/// Comments:      QCFA HDR type information.
///                PIXELINTERLEAVED: QCFA format like native pixel arrangement
///                ROWINTERLEAVED: Each exposure on different line via same VC-DT
///                ROWINLINEINTERLEAVED: Each exposure on different line via different VC-DT
///                Please refer to Sensor Front End guide for further details.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class QCFAHDRTypeInfo
{
    PIXELINTERLEAVED     = 0,
    ROWINTERLEAVED       = 1,
    ROWINLINEINTERLEAVED = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_QCFAHDRTypeInfo(
    ParameterFileSymbolTableEntry* const entry,
    QCFAHDRTypeInfo& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// QCFAHDRPatternInfo
/// Comments:      Valid patterns: MLSM, SMML, MSLM, LMMS, MLMS, SMLM, MSML, LMSM
///                In direction of readout - First Exposure, Second Exposure, Third Exposure, Fourth Exposure
///                L is long exposure, M is middle exposure and S is short exposure
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class QCFAHDRPatternInfo
{
    MLSM = 0,
    SMML = 1,
    MSLM = 2,
    LMMS = 3,
    MLMS = 4,
    SMLM = 5,
    MSML = 6,
    LMSM = 7
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_QCFAHDRPatternInfo(
    ParameterFileSymbolTableEntry* const entry,
    QCFAHDRPatternInfo& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// QCFAHDRInformation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct QCFAHDRInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// QHDRType
    /// Default Value: PIXELINTERLEAVED
    /// Comments:      QCFA HDR type information.
    ///                PIXELINTERLEAVED: QCFA format like native pixel arrangement
    ///                ROWINTERLEAVED: Each exposure on different line via same VC-DT
    ///                ROWINLINEINTERLEAVED: Each exposure on different line via different VC-DT
    ///                Please refer to Sensor Front End guide for further details.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    QCFAHDRTypeInfo     QHDRType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// QHDRPattern - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Valid patterns: MLSM, SMML, MSLM, LMMS, MLMS, SMLM, MSML, LMSM
    ///                In direction of readout - First Exposure, Second Exposure, Third Exposure, Fourth Exposure
    ///                L is long exposure, M is middle exposure and S is short exposure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32              QHDRPatternExists;
    UINT32              QHDRPatternID;
    QCFAHDRPatternInfo  QHDRPattern;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ColorFilterArrangement
/// Comments:      Color filter arrangement of the sensor
///                Supported filter arrangements are: BAYER_BGGR, BAYER_GBRG, BAYER_GRBG, BAYER_RGGB, BAYER_Y, YUV_UYVY,
///                YUV_YUYV
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ColorFilterArrangement
{
    BAYER_BGGR = 0,
    BAYER_GBRG = 1,
    BAYER_GRBG = 2,
    BAYER_RGGB = 3,
    BAYER_Y    = 4,
    YUV_UYVY   = 5,
    YUV_YUYV   = 6
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_ColorFilterArrangement(
    ParameterFileSymbolTableEntry* const entry,
    ColorFilterArrangement& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// DelayInfoType
/// Comments:      Indicates for which category the delay Info belongs to
///                Supported types are ExposureControl, Framesync. Framesync delay info is used for multi camera
///                synchronization
///                For all exposure control purposes ExposureControl type is used including the maxpipeline delay
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class DelayInfoType
{
    EXPOSURECONTROL = 0,
    FRAMESYNC       = 1
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_DelayInfoType(
    ParameterFileSymbolTableEntry* const entry,
    DelayInfoType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// VirtualChannel
///
/// Range:         [0,31]
/// Comments:      Virtual Channel of the data
///                Valid values for virtual channel range from 0 to 31
///                Please check the specific sensor documentation for additional information
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef UINT32 VirtualChannel;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// IntegrationInfo
/// Comments:      Integration related information for each resolution
///                element for integrationTimeMin
///                element for integrationTimeStep
///                element for integrationTimeMargin
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct IntegrationInfo
{
    /// Minimum integration time
    UINT32 integrationTimeMin;
    /// The step of integration time
    UINT32 integrationTimeStep;
    /// Integration time margin
    UINT32 integrationTimeMargin;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// StreamType
/// Comments:      Type of the stream
///                Supported stream types are: BLOB, IMAGE, PDAF, HDR, META, IMAGE_SHORT, IMAGE_MIDDLE, PDAF_VERTICAL,
///                PDAF_SHORT
///                PDAF_VERTICAL: Can be used to configure vertical PD in separate VC/DT from PDAF stream
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class StreamType
{
    BLOB          = 0,
    IMAGE         = 1,
    PDAF          = 2,
    HDR           = 3,
    META          = 4,
    IMAGE_SHORT   = 5,
    IMAGE_MIDDLE  = 6,
    PDAF_VERTICAL = 7,
    PDAF_SHORT    = 8,
    IMAGE1        = 9,
    IMAGE2        = 10,
    IMAGE3        = 11,
    MAX           = 12
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_StreamType(
    ParameterFileSymbolTableEntry* const entry,
    StreamType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TPGPatternType
/// Comments:      Test Pattern Generator Pattern Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class TPGPatternType
{
    INVALID                   = 0,
    REAL_IMAGE                = 1,
    RANDOM_PIXL               = 2,
    RANDOM_INCREMENTING_PIXEL = 3,
    COLOR_BAR                 = 4,
    ALTERNATING_55_AA         = 5,
    ALTERNATING_USER_DEFINED  = 6,
    MAX                       = 7
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_TPGPatternType(
    ParameterFileSymbolTableEntry* const entry,
    TPGPatternType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TPGColorBarMode
/// Comments:      Test Pattern Generator ColorBar Mode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class TPGColorBarMode
{
    INVALID  = 0,
    NORMAL   = 1,
    SPLIT    = 2,
    ROTATING = 3,
    MAX      = 4
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_TPGColorBarMode(
    ParameterFileSymbolTableEntry* const entry,
    TPGColorBarMode& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// StreamConfiguration
/// Comments:      Information for a stream data
///                element for vc
///                element for dt
///                element for dimension
///                element for bitWidth
///                element for type
///                element for patternType
///                element for colorBarMOde
///                element for colorBarPeriod
///                element for TPG Stream HBI
///                element for TPG Stream VBI
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct StreamConfiguration
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// vc - Array
    ///
    /// Default Value: 0
    /// Range:         [0,31]
    /// Min Length:    1
    /// Max Length:    2
    /// Comments:      Virtual Channel of the data
    ///                Valid values for virtual channel range from 0 to 31
    ///                Please check the specific sensor documentation for additional information
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                           vcCount;
    UINT32                           vcID;
    VirtualChannel*                  vc;
    /// Data type of the stream. Default value is 0x2B (10-bit RAW)
    Hex8           dt;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameDimension
    /// Comments:      Frame dimension: contains xStart, yStart, width and height
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FrameDimension frameDimension;
    /// Bit width of the data
    UINT32                           bitWidth;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// type
    /// Default Value: IMAGE
    /// Comments:      Type of the stream
    ///                Supported stream types are: BLOB, IMAGE, PDAF, HDR, META, IMAGE_SHORT, IMAGE_MIDDLE, PDAF_VERTICAL,
    ///                PDAF_SHORT
    ///                PDAF_VERTICAL: Can be used to configure vertical PD in separate VC/DT from PDAF stream
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    StreamType                       type;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// patternType - Optional
    /// Default Value: TPG_PATTERN_COLOR_BAR
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Test Pattern Generator Pattern Type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                           patternTypeExists;
    UINT32                           patternTypeID;
    TPGPatternType                   patternType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// colorBarMode - Optional
    /// Default Value: TPG_COLOR_BAR_MODE_NORMAL
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Test Pattern Generator ColorBar Mode
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                           colorBarModeExists;
    UINT32                           colorBarModeID;
    TPGColorBarMode                  colorBarMode;
    UINT32                           colorBarPeriodExists;
    UINT32                           colorBarPeriodID;
    UINT32                           colorBarPeriod;
    UINT32                           tpgStreamHBIExists;
    UINT32                           tpgStreamHBIID;
    UINT32                           tpgStreamHBI;
    UINT32                           tpgStreamVBIExists;
    UINT32                           tpgStreamVBIID;
    UINT32                           tpgStreamVBI;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// StreamInformation
/// Comments:      Stream information
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct StreamInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamConfiguration - Array
    /// Min Length:    1
    /// Max Length:    4
    /// Comments:      Information for a stream data
    ///                element for vc
    ///                element for dt
    ///                element for dimension
    ///                element for bitWidth
    ///                element for type
    ///                element for patternType
    ///                element for colorBarMOde
    ///                element for colorBarPeriod
    ///                element for TPG Stream HBI
    ///                element for TPG Stream VBI
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32               streamConfigurationCount;
    UINT32               streamConfigurationID;
    StreamConfiguration* streamConfiguration;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorCapability
/// Comments:      Capability / features supported in sensor
///                Supported features are: NORMAL, HFR, IHDR, PDAF, QUADCFA, ZZHDR, FASTAEC, DEPTH, SHDR, FS, INTERNAL
///                FS, typically, is a full size 120 fps mode and it's purpose is different from HFR
///                AONMD (AON Motion Detection events), AONFD(AON face detection events)
///                AONFDMIPI (AONFD with MIPI output)
///                EVS (Event-based Vision sensor)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SensorCapability
{
    NORMAL       = 0,
    HFR          = 1,
    IHDR         = 2,
    PDAF         = 3,
    QUADCFA      = 4,
    ZZHDR        = 5,
    FASTAEC      = 6,
    DEPTH        = 7,
    SHDR         = 8,
    FS           = 9,
    INSENSORZOOM = 10,
    AONMD        = 11,
    AONFD        = 12,
    AONFDMIPI    = 13,
    INTERNAL     = 14,
    QHDR         = 15,
    AEB          = 16,
    XCFA         = 17,
    XHDR         = 18,
    IDCG         = 19,
    EVS          = 20
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_SensorCapability(
    ParameterFileSymbolTableEntry* const entry,
    SensorCapability& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// CFAPixelType
/// Comments:      RED: set this pixel type for Red pixels
///                GREEN: set this pixel type for Green pixels
///                BLUE: set this pixel type for Blue pixels
///                INFRARED: set this pixel type for Infrared pixels
///                MONO: set this pixel type for Monochromatic pixels
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class CFAPixelType
{
    INVALID  = 0,
    RED      = 1,
    GREEN    = 2,
    BLUE     = 3,
    INFRARED = 4,
    MONO     = 5
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_CFAPixelType(
    ParameterFileSymbolTableEntry* const entry,
    CFAPixelType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// CFAPixelCoordinate
/// Comments:      xCoordinate: position of the pixel in the row on a 2D pattern
///                yCoordinate: position of the pixel in the col on a 2D pattern
///                exposureType: element to indicate exposure type for CFA HDR pattern mask
///                pixelType: element to indicate pixel type for CFA pattern mask
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct CFAPixelCoordinate
{
    UINT32                          xCoordinate;
    UINT32                          yCoordinate;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// exposureType - Optional
    /// Default Value: DEFAULT
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Information about exposure type
    ///                Supported types are DEFAULT, SHORT, MIDDLE
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          exposureTypeExists;
    UINT32                          exposureTypeID;
    ExposureType  exposureType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// pixelType
    /// Default Value: INVALID
    /// Comments:      RED: set this pixel type for Red pixels
    ///                GREEN: set this pixel type for Green pixels
    ///                BLUE: set this pixel type for Blue pixels
    ///                INFRARED: set this pixel type for Infrared pixels
    ///                MONO: set this pixel type for Monochromatic pixels
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CFAPixelType                    pixelType;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// CFAInformation
/// Comments:      numberOfPixelsPerColor: number of pixels per color in the pattern
///                patternWidth: Number of all color pixels in horizontal direction in the pattern
///                patternHeight: Number of all color pixels in Vertical direction in the pattern
///                pixelCoordinate: List of Pixel Coordinates in the pattern
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct CFAInformation
{
    UINT32              numberOfPixelsPerColor;
    UINT32              patternWidth;
    UINT32              patternHeight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// pixelCoordinate - Array
    /// Min Length:    4
    /// Max Length:    64
    /// Comments:      xCoordinate: position of the pixel in the row on a 2D pattern
    ///                yCoordinate: position of the pixel in the col on a 2D pattern
    ///                exposureType: element to indicate exposure type for CFA HDR pattern mask
    ///                pixelType: element to indicate pixel type for CFA pattern mask
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32              pixelCoordinateCount;
    UINT32              pixelCoordinateID;
    CFAPixelCoordinate* pixelCoordinate;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorCapabilityList - Array
/// Min Length:    1
/// Max Length:    Unbounded
/// Comments:      List of features / capabilities supported by sensor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef SensorCapability* SensorCapabilityList;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// MipiFlagsType
/// Comments:      Mipi flags that receiver needs to take care
///                Supported flags are: EPDEnabled, DSKEWCalibEnabled, PN9PatternEnabled
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class MipiFlagsType
{
    EPDEnabled        = 0,
    DSKEWCalibEnabled = 1,
    PN9PatternEnabled = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_MipiFlagsType(
    ParameterFileSymbolTableEntry* const entry,
    MipiFlagsType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// MipiFlagsList - Array
/// Min Length:    1
/// Max Length:    Unbounded
/// Comments:      List of Mipi flags that Mipi recever needs to take care of
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef MipiFlagsType* MipiFlagsList;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// HDR3ExposureTypeInfo
/// Comments:      This value represents 3-Exposure HDR sensor type
///                It indicates what types of sensor statistcs data output under 3-Exposure HDR mode
///                HDR3ExposureType1: split, merged statistics data
///                HDR3ExposureType2: split, merged and grid statistics data
///                HDR3ExposureType3: split, merged and ROI related statistics data
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class HDR3ExposureTypeInfo
{
    HDR3ExposureTypeUnknown = 0,
    HDR3ExposureType1       = 1,
    HDR3ExposureType2       = 2,
    HDR3ExposureType3       = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_HDR3ExposureTypeInfo(
    ParameterFileSymbolTableEntry* const entry,
    HDR3ExposureTypeInfo& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ZZHDRFirstExposurePattern
/// Comments:      This value represents whether short exposure or long exposure field comes first
///                for the red or blue color pixel in the pattern.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ZZHDRFirstExposurePattern
{
    SHORTEXPOSURE = 0,
    LONGEXPOSURE  = 1
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_ZZHDRFirstExposurePattern(
    ParameterFileSymbolTableEntry* const entry,
    ZZHDRFirstExposurePattern& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ZZHDRColorPattern
/// Comments:      This value represents the zzHDR pattern.
///                Valid patterns are: P0P1P0P0, P0P1P0P1, P0P0P1P0, P0P0P1P1, P0P0P0P1, P0P1P1P1, P0P1P1P0
///                Each pattern bit(P0 and P1) represents either long or short
///                exposure repeating pattern.
///                First bit of pattern would be interpreted based on ZZHDRFirstExposurePattern.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ZZHDRColorPattern
{
    P0P1P0P0 = 0,
    P0P1P0P1 = 1,
    P0P0P1P0 = 2,
    P0P0P1P1 = 3,
    P0P0P0P1 = 4,
    P0P1P1P1 = 5,
    P0P1P1P0 = 6
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_ZZHDRColorPattern(
    ParameterFileSymbolTableEntry* const entry,
    ZZHDRColorPattern& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// InputCropType
/// Comments:      This value represents Crop Type
///                CSIDCrop will be used to perform crop at CSID
///                SFE Crop will be used to perform crop at SFE crop IQ module
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class InputCropType
{
    CSIDCrop = 0,
    SFECrop  = 1
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_InputCropType(
    ParameterFileSymbolTableEntry* const entry,
    InputCropType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// BorderInformation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct BorderInformation
{
    UINT32         left;
    UINT32         right;
    UINT32         top;
    UINT32         bottom;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// cropType - Optional
    /// Default Value: CSIDCrop
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This value represents Crop Type
    ///                CSIDCrop will be used to perform crop at CSID
    ///                SFE Crop will be used to perform crop at SFE crop IQ module
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32         cropTypeExists;
    UINT32         cropTypeID;
    InputCropType  cropType;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PhaseType
/// Comments:      In a TOF sensor, the reflected light is sampled into different phases to measure phase shift
///                This value represents the number of phases that each pixel is sampled into
///                Valid patterns are: 2-Phase, 4-Phase
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class PhaseType
{
    TWOPHASE  = 0,
    FOURPHASE = 1
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_PhaseType(
    ParameterFileSymbolTableEntry* const entry,
    PhaseType& enumValue,
    BYTE const alignment);
/// List of light frequencies generated by IR emitter
typedef UINT32* FrequencyModulationList;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// DepthInformation
/// Comments:      Describes Depth Mode based information for Time-Of-Flight sensor
///                element for phaseType
///                element for isPhaseShuffle
///                element for isInterleavingMode
///                element for frequencyModulation
///                element for frequencyGCD
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct DepthInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// phaseType
    /// Comments:      In a TOF sensor, the reflected light is sampled into different phases to measure phase shift
    ///                This value represents the number of phases that each pixel is sampled into
    ///                Valid patterns are: 2-Phase, 4-Phase
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PhaseType phaseType;
    /// Indicates if the mode supports Phase shuffle
    /// If so, the sensor will generate alternate non-shuffle and shuffle frame
    /// In the shuffled frame, position of phases with 180 Deg difference, is shuffled
    BOOL      isPhaseShuffle;
    /// Indicates if the frames will be batched in an interleaving fashion
    /// Interleaving batching will batch multiple frequency frames together
    BOOL      isInterleavingMode;
    /// List of light frequencies generated by IR emitter
    /// List of light frequencies generated by the IR emitter of TOF sensor, to illuminate the scene
    /// Unit is Hz
    UINT32    frequencyModulationCount;
    UINT32    frequencyModulationID;
    UINT32*    frequencyModulation;
    /// This value is the Greatest Common Divisor of the different light frequencies supported by the mode
    /// The value is used to calculate the distance covered by the different light frequencies
    UINT32    frequencyGCDExists;
    UINT32    frequencyGCDID;
    UINT32    frequencyGCD;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RemosaicType
/// Comments:      This value represents Remosaic Type for QCFA and InSensor Crop modes
///                SWRemosaic indicates remosaic using software
///                HWRemosaic indicates insensor remosaic
///                NoRemosaic indicates RAW QCFA output without any remosaic
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class RemosaicType
{
    SWRemosaic = 0,
    HWRemosaic = 1,
    NoRemosaic = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_RemosaicType(
    ParameterFileSymbolTableEntry* const entry,
    RemosaicType& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// HDR3ExposureInformation
/// Comments:      Information of in-sensor HDR 3 exposure
///                HDR3ExposureType: exposure type for 3HDR non-seamless mode
///                numberOfLTCRatioRegCount: Number of LTC ratio registers
///                sensorLTCRatioAddr : Register address to program LTC ratio
///                InSensorHDR3ExpLineLengthPixelClock: LineLengthPixelClock for seamless in-sensor HDR 3 exp mode switching
///                InSensorHDR3ExpFrameLengthLines: FrameLengthLines for seamless in-sensor HDR 3 exp mode switching
///                InSensorHDR3ExpMaxAnalogGain: MaxAnalogGain for seamless in-sensor HDR 3 exp mode switching
///                InSensorHDR3ExpStartSettings: StartSetting sequence for seamless in-sensor HDR 3 exp mode switching
///                InSensorHDR3ExpStopSettings: StopSetting sequence for seamless in-sensor HDR 3 exp mode switching
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct HDR3ExposureInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HDR3ExposureType - Optional
    /// Default Value: 0
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This value represents 3-Exposure HDR sensor type
    ///                It indicates what types of sensor statistcs data output under 3-Exposure HDR mode
    ///                HDR3ExposureType1: split, merged statistics data
    ///                HDR3ExposureType2: split, merged and grid statistics data
    ///                HDR3ExposureType3: split, merged and ROI related statistics data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          HDR3ExposureTypeExists;
    UINT32                          HDR3ExposureTypeID;
    HDR3ExposureTypeInfo            HDR3ExposureType;
    UINT32                          sensorLTCRatioAddrExists;
    UINT32                          sensorLTCRatioAddrID;
    UINT32                          sensorLTCRatioAddr;
    UINT32                          numberOfLTCRatioRegCountExists;
    UINT32                          numberOfLTCRatioRegCountID;
    UINT32                          numberOfLTCRatioRegCount;
    UINT32                          InSensorHDR3ExpLineLengthPixelClockExists;
    UINT32                          InSensorHDR3ExpLineLengthPixelClockID;
    UINT32                          InSensorHDR3ExpLineLengthPixelClock;
    UINT32                          InSensorHDR3ExpFrameLengthLinesExists;
    UINT32                          InSensorHDR3ExpFrameLengthLinesID;
    UINT32                          InSensorHDR3ExpFrameLengthLines;
    UINT32                          InSensorHDR3ExpMaxAnalogGainExists;
    UINT32                          InSensorHDR3ExpMaxAnalogGainID;
    double                          InSensorHDR3ExpMaxAnalogGain;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// InSensorHDR3ExpStartSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          InSensorHDR3ExpStartSettingsExists;
    UINT32                          InSensorHDR3ExpStartSettingsID;
    SettingsInfo  InSensorHDR3ExpStartSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// InSensorHDR3ExpStopSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          InSensorHDR3ExpStopSettingsExists;
    UINT32                          InSensorHDR3ExpStopSettingsID;
    SettingsInfo  InSensorHDR3ExpStopSettings;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ZZHDRInformation
/// Comments:      ZZHDR color pattern and first exposure information
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ZZHDRInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ZZHDRPattern - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This value represents the zzHDR pattern.
    ///                Valid patterns are: P0P1P0P0, P0P1P0P1, P0P0P1P0, P0P0P1P1, P0P0P0P1, P0P1P1P1, P0P1P1P0
    ///                Each pattern bit(P0 and P1) represents either long or short
    ///                exposure repeating pattern.
    ///                First bit of pattern would be interpreted based on ZZHDRFirstExposurePattern.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                     ZZHDRPatternExists;
    UINT32                     ZZHDRPatternID;
    ZZHDRColorPattern          ZZHDRPattern;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ZZHDRFirstExposure - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This value represents whether short exposure or long exposure field comes first
    ///                for the red or blue color pixel in the pattern.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                     ZZHDRFirstExposureExists;
    UINT32                     ZZHDRFirstExposureID;
    ZZHDRFirstExposurePattern  ZZHDRFirstExposure;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ModeSwitchRegisterInformation
/// Comments:      Register settings and register addresses to be programmed during seamless mode switch
///                element for regAddrType
///                element for regDataType
///                element for register address to program PDAF virtual channel
///                element for register address to program IMAGE(long/default) stream virtual channel
///                element for register address to program IMAGE SHORT virtual channel
///                element for register address to program IMAGE MIDDLE virtual channel
///                element for register address to program BLOB virtual channel
///                element for register address to program HDR virtual channel
///                element for register address to program META virtual channel
///                element for register address to program PDAF Vertical virtual channel
///                element for register address to program PDAF SHORT virtual channel
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ModeSwitchRegisterInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regAddrType - Optional
    ///
    /// Range:         [1,4]
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                                regAddrTypeExists;
    UINT32                                regAddrTypeID;
    I2CRegAddrDataType  regAddrType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regDataType - Optional
    ///
    /// Range:         [1,4]
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                                regDataTypeExists;
    UINT32                                regDataTypeID;
    I2CRegAddrDataType  regDataType;
    /// Register address to program virtual channel for PDAF data
    UINT32                                PDAFVCAddressCount;
    UINT32                                PDAFVCAddressID;
    UINT32*                               PDAFVCAddress;
    /// Register address to program virtual channel for Image(long/default) stream data
    UINT32                                ImageLongVCAddressExists;
    UINT32                                ImageLongVCAddressID;
    UINT32                                ImageLongVCAddress;
    /// Register address to program virtual channel for short exposure image stream data
    UINT32                                ImageShortVCAddressExists;
    UINT32                                ImageShortVCAddressID;
    UINT32                                ImageShortVCAddress;
    /// Register address to program virtual channel for middle exposure image stream data
    UINT32                                ImageMiddleVCAddressExists;
    UINT32                                ImageMiddleVCAddressID;
    UINT32                                ImageMiddleVCAddress;
    /// Register address to program virtual channel for blob stream data
    UINT32                                BlobVCAddressExists;
    UINT32                                BlobVCAddressID;
    UINT32                                BlobVCAddress;
    /// Register address to program virtual channel for HDR stream data
    UINT32                                HDRVCAddressExists;
    UINT32                                HDRVCAddressID;
    UINT32                                HDRVCAddress;
    /// Register address to program virtual channel for meta stream data
    UINT32                                MetaVCAddressExists;
    UINT32                                MetaVCAddressID;
    UINT32                                MetaVCAddress;
    /// Register address to program virtual channel for PDAF vertical data
    UINT32                                PDAFVerticalVCAddressCount;
    UINT32                                PDAFVerticalVCAddressID;
    UINT32*                               PDAFVerticalVCAddress;
    /// Register address to program virtual channel for short frame's PDAF data
    UINT32                                PDAFShortVCAddressCount;
    UINT32                                PDAFShortVCAddressID;
    UINT32*                               PDAFShortVCAddress;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ResolutionData
/// Comments:      element for transitionGroups
///                element for colorFilterArrangement
///                element for streamInfo
///                element for MCLK disable needed or not
///                element for lineLengthPixelClock
///                element for frameLengthLines
///                element for minHorizontalBlanking
///                element for minVerticalBlanking
///                element for outputPixelClock
///                element for horizontalBinning
///                element for verticalBinning
///                element for frameRate
///                element for activeLinesTransmissionTimeUS
///                element for laneCount
///                element for downScaleFactor
///                element for settleTimeNs
///                element for is3Phase
///                element for integrationInfo
///                element for resSettings
///                element for group hold on settings
///                element for group hold off settings
///                element for cropInfo
///                element for resolution specific exposure control Information
///                element for resolution specific exposure control Information
///                element for Frame Offset Information
///                element to specify type of HDR exposure
///                element for ZZHDR Information
///                element for 3-Exposure HDR Information
///                element for isOverlappedSHDRSupported
///                element for isNDOLSupported
///                element for RemosaicType Information
///                element for capability
///                element for ADCReadoutTime
///                element for MipiFlags
///                element for maxAnalogGain
///                element for QCFA HDR information
///                element for Depth information
///                element for PDAF Mode
///                element for tpgPhyClock
///                element for skipPattern
///                element for fine integration linecount
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ResolutionData
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CFAInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      numberOfPixelsPerColor: number of pixels per color in the pattern
    ///                patternWidth: Number of all color pixels in horizontal direction in the pattern
    ///                patternHeight: Number of all color pixels in Vertical direction in the pattern
    ///                pixelCoordinate: List of Pixel Coordinates in the pattern
    ///                Indicates the color filter arrangement pattern for the sensor mode.
    ///                This field is mandatory for XCFA and XHDR capability modes.
    ///                Please refer to the sensor bringup guide for further details with
    ///                diagrams for more details.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          CFAInfoExists;
    UINT32                          CFAInfoID;
    CFAInformation                  CFAInfo;
    /// Indicates the number of pixels per color
    /// Please refer to the sensor bringup guide for further details.
    UINT32                          numPixelsPerColorExists;
    UINT32                          numPixelsPerColorID;
    UINT32                          numPixelsPerColor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// transitionGroups - Array
    /// Default Value: NONE
    /// Min Length:    0
    /// Max Length:    Unbounded
    /// Comments:      List of semaless mode switch usecases that this sensor mode can support
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          transitionGroupsCount;
    UINT32                          transitionGroupsID;
    TransitionGroupsList            transitionGroups;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// colorFilterArrangement
    /// Comments:      Color filter arrangement of the sensor
    ///                Supported filter arrangements are: BAYER_BGGR, BAYER_GBRG, BAYER_GRBG, BAYER_RGGB, BAYER_Y, YUV_UYVY,
    ///                YUV_YUYV
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ColorFilterArrangement          colorFilterArrangement;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamInfo
    /// Comments:      Stream information
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    StreamInformation               streamInfo;
    /// Indicates whether this particular mode requires MCLK or not
    /// Set it to TRUE when this sensor needs MCLK but this mode doesnt need it
    UINT32                          isClockDisableNeededExists;
    UINT32                          isClockDisableNeededID;
    BOOL                            isClockDisableNeeded;
    /// Line length pixel clock of frame
    /// Typically this value is the active width + blanking width
    UINT32                          lineLengthPixelClock;
    /// Frame length lines of frame
    /// Typically this value is the active height + blanking height
    UINT32                          frameLengthLines;
    /// Minimum horizontal blanking interval in pixels
    UINT32                          minHorizontalBlanking;
    /// Minimum horizontal blanking interval in lines
    UINT32                          minVerticalBlanking;
    /// Output pixel clock
    UINT32                          outputPixelClock;
    /// Horizontal binning value
    UINT32                          horizontalBinning;
    /// Vertical binning value
    UINT32                          verticalBinning;
    /// Maximum frame rate
    double                          frameRate;
    /// Active lines transmission time in microsecond.
    /// Get the time from CSID SOF/EOF irq log.
    UINT32                          activeLinesTransmissionTimeUSExists;
    UINT32                          activeLinesTransmissionTimeUSID;
    UINT32                          activeLinesTransmissionTimeUS;
    /// Number of lanes in which the data is streamed
    UINT32                          laneCount;
    /// The value is a ratio, and the sensors are able only to downscale.
    /// It must be 1.00 or greater at all times.
    UINT32                          downScaleFactorExists;
    UINT32                          downScaleFactorID;
    float                           downScaleFactor;
    /// Settle time in nano seconds
    UINT32                          settleTimeNs;
    /// Flag to know if the sensor is a 3phase sensor
    UINT32                          is3Phase;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// integrationInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Integration related information for each resolution
    ///                element for integrationTimeMin
    ///                element for integrationTimeStep
    ///                element for integrationTimeMargin
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          integrationInfoExists;
    UINT32                          integrationInfoID;
    IntegrationInfo                 integrationInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// resSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  resSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// groupHoldOnSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          groupHoldOnSettingsExists;
    UINT32                          groupHoldOnSettingsID;
    SettingsInfo  groupHoldOnSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// groupHoldOffSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          groupHoldOffSettingsExists;
    UINT32                          groupHoldOffSettingsID;
    SettingsInfo  groupHoldOffSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// cropInfo - Array
    /// Min Length:    1
    /// Max Length:    2
    /// Comments:      Crop information for the frame
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          cropInfoCount;
    UINT32                          cropInfoID;
    BorderInformation*              cropInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// exposureInfo - Array
    /// Min Length:    0
    /// Max Length:    3
    /// Comments:      Resolution specific exposure control information
    ///                Update if its different than the common to common resolution exposure control information
    ///                if this information is not available, then info from common exposure control will be used
    ///                element for exposure type for which this information is being updated
    ///                element for coarseIntgTimeAddr
    ///                element for analog globalGainAddr
    ///                element for digitalGlobalGainAddr
    ///                element for maxAnalogGain
    ///                element for minAnalogGain
    ///                element for maxDigitalGain
    ///                element for minAnalogGain
    ///                element for maximum linecount
    ///                element for minimum linecount
    ///                element for verticalOffset
    ///                element for frameLengthLines
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          exposureInfoCount;
    UINT32                          exposureInfoID;
    ResolutionExposureInformation*  exposureInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// modeSwitchRegInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Register settings and register addresses to be programmed during seamless mode switch
    ///                element for regAddrType
    ///                element for regDataType
    ///                element for register address to program PDAF virtual channel
    ///                element for register address to program IMAGE(long/default) stream virtual channel
    ///                element for register address to program IMAGE SHORT virtual channel
    ///                element for register address to program IMAGE MIDDLE virtual channel
    ///                element for register address to program BLOB virtual channel
    ///                element for register address to program HDR virtual channel
    ///                element for register address to program META virtual channel
    ///                element for register address to program PDAF Vertical virtual channel
    ///                element for register address to program PDAF SHORT virtual channel
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          modeSwitchRegInfoExists;
    UINT32                          modeSwitchRegInfoID;
    ModeSwitchRegisterInformation   modeSwitchRegInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameOffsetInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Addresses for various frame offset registers
    ///                This is optional and must be filled if sensor has frame offset regsiters
    ///                element for middleFrameOffsetAddr
    ///                element for shortFrameOffsetAddr
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          frameOffsetInfoExists;
    UINT32                          frameOffsetInfoID;
    FrameOffsetInformation          frameOffsetInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HDRExposureType - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Information about HDR exposure
    ///                Supported types are ONEEXPOSURE, TWOEXPOSURE, THREEEXPOSURE
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          HDRExposureTypeExists;
    UINT32                          HDRExposureTypeID;
    HDRExposureTypeInfo             HDRExposureType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ZZHDRInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      ZZHDR color pattern and first exposure information
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          ZZHDRInfoExists;
    UINT32                          ZZHDRInfoID;
    ZZHDRInformation                ZZHDRInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HDR3ExposureInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Information of in-sensor HDR 3 exposure
    ///                HDR3ExposureType: exposure type for 3HDR non-seamless mode
    ///                numberOfLTCRatioRegCount: Number of LTC ratio registers
    ///                sensorLTCRatioAddr : Register address to program LTC ratio
    ///                InSensorHDR3ExpLineLengthPixelClock: LineLengthPixelClock for seamless in-sensor HDR 3 exp mode switching
    ///                InSensorHDR3ExpFrameLengthLines: FrameLengthLines for seamless in-sensor HDR 3 exp mode switching
    ///                InSensorHDR3ExpMaxAnalogGain: MaxAnalogGain for seamless in-sensor HDR 3 exp mode switching
    ///                InSensorHDR3ExpStartSettings: StartSetting sequence for seamless in-sensor HDR 3 exp mode switching
    ///                InSensorHDR3ExpStopSettings: StopSetting sequence for seamless in-sensor HDR 3 exp mode switching
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          HDR3ExposureInfoExists;
    UINT32                          HDR3ExposureInfoID;
    HDR3ExposureInformation         HDR3ExposureInfo;
    /// Set the value to TRUE if the sensor mode supports overlapped SHDR
    /// SHDR is said to be overlapped when the readout of Long Exposure Frame of next Request (Req N+1)
    /// overlaps with the readout of Middle/Short Exposure Frames of the previous Request (Req N)
    UINT32                          isOverlappedSHDRSupportedExists;
    UINT32                          isOverlappedSHDRSupportedID;
    BOOL                            isOverlappedSHDRSupported;
    /// Set the value to TRUE if the sensor mode supports SHDR type - NDOL
    /// NDOL is a type of Staggered HDR where the readout of Short/Middle Exposure Frame
    /// does not overlap over the Long/Middle Exposure Frame
    UINT32                          isNDOLSupportedExists;
    UINT32                          isNDOLSupportedID;
    BOOL                            isNDOLSupported;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// RemosaicTypeInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This value represents Remosaic Type for QCFA and InSensor Crop modes
    ///                SWRemosaic indicates remosaic using software
    ///                HWRemosaic indicates insensor remosaic
    ///                NoRemosaic indicates RAW QCFA output without any remosaic
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          RemosaicTypeInfoExists;
    UINT32                          RemosaicTypeInfoID;
    RemosaicType                    RemosaicTypeInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// capability - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      List of features / capabilities supported by sensor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          capabilityCount;
    UINT32                          capabilityID;
    SensorCapabilityList            capability;
    /// Analog to digital conversion time for the sensor. Time specified in milliseconds
    UINT32                          ADCReadoutTimeExists;
    UINT32                          ADCReadoutTimeID;
    double                          ADCReadoutTime;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mipiFlags - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    /// Comments:      List of Mipi flags that Mipi recever needs to take care of
    ///                Any extra mipi parameters that recevier should take care of
    ///                EPDEnabled, DSKEWCalibEnabled
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          mipiFlagsCount;
    UINT32                          mipiFlagsID;
    MipiFlagsList                   mipiFlags;
    /// Maximum analog again supported by current sensor mode
    UINT32                          maxAnalogGainExists;
    UINT32                          maxAnalogGainID;
    double                          maxAnalogGain;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// QHDRInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          QHDRInfoExists;
    UINT32                          QHDRInfoID;
    QCFAHDRInformation              QHDRInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// depthInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Describes Depth Mode based information for Time-Of-Flight sensor
    ///                element for phaseType
    ///                element for isPhaseShuffle
    ///                element for isInterleavingMode
    ///                element for frequencyModulation
    ///                element for frequencyGCD
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          depthInfoExists;
    UINT32                          depthInfoID;
    DepthInformation                depthInfo;
    /// This should be mapped to valid PDAF Mode Key. Each PDAF Mode is given
    /// a user defined mode key to link sensor mode to correct PDAF mode.
    /// For example:
    /// Sensor Driver PDAF Driver
    /// Sensor ResolutionId PDModeKey PDAF ResolutionId PDModeKey
    /// 0 10 2 10
    /// In the example above PDAF mode 2 corresponds to Sensor mode 0.
    /// Link between these modes is established using PDModeKey equal to 10.
    /// Max value of PDModeKey can be 99.
    UINT32                          PDModeKeyExists;
    UINT32                          PDModeKeyID;
    UINT32                          PDModeKey;
    /// Phy timer clock used for this mode
    /// TPG settings are made based on a specific phytimer clock
    /// This field indicates the phy clock which was used for creating the tpg settings
    UINT32                          tpgClockExists;
    UINT32                          tpgClockID;
    UINT32                          tpgClock;
    /// skip pattern for tpg
    /// skip pattern is a 16 bit value
    /// if a bit is 0 in the pattern, that indicates frame is skipped
    /// for example 0x1111 indicates 3 frames are skiped after sending one frame
    UINT32                          skipPatternExists;
    UINT32                          skipPatternID;
    UINT32                          skipPattern;
    /// The additional linecount applied to sensor with fine integration
    UINT32                          fineIntegrationLinecountExists;
    UINT32                          fineIntegrationLinecountID;
    float                           fineIntegrationLinecount;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ResolutionInformation
/// Comments:      Information of all the resolutions
///                Number of resolutions is detected from number of resolutionData nodes
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ResolutionInformation
{
    UINT32          sensorVersionExists;
    UINT32          sensorVersionID;
    UINT32          sensorVersion;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// resolutionData - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      element for transitionGroups
    ///                element for colorFilterArrangement
    ///                element for streamInfo
    ///                element for MCLK disable needed or not
    ///                element for lineLengthPixelClock
    ///                element for frameLengthLines
    ///                element for minHorizontalBlanking
    ///                element for minVerticalBlanking
    ///                element for outputPixelClock
    ///                element for horizontalBinning
    ///                element for verticalBinning
    ///                element for frameRate
    ///                element for activeLinesTransmissionTimeUS
    ///                element for laneCount
    ///                element for downScaleFactor
    ///                element for settleTimeNs
    ///                element for is3Phase
    ///                element for integrationInfo
    ///                element for resSettings
    ///                element for group hold on settings
    ///                element for group hold off settings
    ///                element for cropInfo
    ///                element for resolution specific exposure control Information
    ///                element for resolution specific exposure control Information
    ///                element for Frame Offset Information
    ///                element to specify type of HDR exposure
    ///                element for ZZHDR Information
    ///                element for 3-Exposure HDR Information
    ///                element for isOverlappedSHDRSupported
    ///                element for isNDOLSupported
    ///                element for RemosaicType Information
    ///                element for capability
    ///                element for ADCReadoutTime
    ///                element for MipiFlags
    ///                element for maxAnalogGain
    ///                element for QCFA HDR information
    ///                element for Depth information
    ///                element for PDAF Mode
    ///                element for tpgPhyClock
    ///                element for skipPattern
    ///                element for fine integration linecount
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32          resolutionDataCount;
    UINT32          resolutionDataID;
    ResolutionData* resolutionData;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TemperatureReadSettings
/// Comments:      Information to read sensor temperature
///                Read control may needs to be enabled in init settings in order to read temperature
///                Recommended read interval is 1sec or more
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct TemperatureReadSettings
{
    UINT32                         readIntervalInMs;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// readSetting
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo readSetting;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// InitSettings
/// Comments:      Information of the initial settings
///                preinitOnetimeSetting will be added as part of Init settings in the beginning
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct InitSettings
{
    UINT32                          sensorVersion;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// initSetting
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  initSetting;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// preinitOnetimeSetting - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          preinitOnetimeSettingExists;
    UINT32                          preinitOnetimeSettingID;
    SettingsInfo  preinitOnetimeSetting;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SoftwareSyncConfiguration
/// Comments:      Configuration of Software frame sync
///                element for blankingCompensation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SoftwareSyncConfiguration
{
    /// Indicate if need to compensate the blanking when frame rate changes from low to high.
    /// Some sensors need extra blanking after active frame, but some sensors don't have this blanking.
    /// Need to compensate the blanking if sensors don't have this extra blanking when peer sensors have this blanking.
    /// active frame transmission duration = 30ms
    /// current frame duration = 45ms
    /// next frame duration = 33ms
    /// Example for the sensor has extra blanking:
    /// EOF SOF EOF SOF
    /// | 15ms | 30ms | 15ms |
    /// Example for the sensor doesn't have extra blanking:
    /// EOF SOF EOF SOF
    /// | 15ms | 30ms |3ms|
    /// Will compensate the the blanking difference if true
    BOOL   blankingCompensation;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ExposureControlInformation
/// Comments:      Exposure control information
///                element for maxAnalogGain
///                element for maxDigitalGain
///                element for minAnalogGain
///                element for verticalOffset
///                element for verticalOffset
///                element for maximum linecount
///                element for minimum linecount
///                element for longLineCountThreshold
///                element for maxLongCitLShift
///                element for maximum linecount for a middle exposure frame
///                element for minimum linecount for a middle exposure frame
///                element for maximum linecount for a short exposure frame
///                element for minimum linecount for a short exposure frame
///                element for isFastStandbyEnabled
///                element for frame length automatic tracking
///                element for isGlobalGroupHoldEnabled
///                element for realToRegDigitalGainConversionFactor
///                element for analog realToRegGain
///                element for analog regToRealGain
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ExposureControlInformation
{
    /// Maximum analog again supported by sensor
    double  maxAnalogGain;
    /// Maximum digital again supported by sensor
    double  maxDigitalGain;
    /// Minimum analog again supported by sensor
    UINT32  minAnalogGainExists;
    UINT32  minAnalogGainID;
    double  minAnalogGain;
    /// Minimum offset to be maintained between line count and frame length lines
    UINT32  verticalOffset;
    /// Minimum number of lines of duration difference needed to synchronize master/slave
    /// Will add/substract those many lines duration of corresponding sensor based on the value +ve/-ve
    UINT32  multiCamLineDeltaExists;
    UINT32  multiCamLineDeltaID;
    INT32   multiCamLineDelta;
    /// Maximum line count supported by sensor
    UINT32  maxLineCount;
    /// Minimum line count supported by sensor
    UINT32  minLineCountExists;
    UINT32  minLineCountID;
    UINT32  minLineCount;
    /// Line count threshold for normal exposure mode supported by sensor
    /// LongExposure feature will be utilized if the calculated line count increases this value
    UINT32  longLineCountThresholdExists;
    UINT32  longLineCountThresholdID;
    UINT32  longLineCountThreshold;
    /// Maximum CitLShift supported by sensor
    UINT32  maxLongCitLShiftExists;
    UINT32  maxLongCitLShiftID;
    UINT32  maxLongCitLShift;
    /// Maximum line count supported by sensor for a middle exposure frame
    UINT32  middleMaxLineCountExists;
    UINT32  middleMaxLineCountID;
    UINT32  middleMaxLineCount;
    /// Minimum line count supported by sensor for a middle exposure frame
    UINT32  middleMinLineCountExists;
    UINT32  middleMinLineCountID;
    UINT32  middleMinLineCount;
    /// Maximum line count supported by sensor for a short exposure frame
    UINT32  shortMaxLineCountExists;
    UINT32  shortMaxLineCountID;
    UINT32  shortMaxLineCount;
    /// Minimum line count supported by sensor for a short exposure frame
    UINT32  shortMinLineCountExists;
    UINT32  shortMinLineCountID;
    UINT32  shortMinLineCount;
    /// Specifies whether sensor fast standby enabled or not
    UINT32  isFastStandbyEnabledExists;
    UINT32  isFastStandbyEnabledID;
    BOOL    isFastStandbyEnabled;
    /// Specifies whether sensor enables frame length automatic tracking feature or not
    UINT32  isFLLAutomaticTrackingEnabledExists;
    UINT32  isFLLAutomaticTrackingEnabledID;
    BOOL    isFLLAutomaticTrackingEnabled;
    /// Specifies whether sensor uses global group hold setting in the sensor node
    UINT32  isGlobalGroupHoldEnabledExists;
    UINT32  isGlobalGroupHoldEnabledID;
    BOOL    isGlobalGroupHoldEnabled;
    /// Conversion factor to convert real digital gain to register digital gain
    double  realToRegDigitalGainConversionFactor;
    /// Real analog gain to register analog gain equation
    /// The equation must contain "realGain" in its equation
    /// Ex:= 512 - (512 / realGain)
    CHAR*   realToRegGain;
    /// analog Register gain to real gain equation
    /// The equation must contain "regGain" in its equation
    /// Ex:= 512 / (512 - regGain)
    CHAR*   regToRealGain;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TestPatternMode
/// Comments:      Test pattern mode
///                Supported modes are: OFF, SOLID_COLOR, COLOR_BARS, COLOR_BARS_FADE_TO_GRAY, PN9, CUSTOM1
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class TestPatternMode
{
    OFF                     = 0,
    SOLID_COLOR             = 1,
    COLOR_BARS              = 2,
    COLOR_BARS_FADE_TO_GRAY = 3,
    PN9                     = 4,
    CUSTOM1                 = 5
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_TestPatternMode(
    ParameterFileSymbolTableEntry* const entry,
    TestPatternMode& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TestPatternData
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct TestPatternData
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mode
    /// Comments:      Test pattern mode
    ///                Supported modes are: OFF, SOLID_COLOR, COLOR_BARS, COLOR_BARS_FADE_TO_GRAY, PN9, CUSTOM1
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    TestPatternMode                mode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// settings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo settings;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TestPatternInformation
/// Comments:      element for TestDataLShift
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct TestPatternInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// testPatternData - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           testPatternDataCount;
    UINT32           testPatternDataID;
    TestPatternData* testPatternData;
    /// The test data left shift value
    UINT32           TestDataLShiftExists;
    UINT32           TestDataLShiftID;
    UINT32           TestDataLShift;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorBroadcastMode
/// Comments:      This value represents sensor broadcast mode
///                NON_BROADCAST: is used by default, no broadcast functionality
///                INDIVIDUAL: can be used for broadcast functionlity and as regular sensor as well
///                BROADCAST: this the way to identify broadcast settings xml file for broadcast functionality
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SensorBroadcastMode
{
    NON_BROADCAST = 0,
    INDIVIDUAL    = 1,
    BROADCAST     = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_SensorBroadcastMode(
    ParameterFileSymbolTableEntry* const entry,
    SensorBroadcastMode& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GmslAliasInfo
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct GmslAliasInfo
{
    UINT32 sensorVersion;
    UINT32 aliasAddr;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GmslSettings
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct GmslSettings
{
    UINT32                         sensorVersion;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gmslSetting
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo gmslSetting;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GmslInformation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct GmslInformation
{
    UINT32                          isGmslModule;
    UINT32                          muxedVersionFirst;
    UINT32                          muxedVersionSecond;
    UINT32                          desSlaveAddrExists;
    UINT32                          desSlaveAddrID;
    UINT32                          desSlaveAddr;
    UINT32                          desRevAddrExists;
    UINT32                          desRevAddrID;
    UINT32                          desRevAddr;
    UINT32                          desChipIdAddrExists;
    UINT32                          desChipIdAddrID;
    UINT32                          desChipIdAddr;
    UINT32                          desChipIdDataExists;
    UINT32                          desChipIdDataID;
    UINT32                          desChipIdData;
    UINT32                          serSlaveAddrExists;
    UINT32                          serSlaveAddrID;
    UINT32                          serSlaveAddr;
    UINT32                          serChipIdAddrExists;
    UINT32                          serChipIdAddrID;
    UINT32                          serChipIdAddr;
    UINT32                          serChipIdDataExists;
    UINT32                          serChipIdDataID;
    UINT32                          serChipIdData;
    UINT32                          serBroadcastAddrExists;
    UINT32                          serBroadcastAddrID;
    UINT32                          serBroadcastAddr;
    UINT32                          sensorSlaveAddrExists;
    UINT32                          sensorSlaveAddrID;
    UINT32                          sensorSlaveAddr;
    UINT32                          sensorChipIdAddrExists;
    UINT32                          sensorChipIdAddrID;
    UINT32                          sensorChipIdAddr;
    UINT32                          sensorChipIdDataExists;
    UINT32                          sensorChipIdDataID;
    UINT32                          sensorChipIdData;
    UINT32                          GmslSensorRealProbeEnabledExists;
    UINT32                          GmslSensorRealProbeEnabledID;
    BOOL                            GmslSensorRealProbeEnabled;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// desAliasInfo - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          desAliasInfoCount;
    UINT32                          desAliasInfoID;
    GmslAliasInfo*                  desAliasInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// serAliasInfo - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          serAliasInfoCount;
    UINT32                          serAliasInfoID;
    GmslAliasInfo*                  serAliasInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorAliasInfo - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          sensorAliasInfoCount;
    UINT32                          sensorAliasInfoID;
    GmslAliasInfo*                  sensorAliasInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enablePortAClockSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          enablePortAClockSettingsExists;
    UINT32                          enablePortAClockSettingsID;
    SettingsInfo  enablePortAClockSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enablePortBClockSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          enablePortBClockSettingsExists;
    UINT32                          enablePortBClockSettingsID;
    SettingsInfo  enablePortBClockSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enablePortABClockSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          enablePortABClockSettingsExists;
    UINT32                          enablePortABClockSettingsID;
    SettingsInfo  enablePortABClockSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// disablePortABClockSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          disablePortABClockSettingsExists;
    UINT32                          disablePortABClockSettingsID;
    SettingsInfo  disablePortABClockSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorAStartSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          sensorAStartSettingsExists;
    UINT32                          sensorAStartSettingsID;
    SettingsInfo  sensorAStartSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorBStartSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          sensorBStartSettingsExists;
    UINT32                          sensorBStartSettingsID;
    SettingsInfo  sensorBStartSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorAStopSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          sensorAStopSettingsExists;
    UINT32                          sensorAStopSettingsID;
    SettingsInfo  sensorAStopSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorBStopSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          sensorBStopSettingsExists;
    UINT32                          sensorBStopSettingsID;
    SettingsInfo  sensorBStopSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamOnSettings - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          streamOnSettingsCount;
    UINT32                          streamOnSettingsID;
    GmslSettings*                   streamOnSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamOffSettings - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          streamOffSettingsCount;
    UINT32                          streamOffSettingsID;
    GmslSettings*                   streamOffSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorBroadcastMode - Optional
    /// Default Value: NON_VALID
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This value represents sensor broadcast mode
    ///                NON_BROADCAST: is used by default, no broadcast functionality
    ///                INDIVIDUAL: can be used for broadcast functionlity and as regular sensor as well
    ///                BROADCAST: this the way to identify broadcast settings xml file for broadcast functionality
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          sensorBroadcastModeExists;
    UINT32                          sensorBroadcastModeID;
    SensorBroadcastMode             sensorBroadcastMode;
    UINT32                          sensorBroadcastAddrExists;
    UINT32                          sensorBroadcastAddrID;
    UINT32                          sensorBroadcastAddr;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ColorLevelInformation
/// Comments:      Color level information
///                These are the default currents in various channels in complete dark light
///                element for whiteLevel
///                element for rPedestal
///                element for grPedestal
///                element for bPedestal
///                element for gbPedestal
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ColorLevelInformation
{
    /// White level value
    UINT32 whiteLevel;
    /// Pedestal value for Red channel
    UINT32 rPedestal;
    /// Pedestal value for GreenRed channel
    UINT32 grPedestal;
    /// Pedestal value for Blue channel
    UINT32 bPedestal;
    /// Pedestal value for Green Blue channel
    UINT32 gbPedestal;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// OpticalBlackRegionInfo
/// Comments:      Information about black regions
///                Multiple black regions can be provided if applicable
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct OpticalBlackRegionInfo
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dimension - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Frame dimension: contains xStart, yStart, width and height
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                            dimensionCount;
    UINT32                            dimensionID;
    FrameDimension* dimension;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PixelArrayInfo
/// Comments:      Information about the pixel array
///                Active dimension and dummy pixels width are provided
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct PixelArrayInfo
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// activeDimension
    /// Comments:      Width and height of the frame or subframe
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    Dimension activeDimension;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dummyInfo
    /// Comments:      Dummy pixels surrounding the active pixel array
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BorderInformation           dummyInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// activeArrayCropInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Number of pixels cropped from the active pixel array
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                      activeArrayCropInfoExists;
    UINT32                      activeArrayCropInfoID;
    BorderInformation           activeArrayCropInfo;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// DelayInfo
/// Comments:      Application delay information
///                element for linecount
///                element for gain
///                element for frame length lines
///                element for maxPipelineDelay
///                element for frameSkip
///                element for modeSwitch
///                element for virtualChannelSwitch
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct DelayInfo
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// delayType - Optional
    /// Default Value: EXPOSURECONTROL
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Indicates for which category the delay Info belongs to
    ///                Supported types are ExposureControl, Framesync. Framesync delay info is used for multi camera
    ///                synchronization
    ///                For all exposure control purposes ExposureControl type is used including the maxpipeline delay
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32         delayTypeExists;
    UINT32         delayTypeID;
    DelayInfoType  delayType;
    /// Number of frames required to apply the linecount
    UINT32         linecountExists;
    UINT32         linecountID;
    UINT32         linecount;
    /// Number of frames required to apply the gain
    UINT32         gainExists;
    UINT32         gainID;
    UINT32         gain;
    /// Number of frames required to apply the frame length lines
    UINT32         frameLengthLinesExists;
    UINT32         frameLengthLinesID;
    UINT32         frameLengthLines;
    /// Maximum pipeline delay in number of frames
    UINT32         maxPipeline;
    /// Number of initial bad frames to skip
    UINT32         frameSkip;
    /// Number of frames to delay to apply new sensor mode settings during mode switch.
    UINT32         modeSwitch;
    /// Number of frames it takes for VC settings to be reflected
    /// during dynamic mode switch.
    UINT32         virtualChannelSwitchExists;
    UINT32         virtualChannelSwitchID;
    UINT32         virtualChannelSwitch;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensingMethod
/// Comments:      Sensing method of senosor
///                Supported sensing methods: UNDEFINED, ONE_CHIP_COLOR_AREA, TWO_CHIP_COLOR_AREA
///                THREE_CHIP_COLOR_AREA, COLOR_SEQUENCE_AREA, TRILINEAR, COLOR_SEQUENCE_LINEAR
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SensingMethod
{
    UNDEFINED             = 0,
    ONE_CHIP_COLOR_AREA   = 1,
    TWO_CHIP_COLOR_AREA   = 2,
    THREE_CHIP_COLOR_AREA = 3,
    COLOR_SEQUENCE_AREA   = 4,
    TRILINEAR             = 5,
    COLOR_SEQUENCE_LINEAR = 6
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_SensingMethod(
    ParameterFileSymbolTableEntry* const entry,
    SensingMethod& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorProperty
/// Comments:      element for pixelSize
///                element for cropFactor
///                element for sensingMethod
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SensorProperty
{
    /// Pixel size in micro meters
    double        pixelSize;
    /// Crop factor
    double        cropFactor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensingMethod
    /// Comments:      Sensing method of senosor
    ///                Supported sensing methods: UNDEFINED, ONE_CHIP_COLOR_AREA, TWO_CHIP_COLOR_AREA
    ///                THREE_CHIP_COLOR_AREA, COLOR_SEQUENCE_AREA, TRILINEAR, COLOR_SEQUENCE_LINEAR
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensingMethod sensingMethod;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// NoiseCoefficent
/// Comments:      element for gradient_S
///                element for offset_S
///                element for gradient_O
///                element for offset_O
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct NoiseCoefficent
{
    /// gradient_s Sensor amplification
    double gradient_S;
    /// offset_S Sensor amplification
    double offset_S;
    /// gradient_O sensor readout noise
    double gradient_O;
    /// offset_O sensor readout noise
    double offset_O;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// NoiseCoefficientChannel
/// Comments:      Noise Coefficient Channels
///                Channel are in R=0, GR=1, GB=2, B=3 Y=4 order
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class NoiseCoefficientChannel
{
    BAYER_R  = 0,
    BAYER_Gr = 1,
    BAYER_Gb = 2,
    BAYER_B  = 3,
    BAYER_Y  = 4
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_NoiseCoefficientChannel(
    ParameterFileSymbolTableEntry* const entry,
    NoiseCoefficientChannel& enumValue,
    BYTE const alignment);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// NoiseCoefficientBayer
/// Comments:      Noise Coefficient Channel need to match the Bayer CFA in RGGB order
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct NoiseCoefficientBayer
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// R
    /// Comments:      element for gradient_S
    ///                element for offset_S
    ///                element for gradient_O
    ///                element for offset_O
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    NoiseCoefficent R;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Gr
    /// Comments:      element for gradient_S
    ///                element for offset_S
    ///                element for gradient_O
    ///                element for offset_O
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    NoiseCoefficent Gr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Gb
    /// Comments:      element for gradient_S
    ///                element for offset_S
    ///                element for gradient_O
    ///                element for offset_O
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    NoiseCoefficent Gb;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// B
    /// Comments:      element for gradient_S
    ///                element for offset_S
    ///                element for gradient_O
    ///                element for offset_O
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    NoiseCoefficent B;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RegisterSettingGroup
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RegisterSettingGroup
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// registerSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo registerSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// registerSettingsType
    /// Comments:      Defines type of setting this register set indicates.
    ///                Supported flags are: StreamOn, StreamOff
    ///                StreamOn: This will indicate streamon settings for special usecases.
    ///                StreamOff: This will indicate streamoff settings for special usecases.
    ///                PostStreamOn: This will indicate settings to write after streamOn for special usecases.
    ///                PreStreamOn: This will indicate settings to write before streamOn for special usecases.
    ///                PostStreamOff: This will indicate settings to write after streamOff for special usecases.
    ///                PreStreamOff: This will indicate settings to write before streamOff for special usecases.
    ///                EnableData: This will indicate settings to be written to enable data for the specified settings flag
    ///                type.
    ///                DisableData:This will indicate settings to be written to disable data for the specified settings flag
    ///                type.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsType registerSettingsType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// registerSettingsFlag
    /// Comments:      Use this flag to indicate any settings specially applied for certain usecases.
    ///                Supported flags are: PN9Test
    ///                PN9Test: This indicates settings to be used during PN9 Pattern testing case
    ///                sensorMCLKDisable: This indicates settings to be used while disabling MCLK for certain sensor modes
    ///                PDAFVerticalData: This indicates settings to be used to enable/disable vertical PDAF data
    ///                streamRegExtend: This indicates settings to be used to extend PreStreamOn/PreStreamOn/PostStreamOff
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsFlag registerSettingsFlag;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// EnumDefinition
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct EnumDefinition
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseCoefficientChannel - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Noise Coefficient Channels
    ///                Channel are in R=0, GR=1, GB=2, B=3 Y=4 order
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                   noiseCoefficientChannelExists;
    UINT32                   noiseCoefficientChannelID;
    NoiseCoefficientChannel  noiseCoefficientChannel;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AEBControlInformation
/// Comments:      Auto Exposure Bracketing based control information
///                This is optional and must be filled if sensor supports AE Bracketing
///                It contains the following:
///                1. AEB control settings :
///                - register setting information required to enable AEB,
///                - mask to select specific parameter in the Look up table and
///                - assign VC and DT values for long, short and pdaf frames
///                2. AEB Register Exposure control information : contains register addresses of Coarse Integration Time,
///                Analog Gain, Digital Gain and Frame Length lines for each frame generated
///                element for AEBControlSettings
///                element for AEBControlSettings
///                element for AEBExposureRegInfo
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct AEBControlInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AEBControlSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  AEBControlSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AEBControlOffSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          AEBControlOffSettingsExists;
    UINT32                          AEBControlOffSettingsID;
    SettingsInfo  AEBControlOffSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AEBRegExposureInfo - Array
    /// Min Length:    1
    /// Max Length:    3
    /// Comments:      Resolution specific exposure control information
    ///                Update if its different than the common to common resolution exposure control information
    ///                if this information is not available, then info from common exposure control will be used
    ///                element for exposure type for which this information is being updated
    ///                element for coarseIntgTimeAddr
    ///                element for analog globalGainAddr
    ///                element for digitalGlobalGainAddr
    ///                element for maxAnalogGain
    ///                element for minAnalogGain
    ///                element for maxDigitalGain
    ///                element for minAnalogGain
    ///                element for maximum linecount
    ///                element for minimum linecount
    ///                element for verticalOffset
    ///                element for frameLengthLines
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          AEBRegExposureInfoCount;
    UINT32                          AEBRegExposureInfoID;
    ResolutionExposureInformation*  AEBRegExposureInfo;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorDriverData
/// Comments:      Either noiseCoefficient or noiseCoefficientBayer, noiseCoefficientBayer will be used if both are defined
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SensorDriverData
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32  major_revision;
        INT32  minor_revision;
        INT32  incr_revision;

        bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    };
    struct module_versionStruct module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// slaveInfo
    /// Comments:      Sensor slave information
    ///                element for sensorName
    ///                element for sensorLibName
    ///                element for sensor module type
    ///                element for sensorType
    ///                element for isGlobalShutter
    ///                element for slaveAddress
    ///                element for regAddrType
    ///                element for regDataType
    ///                element for sensorIdRegAddr
    ///                element for sensorId
    ///                element for sensorIdMask
    ///                element for i2cFrequencyMode
    ///                element for sensorGmslRealProbeInfo
    ///                element for sensorRegBankUnlockInfo
    ///                element for sensorRegBankLockInfo
    ///                element for powerUpSequence
    ///                element for powerDownSequence
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SlaveInformation                slaveInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regAddrInfo
    /// Comments:      Addresses for various sensor registers
    ///                element for xOutput
    ///                element for yOutput
    ///                element for frameLengthLines
    ///                element for preShutterLengthLinesAddr
    ///                element for lineLengthPixelClock
    ///                element for coarseIntgTimeAddr
    ///                element for middleCoarseIntgTimeAddr
    ///                element for shortCoarseIntgTimeAddr
    ///                element for analog globalGainAddr
    ///                element for analog middleGlobalGainAddr
    ///                element for analog shortGlobalGainAddr
    ///                element for digitalGlobalGainAddr
    ///                element for middleDigitalGlobalGainAddr
    ///                element for shortDigitalGlobalGainAddr
    ///                element for digitalGainRedAddr
    ///                element for digitalGainGreenRedAddr
    ///                element for digitalGainBlueAddr
    ///                element for digitalGainGreenBlueAddr
    ///                element for testPatternRAddr
    ///                element for testPatternGRAddr
    ///                element for testPatternBAddr
    ///                element for testPatternGBAddr
    ///                element for strobeStartAddr
    ///                element for strobeWidthAddr
    ///                element for longCITLShiftAddr
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    RegAddrInformation              regAddrInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// resolutionInfo - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Information of all the resolutions
    ///                Number of resolutions is detected from number of resolutionData nodes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          resolutionInfoCount;
    UINT32                          resolutionInfoID;
    ResolutionInformation*          resolutionInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// exposureControlInfo
    /// Comments:      Exposure control information
    ///                element for maxAnalogGain
    ///                element for maxDigitalGain
    ///                element for minAnalogGain
    ///                element for verticalOffset
    ///                element for verticalOffset
    ///                element for maximum linecount
    ///                element for minimum linecount
    ///                element for longLineCountThreshold
    ///                element for maxLongCitLShift
    ///                element for maximum linecount for a middle exposure frame
    ///                element for minimum linecount for a middle exposure frame
    ///                element for maximum linecount for a short exposure frame
    ///                element for minimum linecount for a short exposure frame
    ///                element for isFastStandbyEnabled
    ///                element for frame length automatic tracking
    ///                element for isGlobalGroupHoldEnabled
    ///                element for realToRegDigitalGainConversionFactor
    ///                element for analog realToRegGain
    ///                element for analog regToRealGain
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExposureControlInformation      exposureControlInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamOnSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  streamOnSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamOffSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  streamOffSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// groupHoldOnSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  groupHoldOnSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// groupHoldOffSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  groupHoldOffSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// masterSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          masterSettingsExists;
    UINT32                          masterSettingsID;
    SettingsInfo  masterSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// slaveSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          slaveSettingsExists;
    UINT32                          slaveSettingsID;
    SettingsInfo  slaveSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// softwareSyncConfiguration - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Configuration of Software frame sync
    ///                element for blankingCompensation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          softwareSyncConfigurationExists;
    UINT32                          softwareSyncConfigurationID;
    SoftwareSyncConfiguration       softwareSyncConfiguration;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// temperatureReadInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Information to read sensor temperature
    ///                Read control may needs to be enabled in init settings in order to read temperature
    ///                Recommended read interval is 1sec or more
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          temperatureReadInfoExists;
    UINT32                          temperatureReadInfoID;
    TemperatureReadSettings         temperatureReadInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// initSettings - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Information of the initial settings
    ///                preinitOnetimeSetting will be added as part of Init settings in the beginning
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          initSettingsCount;
    UINT32                          initSettingsID;
    InitSettings*                   initSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// testPatternInfo
    /// Comments:      element for TestDataLShift
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    TestPatternInformation          testPatternInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gmslInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          gmslInfoExists;
    UINT32                          gmslInfoID;
    GmslInformation                 gmslInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// colorLevelInfo
    /// Comments:      Color level information
    ///                These are the default currents in various channels in complete dark light
    ///                element for whiteLevel
    ///                element for rPedestal
    ///                element for grPedestal
    ///                element for bPedestal
    ///                element for gbPedestal
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ColorLevelInformation           colorLevelInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// opticalBlackRegionInfo
    /// Comments:      Information about black regions
    ///                Multiple black regions can be provided if applicable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    OpticalBlackRegionInfo          opticalBlackRegionInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// pixelArrayInfo
    /// Comments:      Information about the pixel array
    ///                Active dimension and dummy pixels width are provided
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PixelArrayInfo                  pixelArrayInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// delayInfo - Array
    /// Min Length:    1
    /// Max Length:    2
    /// Comments:      Application delay information
    ///                element for linecount
    ///                element for gain
    ///                element for frame length lines
    ///                element for maxPipelineDelay
    ///                element for frameSkip
    ///                element for modeSwitch
    ///                element for virtualChannelSwitch
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          delayInfoCount;
    UINT32                          delayInfoID;
    DelayInfo*                      delayInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorProperty
    /// Comments:      element for pixelSize
    ///                element for cropFactor
    ///                element for sensingMethod
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensorProperty                  sensorProperty;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseCoefficent - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      element for gradient_S
    ///                element for offset_S
    ///                element for gradient_O
    ///                element for offset_O
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          noiseCoefficentExists;
    UINT32                          noiseCoefficentID;
    NoiseCoefficent                 noiseCoefficent;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseCoefficientBayer - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Noise Coefficient Channel need to match the Bayer CFA in RGGB order
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          noiseCoefficientBayerExists;
    UINT32                          noiseCoefficientBayerID;
    NoiseCoefficientBayer           noiseCoefficientBayer;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// registerSettingsGroupInfo - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          registerSettingsGroupInfoCount;
    UINT32                          registerSettingsGroupInfoID;
    RegisterSettingGroup*           registerSettingsGroupInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// modeSwitchRegInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Register settings and register addresses to be programmed during seamless mode switch
    ///                element for regAddrType
    ///                element for regDataType
    ///                element for register address to program PDAF virtual channel
    ///                element for register address to program IMAGE(long/default) stream virtual channel
    ///                element for register address to program IMAGE SHORT virtual channel
    ///                element for register address to program IMAGE MIDDLE virtual channel
    ///                element for register address to program BLOB virtual channel
    ///                element for register address to program HDR virtual channel
    ///                element for register address to program META virtual channel
    ///                element for register address to program PDAF Vertical virtual channel
    ///                element for register address to program PDAF SHORT virtual channel
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          modeSwitchRegInfoExists;
    UINT32                          modeSwitchRegInfoID;
    ModeSwitchRegisterInformation   modeSwitchRegInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AEBControlInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Auto Exposure Bracketing based control information
    ///                This is optional and must be filled if sensor supports AE Bracketing
    ///                It contains the following:
    ///                1. AEB control settings :
    ///                - register setting information required to enable AEB,
    ///                - mask to select specific parameter in the Look up table and
    ///                - assign VC and DT values for long, short and pdaf frames
    ///                2. AEB Register Exposure control information : contains register addresses of Coarse Integration Time,
    ///                Analog Gain, Digital Gain and Frame Length lines for each frame generated
    ///                element for AEBControlSettings
    ///                element for AEBControlSettings
    ///                element for AEBExposureRegInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          AEBControlInfoExists;
    UINT32                          AEBControlInfoID;
    AEBControlInformation           AEBControlInfo;
    UINT32                          isPerframeUpdateNeededExists;
    UINT32                          isPerframeUpdateNeededID;
    BOOL                            isPerframeUpdateNeeded;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    void Unload(ParameterFileSymbolTable* const __table);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Release the ParameterModule object
    /// Requires that this object was created via a ParameterSetManager::GetModule call
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void Release();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Returns the ParameterModule::Modified value
    /// The Modified value is incremented when the module's data or pointer values change
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 GetModified();
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorDriverDataClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class SensorDriverDataClass : public ParameterModule, public SensorDriverData
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static constexpr UINT16 MAJOR = 1U;
    static constexpr UINT16 MINOR = 0U;
    static constexpr UINT32 PATCH = 0U;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensorDriverDataClass(
        const CHAR* const name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensorDriverDataClass(
        const CHAR* const name,
        ModuleData* const moduleData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~SensorDriverDataClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* const type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create module, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Create(
        ModuleData* const moduleData,
        DefaultModule* const defModule) const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module data, return true if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual bool LoadModule(
        ParameterFileSymbolTable* const table);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload module data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual void UnloadModule();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// /// Release the ParameterModule object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void Release();
}; // End class SensorDriverDataClass

CAMX_NAMESPACE_END
#endif // CAMXSENSORDRIVER_H

