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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  chivendortagdefines.h
/// @brief Define Qualcomm Technologies, Inc. CHI VendorTag define
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CHIVENDORTAGDEFINES_H
#define CHIVENDORTAGDEFINES_H

/************************************************************************************************
 *
 * IMPORTANT NOTE:
 *
 *   This file is QTI vendorTag define headers
 *
 *   Vendor or third-party should define their vendortag in chivendortagoemdefines.h
 *
 *   - DO NOT ADD STRUCTURE DEFINE
 *   - DO NOT ADD CUSTOMER VENDORTAG
 *   - DO NOT CHANGE THE LAYOUT
 ************************************************************************************************/

#include "chiafcommon.h"
#include "chieisdefs.h"
#include "chiifedefs.h"
#include "chiipedefs.h"
#include "chiiqmodulesettings.h"
#include "chiispstatsdefs.h"
#include "chistatsproperty.h"
#include "chiswispdefs.h"
#include "chituningmodeparam.h"
#include "chivendortag.h"
#include "camera_metadata.h"

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

/// @brief redefine from camx-lib\system\firmware\ipdefs.h
struct CHIImageDimensions
{
    uint32_t    widthPixels;
    uint32_t    heightLines;
};

/// @brief redefine from camx\src\core\hal\camxhal3metadatatagtypes.h
struct CHIIPEICACapability
{
    INT32 supportedIPEICATransformType;      ///< ICA Transform Type
    INT32 IPEICATransformGridSize;           ///< ICA Transform Grid Size
};


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

