////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// All rights reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: Parameter Parser V7.4.1 (8cca6579792b9fcef3bc725ff070c5ec453c7c85)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afdflickercorrection.cpp
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "afdflickercorrection.h"
#include "parametersetmanager.h"

AFDFLICKERCORRECTION_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool AFCExtensionParamType::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, "ID") == 0)
    {
        ParameterUtils::DoubleToString((double)ID, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "Name") == 0)
    {
        PARAMETER_STRCPY(__value, __size, Name);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableFlag") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFlag, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "data") == 0)
    {
        if (__index < dataCount)
        {
            ParameterUtils::DoubleToString((double)data[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < dataCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)data[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "extension") == 0)
    {
        if (__index < extensionCount)
        {
            __result = extension[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool AFCExtensionParamType::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, "ID") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ID = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "Name") == 0)
    {
        // Cannot modify strings, risk of memory leaks or corruption
    }
    else if (PARAMETER_STRCMP(__name, "enableFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFlag = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "data") == 0)
    {
        if (__index < dataCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                data[__index] = (float)dblValue; 
            }
        }
        else
        {
            const SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __valuePos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    data[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "extension") == 0)
    {
        if (__index < extensionCount)
        {
            __result = extension[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool HWConfigType::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, "bitDepth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            bitDepth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LUTSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            LUTSize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "interpolation") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            interpolation = (InterpolationType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dataScreening") == 0)
    {
        __result = dataScreening.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

bool TemporalConvType::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
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool TriggerConfigType::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") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            type = (afcglobalelements::TriggerType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "trigger") == 0)
    {
        __result = trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "numSamples") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numSamples = (INT32)dblValue; 
        }
    }

    return __result;
}

bool TriggerConfigType::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
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

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

    return __result;
}

bool TemporalAnalyzerType::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") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "size") == 0)
    {
        ParameterUtils::DoubleToString((double)size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "runTriggers") == 0)
    {
        if (__index < runTriggersCount)
        {
            __result = runTriggers[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "snapshotConsistencyTh") == 0)
    {
        ParameterUtils::DoubleToString((double)snapshotConsistencyTh, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "timeStampWeight") == 0)
    {
        __result = timeStampWeight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceWeight") == 0)
    {
        __result = confidenceWeight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "shiftWeight") == 0)
    {
        __result = shiftWeight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "strengthBlendWeight") == 0)
    {
        __result = strengthBlendWeight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "hysterisThreshold") == 0)
    {
        __result = hysterisThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "validation") == 0)
    {
        __result = validation.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool TemporalAnalyzerType::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") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            size = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "runTriggers") == 0)
    {
        if (__index < runTriggersCount)
        {
            __result = runTriggers[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "snapshotConsistencyTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            snapshotConsistencyTh = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "timeStampWeight") == 0)
    {
        __result = timeStampWeight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceWeight") == 0)
    {
        __result = confidenceWeight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "shiftWeight") == 0)
    {
        __result = shiftWeight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "strengthBlendWeight") == 0)
    {
        __result = strengthBlendWeight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "hysterisThreshold") == 0)
    {
        __result = hysterisThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "validation") == 0)
    {
        __result = validation.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool TemporalAnalyzerType::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
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

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

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

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

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

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

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

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

    return __result;
}

bool EstimationValidationType::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;

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

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

    return __result;
}

bool EstimationValidationType::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;

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxStrengthSTD") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxStrengthSTD = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxPhaseSTD") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxPhaseSTD = (float)dblValue; 
        }
    }

    return __result;
}

bool EstimationValidationType::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;

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

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

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

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

    return __result;
}

