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

#include "shdr_3_0_0.h"
#include "parametersetmanager.h"

SHDR_3_0_0_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool BLC_data_type::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, "BLC_factor") == 0)
    {
        ParameterUtils::DoubleToString((double)BLC_factor, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BLC_up_limit") == 0)
    {
        ParameterUtils::DoubleToString((double)BLC_up_limit, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BLC_reflection_lut") == 0)
    {
        __result = BLC_reflection_lut.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool BLC_data_type::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, "BLC_factor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            BLC_factor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BLC_up_limit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            BLC_up_limit = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BLC_reflection_lut") == 0)
    {
        __result = BLC_reflection_lut.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool BLC_data_type::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);

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

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

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

    return __result;
}

bool BLC_data_type::BLC_reflection_lutStruct::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, "BLC_reflection_lut") == 0)
    {
        if (__index < 32)
        {
            ParameterUtils::DoubleToString((double)BLC_reflection_lut[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 32; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)BLC_reflection_lut[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool BLC_data_type::BLC_reflection_lutStruct::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, "BLC_reflection_lut") == 0)
    {
        if (__index < 32)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                BLC_reflection_lut[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool BLC_data_type::BLC_reflection_lutStruct::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);

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

    return __result;
}

bool Fast_Mode_data_type::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, "FAST_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)FAST_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FAST_hybrid_heavy_percentage") == 0)
    {
        ParameterUtils::DoubleToString((double)FAST_hybrid_heavy_percentage, __value, __size);
        __result = true;
    }

    return __result;
}

bool Fast_Mode_data_type::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, "FAST_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FAST_mode = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FAST_hybrid_heavy_percentage") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FAST_hybrid_heavy_percentage = (float)dblValue; 
        }
    }

    return __result;
}

bool Fast_Mode_data_type::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);

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

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

    return __result;
}

bool Debug_Mode_data_type::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, "ENABLE_DEBUG_MODE") == 0)
    {
        ParameterUtils::DoubleToString((double)ENABLE_DEBUG_MODE, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_debug_pair") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_debug_pair, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool Debug_Mode_data_type::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, "ENABLE_DEBUG_MODE") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ENABLE_DEBUG_MODE = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_debug_pair") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_debug_pair = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool Debug_Mode_data_type::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);

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

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

    return __result;
}

bool Auto_Focus_data_type::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, "AF_IIR_coeff_tab") == 0)
    {
        __result = AF_IIR_coeff_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "AF_FIR_coeff_tab") == 0)
    {
        __result = AF_FIR_coeff_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "AF_reserved") == 0)
    {
        __result = AF_reserved.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool Auto_Focus_data_type::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, "AF_IIR_coeff_tab") == 0)
    {
        __result = AF_IIR_coeff_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "AF_FIR_coeff_tab") == 0)
    {
        __result = AF_FIR_coeff_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "AF_reserved") == 0)
    {
        __result = AF_reserved.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool Auto_Focus_data_type::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);

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

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

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

    return __result;
}

bool Auto_Focus_data_type::AF_IIR_coeff_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, "AF_IIR_coeff") == 0)
    {
        if (__index < 16)
        {
            ParameterUtils::DoubleToString((double)AF_IIR_coeff[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 16; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)AF_IIR_coeff[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool Auto_Focus_data_type::AF_IIR_coeff_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, "AF_IIR_coeff") == 0)
    {
        if (__index < 16)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                AF_IIR_coeff[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool Auto_Focus_data_type::AF_IIR_coeff_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);

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

    return __result;
}

bool Auto_Focus_data_type::AF_FIR_coeff_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, "AF_FIR_coeff") == 0)
    {
        if (__index < 16)
        {
            ParameterUtils::DoubleToString((double)AF_FIR_coeff[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 16; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)AF_FIR_coeff[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool Auto_Focus_data_type::AF_FIR_coeff_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, "AF_FIR_coeff") == 0)
    {
        if (__index < 16)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                AF_FIR_coeff[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool Auto_Focus_data_type::AF_FIR_coeff_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);

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

    return __result;
}

bool Auto_Focus_data_type::AF_reservedStruct::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, "reserved") == 0)
    {
        if (__index < 32)
        {
            ParameterUtils::DoubleToString((double)reserved[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 32; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)reserved[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool Auto_Focus_data_type::AF_reservedStruct::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, "reserved") == 0)
    {
        if (__index < 32)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                reserved[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool Auto_Focus_data_type::AF_reservedStruct::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);

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

    return __result;
}

bool Anti_Banding_data_type::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, "AB_anti_banding_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)AB_anti_banding_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "AB_anti_banding_reserved") == 0)
    {
        __result = AB_anti_banding_reserved.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool Anti_Banding_data_type::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, "AB_anti_banding_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            AB_anti_banding_enable = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "AB_anti_banding_reserved") == 0)
    {
        __result = AB_anti_banding_reserved.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool Anti_Banding_data_type::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);

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

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

    return __result;
}

bool Anti_Banding_data_type::AB_anti_banding_reservedStruct::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, "reserved") == 0)
    {
        if (__index < 16)
        {
            ParameterUtils::DoubleToString((double)reserved[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 16; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)reserved[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool Anti_Banding_data_type::AB_anti_banding_reservedStruct::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, "reserved") == 0)
    {
        if (__index < 16)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                reserved[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool Anti_Banding_data_type::AB_anti_banding_reservedStruct::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);

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

    return __result;
}

bool Detail_Enhancement_data_type::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, "DE_enable_detail_enhancement") == 0)
    {
        ParameterUtils::DoubleToString((double)DE_enable_detail_enhancement, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "DE_luma_adapation_a") == 0)
    {
        ParameterUtils::DoubleToString((double)DE_luma_adapation_a, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "DE_luma_adapation_b") == 0)
    {
        ParameterUtils::DoubleToString((double)DE_luma_adapation_b, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "DE_luma_adapation_c") == 0)
    {
        ParameterUtils::DoubleToString((double)DE_luma_adapation_c, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "DE_regulation_fat_thin") == 0)
    {
        ParameterUtils::DoubleToString((double)DE_regulation_fat_thin, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "DE_regulation_center") == 0)
    {
        ParameterUtils::DoubleToString((double)DE_regulation_center, __value, __size);
        __result = true;
    }

    return __result;
}

