////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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 V7.4.1 (8cca6579792b9fcef3bc725ff070c5ec453c7c85)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

#ifndef ANR_1_4_1_H
#define ANR_1_4_1_H

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

#define ANR_1_4_1_NAMESPACE_BEGIN namespace anr_1_4_1 {
#define ANR_1_4_1_NAMESPACE_END }

ANR_1_4_1_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// mod_anr14_pass_reserve_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct mod_anr14_pass_reserve_dataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// pass_trigger
    ///
    /// Default Value: PASS_FULL,PASS_DC4,PASS_DC16,PASS_DC64
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ispglobalelements::trigger_pass pass_trigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// pass_data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct pass_dataStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// top
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct topStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_noise_reduction_pass
            ///
            /// Tuning Level:  must_tune
            /// Description:   Enable Luma filtering for current PASS.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_noise_reduction_pass;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_noise_reduction_pass
            ///
            /// Tuning Level:  must_tune
            /// Description:   Enable Chroma filtering for current PASS.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_noise_reduction_pass;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_1
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          int
            /// Default Value: 0
            /// Range:         [-2147483647, 2147483647]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            INT32  reserved_1;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_2
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          int
            /// Default Value: 0
            /// Range:         [-2147483647, 2147483647]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            INT32  reserved_2;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_3
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          int
            /// Default Value: 0
            /// Range:         [-2147483647, 2147483647]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            INT32  reserved_3;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_4
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          int
            /// Default Value: 0
            /// Range:         [-2147483647, 2147483647]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            INT32  reserved_4;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_5
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          int
            /// Default Value: 0
            /// Range:         [-2147483647, 2147483647]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            INT32  reserved_5;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_6
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          int
            /// Default Value: 0
            /// Range:         [-2147483647, 2147483647]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            INT32  reserved_6;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_7
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 4294967294]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 reserved_7;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_8
            ///
            /// Tuning Level:  never_tune
            /// Description:   Reserved for future usage .
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 4294967294]
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 reserved_8;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_lut_1_tab
            ///
            /// Description:   Reserved for future usage .
            /// Type:          uint
            /// Range:         [0, 4294967294]
            /// Length:        16
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct reserved_lut_1_tabStruct
            {
                static constexpr UINT32 reserved_lut_1FixedCount = 16;
                UINT32                  reserved_lut_1[16];

                void Load(
                    ParameterLoadParameters& parentParams);

                static void LoadArray(
                    ParameterLoadParameters& __params,
                    void*                    __array,
                    UINT32                   __count);

                static void* AllocArray(
                    UINT32 __count);

                bool GetValue(
                    const CHAR* __path,
                    CHAR*       __value,
                    UINT32      __size);

                bool SetValue(
                    const CHAR* __path,
                    const CHAR* __value);

                bool GetInfo(
                    const CHAR*                 __path,
                    PList<ParameterParserInfo>& __info);
            };
            struct reserved_lut_1_tabStruct reserved_lut_1_tab;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// reserved_lut_2_tab
            ///
            /// Description:   Reserved for future usage .
            /// Type:          int
            /// Range:         [-2147483647, 2147483647]
            /// Length:        16
            /// Notes:         Hide in GUI ! Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct reserved_lut_2_tabStruct
            {
                static constexpr UINT32 reserved_lut_2FixedCount = 16;
                INT32                   reserved_lut_2[16];

                void Load(
                    ParameterLoadParameters& parentParams);

                static void LoadArray(
                    ParameterLoadParameters& __params,
                    void*                    __array,
                    UINT32                   __count);

                static void* AllocArray(
                    UINT32 __count);

                bool GetValue(
                    const CHAR* __path,
                    CHAR*       __value,
                    UINT32      __size);

                bool SetValue(
                    const CHAR* __path,
                    const CHAR* __value);

                bool GetInfo(
                    const CHAR*                 __path,
                    PList<ParameterParserInfo>& __info);
            };
            struct reserved_lut_2_tabStruct reserved_lut_2_tab;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct topStruct top;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// power_control
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct power_controlStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_filter_extension
            ///
            /// Tuning Level:  often_tune
            /// Description:   1 - Standard mode. . 0 - Low power mode, disable chroma filter extension: turn off median, second
            ///                bilateral and chroma indication extension.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_filter_extension;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_smoothing_treatment_and_peak_treatment
            ///
            /// Tuning Level:  often_tune
            /// Description:   if set to 0, luma_smoothing_treatment_and_peak_treatment will be turned off.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_smoothing_treatment_and_peak_treatment;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_smoothing_treatment_and_peak_treatment
            ///
            /// Tuning Level:  often_tune
            /// Description:   if set to 0, chroma_smoothing_treatment_and_peak_treatment will be turned off.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_smoothing_treatment_and_peak_treatment;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_chroma_filter_all_thresholds_per_uv
            ///
            /// Tuning Level:  often_tune
            /// Description:   if set to 0, y,u,v thresholds will be dependent only on Ylut (function of y) and not on Uvlut (function
            ///                of u,v).
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_chroma_filter_all_thresholds_per_uv;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_chroma_filter_uv_thresholds_per_yuv
            ///
            /// Tuning Level:  often_tune
            /// Description:   if set to 0, u,v thresholds will be a constant and will not be dependent on y,u,v. Constant will be taken
            ///                from first cell of LUT_per_y.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_chroma_filter_uv_thresholds_per_yuv;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_filter_uv_thresholds
            ///
            /// Tuning Level:  often_tune
            /// Description:   if set to 0, luma filter will be dependent only on y derivatives and not u,v derivatives (no need to
            ///                compare them).
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_filter_uv_thresholds;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct power_controlStruct power_control;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_kernel
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_kernelStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// kernel_definition_mode
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   0 - use abstraction (auto config) for deciding on kernels based on granularity and filter size. 1- use
            ///                manual configured kernels by the user inside the kernels struct. User MUST set edge kernel, flat weight
            ///                and flat kernel if weight is greater than zero.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 kernel_definition_mode;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// manual_edge_kernel_complement_mode
            ///
            /// Tuning Level:  never_tune
            /// Description:   0: don't include pixels in between main directions. 1 include them only if all directions agree. 2-
            ///                include them only if the two relevant directions (the direction the pixel is in between) agree.
            /// Type:          uint
            /// Default Value: 2
            /// Range:         [0, 2]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 manual_edge_kernel_complement_mode;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// manual_flat_kernel_complement_mode
            ///
            /// Tuning Level:  never_tune
            /// Description:   0: don't include pixels in between main directions, 1 include them only if all directions agree. 2-
            ///                include them only if the two relevant directions (the direction the pixel is in between) agree.
            /// Type:          uint
            /// Default Value: 2
            /// Range:         [0, 2]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 manual_flat_kernel_complement_mode;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_kernelStruct luma_filter_kernel;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// inter_length_output_indication
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct inter_length_output_indicationStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// luma_neighbours_impact_enable
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   if set to 1, pixel can be dependent on its neighbors for indicating as flat for higher pass.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 luma_neighbours_impact_enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// chroma_neighbours_impact_enable
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   if set to 1, pixel can be dependent on its neighbors for indicating as flat for higher pass.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 chroma_neighbours_impact_enable;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct inter_length_output_indicationStruct inter_length_output_indication;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// grey_treatment
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct grey_treatmentStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_grey_treatment_thr_modification
            ///
            /// Tuning Level:  must_tune
            /// Description:   increase threshold towards the Thr_Modification_Target_*_DER values. If fully grey, thresholds will
            ///                assume the target.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_grey_treatment_thr_modification;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_grey_treatment_isotropic_filter_blend
            ///
            /// Tuning Level:  must_tune
            /// Description:   blend with isotropic filtering.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_grey_treatment_isotropic_filter_blend;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct grey_treatmentStruct grey_treatment;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_extension
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_extensionStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_filter_extension_median
            ///
            /// Tuning Level:  must_tune
            /// Description:   enable current pass CLPF Edge filtering bypass.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_filter_extension_median;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_filter_extension_bilateral
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   enable for the Chroma Bilateral filter block .
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_filter_extension_bilateral;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_extensionStruct chroma_filter_extension;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_smoothing_treatment
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_smoothing_treatmentStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_edge_smoothing
            ///
            /// Tuning Level:  must_tune
            /// Description:   If set to 1, Chroma edge smoothing is enabled.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_edge_smoothing;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_transition_smoothing
            ///
            /// Tuning Level:  must_tune
            /// Description:   If set to 1, chroma transition smoothing is enabled.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_transition_smoothing;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_smoothing_treatmentStruct chroma_smoothing_treatment;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// lnr
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct lnrStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_lnr
            ///
            /// Tuning Level:  must_tune
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_lnr;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// use_luts_from_full_pass_configuration
            ///
            /// Tuning Level:  often_tune
            /// Description:   automatic mode : if set to 1, take the LUTs from the Full pass configuration and compensate with
            ///                influence factor. . manual mode : if set to 0, take the LUTs from the current pass configuration. .
            ///                influence factor == 1 take the same LUT, influence factor == 0 take LUT of all 128, in between
            ///                interpolate .
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 use_luts_from_full_pass_configuration;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct lnrStruct lnr;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// cnr
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct cnrStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_cnr
            ///
            /// Tuning Level:  must_tune
            /// Description:   0 - enable operation. 1 - bypass unit.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_cnr;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// number_of_colors
            ///
            /// Tuning Level:  must_tune
            /// Description:   Defines the actual number of treated colors.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 5]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 number_of_colors;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// detect_color0_saturation_mode
            ///
            /// Tuning Level:  often_tune
            /// Description:   0 - Color#0 saturation is calculated by Saturation = Chromaticity/Y (HSY color space). Taken from
            ///                detect_color0_skin_saturation_*. 1 - Color#0 saturation is calculated by Saturation = Chromaticity (YUV
            ///                color space). Taken from detect_chromaticity_start[0], detect_chromaticity_end[0].
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 detect_color0_saturation_mode;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct cnrStruct cnr;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_detection_thresholds
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_detection_thresholdsStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// control_per_uv_limit
            ///
            /// Tuning Level:  often_tune
            /// Description:   CTb points location in the UV space, 127 is at external limits, 64 is half limit, ... . ( HW
            ///                implementation is : Limit value for UV-Average input for Luma base threshold calculation ).
            /// Type:          uint
            /// Default Value: 64
            /// Range:         [32, 127]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 control_per_uv_limit;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_detection_thresholdsStruct luma_filter_detection_thresholds;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_detection_thresholds
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_detection_thresholdsStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// control_per_uv_limit
            ///
            /// Tuning Level:  often_tune
            /// Description:   CTb points location in the UV space, 127 is at external limits, 64 is half limit, ... . ( HW
            ///                implementation is : Limit value for UV-Average input for Luma base threshold calculation ).
            /// Type:          uint
            /// Default Value: 64
            /// Range:         [32, 127]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 control_per_uv_limit;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_detection_thresholdsStruct chroma_filter_detection_thresholds;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcblend1
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct dcblend1Struct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_dcblend1_chroma
            ///
            /// Tuning Level:  must_tune
            /// Description:   enable DCblend1 between lower pass and current one (lower pass has to be processed).
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_dcblend1_chroma;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct dcblend1Struct dcblend1;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcblend2
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct dcblend2Struct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_dcblend2_luma
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   enable DCblend2 between lower pass and current one (lower pass has to be processed).
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_dcblend2_luma;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_dcblend2_chroma
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   enable DCblend2 between lower pass and current one (lower pass has to be processed).
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_dcblend2_chroma;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct dcblend2Struct dcblend2;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dithering
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ditheringStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// dithering_y_en
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   Dithering enable for luma image.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 dithering_y_en;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// dithering_c_en
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   Dithering enable for chroma image.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 dithering_c_en;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ditheringStruct dithering;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_modifiers
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ai_modifiersStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// ai_mod_luma_threshold_lpf_tab
            ///
            /// Description:   First entry for c2. Second entry for c3. LPF3x3 case: 2*c2+c3=128.
            /// Type:          uint
            /// Range:         [[0, 64],[0, 128]]
            /// Length:        2
            /// Notes:         Hide in GUI ! Linear interpolation.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct ai_mod_luma_threshold_lpf_tabStruct
            {
                static constexpr UINT32 ai_mod_luma_threshold_lpfFixedCount = 2;
                UINT32                  ai_mod_luma_threshold_lpf[2];

                void Load(
                    ParameterLoadParameters& parentParams);

                static void LoadArray(
                    ParameterLoadParameters& __params,
                    void*                    __array,
                    UINT32                   __count);

                static void* AllocArray(
                    UINT32 __count);

                bool GetValue(
                    const CHAR* __path,
                    CHAR*       __value,
                    UINT32      __size);

                bool SetValue(
                    const CHAR* __path,
                    const CHAR* __value);

                bool GetInfo(
                    const CHAR*                 __path,
                    PList<ParameterParserInfo>& __info);
            };
            struct ai_mod_luma_threshold_lpf_tabStruct ai_mod_luma_threshold_lpf_tab;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// ai_mod_chroma_threshold_lpf_tab
            ///
            /// Description:   First entry for c2. Second entry for c3. LPF3x3 case: 2*c2+c3=128.
            /// Type:          uint
            /// Range:         [[0, 64],[0, 128]]
            /// Length:        2
            /// Notes:         Hide in GUI ! Linear interpolation.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct ai_mod_chroma_threshold_lpf_tabStruct
            {
                static constexpr UINT32 ai_mod_chroma_threshold_lpfFixedCount = 2;
                UINT32                  ai_mod_chroma_threshold_lpf[2];

                void Load(
                    ParameterLoadParameters& parentParams);

                static void LoadArray(
                    ParameterLoadParameters& __params,
                    void*                    __array,
                    UINT32                   __count);

                static void* AllocArray(
                    UINT32 __count);

                bool GetValue(
                    const CHAR* __path,
                    CHAR*       __value,
                    UINT32      __size);

                bool SetValue(
                    const CHAR* __path,
                    const CHAR* __value);

                bool GetInfo(
                    const CHAR*                 __path,
                    PList<ParameterParserInfo>& __info);
            };
            struct ai_mod_chroma_threshold_lpf_tabStruct ai_mod_chroma_threshold_lpf_tab;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// ai_mod_dcblend2_factor_lpf_tab
            ///
            /// Description:   First entry for c2. Second entry for c3. LPF3x3 case: 2*c2+c3=128.
            /// Type:          uint
            /// Range:         [[0, 64],[0, 128]]
            /// Length:        2
            /// Notes:         Hide in GUI ! Linear interpolation.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct ai_mod_dcblend2_factor_lpf_tabStruct
            {
                static constexpr UINT32 ai_mod_dcblend2_factor_lpfFixedCount = 2;
                UINT32                  ai_mod_dcblend2_factor_lpf[2];

                void Load(
                    ParameterLoadParameters& parentParams);

                static void LoadArray(
                    ParameterLoadParameters& __params,
                    void*                    __array,
                    UINT32                   __count);

                static void* AllocArray(
                    UINT32 __count);

                bool GetValue(
                    const CHAR* __path,
                    CHAR*       __value,
                    UINT32      __size);

                bool SetValue(
                    const CHAR* __path,
                    const CHAR* __value);

                bool GetInfo(
                    const CHAR*                 __path,
                    PList<ParameterParserInfo>& __info);
            };
            struct ai_mod_dcblend2_factor_lpf_tabStruct ai_mod_dcblend2_factor_lpf_tab;

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ai_modifiersStruct ai_modifiers;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct pass_dataStruct pass_data;

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_anr14_reserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_anr14_reserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mod_anr14_pass_reserve_data - Array
    /// Length:        4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static constexpr UINT32          mod_anr14_pass_reserve_dataFixedCount = 4;
    mod_anr14_pass_reserve_dataType  mod_anr14_pass_reserve_data[4];

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// anr14_rgn_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct anr14_rgn_dataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luma_filter_kernel
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct luma_filter_kernelStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// edge_kernel_size
        ///
        /// Tuning Level:  must_tune
        /// Description:   size of edge filter, configured both for autoconf and manual configuration. 0 - 1x1 ( luma filter
        ///                bypass). 1 - 3x3. 2 - 5x5. 3 - 7x7. 4 - 9x9.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [0, 4]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  edge_kernel_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// automatic_definition_granularity
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   luma filter kernel non manual mode, ratio between center and sides. Lower granularity is more smoothing
        ///                kernel (more rectangle). Higher granularity is less smoothing kernel (more picky).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         Linear Floor Interpolation: Do Linear Interpolation and then Floor.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  automatic_definition_granularity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_1x1_center_coefficient
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter middle pixel weight.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [4, 47]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_1x1_center_coefficient;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_3x3_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 3x3 horizontal/vertical pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 -
        ///                Weight 2. 2 - Weight 4. 3 - Weight 8.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_3x3_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_3x3_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 3x3 diagonal pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4. 3 - Weight 8.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_3x3_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_5x5_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 5x5 horizontal/vertical shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2.
        ///                2 - Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_5x5_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_5x5_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 5x5 diagonal pixel weights. 0 - Weight 1. 1 - Weight 2. 2 - Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_5x5_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_5x5_complement_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 5x5 off-diagonal (complementary) shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 -
        ///                Weight 2. 2 - Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_5x5_complement_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_7x7_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter horizontal/vertical pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight
        ///                2. 2 - Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_7x7_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_7x7_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter diagonal pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_7x7_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_7x7_complement_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 7x7 off-diagonal shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_7x7_complement_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_9x9_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter horizontal/vertical shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_9x9_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_9x9_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 9x9 diagonal shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 - Weight
        ///                4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_9x9_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_edge_kernel_9x9_complement_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 9x9 off-diagonal shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_edge_kernel_9x9_complement_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_blend_weight
        ///
        /// Tuning Level:  often_tune
        /// Description:   Max Blend Weight of the flat kernel in regards to Edge kernel. (blend is linear as a function of pixel
        ///                smoothness).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 128]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_blend_weight;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_size
        ///
        /// Tuning Level:  often_tune
        /// Description:   0 - 1x1 (luma filter bypass). 1 - 3x3. 2 - 5x5. 3 - 7x7. 4 - 9x9.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 4]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_1x1_center_coefficient
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter middle pixel weight.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [4, 47]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_1x1_center_coefficient;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_3x3_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 3x3 horizontal/vertical pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 -
        ///                Weight 2. 2 - Weight 4. 3 - Weight 8.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_3x3_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_3x3_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 3x3 diagonal pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4. 3 - Weight 8.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_3x3_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_5x5_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 5x5 horizontal/vertical shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2.
        ///                2 - Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_5x5_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_5x5_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 5x5 diagonal pixel shift weights. Actual weight is 2^shift . 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_5x5_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_5x5_complement_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 5x5 off-diagonal (complementary) shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 -
        ///                Weight 2. 2 - Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_5x5_complement_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_7x7_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 7x7 horizontal/vertical pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 -
        ///                Weight 2. 2 - Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_7x7_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_7x7_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 7x7 diagonal pixel shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_7x7_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_7x7_complement_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 7x7 off-diagonal shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_7x7_complement_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_9x9_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter horizontal/vertical shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_9x9_horver_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_9x9_diag_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 9x9 diagonal shift weights. Actual weight is 2^shift. 0 - Weight 1. 1 - Weight 2. 2 - Weight
        ///                4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_9x9_diag_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// manual_flat_kernel_9x9_complement_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   luma filter 9x9 off-diagonal shift weights. Actual weight is 2^shift . 0 - Weight 1. 1 - Weight 2. 2 -
        ///                Weight 4.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_9x9_complement_shift;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct luma_filter_kernelStruct luma_filter_kernel;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chroma_filter_kernel
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct chroma_filter_kernelStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// kernel_size
        ///
        /// Tuning Level:  must_tune
        /// Description:   0 - 1x1 (YLPF1 bypass). 1 - 3x3. 2 - 5x5. 3 - 7x7.
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [0, 3]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  kernel_size;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct chroma_filter_kernelStruct chroma_filter_kernel;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// inter_length_thr_modification
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct inter_length_thr_modificationStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_input_indication_thr_modification_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   The strength is the maximal thresh gain factor on current PASS assuming fully flat pixel detected by
        ///                input indication from the lower pass. The thresh gain factor for every pixel will be based on the maximal
        ///                value and the flatness of the pixel detected by indication of the lower pass. . 7Q4, example 16 == X1.
        ///                Actual Possible Values are: [16,17,18,20,24,28,30,32,40,48,56,64,72,80] ( == X [ 1, 1.0625, 1.125, 1.25,
        ///                1.5, 1.75, 1.875, 2, 2.5, 3, 3.5, 4, 4.5, 5 ] ). all other values will be quantized later to one of the
        ///                Actual Possible Values.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [16, 80]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_input_indication_thr_modification_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_input_indication_thr_modification_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   The strength is the maximal thresh gain factor on current PASS assuming fully flat pixel detected by
        ///                input indication from the lower pass. The thresh gain factor for every pixel will be based on the maximal
        ///                value and the flatness of the pixel detected by indication of the lower pass. . 7Q4, example 16 == X1.
        ///                Actual Possible Values are: [16,17,18,20,24,28,30,32,40,48,56,64,72,80] ( == X [ 1, 1.0625, 1.125, 1.25,
        ///                1.5, 1.75, 1.875, 2, 2.5, 3, 3.5, 4, 4.5, 5 ] ). all other values will be quantized later to one of the
        ///                Actual Possible Values.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [16, 80]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_input_indication_thr_modification_scale;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct inter_length_thr_modificationStruct inter_length_thr_modification;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// inter_length_output_indication
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct inter_length_output_indicationStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_center_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   in case center pixel is flatter than center_binarization_minflatval it will indicate the pixel as flat
        ///                without any regard to neighbors. If not, the decision will be done according to neighbors decision.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [1, 5]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_center_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   neighbors are counted as flat if they are flatter than neighbours_binarization_minflatval.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [1, 4]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   if percentage of neighbors are determined as flat (according to comparison with
        ///                neighbours_binarization_minflatval) is greater than neighbours_agreement_sensitivity, center pixel will
        ///                be indicated as flat for higher pass.
        /// Type:          uint
        /// Default Value: 80
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_neighbours_agreement_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_center_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   in case center pixel is flatter than center_binarization_minflatval it will indicate the pixel as flat
        ///                without any regard to neighbors. If not, the decision will be done according to neighbors decision.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [1, 6]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_center_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   neighbors are counted as flat if they are flatter than neighbours_binarization_minflatval.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [1, 5]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   if percentage of neighbors are determined as flat (according to comparison with
        ///                neighbours_binarization_minflatval) is greater than neighbours_agreement_sensitivity, center pixel will
        ///                be indicated as flat for higher pass.
        /// Type:          uint
        /// Default Value: 80
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_neighbours_agreement_sensitivity;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct inter_length_output_indicationStruct inter_length_output_indication;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// grey_treatment
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct grey_treatmentStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable_grey_treatment_dcblend2_chroma_modification
        ///
        /// Tuning Level:  must_tune
        /// Description:   dcblend2 will blend as a function of max(greyDCSize,cDCSize) instead of just cDCSize in case that the
        ///                chromaticity of the lower pass is lower than the chromaticity of the current pass for the current pixel.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  enable_grey_treatment_dcblend2_chroma_modification;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_grey_condition_chromaticity_thr_low
        ///
        /// Tuning Level:  must_tune
        /// Description:   Define the conditions for identifying areas as 'grey' - chroma threshold p1 (100% weight), Linear in
        ///                between p1,p2 (start,end).
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [0, 182]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_grey_condition_chromaticity_thr_low;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_grey_condition_chromaticity_thr_high
        ///
        /// Tuning Level:  must_tune
        /// Description:   Define the conditions for identifying areas as 'grey' - chroma threshold p2 (0% weight), Linear in
        ///                between p1,p2 (start,end).
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [0, 182]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_grey_condition_chromaticity_thr_high;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_grey_condition_y_max_derivative_thr_low
        ///
        /// Tuning Level:  must_tune
        /// Description:   Define the conditions for identifying areas as 'grey' - derivative threshold p1 (0% weight), Linear in
        ///                between p1,p2 (start,end).
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_grey_condition_y_max_derivative_thr_low;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_grey_condition_y_max_derivative_thr_high
        ///
        /// Tuning Level:  must_tune
        /// Description:   Define the conditions for identifying areas as 'grey' - derivative threshold p2 (100% weight), Linear in
        ///                between p1,p2 (start,end).
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_grey_condition_y_max_derivative_thr_high;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_greydcsize_neighbors_chromaticity_thr
        ///
        /// Tuning Level:  must_tune
        /// Description:   pixels Neighborhood should have chromaticity lower than this threshold in order to be defined as grey for
        ///                the calculation of the greydcsize.
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [0, 182]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_greydcsize_neighbors_chromaticity_thr;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// thr_modification_target_y
        ///
        /// Tuning Level:  must_tune
        /// Description:   Increase the chroma filter thresholds prior to the CLPF filtering algorithm. If target_y,u,v ==0 then it
        ///                won't change the thresholds, actually if the target threshold is less than base threshold, then no change
        ///                will be made.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  thr_modification_target_y;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// thr_modification_target_u
        ///
        /// Tuning Level:  must_tune
        /// Description:   Increase the chroma filter thresholds prior to the CLPF filtering algorithm. If target_y,u,v ==0 then it
        ///                won't change the thresholds, actually if the target threshold is less than base threshold, then no change
        ///                will be made.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  thr_modification_target_u;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// thr_modification_target_v
        ///
        /// Tuning Level:  must_tune
        /// Description:   Increase the chroma filter thresholds prior to the CLPF filtering algorithm. If target_y,u,v ==0 then it
        ///                won't change the thresholds, actually if the target threshold is less than base threshold, then no change
        ///                will be made.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  thr_modification_target_v;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct grey_treatmentStruct grey_treatment;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chroma_filter_extension
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct chroma_filter_extensionStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_override_detail_condition_chromaticity_thr
        ///
        /// Tuning Level:  must_tune
        /// Description:   The maximum chromaticity value for which details are disabled.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 182]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_override_detail_condition_chromaticity_thr;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_override_detail_condition_y_max_derivative_thr
        ///
        /// Tuning Level:  must_tune
        /// Description:   The minimum luma derivative value for which details are disabled.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_override_detail_condition_y_max_derivative_thr;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_corner_detail_sensitivity_y
        ///
        /// Tuning Level:  must_tune
        /// Description:   The local detail sensitivity controls the local conditions logic: . High value - more local details are
        ///                identified in the image ( = less filtering is performed) . Low value - less local details are identified
        ///                in the image ( = more filtering is performed). this will multiply the chroma x modifiers (scale and
        ///                offset). Q4 example 16 == X1. 65 to disable median filter.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 65]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_corner_detail_sensitivity_y;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_corner_detail_sensitivity_uv
        ///
        /// Tuning Level:  must_tune
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 64]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_corner_detail_sensitivity_uv;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_triple_chromaticities_detail_thr_up_down
        ///
        /// Tuning Level:  must_tune
        /// Description:   Threshold for chroma detail detection, chromaticity difference is calculated from chromaticity 8bits.
        ///                Higher chromaticity difference than this value is a detail.
        /// Type:          uint
        /// Default Value: 8
        /// Range:         [0, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_triple_chromaticities_detail_thr_up_down;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_triple_chromaticities_detail_thr_external
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Threshold for chroma detail detection, chromaticity difference is calculated from chromaticity 8bits.
        ///                Higher chromaticity difference than this value could be a detail depends on UD Th comparison.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_triple_chromaticities_detail_thr_external;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_isotropic_self_decision_enforce_detail
        ///
        /// Tuning Level:  often_tune
        /// Description:   1- if the pixel detected a detail than median won't work on the pixel in the problematic directions, or
        ///                all directions for isotropic. 0 - pixel self detail won't enforce median not working. Now it depends on
        ///                the environment decision.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_isotropic_self_decision_enforce_detail;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_isotropic_neighbors_detail_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   The environment detail sensitivity values determine the importance of the local indications environment
        ///                in generating a detail flag. . High value - few local detail indications are required to generate detail
        ///                flag ( = more details, less filtering). Low value - many local detail indications are required to
        ///                generate detail flag ( = less details, more filtering).
        /// Type:          uint
        /// Default Value: 64
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_isotropic_neighbors_detail_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_isotropic_neighbors_detail_sensitivity_far_scale
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   scale on the sensitivity to get sensitivity for bigger environment .
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_isotropic_neighbors_detail_sensitivity_far_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_directional_self_decision_enforce_detail
        ///
        /// Tuning Level:  often_tune
        /// Description:   1- if the pixel detected a detail than median won't work on the pixel in the problematic directions, or
        ///                all directions for isotropic. 0 - pixel self detail won't enforce median not working. Now it depends on
        ///                the environment decision.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_directional_self_decision_enforce_detail;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_directional_neighbors_detail_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   The environment detail sensitivity values determine the importance of the local indications environment
        ///                in generating a detail flag. . High value - few local detail indications are required to generate detail
        ///                flag ( = more details, less filtering). Low value - many local detail indications are required to
        ///                generate detail flag ( = less details, more filtering).
        /// Type:          uint
        /// Default Value: 32
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_directional_neighbors_detail_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_directional_neighbors_detail_sensitivity_far_scale
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   scale on the sensitivity to get sensitivity for bigger environment .
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_directional_neighbors_detail_sensitivity_far_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// bilateral_decision_minimalsize
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   if both bilateral and median are on. The mux that chooses the final result from one of the two is
        ///                controlled by Bilateral_Decision_MinimalSize. If ( chromaOutputDCindications_CDCMinSize is greater than
        ///                or equal to Bilateral_Decision_MinimalSize) then take bilateral output, otherwise take median output.
        ///                chromaOutputDCindications_CDCMinSize is in range 0:5 . . 6 is bypass. if the pixel is flatter than this
        ///                value then use the bilateral filter on it, otherwise just use median filter.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [0, 6]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  bilateral_decision_minimalsize;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct chroma_filter_extensionStruct chroma_filter_extension;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chroma_smoothing_treatment
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct chroma_smoothing_treatmentStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// flat_isotropic_3x3_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   agreement_sensitivity of the neighbors, size is 3x3. Sensitivity 128 requires 100% of neighbors to be
        ///                flat according to upper threshold.. Sensitivity 129 is disable feature.
        /// Type:          uint
        /// Default Value: 102
        /// Range:         [0, 129]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  flat_isotropic_3x3_neighbours_agreement_sensitivity;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct chroma_smoothing_treatmentStruct chroma_smoothing_treatment;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lnr
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct lnrStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// elliptic_xc
        ///
        /// Tuning Level:  must_tune
        /// Description:   XC in the formula: . R(x,y) = (A*(x-XC))^2 + (B*(y-YC))^2. logic value 0 is start of the image, 16384 is
        ///                the end of the image.
        /// Type:          uint
        /// Default Value: 8192
        /// Range:         [0, 16384]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  elliptic_xc;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// elliptic_yc
        ///
        /// Tuning Level:  must_tune
        /// Description:   YC in the formula:. R(x,y) = (A*(x-XC))^2 + (B*(y-YC))^2. logic value 0 is start of the image, 16384 is
        ///                the end of the image.
        /// Type:          uint
        /// Default Value: 8192
        /// Range:         [0, 16384]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  elliptic_yc;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// elliptic_a
        ///
        /// Tuning Level:  must_tune
        /// Description:   A in the formula:. R(x,y) = (A*(x-XC))^2 + (B*(y-YC))^2. B will be determined by B = (2^16 - A). That way
        ///                we keep A,B normalized for a valid linear interpolation.
        /// Type:          uint
        /// Default Value: 32768
        /// Range:         [6553, 58982]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  elliptic_a;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_lut_thr_y_tab
        ///
        /// Description:   luma filter Y threshold modifier LUT. Modifier threshold as a function of radius^2 and ellipses. 17
        ///                entries, each in (0,4,7) bits. . The actual Y threshold will be YbaseThr*luma_filter_lut_thr_y[elliptic
        ///                radius].
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_lut_thr_y_tabStruct
        {
            static constexpr UINT32 luma_filter_lut_thr_yFixedCount = 17;
            float                   luma_filter_lut_thr_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_lut_thr_y_tabStruct luma_filter_lut_thr_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_lut_thr_uv_tab
        ///
        /// Description:   luma filter uv threshold modifier LUT. Modifier threshold as a function of radius^2 and ellipses. 17
        ///                entries, each in (0,4,7) bits. . The actual uv threshold will be
        ///                U/VbaseThr*luma_filter_lut_thr_uv[elliptic radius].
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_lut_thr_uv_tabStruct
        {
            static constexpr UINT32 luma_filter_lut_thr_uvFixedCount = 17;
            float                   luma_filter_lut_thr_uv[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_lut_thr_uv_tabStruct luma_filter_lut_thr_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_lut_thr_y_tab
        ///
        /// Description:   chroma filter Y threshold modifier LUT. Modifier threshold as a function of radius^2 and ellipses. 17
        ///                entries, each in (0,4,7) bits. . The actual Y threshold will be YbaseThr*chroma_filter_lut_thr_y[elliptic
        ///                radius].
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_lut_thr_y_tabStruct
        {
            static constexpr UINT32 chroma_filter_lut_thr_yFixedCount = 17;
            float                   chroma_filter_lut_thr_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_lut_thr_y_tabStruct chroma_filter_lut_thr_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_lut_thr_uv_tab
        ///
        /// Description:   chroma filter uv threshold modifier LUT. Modifier threshold as a function of radius^2 and ellipses. 17
        ///                entries, each in (0,4,7) bits. . The actual uv threshold will be
        ///                U/VbaseThr*chroma_filter_lut_thr_uv[elliptic radius].
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_lut_thr_uv_tabStruct
        {
            static constexpr UINT32 chroma_filter_lut_thr_uvFixedCount = 17;
            float                   chroma_filter_lut_thr_uv[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_lut_thr_uv_tabStruct chroma_filter_lut_thr_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// strength_modifier_radius_blend_lut_tab
        ///
        /// Description:   LNR Strength Modifier LUT. . Blend factor as a function of radius, the blend factor will be used to blend
        ///                between original dcblend2_lut (or flat weight) and the dcblend2_lut * target_factor. 17 Entries, values
        ///                in 0:128 with 7 fraction bits. 128 = don't change ThMult. 0 = blend fully towards .
        /// Type:          uint
        /// Range:         [0, 128]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct strength_modifier_radius_blend_lut_tabStruct
        {
            static constexpr UINT32 strength_modifier_radius_blend_lutFixedCount = 17;
            float                   strength_modifier_radius_blend_lut[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct strength_modifier_radius_blend_lut_tabStruct strength_modifier_radius_blend_lut_tab;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct lnrStruct lnr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// cnr
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct cnrStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_angle_start_tab
        ///
        /// Description:   Angle(U,V) (hue) low limit.
        /// Type:          uint
        /// Range:         [0, 1440]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_angle_start_tabStruct
        {
            static constexpr UINT32 detect_angle_startFixedCount = 5;
            float                   detect_angle_start[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct detect_angle_start_tabStruct detect_angle_start_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_angle_end_tab
        ///
        /// Description:   Angle(U,V) (hue) high limit.
        /// Type:          uint
        /// Range:         [0, 1440]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_angle_end_tabStruct
        {
            static constexpr UINT32 detect_angle_endFixedCount = 5;
            float                   detect_angle_end[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct detect_angle_end_tabStruct detect_angle_end_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_chromaticity_start_tab
        ///
        /// Description:   Color chromaticity low limit. 1024 is maximal chromaticity chosen according to calc mode.
        /// Type:          uint
        /// Range:         [0, 1024]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_chromaticity_start_tabStruct
        {
            static constexpr UINT32 detect_chromaticity_startFixedCount = 5;
            float                   detect_chromaticity_start[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct detect_chromaticity_start_tabStruct detect_chromaticity_start_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_chromaticity_end_tab
        ///
        /// Description:   Color chromaticity high limit. 1024 is maximal chromaticity chosen according to calc mode.
        /// Type:          uint
        /// Range:         [0, 1024]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_chromaticity_end_tabStruct
        {
            static constexpr UINT32 detect_chromaticity_endFixedCount = 5;
            float                   detect_chromaticity_end[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct detect_chromaticity_end_tabStruct detect_chromaticity_end_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_luma_start_tab
        ///
        /// Description:   Y component low limit.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_luma_start_tabStruct
        {
            static constexpr UINT32 detect_luma_startFixedCount = 5;
            float                   detect_luma_start[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct detect_luma_start_tabStruct detect_luma_start_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_luma_end_tab
        ///
        /// Description:   Y component high limit.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_luma_end_tabStruct
        {
            static constexpr UINT32 detect_luma_endFixedCount = 5;
            float                   detect_luma_end[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct detect_luma_end_tabStruct detect_luma_end_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_color0_skin_saturation_min_y_min
        ///
        /// Tuning Level:  often_tune
        /// Description:   Minimum saturation value for skin when Y=Y_min.
        /// Type:          uint
        /// Default Value: 328
        /// Range:         [0, 1024]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_color0_skin_saturation_min_y_min;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_color0_skin_saturation_max_y_min
        ///
        /// Tuning Level:  often_tune
        /// Description:   Maximum saturation value for skin when Y=Y_min.
        /// Type:          uint
        /// Default Value: 1024
        /// Range:         [0, 1024]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_color0_skin_saturation_max_y_min;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_color0_skin_saturation_min_y_max
        ///
        /// Tuning Level:  often_tune
        /// Description:   Minimum saturation value for skin when Y=Y_max.
        /// Type:          uint
        /// Default Value: 82
        /// Range:         [0, 1024]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_color0_skin_saturation_min_y_max;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_color0_skin_saturation_max_y_max
        ///
        /// Tuning Level:  often_tune
        /// Description:   Maximum saturation value for skin when Y=Y_max.
        /// Type:          uint
        /// Default Value: 819
        /// Range:         [0, 1024]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_color0_skin_saturation_max_y_max;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// boundary_weight_tab
        ///
        /// Description:   Weight value at Color Range Borders.
        /// Type:          uint
        /// Range:         [1, 15]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct boundary_weight_tabStruct
        {
            static constexpr UINT32 boundary_weightFixedCount = 5;
            float                   boundary_weight[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct boundary_weight_tabStruct boundary_weight_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_threshold_scale_y_tab
        ///
        /// Description:   Gain factor YLPF Y-Base Threshold.
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_threshold_scale_y_tabStruct
        {
            static constexpr UINT32 luma_filter_threshold_scale_yFixedCount = 5;
            float                   luma_filter_threshold_scale_y[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_threshold_scale_y_tabStruct luma_filter_threshold_scale_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_threshold_scale_uv_tab
        ///
        /// Description:   Gain factor for YLPF U/V-Base Thresholds .
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_threshold_scale_uv_tabStruct
        {
            static constexpr UINT32 luma_filter_threshold_scale_uvFixedCount = 5;
            float                   luma_filter_threshold_scale_uv[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_threshold_scale_uv_tabStruct luma_filter_threshold_scale_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_offset_y_tab
        ///
        /// Description:   Offset for YLPF Y-Base Threshold .
        /// Type:          int
        /// Range:         [-1024, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_offset_y_tabStruct
        {
            static constexpr UINT32 luma_filter_offset_yFixedCount = 5;
            float                   luma_filter_offset_y[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_offset_y_tabStruct luma_filter_offset_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_offset_u_tab
        ///
        /// Description:   Offset for YLPF U-Base Threshold .
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_offset_u_tabStruct
        {
            static constexpr UINT32 luma_filter_offset_uFixedCount = 5;
            float                   luma_filter_offset_u[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_offset_u_tabStruct luma_filter_offset_u_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_offset_v_tab
        ///
        /// Description:   Offset for YLPF V-Base Threshold.
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_offset_v_tabStruct
        {
            static constexpr UINT32 luma_filter_offset_vFixedCount = 5;
            float                   luma_filter_offset_v[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct luma_filter_offset_v_tabStruct luma_filter_offset_v_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_threshold_scale_y_tab
        ///
        /// Description:   Gain factor for CLPF Y-Base Threshold.
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_threshold_scale_y_tabStruct
        {
            static constexpr UINT32 chroma_filter_threshold_scale_yFixedCount = 5;
            float                   chroma_filter_threshold_scale_y[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_threshold_scale_y_tabStruct chroma_filter_threshold_scale_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_threshold_scale_uv_tab
        ///
        /// Description:   Gain factor for CLPF U/V- Base Threshold .
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_threshold_scale_uv_tabStruct
        {
            static constexpr UINT32 chroma_filter_threshold_scale_uvFixedCount = 5;
            float                   chroma_filter_threshold_scale_uv[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_threshold_scale_uv_tabStruct chroma_filter_threshold_scale_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_offset_y_tab
        ///
        /// Description:   Offset for CLPF Y-Base Threshold.
        /// Type:          int
        /// Range:         [-1024, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_offset_y_tabStruct
        {
            static constexpr UINT32 chroma_filter_offset_yFixedCount = 5;
            float                   chroma_filter_offset_y[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_offset_y_tabStruct chroma_filter_offset_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_offset_u_tab
        ///
        /// Description:   Offset for CLPF U-Base Threshold.
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_offset_u_tabStruct
        {
            static constexpr UINT32 chroma_filter_offset_uFixedCount = 5;
            float                   chroma_filter_offset_u[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_offset_u_tabStruct chroma_filter_offset_u_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_offset_v_tab
        ///
        /// Description:   Offset for CLPF V-Base Threshold.
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_offset_v_tabStruct
        {
            static constexpr UINT32 chroma_filter_offset_vFixedCount = 5;
            float                   chroma_filter_offset_v[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct chroma_filter_offset_v_tabStruct chroma_filter_offset_v_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_base_far_modifier_y
        ///
        /// Tuning Level:  often_tune
        /// Description:   CLPF Blend factor for CNR gain level for the Far base Luma thresholds. 0-no CNR modification on far
        ///                thresholds at all. 4-full CNR modification on far with same scale and offset as in close. in between we
        ///                blend.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [0, 4]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_filter_base_far_modifier_y;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_base_far_modifier_uv
        ///
        /// Tuning Level:  often_tune
        /// Description:   CLPF Blend factor for CNR gain level for the Far base Chroma thresholds. 0-no CNR modification on far
        ///                thresholds at all. 4-full CNR modification on far with same scale and offset as in close. in between we
        ///                blend.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [0, 4]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_filter_base_far_modifier_uv;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct cnrStruct cnr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luma_filter_detection_thresholds
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct luma_filter_detection_thresholdsStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_per_y_tab
        ///
        /// Description:   luma_filter, _Y threshold LutY.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct y_threshold_per_y_tabStruct
        {
            static constexpr UINT32 y_threshold_per_yFixedCount = 17;
            float                   y_threshold_per_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct y_threshold_per_y_tabStruct y_threshold_per_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_per_uv_tab
        ///
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the LUT
        ///                interpolation are limited with control_per_uv_limit. u_limited = min(u, control_per_uv_limit), v_limited
        ///                = min(u, control_per_uv_limit). Output value =interp2( y_threshold_per_uv, (u_limited,v_limited) ).
        /// Type:          int
        /// Range:         [-128, 127]
        /// Length:        8
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct y_threshold_per_uv_tabStruct
        {
            static constexpr UINT32 y_threshold_per_uvFixedCount = 8;
            float                   y_threshold_per_uv[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct y_threshold_per_uv_tabStruct y_threshold_per_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_close3_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   Luma filter, 3x3 luma derivative , 6 bits unsigned (0,2,4).
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_close3_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_close3_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   Luma filter, 3x3 luma derivative , 11 bits signed (1,10,0).
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-1024, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_close3_mod_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_far_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, 7x7/9x9 _Ythr modifier Far(7,9) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_far_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_far_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, 7x7/9x9 _Ythr modifier Far(7,9) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-1024, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_far_mod_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_per_y_tab
        ///
        /// Description:   luma_filter, _U threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct u_threshold_per_y_tabStruct
        {
            static constexpr UINT32 u_threshold_per_yFixedCount = 17;
            float                   u_threshold_per_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct u_threshold_per_y_tabStruct u_threshold_per_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_per_uv_tab
        ///
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the LUT
        ///                interpolation are limited with control_per_uv_limit. u_limited = min(u, control_per_uv_limit), v_limited
        ///                = min(u, control_per_uv_limit). Output value =interp2( y_threshold_per_uv, (u_limited,v_limited) ).
        /// Type:          int
        /// Range:         [-32, 31]
        /// Length:        8
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct u_threshold_per_uv_tabStruct
        {
            static constexpr UINT32 u_threshold_per_uvFixedCount = 8;
            float                   u_threshold_per_uv[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct u_threshold_per_uv_tabStruct u_threshold_per_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_far_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, 7x7/9x9(luma) _Uthr modifier Far(5) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_far_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_per_y_tab
        ///
        /// Description:   luma_filter, _V threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct v_threshold_per_y_tabStruct
        {
            static constexpr UINT32 v_threshold_per_yFixedCount = 17;
            float                   v_threshold_per_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct v_threshold_per_y_tabStruct v_threshold_per_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_per_uv_tab
        ///
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the LUT
        ///                interpolation are limited with control_per_uv_limit. u_limited = min(u, control_per_uv_limit), v_limited
        ///                = min(u, control_per_uv_limit). Output value =interp2( y_threshold_per_uv, (u_limited,v_limited) ).
        /// Type:          int
        /// Range:         [-32, 31]
        /// Length:        8
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct v_threshold_per_uv_tabStruct
        {
            static constexpr UINT32 v_threshold_per_uvFixedCount = 8;
            float                   v_threshold_per_uv[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct v_threshold_per_uv_tabStruct v_threshold_per_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_far_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, 7x7/9x9(luma) _Vthr modifier Far(5) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_far_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_far_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, 7x7/9x9(luma) _Vthr modifier Far(5) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-256, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_far_mod_offset;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct luma_filter_detection_thresholdsStruct luma_filter_detection_thresholds;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chroma_filter_detection_thresholds
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct chroma_filter_detection_thresholdsStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_per_y_tab
        ///
        /// Description:   chroma_filter, _Y threshold LutY.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct y_threshold_per_y_tabStruct
        {
            static constexpr UINT32 y_threshold_per_yFixedCount = 17;
            float                   y_threshold_per_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct y_threshold_per_y_tabStruct y_threshold_per_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_per_uv_tab
        ///
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the LUT
        ///                interpolation are limited with control_per_uv_limit. u_limited = min(u, control_per_uv_limit), v_limited
        ///                = min(u, control_per_uv_limit). Output value =interp2( y_threshold_per_uv, (u_limited,v_limited) ).
        /// Type:          int
        /// Range:         [-128, 127]
        /// Length:        8
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct y_threshold_per_uv_tabStruct
        {
            static constexpr UINT32 y_threshold_per_uvFixedCount = 8;
            float                   y_threshold_per_uv[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct y_threshold_per_uv_tabStruct y_threshold_per_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_far_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 5x5 _Ythr modifier Far(5 chroma blocks but 7x7/9x9 for y pixels) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_far_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_per_y_tab
        ///
        /// Description:   chroma_filter, _U threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct u_threshold_per_y_tabStruct
        {
            static constexpr UINT32 u_threshold_per_yFixedCount = 17;
            float                   u_threshold_per_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct u_threshold_per_y_tabStruct u_threshold_per_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_per_uv_tab
        ///
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the LUT
        ///                interpolation are limited with control_per_uv_limit. u_limited = min(u, control_per_uv_limit), v_limited
        ///                = min(u, control_per_uv_limit). Output value =interp2( y_threshold_per_uv, (u_limited,v_limited) ).
        /// Type:          int
        /// Range:         [-32, 31]
        /// Length:        8
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct u_threshold_per_uv_tabStruct
        {
            static constexpr UINT32 u_threshold_per_uvFixedCount = 8;
            float                   u_threshold_per_uv[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct u_threshold_per_uv_tabStruct u_threshold_per_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_far_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 5x5 _Uthr modifier Far(5) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_far_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_distant_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter,_Uthr modifier Dist (7) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_distant_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_per_y_tab
        ///
        /// Description:   chroma_filter, _V threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct v_threshold_per_y_tabStruct
        {
            static constexpr UINT32 v_threshold_per_yFixedCount = 17;
            float                   v_threshold_per_y[17];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct v_threshold_per_y_tabStruct v_threshold_per_y_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_per_uv_tab
        ///
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the LUT
        ///                interpolation are limited with control_per_uv_limit. u_limited = min(u, control_per_uv_limit), v_limited
        ///                = min(u, control_per_uv_limit). Output value =interp2( y_threshold_per_uv, (u_limited,v_limited) ).
        /// Type:          int
        /// Range:         [-32, 31]
        /// Length:        8
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct v_threshold_per_uv_tabStruct
        {
            static constexpr UINT32 v_threshold_per_uvFixedCount = 8;
            float                   v_threshold_per_uv[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct v_threshold_per_uv_tabStruct v_threshold_per_uv_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_far_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 5x5 _Vthr modifier Far(5) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_far_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_distant_mod_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 7x7 _Vthr modifier Dist (7) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_distant_mod_scale;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct chroma_filter_detection_thresholdsStruct chroma_filter_detection_thresholds;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dcblend2
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct dcblend2Struct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcblend2_luma_strength_function_tab
        ///
        /// Description:   Controls the strength of DCBlend2. LUT of how much to blend as a function YDCSize. Higher values reduce
        ///                luminance noise significantly, at the expense of texture, granularity and sharpness. Lower values
        ///                maintain the luminance noise levels, while preserving texture, granularity and sharpness.
        /// Type:          uint
        /// Range:         [0, 128]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct dcblend2_luma_strength_function_tabStruct
        {
            static constexpr UINT32 dcblend2_luma_strength_functionFixedCount = 5;
            float                   dcblend2_luma_strength_function[5];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct dcblend2_luma_strength_function_tabStruct dcblend2_luma_strength_function_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcblend2_chroma_strength_function_tab
        ///
        /// Description:   Controls the strength of DCBlend2. LUT of how much to blend as a function CDCSize. (in case of filter2
        ///                ind extension interp is off, these values will be interpolated to [0,3] instead of [0,5]). Higher values
        ///                reduce chromatic noise significantly, at the expense of texture, granularity and sharpness. Lower values
        ///                maintain the chromatic noise levels, while preserving texture, granularity and sharpness.
        /// Type:          uint
        /// Range:         [0, 128]
        /// Length:        6
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct dcblend2_chroma_strength_function_tabStruct
        {
            static constexpr UINT32 dcblend2_chroma_strength_functionFixedCount = 6;
            float                   dcblend2_chroma_strength_function[6];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct dcblend2_chroma_strength_function_tabStruct dcblend2_chroma_strength_function_tab;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct dcblend2Struct dcblend2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ai_modifiers
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct ai_modifiersStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_mod_rgn_enable
        ///
        /// Tuning Level:  must_tune
        /// Description:   Enable bit of AI mod for the entire region.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  ai_mod_rgn_enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_mod_luma_threshold_cat_lut_tab
        ///
        /// Description:   LUT for converting category to modifier strength.
        /// Type:          float
        /// Range:         [0, 7.96875]
        /// Length:        32
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ai_mod_luma_threshold_cat_lut_tabStruct
        {
            static constexpr UINT32 ai_mod_luma_threshold_cat_lutFixedCount = 32;
            float                   ai_mod_luma_threshold_cat_lut[32];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ai_mod_luma_threshold_cat_lut_tabStruct ai_mod_luma_threshold_cat_lut_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_mod_luma_threshold_conf_lut_tab
        ///
        /// Description:   LUT for mapping confidence index to confidence impact on modifier.
        /// Type:          float
        /// Range:         [0, 1]
        /// Length:        8
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ai_mod_luma_threshold_conf_lut_tabStruct
        {
            static constexpr UINT32 ai_mod_luma_threshold_conf_lutFixedCount = 8;
            float                   ai_mod_luma_threshold_conf_lut[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ai_mod_luma_threshold_conf_lut_tabStruct ai_mod_luma_threshold_conf_lut_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_mod_chroma_threshold_cat_lut_tab
        ///
        /// Description:   LUT for converting category to modifier strength.
        /// Type:          float
        /// Range:         [0, 7.96875]
        /// Length:        32
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ai_mod_chroma_threshold_cat_lut_tabStruct
        {
            static constexpr UINT32 ai_mod_chroma_threshold_cat_lutFixedCount = 32;
            float                   ai_mod_chroma_threshold_cat_lut[32];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ai_mod_chroma_threshold_cat_lut_tabStruct ai_mod_chroma_threshold_cat_lut_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_mod_chroma_threshold_conf_lut_tab
        ///
        /// Description:   LUT for mapping confidence index to confidence impact on modifier.
        /// Type:          float
        /// Range:         [0, 1]
        /// Length:        8
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ai_mod_chroma_threshold_conf_lut_tabStruct
        {
            static constexpr UINT32 ai_mod_chroma_threshold_conf_lutFixedCount = 8;
            float                   ai_mod_chroma_threshold_conf_lut[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ai_mod_chroma_threshold_conf_lut_tabStruct ai_mod_chroma_threshold_conf_lut_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_mod_dcblend2_factor_cat_lut_tab
        ///
        /// Description:   LUT for converting category to modifier strength.
        /// Type:          float
        /// Range:         [0, 3.984375]
        /// Length:        32
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ai_mod_dcblend2_factor_cat_lut_tabStruct
        {
            static constexpr UINT32 ai_mod_dcblend2_factor_cat_lutFixedCount = 32;
            float                   ai_mod_dcblend2_factor_cat_lut[32];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ai_mod_dcblend2_factor_cat_lut_tabStruct ai_mod_dcblend2_factor_cat_lut_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ai_mod_dcblend2_factor_conf_lut_tab
        ///
        /// Description:   LUT for mapping confidence index to confidence impact on modifier.
        /// Type:          float
        /// Range:         [0, 1]
        /// Length:        8
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ai_mod_dcblend2_factor_conf_lut_tabStruct
        {
            static constexpr UINT32 ai_mod_dcblend2_factor_conf_lutFixedCount = 8;
            float                   ai_mod_dcblend2_factor_conf_lut[8];

            void Load(
                ParameterLoadParameters& parentParams);

            static void LoadArray(
                ParameterLoadParameters& __params,
                void*                    __array,
                UINT32                   __count);

            static void* AllocArray(
                UINT32 __count);

            bool GetValue(
                const CHAR* __path,
                CHAR*       __value,
                UINT32      __size);

            bool SetValue(
                const CHAR* __path,
                const CHAR* __value);

            bool GetInfo(
                const CHAR*                 __path,
                PList<ParameterParserInfo>& __info);
        };
        struct ai_mod_dcblend2_factor_conf_lut_tabStruct ai_mod_dcblend2_factor_conf_lut_tab;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct ai_modifiersStruct ai_modifiers;

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// mod_anr14_pass_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct mod_anr14_pass_dataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// pass_trigger
    ///
    /// Default Value: PASS_FULL,PASS_DC4,PASS_DC16,PASS_DC64
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ispglobalelements::trigger_pass pass_trigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anr14_rgn_data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    anr14_rgn_dataType              anr14_rgn_data;

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// mod_anr14_rgn_array_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct mod_anr14_rgn_array_dataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mod_anr14_pass_data - Array
    /// Length:        4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static constexpr UINT32  mod_anr14_pass_dataFixedCount = 4;
    mod_anr14_pass_dataType  mod_anr14_pass_data[4];

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// triggerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct triggerType
{
    UINT32                           controlIndex;
    ispglobalelements::trigger_types type;

    float                         start;
    float                         end;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// trigger - Array
    /// Min Length:    0
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                        triggerCount;
    UINT32                        triggerID;
    triggerType*                  trigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// region - Optional
    /// Min Length:    0
    /// Max Length:    1
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                        regionCount;
    UINT32                        regionID;
    mod_anr14_rgn_array_dataType* region;

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);
    void Unload(ParameterFileSymbolTable* const __table);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_anr14_coreType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_anr14_coreType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mod_anr14_trigger_data - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32       mod_anr14_trigger_dataCount;
    UINT32       mod_anr14_trigger_dataID;
    triggerType* mod_anr14_trigger_data;

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);
    void Unload(ParameterFileSymbolTable* const __table);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_anr14Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_anr14Type
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable_section
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct enable_sectionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        globalelements::enable_flag_type enable_luma_noise_reduction;
        globalelements::enable_flag_type enable_chroma_noise_reduction;
        globalelements::enable_flag_type ai_mod_luma_threshold_enable;
        globalelements::enable_flag_type ai_mod_chroma_threshold_enable;
        globalelements::enable_flag_type ai_mod_dcblend2_factor_enable;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct enable_sectionStruct enable_section;

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

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct module_versionStruct module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// parameter_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct parameter_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        CHAR*  revision;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);
        void Unload(ParameterFileSymbolTable* const __table);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct parameter_versionStruct parameter_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// control_variables
    ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct control_variablesStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// control_var_type - Array
        /// Default Value: trigger_type_lens_position, trigger_type_lens_zoom, trigger_type_post_nr_scale_ratio, trigger_type_pre_nr_scale_ratio, trigger_type_drc_gain, trigger_type_exp_time_ratio, trigger_type_gain, trigger_type_cct
        /// Min Length:    1
        /// Max Length:    Unbounded
        /// Comments:      Interpolation lookup trigger types. Value: 0 - 99
        ///                Triggers with no interpolation. Value: 75 - 99
        ///                it should always be first trigger
        ///                Discrete lookup trigger types. Value: 100 - 199
        ///                Nearest neighbor lookup trigger types. Value: 200 - 299
        ///                Custom lookup trigger types Values: 1000 - 1100
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32                            control_var_typeCount;
        UINT32                            control_var_typeID;
        ispglobalelements::trigger_types* control_var_type;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);
        void Unload(ParameterFileSymbolTable* const __table);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct control_variablesStruct control_variables;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// private_information
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct private_informationStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// led_sensitivity_trigger
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ispglobalelements::trigger_pt_type led_sensitivity_trigger;

        void Load(
            ParameterLoadParameters& parentParams);

        static void LoadArray(
            ParameterLoadParameters& __params,
            void*                    __array,
            UINT32                   __count);

        static void* AllocArray(
            UINT32 __count);

        bool GetValue(
            const CHAR* __path,
            CHAR*       __value,
            UINT32      __size);

        bool SetValue(
            const CHAR* __path,
            const CHAR* __value);

        bool GetInfo(
            const CHAR*                 __path,
            PList<ParameterParserInfo>& __info);
    };
    struct private_informationStruct private_information;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chromatix_anr14_reserve
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_anr14_reserveType chromatix_anr14_reserve;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chromatix_anr14_core
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_anr14_coreType    chromatix_anr14_core;

    void Load(
        ParameterLoadParameters& parentParams);

    static void LoadArray(
        ParameterLoadParameters& __params,
        void*                    __array,
        UINT32                   __count);

    static void* AllocArray(
        UINT32 __count);
    void Unload(ParameterFileSymbolTable* const __table);

    bool GetValue(
        const CHAR* __path,
        CHAR*       __value,
        UINT32      __size);

    bool SetValue(
        const CHAR* __path,
        const CHAR* __value);

    bool GetInfo(
        const CHAR*                 __path,
        PList<ParameterParserInfo>& __info);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// 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();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetModuleName: Returns ParameterModule::Name variable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    const CHAR* GetModuleName();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetModuleName: Returns ParameterModule::Name variable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT64 GetModuleNameHash();
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatix_anr14TypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatix_anr14TypeClass : public ParameterModule, public chromatix_anr14Type
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static constexpr UINT16 MAJOR = 1U;
    static constexpr UINT16 MINOR = 4U;
    static constexpr UINT32 PATCH = 1U;

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

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

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatix_anr14TypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetModuleName: Returns ParameterModule::Name variable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual PARAMETER_INLINE const CHAR* GetModuleName()
    {
        return Name;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetModuleNameHash: Returns ParameterModule::NameHash variable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual PARAMETER_INLINE UINT64 GetModuleNameHash()
    {
        return NameHash;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Update the trigger type values
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UpdateTriggerType(
        control_variablesStruct* const control,
        triggerType* trigger,
        UINT32 const depth);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// 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();

    virtual bool GetValue(
        const CHAR* const __path,
        CHAR* const       __value,
        UINT32 const      __size)
    {
        return chromatix_anr14Type::GetValue(__path, __value, __size);
    }

    virtual bool SetValue(
        const CHAR* const __path,
        const CHAR* const __value)
    {
        if (chromatix_anr14Type::SetValue(__path, __value))
        {
            // Change SymbolTableID so the code can detect that the module was modified.
            // Increment by 0x01000000, so the original value is preserved for diagnostics (mask with 0x00FFFFFF)
            if (SymbolTableID >= 0xff000000)
            {
                SymbolTableID = SymbolTableID & 0x00ffffffU;
            }
            SymbolTableID += 0x01000000;

            // Increment Modified counter (replaces SymbolTableID to detect modified data)
            Modified++;
            return true;
        }
        else
        {
            return false;
        }
    }

    virtual bool GetInfo(
        const CHAR* const           __path,
        PList<ParameterParserInfo>& __info)
    {
        return chromatix_anr14Type::GetInfo(__path, __info);
    }

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

ANR_1_4_1_NAMESPACE_END
#endif // ANR_1_4_1_H

