////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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  dpp_1_0_0.cpp
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "dpp_1_0_0.h"
#include "parametersetmanager.h"

DPP_1_0_0_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10_reserveType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "holes_fill_and_spatial") == 0)
    {
        __result = holes_fill_and_spatial.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatix_dpp10_reserveType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "holes_fill_and_spatial") == 0)
    {
        __result = holes_fill_and_spatial.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatix_dpp10_reserveType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // holes_fill_and_spatial
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("holes_fill_and_spatial", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "holes_fill_and_spatial") == 0)
    {
        __result = holes_fill_and_spatial.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool chromatix_dpp10_reserveType::holes_fill_and_spatialStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_special_border_section_1") == 0)
    {
        ParameterUtils::DoubleToString((double)adapt_lambda_special_border_section_1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_special_border_section_2") == 0)
    {
        ParameterUtils::DoubleToString((double)adapt_lambda_special_border_section_2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "special_border_side") == 0)
    {
        ParameterUtils::DoubleToString((double)special_border_side, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_section") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_special_border_close_section, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_1") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_special_border_section_1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_2") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_special_border_section_2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_3") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_special_border_section_3, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatix_dpp10_reserveType::holes_fill_and_spatialStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_special_border_section_1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            adapt_lambda_special_border_section_1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_special_border_section_2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            adapt_lambda_special_border_section_2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "special_border_side") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            special_border_side = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_section") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_special_border_close_section = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_special_border_section_1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_special_border_section_2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_special_border_section_3 = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatix_dpp10_reserveType::holes_fill_and_spatialStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // adapt_lambda_special_border_section_1
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_special_border_section_1", ParameterParserDataType::Float, (double)adapt_lambda_special_border_section_1));
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_special_border_section_1") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)adapt_lambda_special_border_section_1));
    }

    // adapt_lambda_special_border_section_2
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_special_border_section_2", ParameterParserDataType::Float, (double)adapt_lambda_special_border_section_2));
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_special_border_section_2") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)adapt_lambda_special_border_section_2));
    }

    // special_border_side
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("special_border_side", ParameterParserDataType::UInt32, (double)special_border_side, 0));
    }
    else if (PARAMETER_STRCMP(__name, "special_border_side") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)special_border_side, 0));
    }

    // hf_conf_special_border_close_section
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_special_border_close_section", ParameterParserDataType::Float, (double)hf_conf_special_border_close_section));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_section") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_conf_special_border_close_section));
    }

    // hf_special_border_section_1
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_special_border_section_1", ParameterParserDataType::Float, (double)hf_special_border_section_1));
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_1") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_special_border_section_1));
    }

    // hf_special_border_section_2
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_special_border_section_2", ParameterParserDataType::Float, (double)hf_special_border_section_2));
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_2") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_special_border_section_2));
    }

    // hf_special_border_section_3
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_special_border_section_3", ParameterParserDataType::Float, (double)hf_special_border_section_3));
    }
    else if (PARAMETER_STRCMP(__name, "hf_special_border_section_3") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_special_border_section_3));
    }

    return __result;
}

bool dpp10_rgn_dataType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "processing_enable") == 0)
    {
        __result = processing_enable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "common_params") == 0)
    {
        __result = common_params.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing") == 0)
    {
        __result = pre_processing.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "holes_fill_and_spatial") == 0)
    {
        __result = holes_fill_and_spatial.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "disparity_map_merge") == 0)
    {
        __result = disparity_map_merge.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "tnr") == 0)
    {
        __result = tnr.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool dpp10_rgn_dataType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "processing_enable") == 0)
    {
        __result = processing_enable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "common_params") == 0)
    {
        __result = common_params.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing") == 0)
    {
        __result = pre_processing.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "holes_fill_and_spatial") == 0)
    {
        __result = holes_fill_and_spatial.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "disparity_map_merge") == 0)
    {
        __result = disparity_map_merge.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "tnr") == 0)
    {
        __result = tnr.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool dpp10_rgn_dataType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // processing_enable
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("processing_enable", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "processing_enable") == 0)
    {
        __result = processing_enable.GetInfo(&__path[__pos], __info);
    }

    // common_params
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("common_params", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "common_params") == 0)
    {
        __result = common_params.GetInfo(&__path[__pos], __info);
    }

    // pre_processing
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pre_processing", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing") == 0)
    {
        __result = pre_processing.GetInfo(&__path[__pos], __info);
    }

    // holes_fill_and_spatial
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("holes_fill_and_spatial", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "holes_fill_and_spatial") == 0)
    {
        __result = holes_fill_and_spatial.GetInfo(&__path[__pos], __info);
    }

    // disparity_map_merge
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("disparity_map_merge", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "disparity_map_merge") == 0)
    {
        __result = disparity_map_merge.GetInfo(&__path[__pos], __info);
    }

    // tnr
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("tnr", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "tnr") == 0)
    {
        __result = tnr.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool dpp10_rgn_dataType::processing_enableStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "depth_processing_en") == 0)
    {
        ParameterUtils::DoubleToString((double)depth_processing_en, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool dpp10_rgn_dataType::processing_enableStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "depth_processing_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            depth_processing_en = (float)dblValue; 
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::processing_enableStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // depth_processing_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("depth_processing_en", ParameterParserDataType::UInt32, (double)depth_processing_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "depth_processing_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)depth_processing_en, 0));
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "focus_roi_disp_calc_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)focus_roi_disp_calc_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "focus_roi_disp_calc_param") == 0)
    {
        ParameterUtils::DoubleToString((double)focus_roi_disp_calc_param, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "disp_map_range_factor") == 0)
    {
        ParameterUtils::DoubleToString((double)disp_map_range_factor, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lnr_grid_luma_tab") == 0)
    {
        __result = lnr_grid_luma_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lnr_grid_chroma_tab") == 0)
    {
        __result = lnr_grid_chroma_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_12") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_12, __value, __size);
        __result = true;
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "focus_roi_disp_calc_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            focus_roi_disp_calc_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "focus_roi_disp_calc_param") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            focus_roi_disp_calc_param = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "disp_map_range_factor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            disp_map_range_factor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lnr_grid_luma_tab") == 0)
    {
        __result = lnr_grid_luma_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lnr_grid_chroma_tab") == 0)
    {
        __result = lnr_grid_chroma_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_12") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_12 = (float)dblValue; 
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // focus_roi_disp_calc_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("focus_roi_disp_calc_mode", ParameterParserDataType::UInt32, (double)focus_roi_disp_calc_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "focus_roi_disp_calc_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)focus_roi_disp_calc_mode, 0));
    }

    // focus_roi_disp_calc_param
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("focus_roi_disp_calc_param", ParameterParserDataType::UInt32, (double)focus_roi_disp_calc_param, 0));
    }
    else if (PARAMETER_STRCMP(__name, "focus_roi_disp_calc_param") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)focus_roi_disp_calc_param, 0));
    }

    // disp_map_range_factor
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("disp_map_range_factor", ParameterParserDataType::Float, (double)disp_map_range_factor));
    }
    else if (PARAMETER_STRCMP(__name, "disp_map_range_factor") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)disp_map_range_factor));
    }

    // lnr_grid_luma_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("lnr_grid_luma_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "lnr_grid_luma_tab") == 0)
    {
        __result = lnr_grid_luma_tab.GetInfo(&__path[__pos], __info);
    }

    // lnr_grid_chroma_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("lnr_grid_chroma_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "lnr_grid_chroma_tab") == 0)
    {
        __result = lnr_grid_chroma_tab.GetInfo(&__path[__pos], __info);
    }

    // reserved_param_12
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_12", ParameterParserDataType::Float, (double)reserved_param_12));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_12") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_12));
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_luma_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "lnr_grid_luma") == 0)
    {
        if (__index < 99)
        {
            ParameterUtils::DoubleToString((double)lnr_grid_luma[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 99; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)lnr_grid_luma[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_luma_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "lnr_grid_luma") == 0)
    {
        if (__index < 99)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                lnr_grid_luma[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 99)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    lnr_grid_luma[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_luma_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // lnr_grid_luma
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("lnr_grid_luma", ParameterParserDataType::Float, true, false, 99));
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_chroma_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "lnr_grid_chroma") == 0)
    {
        if (__index < 99)
        {
            ParameterUtils::DoubleToString((double)lnr_grid_chroma[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 99; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)lnr_grid_chroma[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_chroma_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "lnr_grid_chroma") == 0)
    {
        if (__index < 99)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                lnr_grid_chroma[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 99)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    lnr_grid_chroma[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_chroma_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // lnr_grid_chroma
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("lnr_grid_chroma", ParameterParserDataType::Float, true, false, 99));
    }

    return __result;
}

bool dpp10_rgn_dataType::pre_processingStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pre_processing_en") == 0)
    {
        ParameterUtils::DoubleToString((double)pre_processing_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)pre_processing_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing_func_tab") == 0)
    {
        __result = pre_processing_func_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_1") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_2") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_2, __value, __size);
        __result = true;
    }

    return __result;
}