///< chxextensioninterface.cpp, Section:com.qti.chi.override
static CHIVENDORTAGDATA g_VendorTagDataChiOverride[] =
{
    { "override_tag1",                     TYPE_INT32, 1                                   },
    { "override_tag2",                     TYPE_BYTE,  1                                   },
    { "override_tag3",                     TYPE_INT64, 1                                   },
    { "override_tag4",                     TYPE_INT64, 2                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.multicamerasensorconfig
static CHIVENDORTAGDATA g_VendorTagDataMulticameraSensorConfig[] =
{
    { "sensorsyncmodeconfig",              TYPE_BYTE, sizeof(SensorSyncModeMetadata)       },
};

///< chxextensioninterface.cpp, Section:com.qti.chi.multicamerainputmetadata
static CHIVENDORTAGDATA g_VendorTagDataMulticameraInputMetadata[] =
{
    { "InputMetadataOpticalZoom",          TYPE_BYTE,  sizeof(InputMetadataOpticalZoom)    },
    { "InputMetadataBokeh",                TYPE_BYTE,  sizeof(InputMetadataBokeh)          },
    { "InputMetadataForSwitchController",  TYPE_BYTE,  sizeof(SATSwitchController)         }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.multicameraoutputmetadata
static CHIVENDORTAGDATA g_VendorTagDataMulticameraOutputMetadata[] =
{
    { "OutputMetadataOpticalZoom",         TYPE_BYTE,  sizeof(OutputMetadataOpticalZoom)   },
    { "OutputMetadataBokeh",               TYPE_BYTE,  sizeof(OutputMetadataBokeh)         }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.multicamerainfo
static CHIVENDORTAGDATA g_VendorTagDataMulticameraInfo[] =
{
    { "MultiCameraIds",                    TYPE_BYTE,  sizeof(MultiCameraIds)              },
    { "MasterCamera",                      TYPE_BYTE,  sizeof(BOOL)                        },
    { "LowPowerMode",                      TYPE_BYTE,  sizeof(LowPowerModeInfo)            },
    { "SyncMode",                          TYPE_BYTE,  sizeof(SyncModeInfo)                },
    { "FPSMatch",                          TYPE_BYTE,  sizeof(BOOL)                        },
    { "ActiveCameraMask",                  TYPE_INT32, 1                                   },
    { "ActiveCameraInfo",                  TYPE_BYTE,  sizeof(ActiveCameraInfo)            }
};

/// org.quic.camera.swfusionInfo
static ChiVendorTagData g_VendorTagSectionSWFusionInfo[] =
{
    { "MaintainSequence", TYPE_BYTE, 1 }
};

/// @brief org.quic.camera.scratchbufferdata
static CHIVENDORTAGDATA g_VendorTagSectionScratchBufferData[] =
{
    { "ScratchBufferData",  TYPE_BYTE, sizeof(SWISPScratchBufferData) }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.logicalcamerainfo
static CHIVENDORTAGDATA g_VendorTagDataLogicalCameraInfo[] =
{
    { "NumPhysicalCameras",                TYPE_BYTE,  sizeof(UINT32)                      },
    { "OutputMetadataStreamMask",          TYPE_INT64, 1                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.cropregions
static CHIVENDORTAGDATA g_VendorTagCropRegion[] =
{
    { "crop_regions",                      TYPE_BYTE,  sizeof(CaptureRequestCropRegions)   },
    { "ChiNodeResidualCrop",               TYPE_BYTE,  sizeof(CHIRECT)                     }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.statsaec
static CHIVENDORTAGDATA g_VendorTagAECLux[] =
{
    { "AecLux",                            TYPE_FLOAT, 1                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.statsSkip
static CHIVENDORTAGDATA g_VendorTagStatsSkip[] =
{
    { "skipFrame",                         TYPE_INT32, 1                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.metadataOwnerInfo
static CHIVENDORTAGDATA g_VendorTagMetaOwnerInfo[] =
{
    { "MetadataOwner",                     TYPE_BYTE,  sizeof(MetadataOwnerInfo)           }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.feature2RequestInfo
static CHIVENDORTAGDATA g_VendorTagFeature2RequestInfo[] =
{
    { "Feature2RequestInfo",               TYPE_BYTE,  sizeof(Feature2InputRequestInfo)    },
    { "Feature2MccResult",                 TYPE_BYTE,  sizeof(Feature2ControllerResult)    }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.cameraconfiguration
static CHIVENDORTAGDATA g_VendorTagDataCameraConfiguration[] =
{
    { "PhysicalCameraConfigs",             TYPE_BYTE,  sizeof(CameraConfigs)               },
    { "PhysicalCameraInputConfig",         TYPE_BYTE,  sizeof(ChiMultiCameraConfig)        },
    { "PhysicalDifferentDimensionMap",     TYPE_BYTE,  sizeof(ChiMultiCamDimensionDiffMap) }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.superslowmotionfrc
static CHIVENDORTAGDATA g_VendorTagSuperSlowMotionFRC[] =
{
    { "CaptureStart",                      TYPE_INT32, 1                                   },
    { "CaptureComplete",                   TYPE_INT32, 1                                   },
    { "ProcessingComplete",                TYPE_INT32, 1                                   },
    { "InterpolationFactor",               TYPE_INT32, 1                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.bpsrealtimecam
static CHIVENDORTAGDATA g_VendorTagBPSRealtimeCam[] =
{
    { "cameraRunningOnBPS",                TYPE_BYTE,  sizeof(BOOL)                        }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.ZSLSettings
static CHIVENDORTAGDATA g_VendorTagZSLTags[] =
{
    { "ZSLTimeRange",                      TYPE_INT64, 2                                   },
    { "lastZSLframe",                      TYPE_INT32, 1                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.livePreview
static CHIVENDORTAGDATA g_VendorTagLivePreview[] =
{
    { "enable",                            TYPE_INT32, 1                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.snapshotframeexposuretype
static CHIVENDORTAGDATA g_VendorTagExposureType[] =
{
    { "snapshotframeexposuretype",      TYPE_INT32, 1 },
};

///< chxextensioninterface.cpp, Section:com.qti.chi.qllControl
static CHIVENDORTAGDATA g_VendorTagQLLControl[] =
{
    { "QLLConfiguration",                  TYPE_BYTE, sizeof(QLLData) }
};


///< chxextensioninterface.cpp, Section:org.quic.camera.debugDumpConfig
static CHIVENDORTAGDATA g_VendorTagDebugDumpConfig[] =
{
    { "DebugDumpConfig",                   TYPE_BYTE,  sizeof(DumpFileName)                }
};

///< camxafinterface.cpp Section:com.qti.stats.af
static const CHAR AFAlgoSectionName[]                = "com.qti.stats.af";
static CHIVENDORTAGDATA g_VendorTagDataAFInterface[] =
{
    { "horiCountTag",                       TYPE_INT32,    1                                      },
    { "vertCountTag",                       TYPE_INT32,    1                                      },
    { "widthRegionTag",                     TYPE_INT32,    1                                      },
    { "heightRegionTag",                    TYPE_INT32,    1                                      },
    { "horiOffsetTag",                      TYPE_INT32,    1                                      },
    { "vertOffsetTag",                      TYPE_INT32,    1                                      },
    { "ConfidenceMapTag",                   TYPE_INT32,    MaxAFFocusMapNum                       },
    { "DistanceMapTag",                     TYPE_INT32,    MaxAFFocusMapNum                       },
    { "AFSelectionMapTag",                  TYPE_INT32,    MaxAFFocusMapNum                       },
    { "DefocusMapTag",                      TYPE_INT32,    MaxAFFocusMapNum                       },
};

static CHIVENDORTAGSECTIONDATA g_VendorTagSectionDataAFInterface[] =
{
    {
        AFAlgoSectionName,  0,
        sizeof(g_VendorTagDataAFInterface) / sizeof(g_VendorTagDataAFInterface[0]), g_VendorTagDataAFInterface,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    }
};

static ChiVendorTagInfo g_VendorTagInfoAFInterface[] =
{
    {
        &g_VendorTagSectionDataAFInterface[0],
        sizeof(g_VendorTagSectionDataAFInterface) / sizeof(g_VendorTagSectionDataAFInterface[0])
    }
};

///< Section:com.qti.stats.aec
static const CHAR AECAlgoSectionName[]              = "com.qti.stats.aec";

///< Section:com.qti.stats.awb
static const CHAR AWBAlgoSectionName[]              = "com.qti.stats.awb";

///< Section:"com.qti.stats.pdlib"
static const CHAR PDLibSectionName[]                = "com.qti.stats.pdlib";

///< chxextensioninterface.cpp, Section:com.qti.chi.offlinepipelineinfo
static CHIVENDORTAGDATA g_VendorTagOfflinePipelineInfo[] =
{
    { "MetaBufferDelay",                   TYPE_INT32, 1                                   }
};

///< chxextensioninterface.cpp, Section:com.qti.chi.pixelshift
static CHIVENDORTAGDATA g_VendorTagPixelShift[] =
{
    { "PixelShift",                        TYPE_BYTE,  sizeof(ImageShiftData)              }
};

static CHIVENDORTAGDATA g_VendorTagAnchorSync[] =
{
    { "AnchorFrame", TYPE_INT32, 1 }
};

static CHIVENDORTAGDATA g_VendorTagMultiFrameInfo[] =
{
    { "MultiframeBurstLimit", TYPE_BYTE, 1 },
    { "MultiframeBurstEnable", TYPE_BYTE, 1 }
};

///< Section:org.codeaurora.qcamera3.saturation
static CHIVENDORTAGDATA g_VendorTagSectionSaturation[] =
{
    { "use_saturation",                    TYPE_INT32, 1                                   },
    { "range",                             TYPE_INT32, 4                                   }
};

/// org.codeaurora.qcamera3.ir_led
static CHIVENDORTAGDATA g_VendorTagSectionIRLed[] =
{
    { "ir_modes_supported"  , TYPE_INT32,  3 },
    { "mode"                , TYPE_INT32,  1 },
    { "ready"               , TYPE_INT32,  1 },
    { "manualIRIntensity"   , TYPE_FLOAT,  1 },
};

/// org.codeaurora.qcamera3.pwm_frequency
static CHIVENDORTAGDATA g_VendorTagSectionPWMfrequency[] =
{
    { "pwmFrequencyHz", TYPE_FLOAT, 1 }
};

///< camxchinodeeisv3.cpp, Section:org.quic.camera2.ipeicaconfigs
static CHIVENDORTAGDATA g_VendorTagSectionEISV3ICA[] =
{
    { "ICAInPerspectiveTransform",           0,          sizeof(IPEICAPerspectiveTransform)  },
    { "ICAInGridOut2InTransform",            0,          sizeof(IPEICAGridTransform)         },
    { "ICAInGridTransformLookahead",         0,          sizeof(IPEICAGridTransform)         },
    { "ICAReferenceParams",                  0,          sizeof(IPEICAPerspectiveTransform)  },
    { "ICAInGridIn2OutTransform",            0,          sizeof(IPEICAGridTransform)         },
    { "AltExpToAnchorExpAlignmentTransform", 0,          sizeof(IPEICAGridTransform)         },
    { "StdSumNormalized",                    TYPE_FLOAT, 1                                   },
    { "BlendFactor",                         TYPE_FLOAT, 1                                   },
    { "IsHeavyMotion",                       0,          sizeof(UINT32)                      },
    { "SceneType",                           0,          sizeof(SceneDetection)              },
    { "ICAInGridTransform",                  0,          sizeof(IPEICAGridTransform),        },

};

///< camxchinodeeisv3.cpp, Section:org.quic.camera.recording
static CHIVENDORTAGDATA g_VendorTagSectionRecording[] =
{
    { "endOfStreamRequestId",              0,          sizeof(UINT64)                      },
    { "requestHasVideoBuffer",             0,          1                                   }
};

///< camxchinodeeisv3.cpp, Section:org.quic.camera.eislookahead
static CHIVENDORTAGDATA g_VendorTagSectionEISLookahead[] =
{
    { "Enabled",                           0,          1                                   },
    { "FrameDelay",                        0,          sizeof(UINT32)                      },
    { "RequestedMargin",                   0,          sizeof(MarginRequest)               },
    { "StabilizationMargins",              0,          sizeof(StabilizationMargin)         },
    { "AdditionalCropOffset",              0,          sizeof(CHIImageDimensions)          },
    { "StabilizedOutputDims",              0,          sizeof(CHIDimension)                },
    { "MinimalTotalMargins",               0,          sizeof(MarginRequest)               },
    { "DISMVStats",                        0,          sizeof(DISMVStats)                  },
    { "ExtraHALBuffers",                   0,          sizeof(UINT32)                      },
    { "MOFAlignment",                      0,          sizeof(MOFAlignment)                }
};

///< camxchinodeeisv2.cpp, Section:org.quic.camera.eisrealtime
static CHIVENDORTAGDATA g_VendorTagSectionEISV2RealTime[] =
{
    { "Enabled",                            0,          1 },
    { "RequestedMargin",                    0,          sizeof(MarginRequest)              },
    { "StabilizationMargins",               0,          sizeof(StabilizationMargin)        },
    { "AdditionalCropOffset",               0,          sizeof(CHIImageDimensions)         },
    { "StabilizedOutputDims",               0,          sizeof(CHIDimension)               },
    { "MinimalTotalMargins",                0,          sizeof(MarginRequest)              },
    { "MotionIndication",                   0,          sizeof(FLOAT)                      },
    { "EISOISMode",                         0,          sizeof(EISOISMode)                 }
};

///< camxchinodeeisv3.cpp & camxchinodeeisv2.cpp, Section:org.codeaurora.qcamera3.sensor_meta_data
static CHIVENDORTAGDATA g_VendorTagSectionEISSensorMeta[] =
{
    { "mountAngle",                         0,          sizeof(INT32)                      },
    { "sensor_mode_info",                   0,          sizeof(ChiSensorModeInfo)          },
    { "current_mode",                       0,          sizeof(INT32)                      },
    { "targetFPS",                          0,          sizeof(INT32)                      },
    { "sensorCaps",                         0,          sizeof(ChiSensorCaps)              },
};

///< camxchinodeeisv3.cpp & camxchinodeeisv2.cpp, Section:com.qti.chi.cameraconfiguration
static CHIVENDORTAGDATA g_VendorTagSectionCameraConfiguration[] =
{
    { "PhysicalCameraConfigs",              0,          sizeof(CameraConfigs)              }
};

///< camxchinodeeisv3.cpp & camxchinodeeisv2.cpp, Section:org.quic.camera2.statsconfigs
static CHIVENDORTAGDATA g_VendorTagSectionStatsConfig[] =
{
    { "FOVCFrameControl",                   0,          sizeof(FOVCOutput)                 },
    { "IFOVCFrameControl",                  0,          sizeof(FOVCOutput)                 }
};

///< camxchinodeeisv3.cpp & camxchinodeeisv2.cpp, Section:com.qti.chi.multicameraoutputmetadata
static CHIVENDORTAGDATA g_VendorTagSectionEISMultiCameraInfo[] =
{
    { "OutputMetadataOpticalZoom",         0,          sizeof(OutputMetadataOpticalZoom)   }
};

///< Section:com.qti.chi.metadataOwnerInfo
static CHIVENDORTAGDATA g_VendorTagSectionMultiCameraInfo[] =
{
    { "MetadataOwner",                      0,          sizeof(UINT32)                     }
};

///< camxchinodeeisv3.cpp & camxchinodeeisv2.cpp, Section:com.qti.cropregions
static CHIVENDORTAGDATA g_VendorTagSectionChiNodeCropRegions[] =
{
    { "ChiNodeResidualCrop",                0,          sizeof(CHIRectangle)               }
};

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

///< camxchinodeeisv2.cpp, Section:org.quic.camera2.ipeicaconfigs
static CHIVENDORTAGDATA g_VendorTagSectionEISV2ICA[] =
{
    ///< ICA Ref perspective transform
    { "ICAInPerspectiveTransform",          0,          sizeof(IPEICAPerspectiveTransform) },
    ///< ICA Grid out2in transform
    { "ICAInGridOut2InTransform",           0,          sizeof(IPEICAGridTransform)        },
    ///< ICA Grid in2out transform
    { "ICAInGridIn2OutTransform",           0,          sizeof(IPEICAGridTransform)        },
    ///< ICA reference params for gyro alignment
    { "ICAReferenceParams",                 0,          sizeof(IPEICAPerspectiveTransform) },
    ///< ICA stab Grid for GPU EIS
    { "ICAInGridTransform",                 0,          sizeof(IPEICAGridTransform),       },
};

///< camxchinodeswlsc.cpp, Section:org.codeaurora.qcamera3.sensor_meta_data
static CHIVENDORTAGDATA g_VendorTagSectionSWLSCSensorMeta[] =
{
    { "sensor_mode_info",                   0,          sizeof(ChiSensorModeInfo)          },
    { "current_mode",                       0,          sizeof(INT32)                      },
};

///< camxchinodeswmctf.cpp, Section:org.codeaurora.qcamera3.sensor_meta_data
static CHIVENDORTAGDATA g_VendorTagSectionMCTFSensorMeta[] =
{
    { "targetFPS",                          0,          sizeof(INT32)                      },
    { "sensor_mode_info",                   0,          sizeof(ChiSensorModeInfo)          },
};

///< camxchinodeswmctf.cpp, Section:org.quic.camera.streamDimension
static CHIVENDORTAGDATA g_VendorTagSectionMCTFStreamDimension[] =
{
    { "video",                              0,          sizeof(ChiBufferDimension)         },
};

///< camxchinodeswmctf.cpp, Section:org.quic.camera.swcapabilities
static CHIVENDORTAGDATA g_VendorTagSectionSwMCTFEnablementStatus[] =
{
    { "SWMCTFEnable",         0, sizeof(UINT) },
    { "SWMCTFEnablefor60fps", 0, sizeof(UINT) },
    { "SWMCTFType",           0, sizeof(UINT)}
};

///< camxchinodeswmctf.cpp, Section:org.quic.camera2.statsconfigs
static CHIVENDORTAGDATA g_VendorTagSwMCTFStatsConfig[] =
{
    { "AECFrameControl",        TYPE_BYTE,    sizeof(AECFrameControl)   },
    { "AWBFrameControl",        TYPE_BYTE,    sizeof(AWBFrameControl)   },
    { "AFFrameControl",         TYPE_BYTE,    sizeof(AFFrameControl)    },
};

/// com.qti.camera.swmfnrBlendConfidence
static CHIVENDORTAGDATA g_VendorTagSectionSWMFNRBlendConfidence[] =
{
    {"SWMFNRBlendConfidence",  TYPE_FLOAT, 1 },
    {"SWMFNRBlendedFrames",    TYPE_INT32, 1 },
    {"SWMFNRAdjustmentFactor", TYPE_FLOAT, 1 },
};

/// com.qti.camera.multiRAWLLHDR
static CHIVENDORTAGDATA g_VendorTagSectionMultiRAWLLHDR[] =
{
    {"LLHDRSnapshot",  TYPE_BYTE,  sizeof(BOOL) }
};

///< camxchinodeswbestats.cpp, Section: com.qti.camera.swbestatsdata
static CHIVENDORTAGDATA g_VendorTagSectionSWBEStatsData[] =
{
    { "SWBEStatsConfig",  TYPE_BYTE, sizeof(SWISPBEStatsConfig) },
    { "SWBEStatsGenData", TYPE_BYTE, 8                          },
};

///< camxchinodedewarp.cpp, Section:org.quic.camera2.ipeicaconfigs
static CHIVENDORTAGDATA g_VendorTagSectionICAGpu[]  =
{
    { "ICAInPerspectiveTransformLookAhead", 0,          sizeof(IPEICAPerspectiveTransform) },
    { "ICAInPerspectiveTransform",          0,          sizeof(IPEICAPerspectiveTransform) },
    { "ExtraFrameworkBuffers",              0,          sizeof(UINT32)                     },
    { "ICAInGridTransformLookahead",        0,          sizeof(IPEICAGridTransform)        },
    { "ICAInGridTransform",                 0,          sizeof(IPEICAGridTransform)        },
};

///< camxchinodedepth.cpp, Section:org.quic.camera.AECData
static CHIVENDORTAGDATA g_VendorTagSectionAECData[] =
{
    { "AECData",                            TYPE_BYTE,  sizeof(ChiAECData)                 },
    { "sensor_register_control",            TYPE_INT32, 32                                 },
};

///< camxchinodedepth.cpp, Section:org.quic.camera.AECDataPublisherPresent
static CHIVENDORTAGDATA g_VendorTagSectionAECDataPublisherPresent[] =
{
    { "AECDataPublisherPresent",            TYPE_BYTE,  1                                  },
};

///< camxchinodeswregistration.cpp, Section:org.codeaurora.qcamera3.platformCapabilities
static CHIVENDORTAGDATA g_VendorTagSectionICACapabilities[] =
{
    { "IPEICACapabilities",                 0,          sizeof(CHIIPEICACapability)        },

};

///< org.quic.camera2.objectTrackingConfig section for Tracker configure
static CHIVENDORTAGDATA g_VendorTagSectionTrackerConfig[] =
{
    { "Enable",                             TYPE_BYTE,  1                                  },
    { "CmdTrigger",                         TYPE_INT32, 1                                  },
    { "RegisterROI",                        TYPE_INT32, 4                                  },
};

///< org.quic.camera2.objectTrackingResults section for Tracker results
static CHIVENDORTAGDATA g_VendorTagSectionTrackerResults[] =
{
    { "TrackerEnable",                      TYPE_BYTE,  1                                  },
    { "TrackerStatus",                      TYPE_INT32, 1                                  },
    { "ResultROI",                          TYPE_INT32, 4                                  },
    { "TrackerScore",                       TYPE_INT32, 1                                  },
};

///< org.codeaurora.qcamera3.hal_private_data
static CHIVENDORTAGDATA g_VendorTagSectionHALPrivate[] =
{
    { "reprocess_flags",                    TYPE_BYTE , 1                                  },
    { "reprocess_data_blob",                TYPE_BYTE , 1                                  },
    { "exif_debug_data_blob",               TYPE_BYTE , 1                                  },
    { "debug_image_dump",                   TYPE_BYTE , 1                                  },
    { "debug_image_dump_mask",              TYPE_INT32, 1                                  },
};

///< com.qti.stats_control
static CHIVENDORTAGDATA g_VendorTagStatsControl[] =
{
    { "is_flash_snapshot",                  TYPE_INT32, 1                                  },
    { "is_lls_needed",                      TYPE_INT32, 1                                  },
    { "IRLEDAutoModeSwitch",                TYPE_INT32, 1                                  }
};

///< com.qti.insensor_control
static CHIVENDORTAGDATA g_VendorTagSeamlessInSensorControl[] =
{
    { "seamless_insensor_state",            TYPE_INT32, 1                                  }
};

///< org.quic.camera.debugdata section
static CHIVENDORTAGDATA g_VendorTagSectionDebugData[] =
{
    { "DebugDataAll",                       TYPE_BYTE,  sizeof(DebugData)                  },
    { "DebugDataAEC",                       TYPE_BYTE,  sizeof(DebugData)                  },
    { "DebugDataAWB",                       TYPE_BYTE,  sizeof(DebugData)                  },
    { "DebugDataAF",                        TYPE_BYTE,  sizeof(DebugData)                  },
    { "DebugDataAFD",                       TYPE_BYTE,  sizeof(DebugData)                  },
    { "DebugDataSWEC",                      TYPE_BYTE,  sizeof(DebugData)                  },
    { "DebugDataSWFusion",                  TYPE_BYTE,  sizeof(DebugData)                  },
};

///< org.codeaurora.qcamera3.sharpness section
static CHIVENDORTAGDATA g_VendorTagSectionSharpness[] =
{
    { "strength",                           TYPE_INT32, 1                                  },
    { "range",                              TYPE_INT32, 2                                  }
};

///< org.codeaurora.qcamera3.contrast section
static CHIVENDORTAGDATA g_VendorTagSectionContrast[] =
{
    { "level",                              TYPE_INT32, 1                                  },
};


///< org.codeaurora.qcamera3.exposure_metering section
static CHIVENDORTAGDATA g_VendorTagSectionExposureMetering[] =
{
    { "exposure_metering_mode",             TYPE_INT32, 1                                  },
    { "available_modes",                    TYPE_INT32, 7                                  }
};

///< org.codeaurora.qcamera3.aec_convergence_speed section
static CHIVENDORTAGDATA g_VendorTagSectionAecConvergenceSpeed[] =
{
    { "aec_speed",                          TYPE_FLOAT, 1                                  },
};

///< org.codeaurora.qcamera3.iso_exp_priority section
static CHIVENDORTAGDATA g_VendorTagSectionIsoExpPriority[] =
{
    { "use_iso_exp_priority",               TYPE_INT64, 1                                  },
    { "use_iso_value",                      TYPE_INT32, 1                                  },
    { "select_priority",                    TYPE_INT32, 1                                  },
    { "iso_available_modes",                TYPE_INT32, 8                                  },
    { "exposure_time_range",                TYPE_INT64, 2                                  },
    { "use_gain_value",                     TYPE_FLOAT, 1                                  },

};

///< org.codeaurora.qcamera3.histogram section
static CHIVENDORTAGDATA g_VendorTagSectionHistogram[] =
{
    { "enable",                             TYPE_BYTE,  1                                  },
    { "buckets",                            TYPE_INT32, 1                                  },
    { "max_count",                          TYPE_INT32, 1                                  },
    { "stats",                              TYPE_INT32, MaxBHistBinNum                     },
    { "stats_type",                         TYPE_INT32, 1                                  }
};

///< org.codeaurora.qcamera3.bayer_grid section
static CHIVENDORTAGDATA g_VendorTagSectionBGStats[] =
{
    { "enable",                             TYPE_BYTE,  1                                  },
    { "width",                              TYPE_INT32, 1                                  },
    { "height",                             TYPE_INT32, 1                                  },
    { "r_stats",                            TYPE_INT32, MaxAWBBGStatsNum                   },
    { "g_stats",                            TYPE_INT32, MaxAWBBGStatsNum                   },
    { "b_stats",                            TYPE_INT32, MaxAWBBGStatsNum                   },
    { "stats_type",                         TYPE_INT32, 1                                  }
};

///< org.codeaurora.qcamera3.bayer_exposure section
static CHIVENDORTAGDATA g_VendorTagSectionBEStats[] =
{
    { "enable",                             TYPE_BYTE,  1                                  },
    { "width",                              TYPE_INT32, 1                                  },
    { "height",                             TYPE_INT32, 1                                  },
    { "r_stats",                            TYPE_INT32, MaxAWBBGStatsNum                   },
    { "g_stats",                            TYPE_INT32, MaxAWBBGStatsNum                   },
    { "b_stats",                            TYPE_INT32, MaxAWBBGStatsNum                   },
    { "stats_type",                         TYPE_INT32, 1                                  },
    { "roi_be_x",                           TYPE_FLOAT, 1                                  },
    { "roi_be_y",                           TYPE_FLOAT, 1                                  },
    { "roi_be_width",                       TYPE_FLOAT, 1                                  },
    { "roi_be_height",                      TYPE_FLOAT, 1                                  },
    { "bitDepth",                           TYPE_INT32, 1                                  }
};

///< org.codeaurora.qcamera3.instant_aec section
static CHIVENDORTAGDATA g_VendorTagSectionInstanctAec[] =
{
    { "instant_aec_mode",                   TYPE_INT32, 1                                  },
    { "instant_aec_available_modes",        TYPE_INT32, 3                                  }
};

///< org.codeaurora.qcamera3.awb_convergence_speed section
static CHIVENDORTAGDATA g_VendorTagSectionAwbConvSpeed[] =
{
    { "awb_speed",                          TYPE_FLOAT, 1                                  }
};

///< org.codeaurora.qcamera3.ae_bracket section
static CHIVENDORTAGDATA g_VendorTagSectionAEBracket[] =
{
    { "mode",                              TYPE_BYTE,  1                                   },
    { "num_frames",                        TYPE_INT32, 1                                   },
    { "exposure_values",                   TYPE_INT32, 16                                  }
};

///< org.codeaurora.qcamera3.temporal_denoise section
static CHIVENDORTAGDATA g_VendorTagSectionTemporalDenoise[] =
{
    { "enable",                            TYPE_BYTE,  1                                   },
    { "process_type",                      TYPE_INT32, 4                                   }
};

///< org.codeaurora.qcamera3.manualWB section
static CHIVENDORTAGDATA g_VendorTagSectionManualWB[] =
{
    { "color_temperature",                 TYPE_INT32, 1                                   },
    { "color_temperature_range",           TYPE_INT32, 2                                   },
    { "gains",                             TYPE_FLOAT, 3                                   },
    { "gains_range",                       TYPE_FLOAT, 2                                   },
    { "partial_mwb_mode",                  TYPE_INT32, 1                                   },
};

///< org.codeaurora.qcamera3.jpeg_encode_crop section
static CHIVENDORTAGDATA g_VendorTagSectionJpegEncodeCrop[] =
{
    { "enable",                            TYPE_BYTE,  1                                   },
    { "rect",                              TYPE_INT32, 4                                   },
    { "roi",                               TYPE_INT32, 4                                   }
};

///< org.codeaurora.qcamera3.av_timer
static CHIVENDORTAGDATA g_VendorTagSectionAVTimer[] =
{
    { "use_av_timer",                     TYPE_BYTE,   1                                   }
};

///< org.codeaurora.qcamera3.sensor_meta_data section
static CHIVENDORTAGDATA g_VendorTagSectionSensorMeta[] =
{
    { "dynamic_black_level_pattern",      TYPE_FLOAT,  1                                   },
    { "is_mono_only",                     TYPE_BYTE,   1                                   },
    { "sensor_mode_index",                TYPE_INT32,  MaxSensorModes                      },
    { "EEPROMInformation",                TYPE_BYTE,   sizeof(ChiEEPROMInformation)        },
    { "integration_information",          TYPE_INT32,  3                                   },
    { "mountAngle",                       TYPE_INT32,  1                                   },
    { "cameraPosition",                   TYPE_INT32,  1                                   },
    { "sensor_mode_info",                 TYPE_BYTE,   sizeof(ChiSensorModeInfo)           },
    { "sensor_pdaf_info",                 TYPE_BYTE,   sizeof(ChiSensorPDAFInfo)           },
    { "current_mode",                     TYPE_INT32,  1                                   },
    { "targetFPS",                        TYPE_INT32,  1                                   },
    { "DepthConversionLibInfo",           TYPE_BYTE,   sizeof(ChiDepthConversionLibInfo)   },
    { "sensorCaps",                       TYPE_BYTE,   sizeof(ChiSensorCaps)               },
    { "ircut_status",                     TYPE_BYTE,   sizeof(BOOL)                        },
    { "currentFLL",                       TYPE_INT32,  1                                   },
    { "digital_gain",                     TYPE_FLOAT,  sizeof(FLOAT) * 2                   }
};

///< org.quic.camera2.ipeicaconfigs section
static CHIVENDORTAGDATA g_VendorTagSectionICAConfigs[] =
{
    { "ICAInPerspectiveTransform",           TYPE_BYTE,  sizeof(IPEICAPerspectiveTransform)  },
    { "ICAInGridOut2InTransform",            TYPE_BYTE,  sizeof(IPEICAGridTransform)         },
    { "ICAInGridIn2OutTransform",            TYPE_BYTE,  sizeof(IPEICAGridTransform)         },
    { "ICAInInterpolationParams",            TYPE_BYTE,  sizeof(IPEICAInterpolationParams)   },
    { "ICARefPerspectiveTransform",          TYPE_BYTE,  sizeof(IPEICAPerspectiveTransform)  },
    { "ICARefGridTransform",                 TYPE_BYTE,  sizeof(IPEICAGridTransform)         },
    { "ICARefInterpolationParams",           TYPE_BYTE,  sizeof(IPEICAInterpolationParams)   },
    { "ICAReferenceParams",                  TYPE_BYTE,  sizeof(IPEICAPerspectiveTransform)  },
    { "ICAReferenceParamsLookAhead",         TYPE_BYTE,  sizeof(IPEICAPerspectiveTransform)  },
    { "ICAInPerspectiveTransformLookAhead",  TYPE_BYTE,  sizeof(IPEICAPerspectiveTransform)  },
    { "ICAInGridTransformLookahead",         TYPE_BYTE,  sizeof(IPEICAGridTransform)         },
    { "ExtraFrameworkBuffers",               TYPE_BYTE,  sizeof(UINT32)                      },
    { "AltExpToAnchorExpAlignmentTransform", TYPE_BYTE,  sizeof(IPEICAGridTransform)         },
    { "StdSumNormalized",                    TYPE_FLOAT, 1                                   },
    { "BlendFactor",                         TYPE_FLOAT, 1                                   },
    { "IsHeavyMotion",                       0,          sizeof(UINT32)                      },
    { "SceneType",                           0,          sizeof(SceneDetection)              },
    { "ICAInGridTransform",                  0,          sizeof(IPEICAGridTransform),        },
};

///< org.quic.camera.recording
static CHIVENDORTAGDATA g_VendorTagSectionRecordingConfig[] =
{
    { "endOfStream",                        TYPE_BYTE, 1                                   },
    { "endOfStreamRequestId",               TYPE_BYTE, sizeof(UINT64)                      },
    { "requestHasVideoBuffer",              TYPE_BYTE, 1                                   }
};

///< org.quic.camera.EarlyPCRenable
static CHIVENDORTAGDATA g_VendorTagSectionEarlyPCRFlag[] =
{
    { "EarlyPCRenable",                     TYPE_BYTE, 1                                   }
};

///< org.quic.camera.BurstFPS
static CHIVENDORTAGDATA g_VendorTagSectionBurstFPSFlag[] =
{
    { "burstfps",                           TYPE_BYTE,  1                                  },
    { "isBurstShotSupported",               TYPE_BYTE,  1                                  },
    { "MaxBurstShotFPS",                    TYPE_FLOAT, 1                                  }
};

///< org.quic.camera.MaxPreviewSize
static CHIVENDORTAGDATA g_VendorTagSectionMaxPreviewSizeFlag[] =
{
    { "MaxPreviewSize",                     TYPE_INT32, 2                                  }
};

///< org.quic.camera.LiveshotSize
static CHIVENDORTAGDATA g_VendorTagSectionLiveshotSizeFlag[] =
{
    { "isLiveshotSizeSameAsVideoSize",      TYPE_BYTE,  1                                  }
};

///< org.quic.camera.deviceCapabilities
static CHIVENDORTAGDATA g_VendorTagSectionDeviceCapabilities[] =
{
    { "isFDRenderingInCameraUISupported",   TYPE_BYTE,  1                                  },
    { "deviceMemoryType",                   TYPE_BYTE,  1                                  }
};

///< org.quic.camera.FDRendering
static CHIVENDORTAGDATA g_VendorTagSectionFDRenderingFlag[] =
{
    { "isFDRenderingInVideoUISupported",    TYPE_BYTE,  1                                  }
};

///< org.quic.camera.CustomNoiseReduction
static CHIVENDORTAGDATA g_VendorTagSectionCustomNoiseReductionFlag[] =
{
    { "CustomNoiseReduction",               TYPE_BYTE,  1                                  }
};

///< org.quic.camera.SensorModeFS
static CHIVENDORTAGDATA g_VendorTagSectionSensorModeFSFlag[] =
{
    { "isFastShutterModeSupported",        TYPE_BYTE,   1                                  },
    { "SensorModeFS",                      TYPE_BYTE,   1                                  }
};

///< org.quic.camera.HWResourceInfo
static CHIVENDORTAGDATA g_VendorTagSectionHWResourceInfo[] =
{
    { "IFEMaxLineWidth",                  TYPE_INT32,   1                                  },
    { "numIFEsforGivenTarget",            TYPE_INT32,   1                                  },
    { "maxIFEsRequired",                  TYPE_INT32,   1                                  }
};

///< org.quic.camera2.mfnrconfigs section
static CHIVENDORTAGDATA g_VendorTagSectionMFNRConfigs[] =
{
    { "MFNRTotalNumFrames",               TYPE_INT32,   1                                  },
    { "MFNRBlendFrameNum",                TYPE_INT32,   1                                  },
    { "MultiframeRequestTimestamp",       TYPE_INT64,   1                                  },
};

///< org.quic.camera2.mfsrconfigs section
static CHIVENDORTAGDATA g_VendorTagSectionMFSRConfigs[] =
{
    { "MFSRTotalNumFrames",               TYPE_INT32,  1                                   },
    { "MFSRBlendFrameNum",                TYPE_INT32,  1                                   },
};

///< org.quic.camera2.streamconfigs section
static CHIVENDORTAGDATA g_VendorTagSectionStreamConfigs[] =
{
    { "HDRVideoMode",                     TYPE_BYTE,   1                                   },
};

///< org.quic.camera2.iqsettings section
static CHIVENDORTAGDATA g_VendorTagSectionIQSettings[] =
{
    { "OEMIFEIQSetting",                  TYPE_BYTE,   sizeof(OEMIFEIQSetting)             },
    { "OEMBPSIQSetting",                  TYPE_BYTE,   sizeof(OEMBPSIQSetting)             },
    { "OEMIPEIQSetting",                  TYPE_BYTE,   sizeof(OEMIPEIQSetting)             }
};

///< org.quic.camera2.sensor_register_control
static CHIVENDORTAGDATA g_VendorTagSectionSensorRegisterControl[] =
{
    { "sensor_register_control",          TYPE_INT32,  32                                  }
};

///< org.quic.camera.isDepthFocus
static CHIVENDORTAGDATA g_VendorTagSectionIsDepthFocus[] =
{
    { "isDepthFocus",                     TYPE_BYTE,  sizeof(BOOL)                         }
};

///< org.quic.camera2.tuning mode
static CHIVENDORTAGDATA g_VendorTagSectionTuningParam[] =
{
    { "TuningMode",                       TYPE_BYTE,  sizeof(ChiTuningModeParameter)       }
};

///< org.quic.camera2.tuning.feature mode
static CHIVENDORTAGDATA g_VendorTagSectionFeatureParam[] =
{
    { "Feature1Mode",                     TYPE_BYTE,  1                                    },
    { "Feature2Mode",                     TYPE_BYTE,  1                                    }
};

///< org.quic.camera.ifecropinfo
static CHIVENDORTAGDATA g_VendorTagSectionIFECropInfo[] =
{
    {"ResidualCrop",                      TYPE_BYTE,  sizeof(IFECropInfo)                  },
    {"AppliedCrop",                       TYPE_BYTE,  sizeof(IFECropInfo)                  },
    {"SensorIFEAppliedCrop",              TYPE_BYTE,  sizeof(IFECropInfo)                  },
    {"DeferCrop",                         TYPE_BYTE,  sizeof(BOOL)                         },
    {"DeferredCropFactorLimit",           TYPE_FLOAT, 1                                    }
};

///< org.quic.camera.ifeinitpacket
static CHIVENDORTAGDATA g_VendorTagSectionIFEInitPacket[] =
{
    {"Submitted",                         TYPE_BYTE,  sizeof(BOOL)                         }
};

///< org.quic.camera.qtimer
static CHIVENDORTAGDATA g_VendorTagSectionQTimer[] =
{
    { "timestamp",                        TYPE_BYTE,  sizeof(ChiTimestampInfo)             },
    { "startOfExposure",                  TYPE_BYTE,  sizeof(ChiTimestampInfo)             }
};

///< org.quic.camera.eis3enable
static CHIVENDORTAGDATA g_VendorTagSectionEISConfig[] =
{
    { "EISV3Enable",                      TYPE_BYTE,  1                                    }
};

///< org.quic.camera.streamTypePresent
static CHIVENDORTAGDATA g_VendorTagSectionStreamTypePresent[] =
{
    { "preview",                          TYPE_BYTE,  1                                    }
};

///< org.codeaurora.qcamera3.quadra_cfa section
static CHIVENDORTAGDATA g_VendorTagSectionQuadCFA[] =
{
    { "is_qcfa_sensor",                   TYPE_BYTE,  1                                    },
    { "qcfa_dimension",                   TYPE_INT32, 2                                    }
};

///< org.quic.camera.resource section
static CHIVENDORTAGDATA g_VendorTagSectionResource[] =
{
    { "enable",                           TYPE_INT32, 1                                    },
    { "res_type",                         TYPE_INT32, 1                                    }
};

///< org.codeaurora.qcamera3.available_video_hdr_modes
static CHIVENDORTAGDATA g_VendorTagSectionVideoHDR[] =
{
    { "video_hdr_modes",                  TYPE_INT32, 5                                    }
};

///< org.codeaurora.qcamera3.supportedHDRmodes.HDRModes
static CHIVENDORTAGDATA g_VendorTagSectionSupportedMFHDRmodes[] =
{
    { "HDRModes",                         TYPE_INT32, 6 },
};

///< org.quic.camera.streamDimension
static CHIVENDORTAGDATA g_VendorTagSectionStreamDimension[] =
{
    { "preview",                          TYPE_BYTE, sizeof(ChiBufferDimension)            },
    { "video",                            TYPE_BYTE, sizeof(ChiBufferDimension)            },
    { "snapshot",                         TYPE_BYTE, sizeof(ChiBufferDimension)            },
    { "depth",                            TYPE_BYTE, sizeof(ChiBufferDimension)            },
};

///< org.quic.camera.manualExposure
static CHIVENDORTAGDATA g_VendorTagSectionManualExposure[] =
{
    { "disableFPSLimits",                 TYPE_BYTE,  1                                    },
    { "overrideSensorFrameDuration",      TYPE_INT64, 1                                    }
};

///< org.codeaurora.qcamera3.logicalCameraType
static CHIVENDORTAGDATA g_VendorTagSectionLogicalCameraType[] =
{
    { "logical_camera_type",              TYPE_BYTE,  1                                    },
};

///< org.quic.camera.ltmDynamicContrast
static CHIVENDORTAGDATA g_VendorTagSectionltmDynamicContrast[] =
{
    {"ltmDynamicContrastStrength",        TYPE_FLOAT, 1                                    },
    {"ltmDarkBoostStrength",              TYPE_FLOAT, 1                                    },
    {"ltmBrightSupressStrength",          TYPE_FLOAT, 1                                    },
    {"ltmDynamicContrastStrengthRange",   TYPE_FLOAT, 2                                    },
    {"ltmDarkBoostStrengthRange",         TYPE_FLOAT, 2                                    },
    {"ltmBrightSupressStrengthRange",     TYPE_FLOAT, 2                                    }
};

///< org.quic.camera.ifecsidconfig
static CHIVENDORTAGDATA g_VendorTagSectionCSIDBinningInfo[] =
{
    { "csidbinninginfo",                  TYPE_BYTE,  sizeof(CSIDBinningInfo)              },
};

///< org.quic.camera.geoLibStillFrameConfig
static CHIVENDORTAGDATA g_VendorTagSectionGeoLibStillFrameConfig[] =
{
    { "GeoLibStillFrameConfigPrefilter",  TYPE_BYTE,  sizeof(GeoLibStillFrameConfig)       },
    { "GeoLibStillFrameConfigBlending",   TYPE_BYTE,  sizeof(GeoLibStillFrameConfig)       },
    { "GeoLibStillFrameConfigPostFiler",  TYPE_BYTE,  sizeof(GeoLibStillFrameConfig)       },
};

///< org.quic.camera.snapshotOutputDimension
static CHIVENDORTAGDATA g_VendorTagSectionSnapshotOutputDimension[] =
{
    { "StillOutputDimension",             TYPE_BYTE, sizeof(GeoLibStreamOutput)            },
    { "DisplayOutputDimension",           TYPE_BYTE, sizeof(GeoLibStreamOutput)            },
};

///< org.quic.camera.ISPConfigData
static CHIVENDORTAGDATA g_VendorTagSectionISPConfigData[] =
{
    { "numIFEsUsed",                      TYPE_INT32, 1                                    }
};

///< org.quic.camera.overrideIPEScaleProfile
static CHIVENDORTAGDATA g_VendorTagSectionOverrideIPEScaleProfile[] =
{
    { "OverrideIPEScaleProfile",         TYPE_BYTE,   1                                    }
};

///< org.quic.camera.overrideIPEScaleProfile
static CHIVENDORTAGDATA g_VendorTagSectionOverrideGPURotation[] =
{
    { "OverrideGPURotationUsecase",      TYPE_BYTE,   1                                    }
};

///< org.quic.camera.hdrfeaturemode
static CHIVENDORTAGDATA g_VendorTagSectionHdrFeatureMode[] =
{
    { "HDRFeatureMode",                  TYPE_INT32,  1                                    },
    { "NumberOfSplits",                  TYPE_INT32,  1                                    },
    { "NumberOfExpFrames",               TYPE_INT32,  1                                    }
};

///< org.quic.camera.hvxfeaturemode
static CHIVENDORTAGDATA g_VendorTagSectionHvxFeatureMode[] =
{
    { "HVXFeatureMode",                  TYPE_INT32,  1                                    }
};

///< org.codeaurora.qcamera3.tmcusercontrol section
static CHIVENDORTAGDATA g_VendorTagSectionTMCUserControl[] =
{
    { "isValidDarkBoostOffset",          TYPE_BYTE,   1                                    },
    { "darkBoostOffset",                 TYPE_FLOAT,  1                                    },
    { "isValidFourthToneAnchor",         TYPE_BYTE,   1                                    },
    { "fourthToneAnchor",                TYPE_FLOAT,  1                                    }
};

///< org.quic.camera.swcapabilities
static CHIVENDORTAGDATA g_VendorTagSectionSWCapabilities[] =
{
     { "SWMCTFEnable",                   TYPE_BYTE,   1                                    },
     { "MFNRType",                       TYPE_INT32,  1                                    },
     { "SWMCTFType",                     TYPE_BYTE,   1                                    },
     { "isQLLSupported",                 TYPE_BYTE,   1                                    },
     { "SWMCTFEnablefor60fps",           TYPE_BYTE,   1                                    }
};

///< org.codeaurora.qcamera3.tintless section
static CHIVENDORTAGDATA g_VendorTagSectionTintlessBGStats[] =
{
    { "propertyID",                      TYPE_INT32,  1                                    },
    { "stats",                           TYPE_BYTE,   sizeof(ParsedTintlessBGStatsOutput)  },
};

///< org.codeaurora.qcamera3.bhist section
static CHIVENDORTAGDATA g_VendorTagSectionBHistStats[] =
{
    { "propertyID",                      TYPE_INT32,  1                                    },
    { "stats",                           TYPE_BYTE,   sizeof(ParsedBHistStatsOutput)       },
};

///< org.codeaurora.qcamera3.awbbg section
static CHIVENDORTAGDATA g_VendorTagSectionAWBBGStats[] =
{
    { "propertyID",                      TYPE_INT32,  1                                    },
    { "stats",                           TYPE_BYTE,   sizeof(ParsedAWBBGStatsOutput)       },
};

///< org.codeaurora.qcamera3.hdrbhist section
static CHIVENDORTAGDATA g_VendorTagSectionHDRBHistStats[] =
{
    { "propertyID",                      TYPE_INT32,  1                                    },
    { "stats",                           TYPE_BYTE,   sizeof(ParsedHDRBHistStatsOutput)    },
};

///< org.codeaurora.qcamera3.hdrbe section
static CHIVENDORTAGDATA g_VendorTagSectionHDRBEStats[] =
{
    { "propertyID",                      TYPE_INT32,  1                                    },
    { "stats",                           TYPE_BYTE,   sizeof(ParsedHDRBEStatsOutput)       },
};

///< org.quic.camera.org.quic.camera.inSensorZoom
static CHIVENDORTAGDATA g_VendorTagSectionInSensorZoom[] =
{
    /// Sensor Zoom state Binning/ QCFACrop
    { "InSensorZoomState",               TYPE_INT32,  1                                    },
    /// is TRUE, any time switching from binning to none binning mod
    { "SensorSwitched",                  TYPE_BYTE,   1                                    },
};

///< org.quic.camera.skipgpuprocessingbasedonfd
static CHIVENDORTAGDATA g_VendorTagSectionSkipGPUprocessingbasedonFD[] =
{
    { "SkipGPUprocessingbasedonFD",      TYPE_BYTE,  1                                     }

};

///< org.quic.camera.HEICSupport
static CHIVENDORTAGDATA g_VendorTagSectionOverrideHEICSupport[] =
{
    { "HEICEnabled",                     TYPE_BYTE,  1                                     }
};

///< org.quic.camera2.ref.cropsize
static CHIVENDORTAGDATA g_VendorTagSectionRefCropsize[] =
{
    { "RefCropSize",                     TYPE_BYTE,  sizeof(RefCropWindowSize)             },
    { "DisableZoomCrop",                 TYPE_INT32, 1                                     }
};

///< org.quic.camera.enableVSR
static CHIVENDORTAGDATA g_VendorTagSectionGeoLibEnableVSR[] =
{
    { "GeoLibEnableVSR",                 TYPE_BYTE,  1                                     },
};

///< org.quic.camera.geoLibInit
static CHIVENDORTAGDATA g_VendorTagSectionGeoLibInit[] =
{
    { "GeoLibInitMetadataVideo",         TYPE_BYTE,  sizeof(GeoLibVideoIfeStreamCfg)       },
    { "GeoLibInitMetadataDisplay",       TYPE_BYTE,  sizeof(GeoLibVideoIfeStreamCfg)       }
};

///< org.quic.camera.geoLibFrameConfig
static CHIVENDORTAGDATA g_VendorTagSectionGeoLibIfeFrameConfig[] =
{
    { "GeoLibIfeFrameCfgMetadataPerPort", TYPE_BYTE, sizeof(GeoLibVideoIfeFrameCfg) * MaxGeoLibIfeFrameConfigTagCount },
};

///< org.quic.camera.enableVSR
static CHIVENDORTAGDATA g_VendorTagSectionGeoLibInitConfig[] =
{
    { "GeoLibEnableVSR",                  0,         sizeof(INT32)                         }
};

///< com.qti.camera.streamCropInfo
static CHIVENDORTAGDATA g_VendorTagSectionPSStreamCropInfo[] =
{
    { "StreamCropInfo",                   0,          sizeof(StreamCropInfo)                },
    { "EnableStreamCrop",                 TYPE_INT32, 1                                     }
};

///< org.quic.camera.ADRCParams
static CHIVENDORTAGDATA g_VendorTagSectionADRCParams[] =
{
    { "ADRCParams",                       TYPE_BYTE, sizeof(ISPADRCParams)                 }
};

///< com.qti.node.swpreprocess
static CHIVENDORTAGDATA g_VendorTagSectionPreprocess[] =
{
    { "SupportedFeature",       TYPE_BYTE,  ChiNodeSupportedFeatureBufferSize },
    { "CurrentMode",            TYPE_BYTE,  1 },
    { "ProcessedFrameNumber",   TYPE_INT64, 1 },
    { "FrameDimension",         TYPE_INT32, 2 },
};

///< org.quic.camera.ADRCParam
static CHIVENDORTAGDATA g_VendorTagSectionIFEAdrcConfig[] =
{
    { "ADRCParams", 0, sizeof(ISPADRCParams) }
};

///< org.quic.camera.HWMFHDRSupported
static CHIVENDORTAGDATA g_VendorTagSectionHWMFHDRSupported[] =
{
    { "isHWMFHDRSupported",                TYPE_BYTE, 1                                     }
};

///< org.quic.camera.induceSleepInChiNode
static CHIVENDORTAGDATA g_VendorTagInduceSleepInChiNode[] =
{
    { "InduceSleep",                     TYPE_INT32, 1                                     }
};

///< com.qti.chi.rawcbinfo
static CHIVENDORTAGDATA g_VendorTagRawCBInfo[] =
{
    { "IdealRaw",     TYPE_BYTE, sizeof(IdealRawInfo) },
    { "RawSize",      TYPE_BYTE, sizeof(CHIDimension) }
};

///< org.quic.camera.forceFullFOV
static CHIVENDORTAGDATA g_VendorTagSectionForceFullFOV[] =
{
    { "ForceFullFOV", TYPE_BYTE, 1 }
};

/// @brief org.codeaurora.qcamera3.sessionParameters
static CHIVENDORTAGDATA g_VendorTagSectionSessionParameters[] =
{
    { "enableMCTFwithReferenceFrame",   TYPE_BYTE,                                   1 }
};

/// @brief org.quic.camera.FOVCMetaData
static CHIVENDORTAGDATA g_VendorTagSectionFOVCMetaData[] =
{
    { "FOVCMargin",        TYPE_FLOAT,      1}
};

///< com.qti.node.supportedLDCmodes
static CHIVENDORTAGDATA g_VendorTagSectionSupportedLDCmodes[] =
{
    { "LDCModes",   TYPE_INT32,     2},
};

///< com.qti.node.supportedEISmodes
static CHIVENDORTAGDATA g_VendorTagSectionSupportedEISmodes[] =
{
    { "EISModes",   TYPE_INT32,     2},
};

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

static const CHAR ChiOverrideNodeSectionName[]      = "com.qti.chi.override";
static const CHAR IPEICASectionName[]               = "org.quic.camera2.ipeicaconfigs";
static const CHAR IFECropInfoSectionName[]          = "org.quic.camera.ifecropinfo";
static const CHAR SensorMetaSectionName[]           = "org.codeaurora.qcamera3.sensor_meta_data";
static const CHAR QTimerSectionName[]               = "org.quic.camera.qtimer";
static const CHAR StreamDimensionSectionName[]      = "org.quic.camera.streamDimension";
static const CHAR RecordingSectionName[]            = "org.quic.camera.recording";
static const CHAR EISLookAheadSectionName[]         = "org.quic.camera.eislookahead";
static const CHAR EISRealTimeSectionName[]          = "org.quic.camera.eisrealtime";
static const CHAR MultiCameraInfoSectionName[]      = "com.qti.chi.metadataOwnerInfo";
static const CHAR CameraConfigurationSectionName[]  = "com.qti.chi.cameraconfiguration";
static const CHAR ChiNodeCropRegions[]              = "com.qti.cropregions";
static const CHAR StatsConfigSectionName[]          = "org.quic.camera2.statsconfigs";
static const CHAR EISDewarpMatrixSectionName[]      = "org.quic.camera2.ipeicaconfigs";
static const CHAR StreamTypePresent[]               = "org.quic.camera.streamTypePresent";
static const CHAR GPUSkipbasedonFDSkip[]            = "org.quic.camera.skipgpuprocessingbasedonfd";
static const CHAR SWRegistrationNodeSectionName[]   = "org.quic.camera2.ipeicaconfigs";
static const CHAR ICACapabilitiesSectionName[]      = "org.codeaurora.qcamera3.platformCapabilities";
static const CHAR GeoLibIfeFrameConfigSectionName[] = "org.quic.camera.geoLibFrameConfig";
static const CHAR GeoLibInitConfigSectionName[]     = "org.quic.camera.enableVSR";
static const CHAR SwMCTFEnablementSectionName[]     = "org.quic.camera.swcapabilities"; ///< SWMCTF enablement status
static const CHAR ScratchBufferMetaSectionName[]    = "org.quic.camera.scratchbufferdata";
static const CHAR SWFusionInfoSectionName[]         = "org.quic.camera.swfusionInfo";
static const CHAR EISMultiCameraInfoSectionName[]   = "com.qti.chi.multicameraoutputmetadata";
static const CHAR PSStreamCropInfoSectionName[]     = "com.qti.camera.streamCropInfo";
static const CHAR PreprocessNodeSectionName[]       = "com.qti.node.swpreprocess";
static const CHAR IFEAdrcConfigSectionName[]        = "org.quic.camera.ADRCParam";
static const CHAR MFHDRFuseSectionName[]            = "org.quic.camera.HWMFHDRSupported";
static const CHAR HDRFeatureModeSectionName[]       = "org.quic.camera.hdrfeaturemode";
static const CHAR HVXFeatureModeSectionName[]       = "org.quic.camera.hvxfeaturemode";
static const CHAR IdealRawCBInfoSectionName[]       = "com.qti.chi.rawcbinfo";
static const CHAR SessionParameterSectionName[]     = "org.codeaurora.qcamera3.sessionParameters";
static const CHAR SWBEStatsSectionName[]            = "org.quic.camera.swbestatsdata";
static const CHAR FOVCMarginSectionName[]           = "org.quic.camera.FOVCMetaData";


static CHIVENDORTAGSECTIONDATA g_VendorTagSectionDataChiOverride[] =
{
    {
        "org.codeaurora.qcamera3.saturation", 0,
        sizeof(g_VendorTagSectionSaturation) / sizeof(g_VendorTagSectionSaturation[0]),
        g_VendorTagSectionSaturation, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        ChiOverrideNodeSectionName, 0,
        sizeof(g_VendorTagDataChiOverride) / sizeof(g_VendorTagDataChiOverride[0]),
        g_VendorTagDataChiOverride, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.multicamerasensorconfig", 0,
        sizeof(g_VendorTagDataMulticameraSensorConfig) / sizeof(g_VendorTagDataMulticameraSensorConfig[0]),
        g_VendorTagDataMulticameraSensorConfig, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.multicamerainputmetadata", 0,
        sizeof(g_VendorTagDataMulticameraInputMetadata) / sizeof(g_VendorTagDataMulticameraInputMetadata[0]),
        g_VendorTagDataMulticameraInputMetadata, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.multicameraoutputmetadata", 0,
        sizeof(g_VendorTagDataMulticameraOutputMetadata) / sizeof(g_VendorTagDataMulticameraOutputMetadata[0]),
        g_VendorTagDataMulticameraOutputMetadata, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.multicamerainfo", 0,
        sizeof(g_VendorTagDataMulticameraInfo) / sizeof(g_VendorTagDataMulticameraInfo[0]),
        g_VendorTagDataMulticameraInfo, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.logicalcamerainfo", 0,
        sizeof(g_VendorTagDataLogicalCameraInfo) / sizeof(g_VendorTagDataLogicalCameraInfo[0]),
        g_VendorTagDataLogicalCameraInfo, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.cropregions",  0,
        sizeof(g_VendorTagCropRegion) / sizeof(g_VendorTagCropRegion[0]),
        g_VendorTagCropRegion, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.camera.swmfnrBlendConfidence", 0,
        CAMX_ARRAY_SIZE(g_VendorTagSectionSWMFNRBlendConfidence), g_VendorTagSectionSWMFNRBlendConfidence,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },

    {
        "com.qti.camera.multiRAWLLHDR", 0,
        CAMX_ARRAY_SIZE(g_VendorTagSectionMultiRAWLLHDR), g_VendorTagSectionMultiRAWLLHDR,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },

    {
        "org.quic.camera.swfusionInfo", 0,
        CAMX_ARRAY_SIZE(g_VendorTagSectionSWFusionInfo), g_VendorTagSectionSWFusionInfo,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },

    {
        "org.quic.camera.scratchbufferdata", 0,
        CAMX_ARRAY_SIZE(g_VendorTagSectionScratchBufferData), g_VendorTagSectionScratchBufferData,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },

    {
        SWBEStatsSectionName, 0,
        CAMX_ARRAY_SIZE(g_VendorTagSectionSWBEStatsData), g_VendorTagSectionSWBEStatsData,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },

    {
        "com.qti.chi.statsaec", 0,
        sizeof(g_VendorTagAECLux) / sizeof(g_VendorTagAECLux[0]),
        g_VendorTagAECLux, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.statsSkip",  0,
        sizeof(g_VendorTagStatsSkip) / sizeof(g_VendorTagStatsSkip[0]),
        g_VendorTagStatsSkip, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.metadataOwnerInfo",  0,
        sizeof(g_VendorTagMetaOwnerInfo) / sizeof(g_VendorTagMetaOwnerInfo[0]),
        g_VendorTagMetaOwnerInfo, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.feature2RequestInfo",  0,
        sizeof(g_VendorTagFeature2RequestInfo) / sizeof(g_VendorTagFeature2RequestInfo[0]),
        g_VendorTagFeature2RequestInfo, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.cameraconfiguration",  0,
        sizeof(g_VendorTagDataCameraConfiguration) / sizeof(g_VendorTagDataCameraConfiguration[0]),
        g_VendorTagDataCameraConfiguration, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },

    {
        "com.qti.chi.superslowmotionfrc", 0,
        sizeof(g_VendorTagSuperSlowMotionFRC) / sizeof(g_VendorTagSuperSlowMotionFRC[0]),
        g_VendorTagSuperSlowMotionFRC, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.bpsrealtimecam", 0,
        sizeof(g_VendorTagBPSRealtimeCam) / sizeof(g_VendorTagBPSRealtimeCam[0]),
        g_VendorTagBPSRealtimeCam, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "com.qti.chi.ZSLSettings", 0,
        sizeof(g_VendorTagZSLTags) / sizeof(g_VendorTagZSLTags[0]),
        g_VendorTagZSLTags, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "com.qti.chi.livePreview", 0,
        sizeof(g_VendorTagLivePreview) / sizeof(g_VendorTagLivePreview[0]),
        g_VendorTagLivePreview, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "com.qti.chi.snapshotframeexposuretype", 0,
        sizeof(g_VendorTagExposureType) / sizeof(g_VendorTagExposureType[0]),
        g_VendorTagExposureType, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },

    {
        "org.quic.camera.debugDumpConfig", 0,
        sizeof(g_VendorTagDebugDumpConfig) / sizeof(g_VendorTagDebugDumpConfig[0]),
        g_VendorTagDebugDumpConfig, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "com.qti.chi.offlinepipelineinfo", 0,
        sizeof(g_VendorTagOfflinePipelineInfo) / sizeof(g_VendorTagOfflinePipelineInfo[0]),
        g_VendorTagOfflinePipelineInfo, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },
    {
        "com.qti.chi.pixelshift", 0,
        sizeof(g_VendorTagPixelShift) / sizeof(g_VendorTagPixelShift[0]),
        g_VendorTagPixelShift, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },
    {
        "org.quic.camera.AnchorSync", 0,
        sizeof(g_VendorTagAnchorSync) / sizeof(g_VendorTagAnchorSync[0]),
        g_VendorTagAnchorSync, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "org.quic.camera.MultiFrame", 0,
        sizeof(g_VendorTagMultiFrameInfo) / sizeof(g_VendorTagMultiFrameInfo[0]),
        g_VendorTagMultiFrameInfo, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "org.quic.camera.induceSleepInChiNode", 0,
        sizeof(g_VendorTagInduceSleepInChiNode) / sizeof(g_VendorTagInduceSleepInChiNode[0]),
        g_VendorTagInduceSleepInChiNode, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToOEM
    },
    {
        "com.qti.chi.rawcbinfo", 0,
        sizeof(g_VendorTagRawCBInfo) / sizeof(g_VendorTagRawCBInfo[0]),
        g_VendorTagRawCBInfo, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "com.qti.chi.qllControl", 0,
        sizeof(g_VendorTagQLLControl) / sizeof(g_VendorTagQLLControl[0]),
        g_VendorTagQLLControl, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "org.codeaurora.qcamera3.ir_led", 0,
        sizeof(g_VendorTagSectionIRLed) / sizeof(g_VendorTagSectionIRLed[0]),
        g_VendorTagSectionIRLed, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
    {
        "org.codeaurora.qcamera3.pwm_frequency", 0,
        sizeof(g_VendorTagSectionPWMfrequency) / sizeof(g_VendorTagSectionPWMfrequency[0]),
        g_VendorTagSectionPWMfrequency, CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    },
};

///< camxchinodeswpreprocess.cpp
static CHIVENDORTAGSECTIONDATA g_VendorTagPreprocessSection[] =
{
    {
        PreprocessNodeSectionName,  0,
        sizeof(g_VendorTagSectionPreprocess) / sizeof(g_VendorTagSectionPreprocess[0]), g_VendorTagSectionPreprocess,
        CHITAGSECTIONVISIBILITY::ChiTagSectionVisibleToAll
    }
};

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

static ChiVendorTagInfo g_VendorTagInfoChiOverride[] =
{
    {
        & g_VendorTagSectionDataChiOverride[0],
        sizeof(g_VendorTagSectionDataChiOverride) / sizeof(g_VendorTagSectionDataChiOverride[0])
    }
};

///< camxchinodeswpreprocess.cpp
static ChiVendorTagInfo g_VendorTagInfoPreprocess[] =
{
    {
        &g_VendorTagPreprocessSection[0],
        sizeof(g_VendorTagPreprocessSection) / sizeof(g_VendorTagPreprocessSection[0])
    }
};

#endif // CHIVENDORTAGDEFINES_H