bool FlickerAnalyzerType::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") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "filterID") == 0)
    {
        ParameterUtils::DoubleToString((double)filterID, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "type") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)type, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numFrames") == 0)
    {
        ParameterUtils::DoubleToString((double)numFrames, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numFramesInterval") == 0)
    {
        ParameterUtils::DoubleToString((double)numFramesInterval, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "downScale") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)downScale, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "filterLUT") == 0)
    {
        __result = filterLUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "data") == 0)
    {
        if (__index < dataCount)
        {
            ParameterUtils::DoubleToString((double)data[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < dataCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)data[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool FlickerAnalyzerType::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") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "filterID") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            filterID = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            type = (FilterType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numFrames") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numFrames = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numFramesInterval") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numFramesInterval = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "downScale") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            downScale = (DownscaleType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "filterLUT") == 0)
    {
        __result = filterLUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "data") == 0)
    {
        if (__index < dataCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                data[__index] = (float)dblValue; 
            }
        }
        else
        {
            const SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __valuePos = 0;

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

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

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

    return __result;
}

bool FlickerAnalyzerType::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
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

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

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

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

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

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

    return __result;
}

bool EstimationType::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, "minConfidence") == 0)
    {
        __result = minConfidence.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "minDataPoints") == 0)
    {
        ParameterUtils::DoubleToString((double)minDataPoints, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "flickerAnalyzers") == 0)
    {
        if (__index < flickerAnalyzersCount)
        {
            __result = flickerAnalyzers[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "decisionAggregation") == 0)
    {
        __result = decisionAggregation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "estimationAggregation") == 0)
    {
        __result = estimationAggregation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "estimationValidation") == 0)
    {
        __result = estimationValidation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "strengthAdjust") == 0)
    {
        __result = strengthAdjust.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool EstimationType::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, "minConfidence") == 0)
    {
        __result = minConfidence.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "minDataPoints") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minDataPoints = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "flickerAnalyzers") == 0)
    {
        if (__index < flickerAnalyzersCount)
        {
            __result = flickerAnalyzers[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "decisionAggregation") == 0)
    {
        __result = decisionAggregation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "estimationAggregation") == 0)
    {
        __result = estimationAggregation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "estimationValidation") == 0)
    {
        __result = estimationValidation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "strengthAdjust") == 0)
    {
        __result = strengthAdjust.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

bool StatsCorrectionType::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;

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

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

    return __result;
}

bool StatsCorrectionType::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;

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "edgeCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            edgeCount = (INT32)dblValue; 
        }
    }

    return __result;
}

bool StatsCorrectionType::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;

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

bool StatsScreeningType::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
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

    return __result;
}

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

    return __result;
}