bool dpp10_rgn_dataType::pre_processingStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pre_processing_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pre_processing_en = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pre_processing_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing_func_tab") == 0)
    {
        __result = pre_processing_func_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_2 = (float)dblValue; 
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::pre_processingStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // pre_processing_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pre_processing_en", ParameterParserDataType::UInt32, (double)pre_processing_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)pre_processing_en, 0));
    }

    // pre_processing_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pre_processing_mode", ParameterParserDataType::UInt32, (double)pre_processing_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)pre_processing_mode, 0));
    }

    // pre_processing_func_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pre_processing_func_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "pre_processing_func_tab") == 0)
    {
        __result = pre_processing_func_tab.GetInfo(&__path[__pos], __info);
    }

    // reserved_param_1
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_1", ParameterParserDataType::Float, (double)reserved_param_1));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_1") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_1));
    }

    // reserved_param_2
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_2", ParameterParserDataType::Float, (double)reserved_param_2));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_2") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_2));
    }

    return __result;
}

bool dpp10_rgn_dataType::pre_processingStruct::pre_processing_func_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pre_processing_func") == 0)
    {
        if (__index < 129)
        {
            ParameterUtils::DoubleToString((double)pre_processing_func[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 129; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)pre_processing_func[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::pre_processingStruct::pre_processing_func_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pre_processing_func") == 0)
    {
        if (__index < 129)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                pre_processing_func[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 129)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    pre_processing_func[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::pre_processingStruct::pre_processing_func_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // pre_processing_func
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pre_processing_func", ParameterParserDataType::Float, true, false, 129));
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "spatial_filter_en") == 0)
    {
        ParameterUtils::DoubleToString((double)spatial_filter_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)spatial_filter_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_sigmas_tab") == 0)
    {
        __result = spatial_filter_sigmas_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_lambdas_tab") == 0)
    {
        __result = spatial_filter_lambdas_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_num_iterations") == 0)
    {
        ParameterUtils::DoubleToString((double)spatial_filter_num_iterations, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "post_spatial_filter_en") == 0)
    {
        ParameterUtils::DoubleToString((double)post_spatial_filter_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "post_spatial_filter_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)post_spatial_filter_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_ens_tab") == 0)
    {
        __result = adapt_lambda_ens_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_modes_tab") == 0)
    {
        __result = adapt_lambda_modes_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_sig_func_tab") == 0)
    {
        __result = adapt_lambda_sig_func_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_flat_func_tab") == 0)
    {
        __result = adapt_lambda_flat_func_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "hf_en") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_lambda") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_lambda, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_sigma") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_sigma, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_adapt_lambda_en") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_adapt_lambda_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_adapt_lambda_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_adapt_lambda_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_hor") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_special_border_close_hor, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_ver") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_special_border_close_ver, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_low_thresh") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_low_thresh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_high_thresh") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_high_thresh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_low") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_hist_low, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_high") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_hist_high, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_close_hor") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_hist_close_hor, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_close_ver") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_conf_hist_close_ver, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hf_and_spatial_chroma_saturation_factor") == 0)
    {
        ParameterUtils::DoubleToString((double)hf_and_spatial_chroma_saturation_factor, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_3") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_3, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_4") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_4, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_5") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_5, __value, __size);
        __result = true;
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "spatial_filter_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            spatial_filter_en = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            spatial_filter_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_sigmas_tab") == 0)
    {
        __result = spatial_filter_sigmas_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_lambdas_tab") == 0)
    {
        __result = spatial_filter_lambdas_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_num_iterations") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            spatial_filter_num_iterations = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "post_spatial_filter_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            post_spatial_filter_en = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "post_spatial_filter_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            post_spatial_filter_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_ens_tab") == 0)
    {
        __result = adapt_lambda_ens_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_modes_tab") == 0)
    {
        __result = adapt_lambda_modes_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_sig_func_tab") == 0)
    {
        __result = adapt_lambda_sig_func_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_flat_func_tab") == 0)
    {
        __result = adapt_lambda_flat_func_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "hf_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_en = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_lambda") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_lambda = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_sigma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_sigma = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_adapt_lambda_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_adapt_lambda_en = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_adapt_lambda_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_adapt_lambda_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_hor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_special_border_close_hor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_ver") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_special_border_close_ver = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_low_thresh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_low_thresh = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_high_thresh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_high_thresh = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_low") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_hist_low = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_high") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_hist_high = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_close_hor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_hist_close_hor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_close_ver") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_conf_hist_close_ver = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hf_and_spatial_chroma_saturation_factor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hf_and_spatial_chroma_saturation_factor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_3 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_4") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_4 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_5") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_5 = (float)dblValue; 
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // spatial_filter_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("spatial_filter_en", ParameterParserDataType::UInt32, (double)spatial_filter_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)spatial_filter_en, 0));
    }

    // spatial_filter_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("spatial_filter_mode", ParameterParserDataType::UInt32, (double)spatial_filter_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)spatial_filter_mode, 0));
    }

    // spatial_filter_sigmas_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("spatial_filter_sigmas_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_sigmas_tab") == 0)
    {
        __result = spatial_filter_sigmas_tab.GetInfo(&__path[__pos], __info);
    }

    // spatial_filter_lambdas_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("spatial_filter_lambdas_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_lambdas_tab") == 0)
    {
        __result = spatial_filter_lambdas_tab.GetInfo(&__path[__pos], __info);
    }

    // spatial_filter_num_iterations
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("spatial_filter_num_iterations", ParameterParserDataType::UInt32, (double)spatial_filter_num_iterations, 0));
    }
    else if (PARAMETER_STRCMP(__name, "spatial_filter_num_iterations") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)spatial_filter_num_iterations, 0));
    }

    // post_spatial_filter_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("post_spatial_filter_en", ParameterParserDataType::UInt32, (double)post_spatial_filter_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "post_spatial_filter_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)post_spatial_filter_en, 0));
    }

    // post_spatial_filter_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("post_spatial_filter_mode", ParameterParserDataType::UInt32, (double)post_spatial_filter_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "post_spatial_filter_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)post_spatial_filter_mode, 0));
    }

    // adapt_lambda_ens_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_ens_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_ens_tab") == 0)
    {
        __result = adapt_lambda_ens_tab.GetInfo(&__path[__pos], __info);
    }

    // adapt_lambda_modes_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_modes_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_modes_tab") == 0)
    {
        __result = adapt_lambda_modes_tab.GetInfo(&__path[__pos], __info);
    }

    // adapt_lambda_sig_func_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_sig_func_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_sig_func_tab") == 0)
    {
        __result = adapt_lambda_sig_func_tab.GetInfo(&__path[__pos], __info);
    }

    // adapt_lambda_flat_func_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_flat_func_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "adapt_lambda_flat_func_tab") == 0)
    {
        __result = adapt_lambda_flat_func_tab.GetInfo(&__path[__pos], __info);
    }

    // hf_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_en", ParameterParserDataType::UInt32, (double)hf_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_en, 0));
    }

    // hf_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_mode", ParameterParserDataType::UInt32, (double)hf_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_mode, 0));
    }

    // hf_lambda
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_lambda", ParameterParserDataType::Float, (double)hf_lambda));
    }
    else if (PARAMETER_STRCMP(__name, "hf_lambda") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_lambda));
    }

    // hf_sigma
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_sigma", ParameterParserDataType::Float, (double)hf_sigma));
    }
    else if (PARAMETER_STRCMP(__name, "hf_sigma") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_sigma));
    }

    // hf_adapt_lambda_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_adapt_lambda_en", ParameterParserDataType::UInt32, (double)hf_adapt_lambda_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_adapt_lambda_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_adapt_lambda_en, 0));
    }

    // hf_adapt_lambda_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_adapt_lambda_mode", ParameterParserDataType::UInt32, (double)hf_adapt_lambda_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_adapt_lambda_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_adapt_lambda_mode, 0));
    }

    // hf_conf_special_border_close_hor
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_special_border_close_hor", ParameterParserDataType::UInt32, (double)hf_conf_special_border_close_hor, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_hor") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_conf_special_border_close_hor, 0));
    }

    // hf_conf_special_border_close_ver
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_special_border_close_ver", ParameterParserDataType::UInt32, (double)hf_conf_special_border_close_ver, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_special_border_close_ver") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_conf_special_border_close_ver, 0));
    }

    // hf_conf_low_thresh
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_low_thresh", ParameterParserDataType::UInt32, (double)hf_conf_low_thresh, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_low_thresh") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_conf_low_thresh, 0));
    }

    // hf_conf_high_thresh
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_high_thresh", ParameterParserDataType::UInt32, (double)hf_conf_high_thresh, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_high_thresh") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_conf_high_thresh, 0));
    }

    // hf_conf_hist_low
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_hist_low", ParameterParserDataType::Float, (double)hf_conf_hist_low));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_low") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_conf_hist_low));
    }

    // hf_conf_hist_high
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_hist_high", ParameterParserDataType::Float, (double)hf_conf_hist_high));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_high") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_conf_hist_high));
    }

    // hf_conf_hist_close_hor
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_hist_close_hor", ParameterParserDataType::UInt32, (double)hf_conf_hist_close_hor, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_close_hor") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_conf_hist_close_hor, 0));
    }

    // hf_conf_hist_close_ver
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_conf_hist_close_ver", ParameterParserDataType::UInt32, (double)hf_conf_hist_close_ver, 0));
    }
    else if (PARAMETER_STRCMP(__name, "hf_conf_hist_close_ver") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)hf_conf_hist_close_ver, 0));
    }

    // hf_and_spatial_chroma_saturation_factor
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hf_and_spatial_chroma_saturation_factor", ParameterParserDataType::Float, (double)hf_and_spatial_chroma_saturation_factor));
    }
    else if (PARAMETER_STRCMP(__name, "hf_and_spatial_chroma_saturation_factor") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)hf_and_spatial_chroma_saturation_factor));
    }

    // reserved_param_3
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_3", ParameterParserDataType::Float, (double)reserved_param_3));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_3") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_3));
    }

    // reserved_param_4
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_4", ParameterParserDataType::Float, (double)reserved_param_4));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_4") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_4));
    }

    // reserved_param_5
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_5", ParameterParserDataType::Float, (double)reserved_param_5));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_5") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_5));
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_sigmas_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "spatial_filter_sigmas") == 0)
    {
        if (__index < 4)
        {
            ParameterUtils::DoubleToString((double)spatial_filter_sigmas[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 4; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)spatial_filter_sigmas[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_sigmas_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "spatial_filter_sigmas") == 0)
    {
        if (__index < 4)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                spatial_filter_sigmas[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 4)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    spatial_filter_sigmas[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_sigmas_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // spatial_filter_sigmas
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("spatial_filter_sigmas", ParameterParserDataType::Float, true, false, 4));
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_lambdas_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "spatial_filter_lambdas") == 0)
    {
        if (__index < 4)
        {
            ParameterUtils::DoubleToString((double)spatial_filter_lambdas[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 4; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)spatial_filter_lambdas[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_lambdas_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "spatial_filter_lambdas") == 0)
    {
        if (__index < 4)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                spatial_filter_lambdas[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 4)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    spatial_filter_lambdas[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_lambdas_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // spatial_filter_lambdas
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("spatial_filter_lambdas", ParameterParserDataType::Float, true, false, 4));
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_ens_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_ens") == 0)
    {
        if (__index < 4)
        {
            ParameterUtils::DoubleToString((double)adapt_lambda_ens[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 4; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)adapt_lambda_ens[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_ens_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_ens") == 0)
    {
        if (__index < 4)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                adapt_lambda_ens[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 4)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    adapt_lambda_ens[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_ens_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // adapt_lambda_ens
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_ens", ParameterParserDataType::UInt32, true, false, 4));
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_modes_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_modes") == 0)
    {
        if (__index < 4)
        {
            ParameterUtils::DoubleToString((double)adapt_lambda_modes[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 4; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)adapt_lambda_modes[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_modes_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_modes") == 0)
    {
        if (__index < 4)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                adapt_lambda_modes[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 4)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    adapt_lambda_modes[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_modes_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // adapt_lambda_modes
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_modes", ParameterParserDataType::UInt32, true, false, 4));
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_sig_func_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_sig_func") == 0)
    {
        if (__index < 17)
        {
            ParameterUtils::DoubleToString((double)adapt_lambda_sig_func[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 17; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)adapt_lambda_sig_func[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_sig_func_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_sig_func") == 0)
    {
        if (__index < 17)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                adapt_lambda_sig_func[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 17)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    adapt_lambda_sig_func[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_sig_func_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // adapt_lambda_sig_func
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_sig_func", ParameterParserDataType::Float, true, false, 17));
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_flat_func_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_flat_func") == 0)
    {
        if (__index < 17)
        {
            ParameterUtils::DoubleToString((double)adapt_lambda_flat_func[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 17; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)adapt_lambda_flat_func[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_flat_func_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "adapt_lambda_flat_func") == 0)
    {
        if (__index < 17)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                adapt_lambda_flat_func[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 17)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    adapt_lambda_flat_func[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_flat_func_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // adapt_lambda_flat_func
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("adapt_lambda_flat_func", ParameterParserDataType::Float, true, false, 17));
    }

    return __result;
}

bool dpp10_rgn_dataType::disparity_map_mergeStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pd_merge_en") == 0)
    {
        ParameterUtils::DoubleToString((double)pd_merge_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pd_merge_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)pd_merge_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pd_merge_level") == 0)
    {
        ParameterUtils::DoubleToString((double)pd_merge_level, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pd_map_func_tab") == 0)
    {
        __result = pd_map_func_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_6") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_6, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_7") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_7, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_8") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_8, __value, __size);
        __result = true;
    }

    return __result;
}

bool dpp10_rgn_dataType::disparity_map_mergeStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pd_merge_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pd_merge_en = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pd_merge_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pd_merge_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pd_merge_level") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pd_merge_level = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pd_map_func_tab") == 0)
    {
        __result = pd_map_func_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_6") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_6 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_7") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_7 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_8") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_8 = (float)dblValue; 
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::disparity_map_mergeStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // pd_merge_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pd_merge_en", ParameterParserDataType::UInt32, (double)pd_merge_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "pd_merge_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)pd_merge_en, 0));
    }

    // pd_merge_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pd_merge_mode", ParameterParserDataType::UInt32, (double)pd_merge_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "pd_merge_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)pd_merge_mode, 0));
    }

    // pd_merge_level
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pd_merge_level", ParameterParserDataType::Float, (double)pd_merge_level));
    }
    else if (PARAMETER_STRCMP(__name, "pd_merge_level") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)pd_merge_level));
    }

    // pd_map_func_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pd_map_func_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "pd_map_func_tab") == 0)
    {
        __result = pd_map_func_tab.GetInfo(&__path[__pos], __info);
    }

    // reserved_param_6
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_6", ParameterParserDataType::Float, (double)reserved_param_6));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_6") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_6));
    }

    // reserved_param_7
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_7", ParameterParserDataType::Float, (double)reserved_param_7));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_7") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_7));
    }

    // reserved_param_8
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_8", ParameterParserDataType::Float, (double)reserved_param_8));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_8") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_8));
    }

    return __result;
}

bool dpp10_rgn_dataType::disparity_map_mergeStruct::pd_map_func_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pd_map_func") == 0)
    {
        if (__index < 65)
        {
            ParameterUtils::DoubleToString((double)pd_map_func[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 65; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)pd_map_func[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::disparity_map_mergeStruct::pd_map_func_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pd_map_func") == 0)
    {
        if (__index < 65)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                pd_map_func[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 65)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    pd_map_func[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::disparity_map_mergeStruct::pd_map_func_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // pd_map_func
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pd_map_func", ParameterParserDataType::Float, true, false, 65));
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "tnr_en") == 0)
    {
        ParameterUtils::DoubleToString((double)tnr_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tnr_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)tnr_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "oof_pixels_noise_adj1") == 0)
    {
        ParameterUtils::DoubleToString((double)oof_pixels_noise_adj1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "oof_pixels_noise_adj2") == 0)
    {
        ParameterUtils::DoubleToString((double)oof_pixels_noise_adj2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "alpha_lut_tab") == 0)
    {
        __result = alpha_lut_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "luma_noise_low_thr_lut_tab") == 0)
    {
        __result = luma_noise_low_thr_lut_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "luma_noise_high_thr_lut_tab") == 0)
    {
        __result = luma_noise_high_thr_lut_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "alpha_post_calc_win_size") == 0)
    {
        ParameterUtils::DoubleToString((double)alpha_post_calc_win_size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "alpha_post_calc_filter_sigma") == 0)
    {
        ParameterUtils::DoubleToString((double)alpha_post_calc_filter_sigma, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_win_size") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_im_filter_win_size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_sigma_luma") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_im_filter_sigma_luma, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_sigma_chroma") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_im_filter_sigma_chroma, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "chroma_noise_factor") == 0)
    {
        ParameterUtils::DoubleToString((double)chroma_noise_factor, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "boundary_treatment_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)boundary_treatment_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "luma_avg_filter_win_size") == 0)
    {
        ParameterUtils::DoubleToString((double)luma_avg_filter_win_size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tnr_chroma_saturation_factor") == 0)
    {
        ParameterUtils::DoubleToString((double)tnr_chroma_saturation_factor, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_filter_win_size") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_map_filter_win_size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_alpha_factor_max") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_map_alpha_factor_max, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_thr_low") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_map_thr_low, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_thr_high") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_map_thr_high, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_9") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_9, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_10") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_10, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_11") == 0)
    {
        ParameterUtils::DoubleToString((double)reserved_param_11, __value, __size);
        __result = true;
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "tnr_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tnr_en = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tnr_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tnr_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "oof_pixels_noise_adj1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            oof_pixels_noise_adj1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "oof_pixels_noise_adj2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            oof_pixels_noise_adj2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "alpha_lut_tab") == 0)
    {
        __result = alpha_lut_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "luma_noise_low_thr_lut_tab") == 0)
    {
        __result = luma_noise_low_thr_lut_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "luma_noise_high_thr_lut_tab") == 0)
    {
        __result = luma_noise_high_thr_lut_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "alpha_post_calc_win_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            alpha_post_calc_win_size = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "alpha_post_calc_filter_sigma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            alpha_post_calc_filter_sigma = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_win_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_im_filter_win_size = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_sigma_luma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_im_filter_sigma_luma = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_sigma_chroma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_im_filter_sigma_chroma = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "chroma_noise_factor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            chroma_noise_factor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "boundary_treatment_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            boundary_treatment_mode = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "luma_avg_filter_win_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            luma_avg_filter_win_size = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tnr_chroma_saturation_factor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tnr_chroma_saturation_factor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_filter_win_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_map_filter_win_size = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_alpha_factor_max") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_map_alpha_factor_max = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_thr_low") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_map_thr_low = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_thr_high") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_map_thr_high = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_9") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_9 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_10") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_10 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_11") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            reserved_param_11 = (float)dblValue; 
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // tnr_en
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("tnr_en", ParameterParserDataType::UInt32, (double)tnr_en, 0));
    }
    else if (PARAMETER_STRCMP(__name, "tnr_en") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)tnr_en, 0));
    }

    // tnr_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("tnr_mode", ParameterParserDataType::UInt32, (double)tnr_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "tnr_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)tnr_mode, 0));
    }

    // oof_pixels_noise_adj1
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("oof_pixels_noise_adj1", ParameterParserDataType::Float, (double)oof_pixels_noise_adj1));
    }
    else if (PARAMETER_STRCMP(__name, "oof_pixels_noise_adj1") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)oof_pixels_noise_adj1));
    }

    // oof_pixels_noise_adj2
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("oof_pixels_noise_adj2", ParameterParserDataType::Float, (double)oof_pixels_noise_adj2));
    }
    else if (PARAMETER_STRCMP(__name, "oof_pixels_noise_adj2") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)oof_pixels_noise_adj2));
    }

    // alpha_lut_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("alpha_lut_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "alpha_lut_tab") == 0)
    {
        __result = alpha_lut_tab.GetInfo(&__path[__pos], __info);
    }

    // luma_noise_low_thr_lut_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("luma_noise_low_thr_lut_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "luma_noise_low_thr_lut_tab") == 0)
    {
        __result = luma_noise_low_thr_lut_tab.GetInfo(&__path[__pos], __info);
    }

    // luma_noise_high_thr_lut_tab
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("luma_noise_high_thr_lut_tab", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "luma_noise_high_thr_lut_tab") == 0)
    {
        __result = luma_noise_high_thr_lut_tab.GetInfo(&__path[__pos], __info);
    }

    // alpha_post_calc_win_size
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("alpha_post_calc_win_size", ParameterParserDataType::UInt32, (double)alpha_post_calc_win_size, 0));
    }
    else if (PARAMETER_STRCMP(__name, "alpha_post_calc_win_size") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)alpha_post_calc_win_size, 0));
    }

    // alpha_post_calc_filter_sigma
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("alpha_post_calc_filter_sigma", ParameterParserDataType::Float, (double)alpha_post_calc_filter_sigma));
    }
    else if (PARAMETER_STRCMP(__name, "alpha_post_calc_filter_sigma") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)alpha_post_calc_filter_sigma));
    }

    // diff_im_filter_win_size
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("diff_im_filter_win_size", ParameterParserDataType::UInt32, (double)diff_im_filter_win_size, 0));
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_win_size") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)diff_im_filter_win_size, 0));
    }

    // diff_im_filter_sigma_luma
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("diff_im_filter_sigma_luma", ParameterParserDataType::Float, (double)diff_im_filter_sigma_luma));
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_sigma_luma") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)diff_im_filter_sigma_luma));
    }

    // diff_im_filter_sigma_chroma
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("diff_im_filter_sigma_chroma", ParameterParserDataType::Float, (double)diff_im_filter_sigma_chroma));
    }
    else if (PARAMETER_STRCMP(__name, "diff_im_filter_sigma_chroma") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)diff_im_filter_sigma_chroma));
    }

    // chroma_noise_factor
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("chroma_noise_factor", ParameterParserDataType::Float, (double)chroma_noise_factor));
    }
    else if (PARAMETER_STRCMP(__name, "chroma_noise_factor") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)chroma_noise_factor));
    }

    // boundary_treatment_mode
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("boundary_treatment_mode", ParameterParserDataType::UInt32, (double)boundary_treatment_mode, 0));
    }
    else if (PARAMETER_STRCMP(__name, "boundary_treatment_mode") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)boundary_treatment_mode, 0));
    }

    // luma_avg_filter_win_size
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("luma_avg_filter_win_size", ParameterParserDataType::UInt32, (double)luma_avg_filter_win_size, 0));
    }
    else if (PARAMETER_STRCMP(__name, "luma_avg_filter_win_size") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)luma_avg_filter_win_size, 0));
    }

    // tnr_chroma_saturation_factor
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("tnr_chroma_saturation_factor", ParameterParserDataType::Float, (double)tnr_chroma_saturation_factor));
    }
    else if (PARAMETER_STRCMP(__name, "tnr_chroma_saturation_factor") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)tnr_chroma_saturation_factor));
    }

    // diff_map_filter_win_size
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("diff_map_filter_win_size", ParameterParserDataType::UInt32, (double)diff_map_filter_win_size, 0));
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_filter_win_size") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)diff_map_filter_win_size, 0));
    }

    // diff_map_alpha_factor_max
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("diff_map_alpha_factor_max", ParameterParserDataType::Float, (double)diff_map_alpha_factor_max));
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_alpha_factor_max") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)diff_map_alpha_factor_max));
    }

    // diff_map_thr_low
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("diff_map_thr_low", ParameterParserDataType::UInt32, (double)diff_map_thr_low, 0));
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_thr_low") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)diff_map_thr_low, 0));
    }

    // diff_map_thr_high
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("diff_map_thr_high", ParameterParserDataType::UInt32, (double)diff_map_thr_high, 0));
    }
    else if (PARAMETER_STRCMP(__name, "diff_map_thr_high") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::UInt32, (double)diff_map_thr_high, 0));
    }

    // reserved_param_9
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_9", ParameterParserDataType::Float, (double)reserved_param_9));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_9") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_9));
    }

    // reserved_param_10
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_10", ParameterParserDataType::Float, (double)reserved_param_10));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_10") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_10));
    }

    // reserved_param_11
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("reserved_param_11", ParameterParserDataType::Float, (double)reserved_param_11));
    }
    else if (PARAMETER_STRCMP(__name, "reserved_param_11") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)reserved_param_11));
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::alpha_lut_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "alpha_lut") == 0)
    {
        if (__index < 65)
        {
            ParameterUtils::DoubleToString((double)alpha_lut[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 65; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)alpha_lut[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::alpha_lut_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "alpha_lut") == 0)
    {
        if (__index < 65)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                alpha_lut[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 65)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    alpha_lut[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::alpha_lut_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // alpha_lut
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("alpha_lut", ParameterParserDataType::Float, true, false, 65));
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::luma_noise_low_thr_lut_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "luma_noise_low_thr_lut") == 0)
    {
        if (__index < 17)
        {
            ParameterUtils::DoubleToString((double)luma_noise_low_thr_lut[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 17; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)luma_noise_low_thr_lut[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::luma_noise_low_thr_lut_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "luma_noise_low_thr_lut") == 0)
    {
        if (__index < 17)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                luma_noise_low_thr_lut[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 17)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    luma_noise_low_thr_lut[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::luma_noise_low_thr_lut_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // luma_noise_low_thr_lut
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("luma_noise_low_thr_lut", ParameterParserDataType::Float, true, false, 17));
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::luma_noise_high_thr_lut_tabStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "luma_noise_high_thr_lut") == 0)
    {
        if (__index < 17)
        {
            ParameterUtils::DoubleToString((double)luma_noise_high_thr_lut[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 17; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)luma_noise_high_thr_lut[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::luma_noise_high_thr_lut_tabStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "luma_noise_high_thr_lut") == 0)
    {
        if (__index < 17)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                luma_noise_high_thr_lut[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 17)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    luma_noise_high_thr_lut[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool dpp10_rgn_dataType::tnrStruct::luma_noise_high_thr_lut_tabStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // luma_noise_high_thr_lut
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("luma_noise_high_thr_lut", ParameterParserDataType::Float, true, false, 17));
    }

    return __result;
}

bool mod_dpp10_aec_dataType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "aec_trigger") == 0)
    {
        __result = aec_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "dpp10_rgn_data") == 0)
    {
        __result = dpp10_rgn_data.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool mod_dpp10_aec_dataType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "aec_trigger") == 0)
    {
        __result = aec_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "dpp10_rgn_data") == 0)
    {
        __result = dpp10_rgn_data.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool mod_dpp10_aec_dataType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // aec_trigger
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("aec_trigger", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "aec_trigger") == 0)
    {
        __result = aec_trigger.GetInfo(&__path[__pos], __info);
    }

    // dpp10_rgn_data
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("dpp10_rgn_data", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "dpp10_rgn_data") == 0)
    {
        __result = dpp10_rgn_data.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool mod_dpp10_hdr_aec_dataType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "hdr_aec_trigger") == 0)
    {
        __result = hdr_aec_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "hdr_aec_data") == 0)
    {
        __result = hdr_aec_data.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool mod_dpp10_hdr_aec_dataType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "hdr_aec_trigger") == 0)
    {
        __result = hdr_aec_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "hdr_aec_data") == 0)
    {
        __result = hdr_aec_data.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool mod_dpp10_hdr_aec_dataType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // hdr_aec_trigger
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hdr_aec_trigger", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "hdr_aec_trigger") == 0)
    {
        __result = hdr_aec_trigger.GetInfo(&__path[__pos], __info);
    }

    // hdr_aec_data
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("hdr_aec_data", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "hdr_aec_data") == 0)
    {
        __result = hdr_aec_data.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool mod_dpp10_hdr_aec_dataType::hdr_aec_dataStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "mod_dpp10_aec_data") == 0)
    {
        if (__index < mod_dpp10_aec_dataCount)
        {
            __result = mod_dpp10_aec_data[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool mod_dpp10_hdr_aec_dataType::hdr_aec_dataStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "mod_dpp10_aec_data") == 0)
    {
        if (__index < mod_dpp10_aec_dataCount)
        {
            __result = mod_dpp10_aec_data[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool mod_dpp10_hdr_aec_dataType::hdr_aec_dataStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // mod_dpp10_aec_data
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("mod_dpp10_aec_data", ParameterParserDataType::Structure, true, false, mod_dpp10_aec_dataCount));
    }
    else if (PARAMETER_STRCMP(__name, "mod_dpp10_aec_data") == 0)
    {
        if (__index < mod_dpp10_aec_dataCount)
        {
            __result = mod_dpp10_aec_data[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, mod_dpp10_aec_dataCount));
        }
    }

    return __result;
}

