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

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

#ifndef ANR_1_0_1_H
#define ANR_1_0_1_H

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

#define ANR_1_0_1_NAMESPACE_BEGIN namespace anr_1_0_1 {
#define ANR_1_0_1_NAMESPACE_END }

ANR_1_0_1_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// mod_anr10_pass_reserve_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct mod_anr10_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;

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

            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 indicaton extention.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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 derivativs (no need to
            ///                compare them).
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_filter_uv_thresholds;

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

            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_config
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_configStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// filter_decision_mode
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   0 - normal mode (depends on iisotropic_min, enable_external). 1 - manual settings ( manual mode, config
            ///                FiltDerFlags register as user like. (can be configured to disconnect the link betwee 5 depnds on 3 for
            ///                example ... )).
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 filter_decision_mode;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// filter_enable_external_derivatives
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   is consider dx derivatives for y filtering. 0: don't use. 1:use.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 filter_enable_external_derivatives;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// dcind_decision_mode
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   0 - normal mode. 1 - manual settings ( manual mode, config dcindDerFlags register as user like ).
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 dcind_decision_mode;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// dcind_enable_external_derivatives
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   is consider dx derivatives for y dc indications. 0: don't use. 1:use.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 dcind_enable_external_derivatives;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_use_second_derivative_for_luma_3x3
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   use 2'nd derivative for 3x3 comparison decision for luma filtering and dcind and preform OR with regular
            ///                derivative comparison of regular derivatives.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_use_second_derivative_for_luma_3x3;

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

            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_configStruct luma_filter_config;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_filter_config
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_configStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// filter_decision_mode
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   0 - normal mode. 1 - manual settings ( manual mode, config FiltDerFlags register as user like. (can be
            ///                configured to disconnect the link betwee 5 depnds on 3 for example ... )).
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 filter_decision_mode;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// dcind_decision_mode
            ///
            /// Tuning Level:  rarely_tune
            /// Description:   0 - normal mode. 1 - manual settings ( manual mode, config dcindDerFlags register as user like ).
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 dcind_decision_mode;

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

            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_configStruct chroma_filter_config;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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;

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

            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;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_peak_management
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_peak_managementStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_peak_management
            ///
            /// Tuning Level:  often_tune
            /// Description:   enable luma peak treatment.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_peak_management;

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

            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_peak_managementStruct luma_peak_management;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_peak_management
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_peak_managementStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_chroma_peak_management
            ///
            /// Tuning Level:  often_tune
            /// Description:   enable chroma peak treatment.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_peak_management;

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

            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_peak_managementStruct chroma_peak_management;

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

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// luma_neighbours_impact_enable
            ///
            /// Tuning Level:  never_tune
            /// Description:   if set to 1, pixel can be dependant on its neighbores for indicating as flat for higher pass.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 luma_neighbours_impact_enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// chroma_neighbours_impact_enable
            ///
            /// Tuning Level:  never_tune
            /// Description:   if set to 1, pixel can be dependant on its neighbores for indicating as flat for higher pass.
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 chroma_neighbours_impact_enable;

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

            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 torwards the Thr_Modification_Target_*_DER values. If fully grey, thresholds will
            ///                assume the target.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_grey_treatment_isotropic_filter_blend;

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

            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: 1
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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;

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

            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;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_smoothing_treatment
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_smoothing_treatmentStruct
        {

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_edge_smoothing
            ///
            /// Tuning Level:  must_tune
            /// Description:   If set to 1, Luma edge smoothing is enabled.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_edge_smoothing;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable_luma_transition_smoothing
            ///
            /// Tuning Level:  must_tune
            /// Description:   If set to 1, Luma transition smoothing is enabled.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_luma_transition_smoothing;

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

            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_smoothing_treatmentStruct luma_smoothing_treatment;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 enable_chroma_transition_smoothing;

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

            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
            /// Description:   enable_lnr
            /// 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 ofall 128, in between interpulate
            ///                .
            /// 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;

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

            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;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// input_select
            ///
            /// Tuning Level:  must_tune
            /// Description:   0 - select image from CYLPF. 1 - select DCNF image .
            /// Type:          uint
            /// Default Value: 1
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 input_select;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// 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_chromaticity_calc_mode_tab
            ///
            /// Tuning Level:  often_tune
            /// Description:   0 - chromaticity is calculated by (abs(U) + abs(V))/2. 1 - chromaticity is calculated by Radius =
            ///                (U^2+V^2)^0.5.
            /// Type:          uint
            /// Range:         [0, 1]
            /// Length:        5
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct detect_chromaticity_calc_mode_tabStruct
            {
                UINT32 detect_chromaticity_calc_mode[5];

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

                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_calc_mode_tabStruct detect_chromaticity_calc_mode_tab;

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

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// detect_color0_external_enable
            ///
            /// Tuning Level:  often_tune
            /// Description:   0 - disable external color regions treatment. 1 - enable color regions treatment to U is less than or
            ///                equal to 0 and V is greater than or equal to 0.
            /// Type:          uint
            /// Default Value: 0
            /// Range:         [0, 1]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 detect_color0_external_enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// face_detection_dependency_tab
            ///
            /// Tuning Level:  must_tune
            /// Description:   is dependent of Face Detection for this color. Demand FD in addition to color detection.
            /// Type:          uint
            /// Range:         [0, 1]
            /// Length:        5
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct face_detection_dependency_tabStruct
            {
                UINT32 face_detection_dependency[5];

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

                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 face_detection_dependency_tabStruct face_detection_dependency_tab;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// face_detection_boundary
            ///
            /// Tuning Level:  often_tune
            /// Description:   actual face radius will be face_detection_boundary * face_detected_radius.
            /// Type:          uint
            /// Default Value: 1229
            /// Range:         [512, 8192]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 face_detection_boundary;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// face_detection_transition
            ///
            /// Tuning Level:  often_tune
            /// Description:   actual face transition radius (from this point and outer face weight == 0 ) will be
            ///                face_detection_transition * face_detected_radius . restriction : face_detection_boundary is less than or
            ///                equal to face_detection_transition is less than = 2 * face_detection_boundary (will be forced otherwise).
            /// Type:          uint
            /// Default Value: 2048
            /// Range:         [1024, 8192]
            /// Notes:         Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 face_detection_transition;

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

            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 caluclation ).
            /// 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;

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

            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 caluclation ).
            /// 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;

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

            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;

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

            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;

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

            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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
            ///                for DC64. Constant (per pass): no dynamic configuration even when control variable change.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 dithering_c_en;

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

            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;

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

        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;

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

    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_anr10_reserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_anr10_reserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mod_anr10_pass_reserve_data - Array
    /// Length:        4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    mod_anr10_pass_reserve_dataType mod_anr10_pass_reserve_data[4];

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

    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);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// anr10_rgn_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct anr10_rgn_dataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luma_chroma_filter_config
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct luma_chroma_filter_configStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// threshold_lut_control_avg_block_size
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   yuv average block size for controling the threshold lut entry. . 0-Y3x3/UV1x1 threshold avg support.
        ///                1-Y5x5/UV3x3 threshold avg support. 2-Y9x9/UV5x5 threshold avg support.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [0, 2]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  threshold_lut_control_avg_block_size;

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

        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_chroma_filter_configStruct luma_chroma_filter_config;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luma_filter_config
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct luma_filter_configStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// filter_isotropic_min_filter_size
        ///
        /// Tuning Level:  often_tune
        /// Description:   0 - normal mode, each distance depends on distences shorter than him and himself. ( == Isotropic mode 1x1
        ///                (minimum filter size) ). 1 - Isotropic mode 3x3 (minimum filter size). 2 - Isotropic mode 5x5 (minimum
        ///                filter size). 3 - Isotropic mode 7x7 (minimum filter size). 4 - Isotropic mode 9x9 (minimum filter size).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 4]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  filter_isotropic_min_filter_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// filter_manual_derivatives_flags
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Condition flags for calculating the luma filtering. Di_j == 0 means that filtering of length i is
        ///                controlled by detection of length j. (0-consider, 1-ignore). D3_3 StartBit:0 Default:0. D3_5 StartBit:1
        ///                Default:1. D3_5X StartBit:2 Default:1. D3_7 StartBit:3 Default:1. D3_9 StartBit:4 Default:1. D3_9X
        ///                StartBit:5 Default:1. D5_3 StartBit:6 Default:0. D5_5 StartBit:7 Default:0. D5_5X StartBit:8 Default:0.
        ///                D5_7 StartBit:9 Default:1. D5_9 StartBit:10 Default:1. D5_9X StartBit:11 Default:1. D7_3 StartBit:12
        ///                Default:0. D7_5 StartBit:13 Default:0. D7_5X StartBit:14 Default:0. D7_7 StartBit:15 Default:0. D7_9
        ///                StartBit:16 Default:1. D7_9X StartBit:17 Default:1. D9_3 StartBit:18 Default:0. D9_5 StartBit:19
        ///                Default:0. D9_5X StartBit:20 Default:0. D9_7 StartBit:21 Default:0. D9_9 StartBit:22 Default:0. D9_9X
        ///                StartBit:23 Default:0.
        /// Type:          uint
        /// Default Value: 9654078
        /// Range:         [0, 16777215]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  filter_manual_derivatives_flags;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcind_isotropic_min_size
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   0 - normal mode, each distance depends on distences shorter than him and himself. ( == Isotropic mode 1x1
        ///                (minimum dc indication size) ). 1 - Isotropic mode 3x3 (minimum dc indication size). 2 - Isotropic mode
        ///                5x5 (minimum dc indication size). 3 - Isotropic mode 7x7 (minimum dc indication size). 4 - Isotropic mode
        ///                9x9 (minimum dc indication size).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 4]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  dcind_isotropic_min_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcind_manual_derivatives_flags
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Condition flags for calculating the luma dc indications. Di_j == 0 means that dc indication of length i
        ///                is controlled by detection of length j. (0-consider, 1-ignore). D3_3 StartBit:0 Default:0. D3_5
        ///                StartBit:1 Default:1. D3_5X StartBit:2 Default:1. D3_7 StartBit:3 Default:1. D3_9 StartBit:4 Default:1.
        ///                D3_9X StartBit:5 Default:1. D5_3 StartBit:6 Default:0. D5_5 StartBit:7 Default:0. D5_5X StartBit:8
        ///                Default:0. D5_7 StartBit:9 Default:1. D5_9 StartBit:10 Default:1. D5_9X StartBit:11 Default:1. D7_3
        ///                StartBit:12 Default:0. D7_5 StartBit:13 Default:0. D7_5X StartBit:14 Default:0. D7_7 StartBit:15
        ///                Default:0. D7_9 StartBit:16 Default:1. D7_9X StartBit:17 Default:1. D9_3 StartBit:18 Default:0. D9_5
        ///                StartBit:19 Default:0. D9_5X StartBit:20 Default:0. D9_7 StartBit:21 Default:0. D9_9 StartBit:22
        ///                Default:0. D9_9X StartBit:23 Default:0.
        /// Type:          uint
        /// Default Value: 9654078
        /// Range:         [0, 16777215]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  dcind_manual_derivatives_flags;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// second_derivative_max_influence_radius_filtering
        ///
        /// Tuning Level:  never_tune
        /// Description:   Controls the influence radius of the 2'nd derivative on the filtering (consider der2 evaluation upto this
        ///                radius). Demux to registers: FULL_IPU_CYLPF_YFilter_Der2FlagsDCInd_D3_*.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [0, 4]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  second_derivative_max_influence_radius_filtering;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// second_derivative_max_influence_radius_dc_indication
        ///
        /// Tuning Level:  never_tune
        /// Description:   Controls the influence radius of the 2'nd derivative on the DC Indications (consider der2 evaluation upto
        ///                this radius). Demux to registers: FULL_IPU_CYLPF_YFilter_Der2FlagsFilt_D3_3*.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 4]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  second_derivative_max_influence_radius_dc_indication;

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

        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_configStruct luma_filter_config;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chroma_filter_config
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct chroma_filter_configStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// filter_isotropic_min_filter_size
        ///
        /// Tuning Level:  often_tune
        /// Description:   0 - normal mode, each distance depends on distences shorter than him and himself. ( == Isotropic mode 1x1
        ///                (minimum filter size) ). 1 - Isotropic mode 3x3 (minimum filter size). 2 - Isotropic mode 5x5 (minimum
        ///                filter size). 3 - Isotropic mode 7x7 (minimum filter size).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  filter_isotropic_min_filter_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// filter_manual_derivatives_flags
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Condition flags for calculating the chroma filtering. Di_j == 0 means that filtering of length i is
        ///                controlled by detection of length j. (0-consider, 1-ignore). D3_3 StartBit:0 Default:0. D3_5 StartBit:1
        ///                Default:1. D3_5X StartBit:2 Default:1. D3_7 StartBit:3 Default:1. D5_3 StartBit:6 Default:0. D5_5
        ///                StartBit:7 Default:0. D5_5X StartBit:8 Default:1. D5_7 StartBit:9 Default:1. D7_3 StartBit:12 Default:0.
        ///                D7_5 StartBit:13 Default:0. D7_5X StartBit:14 Default:1. D7_7 StartBit:15 Default:0.
        /// Type:          uint
        /// Default Value: 20286
        /// Range:         [0, 65535]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  filter_manual_derivatives_flags;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcind_isotropic_min_size
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   0 - normal mode, each distance depends on distences shorter than him and himself. ( == Isotropic mode 1x1
        ///                (minimum dc indication size) ). 1 - Isotropic mode 3x3 (minimum dc indication size). 2 - Isotropic mode
        ///                5x5 (minimum dc indication size). 3 - Isotropic mode 7x7 (minimum dc indication size). 4 - Isotropic mode
        ///                9x9 (minimum dc indication size). 5 - Isotropic mode 11x11 (minimum dc indication size).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  dcind_isotropic_min_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dcind_manual_derivatives_flags
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Condition flags for calculating the chroma dc indications. Di_j == 0 means that dc indication of length i
        ///                is controlled by detection of length j. (0-consider, 1-ignore). D3_3 StartBit:0 Default:0. D3_5
        ///                StartBit:1 Default:1. D3_5X StartBit:2 Default:1. D3_7 StartBit:3 Default:1. D5_3 StartBit:6 Default:0.
        ///                D5_5 StartBit:7 Default:0. D5_5X StartBit:8 Default:1. D5_7 StartBit:9 Default:1. D7_3 StartBit:12
        ///                Default:0. D7_5 StartBit:13 Default:0. D7_5X StartBit:14 Default:1. D7_7 StartBit:15 Default:0.
        /// Type:          uint
        /// Default Value: 20286
        /// Range:         [0, 65535]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  dcind_manual_derivatives_flags;

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

        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_configStruct chroma_filter_config;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  manual_flat_kernel_9x9_complement_shift;

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

        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;

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

        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;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luma_peak_management
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct luma_peak_managementStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_hard_decision_environment_activity
        ///
        /// Tuning Level:  often_tune
        /// Description:   The maximum environment activity of the pixel (the difference between the maximum and minimum Y component
        ///                values in the pixel neighborhood, . excluding the candidate pixel) is less than LUMA_DCTHRSH. Decreasing
        ///                this parameter results in fewer peak identifications. 0 = Condition is disabled.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_hard_decision_environment_activity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_hard_decision_distance_from_average
        ///
        /// Tuning Level:  often_tune
        /// Description:   The difference between the Y component of the candidate pixel and the average Y component value of its .
        ///                neighboring pixels (excluding candidate pixel) is at least LUMA_DCLEVEL. . Increasing this parameter
        ///                results in fewer peak identifications. 255 = Condition is disabled.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_hard_decision_distance_from_average;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_soft_decision_distance_from_average_lower_limit
        ///
        /// Tuning Level:  often_tune
        /// Description:   soft decision function for distance_from_avg vs activity. . distance_from_avg (for peak) is greater than
        ///                or equal to min ( max ( ( (slope * activity ) + offset , lower_limit ) , 255);.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_soft_decision_distance_from_average_lower_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_soft_decision_distance_from_average_offset
        ///
        /// Tuning Level:  often_tune
        /// Description:   soft decision function for distance_from_avg vs activity. . distance_from_avg (for peak) is greater than
        ///                or equal to min ( max ( ( (slope * activity ) + offset , lower_limit ) , 255);. 255 is disabled.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_soft_decision_distance_from_average_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_soft_decision_distance_from_average_slope
        ///
        /// Tuning Level:  often_tune
        /// Description:   soft decision function for distance_from_avg vs activity. . distance_from_avg (for peak) is greater than
        ///                or equal to min ( max ( ( (slope * activity ) + offset , lower_limit ) , 255);.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1023]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_soft_decision_distance_from_average_slope;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_extreme_decision_distance_from_maxmin
        ///
        /// Tuning Level:  often_tune
        /// Description:   The maximum difference between the Y component of the candidate pixel and the Y component of its
        ///                neighboring pixels is at least detect_extreme_decision_distance_from_maxmin. . Increasing this parameter
        ///                results in fewer peak identifications. Max( pixel_val - env_max, env_min-pixel_val ). 255 = Condition is
        ///                disabled.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_extreme_decision_distance_from_maxmin;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_dcsize_decision_sensitivity
        ///
        /// Tuning Level:  often_tune
        /// Description:   Rank peak identification flags a peak when a sufficient number of neighbors around a . pixel are
        ///                identified as flat (regardless of whether the current pixel is flat or not). The following parameters
        ///                control the minimum number of flat neighbors for identifying a peak in each length. 128 is all
        ///                neighbores. 129 is disable.
        /// Type:          uint
        /// Default Value: 129
        /// Range:         [0, 129]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_dcsize_decision_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// correction_mode
        ///
        /// Tuning Level:  often_tune
        /// Description:   0 - Correct using area smart selection. (closest pixel value in the 3x3 environment). 1 - Correct using
        ///                flattest direction. area smart is recommended. This parameter should be modified only in FULL pass. DC4,
        ///                DC16,DC64 Passes should always use area smart selection.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  correction_mode;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// correction_area_smart_min_inner_distance
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Area smart selection can be made more robust to larger peaks by increasing correction_nl_mode_thr. This
        ///                value will result taking a pixel value closer to the median of 3x3. 0 - take the closest pixel value. 3-
        ///                take the median.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  correction_area_smart_min_inner_distance;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// correction_isotropic_activity_threshold
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Non edge-preserving is enabled based on following thresholds. Peaks with environment activity below these
        ///                thresholds are corrected using non edge-preserving filtering. Peaks with environment activity above these
        ///                thresholds are corrected using edge preserving filtering. (either area smart or flattest direction based
        ///                on user settings of correction_mode ).
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  correction_isotropic_activity_threshold;

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

        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_peak_managementStruct luma_peak_management;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chroma_peak_management
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct chroma_peak_managementStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_hard_decision_environment_activity
        ///
        /// Tuning Level:  often_tune
        /// Description:   The maximum environment activity of the pixel (the difference between the maximum and minimum UV
        ///                component values in the pixel neighborhood, . excluding the candidate pixel) is less than DCTHRSH.
        ///                Decreasing this parameter results in fewer peak identifications. 0 = Condition is disabled.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_hard_decision_environment_activity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_hard_decision_distance_from_average
        ///
        /// Tuning Level:  often_tune
        /// Description:   The difference between the Y component of the candidate pixel and the average UV component value of its .
        ///                neighboring pixels (excluding candidate pixel) is at least DCLEVEL. . Increasing this parameter results
        ///                in fewer peak identifications. 255 = Condition is disabled.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_hard_decision_distance_from_average;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_soft_decision_distance_from_average_lower_limit
        ///
        /// Tuning Level:  often_tune
        /// Description:   soft decision function for distance_from_avg vs activity. . distance_from_avg (for peak) is greater than
        ///                or equal to min ( max ( ( (slope * activity ) + offset , lower_limit ) , 255);.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_soft_decision_distance_from_average_lower_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_soft_decision_distance_from_average_offset
        ///
        /// Tuning Level:  often_tune
        /// Description:   soft decision function for distance_from_avg vs activity. . distance_from_avg (for peak) is greater than
        ///                or equal to min ( max ( ( (slope * activity ) + offset , lower_limit ) , 255);.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_soft_decision_distance_from_average_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_soft_decision_distance_from_average_slope
        ///
        /// Tuning Level:  often_tune
        /// Description:   soft decision function for distance_from_avg vs activity. . distance_from_avg (for peak) is greater than
        ///                or equal to min ( max ( ( (slope * activity ) + offset , lower_limit ) , 255);.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1023]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_soft_decision_distance_from_average_slope;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_extreme_decision_distance_from_maxmin
        ///
        /// Tuning Level:  often_tune
        /// Description:   The maximum difference between the Y component of the candidate pixel and the Y component of its
        ///                neighboring pixels is at least detect_extreme_decision_distance_from_maxmin. . Increasing this parameter
        ///                results in fewer peak identifications. Max( pixel_val - env_max, env_min-pixel_val ). 255 = Condition is
        ///                disabled.
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_extreme_decision_distance_from_maxmin;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_dcsize_decision_sensitivity
        ///
        /// Tuning Level:  often_tune
        /// Description:   Rank peak identification flags a peak when a sufficient number of neighbors around a . pixel are
        ///                identified as flat (regardless of whether the current pixel is flat or not). The following parameters
        ///                control the minimum number of flat neighbors for identifying a peak in each length. 128 is all
        ///                neighbores. 129 is disable.
        /// Type:          uint
        /// Default Value: 129
        /// Range:         [0, 129]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_dcsize_decision_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// correction_mode
        ///
        /// Tuning Level:  often_tune
        /// Description:   0 - Correct using area smart selection. (closest pixel value in the 3x3 environment). 1 - Correct using
        ///                flattest direction. area smart is recommended. This parameter should be modified only in FULL pass. DC4,
        ///                DC16,DC64 Passes should always use area smart selection.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  correction_mode;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// correction_area_smart_min_inner_distance
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Area smart selection can be made more robust to larger peaks by increasing correction_nl_mode_thr. This
        ///                value will result taking a pixel value closer to the median of 3x3. 0 - take the closest pixel value. 3-
        ///                take the median.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  correction_area_smart_min_inner_distance;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// correction_isotropic_activity_threshold
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   Non edge-preserving is enabled based on following thresholds. Peaks with environment activity below these
        ///                thresholds are corrected using non edge-preserving filtering. Peaks with environment activity above these
        ///                thresholds are corrected using edge preserving filtering. (either area smart or flattest direction based
        ///                on user settings of correction_mode ).
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [0, 255]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  correction_isotropic_activity_threshold;

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

        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_peak_managementStruct chroma_peak_management;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_input_indication_thr_modification_scale;

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

        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:  never_tune
        /// Description:   in case center pixel is flatter than center_binarization_minflatval it will indicate the pixel as flat
        ///                without any regard to neighbores. If not, the decision will be done according to neighbores decision.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [1, 5]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_center_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  never_tune
        /// Description:   neighbors are counted as flat if they are flatter than neighbours_binarization_minflatval.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [1, 4]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_neighbours_parallel_dist
        ///
        /// Tuning Level:  never_tune
        /// Description:   perpendicular neighbourhood size can be 3 or 4. 1- size =3 . 2- size =5.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [1, 2]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_neighbours_parallel_dist;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_neighbours_perpendicular_dist
        ///
        /// Tuning Level:  never_tune
        /// Description:   perpendicular neighbourhood size can be 1 or 3. 0- size =1 . 1- size =3.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [0, 1]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_neighbours_perpendicular_dist;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  never_tune
        /// Description:   if percentage of neighbores are determind 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_neighbours_agreement_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_center_binarization_minflatval
        ///
        /// Tuning Level:  never_tune
        /// Description:   in case center pixel is flatter than center_binarization_minflatval it will indicate the pixel as flat
        ///                without any regard to neighbores. If not, the decision will be done according to neighbores decision.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [1, 6]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_center_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  never_tune
        /// Description:   neighbors are counted as flat if they are flatter than neighbours_binarization_minflatval.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [1, 5]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_neighbours_perpendicular_dist
        ///
        /// Tuning Level:  never_tune
        /// Description:   perpendicular neighbourhood size can be 1 or 3. 0- size =1 . 1- size =3.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [0, 1]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_neighbours_perpendicular_dist;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  never_tune
        /// Description:   if percentage of neighbores are determind 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_neighbours_agreement_sensitivity;

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

        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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  enable_grey_treatment_dcblend2_chroma_modification;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_grey_condition_chromaticity_radius
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   chromaticity is estimated using : 0 - 3x3 circle, 1- 5x5 circle.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [0, 1]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_grey_condition_chromaticity_radius;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_grey_condition_chromaticity_thr_high;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_grey_condition_y_max_derivative_radius
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   y max derivative is calculated using : 0- 3x3 , 1- 5x5.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [0, 1]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_grey_condition_y_max_derivative_radius;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_greydcsize_neighbors_chromaticity_thr;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detect_greydcsize_center_detail_chromaticity_thr
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   if pixel has a higher chromaticity than this threshold it will be defined a chromatc detail and will set
        ///                greydcsize to zero.
        /// Type:          uint
        /// Default Value: 30
        /// Range:         [0, 182]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  detect_greydcsize_center_detail_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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  thr_modification_target_v;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// isotropic_filter_blend_factor_scale
        ///
        /// Tuning Level:  must_tune
        /// Description:   controls how much blend will be done with the isotropic chroma filtering upto 7x7, depends on GreyDCSize
        ///                and Isotropic_Filter_Size. blend (with isotropic filtering 7x7) factor fucntion scale as a function of
        ///                grey edge detection. Function values are 0:64 and as a function of grey edge detection which is also
        ///                0:64. scale values are Q4, 7Q4, example 16 == X1 slope. to disable blend with isotropic filter :
        ///                isotropic_filter_blend_factor_scale == isotropic_filter_blend_factor_offset == 0 .
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  isotropic_filter_blend_factor_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// isotropic_filter_blend_factor_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   controls how much blend will be done with the isotropic chroma filtering upto 7x7, depends on GreyDCSize
        ///                and Isotropic_Filter_Size. blend (with isotropic filtering 7x7) factor fucntion scale as a function of
        ///                grey edge detection. Function values are 0:64 and as a function of grey edge detection which is also
        ///                0:64. to disable blend with isotropic filter : isotropic_filter_blend_factor_scale ==
        ///                isotropic_filter_blend_factor_offset == 0 .
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-64, 63]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  isotropic_filter_blend_factor_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// isotropic_filter_size
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   0- isotropic filter is 3x3. 1- isotropic filter is 5x5. 2- isotropic filter is adaptive (1x1/3x3/5x5/7x7)
        ///                depends on GreyDCSize (0/1/2/3). 3- isotropic filter is 7x7.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [0, 3]
        /// Notes:         Nearest neighbor interpolation: discrete values allowed.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  isotropic_filter_size;

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

        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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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 modifers (scale and
        ///                offset). Q4 example 16 == X1. 65 to disable median filter.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 65]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  median_detect_corner_detail_sensitivity_y;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// median_detect_corner_detail_sensitivity_uv
        ///
        /// Tuning Level:  must_tune
        /// Description:   median_detect_corner_detail_sensitivity_uv
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 64]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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 sensativity to get sensativity for bigger environment .
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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 sensativity to get sensativity for bigger environment .
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. 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
        ///                controled by Bilateral_Decision_MinimalSize. If ( chromaOutputDCindications_CDCMinSize is greater than or
        ///                equal to Bilateral_Decision_MinimalSize) then take bilateral output, otherwise thake 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;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// bilateral_filtersize
        ///
        /// Tuning Level:  rarely_tune
        /// Description:   0- bilateral size 1x1 (disabled). 1- bilateral size 3x3. 2- bilateral size 5x5.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [0, 2]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  bilateral_filtersize;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_flat_indication_extension_threshold_9x9
        ///
        /// Tuning Level:  never_tune
        /// Description:   extension of the flatness indication from 0:3 (1x1 : 7x7) to 0:5 (1x1 : 11x11).
        /// Type:          uint
        /// Default Value: 6
        /// Range:         [0, 15]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_flat_indication_extension_threshold_9x9;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_flat_indication_extension_threshold_11x11
        ///
        /// Tuning Level:  never_tune
        /// Description:   chroma_flat_indication_extension_threshold_11x11
        /// Type:          uint
        /// Default Value: 6
        /// Range:         [0, 15]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_flat_indication_extension_threshold_11x11;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_grey_indication_extension_threshold_9x9
        ///
        /// Tuning Level:  never_tune
        /// Description:   chroma_grey_indication_extension_threshold_9x9
        /// Type:          uint
        /// Default Value: 21
        /// Range:         [0, 31]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_grey_indication_extension_threshold_9x9;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_grey_indication_extension_threshold_11x11
        ///
        /// Tuning Level:  never_tune
        /// Description:   chroma_grey_indication_extension_threshold_11x11
        /// Type:          uint
        /// Default Value: 42
        /// Range:         [0, 63]
        /// Notes:         Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_grey_indication_extension_threshold_11x11;

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

        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;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luma_smoothing_treatment
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct luma_smoothing_treatmentStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// edge_smoothing_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   min flat val in parallel to the edge in order to smooth it. Flat enough means a large edge and could be
        ///                smoothed. 5 - to bypasse.
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [0, 5]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  edge_smoothing_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// edge_smoothing_binarization_maxedgeval
        ///
        /// Tuning Level:  must_tune
        /// Description:   max edge val in perpendicular to the edge in order to smooth the edge. Edge small enough means a strong
        ///                edge that could be smoothed.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [0, 4]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  edge_smoothing_binarization_maxedgeval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// edge_smoothing_agreement_number
        ///
        /// Tuning Level:  must_tune
        /// Description:   how many neighbores out of 5 should fulfill the parrallel minflatval condition and the perpendicular
        ///                maxedgeval condition. This affects also how many neighbores out of 3 should fulfill the conditions.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [2, 5]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  edge_smoothing_agreement_number;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_smoothing_filter_size
        ///
        /// Tuning Level:  often_tune
        /// Description:   1- 3x3 , 2-5x5.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [1, 2]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_smoothing_filter_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  often_tune
        /// Description:   binarization_minflatval, lower value means more areas will be defined as flat which in turn can give
        ///                filtering in more areas. range [1,4].
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [1, 4]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_binarization_minedgeval
        ///
        /// Tuning Level:  often_tune
        /// Description:   binarization_minedgeval, lower value means more areas will be defined as edge which in turn can give
        ///                filtering in more areas. range [0,3].
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 3]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_binarization_minedgeval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_binarization_maxedgeval
        ///
        /// Tuning Level:  often_tune
        /// Description:   binarization_maxedgeval, higher value means more areas will be defined as edge which in turn can give
        ///                filtering in more areas. range [0,3].
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [0, 3]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_binarization_maxedgeval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  often_tune
        /// Description:   agreement_sensitivity percentage (out of 128) will set the effective neighbours percetage needs to pass
        ///                all condtions. 86/128 value is 6/9 or 16/25 depends on transition_smoothing_filter_size. 129 to disable
        ///                feature.
        /// Type:          uint
        /// Default Value: 86
        /// Range:         [86, 129]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_agreement_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_agreement_flat_vs_voters
        ///
        /// Tuning Level:  often_tune
        /// Description:   percentage (out of 128) of flats voters out of all voters, rest of needed voters should be edges. total
        ///                number of needed voters is determind by transition_isotropic_neighbours_agreement_sensitivity.
        /// Type:          uint
        /// Default Value: 92
        /// Range:         [0, 128]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_agreement_flat_vs_voters;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// flat_isotropic_3x3_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   mininum flat value to define flat for 3x3 additional isotropic filtering feature.
        /// Type:          uint
        /// Default Value: 4
        /// Range:         [1, 4]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  flat_isotropic_3x3_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// flat_isotropic_3x3_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   agreement_sensitivity of the neighbours, size is 3x3 / 5x5 according to transition_smoothing_filter_size.
        ///                Sensativity 128 requires 100% of neighbours to be flat according to upper threshold. Sensativity 129 is
        ///                disable feature.
        /// Type:          uint
        /// Default Value: 129
        /// Range:         [0, 129]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  flat_isotropic_3x3_neighbours_agreement_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// flat_isotropic_5x5_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   agreement_sensitivity of the neighbours 5x5 according only if transition_smoothing_filter_size ==2,
        ///                otherwise not operational.. Sensativity 128 requires 100% of neighbours to be flat according to upper
        ///                threshold. Sensativity 129 is disable feature. binarization_minflatval is always 4 for this condition.
        /// Type:          uint
        /// Default Value: 129
        /// Range:         [0, 129]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  flat_isotropic_5x5_neighbours_agreement_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// smoothing_kernel_3x3_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   3x3 (including center) coefficients weight = 2^kernel_3x3_shift.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  smoothing_kernel_3x3_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// smoothing_kernel_5x5_horver_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   5x5 horizontal, vertical and off-diagonals only coefficients weight = 2^kernel_5x5_horver_shift. 5x5 main
        ///                diagonals are weight = 1.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  smoothing_kernel_5x5_horver_shift;

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

        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_smoothing_treatmentStruct luma_smoothing_treatment;

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// edge_smoothing_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   min flat val in parallel to the edge in order to smooth it. Flat enough means a large edge and could be
        ///                smoothed. 6 - to bypasse.
        /// Type:          uint
        /// Default Value: 3
        /// Range:         [0, 6]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  edge_smoothing_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// edge_smoothing_binarization_maxedgeval
        ///
        /// Tuning Level:  must_tune
        /// Description:   max edge val in perpendicular to the edge in order to smooth the edge. Edge small enough means a strong
        ///                edge that could be smoothed.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [0, 5]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  edge_smoothing_binarization_maxedgeval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// edge_smoothing_agreement_number
        ///
        /// Tuning Level:  must_tune
        /// Description:   how many neighbores out of 3 should fulfill the parrallel minflatval condition and the perpendicular
        ///                maxedgeval condition.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [2, 3]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  edge_smoothing_agreement_number;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  often_tune
        /// Description:   binarization_minflatval, lower value means more areas will be defined as flat which in turn can give
        ///                filtering in more areas.
        /// Type:          uint
        /// Default Value: 2
        /// Range:         [1, 4]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_binarization_minedgeval
        ///
        /// Tuning Level:  often_tune
        /// Description:   binarization_minedgeval, lower value means more areas will be defined as edge which in turn can give
        ///                filtering in more areas.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 4]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_binarization_minedgeval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_binarization_maxedgeval
        ///
        /// Tuning Level:  often_tune
        /// Description:   binarization_maxedgeval, higher value means more areas will be defined as edge which in turn can give
        ///                filtering in more areas.
        /// Type:          uint
        /// Default Value: 1
        /// Range:         [0, 4]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_binarization_maxedgeval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  often_tune
        /// Description:   agreement_sensitivity percentage (out of 128) will set the effective neighbours percetage needs to pass
        ///                all condtions. 86/128 value is 6/9 or 16/25 depends on transition_smoothing_filter_size. 129 to disable
        ///                feature.
        /// Type:          uint
        /// Default Value: 86
        /// Range:         [86, 129]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_agreement_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_isotropic_neighbours_agreement_flat_vs_voters
        ///
        /// Tuning Level:  often_tune
        /// Description:   percentage (out of 128) of flats voters out of all voters, rest of needed voters should be edges. total
        ///                number of needed voters is determind by transition_isotropic_neighbours_agreement_sensitivity.
        /// Type:          uint
        /// Default Value: 92
        /// Range:         [0, 128]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  transition_isotropic_neighbours_agreement_flat_vs_voters;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// flat_isotropic_3x3_neighbours_binarization_minflatval
        ///
        /// Tuning Level:  must_tune
        /// Description:   mininum flat value to define flat for 3x3 additional isotropic filtering feature.
        /// Type:          uint
        /// Default Value: 5
        /// Range:         [1, 5]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  flat_isotropic_3x3_neighbours_binarization_minflatval;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// flat_isotropic_3x3_neighbours_agreement_sensitivity
        ///
        /// Tuning Level:  must_tune
        /// Description:   agreement_sensitivity of the neighbours, size is 3x3. Sensativity 128 requires 100% of neighbours to be
        ///                flat according to upper threshold.. Sensativity 129 is disable feature.
        /// Type:          uint
        /// Default Value: 102
        /// Range:         [0, 129]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  flat_isotropic_3x3_neighbours_agreement_sensitivity;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// smoothing_kernel_1x1_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   center coefficient weight = 2^kernel_1x1_shift.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  smoothing_kernel_1x1_shift;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// smoothing_kernel_3x3_shift
        ///
        /// Tuning Level:  often_tune
        /// Description:   3x3 (not including center) coefficients weight = 2^kernel_3x3_shift.
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 2]
        /// Notes:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear Ceil Interpolation: Do Linear Interpolation and then Ceil.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  smoothing_kernel_3x3_shift;

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

        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 detemind by B = (2^16 - A). That way
        ///                we keep A,B normilized for a valid linear interpulation.
        /// Type:          uint
        /// Default Value: 32768
        /// Range:         [6553, 58982]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  elliptic_a;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_lut_thr_y_tab
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma filter Y threshold modifier LUT. Modifier threshold as a function of radius^2 and elipses. 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
        {
            float  luma_filter_lut_thr_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma filter uv threshold modifier LUT. Modifier threshold as a function of radius^2 and elipses. 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
        {
            float  luma_filter_lut_thr_uv[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma filter Y threshold modifier LUT. Modifier threshold as a function of radius^2 and elipses. 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
        {
            float  chroma_filter_lut_thr_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma filter uv threshold modifier LUT. Modifier threshold as a function of radius^2 and elipses. 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
        {
            float  chroma_filter_lut_thr_uv[17];

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

            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
        ///
        /// Tuning Level:  often_tune
        /// 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 torwards .
        /// Type:          uint
        /// Range:         [0, 128]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct strength_modifier_radius_blend_lut_tabStruct
        {
            float  strength_modifier_radius_blend_lut[17];

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

            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;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_lnr_dcblend2_target_factor
        ///
        /// Tuning Level:  often_tune
        /// Description:   LNR Luma blend factor (128 is factor 1).
        /// Type:          uint
        /// Default Value: 128
        /// Range:         [128, 2048]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_lnr_dcblend2_target_factor;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_lnr_flat_kernel_weight_target_factor
        ///
        /// Tuning Level:  often_tune
        /// Description:   LNR Luma flat blend factor (128 is factor 1). Factor on the weight of the flat kernel for lnr in its
        ///                maximal target strenght (lut blend ==0).
        /// Type:          uint
        /// Default Value: 128
        /// Range:         [128, 2048]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  luma_lnr_flat_kernel_weight_target_factor;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_lnr_cnr_dcblend2_target_factor
        ///
        /// Tuning Level:  often_tune
        /// Description:   LNR CNR Chroma blend factor (128 is factor 1) (max factor). This target factor also serves as the maximal
        ///                scale factor that lnr and cnr can apply together.
        /// Type:          uint
        /// Default Value: 128
        /// Range:         [128, 2048]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  chroma_lnr_cnr_dcblend2_target_factor;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// automatic_influence_luma_luts
        ///
        /// Tuning Level:  often_tune
        /// Description:   if use_luts_from_full_pass_configuration == 1 then. luma_filter_luts = ( full_pass_luma_filter_luts *
        ///                automatic_influence_luma_luts + (128-automatic_influence_luma_luts ) * [128,128,...,128] ) is greater
        ///                thanis greater than 7.
        /// Type:          uint
        /// Default Value: 128
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  automatic_influence_luma_luts;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// automatic_influence_chroma_luts
        ///
        /// Tuning Level:  often_tune
        /// Description:   if use_luts_from_full_pass_configuration == 1 then. chroma_filter_luts = ( full_pass_chroma_filter_luts *
        ///                automatic_influence_chroma_luts + (128-automatic_influence_chroma_luts ) * [128,128,...,128] ) is greater
        ///                thanis greater than 7.
        /// Type:          uint
        /// Default Value: 128
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  automatic_influence_chroma_luts;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// automatic_influence_modifier_radius_blend_lut
        ///
        /// Tuning Level:  often_tune
        /// Description:   if use_luts_from_full_pass_configuration == 1 then. strength_modifier_radius_blend_lut = (
        ///                full_pass_strength_modifier_radius_blend_lut * automatic_influence_chroma_luts +
        ///                (128-automatic_influence_chroma_luts ) * [128,128,...,128] ) is greater thanis greater than 7.
        /// Type:          uint
        /// Default Value: 128
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  automatic_influence_modifier_radius_blend_lut;

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

        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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Angle(U,V) (hue) low limit.
        /// Type:          uint
        /// Range:         [0, 1440]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_angle_start_tabStruct
        {
            float  detect_angle_start[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Angle(U,V) (hue) high limit.
        /// Type:          uint
        /// Range:         [0, 1440]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_angle_end_tabStruct
        {
            float  detect_angle_end[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// 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
        {
            float  detect_chromaticity_start[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// 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
        {
            float  detect_chromaticity_end[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Y component low limit.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_luma_start_tabStruct
        {
            float  detect_luma_start[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Y component high limit.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct detect_luma_end_tabStruct
        {
            float  detect_luma_end[5];

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

            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:   Minumum 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:   Minumum 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
        ///
        /// Tuning Level:  often_tune
        /// Description:   Weight value at Color Range Borders.
        /// Type:          uint
        /// Range:         [1, 15]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct boundary_weight_tabStruct
        {
            float  boundary_weight[5];

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

            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;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// transition_ratio_tab
        ///
        /// Tuning Level:  often_tune
        /// Description:   smooth range transition ratio (with regards to color range) of each color region.
        /// Type:          uint
        /// Range:         [0, 128]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct transition_ratio_tabStruct
        {
            float  transition_ratio[5];

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

            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 transition_ratio_tabStruct transition_ratio_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// color0_transition_ratio_external
        ///
        /// Tuning Level:  often_tune
        /// Description:   smooth range transition ratio (with regards to color 0 range) of each external color regions. q_ext =
        ///                transition_ratio_external / boundery_probability[0].
        /// Type:          uint
        /// Default Value: 13
        /// Range:         [0, 128]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  color0_transition_ratio_external;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_threshold_scale_y_tab
        ///
        /// Tuning Level:  must_tune
        /// Description:   Gain factor YLPF Y-Base Threshold.
        /// Type:          uint
        /// Range:         [0, 2047]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_threshold_scale_y_tabStruct
        {
            float  luma_filter_threshold_scale_y[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// 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
        {
            float  luma_filter_threshold_scale_uv[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Offset for YLPF Y-Base Threshold .
        /// Type:          int
        /// Range:         [-1024, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_offset_y_tabStruct
        {
            float  luma_filter_offset_y[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Offset for YLPF U-Base Threshold .
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_offset_u_tabStruct
        {
            float  luma_filter_offset_u[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Offset for YLPF V-Base Threshold.
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_filter_offset_v_tabStruct
        {
            float  luma_filter_offset_v[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// 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
        {
            float  chroma_filter_threshold_scale_y[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// 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
        {
            float  chroma_filter_threshold_scale_uv[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Offset for CLPF Y-Base Threshold.
        /// Type:          int
        /// Range:         [-1024, 1023]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_offset_y_tabStruct
        {
            float  chroma_filter_offset_y[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Offset for CLPF U-Base Threshold.
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_offset_u_tabStruct
        {
            float  chroma_filter_offset_u[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Offset for CLPF V-Base Threshold.
        /// Type:          int
        /// Range:         [-256, 255]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_filter_offset_v_tabStruct
        {
            float  chroma_filter_offset_v[5];

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

            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;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_base_far_modifier_y
        ///
        /// Tuning Level:  often_tune
        /// Description:   YLPF 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  luma_filter_base_far_modifier_y;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_filter_base_far_modifier_uv
        ///
        /// Tuning Level:  often_tune
        /// Description:   YLPF 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  luma_filter_base_far_modifier_uv;

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_dcblend2_weight_scale_tab
        ///
        /// Tuning Level:  often_tune
        /// Description:   Scale Factor for user defined DCBlend2 Y_Dc blend factor. (2048 == X16).
        /// Type:          uint
        /// Range:         [0, 2048]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_dcblend2_weight_scale_tabStruct
        {
            float  luma_dcblend2_weight_scale[5];

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

            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_dcblend2_weight_scale_tabStruct luma_dcblend2_weight_scale_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// chroma_dcblend2_weight_restricted_scale_tab
        ///
        /// Tuning Level:  often_tune
        /// Description:   Scale Factor for user defined DCBlend2 C_Dc blend factor. (2048 == X16). this scale is limited by
        ///                chroma_lnr_cnr_dcblend2_target_factor with the following: . chroma_dcblend2_weight_scale (actual cnr
        ///                scale influence of dcblend 2 blend factor ) = MIN( MAX(chroma_dcblend2_weight_restricted_scale , 2*128 -
        ///                chroma_lnr_cnr_dcblend2_target_factor ) , chroma_lnr_cnr_dcblend2_target_factor ).
        /// Type:          uint
        /// Range:         [0, 2048]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct chroma_dcblend2_weight_restricted_scale_tabStruct
        {
            float  chroma_dcblend2_weight_restricted_scale[5];

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

            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_dcblend2_weight_restricted_scale_tabStruct chroma_dcblend2_weight_restricted_scale_tab;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// luma_flat_kernel_blend_weight_scale_tab
        ///
        /// Tuning Level:  often_tune
        /// Description:   Scale Factor for user defined flat kernel blend factor. (2048 == X16).
        /// Type:          uint
        /// Range:         [0, 2048]
        /// Length:        5
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct luma_flat_kernel_blend_weight_scale_tabStruct
        {
            float  luma_flat_kernel_blend_weight_scale[5];

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

            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_flat_kernel_blend_weight_scale_tabStruct luma_flat_kernel_blend_weight_scale_tab;

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

        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
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _Y threshold LutY.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct y_threshold_per_y_tabStruct
        {
            float  y_threshold_per_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the lut
        ///                interpulation 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
        {
            float  y_threshold_per_uv[8];

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

            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_top_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _Y threshold Top Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 1023
        /// Range:         [0, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_top_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_bottom_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _Y threshold Bottom, Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_bottom_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 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_der2_close3_mod_scale
        ///
        /// Tuning Level:  often_tune
        /// Description:   Luma filter, 3x3 luma second order derivative scale, 6 bits unsigned (0,2,4).
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_der2_close3_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_der2_close3_mod_offset
        ///
        /// Tuning Level:  often_tune
        /// Description:   Luma filter, 3x3 luma second order derivative offset 11 bits signed (1,10,0).
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-1024, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_der2_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;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_close_external_mod_scale
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 3x3/5x5 _Ythr modifier CloseX (X==External) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_close_external_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_close_external_mod_offset
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 3x3/5x5 _Ythr modifier CloseX (X==External) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-1024, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_close_external_mod_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_far_external_mod_scale
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 7x7/9x9 _Ythr modifier FarX (X==External) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_far_external_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_far_external_mod_offset
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 7x7/9x9 _Ythr modifier FarX (X==External) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-1024, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_far_external_mod_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_per_y_tab
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _U threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct u_threshold_per_y_tabStruct
        {
            float  u_threshold_per_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the lut
        ///                interpulation 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
        {
            float  u_threshold_per_uv[8];

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

            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_top_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _U threshold Top Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_top_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_bottom_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _U threshold Bottom, Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_bottom_limit;

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

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_far_external_mod_scale
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 7x7/9x9 _Uthr modifier FarX (X==External) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_far_external_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_far_external_mod_offset
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 7x7/9x9 _Uthr modifier FarX (X==External) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-256, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_far_external_mod_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_per_y_tab
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _V threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct v_threshold_per_y_tabStruct
        {
            float  v_threshold_per_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the lut
        ///                interpulation 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
        {
            float  v_threshold_per_uv[8];

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

            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_top_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _V threshold Top Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_top_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_bottom_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   luma_filter, _V threshold Bottom, Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_bottom_limit;

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_far_external_mod_scale
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 7x7/9x9 _Vthr modifier FarX (X==External) scale/offset factors.
        /// Type:          uint
        /// Default Value: 16
        /// Range:         [0, 63]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_far_external_mod_scale;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_far_external_mod_offset
        ///
        /// Tuning Level:  never_tune
        /// Description:   luma_filter, 7x7/9x9 _Vthr modifier FarX (X==External) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-256, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_far_external_mod_offset;

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

        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
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _Y threshold LutY.
        /// Type:          uint
        /// Range:         [0, 1023]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct y_threshold_per_y_tabStruct
        {
            float  y_threshold_per_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the lut
        ///                interpulation 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
        {
            float  y_threshold_per_uv[8];

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

            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_top_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _Y threshold Top Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 1023
        /// Range:         [0, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_top_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_bottom_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _Y threshold Bottom, Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 1023]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  y_threshold_bottom_limit;

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// y_threshold_far_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 5x5 _Ythr modifier Far(5 chroma blocks but 7x7/9x9 for y pixels) 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
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _U threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct u_threshold_per_y_tabStruct
        {
            float  u_threshold_per_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the lut
        ///                interpulation 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
        {
            float  u_threshold_per_uv[8];

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

            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_top_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _U threshold Top Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_top_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_bottom_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _U threshold Bottom, Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_bottom_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 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_far_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 5x5 _Uthr modifier Far(5) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-256, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_far_mod_offset;

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// u_threshold_distant_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter,_Uthr modifier Dist (7) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-256, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  u_threshold_distant_mod_offset;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_per_y_tab
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _V threshold LutY.
        /// Type:          uint
        /// Range:         [0, 255]
        /// Length:        17
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct v_threshold_per_y_tabStruct
        {
            float  v_threshold_per_y[17];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   threshold LutUV, points are located at the end of uv space (-128,127). Input uv values to the lut
        ///                interpulation 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
        {
            float  v_threshold_per_uv[8];

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

            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_top_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _V threshold Top Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 255
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_top_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_bottom_limit
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, _V threshold Bottom, Limit of (LutY+LutUV).
        /// Type:          uint
        /// Default Value: 0
        /// Range:         [0, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_bottom_limit;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 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_far_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 5x5 _Vthr modifier Far(5) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-256, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_far_mod_offset;

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// v_threshold_distant_mod_offset
        ///
        /// Tuning Level:  must_tune
        /// Description:   chroma_filter, 7x7 _Vthr modifier Dist (7) scale/offset factors.
        /// Type:          int
        /// Default Value: 0
        /// Range:         [-256, 255]
        /// Notes:         Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        float  v_threshold_distant_mod_offset;

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

        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
        ///
        /// Tuning Level:  must_tune
        /// 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct dcblend2_luma_strength_function_tabStruct
        {
            float  dcblend2_luma_strength_function[5];

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

            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
        ///
        /// Tuning Level:  must_tune
        /// Description:   Controls the strength of DCBlend2. Lut of how much to blend as a function CDCSize. (in case of filter2
        ///                ind extenstion interp is off, these values will be interpulated 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:         In tuning_parameter_level, first parameter is for FULL pass, second for DC4, third for DC16 and last is
        ///                for DC64. Linear interpolation.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct dcblend2_chroma_strength_function_tabStruct
        {
            float  dcblend2_chroma_strength_function[6];

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

            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;

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

        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;

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

    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_anr10_pass_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct mod_anr10_pass_dataType
{

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

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anr10_rgn_data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    anr10_rgn_dataType anr10_rgn_data;

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

    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_anr10_rgn_array_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct mod_anr10_rgn_array_dataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mod_anr10_pass_data - Array
    /// Length:        4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    mod_anr10_pass_dataType mod_anr10_pass_data[4];

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

    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_anr10_rgn_array_dataType* region;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    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_anr10_coreType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_anr10_coreType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mod_anr10_trigger_data - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32       mod_anr10_trigger_dataCount;
    UINT32       mod_anr10_trigger_dataID;
    triggerType* mod_anr10_trigger_data;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    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_anr10Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatix_anr10Type
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// 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;

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

        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;

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

        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;

        bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
        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_aec_exp_sensitivity_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;

        bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
        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;

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

        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_anr10_reserve
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_anr10_reserveType chromatix_anr10_reserve;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chromatix_anr10_core
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatix_anr10_coreType    chromatix_anr10_core;

    bool Load(ParameterFileSymbolTableEntry* const entry, BYTE const alignment);
    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();
};

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

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

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

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatix_anr10TypeClass();

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


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// 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_anr10Type::GetValue(__path, __value, __size);
    }

    virtual bool SetValue(
        const CHAR* const __path,
        const CHAR* const __value)
    {
        if (chromatix_anr10Type::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 & 0x00ffffff;
            }
            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_anr10Type::GetInfo(__path, __info);
    }

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

ANR_1_0_1_NAMESPACE_END
#endif // ANR_1_0_1_H