bool Detail_Enhancement_data_type::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, "DE_enable_detail_enhancement") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            DE_enable_detail_enhancement = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "DE_luma_adapation_a") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            DE_luma_adapation_a = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "DE_luma_adapation_b") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            DE_luma_adapation_b = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "DE_luma_adapation_c") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            DE_luma_adapation_c = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "DE_regulation_fat_thin") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            DE_regulation_fat_thin = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "DE_regulation_center") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            DE_regulation_center = (float)dblValue; 
        }
    }

    return __result;
}

bool Detail_Enhancement_data_type::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);

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

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

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

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

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

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

    return __result;
}

bool ma_level_based_table_data_type::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, "FUSION_ma_reserved_tables_tab") == 0)
    {
        __result = FUSION_ma_reserved_tables_tab.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool ma_level_based_table_data_type::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, "FUSION_ma_reserved_tables_tab") == 0)
    {
        __result = FUSION_ma_reserved_tables_tab.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool ma_level_based_table_data_type::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);

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

    return __result;
}

bool ma_level_based_table_data_type::FUSION_ma_reserved_tables_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, "FUSION_ma_reserved_tables") == 0)
    {
        if (__index < 64)
        {
            ParameterUtils::DoubleToString((double)FUSION_ma_reserved_tables[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 64; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)FUSION_ma_reserved_tables[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool ma_level_based_table_data_type::FUSION_ma_reserved_tables_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, "FUSION_ma_reserved_tables") == 0)
    {
        if (__index < 64)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                FUSION_ma_reserved_tables[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool ma_level_based_table_data_type::FUSION_ma_reserved_tables_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);

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

    return __result;
}

bool trigger_pt_type_gain::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, "gain_start") == 0)
    {
        ParameterUtils::DoubleToString((double)gain_start, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gain_end") == 0)
    {
        ParameterUtils::DoubleToString((double)gain_end, __value, __size);
        __result = true;
    }

    return __result;
}

bool trigger_pt_type_gain::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, "gain_start") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gain_start = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gain_end") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gain_end = (float)dblValue; 
        }
    }

    return __result;
}

bool trigger_pt_type_gain::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);

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

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

    return __result;
}

bool ma_level_based_trigger_pt_type_gain::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool ma_level_based_trigger_pt_type_gain::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool ma_level_based_trigger_pt_type_gain::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);

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

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

    return __result;
}

bool ma_level_based_trigger_pt_type_exp_ratio::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, "gain_zone") == 0)
    {
        if (__index < gain_zoneCount)
        {
            __result = gain_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool ma_level_based_trigger_pt_type_exp_ratio::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, "gain_zone") == 0)
    {
        if (__index < gain_zoneCount)
        {
            __result = gain_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool ma_level_based_trigger_pt_type_exp_ratio::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);

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

    return __result;
}

bool trigger_pt_type_exp_ratio::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, "exp_ratio_start") == 0)
    {
        ParameterUtils::DoubleToString((double)exp_ratio_start, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "exp_ratio_end") == 0)
    {
        ParameterUtils::DoubleToString((double)exp_ratio_end, __value, __size);
        __result = true;
    }

    return __result;
}

bool trigger_pt_type_exp_ratio::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, "exp_ratio_start") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            exp_ratio_start = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "exp_ratio_end") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            exp_ratio_end = (float)dblValue; 
        }
    }

    return __result;
}

bool trigger_pt_type_exp_ratio::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);

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

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

    return __result;
}

bool ma_level_based_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool ma_level_based_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool ma_level_based_trigger_type::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);

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

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

    return __result;
}

bool me_factor_table_data_type::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, "FUSION_multipass_me_factor") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_multipass_me_factor, __value, __size);
        __result = true;
    }

    return __result;
}

bool me_factor_table_data_type::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, "FUSION_multipass_me_factor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_multipass_me_factor = (float)dblValue; 
        }
    }

    return __result;
}

bool me_factor_table_data_type::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);

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

    return __result;
}

bool me_factor_trigger_pt_type_gain::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool me_factor_trigger_pt_type_gain::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool me_factor_trigger_pt_type_gain::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);

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

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

    return __result;
}

bool me_factor_trigger_pt_type_exp_ratio::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, "gain_zone") == 0)
    {
        if (__index < gain_zoneCount)
        {
            __result = gain_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool me_factor_trigger_pt_type_exp_ratio::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, "gain_zone") == 0)
    {
        if (__index < gain_zoneCount)
        {
            __result = gain_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool me_factor_trigger_pt_type_exp_ratio::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);

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

    return __result;
}

bool me_factor_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool me_factor_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool me_factor_trigger_type::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);

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

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

    return __result;
}

bool diff_threshold_table_data_type::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, "FUSION_ma_diff_th1_exp0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th1_exp0, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th1_exp1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th1_exp1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th1_exp2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th1_exp2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th1_exp3") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th1_exp3, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th2_exp0, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th2_exp1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th2_exp2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp3") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_diff_th2_exp3, __value, __size);
        __result = true;
    }

    return __result;
}

bool diff_threshold_table_data_type::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, "FUSION_ma_diff_th1_exp0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th1_exp0 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th1_exp1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th1_exp1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th1_exp2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th1_exp2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th1_exp3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th1_exp3 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th2_exp0 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th2_exp1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th2_exp2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_diff_th2_exp3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_diff_th2_exp3 = (float)dblValue; 
        }
    }

    return __result;
}

bool diff_threshold_table_data_type::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);

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

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

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

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

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

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

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

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

    return __result;
}

bool diff_threshold_trigger_pt_type_gain::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool diff_threshold_trigger_pt_type_gain::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool diff_threshold_trigger_pt_type_gain::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);

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

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

    return __result;
}

bool diff_threshold_trigger_pt_type_exp_ratio::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, "gain_zone") == 0)
    {
        if (__index < gain_zoneCount)
        {
            __result = gain_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool diff_threshold_trigger_pt_type_exp_ratio::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, "gain_zone") == 0)
    {
        if (__index < gain_zoneCount)
        {
            __result = gain_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool diff_threshold_trigger_pt_type_exp_ratio::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);

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

    return __result;
}

bool diff_threshold_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool diff_threshold_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool diff_threshold_trigger_type::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);

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

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

    return __result;
}

bool luma_threshold_table_data_type::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, "FUSION_ma_luma_th1_exp0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th1_exp0, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th1_exp1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th1_exp1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th1_exp2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th1_exp2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th1_exp3") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th1_exp3, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th2_exp0, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th2_exp1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th2_exp2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp3") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_ma_luma_th2_exp3, __value, __size);
        __result = true;
    }

    return __result;
}