bool mod_dpp10_pre_scale_ratio_dataType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pre_scale_ratio_trigger") == 0)
    {
        __result = pre_scale_ratio_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "pre_scale_ratio_data") == 0)
    {
        __result = pre_scale_ratio_data.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool mod_dpp10_pre_scale_ratio_dataType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "pre_scale_ratio_trigger") == 0)
    {
        __result = pre_scale_ratio_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "pre_scale_ratio_data") == 0)
    {
        __result = pre_scale_ratio_data.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool mod_dpp10_pre_scale_ratio_dataType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // pre_scale_ratio_trigger
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pre_scale_ratio_trigger", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "pre_scale_ratio_trigger") == 0)
    {
        __result = pre_scale_ratio_trigger.GetInfo(&__path[__pos], __info);
    }

    // pre_scale_ratio_data
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("pre_scale_ratio_data", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "pre_scale_ratio_data") == 0)
    {
        __result = pre_scale_ratio_data.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool mod_dpp10_pre_scale_ratio_dataType::pre_scale_ratio_dataStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "mod_dpp10_hdr_aec_data") == 0)
    {
        if (__index < mod_dpp10_hdr_aec_dataCount)
        {
            __result = mod_dpp10_hdr_aec_data[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool mod_dpp10_pre_scale_ratio_dataType::pre_scale_ratio_dataStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "mod_dpp10_hdr_aec_data") == 0)
    {
        if (__index < mod_dpp10_hdr_aec_dataCount)
        {
            __result = mod_dpp10_hdr_aec_data[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool mod_dpp10_pre_scale_ratio_dataType::pre_scale_ratio_dataStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // mod_dpp10_hdr_aec_data
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("mod_dpp10_hdr_aec_data", ParameterParserDataType::Structure, true, false, mod_dpp10_hdr_aec_dataCount));
    }
    else if (PARAMETER_STRCMP(__name, "mod_dpp10_hdr_aec_data") == 0)
    {
        if (__index < mod_dpp10_hdr_aec_dataCount)
        {
            __result = mod_dpp10_hdr_aec_data[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, mod_dpp10_hdr_aec_dataCount));
        }
    }

    return __result;
}

