////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016-2023 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  chivendortagoemdefines.h
/// @brief Define Qualcomm Technologies, Inc. OEM VendorTag define
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CHIVENDORTAGOEMDEFINES_H
#define CHIVENDORTAGOEMDEFINES_H

/************************************************************************************************
 *
 * IMPORTANT NOTE:
 *
 *   This file is customer vendorTag define headers
 *
 *   - DO NOT ADD INTERNAL USAGE VENDORTAG
 *   - DO NOT CHANGE THE LAYOUT
 ************************************************************************************************/

#include "chi.h"
#include "camera_metadata.h"
#include "chiafcommon.h"
#include "chiipedefs.h"
#include "chivendortag.h"
#include "chistatsproperty.h"


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// VendorTag Type Define
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/// @brief structure to contain eisv3 algo perspective matrix and grid
struct EISV3PerspectiveGridTransforms
{
    IPEICAPerspectiveTransform perspective;         ///< Stabilization perspective transform
    IPEICAGridTransform        grid;                ///< LDC grid
    IPEICAPerspectiveTransform alignmentMatrix;     ///< Gyro MCTF alignemnt
    IPEICAGridTransform        gridDIS;             ///< DIS grid
};

/// @brief structure to contain eisv3 time interval
struct EISv3TimeInterval
{
    UINT64 timeIntervalStart;                       ///< Start ts of Time interval
    UINT64 timeIntervalEnd;                         ///< End ts of time interval
};

/// @brief structure to contain eisv3 algo handle
struct EISv3AlgoHandleData
{
    VOID*             isalgoHandle;                 ///< EISv3 algo handle
};