bool luma_threshold_table_data_type::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, "FUSION_ma_luma_th1_exp0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th1_exp0 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th1_exp1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th1_exp1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th1_exp2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th1_exp2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th1_exp3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th1_exp3 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th2_exp0 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th2_exp1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th2_exp2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_ma_luma_th2_exp3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_ma_luma_th2_exp3 = (float)dblValue; 
        }
    }

    return __result;
}

bool luma_threshold_table_data_type::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);

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

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

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

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

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

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

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

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

    return __result;
}

bool luma_threshold_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool luma_threshold_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool luma_threshold_trigger_type::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);

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

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

    return __result;
}

bool Motion_Adaptation_data_type::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, "FUSION_enable_motion_adaptation") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_motion_adaptation, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_morphology_decision") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_morphology_decision, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "luma_threshold_LUT") == 0)
    {
        __result = luma_threshold_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "diff_threshold_LUT") == 0)
    {
        __result = diff_threshold_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "me_factor_LUT") == 0)
    {
        __result = me_factor_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_motion_factor0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_motion_factor0, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_motion_factor1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_motion_factor1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_motion_factor2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_motion_factor2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_blur_factor0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_blur_factor0, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_blur_factor1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_blur_factor1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_blur_factor2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_blur_factor2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_blurring0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_ma_blurring0, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_blurring1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_ma_blurring1, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_blurring2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_ma_blurring2, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_multipass0") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_ma_multipass0, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_multipass1") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_ma_multipass1, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_multipass2") == 0)
    {
        ParameterUtils::DoubleToString((double)FUSION_enable_ma_multipass2, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ma_level_based_LUT") == 0)
    {
        __result = ma_level_based_LUT.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool Motion_Adaptation_data_type::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, "FUSION_enable_motion_adaptation") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_motion_adaptation = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_morphology_decision") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_morphology_decision = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "luma_threshold_LUT") == 0)
    {
        __result = luma_threshold_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "diff_threshold_LUT") == 0)
    {
        __result = diff_threshold_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "me_factor_LUT") == 0)
    {
        __result = me_factor_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_motion_factor0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_motion_factor0 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_motion_factor1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_motion_factor1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_motion_factor2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_motion_factor2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_blur_factor0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_blur_factor0 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_blur_factor1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_blur_factor1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_blur_factor2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_blur_factor2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_blurring0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_ma_blurring0 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_blurring1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_ma_blurring1 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_blurring2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_ma_blurring2 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_multipass0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_ma_multipass0 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_multipass1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_ma_multipass1 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FUSION_enable_ma_multipass2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FUSION_enable_ma_multipass2 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ma_level_based_LUT") == 0)
    {
        __result = ma_level_based_LUT.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool Motion_Adaptation_data_type::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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool Motion_Adaptation_data_type::luma_threshold_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::luma_threshold_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::luma_threshold_LUTStruct::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);

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

    return __result;
}

bool Motion_Adaptation_data_type::diff_threshold_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::diff_threshold_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::diff_threshold_LUTStruct::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);

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

    return __result;
}

bool Motion_Adaptation_data_type::me_factor_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::me_factor_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::me_factor_LUTStruct::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);

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

    return __result;
}

bool Motion_Adaptation_data_type::ma_level_based_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::ma_level_based_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool Motion_Adaptation_data_type::ma_level_based_LUTStruct::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);

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

    return __result;
}

bool desaturate_table_data_type::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, "TM_desat_th") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_desat_th, __value, __size);
        __result = true;
    }

    return __result;
}

bool desaturate_table_data_type::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, "TM_desat_th") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_desat_th = (float)dblValue; 
        }
    }

    return __result;
}

bool desaturate_table_data_type::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);

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

    return __result;
}

bool desaturate_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool desaturate_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool desaturate_trigger_type::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);

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

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

    return __result;
}

bool mingain_table_data_type::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, "TM_mingain") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_mingain, __value, __size);
        __result = true;
    }

    return __result;
}

bool mingain_table_data_type::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, "TM_mingain") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_mingain = (float)dblValue; 
        }
    }

    return __result;
}

bool mingain_table_data_type::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);

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

    return __result;
}

bool mingain_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool mingain_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool mingain_trigger_type::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);

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

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

    return __result;
}

bool maxgain_table_data_type::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, "TM_maxgain") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_maxgain, __value, __size);
        __result = true;
    }

    return __result;
}

bool maxgain_table_data_type::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, "TM_maxgain") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_maxgain = (float)dblValue; 
        }
    }

    return __result;
}

bool maxgain_table_data_type::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);

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

    return __result;
}

bool maxgain_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool maxgain_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool maxgain_trigger_type::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);

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

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

    return __result;
}

bool gamma_table_data_type::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, "TM_pre_gamma") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_pre_gamma, __value, __size);
        __result = true;
    }

    return __result;
}

bool gamma_table_data_type::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, "TM_pre_gamma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_pre_gamma = (float)dblValue; 
        }
    }

    return __result;
}

bool gamma_table_data_type::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);

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

    return __result;
}

bool gamma_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool gamma_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool gamma_trigger_type::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);

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

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

    return __result;
}

bool tone_mapping_table_data_type::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, "TM_boost_strength") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_boost_strength, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_factor") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_factor, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_max_total_gain") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_max_total_gain, __value, __size);
        __result = true;
    }

    return __result;
}

bool tone_mapping_table_data_type::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, "TM_boost_strength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_boost_strength = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_factor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_factor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_max_total_gain") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_max_total_gain = (float)dblValue; 
        }
    }

    return __result;
}

bool tone_mapping_table_data_type::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);

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

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

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

    return __result;
}

bool tone_mapping_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool tone_mapping_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool tone_mapping_trigger_type::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);

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

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

    return __result;
}

bool low_pass_filter_table_data_type::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, "EPLP_eps") == 0)
    {
        ParameterUtils::DoubleToString((double)EPLP_eps, __value, __size);
        __result = true;
    }

    return __result;
}

bool low_pass_filter_table_data_type::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, "EPLP_eps") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            EPLP_eps = (float)dblValue; 
        }
    }

    return __result;
}

bool low_pass_filter_table_data_type::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);

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

    return __result;
}