bool chromatix_dpp10_coreType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "mod_dpp10_pre_scale_ratio_data") == 0)
    {
        if (__index < mod_dpp10_pre_scale_ratio_dataCount)
        {
            __result = mod_dpp10_pre_scale_ratio_data[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatix_dpp10_coreType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "mod_dpp10_pre_scale_ratio_data") == 0)
    {
        if (__index < mod_dpp10_pre_scale_ratio_dataCount)
        {
            __result = mod_dpp10_pre_scale_ratio_data[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatix_dpp10_coreType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // mod_dpp10_pre_scale_ratio_data
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("mod_dpp10_pre_scale_ratio_data", ParameterParserDataType::Structure, true, false, mod_dpp10_pre_scale_ratio_dataCount));
    }
    else if (PARAMETER_STRCMP(__name, "mod_dpp10_pre_scale_ratio_data") == 0)
    {
        if (__index < mod_dpp10_pre_scale_ratio_dataCount)
        {
            __result = mod_dpp10_pre_scale_ratio_data[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, mod_dpp10_pre_scale_ratio_dataCount));
        }
    }

    return __result;
}

bool chromatix_dpp10Type::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "control_variables") == 0)
    {
        __result = control_variables.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "control_method") == 0)
    {
        __result = control_method.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "chromatix_dpp10_reserve") == 0)
    {
        __result = chromatix_dpp10_reserve.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "chromatix_dpp10_core") == 0)
    {
        __result = chromatix_dpp10_core.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatix_dpp10Type::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "control_variables") == 0)
    {
        __result = control_variables.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "control_method") == 0)
    {
        __result = control_method.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "chromatix_dpp10_reserve") == 0)
    {
        __result = chromatix_dpp10_reserve.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "chromatix_dpp10_core") == 0)
    {
        __result = chromatix_dpp10_core.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatix_dpp10Type::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // module_version
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("module_version", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetInfo(&__path[__pos], __info);
    }

    // parameter_version
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("parameter_version", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.GetInfo(&__path[__pos], __info);
    }

    // control_variables
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("control_variables", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "control_variables") == 0)
    {
        __result = control_variables.GetInfo(&__path[__pos], __info);
    }

    // control_method
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("control_method", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "control_method") == 0)
    {
        __result = control_method.GetInfo(&__path[__pos], __info);
    }

    // chromatix_dpp10_reserve
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("chromatix_dpp10_reserve", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "chromatix_dpp10_reserve") == 0)
    {
        __result = chromatix_dpp10_reserve.GetInfo(&__path[__pos], __info);
    }

    // chromatix_dpp10_core
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("chromatix_dpp10_core", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "chromatix_dpp10_core") == 0)
    {
        __result = chromatix_dpp10_core.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool chromatix_dpp10Type::module_versionStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "major_revision") == 0)
    {
        ParameterUtils::DoubleToString((double)major_revision, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minor_revision") == 0)
    {
        ParameterUtils::DoubleToString((double)minor_revision, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "incr_revision") == 0)
    {
        ParameterUtils::DoubleToString((double)incr_revision, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatix_dpp10Type::module_versionStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "major_revision") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            major_revision = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minor_revision") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minor_revision = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "incr_revision") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            incr_revision = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatix_dpp10Type::module_versionStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // major_revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("major_revision", ParameterParserDataType::Int32, (double)major_revision, 0));
    }
    else if (PARAMETER_STRCMP(__name, "major_revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)major_revision, 0));
    }

    // minor_revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("minor_revision", ParameterParserDataType::Int32, (double)minor_revision, 0));
    }
    else if (PARAMETER_STRCMP(__name, "minor_revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)minor_revision, 0));
    }

    // incr_revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("incr_revision", ParameterParserDataType::Int32, (double)incr_revision, 0));
    }
    else if (PARAMETER_STRCMP(__name, "incr_revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)incr_revision, 0));
    }

    return __result;
}

bool chromatix_dpp10Type::parameter_versionStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "revision") == 0)
    {
        PARAMETER_STRCPY(__value, __size, revision);
        __result = true;
    }

    return __result;
}