bool StatsProcessorType::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, "rowDSFactor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            rowDSFactor = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "colDSFactor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            colDSFactor = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "segmentConfig") == 0)
    {
        __result = segmentConfig.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statsScreening") == 0)
    {
        __result = statsScreening.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statsCorrection") == 0)
    {
        __result = statsCorrection.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

bool RunType::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, "runSkip") == 0)
    {
        __result = runSkip.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "runTriggers") == 0)
    {
        if (__index < runTriggersCount)
        {
            __result = runTriggers[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "sceneChangeTriggers") == 0)
    {
        if (__index < sceneChangeTriggersCount)
        {
            __result = sceneChangeTriggers[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "stableCountThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)stableCountThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minExposureTime") == 0)
    {
        __result = minExposureTime.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "numFlickerMonitorFrames") == 0)
    {
        ParameterUtils::DoubleToString((double)numFlickerMonitorFrames, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool RunType::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, "runSkip") == 0)
    {
        __result = runSkip.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "runTriggers") == 0)
    {
        if (__index < runTriggersCount)
        {
            __result = runTriggers[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "sceneChangeTriggers") == 0)
    {
        if (__index < sceneChangeTriggersCount)
        {
            __result = sceneChangeTriggers[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "stableCountThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stableCountThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minExposureTime") == 0)
    {
        __result = minExposureTime.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "numFlickerMonitorFrames") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numFlickerMonitorFrames = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

bool CorrectionType::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") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "exposure0") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)exposure0, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "exposure1") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)exposure1, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "run") == 0)
    {
        __result = run.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "statsProcessor") == 0)
    {
        __result = statsProcessor.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "estimation") == 0)
    {
        __result = estimation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "temporalAnalyzer") == 0)
    {
        __result = temporalAnalyzer.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "temporalConv") == 0)
    {
        __result = temporalConv.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "HWConfig") == 0)
    {
        __result = HWConfig.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "extension") == 0)
    {
        if (__index < extensionCount)
        {
            __result = extension[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool CorrectionType::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") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "exposure0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            exposure0 = (afcglobalelements::AFCExposureType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "exposure1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            exposure1 = (afcglobalelements::AFCExposureType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "run") == 0)
    {
        __result = run.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statsProcessor") == 0)
    {
        __result = statsProcessor.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "estimation") == 0)
    {
        __result = estimation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "temporalAnalyzer") == 0)
    {
        __result = temporalAnalyzer.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "temporalConv") == 0)
    {
        __result = temporalConv.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "HWConfig") == 0)
    {
        __result = HWConfig.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "extension") == 0)
    {
        if (__index < extensionCount)
        {
            __result = extension[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool CorrectionType::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
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "correction") == 0)
    {
        if (__index < correctionCount)
        {
            __result = correction[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "correction") == 0)
    {
        if (__index < correctionCount)
        {
            __result = correction[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

bool afdFlickerCorrectionType::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;

    (void)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 afdFlickerCorrectionType::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;

    (void)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 afdFlickerCorrectionType::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;

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
afdFlickerCorrectionTypeClass::afdFlickerCorrectionTypeClass(
    const CHAR* name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(correctionCount);
    PARAMETER_INITIALIZE(correction);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
afdFlickerCorrectionTypeClass::afdFlickerCorrectionTypeClass(
    const CHAR*       name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(correction);
}

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


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load AFCExtensionParamType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AFCExtensionParamType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(ID);
    PARAMETER_INITIALIZE(Name);
    PARAMETER_INITIALIZE(enableFlag);
    PARAMETER_INITIALIZE(dataCount);
    PARAMETER_INITIALIZE(data);
    PARAMETER_INITIALIZE(extensionCount);
    PARAMETER_INITIALIZE(extension);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0x8b3084712c1fb472;
        entry->ReadSimpleTypeFixedArray(&ID, 1, localParams);
        localParams.NameHash = 0xa8a406624050bf0c;
        entry->ReadStringFixedArray(&Name, 1, localParams, __COUNTER__);
        localParams.NameHash = 0x89a1d7b1468113d1;
        entry->ReadSimpleTypeFixedArray(&enableFlag, 1, localParams);
        localParams.NameHash = 0x8c93b82417321453;
        entry->ReadSimpleTypeArray(data, dataCount, dataID, 1,
            localParams, __COUNTER__);
        localParams.NameHash = 0x929b223f44ba9c17;
        entry->ReadStructureArray(extension, extensionCount, extensionID, 1, localParams, __COUNTER__);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void AFCExtensionParamType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        AFCExtensionParamType* arrayPtr = (AFCExtensionParamType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* AFCExtensionParamType::AllocArray(
    UINT32 __count)
{
    AFCExtensionParamType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW AFCExtensionParamType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load HWConfigType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void HWConfigType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(bitDepth);
    PARAMETER_INITIALIZE(LUTSize);
    PARAMETER_INITIALIZE(interpolation);
    PARAMETER_INITIALIZE(dataScreening);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xaab439c4c2ada27b;
        entry->ReadSimpleTypeFixedArray(&bitDepth, 1, localParams);
        localParams.NameHash = 0x8551f6a075e941af;
        entry->ReadSimpleTypeFixedArray(&LUTSize, 1, localParams);
        localParams.NameHash = 0xe08235a683de4819;
        entry->ReadEnumFixedArray(&interpolation, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xb9e5503857feb85c;
        dataScreening.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void HWConfigType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        HWConfigType* arrayPtr = (HWConfigType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* HWConfigType::AllocArray(
    UINT32 __count)
{
    HWConfigType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW HWConfigType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load TemporalConvType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TemporalConvType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(startupBlendFactor);
    PARAMETER_INITIALIZE(blendFactor);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xd482c00cbe42eb05;
        entry->ReadSimpleTypeFixedArray(&startupBlendFactor, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x90323259c407dfdc;
        blendFactor.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void TemporalConvType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        TemporalConvType* arrayPtr = (TemporalConvType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* TemporalConvType::AllocArray(
    UINT32 __count)
{
    TemporalConvType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW TemporalConvType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load TemporalValidationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TemporalValidationType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(fpsPercentThreshold);
    PARAMETER_INITIALIZE(phaseThreshold);
    PARAMETER_INITIALIZE(maxStrength);
    PARAMETER_INITIALIZE(minStrength);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0x8b5789c667a1cb7e;
        entry->ReadSimpleTypeFixedArray(&fpsPercentThreshold, 1, localParams);
        localParams.NameHash = 0xd7d1a8ad26bfe0a8;
        entry->ReadSimpleTypeFixedArray(&phaseThreshold, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xbfd8886081d3a220;
        maxStrength.Load(localParams);
        localParams.NameHash        = 0x81b40abd3e4e0865;
        minStrength.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void TemporalValidationType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        TemporalValidationType* arrayPtr = (TemporalValidationType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* TemporalValidationType::AllocArray(
    UINT32 __count)
{
    TemporalValidationType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW TemporalValidationType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load TriggerConfigType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TriggerConfigType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(trigger);
    PARAMETER_INITIALIZE(numSamples);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xd7a23f43d1e0d686;
        entry->ReadEnumFixedArray(&type, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x9d162d4c268294aa;
        trigger.Load(localParams);
        localParams.NameHash = 0xa0ae4bb7c3156ae9;
        entry->ReadSimpleTypeFixedArray(&numSamples, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void TriggerConfigType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        TriggerConfigType* arrayPtr = (TriggerConfigType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* TriggerConfigType::AllocArray(
    UINT32 __count)
{
    TriggerConfigType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW TriggerConfigType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load TemporalAnalyzerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TemporalAnalyzerType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(size);
    PARAMETER_INITIALIZE(runTriggersCount);
    PARAMETER_INITIALIZE(runTriggers);
    PARAMETER_INITIALIZE(snapshotConsistencyTh);
    PARAMETER_INITIALIZE(timeStampWeight);
    PARAMETER_INITIALIZE(confidenceWeight);
    PARAMETER_INITIALIZE(shiftWeight);
    PARAMETER_INITIALIZE(strengthBlendWeight);
    PARAMETER_INITIALIZE(hysterisThreshold);
    PARAMETER_INITIALIZE(validation);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xce93cff176bbb42b;
        entry->ReadSimpleTypeFixedArray(&size, 1, localParams);
        localParams.NameHash = 0xb9172b73ad93a880;
        entry->ReadStructureArray(runTriggers, runTriggersCount, runTriggersID, 4, localParams, __COUNTER__);
        localParams.NameHash = 0xed122a72ab1f58d9;
        entry->ReadSimpleTypeFixedArray(&snapshotConsistencyTh, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x9e6f2a14e21d0b6f;
        timeStampWeight.Load(localParams);
        localParams.NameHash        = 0xf01009fb7e5d1778;
        confidenceWeight.Load(localParams);
        localParams.NameHash        = 0x95d1fdad55056dfb;
        shiftWeight.Load(localParams);
        localParams.NameHash        = 0xf46ed637ba255804;
        strengthBlendWeight.Load(localParams);
        localParams.NameHash        = 0xbe21e89b136eab0d;
        hysterisThreshold.Load(localParams);
        localParams.NameHash        = 0xc464b01600dcc977;
        validation.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void TemporalAnalyzerType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        TemporalAnalyzerType* arrayPtr = (TemporalAnalyzerType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* TemporalAnalyzerType::AllocArray(
    UINT32 __count)
{
    TemporalAnalyzerType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW TemporalAnalyzerType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load EstimationValidationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void EstimationValidationType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(maxStrengthSTD);
    PARAMETER_INITIALIZE(maxPhaseSTD);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xd96db10df7d01d09;
        entry->ReadSimpleTypeFixedArray(&maxStrengthSTD, 1, localParams);
        localParams.NameHash = 0xf322104010358525;
        entry->ReadSimpleTypeFixedArray(&maxPhaseSTD, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void EstimationValidationType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        EstimationValidationType* arrayPtr = (EstimationValidationType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* EstimationValidationType::AllocArray(
    UINT32 __count)
{
    EstimationValidationType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW EstimationValidationType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load FlickerAnalyzerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FlickerAnalyzerType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(filterID);
    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(numFrames);
    PARAMETER_INITIALIZE(numFramesInterval);
    PARAMETER_INITIALIZE(downScale);
    PARAMETER_INITIALIZE(filterLUT);
    PARAMETER_INITIALIZE(dataCount);
    PARAMETER_INITIALIZE(data);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xe35fd5889dabc3d8;
        entry->ReadSimpleTypeFixedArray(&filterID, 1, localParams);
        localParams.NameHash = 0xd7a23f43d1e0d686;
        entry->ReadEnumFixedArray(&type, 1, localParams);
        localParams.NameHash = 0xdbf51f9cd2ecde26;
        entry->ReadSimpleTypeFixedArray(&numFrames, 1, localParams);
        localParams.NameHash = 0x9d777ad970da8211;
        entry->ReadSimpleTypeFixedArray(&numFramesInterval, 1, localParams);
        localParams.NameHash = 0xb285351abc86dabb;
        entry->ReadEnumFixedArray(&downScale, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x83c4b56d989fc6b3;
        filterLUT.Load(localParams);
        localParams.NameHash = 0x8c93b82417321453;
        entry->ReadSimpleTypeArray(data, dataCount, dataID, 2,
            localParams, __COUNTER__);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void FlickerAnalyzerType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        FlickerAnalyzerType* arrayPtr = (FlickerAnalyzerType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* FlickerAnalyzerType::AllocArray(
    UINT32 __count)
{
    FlickerAnalyzerType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW FlickerAnalyzerType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load EstimationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void EstimationType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(minConfidence);
    PARAMETER_INITIALIZE(minDataPoints);
    PARAMETER_INITIALIZE(flickerAnalyzersCount);
    PARAMETER_INITIALIZE(flickerAnalyzers);
    PARAMETER_INITIALIZE(decisionAggregation);
    PARAMETER_INITIALIZE(estimationAggregation);
    PARAMETER_INITIALIZE(estimationValidation);
    PARAMETER_INITIALIZE(strengthAdjust);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xc3c3b776477bbdb4;
        minConfidence.Load(localParams);
        localParams.NameHash = 0xd65d52067dc65a84;
        entry->ReadSimpleTypeFixedArray(&minDataPoints, 1, localParams);
        localParams.NameHash = 0xc64dd34ca82e14b2;
        entry->ReadStructureArray(flickerAnalyzers, flickerAnalyzersCount, flickerAnalyzersID, 2, localParams, __COUNTER__);
        localParams.NameHash        = 0x86450cf489d50e83;
        decisionAggregation.Load(localParams);
        localParams.NameHash        = 0xc05cb84b8a6e4e82;
        estimationAggregation.Load(localParams);
        localParams.NameHash        = 0xad10a80593919581;
        estimationValidation.Load(localParams);
        localParams.NameHash        = 0xfd7a2599c3e681d4;
        strengthAdjust.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void EstimationType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        EstimationType* arrayPtr = (EstimationType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* EstimationType::AllocArray(
    UINT32 __count)
{
    EstimationType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW EstimationType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load StatsCorrectionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void StatsCorrectionType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(threshold);
    PARAMETER_INITIALIZE(edgeCount);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xe04ba95df59bbd7c;
        entry->ReadSimpleTypeFixedArray(&threshold, 1, localParams);
        localParams.NameHash = 0xe8ad61ca5b4f9a08;
        entry->ReadSimpleTypeFixedArray(&edgeCount, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void StatsCorrectionType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        StatsCorrectionType* arrayPtr = (StatsCorrectionType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* StatsCorrectionType::AllocArray(
    UINT32 __count)
{
    StatsCorrectionType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW StatsCorrectionType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load StatsScreeningType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void StatsScreeningType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(validThreshold);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xd16840b2f87a1298;
        validThreshold.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void StatsScreeningType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        StatsScreeningType* arrayPtr = (StatsScreeningType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* StatsScreeningType::AllocArray(
    UINT32 __count)
{
    StatsScreeningType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW StatsScreeningType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load StatsProcessorType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void StatsProcessorType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(rowDSFactor);
    PARAMETER_INITIALIZE(colDSFactor);
    PARAMETER_INITIALIZE(segmentConfig);
    PARAMETER_INITIALIZE(statsScreening);
    PARAMETER_INITIALIZE(statsCorrection);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xa28b9cdcd9920997;
        entry->ReadSimpleTypeFixedArray(&rowDSFactor, 1, localParams);
        localParams.NameHash = 0x9aa59b910e435376;
        entry->ReadSimpleTypeFixedArray(&colDSFactor, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xc2142cf37c1e63e5;
        segmentConfig.Load(localParams);
        localParams.NameHash        = 0x837209969e316497;
        statsScreening.Load(localParams);
        localParams.NameHash        = 0xbfa8d0d115d66e40;
        statsCorrection.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void StatsProcessorType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        StatsProcessorType* arrayPtr = (StatsProcessorType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* StatsProcessorType::AllocArray(
    UINT32 __count)
{
    StatsProcessorType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW StatsProcessorType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load RunType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RunType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(runSkip);
    PARAMETER_INITIALIZE(runTriggersCount);
    PARAMETER_INITIALIZE(runTriggers);
    PARAMETER_INITIALIZE(sceneChangeTriggersCount);
    PARAMETER_INITIALIZE(sceneChangeTriggers);
    PARAMETER_INITIALIZE(stableCountThreshold);
    PARAMETER_INITIALIZE(minExposureTime);
    PARAMETER_INITIALIZE(numFlickerMonitorFrames);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xc8b1247e6eb08cb9;
        runSkip.Load(localParams);
        localParams.NameHash = 0xb9172b73ad93a880;
        entry->ReadStructureArray(runTriggers, runTriggersCount, runTriggersID, 4, localParams, __COUNTER__);
        localParams.NameHash = 0x957f7efe005bb960;
        entry->ReadStructureArray(sceneChangeTriggers, sceneChangeTriggersCount, sceneChangeTriggersID, 5, localParams, __COUNTER__);
        localParams.NameHash = 0xb998c075083d6a28;
        entry->ReadSimpleTypeFixedArray(&stableCountThreshold, 1, localParams);
        localParams.NameHash        = 0x95002381d23edbb1;
        minExposureTime.Load(localParams);
        localParams.NameHash = 0xb8fb3b0877888bea;
        entry->ReadSimpleTypeFixedArray(&numFlickerMonitorFrames, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void RunType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        RunType* arrayPtr = (RunType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* RunType::AllocArray(
    UINT32 __count)
{
    RunType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW RunType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load CorrectionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CorrectionType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(exposure0);
    PARAMETER_INITIALIZE(exposure1);
    PARAMETER_INITIALIZE(run);
    PARAMETER_INITIALIZE(statsProcessor);
    PARAMETER_INITIALIZE(estimation);
    PARAMETER_INITIALIZE(temporalAnalyzer);
    PARAMETER_INITIALIZE(temporalConv);
    PARAMETER_INITIALIZE(HWConfig);
    PARAMETER_INITIALIZE(extensionCount);
    PARAMETER_INITIALIZE(extension);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xb96898e90e604ddb;
        entry->ReadEnumFixedArray(&exposure0, 1, localParams);
        localParams.NameHash = 0x818cf236055be621;
        entry->ReadEnumFixedArray(&exposure1, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xefa8d8aac534e461;
        run.Load(localParams);
        localParams.NameHash        = 0xd1dc3f01e2044ef7;
        statsProcessor.Load(localParams);
        localParams.NameHash        = 0xc93249672e5c79ac;
        estimation.Load(localParams);
        localParams.NameHash        = 0xaa4dbf4eb7a7e067;
        temporalAnalyzer.Load(localParams);
        localParams.NameHash        = 0xc129191220908484;
        temporalConv.Load(localParams);
        localParams.NameHash        = 0xbf6f62ef39e617ba;
        HWConfig.Load(localParams);
        localParams.NameHash = 0x929b223f44ba9c17;
        entry->ReadStructureArray(extension, extensionCount, extensionID, 1, localParams, __COUNTER__);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void CorrectionType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        CorrectionType* arrayPtr = (CorrectionType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* CorrectionType::AllocArray(
    UINT32 __count)
{
    CorrectionType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW CorrectionType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load afdFlickerCorrectionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void afdFlickerCorrectionType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(correctionCount);
    PARAMETER_INITIALIZE(correction);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xe11cd9f365a2599f;
        module_version.Load(localParams);
        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xbf0f405760cefb0f;
        entry->ReadStructureArray(correction, correctionCount, correctionID, 1, localParams, __COUNTER__);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void afdFlickerCorrectionType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        afdFlickerCorrectionType* arrayPtr = (afdFlickerCorrectionType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* afdFlickerCorrectionType::AllocArray(
    UINT32 __count)
{
    afdFlickerCorrectionType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW afdFlickerCorrectionType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void afdFlickerCorrectionType::module_versionStruct::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(major_revision);
    PARAMETER_INITIALIZE(minor_revision);
    PARAMETER_INITIALIZE(incr_revision);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xcd66249477636693;
        entry->ReadSimpleTypeFixedArray(&major_revision, 1, localParams);
        localParams.NameHash = 0xc5497493137a9c25;
        entry->ReadSimpleTypeFixedArray(&minor_revision, 1, localParams);
        localParams.NameHash = 0xb27b8a668efb2a56;
        entry->ReadSimpleTypeFixedArray(&incr_revision, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void afdFlickerCorrectionType::module_versionStruct::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        module_versionStruct* arrayPtr = (module_versionStruct*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* afdFlickerCorrectionType::module_versionStruct::AllocArray(
    UINT32 __count)
{
    module_versionStruct* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW module_versionStruct[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AFCExtensionParamType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AFCExtensionParamType::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, Name);
    ParameterFileSymbolTable::ReleaseObject(__table, data);
    for (UINT32 i = 0; extension != nullptr && i < extensionCount; i++)
    {
        extension[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, extension);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload HWConfigType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void HWConfigType::Unload(ParameterFileSymbolTable* const __table)
{
    dataScreening.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload TemporalConvType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TemporalConvType::Unload(ParameterFileSymbolTable* const __table)
{
    blendFactor.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload TemporalAnalyzerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TemporalAnalyzerType::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, runTriggers);
    timeStampWeight.Unload(__table);
    confidenceWeight.Unload(__table);
    shiftWeight.Unload(__table);
    strengthBlendWeight.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload FlickerAnalyzerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FlickerAnalyzerType::Unload(ParameterFileSymbolTable* const __table)
{
    filterLUT.Unload(__table);
    ParameterFileSymbolTable::ReleaseObject(__table, data);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload EstimationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void EstimationType::Unload(ParameterFileSymbolTable* const __table)
{
    minConfidence.Unload(__table);
    for (UINT32 i = 0; flickerAnalyzers != nullptr && i < flickerAnalyzersCount; i++)
    {
        flickerAnalyzers[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, flickerAnalyzers);
    decisionAggregation.Unload(__table);
    estimationAggregation.Unload(__table);
    strengthAdjust.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload StatsScreeningType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void StatsScreeningType::Unload(ParameterFileSymbolTable* const __table)
{
    validThreshold.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload StatsProcessorType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void StatsProcessorType::Unload(ParameterFileSymbolTable* const __table)
{
    segmentConfig.Unload(__table);
    statsScreening.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload RunType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RunType::Unload(ParameterFileSymbolTable* const __table)
{
    runSkip.Unload(__table);
    ParameterFileSymbolTable::ReleaseObject(__table, runTriggers);
    ParameterFileSymbolTable::ReleaseObject(__table, sceneChangeTriggers);
    minExposureTime.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload CorrectionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CorrectionType::Unload(ParameterFileSymbolTable* const __table)
{
    run.Unload(__table);
    statsProcessor.Unload(__table);
    estimation.Unload(__table);
    temporalAnalyzer.Unload(__table);
    temporalConv.Unload(__table);
    HWConfig.Unload(__table);
    for (UINT32 i = 0; extension != nullptr && i < extensionCount; i++)
    {
        extension[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, extension);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload afdFlickerCorrectionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void afdFlickerCorrectionType::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; correction != nullptr && i < correctionCount; i++)
    {
        correction[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, correction);
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GetModuleName: Returns ParameterModule::Name variable
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CHAR* afdFlickerCorrectionType::GetModuleName()
{
    return ((afdFlickerCorrectionTypeClass*)this)->Name;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GetModuleName: Returns ParameterModule::NameHash variable
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
UINT64 afdFlickerCorrectionType::GetModuleNameHash()
{
    return ((afdFlickerCorrectionTypeClass*)this)->NameHash;
}

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

    if (IsModuleMatch(moduleData) && 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 = (afdFlickerCorrectionTypeClass*)module;
        }
        else
        {
            cls = PARAMETER_NEW afdFlickerCorrectionTypeClass(Name, moduleData);
            cls->SymbolTableID = id;
            defModule->AddModule((ParameterModule*)cls);
        }
    }
    else if (Version.Value != moduleData->Version.Value)
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create afdFlickerCorrectionTypeClass, binary version (%lld) does not match source version (%lld)\n",
            moduleData->Version.Value, Version.Value);
    }
    else
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create afdFlickerCorrectionTypeClass, binary name hash (0x%016llx) does not match source name hash (0x%016llx)\n",
            moduleData->NameHash, NameHash);
    }

    return (ParameterModule*)cls;
}

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

#ifdef PARAMETER_USE_MUTEX
    ParameterMutexLocker lock(Mutex); // Unique LOCK
#endif

    if (!Loaded)
    {
        afdFlickerCorrectionTypeClass* 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 & 0x00ffffffU);

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


        ParameterDefinitionElement* _element = nullptr;
        if (table->ModuleDefinitions != nullptr && !table->ModuleDefinitions->empty())
        {
            _element = table->BuildModuleElement(NameHash);
        }

        ParameterLoadParameters parentParams(entry, NameHash, true, true, _element, entry->Position, 0, ParameterFileSymbolTableEntry::LOAD_LIMIT_MAX);
        cls->Load(parentParams);
        PARAMETER_DELETE _element;
        Modified++;
        Loaded = true;
    }

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

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload module data
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void afdFlickerCorrectionTypeClass::UnloadModule()
{
#ifdef PARAMETER_USE_MUTEX
    ParameterMutexLocker lock(Mutex); // Unique LOCK
#endif

    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 afdFlickerCorrectionTypeClass::Release()
{
    ParameterModule::Release();
}

AFDFLICKERCORRECTION_NAMESPACE_END
