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

#include "aecextension.h"
#include "parametersetmanager.h"

AECEXTENSION_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ApertureControlZoneDataType::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, "FNumber") == 0)
    {
        ParameterUtils::DoubleToString((double)FNumber, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "SensitivityFactor") == 0)
    {
        ParameterUtils::DoubleToString((double)SensitivityFactor, __value, __size);
        __result = true;
    }

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool ApertureControlType::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, "enableApertureControl") == 0)
    {
        ParameterUtils::DoubleToString((double)enableApertureControl, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enSettleCntThdforlaunch") == 0)
    {
        ParameterUtils::DoubleToString((double)enSettleCntThdforlaunch, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enSensitivityComp") == 0)
    {
        ParameterUtils::DoubleToString((double)enSensitivityComp, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defaultApertureFNumber") == 0)
    {
        ParameterUtils::DoubleToString((double)defaultApertureFNumber, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "setCntThdforlaunch") == 0)
    {
        ParameterUtils::DoubleToString((double)setCntThdforlaunch, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "SettleCountThd") == 0)
    {
        ParameterUtils::DoubleToString((double)SettleCountThd, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "NumofSkipFrame") == 0)
    {
        ParameterUtils::DoubleToString((double)NumofSkipFrame, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "NumofSkipFrameforSystemlatency") == 0)
    {
        ParameterUtils::DoubleToString((double)NumofSkipFrameforSystemlatency, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ApertureControlZone") == 0)
    {
        if (__index < ApertureControlZoneCount)
        {
            __result = ApertureControlZone[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool ApertureControlType::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, "enableApertureControl") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableApertureControl = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enSettleCntThdforlaunch") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enSettleCntThdforlaunch = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enSensitivityComp") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enSensitivityComp = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defaultApertureFNumber") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defaultApertureFNumber = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "setCntThdforlaunch") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            setCntThdforlaunch = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "SettleCountThd") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            SettleCountThd = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "NumofSkipFrame") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            NumofSkipFrame = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "NumofSkipFrameforSystemlatency") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            NumofSkipFrameforSystemlatency = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ApertureControlZone") == 0)
    {
        if (__index < ApertureControlZoneCount)
        {
            __result = ApertureControlZone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool DualCamType::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, "enableDualCamExpComp") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableDualCamExpComp = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dualCamExpCompMultiplier") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dualCamExpCompMultiplier = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "CCTBasedExpComp") == 0)
    {
        if (__index < CCTBasedExpCompCount)
        {
            __result = CCTBasedExpComp[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool TouchEVSceneChangeType::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, "enableTouchEVScnDet") == 0)
    {
        ParameterUtils::DoubleToString((double)enableTouchEVScnDet, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresLumaDelta") == 0)
    {
        ParameterUtils::DoubleToString((double)thresLumaDelta, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresLumaAvgPct") == 0)
    {
        ParameterUtils::DoubleToString((double)thresLumaAvgPct, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minLumaAvg") == 0)
    {
        ParameterUtils::DoubleToString((double)minLumaAvg, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayBeforeStable") == 0)
    {
        ParameterUtils::DoubleToString((double)frameDelayBeforeStable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "temporalLumaAverageCount") == 0)
    {
        ParameterUtils::DoubleToString((double)temporalLumaAverageCount, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool TouchEVSceneChangeType::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, "enableTouchEVScnDet") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableTouchEVScnDet = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresLumaDelta") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresLumaDelta = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresLumaAvgPct") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresLumaAvgPct = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minLumaAvg") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minLumaAvg = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayBeforeStable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameDelayBeforeStable = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "temporalLumaAverageCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            temporalLumaAverageCount = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

bool YHistStretchZoneDataType::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, "darkBinThres") == 0)
    {
        ParameterUtils::DoubleToString((double)darkBinThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "darkBinThresLow") == 0)
    {
        ParameterUtils::DoubleToString((double)darkBinThresLow, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "satBinThres") == 0)
    {
        ParameterUtils::DoubleToString((double)satBinThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "satBinThresLow") == 0)
    {
        ParameterUtils::DoubleToString((double)satBinThresLow, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "darkTargetLvL") == 0)
    {
        ParameterUtils::DoubleToString((double)darkTargetLvL, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "satTargetLvL") == 0)
    {
        ParameterUtils::DoubleToString((double)satTargetLvL, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "satScalingMax") == 0)
    {
        ParameterUtils::DoubleToString((double)satScalingMax, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "darkClampingMax") == 0)
    {
        ParameterUtils::DoubleToString((double)darkClampingMax, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool YHistStretchZoneDataType::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, "darkBinThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            darkBinThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "darkBinThresLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            darkBinThresLow = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "satBinThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            satBinThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "satBinThresLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            satBinThresLow = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "darkTargetLvL") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            darkTargetLvL = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "satTargetLvL") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            satTargetLvL = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "satScalingMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            satScalingMax = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "darkClampingMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            darkClampingMax = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool YHistStretchType::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, "enableYHistStretch") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableYHistStretch = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tempFilter") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tempFilter = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "yHistStretchZone") == 0)
    {
        if (__index < yHistStretchZoneCount)
        {
            __result = yHistStretchZone[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "YHistStretch") == 0)
    {
        __result = YHistStretch.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "touchEVScnMonitor") == 0)
    {
        __result = touchEVScnMonitor.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "dualCam") == 0)
    {
        __result = dualCam.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enableLVTest") == 0)
    {
        ParameterUtils::DoubleToString((double)enableLVTest, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ApertureControl") == 0)
    {
        __result = ApertureControl.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "YHistStretch") == 0)
    {
        __result = YHistStretch.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "touchEVScnMonitor") == 0)
    {
        __result = touchEVScnMonitor.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "dualCam") == 0)
    {
        __result = dualCam.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enableLVTest") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableLVTest = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ApertureControl") == 0)
    {
        __result = ApertureControl.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AECCoreExtensionTypeClass::AECCoreExtensionTypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(YHistStretch);
    PARAMETER_INITIALIZE(touchEVScnMonitor);
    PARAMETER_INITIALIZE(dualCam);
    PARAMETER_INITIALIZE(enableLVTest);
    PARAMETER_INITIALIZE(ApertureControl);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AECCoreExtensionTypeClass::AECCoreExtensionTypeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(YHistStretch);
    PARAMETER_INITIALIZE(touchEVScnMonitor);
    PARAMETER_INITIALIZE(dualCam);
    PARAMETER_INITIALIZE(enableLVTest);
    PARAMETER_INITIALIZE(ApertureControl);
}

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

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

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

    PARAMETER_INITIALIZE(FNumber);
    PARAMETER_INITIALIZE(SensitivityFactor);

    SYMBOL_TABLE_ENTRY_READ(entry, result, FNumber, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, SensitivityFactor, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

    result = zoneTrigger.Load(entry, alignment);
    if (result)
    {
        result = zoneData.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableApertureControl);
    PARAMETER_INITIALIZE(enSettleCntThdforlaunch);
    PARAMETER_INITIALIZE(enSensitivityComp);
    PARAMETER_INITIALIZE(defaultApertureFNumber);
    PARAMETER_INITIALIZE(setCntThdforlaunch);
    PARAMETER_INITIALIZE(SettleCountThd);
    PARAMETER_INITIALIZE(NumofSkipFrame);
    PARAMETER_INITIALIZE(NumofSkipFrameforSystemlatency);
    PARAMETER_INITIALIZE(ApertureControlZone);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableApertureControl, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enSettleCntThdforlaunch, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enSensitivityComp, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defaultApertureFNumber, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, setCntThdforlaunch, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, SettleCountThd, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, NumofSkipFrame, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, NumofSkipFrameforSystemlatency, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(CCT);
    PARAMETER_INITIALIZE(compensationRatio);

    SYMBOL_TABLE_ENTRY_READ(entry, result, CCT, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, compensationRatio, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enableDualCamExpComp);
    PARAMETER_INITIALIZE(dualCamExpCompMultiplier);
    PARAMETER_INITIALIZE(CCTBasedExpComp);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableDualCamExpComp, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dualCamExpCompMultiplier, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableTouchEVScnDet);
    PARAMETER_INITIALIZE(thresLumaDelta);
    PARAMETER_INITIALIZE(thresLumaAvgPct);
    PARAMETER_INITIALIZE(minLumaAvg);
    PARAMETER_INITIALIZE(frameDelayBeforeStable);
    PARAMETER_INITIALIZE(temporalLumaAverageCount);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableTouchEVScnDet, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresLumaDelta, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresLumaAvgPct, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minLumaAvg, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameDelayBeforeStable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, temporalLumaAverageCount, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(darkBinThres);
    PARAMETER_INITIALIZE(darkBinThresLow);
    PARAMETER_INITIALIZE(satBinThres);
    PARAMETER_INITIALIZE(satBinThresLow);
    PARAMETER_INITIALIZE(darkTargetLvL);
    PARAMETER_INITIALIZE(satTargetLvL);
    PARAMETER_INITIALIZE(satScalingMax);
    PARAMETER_INITIALIZE(darkClampingMax);

    SYMBOL_TABLE_ENTRY_READ(entry, result, darkBinThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, darkBinThresLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, satBinThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, satBinThresLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, darkTargetLvL, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, satTargetLvL, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, satScalingMax, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, darkClampingMax, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

    result = zoneTrigger.Load(entry, alignment);
    if (result)
    {
        result = zoneData.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableYHistStretch);
    PARAMETER_INITIALIZE(tempFilter);
    PARAMETER_INITIALIZE(yHistStretchZone);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableYHistStretch, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tempFilter, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(YHistStretch);
    PARAMETER_INITIALIZE(touchEVScnMonitor);
    PARAMETER_INITIALIZE(dualCam);
    PARAMETER_INITIALIZE(enableLVTest);
    PARAMETER_INITIALIZE(ApertureControl);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = YHistStretch.Load(entry, alignment);
    }
    if (result)
    {
        result = touchEVScnMonitor.Load(entry, alignment);
    }
    if (result)
    {
        result = dualCam.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableLVTest, alignment)
    if (result)
    {
        result = ApertureControl.Load(entry, alignment);
    }

    return result;
}

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(revision);


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

    return result;
}

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AECCoreExtensionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECCoreExtensionType::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    YHistStretch.Unload(__table);
    dualCam.Unload(__table);
    ApertureControl.Unload(__table);
}

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

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

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

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

    return (ParameterModule*)cls;
}

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

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

AECEXTENSION_NAMESPACE_END