bool chromatix_dpp10Type::parameter_versionStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const /*__value*/)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "revision") == 0)
    {
        // Cannot modify strings, risk of memory leaks or corruption
    }

    return __result;
}

bool chromatix_dpp10Type::parameter_versionStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("revision", ParameterParserDataType::String, revision));
    }
    else if (PARAMETER_STRCMP(__name, "revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::String, revision));
    }

    return __result;
}

bool chromatix_dpp10Type::control_variablesStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "control_var_type") == 0)
    {
        if (__index < 3)
        {
            ParameterUtils::DoubleToString((double)(UINT32)control_var_type[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 3; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)(UINT32)control_var_type[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }

    return __result;
}

bool chromatix_dpp10Type::control_variablesStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "control_var_type") == 0)
    {
        if (__index < 3)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                control_var_type[__index] = (control_var_typeEnum)(UINT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < 3)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    control_var_type[__index] = (control_var_typeEnum)(UINT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool chromatix_dpp10Type::control_variablesStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // control_var_type
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("control_var_type", ParameterParserDataType::Enum, true, false, 3));
    }

    return __result;
}

bool chromatix_dpp10Type::control_methodStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "aec_exp_control") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)aec_exp_control, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aec_hdr_control") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)aec_hdr_control, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatix_dpp10Type::control_methodStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "aec_exp_control") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aec_exp_control = (ispglobalelements::tuning_control_aec_type)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aec_hdr_control") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aec_hdr_control = (ispglobalelements::tuning_control_aec_hdr_type)(UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatix_dpp10Type::control_methodStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // aec_exp_control
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("aec_exp_control", ParameterParserDataType::Enum, (double)(UINT32)aec_exp_control, 0));
    }
    else if (PARAMETER_STRCMP(__name, "aec_exp_control") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)aec_exp_control, 0));
    }

    // aec_hdr_control
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("aec_hdr_control", ParameterParserDataType::Enum, (double)(UINT32)aec_hdr_control, 0));
    }
    else if (PARAMETER_STRCMP(__name, "aec_hdr_control") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)aec_hdr_control, 0));
    }

    return __result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10Type::control_variablesStruct::ReadEnum_control_var_typeEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_lux_idx):
            enumValue = chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_lux_idx;
            result    = true;
            break;
        case static_cast<UINT32>(chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_gain):
            enumValue = chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_gain;
            result    = true;
            break;
        case static_cast<UINT32>(chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_exp_time_ratio):
            enumValue = chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_exp_time_ratio;
            result    = true;
            break;
        case static_cast<UINT32>(chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_aec_exp_sensitivity_ratio):
            enumValue = chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_aec_exp_sensitivity_ratio;
            result    = true;
            break;
        case static_cast<UINT32>(chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_exp_gain_ratio):
            enumValue = chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_exp_gain_ratio;
            result    = true;
            break;
        case static_cast<UINT32>(chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_pre_scale_ratio):
            enumValue = chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum::control_pre_scale_ratio;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatix_dpp10Type::control_variablesStruct::control_var_typeEnum", uintValue);
            break;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatix_dpp10TypeClass::chromatix_dpp10TypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(control_variables);
    PARAMETER_INITIALIZE(control_method);
    PARAMETER_INITIALIZE(chromatix_dpp10_reserve);
    PARAMETER_INITIALIZE(chromatix_dpp10_core);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatix_dpp10TypeClass::chromatix_dpp10TypeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(control_variables);
    PARAMETER_INITIALIZE(control_method);
    PARAMETER_INITIALIZE(chromatix_dpp10_reserve);
    PARAMETER_INITIALIZE(chromatix_dpp10_core);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Destructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatix_dpp10TypeClass::~chromatix_dpp10TypeClass()
{
    if (Loaded)
    {
        UnloadModule();
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GetName
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CHAR* chromatix_dpp10TypeClass::GetName(
    const CHAR* const type)
{
    const CHAR* name = type;
    CHAR temp[ParameterFileSymbolTableEntry::TYPE_LEN + 1];
    if (PARAMETER_STRCMP(type, ModuleData::GetType(temp, "dpp10_eva")) == 0)
    {
        name = "dpp10_eva";
    }
    return name;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatix_dpp10_reserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10_reserveType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(holes_fill_and_spatial);

    result = holes_fill_and_spatial.Load(entry, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatix_dpp10_reserveType_holes_fill_and_spatialStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10_reserveType::holes_fill_and_spatialStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(adapt_lambda_special_border_section_1);
    PARAMETER_INITIALIZE(adapt_lambda_special_border_section_2);
    PARAMETER_INITIALIZE(special_border_side);
    PARAMETER_INITIALIZE(hf_conf_special_border_close_section);
    PARAMETER_INITIALIZE(hf_special_border_section_1);
    PARAMETER_INITIALIZE(hf_special_border_section_2);
    PARAMETER_INITIALIZE(hf_special_border_section_3);

    SYMBOL_TABLE_ENTRY_READ(entry, result, adapt_lambda_special_border_section_1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, adapt_lambda_special_border_section_2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, special_border_side, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_special_border_close_section, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_special_border_section_1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_special_border_section_2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_special_border_section_3, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(processing_enable);
    PARAMETER_INITIALIZE(common_params);
    PARAMETER_INITIALIZE(pre_processing);
    PARAMETER_INITIALIZE(holes_fill_and_spatial);
    PARAMETER_INITIALIZE(disparity_map_merge);
    PARAMETER_INITIALIZE(tnr);

    result = processing_enable.Load(entry, alignment);
    if (result)
    {
        result = common_params.Load(entry, alignment);
    }
    if (result)
    {
        result = pre_processing.Load(entry, alignment);
    }
    if (result)
    {
        result = holes_fill_and_spatial.Load(entry, alignment);
    }
    if (result)
    {
        result = disparity_map_merge.Load(entry, alignment);
    }
    if (result)
    {
        result = tnr.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_processing_enableStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::processing_enableStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(depth_processing_en);

    SYMBOL_TABLE_ENTRY_READ(entry, result, depth_processing_en, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_common_paramsStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::common_paramsStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(focus_roi_disp_calc_mode);
    PARAMETER_INITIALIZE(focus_roi_disp_calc_param);
    PARAMETER_INITIALIZE(disp_map_range_factor);
    PARAMETER_INITIALIZE(lnr_grid_luma_tab);
    PARAMETER_INITIALIZE(lnr_grid_chroma_tab);
    PARAMETER_INITIALIZE(reserved_param_12);

    SYMBOL_TABLE_ENTRY_READ(entry, result, focus_roi_disp_calc_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, focus_roi_disp_calc_param, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, disp_map_range_factor, alignment)
    if (result)
    {
        result = lnr_grid_luma_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = lnr_grid_chroma_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_12, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_common_paramsStruct_lnr_grid_luma_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_luma_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(lnr_grid_luma);

    result = entry->ReadArray(lnr_grid_luma, 99, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_common_paramsStruct_lnr_grid_chroma_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::common_paramsStruct::lnr_grid_chroma_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(lnr_grid_chroma);

    result = entry->ReadArray(lnr_grid_chroma, 99, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_pre_processingStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::pre_processingStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(pre_processing_en);
    PARAMETER_INITIALIZE(pre_processing_mode);
    PARAMETER_INITIALIZE(pre_processing_func_tab);
    PARAMETER_INITIALIZE(reserved_param_1);
    PARAMETER_INITIALIZE(reserved_param_2);

    SYMBOL_TABLE_ENTRY_READ(entry, result, pre_processing_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pre_processing_mode, alignment)
    if (result)
    {
        result = pre_processing_func_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_2, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_pre_processingStruct_pre_processing_func_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::pre_processingStruct::pre_processing_func_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(pre_processing_func);

    result = entry->ReadArray(pre_processing_func, 129, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_holes_fill_and_spatialStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(spatial_filter_en);
    PARAMETER_INITIALIZE(spatial_filter_mode);
    PARAMETER_INITIALIZE(spatial_filter_sigmas_tab);
    PARAMETER_INITIALIZE(spatial_filter_lambdas_tab);
    PARAMETER_INITIALIZE(spatial_filter_num_iterations);
    PARAMETER_INITIALIZE(post_spatial_filter_en);
    PARAMETER_INITIALIZE(post_spatial_filter_mode);
    PARAMETER_INITIALIZE(adapt_lambda_ens_tab);
    PARAMETER_INITIALIZE(adapt_lambda_modes_tab);
    PARAMETER_INITIALIZE(adapt_lambda_sig_func_tab);
    PARAMETER_INITIALIZE(adapt_lambda_flat_func_tab);
    PARAMETER_INITIALIZE(hf_en);
    PARAMETER_INITIALIZE(hf_mode);
    PARAMETER_INITIALIZE(hf_lambda);
    PARAMETER_INITIALIZE(hf_sigma);
    PARAMETER_INITIALIZE(hf_adapt_lambda_en);
    PARAMETER_INITIALIZE(hf_adapt_lambda_mode);
    PARAMETER_INITIALIZE(hf_conf_special_border_close_hor);
    PARAMETER_INITIALIZE(hf_conf_special_border_close_ver);
    PARAMETER_INITIALIZE(hf_conf_low_thresh);
    PARAMETER_INITIALIZE(hf_conf_high_thresh);
    PARAMETER_INITIALIZE(hf_conf_hist_low);
    PARAMETER_INITIALIZE(hf_conf_hist_high);
    PARAMETER_INITIALIZE(hf_conf_hist_close_hor);
    PARAMETER_INITIALIZE(hf_conf_hist_close_ver);
    PARAMETER_INITIALIZE(hf_and_spatial_chroma_saturation_factor);
    PARAMETER_INITIALIZE(reserved_param_3);
    PARAMETER_INITIALIZE(reserved_param_4);
    PARAMETER_INITIALIZE(reserved_param_5);

    SYMBOL_TABLE_ENTRY_READ(entry, result, spatial_filter_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, spatial_filter_mode, alignment)
    if (result)
    {
        result = spatial_filter_sigmas_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = spatial_filter_lambdas_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, spatial_filter_num_iterations, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, post_spatial_filter_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, post_spatial_filter_mode, alignment)
    if (result)
    {
        result = adapt_lambda_ens_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = adapt_lambda_modes_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = adapt_lambda_sig_func_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = adapt_lambda_flat_func_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_lambda, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_sigma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_adapt_lambda_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_adapt_lambda_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_special_border_close_hor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_special_border_close_ver, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_low_thresh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_high_thresh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_hist_low, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_hist_high, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_hist_close_hor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_conf_hist_close_ver, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hf_and_spatial_chroma_saturation_factor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_3, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_4, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_5, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_holes_fill_and_spatialStruct_spatial_filter_sigmas_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_sigmas_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(spatial_filter_sigmas);

    result = entry->ReadArray(spatial_filter_sigmas, 4, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_holes_fill_and_spatialStruct_spatial_filter_lambdas_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::spatial_filter_lambdas_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(spatial_filter_lambdas);

    result = entry->ReadArray(spatial_filter_lambdas, 4, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_holes_fill_and_spatialStruct_adapt_lambda_ens_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_ens_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(adapt_lambda_ens);

    result = entry->ReadArray(adapt_lambda_ens, 4, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_holes_fill_and_spatialStruct_adapt_lambda_modes_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_modes_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(adapt_lambda_modes);

    result = entry->ReadArray(adapt_lambda_modes, 4, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_holes_fill_and_spatialStruct_adapt_lambda_sig_func_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_sig_func_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(adapt_lambda_sig_func);

    result = entry->ReadArray(adapt_lambda_sig_func, 17, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_holes_fill_and_spatialStruct_adapt_lambda_flat_func_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::holes_fill_and_spatialStruct::adapt_lambda_flat_func_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(adapt_lambda_flat_func);

    result = entry->ReadArray(adapt_lambda_flat_func, 17, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_disparity_map_mergeStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::disparity_map_mergeStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(pd_merge_en);
    PARAMETER_INITIALIZE(pd_merge_mode);
    PARAMETER_INITIALIZE(pd_merge_level);
    PARAMETER_INITIALIZE(pd_map_func_tab);
    PARAMETER_INITIALIZE(reserved_param_6);
    PARAMETER_INITIALIZE(reserved_param_7);
    PARAMETER_INITIALIZE(reserved_param_8);

    SYMBOL_TABLE_ENTRY_READ(entry, result, pd_merge_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pd_merge_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pd_merge_level, alignment)
    if (result)
    {
        result = pd_map_func_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_6, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_7, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_8, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_disparity_map_mergeStruct_pd_map_func_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::disparity_map_mergeStruct::pd_map_func_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(pd_map_func);

    result = entry->ReadArray(pd_map_func, 65, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_tnrStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::tnrStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(tnr_en);
    PARAMETER_INITIALIZE(tnr_mode);
    PARAMETER_INITIALIZE(oof_pixels_noise_adj1);
    PARAMETER_INITIALIZE(oof_pixels_noise_adj2);
    PARAMETER_INITIALIZE(alpha_lut_tab);
    PARAMETER_INITIALIZE(luma_noise_low_thr_lut_tab);
    PARAMETER_INITIALIZE(luma_noise_high_thr_lut_tab);
    PARAMETER_INITIALIZE(alpha_post_calc_win_size);
    PARAMETER_INITIALIZE(alpha_post_calc_filter_sigma);
    PARAMETER_INITIALIZE(diff_im_filter_win_size);
    PARAMETER_INITIALIZE(diff_im_filter_sigma_luma);
    PARAMETER_INITIALIZE(diff_im_filter_sigma_chroma);
    PARAMETER_INITIALIZE(chroma_noise_factor);
    PARAMETER_INITIALIZE(boundary_treatment_mode);
    PARAMETER_INITIALIZE(luma_avg_filter_win_size);
    PARAMETER_INITIALIZE(tnr_chroma_saturation_factor);
    PARAMETER_INITIALIZE(diff_map_filter_win_size);
    PARAMETER_INITIALIZE(diff_map_alpha_factor_max);
    PARAMETER_INITIALIZE(diff_map_thr_low);
    PARAMETER_INITIALIZE(diff_map_thr_high);
    PARAMETER_INITIALIZE(reserved_param_9);
    PARAMETER_INITIALIZE(reserved_param_10);
    PARAMETER_INITIALIZE(reserved_param_11);

    SYMBOL_TABLE_ENTRY_READ(entry, result, tnr_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tnr_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, oof_pixels_noise_adj1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, oof_pixels_noise_adj2, alignment)
    if (result)
    {
        result = alpha_lut_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = luma_noise_low_thr_lut_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = luma_noise_high_thr_lut_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, alpha_post_calc_win_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, alpha_post_calc_filter_sigma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_im_filter_win_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_im_filter_sigma_luma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_im_filter_sigma_chroma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, chroma_noise_factor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, boundary_treatment_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, luma_avg_filter_win_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tnr_chroma_saturation_factor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_map_filter_win_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_map_alpha_factor_max, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_map_thr_low, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_map_thr_high, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_9, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_10, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, reserved_param_11, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_tnrStruct_alpha_lut_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::tnrStruct::alpha_lut_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(alpha_lut);

    result = entry->ReadArray(alpha_lut, 65, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_tnrStruct_luma_noise_low_thr_lut_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::tnrStruct::luma_noise_low_thr_lut_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(luma_noise_low_thr_lut);

    result = entry->ReadArray(luma_noise_low_thr_lut, 17, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load dpp10_rgn_dataType_tnrStruct_luma_noise_high_thr_lut_tabStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool dpp10_rgn_dataType::tnrStruct::luma_noise_high_thr_lut_tabStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(luma_noise_high_thr_lut);

    result = entry->ReadArray(luma_noise_high_thr_lut, 17, alignment);

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load mod_dpp10_aec_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool mod_dpp10_aec_dataType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(aec_trigger);
    PARAMETER_INITIALIZE(dpp10_rgn_data);

    result = aec_trigger.Load(entry, alignment);
    if (result)
    {
        result = dpp10_rgn_data.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load mod_dpp10_hdr_aec_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool mod_dpp10_hdr_aec_dataType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(hdr_aec_trigger);
    PARAMETER_INITIALIZE(hdr_aec_data);

    result = hdr_aec_trigger.Load(entry, alignment);
    if (result)
    {
        result = hdr_aec_data.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load mod_dpp10_hdr_aec_dataType_hdr_aec_dataStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool mod_dpp10_hdr_aec_dataType::hdr_aec_dataStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(mod_dpp10_aec_data);


    // Reading Array mod_dpp10_aec_data from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        mod_dpp10_aec_dataCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, mod_dpp10_aec_dataCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            mod_dpp10_aec_dataID = pointerEntry->ID;
            DupObjInfo* mod_dpp10_aec_dataDupInfo = pointerEntry->GetDupObject(mod_dpp10_aec_dataCount, file, line);
            if (mod_dpp10_aec_dataDupInfo != nullptr && mod_dpp10_aec_dataDupInfo->Object != nullptr)
            {
                mod_dpp10_aec_data = (mod_dpp10_aec_dataType*)mod_dpp10_aec_dataDupInfo->Object;
                if (mod_dpp10_aec_data == nullptr)
                {
                    if (mod_dpp10_aec_dataDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "mod_dpp10_aec_data duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            mod_dpp10_aec_dataDupInfo->File, mod_dpp10_aec_dataDupInfo->Line, mod_dpp10_aec_dataDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "mod_dpp10_aec_data duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            mod_dpp10_aec_dataDupInfo->Line, mod_dpp10_aec_dataDupInfo->RefCount);
                    }
                }
            }

            if (mod_dpp10_aec_data == nullptr)
            {
                if (result && mod_dpp10_aec_dataCount > 0)
                {
                    mod_dpp10_aec_data = PARAMETER_NEW mod_dpp10_aec_dataType[mod_dpp10_aec_dataCount];
                    (void)pointerEntry->SetDupObject(mod_dpp10_aec_data, mod_dpp10_aec_dataCount, file, line);
                }
                if (!result || mod_dpp10_aec_data == nullptr)
                {
                    if (mod_dpp10_aec_dataCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate mod_dpp10_aec_data\n");
                    }
                    mod_dpp10_aec_dataCount = 0;
                }
                for (UINT32 i = 0; result && i < mod_dpp10_aec_dataCount; i++)
                {
                    result = mod_dpp10_aec_data[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (mod_dpp10_aec_data == nullptr)
        {
            mod_dpp10_aec_dataCount = 0;
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load mod_dpp10_pre_scale_ratio_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool mod_dpp10_pre_scale_ratio_dataType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(pre_scale_ratio_trigger);
    PARAMETER_INITIALIZE(pre_scale_ratio_data);

    result = pre_scale_ratio_trigger.Load(entry, alignment);
    if (result)
    {
        result = pre_scale_ratio_data.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load mod_dpp10_pre_scale_ratio_dataType_pre_scale_ratio_dataStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool mod_dpp10_pre_scale_ratio_dataType::pre_scale_ratio_dataStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(mod_dpp10_hdr_aec_data);


    // Reading Array mod_dpp10_hdr_aec_data from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        mod_dpp10_hdr_aec_dataCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, mod_dpp10_hdr_aec_dataCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            mod_dpp10_hdr_aec_dataID = pointerEntry->ID;
            DupObjInfo* mod_dpp10_hdr_aec_dataDupInfo = pointerEntry->GetDupObject(mod_dpp10_hdr_aec_dataCount, file, line);
            if (mod_dpp10_hdr_aec_dataDupInfo != nullptr && mod_dpp10_hdr_aec_dataDupInfo->Object != nullptr)
            {
                mod_dpp10_hdr_aec_data = (mod_dpp10_hdr_aec_dataType*)mod_dpp10_hdr_aec_dataDupInfo->Object;
                if (mod_dpp10_hdr_aec_data == nullptr)
                {
                    if (mod_dpp10_hdr_aec_dataDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "mod_dpp10_hdr_aec_data duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            mod_dpp10_hdr_aec_dataDupInfo->File, mod_dpp10_hdr_aec_dataDupInfo->Line, mod_dpp10_hdr_aec_dataDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "mod_dpp10_hdr_aec_data duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            mod_dpp10_hdr_aec_dataDupInfo->Line, mod_dpp10_hdr_aec_dataDupInfo->RefCount);
                    }
                }
            }

            if (mod_dpp10_hdr_aec_data == nullptr)
            {
                if (result && mod_dpp10_hdr_aec_dataCount > 0)
                {
                    mod_dpp10_hdr_aec_data = PARAMETER_NEW mod_dpp10_hdr_aec_dataType[mod_dpp10_hdr_aec_dataCount];
                    (void)pointerEntry->SetDupObject(mod_dpp10_hdr_aec_data, mod_dpp10_hdr_aec_dataCount, file, line);
                }
                if (!result || mod_dpp10_hdr_aec_data == nullptr)
                {
                    if (mod_dpp10_hdr_aec_dataCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate mod_dpp10_hdr_aec_data\n");
                    }
                    mod_dpp10_hdr_aec_dataCount = 0;
                }
                for (UINT32 i = 0; result && i < mod_dpp10_hdr_aec_dataCount; i++)
                {
                    result = mod_dpp10_hdr_aec_data[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (mod_dpp10_hdr_aec_data == nullptr)
        {
            mod_dpp10_hdr_aec_dataCount = 0;
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatix_dpp10_coreType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10_coreType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(mod_dpp10_pre_scale_ratio_data);


    // Reading Array mod_dpp10_pre_scale_ratio_data from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        mod_dpp10_pre_scale_ratio_dataCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, mod_dpp10_pre_scale_ratio_dataCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            mod_dpp10_pre_scale_ratio_dataID = pointerEntry->ID;
            DupObjInfo* mod_dpp10_pre_scale_ratio_dataDupInfo = pointerEntry->GetDupObject(mod_dpp10_pre_scale_ratio_dataCount, file, line);
            if (mod_dpp10_pre_scale_ratio_dataDupInfo != nullptr && mod_dpp10_pre_scale_ratio_dataDupInfo->Object != nullptr)
            {
                mod_dpp10_pre_scale_ratio_data = (mod_dpp10_pre_scale_ratio_dataType*)mod_dpp10_pre_scale_ratio_dataDupInfo->Object;
                if (mod_dpp10_pre_scale_ratio_data == nullptr)
                {
                    if (mod_dpp10_pre_scale_ratio_dataDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "mod_dpp10_pre_scale_ratio_data duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            mod_dpp10_pre_scale_ratio_dataDupInfo->File, mod_dpp10_pre_scale_ratio_dataDupInfo->Line, mod_dpp10_pre_scale_ratio_dataDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "mod_dpp10_pre_scale_ratio_data duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            mod_dpp10_pre_scale_ratio_dataDupInfo->Line, mod_dpp10_pre_scale_ratio_dataDupInfo->RefCount);
                    }
                }
            }

            if (mod_dpp10_pre_scale_ratio_data == nullptr)
            {
                if (result && mod_dpp10_pre_scale_ratio_dataCount > 0)
                {
                    mod_dpp10_pre_scale_ratio_data = PARAMETER_NEW mod_dpp10_pre_scale_ratio_dataType[mod_dpp10_pre_scale_ratio_dataCount];
                    (void)pointerEntry->SetDupObject(mod_dpp10_pre_scale_ratio_data, mod_dpp10_pre_scale_ratio_dataCount, file, line);
                }
                if (!result || mod_dpp10_pre_scale_ratio_data == nullptr)
                {
                    if (mod_dpp10_pre_scale_ratio_dataCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate mod_dpp10_pre_scale_ratio_data\n");
                    }
                    mod_dpp10_pre_scale_ratio_dataCount = 0;
                }
                for (UINT32 i = 0; result && i < mod_dpp10_pre_scale_ratio_dataCount; i++)
                {
                    result = mod_dpp10_pre_scale_ratio_data[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (mod_dpp10_pre_scale_ratio_data == nullptr)
        {
            mod_dpp10_pre_scale_ratio_dataCount = 0;
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatix_dpp10Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10Type::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(control_variables);
    PARAMETER_INITIALIZE(control_method);
    PARAMETER_INITIALIZE(chromatix_dpp10_reserve);
    PARAMETER_INITIALIZE(chromatix_dpp10_core);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = control_variables.Load(entry, alignment);
    }
    if (result)
    {
        result = control_method.Load(entry, alignment);
    }
    if (result)
    {
        result = chromatix_dpp10_reserve.Load(entry, alignment);
    }
    if (result)
    {
        result = chromatix_dpp10_core.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10Type::module_versionStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(major_revision);
    PARAMETER_INITIALIZE(minor_revision);
    PARAMETER_INITIALIZE(incr_revision);

    SYMBOL_TABLE_ENTRY_READ(entry, result, major_revision, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minor_revision, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, incr_revision, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load parameter_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10Type::parameter_versionStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(revision);


    // Reading String revision from symbol table
    {
        UINT32 count = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, count, alignment)
        ParameterFileSymbolTableEntry stringPointerEntryCls;
        ParameterFileSymbolTableEntry* const stringPointerEntry = &stringPointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(stringPointerEntryCls, entry, alignment);
        }
        SYMBOL_TABLE_ENTRY_READ_STRING(stringPointerEntry, result, revision, count, alignment)
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load control_variablesStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10Type::control_variablesStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(control_var_type);

    for (UINT32 i = 0; result && i < 3; i++)
    {
        result = chromatix_dpp10Type::control_variablesStruct::ReadEnum_control_var_typeEnum(entry, control_var_type[i], alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load control_methodStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10Type::control_methodStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(aec_exp_control);
    PARAMETER_INITIALIZE(aec_hdr_control);

    result = ispglobalelements::ReadEnum_tuning_control_aec_type(entry, aec_exp_control, alignment);
    if (result)
    {
        result = ispglobalelements::ReadEnum_tuning_control_aec_hdr_type(entry, aec_hdr_control, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload mod_dpp10_hdr_aec_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mod_dpp10_hdr_aec_dataType::Unload(ParameterFileSymbolTable* const __table)
{
    hdr_aec_data.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload mod_dpp10_hdr_aec_dataType_hdr_aec_dataStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mod_dpp10_hdr_aec_dataType::hdr_aec_dataStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(mod_dpp10_aec_data))
    {
        PARAMETER_DELETE[] mod_dpp10_aec_data;
    }
    mod_dpp10_aec_data = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload mod_dpp10_pre_scale_ratio_dataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mod_dpp10_pre_scale_ratio_dataType::Unload(ParameterFileSymbolTable* const __table)
{
    pre_scale_ratio_data.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload mod_dpp10_pre_scale_ratio_dataType_pre_scale_ratio_dataStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mod_dpp10_pre_scale_ratio_dataType::pre_scale_ratio_dataStruct::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < mod_dpp10_hdr_aec_dataCount; i++)
    {
        mod_dpp10_hdr_aec_data[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(mod_dpp10_hdr_aec_data))
    {
        PARAMETER_DELETE[] mod_dpp10_hdr_aec_data;
    }
    mod_dpp10_hdr_aec_data = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatix_dpp10_coreType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_dpp10_coreType::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < mod_dpp10_pre_scale_ratio_dataCount; i++)
    {
        mod_dpp10_pre_scale_ratio_data[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(mod_dpp10_pre_scale_ratio_data))
    {
        PARAMETER_DELETE[] mod_dpp10_pre_scale_ratio_data;
    }
    mod_dpp10_pre_scale_ratio_data = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatix_dpp10Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_dpp10Type::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    chromatix_dpp10_core.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload parameter_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_dpp10Type::parameter_versionStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(revision))
    {
        PARAMETER_DELETE[] revision;
    }
    revision = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Release the ParameterModule object
/// Requires that this object was created via a ParameterSetManager::GetModule call
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_dpp10Type::Release()
{
    ((chromatix_dpp10TypeClass*)this)->Release();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Returns the ParameterModule::Modified value
/// The Modified value is incremented when the module's data or pointer values change
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
UINT32 chromatix_dpp10Type::GetModified()
{
    return ((chromatix_dpp10TypeClass*)this)->Modified;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Create module, and return a new object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ParameterModule* chromatix_dpp10TypeClass::Create(
    ModuleData*    moduleData,
    DefaultModule* const defModule) const
{
    chromatix_dpp10TypeClass* cls = nullptr;

    if (PARAMETER_STRCMP(Type, moduleData->Type) == 0 && Version.Value == moduleData->Version.Value)
    {
        const UINT32 id = moduleData->DuplicateID > 0 ? moduleData->DuplicateID : moduleData->ID;

        ParameterModule* const module = defModule->Find(id);
        if (module != nullptr)
        {
            cls = (chromatix_dpp10TypeClass*)module;
        }
        else
        {
            cls = PARAMETER_NEW chromatix_dpp10TypeClass(GetName(moduleData->Type), moduleData);
            cls->SymbolTableID = id;
            defModule->AddModule((ParameterModule*)cls);
        }
    }
    else if (Version.Value != moduleData->Version.Value)
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatix_dpp10TypeClass, binary version (%lld) does not match source version (%lld)\n",
            moduleData->Version.Value, Version.Value);
    }
    else
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatix_dpp10TypeClass, binary name (%s) does not match source name (%s)\n",
            moduleData->Type, Type);
    }

    return (ParameterModule*)cls;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module data, return true is successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatix_dpp10TypeClass::LoadModule(
    ParameterFileSymbolTable* const table)
{
    bool result = true;

    if (!Loaded)
    {
        BYTE const alignment = table->Alignment;
        chromatix_dpp10TypeClass* const cls = this;

        ParameterFileSymbolTableEntry  entryObj;
        ParameterFileSymbolTableEntry* const entry = &entryObj;
        // With EzTune enabled, the unused upper byte of SymbolTableID value can change, so clear it
        result = table->Find(entryObj, SymbolTableID & 0x00ffffff);

        if (!result)
        {
            PARAMETER_LOG_ERROR(entry->SetManager, "chromatix_dpp10TypeClass::LoadModule Failed to find module ID (%d) in Symbol Table\n", SymbolTableID);
        }

        if (result)
        {
            result = cls->Load(entry, alignment);
        }
        Modified++;
        Loaded = true;
    }

    if (!result)
    {
        /// Module failed to fully load, unload it
        UnloadModule();
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload module data
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_dpp10TypeClass::UnloadModule()
{
    if (Loaded)
    {
        if (Data != nullptr && Data->SymbolTable != nullptr)
        {
            Unload(Data->SymbolTable);
        }
        else
        {
            PARAMETER_LOG_ERROR(Data != nullptr ? Data->SetManager : nullptr, "UnloadModule %s called with nullptr "
                "Data->SymbolTable object\n", Name);
            Unload(nullptr);
        }
        Loaded = false;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// /// Release the ParameterModule object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_dpp10TypeClass::Release()
{
    ParameterModule::Release();
}

DPP_1_0_0_NAMESPACE_END