/// @brief structure to contain eisv3 time interval sync info betweeen stablization and distortion node
struct EISv3AlgoTimeIntervalSync
{
    EISv3TimeInterval timeIntervalWindow;           ///< Time interval window
    UINT64            lastGyroSampleTs;             ///< Previous frame last gyro sample timestamp
    UINT32            noOfsampleReceived;           ///< Number of sample received for specified time interval
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// VendorTag Data Define
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///< awbwrapper.cpp, Section:com.qti.stats.awbwrapper
static CHIVENDORTAGDATA g_VendorTagSectionWrapperAWB[] =
{
    { "AWBGains",                           TYPE_FLOAT,    3, NoPrintFormat },
    { "AWBCCT",                             TYPE_INT32,    1, NoPrintFormat }
};

///< camxchinodedummystich.cpp, Section:com.qti.node.dummystich
static CHIVENDORTAGDATA g_VendorTagSectionDummyStich[] =
{
    { "SupportedFeature",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat }
};

///< camxchinodeeisv2.cpp, Section:com.qti.node.eisv2
static CHIVENDORTAGDATA g_VendorTagSectionEISV2Node[] =
{
    { "AlgoComplete",                       0,             sizeof(BOOL), NoPrintFormat }
};

///< camxchinodeswmctf.cpp, Section:com.qti.node.swmctf
static CHIVENDORTAGDATA g_VendorTagSectionSWMCTFNode[] =
{
    { "RegisterComplete",                   0,             sizeof(BOOL),    NoPrintFormat   },
    { "ProcessComplete",                    0,             sizeof(BOOL),    NoPrintFormat   },
    { "MaintainSequence",                   0,             sizeof(BOOL),    NoPrintFormat   },
	{ "ExtraHALBuffers",                    0,             sizeof(UINT32),  NoPrintFormat   }
};

///< camxchinodecustomhwnode.cpp, Section:com.qti.node.customhw
static CHIVENDORTAGDATA g_VendorTagSectionCustomHwNode[] =
{
};

///< camxchinodedummyrtb.cpp, Section:com.qti.node.dummyrtb
static CHIVENDORTAGDATA g_VendorTagSectionDummyRTB[] =
{
    { "SupportedFeature",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat }
};

///< camxchinodedummydepth.cpp, Section:com.qti.node.dummydepth
static CHIVENDORTAGDATA g_VendorTagSectionDummyDepth[] =
{
    { "Depth2LUT",                          TYPE_BYTE,     256,                               NoPrintFormat },
};

///< camxchinodemuxer.cpp, Section:com.qti.node.muxer
static CHIVENDORTAGDATA g_VendorTagSectionMuxer[] =
{

};

///< camxchinodedummysat.cpp, Section:com.qti.node.dummysat
static CHIVENDORTAGDATA g_VendorTagSectionDummySAT[] =
{
    { "SupportedFeature",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat }
};

///< camxchinodefcv.cpp, Section:com.qti.node.fcv
static CHIVENDORTAGDATA g_VendorTagSectionFCV[] =
{
    { "SupportedFeature",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat },
    { "CurrentMode",                        TYPE_BYTE,     1,                                 NoPrintFormat },
    { "ProcessedFrameNumber",               TYPE_INT64,    1,                                 NoPrintFormat },
    { "FrameDimension",                     TYPE_INT32,    2,                                 NoPrintFormat },
    { "BypassCameraId",                     TYPE_INT32,    1,                                 NoPrintFormat },
};

///< camxchinodegpu.cpp, Section:com.qti.node.gpu
static CHIVENDORTAGDATA g_VendorTagSectionGpuNode[] =
{
    { "SupportedFeature",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat },
    { "CurrentMode",                        TYPE_BYTE,     1,                                 NoPrintFormat },
    { "ProcessedFrameNumber",               TYPE_INT64,    1,                                 NoPrintFormat },
    { "FrameDimension",                     TYPE_INT32,    2,                                 NoPrintFormat },
    { "BypassCameraId",                     TYPE_INT32,    1,                                 NoPrintFormat },
};


///< camxchinodememcpy.cpp, Section:com.qti.node.memcpy
static CHIVENDORTAGDATA g_VendorTagSectionMemCpy[] =
{
    { "SupportedFeature",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat }
};

///< camxchinoderemosaic.cpp, Section:com.qti.node.remosaic
static CHIVENDORTAGDATA g_VendorTagSectionRemosaic[] =
{
    { "SupportedFeature",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat }
};

///< camxstaticaecalgoimpl.cpp, Section:com.qtistatic.stats.aec
static CHIVENDORTAGDATA g_VendorTagDataAEC[] =
{
    { "VendorTag1",                         TYPE_DOUBLE,   1, NoPrintFormat                      },
    { "VendorTag2",                         TYPE_INT32,    1, NoPrintFormat                      },
};

///< camxawb.cpp, Section:com.qtistatic.stats.awb
static CHIVENDORTAGDATA g_VendorTagDataAWB[] =
{
    { "AWBAlgoTag1",                        TYPE_DOUBLE,   1, NoPrintFormat                      },
    { "AWBAlgoTag2",                        TYPE_INT32,    1, NoPrintFormat                      },
};

///< camxaf.cpp, Section:com.qtistatic.stats.af
static CHIVENDORTAGDATA g_VendorTagDataAF[] =
{
    { "AFAlgoTag1",                         TYPE_DOUBLE,   1, NoPrintFormat                      },
    { "AFAlgoTag2",                         TYPE_INT32,    1, NoPrintFormat                      },
};

///< camxpdlib.cpp Section:com.qtistatic.stats.pdlib
static CHIVENDORTAGDATA g_VendorTagDataPD[] =
{
    { "PDLibTag1",                          TYPE_DOUBLE,   1, NoPrintFormat                      },
    { "PDLibTag2",                          TYPE_INT32,    1, NoPrintFormat                      },
};

///< camxchinodeswregistration.cpp, Section:org.quic.camera2.ipeicaconfigs
static CHIVENDORTAGDATA g_VendorTagSectionSWRegistration[] =
{
    { "ICAInPerspectiveTransform",       0,    sizeof(IPEICAPerspectiveTransform), PrintIPEICAPerspectiveTransform },

};

///< camxchinodeeisv3.cpp, Section:com.qti.node.eisv3
static CHIVENDORTAGDATA g_VendorTagSectionEISV3Node[] =
{
    { "PerspectiveGridTransform",        0,    sizeof(EISV3PerspectiveGridTransforms), PrintEISV3PerspectiveGridTransforms },
    { "EIS3Handle",                      0,    sizeof(EISv3AlgoHandleData),            PrintEISv3AlgoHandleData },
    { "EISv3TimeIntervalSync",           0,    sizeof(EISv3AlgoTimeIntervalSync),      PrintEISv3AlgoTimeIntervalSync },
};

///< camxchinodedepth.cpp, Section:com.qti.node.depth
static CHIVENDORTAGDATA g_VendorTagSectionDepth[] =
{
    { "PointCloudCount",        TYPE_INT64, 1, NoPrintFormat },
};

///< camxchinodedepthprovider.cpp, Section:com.qti.node.depthprovider
static CHIVENDORTAGDATA g_VendorTagSectionDepthProviderNode[] =
{
    { "DepthTimestamp",         TYPE_BYTE,   sizeof(UINT64), NoPrintFormat                      },
};

///< camxchinodeaon.cpp, Section:com.qti.node.aon
static CHIVENDORTAGDATA g_VendorTagSectionAONNode[] =
{
    { "AONInfo",    TYPE_BYTE, sizeof(AONInfo), NoPrintFormat },
};

///< camxchinodeevs.cpp, Section:com.qti.node.evs
static CHIVENDORTAGDATA g_VendorTagSectionEVSNode[] =
{
    { "SupportedFeatureEVS",                   TYPE_BYTE,     ChiNodeSupportedFeatureBufferSize, NoPrintFormat }
};

///< camxchinodeitofpreprocess.cpp, Section:com.qti.node.itofpreprocess
static CHIVENDORTAGDATA g_VendorTagSectionTofPreProcess[] =
{
    ///< ITOF indoor/ outdoor flag
    { "ITOFIndoorOutdoorFlag",      TYPE_BYTE,   1,                             NoPrintFormat },
    ///< ITOF input average of intensity
    { "ITOFIntensityAverage",       TYPE_FLOAT,  1,                             NoPrintFormat },
    ///< ITOF input average of amplitude
    { "ITOFAmplitudeAverage",       TYPE_FLOAT,  1,                             NoPrintFormat },
    ///< ITOF sensor preprocessing calibration output parameters
    { "ITOFPreProcessInitInfo",     TYPE_BYTE,   sizeof(ITOFPreprocessCalInfo), PrintITOFPreprocessCalInfo }
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// VendorTag Section Define
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///< awbwrapper.cpp
static const CHAR AWBWrapperSectionName[] = "com.qti.stats.awbwrapper";

static CHIVENDORTAGSECTIONDATA g_VendorTagSectionWrapperDataAWB[] =
{
    {
        AWBWrapperSectionName,  0,
        sizeof(g_VendorTagSectionWrapperAWB) / sizeof(g_VendorTagSectionWrapperAWB[0]), g_VendorTagSectionWrapperAWB,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodedummystich.cpp
static const CHAR DummyStichNodeSectionName[]       = "com.qti.node.dummystich";

static CHIVENDORTAGSECTIONDATA g_VendorTagDummyStichSection[] =
{
    {
        DummyStichNodeSectionName,  0,
        sizeof(g_VendorTagSectionDummyStich) / sizeof(g_VendorTagSectionDummyStich[0]), g_VendorTagSectionDummyStich,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodeeisv3.cpp
static const CHAR EISv3NodeSectionName[]            = "com.qti.node.eisv3";

static CHIVENDORTAGSECTIONDATA g_VendorTagEISV3NodeSection[] =
{
    {
        EISv3NodeSectionName,  0,
        sizeof(g_VendorTagSectionEISV3Node) / sizeof(g_VendorTagSectionEISV3Node[0]), g_VendorTagSectionEISV3Node,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    }
};


///< camxchinodeeisv2.cpp
static const CHAR   EISv2NodeSectionName[]        = "com.qti.node.eisv2";                       ///< EISV2

static CHIVENDORTAGSECTIONDATA g_VendorTagEISV2NodeSection[] =
{
    {
        EISv2NodeSectionName,  0,
        sizeof(g_VendorTagSectionEISV2Node) / sizeof(g_VendorTagSectionEISV2Node[0]), g_VendorTagSectionEISV2Node,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    }
};

///< camxchinodeswmctf.cpp
static const CHAR   SWMCTFNodeSectionName[]       = "com.qti.node.swmctf";                      ///< The section name for node
static const CHAR   SWMCTFAlgoLibName[]           = "libmctfengine_stub";                       ///< MCTF algo library name
static const CHAR   CameraConfigSectionName[]     = "com.qti.chi.cameraconfiguration";          ///< Multicamera

static CHIVENDORTAGSECTIONDATA g_VendorTagSWMCTFNodeSection[] =
{
    {
        SWMCTFNodeSectionName,  0,
        sizeof(g_VendorTagSectionSWMCTFNode) / sizeof(g_VendorTagSectionSWMCTFNode[0]), g_VendorTagSectionSWMCTFNode,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodecustomhwnode.cpp
static const CHAR   CustomHwNodeNodeSectionName[]  = "com.qti.node.customhw";

static CHIVENDORTAGSECTIONDATA g_VendorTagCustomHwNodeSection[] =
{
    {
        CustomHwNodeNodeSectionName,  0,
        sizeof(g_VendorTagSectionCustomHwNode) / sizeof(g_VendorTagSectionCustomHwNode[0]), g_VendorTagSectionCustomHwNode,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodedepth.cpp
static const CHAR DepthNodeSectionName[]            = "com.qti.node.depth";

static CHIVENDORTAGSECTIONDATA g_VendorTagDepthSection[] =
{
    {
        DepthNodeSectionName,  0,
        sizeof(g_VendorTagSectionDepth) / sizeof(g_VendorTagSectionDepth[0]), g_VendorTagSectionDepth,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

static ChiVendorTagInfo g_VendorTagInfoDepth[] =
{
    {
        &g_VendorTagDepthSection[0],
        sizeof(g_VendorTagDepthSection) / sizeof(g_VendorTagDepthSection[0])
    }
};

///< camxchinodeitofpreprocess.cpp
static const CHAR TofPreProcessNodeSectionName[]            = "com.qti.node.itofpreprocess";

static CHIVENDORTAGSECTIONDATA g_VendorTagTofPreProcessSection[] =
{
    {
        TofPreProcessNodeSectionName,  0,
        sizeof(g_VendorTagSectionTofPreProcess) / sizeof(g_VendorTagSectionTofPreProcess[0]),
        g_VendorTagSectionTofPreProcess,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

static ChiVendorTagInfo g_VendorTagInfoTofPreProcess[] =
{
    {
        &g_VendorTagTofPreProcessSection[0],
        sizeof(g_VendorTagTofPreProcessSection) / sizeof(g_VendorTagTofPreProcessSection[0])
    }
};

///< camxchinodedummydepth.cpp
static const CHAR DummyDepthNodeSectionName[]            = "com.qti.node.dummydepth";

static CHIVENDORTAGSECTIONDATA g_VendorTagDummyDepthSection[] =
{
    {
        DummyDepthNodeSectionName,  0,
        sizeof(g_VendorTagSectionDummyDepth) / sizeof(g_VendorTagSectionDummyDepth[0]), g_VendorTagSectionDummyDepth,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

static ChiVendorTagInfo g_VendorTagInfoDummyDepth[] =
{
    {
        &g_VendorTagDummyDepthSection[0],
        sizeof(g_VendorTagDummyDepthSection) / sizeof(g_VendorTagDummyDepthSection[0])
    }
};

///< camxchinodemuxer.cpp
static const CHAR MuxerNodeSectionName[]            = "com.qti.node.muxer";

static CHIVENDORTAGSECTIONDATA g_VendorTagMuxerSection[] =
{
    {
        MuxerNodeSectionName,  0,
        sizeof(g_VendorTagSectionMuxer) / sizeof(g_VendorTagSectionMuxer[0]), g_VendorTagSectionMuxer,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

static ChiVendorTagInfo g_VendorTagInfoMuxer[] =
{
    {
        &g_VendorTagMuxerSection[0],
        sizeof(g_VendorTagMuxerSection) / sizeof(g_VendorTagMuxerSection[0])
    }
};

///< camxchinodedummyrtb.cpp
static const CHAR DummyRTBNodeSectionName[]         = "com.qti.node.dummyrtb";

static CHIVENDORTAGSECTIONDATA g_VendorTagDummyRTBSection[] =
{
    {
        DummyRTBNodeSectionName,  0,
        sizeof(g_VendorTagSectionDummyRTB) / sizeof(g_VendorTagSectionDummyRTB[0]), g_VendorTagSectionDummyRTB,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodedummysat.cpp
static const CHAR DummySATNodeSectionName[]         = "com.qti.node.dummysat";

static CHIVENDORTAGSECTIONDATA g_VendorTagDummySATSection[] =
{
    {
        DummySATNodeSectionName,  0,
        sizeof(g_VendorTagSectionDummySAT) / sizeof(g_VendorTagSectionDummySAT[0]), g_VendorTagSectionDummySAT,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodefcv.cpp
static const CHAR FCVNodeSectionName[]              = "com.qti.node.fcv";

static CHIVENDORTAGSECTIONDATA g_VendorTagFCVSection[] =
{
    {
        FCVNodeSectionName,  0,
        sizeof(g_VendorTagSectionFCV) / sizeof(g_VendorTagSectionFCV[0]), g_VendorTagSectionFCV,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodegpu.cpp
static const CHAR GpuNodeSectionName[]              = "com.qti.node.gpu";
static const CHAR GpuNodeInputSectionName[]         = "com.qti.node.gpuinput";

static CHIVENDORTAGSECTIONDATA g_VendorTagGpuNodeSection[] =
{
    {
        GpuNodeSectionName,  0,
        sizeof(g_VendorTagSectionGpuNode) / sizeof(g_VendorTagSectionGpuNode[0]), g_VendorTagSectionGpuNode,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodememcpy.cpp
static const CHAR MemCpyNodeSectionName[]           = "com.qti.node.memcpy";

static CHIVENDORTAGSECTIONDATA g_VendorTagMemCpySection[] =
{
    {
        MemCpyNodeSectionName,  0,
        sizeof(g_VendorTagSectionMemCpy) / sizeof(g_VendorTagSectionMemCpy[0]), g_VendorTagSectionMemCpy,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinoderemosaic.cpp
static const CHAR RemosaicNodeSectionName[]         = "com.qti.node.remosaic";

static CHIVENDORTAGSECTIONDATA g_VendorTagRemosaicSection[] =
{
    {
        RemosaicNodeSectionName,  0,
        sizeof(g_VendorTagSectionRemosaic) / sizeof(g_VendorTagSectionRemosaic[0]), g_VendorTagSectionRemosaic,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxstaticaecalgoimpl.cpp
static const CHAR StaticAECAlgoSectionName[]        = "com.qtistatic.stats.aec";

static CHIVENDORTAGSECTIONDATA g_VendorTagStaticSectionDataAEC[] =
{
    {
        StaticAECAlgoSectionName,  0,
        sizeof(g_VendorTagDataAEC) / sizeof(g_VendorTagDataAEC[0]), g_VendorTagDataAEC,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxawb.cpp
static const CHAR StaticAWBAlgoSectionName[]        = "com.qtistatic.stats.awb";

static CHIVENDORTAGSECTIONDATA g_VendorTagStaticSectionDataAWB[] =
{
    {
        StaticAWBAlgoSectionName,  0,
        sizeof(g_VendorTagDataAWB) / sizeof(g_VendorTagDataAWB[0]), g_VendorTagDataAWB,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxaf.cpp
static const CHAR StaticAFAlgoSectionName[]         = "com.qtistatic.stats.af";

static CHIVENDORTAGSECTIONDATA g_VendorTagStaticSectionDataAF[] =
{
    {
        StaticAFAlgoSectionName,  0,
        sizeof(g_VendorTagDataAF) / sizeof(g_VendorTagDataAF[0]), g_VendorTagDataAF,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxpdlib.cpp
static const CHAR StaticPDLibSectionName[]          = "com.qtistatic.stats.pdlib";

static CHIVENDORTAGSECTIONDATA g_VendorTagStaticSectionDataPD[] =
{
    {
        StaticPDLibSectionName,  0,
        sizeof(g_VendorTagDataPD) / sizeof(g_VendorTagDataPD[0]), g_VendorTagDataPD,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodeswmfnr.cpp
static const CHAR SWMFNRNodeSectionName[]           = "com.qti.node.swmfnr";

///< camxpdlibinterface.cpp
static const CHAR SonyPDLibSectionName[]            = "com.sonystatic.stats.pdlib";

static CHIVENDORTAGSECTIONDATA g_VendorTagSectionDataSonyPD[] =
{
    {
        SonyPDLibSectionName,  0,
        sizeof(g_VendorTagDataPD) / sizeof(g_VendorTagDataPD[0]), g_VendorTagDataPD,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

///< camxchinodedepthprovider.cpp
static const CHAR DepthProviderNodeSectionName[]            = "com.qti.node.depthprovider";

static CHIVENDORTAGSECTIONDATA g_VendorTagDepthProviderNodeSection[] =
{
    {
        DepthProviderNodeSectionName,  0,
        sizeof(g_VendorTagSectionDepthProviderNode) / sizeof(g_VendorTagSectionDepthProviderNode[0]),
        g_VendorTagSectionDepthProviderNode,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    }
};

///< camxchinodedepthprovider.cpp
static const CHAR AONNodeSectionName[]            = "com.qti.node.aon";

static CHIVENDORTAGSECTIONDATA g_VendorTagAONNodeSection[] =
{
    {
        AONNodeSectionName,  0,
        sizeof(g_VendorTagSectionAONNode) / sizeof(g_VendorTagSectionAONNode[0]),
        g_VendorTagSectionAONNode,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    }
};

///< camxchinodeevs.cpp
static const CHAR EVSNodeSectionName[]            = "com.qti.node.evs";

static CHIVENDORTAGSECTIONDATA g_VendorTagEVSNodeSection[] =
{
    {
        EVSNodeSectionName,  0,
        sizeof(g_VendorTagSectionEVSNode) / sizeof(g_VendorTagSectionEVSNode[0]),
        g_VendorTagSectionEVSNode,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    }
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// VendorTag Info Define
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///< awbwrapper.cpp
static ChiVendorTagInfo g_VendorTagInfoWrapperAWB[] =
{
    {
        &g_VendorTagSectionWrapperDataAWB[0],
        sizeof(g_VendorTagSectionWrapperDataAWB) / sizeof(g_VendorTagSectionWrapperDataAWB[0])
    }
};

///< camxchinodedummystich.cpp
static ChiVendorTagInfo g_VendorTagInfoDummyStich[] =
{
    {
        &g_VendorTagDummyStichSection[0],
        sizeof(g_VendorTagDummyStichSection) / sizeof(g_VendorTagDummyStichSection[0])
    }
};

///< camxchinodeeisv3.cpp
static ChiVendorTagInfo g_VendorTagInfoEISV3Node[] =
{
    {
        &g_VendorTagEISV3NodeSection[0],
        sizeof(g_VendorTagEISV3NodeSection) / sizeof(g_VendorTagEISV3NodeSection[0])
    }
};

///< camxchinodeeisv2.cpp
static ChiVendorTagInfo g_VendorTagInfoEISV2Node[] =
{
    {
        &g_VendorTagEISV2NodeSection[0],
        sizeof(g_VendorTagEISV2NodeSection) / sizeof(g_VendorTagEISV2NodeSection[0])
    }
};

///< camxchinodeswmctf.cpp
static ChiVendorTagInfo g_VendorTagInfoSWMCTFNode[] =
{
    {
        &g_VendorTagSWMCTFNodeSection[0],
        sizeof(g_VendorTagSWMCTFNodeSection) / sizeof(g_VendorTagSWMCTFNodeSection[0])
    }
};

///< camxchinodecustomhwnode.cpp
static ChiVendorTagInfo g_VendorTagInfoCustomHwNode[] =
{
    {
        &g_VendorTagCustomHwNodeSection[0],
        sizeof(g_VendorTagCustomHwNodeSection) / sizeof(g_VendorTagCustomHwNodeSection[0])
    }
};

///< camxchinodedummyrtb.cpp
static ChiVendorTagInfo g_VendorTagInfoDummyRTB[] =
{
    {
        &g_VendorTagDummyRTBSection[0],
        sizeof(g_VendorTagDummyRTBSection) / sizeof(g_VendorTagDummyRTBSection[0])
    }
};

///< camxchinodedummysat.cpp
static ChiVendorTagInfo g_VendorTagInfoDummySAT[] =
{
    {
        &g_VendorTagDummySATSection[0],
        sizeof(g_VendorTagDummySATSection) / sizeof(g_VendorTagDummySATSection[0])
    }
};

///< camxchinodefcv.cpp
static ChiVendorTagInfo g_VendorTagInfoFCV[] =
{
    {
        &g_VendorTagFCVSection[0],
        sizeof(g_VendorTagFCVSection) / sizeof(g_VendorTagFCVSection[0])
    }
};

///< camxchinodegpu.cpp
static ChiVendorTagInfo g_VendorTagInfoGpuNode[] =
{
    {
        &g_VendorTagGpuNodeSection[0],
        sizeof(g_VendorTagGpuNodeSection) / sizeof(g_VendorTagGpuNodeSection[0])
    }
};

///< camxchinodememcpy.cpp
static ChiVendorTagInfo g_VendorTagInfoMemCpy[] =
{
    {
        &g_VendorTagMemCpySection[0],
        sizeof(g_VendorTagMemCpySection) / sizeof(g_VendorTagMemCpySection[0])
    }
};

///< camxchinoderemosaic.cpp
static ChiVendorTagInfo g_VendorTagInfoRemosaic[] =
{
    {
        &g_VendorTagRemosaicSection[0],
        sizeof(g_VendorTagRemosaicSection) / sizeof(g_VendorTagRemosaicSection[0])
    }
};

///< camxstaticaecalgoimpl.cpp
static ChiVendorTagInfo g_VendorTagInfoAEC[] =
{
    {
        &g_VendorTagStaticSectionDataAEC[0],
        sizeof(g_VendorTagStaticSectionDataAEC) / sizeof(g_VendorTagStaticSectionDataAEC[0])
    }
};

///< camxawb.cpp
static ChiVendorTagInfo g_VendorTagInfoAWB[] =
{
    {
        &g_VendorTagStaticSectionDataAWB[0],
        sizeof(g_VendorTagStaticSectionDataAWB) / sizeof(g_VendorTagStaticSectionDataAWB[0])
    }
};

///< camxaf.cpp
static ChiVendorTagInfo g_VendorTagInfoAF[] =
{
    {
        &g_VendorTagStaticSectionDataAF[0],
        sizeof(g_VendorTagStaticSectionDataAF) / sizeof(g_VendorTagStaticSectionDataAF[0])
    }
};

///< camxpdlib.cpp
static ChiVendorTagInfo g_VendorTagInfoStaticPD[] =
{
    {
        &g_VendorTagStaticSectionDataPD[0],
        sizeof(g_VendorTagStaticSectionDataPD) / sizeof(g_VendorTagStaticSectionDataPD[0])
    }
};

static ChiVendorTagInfo g_VendorTagInfoSonyPD[] =
{
    {
        &g_VendorTagSectionDataSonyPD[0],
        sizeof(g_VendorTagSectionDataSonyPD) / sizeof(g_VendorTagSectionDataSonyPD[0])
    }
};

///< camxchinodedepthprovider.cpp
static ChiVendorTagInfo g_VendorTagInfoDepthProviderNode[] =
{
    {
        &g_VendorTagDepthProviderNodeSection[0],
        sizeof(g_VendorTagDepthProviderNodeSection) / sizeof(g_VendorTagDepthProviderNodeSection[0])
    }
};

///< camxchinodeevs.cpp
static ChiVendorTagInfo g_VendorTagInfoEVSNode[] =
{
    {
        &g_VendorTagEVSNodeSection[0],
        sizeof(g_VendorTagEVSNodeSection) / sizeof(g_VendorTagEVSNodeSection[0])
    }
};

#endif // CHIVENDORTAGOEMDEFINES_H