bool low_pass_filter_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool low_pass_filter_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool low_pass_filter_trigger_type::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);

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

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

    return __result;
}

bool LTM_data_type::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, "down_scale_rate") == 0)
    {
        ParameterUtils::DoubleToString((double)down_scale_rate, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gpu_LTM_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)gpu_LTM_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "EPLP_sigma") == 0)
    {
        ParameterUtils::DoubleToString((double)EPLP_sigma, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "EPLP_radius") == 0)
    {
        ParameterUtils::DoubleToString((double)EPLP_radius, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "low_pass_filter_LUT") == 0)
    {
        __result = low_pass_filter_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "EPLP_iterations") == 0)
    {
        ParameterUtils::DoubleToString((double)EPLP_iterations, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_gamma") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_gamma, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_gamma_region") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_gamma_region, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_alpha") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_alpha, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_highlight_compression_strength") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_highlight_compression_strength, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tone_mapping_LUT") == 0)
    {
        __result = tone_mapping_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "gamma_LUT") == 0)
    {
        __result = gamma_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "maxgain_LUT") == 0)
    {
        __result = maxgain_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "mingain_LUT") == 0)
    {
        __result = mingain_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "TM_method") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_method, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "desaturate_LUT") == 0)
    {
        __result = desaturate_LUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "TM_detail_smoothing_weight_pass_full") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_detail_smoothing_weight_pass_full, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_detail_smoothing_weight_pass_dc4") == 0)
    {
        ParameterUtils::DoubleToString((double)TM_detail_smoothing_weight_pass_dc4, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TM_reserved") == 0)
    {
        __result = TM_reserved.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool LTM_data_type::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, "down_scale_rate") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            down_scale_rate = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gpu_LTM_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gpu_LTM_enable = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "EPLP_sigma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            EPLP_sigma = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "EPLP_radius") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            EPLP_radius = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "low_pass_filter_LUT") == 0)
    {
        __result = low_pass_filter_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "EPLP_iterations") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            EPLP_iterations = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_gamma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_gamma = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_gamma_region") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_gamma_region = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_alpha") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_alpha = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_highlight_compression_strength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_highlight_compression_strength = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tone_mapping_LUT") == 0)
    {
        __result = tone_mapping_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "gamma_LUT") == 0)
    {
        __result = gamma_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "maxgain_LUT") == 0)
    {
        __result = maxgain_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "mingain_LUT") == 0)
    {
        __result = mingain_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "TM_method") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_method = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "desaturate_LUT") == 0)
    {
        __result = desaturate_LUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "TM_detail_smoothing_weight_pass_full") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_detail_smoothing_weight_pass_full = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_detail_smoothing_weight_pass_dc4") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TM_detail_smoothing_weight_pass_dc4 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TM_reserved") == 0)
    {
        __result = TM_reserved.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool LTM_data_type::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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool LTM_data_type::low_pass_filter_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool LTM_data_type::low_pass_filter_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool LTM_data_type::low_pass_filter_LUTStruct::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);

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

    return __result;
}

bool LTM_data_type::tone_mapping_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool LTM_data_type::tone_mapping_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool LTM_data_type::tone_mapping_LUTStruct::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);

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

    return __result;
}

bool LTM_data_type::gamma_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool LTM_data_type::gamma_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool LTM_data_type::gamma_LUTStruct::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);

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

    return __result;
}

bool LTM_data_type::maxgain_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool LTM_data_type::maxgain_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool LTM_data_type::maxgain_LUTStruct::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);

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

    return __result;
}

bool LTM_data_type::mingain_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool LTM_data_type::mingain_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool LTM_data_type::mingain_LUTStruct::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);

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

    return __result;
}

bool LTM_data_type::desaturate_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool LTM_data_type::desaturate_LUTStruct::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, "exp_ratio_zone") == 0)
    {
        if (__index < exp_ratio_zoneCount)
        {
            __result = exp_ratio_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool LTM_data_type::desaturate_LUTStruct::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);

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

    return __result;
}

bool LTM_data_type::TM_reservedStruct::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, "reserved") == 0)
    {
        if (__index < 32)
        {
            ParameterUtils::DoubleToString((double)reserved[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 32; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)reserved[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool LTM_data_type::TM_reservedStruct::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, "reserved") == 0)
    {
        if (__index < 32)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                reserved[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool LTM_data_type::TM_reservedStruct::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);

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

    return __result;
}

bool autoLTM_table_data_type::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, "autoLTM3_max_gain_limit") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_max_gain_limit, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_center") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_center, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_region") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_region, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_pre_weight") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_pre_weight, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_boost_upper_bound") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_boost_upper_bound, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_boost_lower_bound") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_boost_lower_bound, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_dark_start") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_dark_start, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_dark_end") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_dark_end, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_midtone_start") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_midtone_start, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_midtone_end") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_midtone_end, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_highlight_start") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_highlight_start, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_highlight_end") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_highlight_end, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool autoLTM_table_data_type::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, "autoLTM3_max_gain_limit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_max_gain_limit = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_center") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_center = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_region") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_region = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_pre_weight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_pre_weight = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_boost_upper_bound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_boost_upper_bound = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_boost_lower_bound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_boost_lower_bound = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_dark_start") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_dark_start = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_dark_end") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_dark_end = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_midtone_start") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_midtone_start = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_midtone_end") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_midtone_end = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_highlight_start") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_highlight_start = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM3_highlight_end") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_highlight_end = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool autoLTM_table_data_type::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);

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool trigger_pt_type_lux_idx::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, "lux_idx_start") == 0)
    {
        ParameterUtils::DoubleToString((double)lux_idx_start, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lux_idx_end") == 0)
    {
        ParameterUtils::DoubleToString((double)lux_idx_end, __value, __size);
        __result = true;
    }

    return __result;
}

bool trigger_pt_type_lux_idx::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, "lux_idx_start") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lux_idx_start = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lux_idx_end") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lux_idx_end = (float)dblValue; 
        }
    }

    return __result;
}

bool trigger_pt_type_lux_idx::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);

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

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

    return __result;
}

bool autoLTM_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool autoLTM_trigger_type::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, "zone_trigger") == 0)
    {
        __result = zone_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zone") == 0)
    {
        __result = zone.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool autoLTM_trigger_type::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);

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

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

    return __result;
}

