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

#include "afpdlibelements.h"
#include "parametersetmanager.h"

AFPDLIBELEMENTS_NAMESPACE_BEGIN

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

bool chromatixMLPDControlProcess::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, "useRDIPDAF") == 0)
    {
        ParameterUtils::DoubleToString((double)useRDIPDAF, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "mlpdEnabledInHWFlow") == 0)
    {
        ParameterUtils::DoubleToString((double)mlpdEnabledInHWFlow, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "alterLROrder") == 0)
    {
        ParameterUtils::DoubleToString((double)alterLROrder, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "modelNetType") == 0)
    {
        ParameterUtils::DoubleToString((double)modelNetType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gainThLow") == 0)
    {
        ParameterUtils::DoubleToString((double)gainThLow, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gainThHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)gainThHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gainThMax") == 0)
    {
        ParameterUtils::DoubleToString((double)gainThMax, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "expIndexThLow") == 0)
    {
        ParameterUtils::DoubleToString((double)expIndexThLow, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "expIndexThHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)expIndexThHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "expIndexThMax") == 0)
    {
        ParameterUtils::DoubleToString((double)expIndexThMax, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "adrcGainThLow") == 0)
    {
        ParameterUtils::DoubleToString((double)adrcGainThLow, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "adrcGainThHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)adrcGainThHigh, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "adrcGainThMax") == 0)
    {
        ParameterUtils::DoubleToString((double)adrcGainThMax, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confThLow") == 0)
    {
        ParameterUtils::DoubleToString((double)confThLow, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confThHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)confThHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tradiConfTh") == 0)
    {
        ParameterUtils::DoubleToString((double)tradiConfTh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dccRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)dccRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pdOffset") == 0)
    {
        ParameterUtils::DoubleToString((double)pdOffset, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pdMaxVarThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)pdMaxVarThreshold, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixMLPDControlProcess::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "useRDIPDAF") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            useRDIPDAF = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "mlpdEnabledInHWFlow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            mlpdEnabledInHWFlow = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "alterLROrder") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            alterLROrder = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "modelNetType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            modelNetType = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gainThLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gainThLow = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gainThHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gainThHigh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gainThMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gainThMax = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "expIndexThLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            expIndexThLow = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "expIndexThHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            expIndexThHigh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "expIndexThMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            expIndexThMax = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "adrcGainThLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            adrcGainThLow = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "adrcGainThHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            adrcGainThHigh = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "adrcGainThMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            adrcGainThMax = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confThLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confThLow = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confThHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confThHigh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tradiConfTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tradiConfTh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dccRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dccRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pdOffset") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pdOffset = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pdMaxVarThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pdMaxVarThreshold = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixTuningDarkFaceOptimization::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, "gamma") == 0)
    {
        ParameterUtils::DoubleToString((double)gamma, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "topRatioBinDark") == 0)
    {
        ParameterUtils::DoubleToString((double)topRatioBinDark, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "topRatioBinBright") == 0)
    {
        ParameterUtils::DoubleToString((double)topRatioBinBright, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresRoiSizeSmall") == 0)
    {
        ParameterUtils::DoubleToString((double)thresRoiSizeSmall, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresRoiSizeLarge") == 0)
    {
        ParameterUtils::DoubleToString((double)thresRoiSizeLarge, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresDifferenceHistStats") == 0)
    {
        ParameterUtils::DoubleToString((double)thresDifferenceHistStats, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "histCeilRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)histCeilRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "histBaseRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)histBaseRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "histFilterRAD") == 0)
    {
        ParameterUtils::DoubleToString((double)histFilterRAD, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "recoverOverwritePDBuffer") == 0)
    {
        ParameterUtils::DoubleToString((double)recoverOverwritePDBuffer, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixTuningDarkFaceOptimization::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gamma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gamma = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "topRatioBinDark") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            topRatioBinDark = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "topRatioBinBright") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            topRatioBinBright = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresRoiSizeSmall") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresRoiSizeSmall = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresRoiSizeLarge") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresRoiSizeLarge = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresDifferenceHistStats") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresDifferenceHistStats = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "histCeilRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            histCeilRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "histBaseRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            histBaseRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "histFilterRAD") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            histFilterRAD = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "recoverOverwritePDBuffer") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            recoverOverwritePDBuffer = (BOOL)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixPDHWOutputControl::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, "preprocessMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            preprocessMode = (PreprocessOutputMode)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "parsedMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            parsedMode = (ParsedOutputMode)(UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

    return __result;
}

bool chromatixPDAFHardwareResamplerInstruction::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, "S") == 0)
    {
        if (__index < SCount)
        {
            ParameterUtils::DoubleToString((double)S[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < SCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)S[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "O") == 0)
    {
        if (__index < OCount)
        {
            ParameterUtils::DoubleToString((double)O[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < OCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)O[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    S[__index] = (INT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "O") == 0)
    {
        if (__index < OCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                O[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

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

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

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

    return __result;
}

bool chromatixPDAFHardwareResampler::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, "inputBlockWidth") == 0)
    {
        ParameterUtils::DoubleToString((double)inputBlockWidth, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "inputBlockHeight") == 0)
    {
        ParameterUtils::DoubleToString((double)inputBlockHeight, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockWidth") == 0)
    {
        ParameterUtils::DoubleToString((double)outputBlockWidth, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockHeight") == 0)
    {
        ParameterUtils::DoubleToString((double)outputBlockHeight, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "instructions") == 0)
    {
        if (__index < instructionsCount)
        {
            __result = instructions[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDAFHardwareResampler::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "inputBlockWidth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            inputBlockWidth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "inputBlockHeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            inputBlockHeight = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockWidth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            outputBlockWidth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockHeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            outputBlockHeight = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "instructions") == 0)
    {
        if (__index < instructionsCount)
        {
            __result = instructions[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

bool chromatixPDAFHardwarePixelSeparator::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, "inputBlockWidth") == 0)
    {
        ParameterUtils::DoubleToString((double)inputBlockWidth, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "inputBlockHeight") == 0)
    {
        ParameterUtils::DoubleToString((double)inputBlockHeight, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockWidth") == 0)
    {
        ParameterUtils::DoubleToString((double)outputBlockWidth, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockHeight") == 0)
    {
        ParameterUtils::DoubleToString((double)outputBlockHeight, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pixelSpan") == 0)
    {
        ParameterUtils::DoubleToString((double)pixelSpan, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "L_map") == 0)
    {
        if (__index < L_mapCount)
        {
            ParameterUtils::DoubleToString((double)L_map[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < L_mapCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)L_map[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "R_map") == 0)
    {
        if (__index < R_mapCount)
        {
            ParameterUtils::DoubleToString((double)R_map[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < R_mapCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)R_map[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }

    return __result;
}

bool chromatixPDAFHardwarePixelSeparator::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, "inputBlockWidth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            inputBlockWidth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "inputBlockHeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            inputBlockHeight = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockWidth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            outputBlockWidth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "outputBlockHeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            outputBlockHeight = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pixelSpan") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pixelSpan = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "L_map") == 0)
    {
        if (__index < L_mapCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                L_map[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    L_map[__index] = (INT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "R_map") == 0)
    {
        if (__index < R_mapCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                R_map[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixPDAFHardwareLineExtractor::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, "XOffset") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            XOffset = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "YOffset") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            YOffset = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "HalfLine") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            HalfLine = (BOOL)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixPDAFHardwarePixelExtractor::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "outputWidth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            outputWidth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "outputHeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            outputHeight = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

    return __result;
}

bool chromatixTuningHardwarePattern::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, "pixelExtractor") == 0)
    {
        __result = pixelExtractor.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lineExtractor") == 0)
    {
        if (__index < lineExtractorCount)
        {
            __result = lineExtractor[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "pixelSeparator") == 0)
    {
        __result = pixelSeparator.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "resampler") == 0)
    {
        __result = resampler.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "gridWidthScaleRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)gridWidthScaleRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gridHeightScaleRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)gridHeightScaleRatio, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixTuningHardwarePattern::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, "pixelExtractor") == 0)
    {
        __result = pixelExtractor.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lineExtractor") == 0)
    {
        if (__index < lineExtractorCount)
        {
            __result = lineExtractor[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "pixelSeparator") == 0)
    {
        __result = pixelSeparator.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "resampler") == 0)
    {
        __result = resampler.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "gridWidthScaleRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gridWidthScaleRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gridHeightScaleRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gridHeightScaleRatio = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

bool chromatixTuningHardwareGeometry::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, "enabldHardwarePDModule") == 0)
    {
        ParameterUtils::DoubleToString((double)enabldHardwarePDModule, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableOverlap") == 0)
    {
        ParameterUtils::DoubleToString((double)enableOverlap, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numOfHoriGrids") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfHoriGrids, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numOfVertGrids") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfVertGrids, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "horiNumOfRGNInGridUnit") == 0)
    {
        ParameterUtils::DoubleToString((double)horiNumOfRGNInGridUnit, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "vertNumOfRGNInGridUnit") == 0)
    {
        ParameterUtils::DoubleToString((double)vertNumOfRGNInGridUnit, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "horiRegionOffset") == 0)
    {
        ParameterUtils::DoubleToString((double)horiRegionOffset, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "vertRegionOffset") == 0)
    {
        ParameterUtils::DoubleToString((double)vertRegionOffset, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "widhtOfRegion") == 0)
    {
        ParameterUtils::DoubleToString((double)widhtOfRegion, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "heightOfRegion") == 0)
    {
        ParameterUtils::DoubleToString((double)heightOfRegion, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "horiNumOfRegion") == 0)
    {
        ParameterUtils::DoubleToString((double)horiNumOfRegion, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "vertNumOfRegion") == 0)
    {
        ParameterUtils::DoubleToString((double)vertNumOfRegion, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixTuningHardwareGeometry::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, "enabldHardwarePDModule") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enabldHardwarePDModule = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableOverlap") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableOverlap = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numOfHoriGrids") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numOfHoriGrids = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numOfVertGrids") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numOfVertGrids = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "horiNumOfRGNInGridUnit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            horiNumOfRGNInGridUnit = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "vertNumOfRGNInGridUnit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            vertNumOfRGNInGridUnit = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "horiRegionOffset") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            horiRegionOffset = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "vertRegionOffset") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            vertRegionOffset = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "widhtOfRegion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            widhtOfRegion = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "heightOfRegion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            heightOfRegion = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "horiNumOfRegion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            horiNumOfRegion = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "vertNumOfRegion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            vertNumOfRegion = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool chromatixHVControl::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, "PDProcessingAxis") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)PDProcessingAxis, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "horizontalConfWeightTuning") == 0)
    {
        if (__index < horizontalConfWeightTuningCount)
        {
            __result = horizontalConfWeightTuning[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "verticalConfWeightTuning") == 0)
    {
        if (__index < verticalConfWeightTuningCount)
        {
            __result = verticalConfWeightTuning[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixHVControl::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, "PDProcessingAxis") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            PDProcessingAxis = (chromatixPDAxisControl)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "horizontalConfWeightTuning") == 0)
    {
        if (__index < horizontalConfWeightTuningCount)
        {
            __result = horizontalConfWeightTuning[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "verticalConfWeightTuning") == 0)
    {
        if (__index < verticalConfWeightTuningCount)
        {
            __result = verticalConfWeightTuning[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool chromatixTuningProcessLevel::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, "processingMode") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)processingMode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dynamicLevel") == 0)
    {
        ParameterUtils::DoubleToString((double)dynamicLevel, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "staticLevel") == 0)
    {
        ParameterUtils::DoubleToString((double)staticLevel, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixTuningProcessLevel::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, "processingMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            processingMode = (chromatixPDProcessingMode)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dynamicLevel") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dynamicLevel = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "staticLevel") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            staticLevel = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool chromatixTuningAdaptiveK::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, "timeoutFrameCntThres") == 0)
    {
        ParameterUtils::DoubleToString((double)timeoutFrameCntThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "filterSize") == 0)
    {
        ParameterUtils::DoubleToString((double)filterSize, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "state0StableCntThres") == 0)
    {
        ParameterUtils::DoubleToString((double)state0StableCntThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "state1StableCntThres") == 0)
    {
        ParameterUtils::DoubleToString((double)state1StableCntThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minimumLensPosDelta") == 0)
    {
        ParameterUtils::DoubleToString((double)minimumLensPosDelta, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "state0ConfThres") == 0)
    {
        ParameterUtils::DoubleToString((double)state0ConfThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "state1ConfThres") == 0)
    {
        ParameterUtils::DoubleToString((double)state1ConfThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "state0PhaseDiffThres") == 0)
    {
        ParameterUtils::DoubleToString((double)state0PhaseDiffThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "state1PhaseDiffThres") == 0)
    {
        ParameterUtils::DoubleToString((double)state1PhaseDiffThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tolNearTargetUpperBound") == 0)
    {
        ParameterUtils::DoubleToString((double)tolNearTargetUpperBound, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tolNearTargetLowerBound") == 0)
    {
        ParameterUtils::DoubleToString((double)tolNearTargetLowerBound, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tolFarTargetUpperBound") == 0)
    {
        ParameterUtils::DoubleToString((double)tolFarTargetUpperBound, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tolFarTargetLowerBound") == 0)
    {
        ParameterUtils::DoubleToString((double)tolFarTargetLowerBound, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixTuningAdaptiveK::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "timeoutFrameCntThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            timeoutFrameCntThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "filterSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            filterSize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "state0StableCntThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            state0StableCntThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "state1StableCntThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            state1StableCntThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minimumLensPosDelta") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minimumLensPosDelta = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "state0ConfThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            state0ConfThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "state1ConfThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            state1ConfThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "state0PhaseDiffThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            state0PhaseDiffThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "state1PhaseDiffThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            state1PhaseDiffThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tolNearTargetUpperBound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tolNearTargetUpperBound = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tolNearTargetLowerBound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tolNearTargetLowerBound = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tolFarTargetUpperBound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tolFarTargetUpperBound = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tolFarTargetLowerBound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tolFarTargetLowerBound = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixPDLibRepeatPatternDetect::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, "maxRevCnt") == 0)
    {
        ParameterUtils::DoubleToString((double)maxRevCnt, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "changeRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)changeRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "revDisTol") == 0)
    {
        ParameterUtils::DoubleToString((double)revDisTol, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)confThreshold, __value, __size);
        __result = true;
    }

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

bool chromatixTuningPostProcess::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, "biasVectorStrength") == 0)
    {
        ParameterUtils::DoubleToString((double)biasVectorStrength, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilterStaticWeight") == 0)
    {
        ParameterUtils::DoubleToString((double)temporalFilterStaticWeight, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilterDynamicWeight") == 0)
    {
        ParameterUtils::DoubleToString((double)temporalFilterDynamicWeight, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilterTrigger") == 0)
    {
        __result = temporalFilterTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enableGridOverlap") == 0)
    {
        ParameterUtils::DoubleToString((double)enableGridOverlap, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableFocusMapGridOverlap") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFocusMapGridOverlap, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confIntegralWidth") == 0)
    {
        ParameterUtils::DoubleToString((double)confIntegralWidth, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "repeatPatternDetect") == 0)
    {
        __result = repeatPatternDetect.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixTuningPostProcess::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, "biasVectorStrength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            biasVectorStrength = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilterStaticWeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            temporalFilterStaticWeight = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilterDynamicWeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            temporalFilterDynamicWeight = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilterTrigger") == 0)
    {
        __result = temporalFilterTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enableGridOverlap") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableGridOverlap = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableFocusMapGridOverlap") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFocusMapGridOverlap = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confIntegralWidth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confIntegralWidth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "repeatPatternDetect") == 0)
    {
        __result = repeatPatternDetect.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool chromatixTuningCorrelation::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, "minimumConfidenceLevel") == 0)
    {
        ParameterUtils::DoubleToString((double)minimumConfidenceLevel, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusConfidenceThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusConfidenceThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "PDRangeControl") == 0)
    {
        ParameterUtils::DoubleToString((double)PDRangeControl, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "searchRange") == 0)
    {
        __result = searchRange.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lcrSearchRange") == 0)
    {
        __result = lcrSearchRange.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lcrConfidenceThresholdLow") == 0)
    {
        ParameterUtils::DoubleToString((double)lcrConfidenceThresholdLow, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lcrConfidenceThresholdHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)lcrConfidenceThresholdHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "advanceSparseProcMode") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)advanceSparseProcMode, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixTuningCorrelation::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, "minimumConfidenceLevel") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minimumConfidenceLevel = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusConfidenceThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusConfidenceThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDRangeControl") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            PDRangeControl = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "searchRange") == 0)
    {
        __result = searchRange.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lcrSearchRange") == 0)
    {
        __result = lcrSearchRange.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lcrConfidenceThresholdLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrConfidenceThresholdLow = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lcrConfidenceThresholdHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrConfidenceThresholdHigh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "advanceSparseProcMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            advanceSparseProcMode = (chromatixAdvanceSparseProcMode)(UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixPDLIBPreprocessingFilterSettings::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, "AECTrigger") == 0)
    {
        __result = AECTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "verticalMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            verticalMode = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "horizontalMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            horizontalMode = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "boxFilterLength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            boxFilterLength = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "antiAliasFilterThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            antiAliasFilterThreshold = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

bool chromatixTuningSpotLight::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, "mode") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sequenceCntThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)sequenceCntThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pixelValThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)pixelValThreshold, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixTuningSpotLight::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            mode = (chromatixSpotlightDetectionMode)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sequenceCntThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sequenceCntThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pixelValThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pixelValThreshold = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixTuningHDRCfg::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, "channelSelection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            channelSelection = (chromatixHDRChannelSelection)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "longThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            longThreshold = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

    return __result;
}

bool chromatixTuningPreProcess::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, "sparseProcessingMode") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)sparseProcessingMode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "HDR") == 0)
    {
        __result = HDR.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "boxFilterLength") == 0)
    {
        ParameterUtils::DoubleToString((double)boxFilterLength, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "antiAliasFilterThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)antiAliasFilterThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "saturationThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)saturationThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "spotLightCompensation") == 0)
    {
        __result = spotLightCompensation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "filterTrigger") == 0)
    {
        __result = filterTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lcrFilterTrigger") == 0)
    {
        __result = lcrFilterTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lcrChannel") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)lcrChannel, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lcrBinningMode") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)lcrBinningMode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lcrRawType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)lcrRawType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lcrMaxBinningNum") == 0)
    {
        ParameterUtils::DoubleToString((double)lcrMaxBinningNum, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lcrChannelSeparated") == 0)
    {
        ParameterUtils::DoubleToString((double)lcrChannelSeparated, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lcrXCFAType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)lcrXCFAType, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixTuningPreProcess::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, "sparseProcessingMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sparseProcessingMode = (chromatixSparsePDProcMode)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "HDR") == 0)
    {
        __result = HDR.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "boxFilterLength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            boxFilterLength = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "antiAliasFilterThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            antiAliasFilterThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "saturationThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            saturationThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "spotLightCompensation") == 0)
    {
        __result = spotLightCompensation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "filterTrigger") == 0)
    {
        __result = filterTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lcrFilterTrigger") == 0)
    {
        __result = lcrFilterTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lcrChannel") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrChannel = (chromatixLCRChannel)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lcrBinningMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrBinningMode = (chromatixLCRBinningMode)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lcrRawType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrRawType = (chromatixLCRRawType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lcrMaxBinningNum") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrMaxBinningNum = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lcrChannelSeparated") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrChannelSeparated = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lcrXCFAType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lcrXCFAType = (chromatixLCRXCFAType)(UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixPDLibType::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, "preProcess") == 0)
    {
        __result = preProcess.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "preProcessVertical") == 0)
    {
        __result = preProcessVertical.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "correlation") == 0)
    {
        __result = correlation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "correlationVertical") == 0)
    {
        __result = correlationVertical.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "postProcess") == 0)
    {
        __result = postProcess.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "postProcessVertical") == 0)
    {
        __result = postProcessVertical.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "adaptiveK") == 0)
    {
        __result = adaptiveK.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enablePeripheralWindows") == 0)
    {
        ParameterUtils::DoubleToString((double)enablePeripheralWindows, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "singleWindowProcessingLevel") == 0)
    {
        __result = singleWindowProcessingLevel.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "singleWindowProcessingLevelVertical") == 0)
    {
        __result = singleWindowProcessingLevelVertical.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "gridProcessingLevel") == 0)
    {
        __result = gridProcessingLevel.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "gridProcessingLevelVertical") == 0)
    {
        __result = gridProcessingLevelVertical.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "PeripheralProcessing") == 0)
    {
        __result = PeripheralProcessing.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "PeripheralProcessingVertical") == 0)
    {
        __result = PeripheralProcessingVertical.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "LFMProcessingLevel") == 0)
    {
        __result = LFMProcessingLevel.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "HVControl") == 0)
    {
        __result = HVControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "skipControl") == 0)
    {
        __result = skipControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "HDRControl") == 0)
    {
        __result = HDRControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "hardwareGeometry") == 0)
    {
        __result = hardwareGeometry.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "hardwarePattern") == 0)
    {
        if (__index < hardwarePatternCount)
        {
            __result = hardwarePattern[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableFocusMaps") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFocusMaps, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FocusMapInterrupt") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)FocusMapInterrupt, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LFMCorrectionRange") == 0)
    {
        if (__index < 2)
        {
            ParameterUtils::DoubleToString((double)LFMCorrectionRange[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 2; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)LFMCorrectionRange[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDHWOutputControl") == 0)
    {
        __result = PDHWOutputControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "darkFaceOptimization") == 0)
    {
        __result = darkFaceOptimization.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "mlpdControlProcess") == 0)
    {
        __result = mlpdControlProcess.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "PDHWFallbackControl") == 0)
    {
        __result = PDHWFallbackControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "extensionParam") == 0)
    {
        if (__index < extensionParamCount)
        {
            __result = extensionParam[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDLibType::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, "preProcess") == 0)
    {
        __result = preProcess.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "preProcessVertical") == 0)
    {
        __result = preProcessVertical.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "correlation") == 0)
    {
        __result = correlation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "correlationVertical") == 0)
    {
        __result = correlationVertical.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "postProcess") == 0)
    {
        __result = postProcess.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "postProcessVertical") == 0)
    {
        __result = postProcessVertical.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "adaptiveK") == 0)
    {
        __result = adaptiveK.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enablePeripheralWindows") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enablePeripheralWindows = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "singleWindowProcessingLevel") == 0)
    {
        __result = singleWindowProcessingLevel.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "singleWindowProcessingLevelVertical") == 0)
    {
        __result = singleWindowProcessingLevelVertical.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "gridProcessingLevel") == 0)
    {
        __result = gridProcessingLevel.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "gridProcessingLevelVertical") == 0)
    {
        __result = gridProcessingLevelVertical.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "PeripheralProcessing") == 0)
    {
        __result = PeripheralProcessing.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "PeripheralProcessingVertical") == 0)
    {
        __result = PeripheralProcessingVertical.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "LFMProcessingLevel") == 0)
    {
        __result = LFMProcessingLevel.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "HVControl") == 0)
    {
        __result = HVControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "skipControl") == 0)
    {
        __result = skipControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "HDRControl") == 0)
    {
        __result = HDRControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "hardwareGeometry") == 0)
    {
        __result = hardwareGeometry.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "hardwarePattern") == 0)
    {
        if (__index < hardwarePatternCount)
        {
            __result = hardwarePattern[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableFocusMaps") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFocusMaps = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FocusMapInterrupt") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FocusMapInterrupt = (chromatixPDLibProcessInterrupt)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LFMCorrectionRange") == 0)
    {
        if (__index < 2)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                LFMCorrectionRange[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    LFMCorrectionRange[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDHWOutputControl") == 0)
    {
        __result = PDHWOutputControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "darkFaceOptimization") == 0)
    {
        __result = darkFaceOptimization.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "mlpdControlProcess") == 0)
    {
        __result = mlpdControlProcess.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "PDHWFallbackControl") == 0)
    {
        __result = PDHWFallbackControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "extensionParam") == 0)
    {
        if (__index < extensionParamCount)
        {
            __result = extensionParam[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @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_chromatixPDLibROIType(
    ParameterFileSymbolTableEntry* const entry,
    chromatixPDLibROIType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixPDLibROIType::Center):
            enumValue = chromatixPDLibROIType::Center;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::Peripheral):
            enumValue = chromatixPDLibROIType::Peripheral;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::Face):
            enumValue = chromatixPDLibROIType::Face;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::Touch):
            enumValue = chromatixPDLibROIType::Touch;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::Salient):
            enumValue = chromatixPDLibROIType::Salient;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::ROITypeExt1):
            enumValue = chromatixPDLibROIType::ROITypeExt1;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::ROITypeExt2):
            enumValue = chromatixPDLibROIType::ROITypeExt2;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::ROITypeExt3):
            enumValue = chromatixPDLibROIType::ROITypeExt3;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::ROITypeExt4):
            enumValue = chromatixPDLibROIType::ROITypeExt4;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::ROITypeExt5):
            enumValue = chromatixPDLibROIType::ROITypeExt5;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibROIType::ROITypeMax):
            enumValue = chromatixPDLibROIType::ROITypeMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixPDLibROIType", 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_ParsedOutputMode(
    ParameterFileSymbolTableEntry* const entry,
    ParsedOutputMode& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(ParsedOutputMode::Disable):
            enumValue = ParsedOutputMode::Disable;
            result    = true;
            break;
        case static_cast<UINT32>(ParsedOutputMode::Auto):
            enumValue = ParsedOutputMode::Auto;
            result    = true;
            break;
        case static_cast<UINT32>(ParsedOutputMode::Vertical):
            enumValue = ParsedOutputMode::Vertical;
            result    = true;
            break;
        case static_cast<UINT32>(ParsedOutputMode::Center):
            enumValue = ParsedOutputMode::Center;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to ParsedOutputMode", 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_PreprocessOutputMode(
    ParameterFileSymbolTableEntry* const entry,
    PreprocessOutputMode& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(PreprocessOutputMode::Disable):
            enumValue = PreprocessOutputMode::Disable;
            result    = true;
            break;
        case static_cast<UINT32>(PreprocessOutputMode::Auto):
            enumValue = PreprocessOutputMode::Auto;
            result    = true;
            break;
        case static_cast<UINT32>(PreprocessOutputMode::PostIIR):
            enumValue = PreprocessOutputMode::PostIIR;
            result    = true;
            break;
        case static_cast<UINT32>(PreprocessOutputMode::PostPolyphase):
            enumValue = PreprocessOutputMode::PostPolyphase;
            result    = true;
            break;
        case static_cast<UINT32>(PreprocessOutputMode::Vertical):
            enumValue = PreprocessOutputMode::Vertical;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to PreprocessOutputMode", 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_chromatixPDLibProcessInterrupt(
    ParameterFileSymbolTableEntry* const entry,
    chromatixPDLibProcessInterrupt& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixPDLibProcessInterrupt::EndOfFrame):
            enumValue = chromatixPDLibProcessInterrupt::EndOfFrame;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibProcessInterrupt::EarlyInterrupt):
            enumValue = chromatixPDLibProcessInterrupt::EarlyInterrupt;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDLibProcessInterrupt::Incremental):
            enumValue = chromatixPDLibProcessInterrupt::Incremental;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixPDLibProcessInterrupt", 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_HDRStatsTypeGrid(
    ParameterFileSymbolTableEntry* const entry,
    HDRStatsTypeGrid& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(HDRStatsTypeGrid::GridTypeSaturationRatio):
            enumValue = HDRStatsTypeGrid::GridTypeSaturationRatio;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsTypeGrid::GridTypePDLibConfidence):
            enumValue = HDRStatsTypeGrid::GridTypePDLibConfidence;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsTypeGrid::TypeMax):
            enumValue = HDRStatsTypeGrid::TypeMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to HDRStatsTypeGrid", 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_HDRStatsTypeGlobal(
    ParameterFileSymbolTableEntry* const entry,
    HDRStatsTypeGlobal& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(HDRStatsTypeGlobal::GlobalTypeExposureTime):
            enumValue = HDRStatsTypeGlobal::GlobalTypeExposureTime;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsTypeGlobal::GlobalTypeExposureGain):
            enumValue = HDRStatsTypeGlobal::GlobalTypeExposureGain;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsTypeGlobal::GlobalTypeLuma):
            enumValue = HDRStatsTypeGlobal::GlobalTypeLuma;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsTypeGlobal::GlobalTypeSaturationRatio):
            enumValue = HDRStatsTypeGlobal::GlobalTypeSaturationRatio;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsTypeGlobal::GlobalTypePDAFConfidence):
            enumValue = HDRStatsTypeGlobal::GlobalTypePDAFConfidence;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsTypeGlobal::TypeMax):
            enumValue = HDRStatsTypeGlobal::TypeMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to HDRStatsTypeGlobal", 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_BiasExposureType(
    ParameterFileSymbolTableEntry* const entry,
    BiasExposureType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(BiasExposureType::exposureTypeShort):
            enumValue = BiasExposureType::exposureTypeShort;
            result    = true;
            break;
        case static_cast<UINT32>(BiasExposureType::exposureTypeLong):
            enumValue = BiasExposureType::exposureTypeLong;
            result    = true;
            break;
        case static_cast<UINT32>(BiasExposureType::exposureTypeSafe):
            enumValue = BiasExposureType::exposureTypeSafe;
            result    = true;
            break;
        case static_cast<UINT32>(BiasExposureType::exposureTypeMerged):
            enumValue = BiasExposureType::exposureTypeMerged;
            result    = true;
            break;
        case static_cast<UINT32>(BiasExposureType::exposureTypeMax):
            enumValue = BiasExposureType::exposureTypeMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to BiasExposureType", 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_HDRStatsSelectionType(
    ParameterFileSymbolTableEntry* const entry,
    HDRStatsSelectionType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(HDRStatsSelectionType::SelectTypeChooseGlobal):
            enumValue = HDRStatsSelectionType::SelectTypeChooseGlobal;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsSelectionType::SelectTypeBlendGlobal):
            enumValue = HDRStatsSelectionType::SelectTypeBlendGlobal;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsSelectionType::SelectTypeChooseGrid):
            enumValue = HDRStatsSelectionType::SelectTypeChooseGrid;
            result    = true;
            break;
        case static_cast<UINT32>(HDRStatsSelectionType::SelectTypeBlendGrid):
            enumValue = HDRStatsSelectionType::SelectTypeBlendGrid;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to HDRStatsSelectionType", 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_chromatixPDAxisControl(
    ParameterFileSymbolTableEntry* const entry,
    chromatixPDAxisControl& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixPDAxisControl::Horizontal):
            enumValue = chromatixPDAxisControl::Horizontal;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDAxisControl::Vertical):
            enumValue = chromatixPDAxisControl::Vertical;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDAxisControl::HorizontalVertical):
            enumValue = chromatixPDAxisControl::HorizontalVertical;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixPDAxisControl", 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_chromatixPDProcessingMode(
    ParameterFileSymbolTableEntry* const entry,
    chromatixPDProcessingMode& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixPDProcessingMode::PD_PROCESSING_MODE_DYNAMIC):
            enumValue = chromatixPDProcessingMode::PD_PROCESSING_MODE_DYNAMIC;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDProcessingMode::PD_PROCESSING_MODE_LOW):
            enumValue = chromatixPDProcessingMode::PD_PROCESSING_MODE_LOW;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDProcessingMode::PD_PROCESSING_MODE_MED):
            enumValue = chromatixPDProcessingMode::PD_PROCESSING_MODE_MED;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDProcessingMode::PD_PROCESSING_MODE_HIGH):
            enumValue = chromatixPDProcessingMode::PD_PROCESSING_MODE_HIGH;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDProcessingMode::PD_PROCESSING_MODE_CONSTANT_QUALITY):
            enumValue = chromatixPDProcessingMode::PD_PROCESSING_MODE_CONSTANT_QUALITY;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixPDProcessingMode::PD_PROCESSING_MODE_CONSTANT_COST):
            enumValue = chromatixPDProcessingMode::PD_PROCESSING_MODE_CONSTANT_COST;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixPDProcessingMode", 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_chromatixAdvanceSparseProcMode(
    ParameterFileSymbolTableEntry* const entry,
    chromatixAdvanceSparseProcMode& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixAdvanceSparseProcMode::Default):
            enumValue = chromatixAdvanceSparseProcMode::Default;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAdvanceSparseProcMode::Disable):
            enumValue = chromatixAdvanceSparseProcMode::Disable;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAdvanceSparseProcMode::PartialAcceleration):
            enumValue = chromatixAdvanceSparseProcMode::PartialAcceleration;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAdvanceSparseProcMode::FullAcceleration):
            enumValue = chromatixAdvanceSparseProcMode::FullAcceleration;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixAdvanceSparseProcMode", 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_chromatixLCRXCFAType(
    ParameterFileSymbolTableEntry* const entry,
    chromatixLCRXCFAType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixLCRXCFAType::PDAF_LCR_BAYER):
            enumValue = chromatixLCRXCFAType::PDAF_LCR_BAYER;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRXCFAType::PDAF_LCR_QCFA):
            enumValue = chromatixLCRXCFAType::PDAF_LCR_QCFA;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRXCFAType::PDAF_LCR_3x3_CFA):
            enumValue = chromatixLCRXCFAType::PDAF_LCR_3x3_CFA;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRXCFAType::PDAF_LCR_4x4_CFA):
            enumValue = chromatixLCRXCFAType::PDAF_LCR_4x4_CFA;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixLCRXCFAType", 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_chromatixLCRRawType(
    ParameterFileSymbolTableEntry* const entry,
    chromatixLCRRawType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixLCRRawType::PDAF_BAYER_RAW):
            enumValue = chromatixLCRRawType::PDAF_BAYER_RAW;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRRawType::PDAF_IDEAL_RAW):
            enumValue = chromatixLCRRawType::PDAF_IDEAL_RAW;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRRawType::PDAF_CAMIF_RAW):
            enumValue = chromatixLCRRawType::PDAF_CAMIF_RAW;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixLCRRawType", 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_chromatixLCRBinningMode(
    ParameterFileSymbolTableEntry* const entry,
    chromatixLCRBinningMode& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixLCRBinningMode::PDAF_LCR_BINNING_DEFAULT):
            enumValue = chromatixLCRBinningMode::PDAF_LCR_BINNING_DEFAULT;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRBinningMode::PDAF_LCR_BINNING_ALL):
            enumValue = chromatixLCRBinningMode::PDAF_LCR_BINNING_ALL;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRBinningMode::PDAF_LCR_BINNING_SHIELD):
            enumValue = chromatixLCRBinningMode::PDAF_LCR_BINNING_SHIELD;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixLCRBinningMode", 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_chromatixLCRChannel(
    ParameterFileSymbolTableEntry* const entry,
    chromatixLCRChannel& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixLCRChannel::PDAF_LCR_CHANNEL_G):
            enumValue = chromatixLCRChannel::PDAF_LCR_CHANNEL_G;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixLCRChannel::PDAF_LCR_CHANNEL_Y):
            enumValue = chromatixLCRChannel::PDAF_LCR_CHANNEL_Y;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixLCRChannel", 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_chromatixSpotlightDetectionMode(
    ParameterFileSymbolTableEntry* const entry,
    chromatixSpotlightDetectionMode& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixSpotlightDetectionMode::SPOTLIGHT_AND):
            enumValue = chromatixSpotlightDetectionMode::SPOTLIGHT_AND;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixSpotlightDetectionMode::SPOTLIGHT_OR):
            enumValue = chromatixSpotlightDetectionMode::SPOTLIGHT_OR;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixSpotlightDetectionMode", 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_chromatixHDRChannelSelection(
    ParameterFileSymbolTableEntry* const entry,
    chromatixHDRChannelSelection& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixHDRChannelSelection::DPD_HDR_AUTO_MODE):
            enumValue = chromatixHDRChannelSelection::DPD_HDR_AUTO_MODE;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixHDRChannelSelection::DPD_HDR_LONG_MODE):
            enumValue = chromatixHDRChannelSelection::DPD_HDR_LONG_MODE;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixHDRChannelSelection::DPD_HDR_SHORT_MODE):
            enumValue = chromatixHDRChannelSelection::DPD_HDR_SHORT_MODE;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixHDRChannelSelection", 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_chromatixSparsePDProcMode(
    ParameterFileSymbolTableEntry* const entry,
    chromatixSparsePDProcMode& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

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


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixPDLibTypeClass::chromatixPDLibTypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(preProcess);
    PARAMETER_INITIALIZE(preProcessVertical);
    PARAMETER_INITIALIZE(correlation);
    PARAMETER_INITIALIZE(correlationVertical);
    PARAMETER_INITIALIZE(postProcess);
    PARAMETER_INITIALIZE(postProcessVertical);
    PARAMETER_INITIALIZE(adaptiveK);
    PARAMETER_INITIALIZE(enablePeripheralWindows);
    PARAMETER_INITIALIZE(singleWindowProcessingLevel);
    PARAMETER_INITIALIZE(singleWindowProcessingLevelVertical);
    PARAMETER_INITIALIZE(gridProcessingLevel);
    PARAMETER_INITIALIZE(gridProcessingLevelVertical);
    PARAMETER_INITIALIZE(PeripheralProcessing);
    PARAMETER_INITIALIZE(PeripheralProcessingVertical);
    PARAMETER_INITIALIZE(LFMProcessingLevel);
    PARAMETER_INITIALIZE(HVControl);
    PARAMETER_INITIALIZE(skipControl);
    PARAMETER_INITIALIZE(HDRControl);
    PARAMETER_INITIALIZE(hardwareGeometry);
    PARAMETER_INITIALIZE(hardwarePatternCount);
    PARAMETER_INITIALIZE(hardwarePattern);
    PARAMETER_INITIALIZE(enableFocusMaps);
    PARAMETER_INITIALIZE(FocusMapInterrupt);
    PARAMETER_INITIALIZE(LFMCorrectionRange);
    PARAMETER_INITIALIZE(PDHWOutputControl);
    PARAMETER_INITIALIZE(darkFaceOptimization);
    PARAMETER_INITIALIZE(mlpdControlProcess);
    PARAMETER_INITIALIZE(PDHWFallbackControl);
    PARAMETER_INITIALIZE(extensionParamCount);
    PARAMETER_INITIALIZE(extensionParam);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixPDLibTypeClass::chromatixPDLibTypeClass(
    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(preProcess);
    PARAMETER_INITIALIZE(preProcessVertical);
    PARAMETER_INITIALIZE(correlation);
    PARAMETER_INITIALIZE(correlationVertical);
    PARAMETER_INITIALIZE(postProcess);
    PARAMETER_INITIALIZE(postProcessVertical);
    PARAMETER_INITIALIZE(adaptiveK);
    PARAMETER_INITIALIZE(enablePeripheralWindows);
    PARAMETER_INITIALIZE(singleWindowProcessingLevel);
    PARAMETER_INITIALIZE(singleWindowProcessingLevelVertical);
    PARAMETER_INITIALIZE(gridProcessingLevel);
    PARAMETER_INITIALIZE(gridProcessingLevelVertical);
    PARAMETER_INITIALIZE(PeripheralProcessing);
    PARAMETER_INITIALIZE(PeripheralProcessingVertical);
    PARAMETER_INITIALIZE(LFMProcessingLevel);
    PARAMETER_INITIALIZE(HVControl);
    PARAMETER_INITIALIZE(skipControl);
    PARAMETER_INITIALIZE(HDRControl);
    PARAMETER_INITIALIZE(hardwareGeometry);
    PARAMETER_INITIALIZE(hardwarePattern);
    PARAMETER_INITIALIZE(enableFocusMaps);
    PARAMETER_INITIALIZE(FocusMapInterrupt);
    PARAMETER_INITIALIZE(LFMCorrectionRange);
    PARAMETER_INITIALIZE(PDHWOutputControl);
    PARAMETER_INITIALIZE(darkFaceOptimization);
    PARAMETER_INITIALIZE(mlpdControlProcess);
    PARAMETER_INITIALIZE(PDHWFallbackControl);
    PARAMETER_INITIALIZE(extensionParam);
}

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

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

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

    PARAMETER_INITIALIZE(ROIType);
    PARAMETER_INITIALIZE(widthRatio);
    PARAMETER_INITIALIZE(heightRatio);

    result = afpdlibelements::ReadEnum_chromatixPDLibROIType(entry, ROIType, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, widthRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, heightRatio, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(controlArr);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(useRDIPDAF);
    PARAMETER_INITIALIZE(mlpdEnabledInHWFlow);
    PARAMETER_INITIALIZE(alterLROrder);
    PARAMETER_INITIALIZE(modelNetType);
    PARAMETER_INITIALIZE(gainThLow);
    PARAMETER_INITIALIZE(gainThHigh);
    PARAMETER_INITIALIZE(gainThMax);
    PARAMETER_INITIALIZE(expIndexThLow);
    PARAMETER_INITIALIZE(expIndexThHigh);
    PARAMETER_INITIALIZE(expIndexThMax);
    PARAMETER_INITIALIZE(adrcGainThLow);
    PARAMETER_INITIALIZE(adrcGainThHigh);
    PARAMETER_INITIALIZE(adrcGainThMax);
    PARAMETER_INITIALIZE(confThLow);
    PARAMETER_INITIALIZE(confThHigh);
    PARAMETER_INITIALIZE(tradiConfTh);
    PARAMETER_INITIALIZE(dccRatio);
    PARAMETER_INITIALIZE(pdOffset);
    PARAMETER_INITIALIZE(pdMaxVarThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, useRDIPDAF, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, mlpdEnabledInHWFlow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, alterLROrder, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, modelNetType, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gainThLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gainThHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gainThMax, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, expIndexThLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, expIndexThHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, expIndexThMax, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, adrcGainThLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, adrcGainThHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, adrcGainThMax, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confThLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confThHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tradiConfTh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dccRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pdOffset, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pdMaxVarThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(gamma);
    PARAMETER_INITIALIZE(topRatioBinDark);
    PARAMETER_INITIALIZE(topRatioBinBright);
    PARAMETER_INITIALIZE(thresRoiSizeSmall);
    PARAMETER_INITIALIZE(thresRoiSizeLarge);
    PARAMETER_INITIALIZE(thresDifferenceHistStats);
    PARAMETER_INITIALIZE(histCeilRatio);
    PARAMETER_INITIALIZE(histBaseRatio);
    PARAMETER_INITIALIZE(histFilterRAD);
    PARAMETER_INITIALIZE(recoverOverwritePDBuffer);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gamma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, topRatioBinDark, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, topRatioBinBright, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresRoiSizeSmall, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresRoiSizeLarge, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresDifferenceHistStats, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, histCeilRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, histBaseRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, histFilterRAD, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, recoverOverwritePDBuffer, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(preprocessMode);
    PARAMETER_INITIALIZE(parsedMode);

    result = afpdlibelements::ReadEnum_PreprocessOutputMode(entry, preprocessMode, alignment);
    if (result)
    {
        result = afpdlibelements::ReadEnum_ParsedOutputMode(entry, parsedMode, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(S);
    PARAMETER_INITIALIZE(O);


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

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(inputBlockWidth);
    PARAMETER_INITIALIZE(inputBlockHeight);
    PARAMETER_INITIALIZE(outputBlockWidth);
    PARAMETER_INITIALIZE(outputBlockHeight);
    PARAMETER_INITIALIZE(instructions);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, inputBlockWidth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, inputBlockHeight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, outputBlockWidth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, outputBlockHeight, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(inputBlockWidth);
    PARAMETER_INITIALIZE(inputBlockHeight);
    PARAMETER_INITIALIZE(outputBlockWidth);
    PARAMETER_INITIALIZE(outputBlockHeight);
    PARAMETER_INITIALIZE(pixelSpan);
    PARAMETER_INITIALIZE(L_map);
    PARAMETER_INITIALIZE(R_map);

    SYMBOL_TABLE_ENTRY_READ(entry, result, inputBlockWidth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, inputBlockHeight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, outputBlockWidth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, outputBlockHeight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pixelSpan, alignment)

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

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(XOffset);
    PARAMETER_INITIALIZE(YOffset);
    PARAMETER_INITIALIZE(HalfLine);

    SYMBOL_TABLE_ENTRY_READ(entry, result, XOffset, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, YOffset, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, HalfLine, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(outputWidth);
    PARAMETER_INITIALIZE(outputHeight);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, outputWidth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, outputHeight, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(pixelExtractor);
    PARAMETER_INITIALIZE(lineExtractor);
    PARAMETER_INITIALIZE(pixelSeparator);
    PARAMETER_INITIALIZE(resampler);
    PARAMETER_INITIALIZE(gridWidthScaleRatio);
    PARAMETER_INITIALIZE(gridHeightScaleRatio);

    result = pixelExtractor.Load(entry, alignment);

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

            if (lineExtractor == nullptr)
            {
                if (result && lineExtractorCount > 0)
                {
                    lineExtractor = PARAMETER_NEW chromatixPDAFHardwareLineExtractor[lineExtractorCount];
                    (void)pointerEntry->SetDupObject(lineExtractor, lineExtractorCount, file, line);
                }
                if (!result || lineExtractor == nullptr)
                {
                    if (lineExtractorCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate lineExtractor\n");
                    }
                    lineExtractorCount = 0;
                }
                for (UINT32 i = 0; result && i < lineExtractorCount; i++)
                {
                    result = lineExtractor[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (lineExtractor == nullptr)
        {
            lineExtractorCount = 0;
        }
    }
    if (result)
    {
        result = pixelSeparator.Load(entry, alignment);
    }
    if (result)
    {
        result = resampler.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, gridWidthScaleRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gridHeightScaleRatio, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enabldHardwarePDModule);
    PARAMETER_INITIALIZE(enableOverlap);
    PARAMETER_INITIALIZE(numOfHoriGrids);
    PARAMETER_INITIALIZE(numOfVertGrids);
    PARAMETER_INITIALIZE(horiNumOfRGNInGridUnit);
    PARAMETER_INITIALIZE(vertNumOfRGNInGridUnit);
    PARAMETER_INITIALIZE(horiRegionOffset);
    PARAMETER_INITIALIZE(vertRegionOffset);
    PARAMETER_INITIALIZE(widhtOfRegion);
    PARAMETER_INITIALIZE(heightOfRegion);
    PARAMETER_INITIALIZE(horiNumOfRegion);
    PARAMETER_INITIALIZE(vertNumOfRegion);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enabldHardwarePDModule, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableOverlap, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfHoriGrids, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfVertGrids, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, horiNumOfRGNInGridUnit, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, vertNumOfRGNInGridUnit, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, horiRegionOffset, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, vertRegionOffset, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, widhtOfRegion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, heightOfRegion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, horiNumOfRegion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, vertNumOfRegion, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(value);
    PARAMETER_INITIALIZE(weight);

    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, weight, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(StatsTypeArr);
    PARAMETER_INITIALIZE(entries);

    result = afpdlibelements::ReadEnum_HDRStatsTypeGrid(entry, StatsTypeArr, alignment);

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(StatsTypeArr);
    PARAMETER_INITIALIZE(entries);

    result = afpdlibelements::ReadEnum_HDRStatsTypeGlobal(entry, StatsTypeArr, alignment);

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(biasType);
    PARAMETER_INITIALIZE(weight);

    result = afpdlibelements::ReadEnum_BiasExposureType(entry, biasType, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, weight, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(modeSelect);
    PARAMETER_INITIALIZE(bias);
    PARAMETER_INITIALIZE(statsTypeGlobal);
    PARAMETER_INITIALIZE(statsTypeGrid);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = afpdlibelements::ReadEnum_HDRStatsSelectionType(entry, modeSelect, alignment);
    }
    if (result)
    {
        result = bias.Load(entry, alignment);
    }
    if (result)
    {
        result = statsTypeGlobal.Load(entry, alignment);
    }
    if (result)
    {
        result = statsTypeGrid.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(entries);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(StatsControlArr);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(StatsControlArr);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(staticFrameCountThres);
    PARAMETER_INITIALIZE(maxFrameRate);

    SYMBOL_TABLE_ENTRY_READ(entry, result, staticFrameCountThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxFrameRate, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(weight);
    PARAMETER_INITIALIZE(confThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, weight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(PDProcessingAxis);
    PARAMETER_INITIALIZE(horizontalConfWeightTuning);
    PARAMETER_INITIALIZE(verticalConfWeightTuning);

    result = afpdlibelements::ReadEnum_chromatixPDAxisControl(entry, PDProcessingAxis, alignment);

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

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(processingMode);
    PARAMETER_INITIALIZE(dynamicLevel);
    PARAMETER_INITIALIZE(staticLevel);

    result = afpdlibelements::ReadEnum_chromatixPDProcessingMode(entry, processingMode, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, dynamicLevel, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, staticLevel, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(timeoutFrameCntThres);
    PARAMETER_INITIALIZE(filterSize);
    PARAMETER_INITIALIZE(state0StableCntThres);
    PARAMETER_INITIALIZE(state1StableCntThres);
    PARAMETER_INITIALIZE(minimumLensPosDelta);
    PARAMETER_INITIALIZE(state0ConfThres);
    PARAMETER_INITIALIZE(state1ConfThres);
    PARAMETER_INITIALIZE(state0PhaseDiffThres);
    PARAMETER_INITIALIZE(state1PhaseDiffThres);
    PARAMETER_INITIALIZE(tolNearTargetUpperBound);
    PARAMETER_INITIALIZE(tolNearTargetLowerBound);
    PARAMETER_INITIALIZE(tolFarTargetUpperBound);
    PARAMETER_INITIALIZE(tolFarTargetLowerBound);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, timeoutFrameCntThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, filterSize, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, state0StableCntThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, state1StableCntThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minimumLensPosDelta, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, state0ConfThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, state1ConfThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, state0PhaseDiffThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, state1PhaseDiffThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tolNearTargetUpperBound, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tolNearTargetLowerBound, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tolFarTargetUpperBound, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tolFarTargetLowerBound, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(maxRevCnt);
    PARAMETER_INITIALIZE(changeRatio);
    PARAMETER_INITIALIZE(revDisTol);
    PARAMETER_INITIALIZE(confThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxRevCnt, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, changeRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, revDisTol, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(AECTrigger);
    PARAMETER_INITIALIZE(dynamicWeight);
    PARAMETER_INITIALIZE(staticWeight);

    result = AECTrigger.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, dynamicWeight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, staticWeight, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(temporalFilterSet);

    for (UINT32 i = 0; result && i < 3; i++)
    {
        result = temporalFilterSet[i].Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(biasVectorStrength);
    PARAMETER_INITIALIZE(temporalFilterStaticWeight);
    PARAMETER_INITIALIZE(temporalFilterDynamicWeight);
    PARAMETER_INITIALIZE(temporalFilterTrigger);
    PARAMETER_INITIALIZE(enableGridOverlap);
    PARAMETER_INITIALIZE(enableFocusMapGridOverlap);
    PARAMETER_INITIALIZE(confIntegralWidth);
    PARAMETER_INITIALIZE(repeatPatternDetect);

    SYMBOL_TABLE_ENTRY_READ(entry, result, biasVectorStrength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, temporalFilterStaticWeight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, temporalFilterDynamicWeight, alignment)
    if (result)
    {
        result = temporalFilterTrigger.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableGridOverlap, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFocusMapGridOverlap, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confIntegralWidth, alignment)
    if (result)
    {
        result = repeatPatternDetect.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(from);
    PARAMETER_INITIALIZE(to);

    SYMBOL_TABLE_ENTRY_READ(entry, result, from, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, to, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(minimumConfidenceLevel);
    PARAMETER_INITIALIZE(defocusConfidenceThreshold);
    PARAMETER_INITIALIZE(PDRangeControl);
    PARAMETER_INITIALIZE(searchRange);
    PARAMETER_INITIALIZE(lcrSearchRange);
    PARAMETER_INITIALIZE(lcrConfidenceThresholdLow);
    PARAMETER_INITIALIZE(lcrConfidenceThresholdHigh);
    PARAMETER_INITIALIZE(advanceSparseProcMode);

    SYMBOL_TABLE_ENTRY_READ(entry, result, minimumConfidenceLevel, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusConfidenceThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, PDRangeControl, alignment)
    if (result)
    {
        result = searchRange.Load(entry, alignment);
    }
    if (result)
    {
        result = lcrSearchRange.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, lcrConfidenceThresholdLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, lcrConfidenceThresholdHigh, alignment)
    if (result)
    {
        result = afpdlibelements::ReadEnum_chromatixAdvanceSparseProcMode(entry, advanceSparseProcMode, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(AECTrigger);
    PARAMETER_INITIALIZE(verticalMode);
    PARAMETER_INITIALIZE(horizontalMode);
    PARAMETER_INITIALIZE(boxFilterLength);
    PARAMETER_INITIALIZE(antiAliasFilterThreshold);

    result = AECTrigger.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, verticalMode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, horizontalMode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, boxFilterLength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, antiAliasFilterThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(filterSet);

    for (UINT32 i = 0; result && i < 3; i++)
    {
        result = filterSet[i].Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(filterSet);

    for (UINT32 i = 0; result && i < 3; i++)
    {
        result = filterSet[i].Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(mode);
    PARAMETER_INITIALIZE(sequenceCntThreshold);
    PARAMETER_INITIALIZE(pixelValThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = afpdlibelements::ReadEnum_chromatixSpotlightDetectionMode(entry, mode, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, sequenceCntThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pixelValThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(channelSelection);
    PARAMETER_INITIALIZE(longThreshold);

    result = afpdlibelements::ReadEnum_chromatixHDRChannelSelection(entry, channelSelection, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, longThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(sparseProcessingMode);
    PARAMETER_INITIALIZE(HDR);
    PARAMETER_INITIALIZE(boxFilterLength);
    PARAMETER_INITIALIZE(antiAliasFilterThreshold);
    PARAMETER_INITIALIZE(saturationThreshold);
    PARAMETER_INITIALIZE(spotLightCompensation);
    PARAMETER_INITIALIZE(filterTrigger);
    PARAMETER_INITIALIZE(lcrFilterTrigger);
    PARAMETER_INITIALIZE(lcrChannel);
    PARAMETER_INITIALIZE(lcrBinningMode);
    PARAMETER_INITIALIZE(lcrRawType);
    PARAMETER_INITIALIZE(lcrMaxBinningNum);
    PARAMETER_INITIALIZE(lcrChannelSeparated);
    PARAMETER_INITIALIZE(lcrXCFAType);

    result = afpdlibelements::ReadEnum_chromatixSparsePDProcMode(entry, sparseProcessingMode, alignment);
    if (result)
    {
        result = HDR.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, boxFilterLength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, antiAliasFilterThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, saturationThreshold, alignment)
    if (result)
    {
        result = spotLightCompensation.Load(entry, alignment);
    }
    if (result)
    {
        result = filterTrigger.Load(entry, alignment);
    }
    if (result)
    {
        result = lcrFilterTrigger.Load(entry, alignment);
    }
    if (result)
    {
        result = afpdlibelements::ReadEnum_chromatixLCRChannel(entry, lcrChannel, alignment);
    }
    if (result)
    {
        result = afpdlibelements::ReadEnum_chromatixLCRBinningMode(entry, lcrBinningMode, alignment);
    }
    if (result)
    {
        result = afpdlibelements::ReadEnum_chromatixLCRRawType(entry, lcrRawType, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, lcrMaxBinningNum, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, lcrChannelSeparated, alignment)
    if (result)
    {
        result = afpdlibelements::ReadEnum_chromatixLCRXCFAType(entry, lcrXCFAType, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(preProcess);
    PARAMETER_INITIALIZE(preProcessVertical);
    PARAMETER_INITIALIZE(correlation);
    PARAMETER_INITIALIZE(correlationVertical);
    PARAMETER_INITIALIZE(postProcess);
    PARAMETER_INITIALIZE(postProcessVertical);
    PARAMETER_INITIALIZE(adaptiveK);
    PARAMETER_INITIALIZE(enablePeripheralWindows);
    PARAMETER_INITIALIZE(singleWindowProcessingLevel);
    PARAMETER_INITIALIZE(singleWindowProcessingLevelVertical);
    PARAMETER_INITIALIZE(gridProcessingLevel);
    PARAMETER_INITIALIZE(gridProcessingLevelVertical);
    PARAMETER_INITIALIZE(PeripheralProcessing);
    PARAMETER_INITIALIZE(PeripheralProcessingVertical);
    PARAMETER_INITIALIZE(LFMProcessingLevel);
    PARAMETER_INITIALIZE(HVControl);
    PARAMETER_INITIALIZE(skipControl);
    PARAMETER_INITIALIZE(HDRControl);
    PARAMETER_INITIALIZE(hardwareGeometry);
    PARAMETER_INITIALIZE(hardwarePattern);
    PARAMETER_INITIALIZE(enableFocusMaps);
    PARAMETER_INITIALIZE(FocusMapInterrupt);
    PARAMETER_INITIALIZE(LFMCorrectionRange);
    PARAMETER_INITIALIZE(PDHWOutputControl);
    PARAMETER_INITIALIZE(darkFaceOptimization);
    PARAMETER_INITIALIZE(mlpdControlProcess);
    PARAMETER_INITIALIZE(PDHWFallbackControl);
    PARAMETER_INITIALIZE(extensionParam);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = preProcess.Load(entry, alignment);
    }
    if (result)
    {
        result = preProcessVertical.Load(entry, alignment);
    }
    if (result)
    {
        result = correlation.Load(entry, alignment);
    }
    if (result)
    {
        result = correlationVertical.Load(entry, alignment);
    }
    if (result)
    {
        result = postProcess.Load(entry, alignment);
    }
    if (result)
    {
        result = postProcessVertical.Load(entry, alignment);
    }
    if (result)
    {
        result = adaptiveK.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enablePeripheralWindows, alignment)
    if (result)
    {
        result = singleWindowProcessingLevel.Load(entry, alignment);
    }
    if (result)
    {
        result = singleWindowProcessingLevelVertical.Load(entry, alignment);
    }
    if (result)
    {
        result = gridProcessingLevel.Load(entry, alignment);
    }
    if (result)
    {
        result = gridProcessingLevelVertical.Load(entry, alignment);
    }
    if (result)
    {
        result = PeripheralProcessing.Load(entry, alignment);
    }
    if (result)
    {
        result = PeripheralProcessingVertical.Load(entry, alignment);
    }
    if (result)
    {
        result = LFMProcessingLevel.Load(entry, alignment);
    }
    if (result)
    {
        result = HVControl.Load(entry, alignment);
    }
    if (result)
    {
        result = skipControl.Load(entry, alignment);
    }
    if (result)
    {
        result = HDRControl.Load(entry, alignment);
    }
    if (result)
    {
        result = hardwareGeometry.Load(entry, alignment);
    }

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

            if (hardwarePattern == nullptr)
            {
                if (result && hardwarePatternCount > 0)
                {
                    hardwarePattern = PARAMETER_NEW chromatixTuningHardwarePattern[hardwarePatternCount];
                    (void)pointerEntry->SetDupObject(hardwarePattern, hardwarePatternCount, file, line);
                }
                if (!result || hardwarePattern == nullptr)
                {
                    if (hardwarePatternCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate hardwarePattern\n");
                    }
                    hardwarePatternCount = 0;
                }
                for (UINT32 i = 0; result && i < hardwarePatternCount; i++)
                {
                    result = hardwarePattern[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (hardwarePattern == nullptr)
        {
            hardwarePatternCount = 0;
        }
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFocusMaps, alignment)
    if (result)
    {
        result = afpdlibelements::ReadEnum_chromatixPDLibProcessInterrupt(entry, FocusMapInterrupt, alignment);
    }
    if (result)
    {
        result = entry->ReadArray(LFMCorrectionRange, 2, alignment);
    }
    if (result)
    {
        result = PDHWOutputControl.Load(entry, alignment);
    }
    if (result)
    {
        result = darkFaceOptimization.Load(entry, alignment);
    }
    if (result)
    {
        result = mlpdControlProcess.Load(entry, alignment);
    }
    if (result)
    {
        result = PDHWFallbackControl.Load(entry, alignment);
    }

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

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

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixPDLibType::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 chromatixPDLibType::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 chromatixPDHWFallbackControl
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDHWFallbackControl::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(controlArr))
    {
        PARAMETER_DELETE[] controlArr;
    }
    controlArr = nullptr;
}

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixTuningHardwarePattern
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixTuningHardwarePattern::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(lineExtractor))
    {
        PARAMETER_DELETE[] lineExtractor;
    }
    lineExtractor = nullptr;
    pixelSeparator.Unload(__table);
    resampler.Unload(__table);
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDLibHDRControl
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDLibHDRControl::Unload(ParameterFileSymbolTable* const __table)
{
    bias.Unload(__table);
    statsTypeGlobal.Unload(__table);
    statsTypeGrid.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDLibHDRControl_statsTypeGlobalStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDLibHDRControl::statsTypeGlobalStruct::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < StatsControlArrCount; i++)
    {
        StatsControlArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(StatsControlArr))
    {
        PARAMETER_DELETE[] StatsControlArr;
    }
    StatsControlArr = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDLibHDRControl_statsTypeGridStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDLibHDRControl::statsTypeGridStruct::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < StatsControlArrCount; i++)
    {
        StatsControlArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(StatsControlArr))
    {
        PARAMETER_DELETE[] StatsControlArr;
    }
    StatsControlArr = nullptr;
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDLibType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDLibType::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    HVControl.Unload(__table);
    HDRControl.Unload(__table);
    for (UINT32 i = 0; i < hardwarePatternCount; i++)
    {
        hardwarePattern[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(hardwarePattern))
    {
        PARAMETER_DELETE[] hardwarePattern;
    }
    hardwarePattern = nullptr;
    PDHWFallbackControl.Unload(__table);
    for (UINT32 i = 0; i < extensionParamCount; i++)
    {
        extensionParam[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(extensionParam))
    {
        PARAMETER_DELETE[] extensionParam;
    }
    extensionParam = nullptr;
}

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

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

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

    return (ParameterModule*)cls;
}

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

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

AFPDLIBELEMENTS_NAMESPACE_END
