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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  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
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                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;

    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;

    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;

    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
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                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;

    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;

    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;

    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;

    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;

    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;

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

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(InterpolationType::Off):
            enumValue = InterpolationType::Off;
            result    = true;
            break;
        case static_cast<UINT32>(InterpolationType::Linear):
            enumValue = InterpolationType::Linear;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to InterpolationType", uintValue);
            break;
        }
    }
    return result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(DownscaleType::Off):
            enumValue = DownscaleType::Off;
            result    = true;
            break;
        case static_cast<UINT32>(DownscaleType::Avg2):
            enumValue = DownscaleType::Avg2;
            result    = true;
            break;
        case static_cast<UINT32>(DownscaleType::Avg4):
            enumValue = DownscaleType::Avg4;
            result    = true;
            break;
        case static_cast<UINT32>(DownscaleType::SubSample2):
            enumValue = DownscaleType::SubSample2;
            result    = true;
            break;
        case static_cast<UINT32>(DownscaleType::SubSample4):
            enumValue = DownscaleType::SubSample4;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to DownscaleType", uintValue);
            break;
        }
    }
    return result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(FilterType::Freq):
            enumValue = FilterType::Freq;
            result    = true;
            break;
        case static_cast<UINT32>(FilterType::Offset):
            enumValue = FilterType::Offset;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to FilterType", uintValue);
            break;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