bool AutoLTM_data_type::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, "autoLTM3_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)autoLTM3_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM_LUT") == 0)
    {
        __result = autoLTM_LUT.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool AutoLTM_data_type::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, "autoLTM3_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            autoLTM3_enable = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "autoLTM_LUT") == 0)
    {
        __result = autoLTM_LUT.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool AutoLTM_data_type::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);

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

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

    return __result;
}

bool AutoLTM_data_type::autoLTM_LUTStruct::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, "lux_idx_zone") == 0)
    {
        if (__index < lux_idx_zoneCount)
        {
            __result = lux_idx_zone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool AutoLTM_data_type::autoLTM_LUTStruct::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, "lux_idx_zone") == 0)
    {
        if (__index < lux_idx_zoneCount)
        {
            __result = lux_idx_zone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool AutoLTM_data_type::autoLTM_LUTStruct::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);

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

    return __result;
}

bool Bayer_Proc_data_type::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, "num_exposure") == 0)
    {
        ParameterUtils::DoubleToString((double)num_exposure, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "input_frame_format") == 0)
    {
        ParameterUtils::DoubleToString((double)input_frame_format, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool Bayer_Proc_data_type::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, "num_exposure") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_exposure = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "input_frame_format") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            input_frame_format = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool Bayer_Proc_data_type::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);

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

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

    return __result;
}

bool shdr30Type::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, "enable_section") == 0)
    {
        __result = enable_section.GetValue(&__path[__pos], __value, __size);
    }
    else 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, "Bayer_Proc") == 0)
    {
        __result = Bayer_Proc.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "AutoLTM") == 0)
    {
        __result = AutoLTM.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "LTM") == 0)
    {
        __result = LTM.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "Motion_Adaptation") == 0)
    {
        __result = Motion_Adaptation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "Detail_Enhancement") == 0)
    {
        __result = Detail_Enhancement.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "Anti_Banding") == 0)
    {
        __result = Anti_Banding.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "Auto_Focus") == 0)
    {
        __result = Auto_Focus.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "DEBUG_MODE") == 0)
    {
        __result = DEBUG_MODE.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "Fast_Mode") == 0)
    {
        __result = Fast_Mode.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "BLC") == 0)
    {
        __result = BLC.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool shdr30Type::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, "enable_section") == 0)
    {
        __result = enable_section.SetValue(&__path[__pos], __value);
    }
    else 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, "Bayer_Proc") == 0)
    {
        __result = Bayer_Proc.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "AutoLTM") == 0)
    {
        __result = AutoLTM.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "LTM") == 0)
    {
        __result = LTM.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "Motion_Adaptation") == 0)
    {
        __result = Motion_Adaptation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "Detail_Enhancement") == 0)
    {
        __result = Detail_Enhancement.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "Anti_Banding") == 0)
    {
        __result = Anti_Banding.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "Auto_Focus") == 0)
    {
        __result = Auto_Focus.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "DEBUG_MODE") == 0)
    {
        __result = DEBUG_MODE.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "Fast_Mode") == 0)
    {
        __result = Fast_Mode.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "BLC") == 0)
    {
        __result = BLC.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool shdr30Type::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);

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool shdr30Type::enable_sectionStruct::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, "shdr_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)shdr_enable, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool shdr30Type::enable_sectionStruct::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, "shdr_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            shdr_enable = (globalelements::enable_flag_type)dblValue; 
        }
    }

    return __result;
}

bool shdr30Type::enable_sectionStruct::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);

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

    return __result;
}

bool shdr30Type::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 shdr30Type::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 shdr30Type::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 shdr30Type::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 shdr30Type::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 shdr30Type::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;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
shdr30TypeClass::shdr30TypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(enable_section);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(Bayer_Proc);
    PARAMETER_INITIALIZE(AutoLTM);
    PARAMETER_INITIALIZE(LTM);
    PARAMETER_INITIALIZE(Motion_Adaptation);
    PARAMETER_INITIALIZE(Detail_Enhancement);
    PARAMETER_INITIALIZE(Anti_Banding);
    PARAMETER_INITIALIZE(Auto_Focus);
    PARAMETER_INITIALIZE(DEBUG_MODE);
    PARAMETER_INITIALIZE(Fast_Mode);
    PARAMETER_INITIALIZE(BLC);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