afdFlickerCorrectionTypeClass::afdFlickerCorrectionTypeClass(
    const CHAR* const 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* const 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();
    }
}

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

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

    PARAMETER_INITIALIZE(ID);
    PARAMETER_INITIALIZE(Name);
    PARAMETER_INITIALIZE(enableFlag);
    PARAMETER_INITIALIZE(data);
    PARAMETER_INITIALIZE(extension);

    SYMBOL_TABLE_ENTRY_READ(entry, result, ID, alignment)

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

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

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

            if (data == nullptr)
            {
                if (result && dataCount > 0)
                {
                    data = pointerEntry->ReadArray<float>(dataCount, alignment);
                    result = data != nullptr;
                }
                if (!result || data == nullptr)
                {
                    if (dataCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate data\n");
                    }
                    dataCount = 0;
                }
            }
        }
        if (data == nullptr)
        {
            dataCount = 0;
        }
    }

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

        if (result)
        {
            extensionID = pointerEntry->ID;
            DupObjInfo* extensionDupInfo = pointerEntry->GetDupObject(extensionCount, file, line);
            if (extensionDupInfo != nullptr && extensionDupInfo->Object != nullptr)
            {
                extension = (afcglobalelements::ExtensionTriggerType*)extensionDupInfo->Object;
                if (extension == nullptr)
                {
                    if (extensionDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "extension duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            extensionDupInfo->File, extensionDupInfo->Line, extensionDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "extension duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            extensionDupInfo->Line, extensionDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(bitDepth);
    PARAMETER_INITIALIZE(LUTSize);
    PARAMETER_INITIALIZE(interpolation);
    PARAMETER_INITIALIZE(dataScreening);

    SYMBOL_TABLE_ENTRY_READ(entry, result, bitDepth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, LUTSize, alignment)
    if (result)
    {
        result = afdFlickerCorrection::ReadEnum_InterpolationType(entry, interpolation, alignment);
    }
    if (result)
    {
        result = dataScreening.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(startupBlendFactor);
    PARAMETER_INITIALIZE(blendFactor);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, startupBlendFactor, alignment)
    if (result)
    {
        result = blendFactor.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(fpsPercentThreshold);
    PARAMETER_INITIALIZE(phaseThreshold);
    PARAMETER_INITIALIZE(maxStrength);
    PARAMETER_INITIALIZE(minStrength);

    SYMBOL_TABLE_ENTRY_READ(entry, result, fpsPercentThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, phaseThreshold, alignment)
    if (result)
    {
        result = maxStrength.Load(entry, alignment);
    }
    if (result)
    {
        result = minStrength.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(trigger);
    PARAMETER_INITIALIZE(numSamples);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = afcglobalelements::ReadEnum_TriggerType(entry, type, alignment);
    }
    if (result)
    {
        result = trigger.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, numSamples, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(size);
    PARAMETER_INITIALIZE(runTriggers);
    PARAMETER_INITIALIZE(snapshotConsistencyTh);
    PARAMETER_INITIALIZE(timeStampWeight);
    PARAMETER_INITIALIZE(confidenceWeight);
    PARAMETER_INITIALIZE(shiftWeight);
    PARAMETER_INITIALIZE(strengthBlendWeight);
    PARAMETER_INITIALIZE(hysterisThreshold);
    PARAMETER_INITIALIZE(validation);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, size, alignment)

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

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

            if (runTriggers == nullptr)
            {
                if (result && runTriggersCount > 0)
                {
                    runTriggers = PARAMETER_NEW TriggerConfigType[runTriggersCount];
                    (void)pointerEntry->SetDupObject(runTriggers, runTriggersCount, file, line);
                }
                if (!result || runTriggers == nullptr)
                {
                    if (runTriggersCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate runTriggers\n");
                    }
                    runTriggersCount = 0;
                }
                for (UINT32 i = 0; result && i < runTriggersCount; i++)
                {
                    result = runTriggers[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (runTriggers == nullptr)
        {
            runTriggersCount = 0;
        }
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, snapshotConsistencyTh, alignment)
    if (result)
    {
        result = timeStampWeight.Load(entry, alignment);
    }
    if (result)
    {
        result = confidenceWeight.Load(entry, alignment);
    }
    if (result)
    {
        result = shiftWeight.Load(entry, alignment);
    }
    if (result)
    {
        result = strengthBlendWeight.Load(entry, alignment);
    }
    if (result)
    {
        result = hysterisThreshold.Load(entry, alignment);
    }
    if (result)
    {
        result = validation.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(maxStrengthSTD);
    PARAMETER_INITIALIZE(maxPhaseSTD);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxStrengthSTD, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxPhaseSTD, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(filterID);
    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(numFrames);
    PARAMETER_INITIALIZE(numFramesInterval);
    PARAMETER_INITIALIZE(downScale);
    PARAMETER_INITIALIZE(filterLUT);
    PARAMETER_INITIALIZE(data);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, filterID, alignment)
    if (result)
    {
        result = afdFlickerCorrection::ReadEnum_FilterType(entry, type, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, numFrames, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numFramesInterval, alignment)
    if (result)
    {
        result = afdFlickerCorrection::ReadEnum_DownscaleType(entry, downScale, alignment);
    }
    if (result)
    {
        result = filterLUT.Load(entry, alignment);
    }

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

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

            if (data == nullptr)
            {
                if (result && dataCount > 0)
                {
                    data = pointerEntry->ReadArray<float>(dataCount, alignment);
                    result = data != nullptr;
                }
                if (!result || data == nullptr)
                {
                    if (dataCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate data\n");
                    }
                    dataCount = 0;
                }
            }
        }
        if (data == nullptr)
        {
            dataCount = 0;
        }
    }

    return result;
}

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

    PARAMETER_INITIALIZE(minConfidence);
    PARAMETER_INITIALIZE(minDataPoints);
    PARAMETER_INITIALIZE(flickerAnalyzers);
    PARAMETER_INITIALIZE(decisionAggregation);
    PARAMETER_INITIALIZE(estimationAggregation);
    PARAMETER_INITIALIZE(estimationValidation);
    PARAMETER_INITIALIZE(strengthAdjust);

    result = minConfidence.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, minDataPoints, alignment)

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(threshold);
    PARAMETER_INITIALIZE(edgeCount);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, edgeCount, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(validThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = validThreshold.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(rowDSFactor);
    PARAMETER_INITIALIZE(colDSFactor);
    PARAMETER_INITIALIZE(segmentConfig);
    PARAMETER_INITIALIZE(statsScreening);
    PARAMETER_INITIALIZE(statsCorrection);

    SYMBOL_TABLE_ENTRY_READ(entry, result, rowDSFactor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, colDSFactor, alignment)
    if (result)
    {
        result = segmentConfig.Load(entry, alignment);
    }
    if (result)
    {
        result = statsScreening.Load(entry, alignment);
    }
    if (result)
    {
        result = statsCorrection.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(runSkip);
    PARAMETER_INITIALIZE(runTriggers);
    PARAMETER_INITIALIZE(sceneChangeTriggers);
    PARAMETER_INITIALIZE(stableCountThreshold);
    PARAMETER_INITIALIZE(minExposureTime);
    PARAMETER_INITIALIZE(numFlickerMonitorFrames);

    result = runSkip.Load(entry, alignment);

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

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

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

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

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

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

    return result;
}

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

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

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = afcglobalelements::ReadEnum_AFCExposureType(entry, exposure0, alignment);
    }
    if (result)
    {
        result = afcglobalelements::ReadEnum_AFCExposureType(entry, exposure1, alignment);
    }
    if (result)
    {
        result = run.Load(entry, alignment);
    }
    if (result)
    {
        result = statsProcessor.Load(entry, alignment);
    }
    if (result)
    {
        result = estimation.Load(entry, alignment);
    }
    if (result)
    {
        result = temporalAnalyzer.Load(entry, alignment);
    }
    if (result)
    {
        result = temporalConv.Load(entry, alignment);
    }
    if (result)
    {
        result = HWConfig.Load(entry, alignment);
    }

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(correction);

    result = module_version.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)

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

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

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

    return result;
}

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

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

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

    return result;
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// 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)
{
    if (__table != nullptr && __table->ReleaseDupObject(runTriggers))
    {
        PARAMETER_DELETE[] runTriggers;
    }
    runTriggers = nullptr;
    timeStampWeight.Unload(__table);
    confidenceWeight.Unload(__table);
    shiftWeight.Unload(__table);
    strengthBlendWeight.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload EstimationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void EstimationType::Unload(ParameterFileSymbolTable* const __table)
{
    minConfidence.Unload(__table);
    for (UINT32 i = 0; i < flickerAnalyzersCount; i++)
    {
        flickerAnalyzers[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(flickerAnalyzers))
    {
        PARAMETER_DELETE[] flickerAnalyzers;
    }
    flickerAnalyzers = nullptr;
    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);
    if (__table != nullptr && __table->ReleaseDupObject(runTriggers))
    {
        PARAMETER_DELETE[] runTriggers;
    }
    runTriggers = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(sceneChangeTriggers))
    {
        PARAMETER_DELETE[] sceneChangeTriggers;
    }
    sceneChangeTriggers = nullptr;
    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; i < extensionCount; i++)
    {
        extension[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(extension))
    {
        PARAMETER_DELETE[] extension;
    }
    extension = nullptr;
}

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

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

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

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

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

    return (ParameterModule*)cls;
}

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

    if (!Loaded)
    {
        BYTE const alignment = table->Alignment;
        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 & 0x00ffffff);

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

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

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

    return result;
}

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

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

AFDFLICKERCORRECTION_NAMESPACE_END