shdr30TypeClass::shdr30TypeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(enable_section);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(Bayer_Proc);
    PARAMETER_INITIALIZE(AutoLTM);
    PARAMETER_INITIALIZE(LTM);
    PARAMETER_INITIALIZE(Motion_Adaptation);
    PARAMETER_INITIALIZE(Detail_Enhancement);
    PARAMETER_INITIALIZE(Anti_Banding);
    PARAMETER_INITIALIZE(Auto_Focus);
    PARAMETER_INITIALIZE(DEBUG_MODE);
    PARAMETER_INITIALIZE(Fast_Mode);
    PARAMETER_INITIALIZE(BLC);
}

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

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

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

    PARAMETER_INITIALIZE(BLC_factor);
    PARAMETER_INITIALIZE(BLC_up_limit);
    PARAMETER_INITIALIZE(BLC_reflection_lut);

    SYMBOL_TABLE_ENTRY_READ(entry, result, BLC_factor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, BLC_up_limit, alignment)
    if (result)
    {
        result = BLC_reflection_lut.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(BLC_reflection_lut);

    result = entry->ReadArray(BLC_reflection_lut, 32, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(FAST_mode);
    PARAMETER_INITIALIZE(FAST_hybrid_heavy_percentage);

    SYMBOL_TABLE_ENTRY_READ(entry, result, FAST_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FAST_hybrid_heavy_percentage, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(ENABLE_DEBUG_MODE);
    PARAMETER_INITIALIZE(FUSION_enable_debug_pair);

    SYMBOL_TABLE_ENTRY_READ(entry, result, ENABLE_DEBUG_MODE, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_debug_pair, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(AF_IIR_coeff_tab);
    PARAMETER_INITIALIZE(AF_FIR_coeff_tab);
    PARAMETER_INITIALIZE(AF_reserved);

    result = AF_IIR_coeff_tab.Load(entry, alignment);
    if (result)
    {
        result = AF_FIR_coeff_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = AF_reserved.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(AF_IIR_coeff);

    result = entry->ReadArray(AF_IIR_coeff, 16, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(AF_FIR_coeff);

    result = entry->ReadArray(AF_FIR_coeff, 16, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(reserved);

    result = entry->ReadArray(reserved, 32, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(AB_anti_banding_enable);
    PARAMETER_INITIALIZE(AB_anti_banding_reserved);

    SYMBOL_TABLE_ENTRY_READ(entry, result, AB_anti_banding_enable, alignment)
    if (result)
    {
        result = AB_anti_banding_reserved.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(reserved);

    result = entry->ReadArray(reserved, 16, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(DE_enable_detail_enhancement);
    PARAMETER_INITIALIZE(DE_luma_adapation_a);
    PARAMETER_INITIALIZE(DE_luma_adapation_b);
    PARAMETER_INITIALIZE(DE_luma_adapation_c);
    PARAMETER_INITIALIZE(DE_regulation_fat_thin);
    PARAMETER_INITIALIZE(DE_regulation_center);

    SYMBOL_TABLE_ENTRY_READ(entry, result, DE_enable_detail_enhancement, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, DE_luma_adapation_a, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, DE_luma_adapation_b, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, DE_luma_adapation_c, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, DE_regulation_fat_thin, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, DE_regulation_center, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(FUSION_ma_reserved_tables_tab);

    result = FUSION_ma_reserved_tables_tab.Load(entry, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(FUSION_ma_reserved_tables);

    result = entry->ReadArray(FUSION_ma_reserved_tables, 64, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(gain_start);
    PARAMETER_INITIALIZE(gain_end);

    SYMBOL_TABLE_ENTRY_READ(entry, result, gain_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gain_end, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(gain_zone);


    // Reading Array gain_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        gain_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, gain_zoneCount, 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)
        {
            gain_zoneID = pointerEntry->ID;
            DupObjInfo* gain_zoneDupInfo = pointerEntry->GetDupObject(gain_zoneCount, file, line);
            if (gain_zoneDupInfo != nullptr && gain_zoneDupInfo->Object != nullptr)
            {
                gain_zone = (ma_level_based_trigger_pt_type_gain*)gain_zoneDupInfo->Object;
                if (gain_zone == nullptr)
                {
                    if (gain_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gain_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            gain_zoneDupInfo->File, gain_zoneDupInfo->Line, gain_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gain_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            gain_zoneDupInfo->Line, gain_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_start);
    PARAMETER_INITIALIZE(exp_ratio_end);

    SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_end, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(FUSION_multipass_me_factor);

    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_multipass_me_factor, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(gain_zone);


    // Reading Array gain_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        gain_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, gain_zoneCount, 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)
        {
            gain_zoneID = pointerEntry->ID;
            DupObjInfo* gain_zoneDupInfo = pointerEntry->GetDupObject(gain_zoneCount, file, line);
            if (gain_zoneDupInfo != nullptr && gain_zoneDupInfo->Object != nullptr)
            {
                gain_zone = (me_factor_trigger_pt_type_gain*)gain_zoneDupInfo->Object;
                if (gain_zone == nullptr)
                {
                    if (gain_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gain_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            gain_zoneDupInfo->File, gain_zoneDupInfo->Line, gain_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gain_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            gain_zoneDupInfo->Line, gain_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(FUSION_ma_diff_th1_exp0);
    PARAMETER_INITIALIZE(FUSION_ma_diff_th1_exp1);
    PARAMETER_INITIALIZE(FUSION_ma_diff_th1_exp2);
    PARAMETER_INITIALIZE(FUSION_ma_diff_th1_exp3);
    PARAMETER_INITIALIZE(FUSION_ma_diff_th2_exp0);
    PARAMETER_INITIALIZE(FUSION_ma_diff_th2_exp1);
    PARAMETER_INITIALIZE(FUSION_ma_diff_th2_exp2);
    PARAMETER_INITIALIZE(FUSION_ma_diff_th2_exp3);

    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th1_exp0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th1_exp1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th1_exp2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th1_exp3, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th2_exp0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th2_exp1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th2_exp2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_diff_th2_exp3, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(gain_zone);


    // Reading Array gain_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        gain_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, gain_zoneCount, 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)
        {
            gain_zoneID = pointerEntry->ID;
            DupObjInfo* gain_zoneDupInfo = pointerEntry->GetDupObject(gain_zoneCount, file, line);
            if (gain_zoneDupInfo != nullptr && gain_zoneDupInfo->Object != nullptr)
            {
                gain_zone = (diff_threshold_trigger_pt_type_gain*)gain_zoneDupInfo->Object;
                if (gain_zone == nullptr)
                {
                    if (gain_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gain_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            gain_zoneDupInfo->File, gain_zoneDupInfo->Line, gain_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gain_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            gain_zoneDupInfo->Line, gain_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(FUSION_ma_luma_th1_exp0);
    PARAMETER_INITIALIZE(FUSION_ma_luma_th1_exp1);
    PARAMETER_INITIALIZE(FUSION_ma_luma_th1_exp2);
    PARAMETER_INITIALIZE(FUSION_ma_luma_th1_exp3);
    PARAMETER_INITIALIZE(FUSION_ma_luma_th2_exp0);
    PARAMETER_INITIALIZE(FUSION_ma_luma_th2_exp1);
    PARAMETER_INITIALIZE(FUSION_ma_luma_th2_exp2);
    PARAMETER_INITIALIZE(FUSION_ma_luma_th2_exp3);

    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th1_exp0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th1_exp1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th1_exp2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th1_exp3, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th2_exp0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th2_exp1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th2_exp2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_ma_luma_th2_exp3, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(FUSION_enable_motion_adaptation);
    PARAMETER_INITIALIZE(FUSION_morphology_decision);
    PARAMETER_INITIALIZE(luma_threshold_LUT);
    PARAMETER_INITIALIZE(diff_threshold_LUT);
    PARAMETER_INITIALIZE(me_factor_LUT);
    PARAMETER_INITIALIZE(FUSION_motion_factor0);
    PARAMETER_INITIALIZE(FUSION_motion_factor1);
    PARAMETER_INITIALIZE(FUSION_motion_factor2);
    PARAMETER_INITIALIZE(FUSION_blur_factor0);
    PARAMETER_INITIALIZE(FUSION_blur_factor1);
    PARAMETER_INITIALIZE(FUSION_blur_factor2);
    PARAMETER_INITIALIZE(FUSION_enable_ma_blurring0);
    PARAMETER_INITIALIZE(FUSION_enable_ma_blurring1);
    PARAMETER_INITIALIZE(FUSION_enable_ma_blurring2);
    PARAMETER_INITIALIZE(FUSION_enable_ma_multipass0);
    PARAMETER_INITIALIZE(FUSION_enable_ma_multipass1);
    PARAMETER_INITIALIZE(FUSION_enable_ma_multipass2);
    PARAMETER_INITIALIZE(ma_level_based_LUT);

    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_motion_adaptation, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_morphology_decision, alignment)
    if (result)
    {
        result = luma_threshold_LUT.Load(entry, alignment);
    }
    if (result)
    {
        result = diff_threshold_LUT.Load(entry, alignment);
    }
    if (result)
    {
        result = me_factor_LUT.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_motion_factor0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_motion_factor1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_motion_factor2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_blur_factor0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_blur_factor1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_blur_factor2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_ma_blurring0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_ma_blurring1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_ma_blurring2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_ma_multipass0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_ma_multipass1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FUSION_enable_ma_multipass2, alignment)
    if (result)
    {
        result = ma_level_based_LUT.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (luma_threshold_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (diff_threshold_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (me_factor_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (ma_level_based_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(TM_desat_th);

    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_desat_th, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(TM_mingain);

    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_mingain, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(TM_maxgain);

    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_maxgain, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(TM_pre_gamma);

    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_pre_gamma, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(TM_boost_strength);
    PARAMETER_INITIALIZE(TM_factor);
    PARAMETER_INITIALIZE(TM_max_total_gain);

    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_boost_strength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_factor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_max_total_gain, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(EPLP_eps);

    SYMBOL_TABLE_ENTRY_READ(entry, result, EPLP_eps, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(down_scale_rate);
    PARAMETER_INITIALIZE(gpu_LTM_enable);
    PARAMETER_INITIALIZE(EPLP_sigma);
    PARAMETER_INITIALIZE(EPLP_radius);
    PARAMETER_INITIALIZE(low_pass_filter_LUT);
    PARAMETER_INITIALIZE(EPLP_iterations);
    PARAMETER_INITIALIZE(TM_gamma);
    PARAMETER_INITIALIZE(TM_gamma_region);
    PARAMETER_INITIALIZE(TM_alpha);
    PARAMETER_INITIALIZE(TM_highlight_compression_strength);
    PARAMETER_INITIALIZE(tone_mapping_LUT);
    PARAMETER_INITIALIZE(gamma_LUT);
    PARAMETER_INITIALIZE(maxgain_LUT);
    PARAMETER_INITIALIZE(mingain_LUT);
    PARAMETER_INITIALIZE(TM_method);
    PARAMETER_INITIALIZE(desaturate_LUT);
    PARAMETER_INITIALIZE(TM_detail_smoothing_weight_pass_full);
    PARAMETER_INITIALIZE(TM_detail_smoothing_weight_pass_dc4);
    PARAMETER_INITIALIZE(TM_reserved);

    SYMBOL_TABLE_ENTRY_READ(entry, result, down_scale_rate, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gpu_LTM_enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, EPLP_sigma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, EPLP_radius, alignment)
    if (result)
    {
        result = low_pass_filter_LUT.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, EPLP_iterations, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_gamma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_gamma_region, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_alpha, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_highlight_compression_strength, alignment)
    if (result)
    {
        result = tone_mapping_LUT.Load(entry, alignment);
    }
    if (result)
    {
        result = gamma_LUT.Load(entry, alignment);
    }
    if (result)
    {
        result = maxgain_LUT.Load(entry, alignment);
    }
    if (result)
    {
        result = mingain_LUT.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_method, alignment)
    if (result)
    {
        result = desaturate_LUT.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_detail_smoothing_weight_pass_full, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TM_detail_smoothing_weight_pass_dc4, alignment)
    if (result)
    {
        result = TM_reserved.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (low_pass_filter_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (tone_mapping_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (gamma_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (maxgain_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (mingain_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(exp_ratio_zone);


    // Reading Array exp_ratio_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        exp_ratio_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, exp_ratio_zoneCount, 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)
        {
            exp_ratio_zoneID = pointerEntry->ID;
            DupObjInfo* exp_ratio_zoneDupInfo = pointerEntry->GetDupObject(exp_ratio_zoneCount, file, line);
            if (exp_ratio_zoneDupInfo != nullptr && exp_ratio_zoneDupInfo->Object != nullptr)
            {
                exp_ratio_zone = (desaturate_trigger_type*)exp_ratio_zoneDupInfo->Object;
                if (exp_ratio_zone == nullptr)
                {
                    if (exp_ratio_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->File, exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "exp_ratio_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            exp_ratio_zoneDupInfo->Line, exp_ratio_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(reserved);

    result = entry->ReadArray(reserved, 32, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(autoLTM3_max_gain_limit);
    PARAMETER_INITIALIZE(autoLTM3_center);
    PARAMETER_INITIALIZE(autoLTM3_region);
    PARAMETER_INITIALIZE(autoLTM3_pre_weight);
    PARAMETER_INITIALIZE(autoLTM3_boost_upper_bound);
    PARAMETER_INITIALIZE(autoLTM3_boost_lower_bound);
    PARAMETER_INITIALIZE(autoLTM3_dark_start);
    PARAMETER_INITIALIZE(autoLTM3_dark_end);
    PARAMETER_INITIALIZE(autoLTM3_midtone_start);
    PARAMETER_INITIALIZE(autoLTM3_midtone_end);
    PARAMETER_INITIALIZE(autoLTM3_highlight_start);
    PARAMETER_INITIALIZE(autoLTM3_highlight_end);

    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_max_gain_limit, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_center, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_region, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_pre_weight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_boost_upper_bound, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_boost_lower_bound, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_dark_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_dark_end, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_midtone_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_midtone_end, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_highlight_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_highlight_end, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(lux_idx_start);
    PARAMETER_INITIALIZE(lux_idx_end);

    SYMBOL_TABLE_ENTRY_READ(entry, result, lux_idx_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, lux_idx_end, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zone_trigger);
    PARAMETER_INITIALIZE(zone);

    result = zone_trigger.Load(entry, alignment);
    if (result)
    {
        result = zone.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(autoLTM3_enable);
    PARAMETER_INITIALIZE(autoLTM_LUT);

    SYMBOL_TABLE_ENTRY_READ(entry, result, autoLTM3_enable, alignment)
    if (result)
    {
        result = autoLTM_LUT.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(lux_idx_zone);


    // Reading Array lux_idx_zone from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        lux_idx_zoneCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, lux_idx_zoneCount, 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)
        {
            lux_idx_zoneID = pointerEntry->ID;
            DupObjInfo* lux_idx_zoneDupInfo = pointerEntry->GetDupObject(lux_idx_zoneCount, file, line);
            if (lux_idx_zoneDupInfo != nullptr && lux_idx_zoneDupInfo->Object != nullptr)
            {
                lux_idx_zone = (autoLTM_trigger_type*)lux_idx_zoneDupInfo->Object;
                if (lux_idx_zone == nullptr)
                {
                    if (lux_idx_zoneDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "lux_idx_zone duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            lux_idx_zoneDupInfo->File, lux_idx_zoneDupInfo->Line, lux_idx_zoneDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "lux_idx_zone duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            lux_idx_zoneDupInfo->Line, lux_idx_zoneDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(num_exposure);
    PARAMETER_INITIALIZE(input_frame_format);

    SYMBOL_TABLE_ENTRY_READ(entry, result, num_exposure, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, input_frame_format, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable_section);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(Bayer_Proc);
    PARAMETER_INITIALIZE(AutoLTM);
    PARAMETER_INITIALIZE(LTM);
    PARAMETER_INITIALIZE(Motion_Adaptation);
    PARAMETER_INITIALIZE(Detail_Enhancement);
    PARAMETER_INITIALIZE(Anti_Banding);
    PARAMETER_INITIALIZE(Auto_Focus);
    PARAMETER_INITIALIZE(DEBUG_MODE);
    PARAMETER_INITIALIZE(Fast_Mode);
    PARAMETER_INITIALIZE(BLC);

    result = enable_section.Load(entry, alignment);
    if (result)
    {
        result = module_version.Load(entry, alignment);
    }
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = Bayer_Proc.Load(entry, alignment);
    }
    if (result)
    {
        result = AutoLTM.Load(entry, alignment);
    }
    if (result)
    {
        result = LTM.Load(entry, alignment);
    }
    if (result)
    {
        result = Motion_Adaptation.Load(entry, alignment);
    }
    if (result)
    {
        result = Detail_Enhancement.Load(entry, alignment);
    }
    if (result)
    {
        result = Anti_Banding.Load(entry, alignment);
    }
    if (result)
    {
        result = Auto_Focus.Load(entry, alignment);
    }
    if (result)
    {
        result = DEBUG_MODE.Load(entry, alignment);
    }
    if (result)
    {
        result = Fast_Mode.Load(entry, alignment);
    }
    if (result)
    {
        result = BLC.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(shdr_enable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, shdr_enable, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool shdr30Type::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 shdr30Type::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;
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload ma_level_based_trigger_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ma_level_based_trigger_type::Unload(ParameterFileSymbolTable* const __table)
{
    zone.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload me_factor_trigger_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void me_factor_trigger_type::Unload(ParameterFileSymbolTable* const __table)
{
    zone.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload diff_threshold_trigger_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void diff_threshold_trigger_type::Unload(ParameterFileSymbolTable* const __table)
{
    zone.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload Motion_Adaptation_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Motion_Adaptation_data_type::Unload(ParameterFileSymbolTable* const __table)
{
    luma_threshold_LUT.Unload(__table);
    diff_threshold_LUT.Unload(__table);
    me_factor_LUT.Unload(__table);
    ma_level_based_LUT.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload Motion_Adaptation_data_type_luma_threshold_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Motion_Adaptation_data_type::luma_threshold_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload Motion_Adaptation_data_type_diff_threshold_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Motion_Adaptation_data_type::diff_threshold_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < exp_ratio_zoneCount; i++)
    {
        exp_ratio_zone[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload Motion_Adaptation_data_type_me_factor_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Motion_Adaptation_data_type::me_factor_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < exp_ratio_zoneCount; i++)
    {
        exp_ratio_zone[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload Motion_Adaptation_data_type_ma_level_based_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Motion_Adaptation_data_type::ma_level_based_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < exp_ratio_zoneCount; i++)
    {
        exp_ratio_zone[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LTM_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LTM_data_type::Unload(ParameterFileSymbolTable* const __table)
{
    low_pass_filter_LUT.Unload(__table);
    tone_mapping_LUT.Unload(__table);
    gamma_LUT.Unload(__table);
    maxgain_LUT.Unload(__table);
    mingain_LUT.Unload(__table);
    desaturate_LUT.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LTM_data_type_low_pass_filter_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LTM_data_type::low_pass_filter_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LTM_data_type_tone_mapping_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LTM_data_type::tone_mapping_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LTM_data_type_gamma_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LTM_data_type::gamma_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LTM_data_type_maxgain_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LTM_data_type::maxgain_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LTM_data_type_mingain_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LTM_data_type::mingain_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LTM_data_type_desaturate_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LTM_data_type::desaturate_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(exp_ratio_zone))
    {
        PARAMETER_DELETE[] exp_ratio_zone;
    }
    exp_ratio_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AutoLTM_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AutoLTM_data_type::Unload(ParameterFileSymbolTable* const __table)
{
    autoLTM_LUT.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AutoLTM_data_type_autoLTM_LUTStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AutoLTM_data_type::autoLTM_LUTStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(lux_idx_zone))
    {
        PARAMETER_DELETE[] lux_idx_zone;
    }
    lux_idx_zone = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload shdr30Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void shdr30Type::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    AutoLTM.Unload(__table);
    LTM.Unload(__table);
    Motion_Adaptation.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload parameter_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void shdr30Type::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 shdr30Type::Release()
{
    ((shdr30TypeClass*)this)->Release();
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Create module, and return a new object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ParameterModule* shdr30TypeClass::Create(
    ModuleData*    moduleData,
    DefaultModule* const defModule) const
{
    shdr30TypeClass* 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 = (shdr30TypeClass*)module;
        }
        else
        {
            cls = PARAMETER_NEW shdr30TypeClass(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 shdr30TypeClass, binary version (%lld) does not match source version (%lld)\n",
            moduleData->Version.Value, Version.Value);
    }
    else
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create shdr30TypeClass, binary name (%s) does not match source name (%s)\n",
            moduleData->Type, Type);
    }

    return (ParameterModule*)cls;
}

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

    if (!Loaded)
    {
        BYTE const alignment = table->Alignment;
        shdr30TypeClass* 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, "shdr30TypeClass::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 shdr30TypeClass::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 shdr30TypeClass::Release()
{
    ParameterModule::Release();
}

SHDR_3_0_0_NAMESPACE_END
