/* Copyright (c) 2017 Samsung Electronics Co, Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.

 *

 * Alternatively, Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*2012.04.18 Version 0.1 Initial Release*/
/*2012.04.23 Version 0.2 Added static metadata (draft)*/
/*2012.07.04 Version 0.3 Applied google's undocumented changes (draft)*/
/*2012.07.11 Version 0.4 Added FD parameters */
/*2012.07.27 Version 0.5 Modified HSB control and DM */
/*2012.08.28 Version 0.6 Added AA_SCENE_MODE_NIGHT_CAPTURE */
/*2012.10.15 Version 0.7 Added contrast in colorcorrection */
/*2012.10.22 Version 0.8 Added analogGain and digitalGain in sensor control */
/*2012.10.30 Version 0.9 Added disTargetAddress in camera2_scaler_uctl */
/*2012.10.31 Version 0.10 Added user-defined metadata for 3A */
/*2012.11.27 Version 0.11 Added image effects */
/*2012.12.10 Version 0.12 Modified aa_aemode */

#ifndef FIMC_IS_METADATA_H_
#define FIMC_IS_METADATA_H_

#ifndef _LINUX_TYPES_H
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef unsigned int uint32_t;
/*typedef unsigned long long uint64_t;*/
#endif

struct rational {
    int32_t num;
    int32_t den;
};

#define CAMERA2_MAX_AVAILABLE_MODE          21
#define CAMERA2_MAX_FACES                   16
#define CAMERA2_MAX_VENDER_LENGTH           400
#define CAMERA2_MAX_IPC_VENDER_LENGTH		1049
#define CAPTURE_NODE_MAX                    12

#define CAMERA2_MAX_PDAF_MULTIROI_COLUMN    13
#define CAMERA2_MAX_PDAF_MULTIROI_ROW       9
#define CAMERA2_MAX_UCTL_VENDER_LENGTH      32

#define CAMERA2_MAX_UCTL_VENDOR2_LENGTH      400
#define CAMERA2_MAX_UDM_VENDOR2_LENGTH       32
#define OPEN_MAGIC_NUMBER       0x01020304
#define SHOT_MAGIC_NUMBER       0x23456789

#include "ExynosCameraConfig.h"

/*
 *controls/dynamic metadata
 */

/* android.request */

enum metadata_mode {
    METADATA_MODE_NONE,
    METADATA_MODE_FULL
};

enum is_subscenario_id {
    ISS_SUB_SCENARIO_STILL_PREVIEW = 0,     /* 0: still preview */
    ISS_SUB_SCENARIO_VIDEO = 1,             /* 1: video */
    ISS_SUB_SCENARIO_UHD_30FPS_WDR_ON = 2,  /* 2: video UHD QHD 30fps (HDR ON) */
    ISS_SUB_SCENARIO_UHD_30FPS_WDR_AUTO = 3,/* 3: video UHD QHD 30fps (HDR AUTO) */
    ISS_SUB_SCENARIO_VIDEO_HIGH_SPEED = 4,  /* 4: video high speed */
    ISS_SUB_SCENARIO_STILL_CAPTURE = 5,     /* 5: still capture */
    ISS_SUB_SCENARIO_FHD_60FPS = 6,         /* 6: video FHD 60fps (HDR OFF)*/
    ISS_SUB_SCENARIO_UHD_30FPS = 7,         /* 7: video UHD QHD 30fps (HDR OFF) */
    ISS_SUB_SCENARIO_WVGA_300FPS = 8,       /* 8: video WVGA 300fps */
    ISS_SUB_SCENARIO_STILL_PREVIEW_WDR_ON = 9,
    ISS_SUB_SCENARIO_VIDEO_WDR_ON = 10,
    ISS_SUB_SCENARIO_STILL_CAPTURE_WDR_ON = 11,
    ISS_SUB_SCENARIO_STILL_CAPTURE_ZOOM = 13,
    ISS_SUB_SCENARIO_STILL_CAPTURE_ZOOM_INDOOR = 14,
    ISS_SUB_SCENARIO_STILL_CAPTURE_ZOOM_OUTDOOR = 15,
    ISS_SUB_SCENARIO_STILL_CAPTURE_WDR_ON_ZOOM = 16,
    ISS_SUB_SCENARIO_STILL_CAPTURE_DNG_REPROCESSING = 17,
    ISS_SUB_SCENARIO_FHD_60FPS_WDR_ON = 18,             /* 18: video FHD 60fps (HDR ON) */
    ISS_SUB_SCENARIO_STILL_CAPTURE_LLS = 19,
    ISS_SUB_SCENARIO_MERGED_STILL_CAPTURE_WDR_AUTO = ISS_SUB_SCENARIO_STILL_CAPTURE_LLS,
    ISS_SUB_SCENARIO_STILL_CAPTURE_WDR_ON_LLS = 20,
    ISS_SUB_SCENARIO_MERGED_STILL_CAPTURE_WDR_ON = ISS_SUB_SCENARIO_STILL_CAPTURE_WDR_ON_LLS,
    ISS_SUB_SCENARIO_UHD_60FPS_WDR_ON = 21,             /* 21: video UHD 60fps (HDR ON) */
    ISS_SUB_SCENARIO_UHD_60FPS = 22,                    /* 22: video UHD 60fps (HDR OFF) */
    ISS_SUB_SCENARIO_UHD_60FPS_WDR_AUTO = 23,           /* 23: video UHD 60fps (HDR AUTO) */
    ISS_SUB_SCENARIO_STILL_CAPTURE_WDR_AUTO = 24,
    ISS_SUB_SCENARIO_VIDEO_WDR_AUTO = 25,
    ISS_SUB_SCENARIO_STILL_PREVIEW_WDR_AUTO = 26,
    ISS_SUB_SCENARIO_FHD_240FPS = 27,
    ISS_SUB_SCENARIO_MERGED_STILL_CAPTURE = 28,
    ISS_SUB_SCENARIO_FHD_60FPS_WDR_AUTO = 29,           /* 29: video FHD 60fps (HDR AUTO) */
    ISS_SUB_SCENARIO_STILL_CAPTURE_LONG = 30,
    ISS_SUB_SCENARIO_STILL_PREVIEW_BINNING = 40,        /* 40: binning mode for low power */
    ISS_SUB_SCENARIO_STILL_CAPTURE_BDS = 41,            /* 41: still capture bds */
    ISS_SUB_SCENARIO_STILL_PREVIEW_LLS = 42,            /* 42: still preview lls */
    ISS_SUB_SCENARIO_LIVE_OUTFOCUS_PREVIEW = 44,        /* 44 ~ 50: Bokeh (HDR off/auto/on) */
    ISS_SUB_SCENARIO_LIVE_OUTFOCUS_CAPTURE = 45,
    ISS_SUB_SCENARIO_LIVE_OUTFOCUS_PREVIEW_WDR_AUTO = 47,
    ISS_SUB_SCENARIO_LIVE_OUTFOCUS_PREVIEW_WDR_ON = 48,
    ISS_SUB_SCENARIO_LIVE_OUTFOCUS_CAPTURE_WDR_AUTO = 49,
    ISS_SUB_SCENARIO_LIVE_OUTFOCUS_CAPTURE_WDR_ON = 50,
    ISS_SUB_SCENARIO_STILL_PREVIEW_3RD_PARTY_WDR_AUTO = 51,
    ISS_SUB_SCENARIO_VIDEO_3RD_PARTY_WDR_AUTO = 52,

    ISS_SUB_SCENARIO_FRONT_VT1 = 31,                    /* 31: front camera VT1 */
    ISS_SUB_SCENARIO_FRONT_VT2 = 32,                    /* 32: front camera VT2 */
    ISS_SUB_SCENARIO_FRONT_SMART_STAY = 33,             /* 33: front camera smart stay */
    ISS_SUB_SCENARIO_FRONT_PANORAMA = 34,               /* 34: front camera front panorama */
    ISS_SUB_SCENARIO_FRONT_C2_OFF_STILL_PREVIEW = 35,   /* 35: C2 off front still preview */
    ISS_SUB_SCENARIO_FRONT_C2_OFF_STILL_CAPTURE = 36,   /* 36: C2 off front still capture */
    ISS_SUB_SCENARIO_FRONT_C2_OFF_VIDEO = 37,           /* 37: C2 off front video */
    ISS_SUB_SCENARIO_FRONT_VT4 = 38,                    /* 38: front camera VT4 */
    ISS_SUB_SCENARIO_FRONT_VT1_STILL_CAPTURE = 39,      /* 39: front camera VT1 still capture */
    ISS_SUB_SCENARIO_FRONT_STILL_PREVIEW_BINNING = 40,  /* 40: front camera binning mode for low power */
    ISS_SUB_SCENARIO_FRONT_COLOR_IRIS_PREVIEW = 43,     /* 43: front camera Color Iris preview */
    ISS_SUB_END,
};

enum is_scenario_is {
    FIMC_IS_SCENARIO_SWVDIS = 1,
    FIMC_IS_SCENARIO_COLOR_IRIS = 2,
    FIMC_IS_SCENARIO_AUTO_DUAL = 3,
    FIMC_IS_SCENARIO_FULL_SIZE = 4,
    FIMC_IS_SCENARIO_HIGH_SPEED_DUALFPS = 5, /* FPS is changed from normal to high speed */
};

enum available_capabilities {
    REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE = 0,
    REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR,
    REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING,
    REQUEST_AVAILABLE_CAPABILITIES_RAW,
    REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING,
    REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS,
    REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE,
    REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING,
    REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT,
    REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO,
};

struct camera2_request_ctl {
    uint32_t            frameCount;
    uint32_t            id;
    enum metadata_mode  metadataMode;

    /* vendor feature */
    uint32_t            vendor_frameCount;
};

struct camera2_request_dm {
    uint32_t            frameCount;
    uint32_t            id;
    enum metadata_mode  metadataMode;
    uint8_t             pipelineDepth;
    uint32_t            vendor_frameCount;
};

struct camera2_request_sm {
    uint32_t    maxNumOutputStreams[3];
    uint32_t    maxNumOutputRaw;
    uint32_t    maxNumOutputProc;
    uint32_t    maxNumOutputProcStalling;
    uint32_t    maxNumInputStreams;
    uint8_t     pipelineMaxDepth;
    uint32_t    partialResultCount;
    uint8_t     availableCapabilities[CAMERA2_MAX_AVAILABLE_MODE];
    uint32_t    availableRequestKeys[CAMERA2_MAX_AVAILABLE_MODE];
    uint32_t    availableResultKeys[CAMERA2_MAX_AVAILABLE_MODE];
    uint32_t    availableCharacteristicsKeys[CAMERA2_MAX_AVAILABLE_MODE];
};

struct camera2_entry_ctl {
    uint32_t    lowIndexParam;
    uint32_t    highIndexParam;
    uint32_t    parameter[2048];
};

struct camera2_entry_dm {
    uint32_t    lowIndexParam;
    uint32_t    highIndexParam;
};

/* android.lens */

enum optical_stabilization_mode {
    OPTICAL_STABILIZATION_MODE_OFF = 0,
    OPTICAL_STABILIZATION_MODE_ON = 1,

    /* vendor feature */
    OPTICAL_STABILIZATION_MODE_STILL = 100, // Still mode
    OPTICAL_STABILIZATION_MODE_STILL_ZOOM,  // Still Zoom mode
    OPTICAL_STABILIZATION_MODE_VIDEO,       // Recording mode
    OPTICAL_STABILIZATION_MODE_SINE_X,      // factory mode x
    OPTICAL_STABILIZATION_MODE_SINE_Y,      // factory mode y
    OPTICAL_STABILIZATION_MODE_CENTERING,   // Centering mode
    OPTICAL_STABILIZATION_MODE_VDIS,        // VDIS mode
    OPTICAL_STABILIZATION_MODE_VIDEO_RATIO_4_3, // Recording mode(VGA)
};

enum lens_state {
    LENS_STATE_STATIONARY = 0,
    LENS_STATE_MOVING,
};


enum lens_focus_distance_calibration {
    LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED = 0,
    LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE,
    LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED,
};

enum lens_facing {
    LENS_FACING_BACK,
    LENS_FACING_FRONT,
    LENS_FACING_EXTERNAL,
};

struct camera2_lens_ctl {
    int32_t   aperture;
    float   filterDensity;
    float   focalLength;
    float   focusDistance;
    enum optical_stabilization_mode opticalStabilizationMode;
};

struct camera2_lens_dm {
    int32_t   aperture;
    float   filterDensity;
    float   focalLength;
    float   focusDistance;
    float   focusRange[2];
    enum optical_stabilization_mode opticalStabilizationMode;
    enum lens_state     state;
    float   poseRotation[4];
    float   poseTranslation[3];
    float   intrinsicCalibration[5];
    float   radialDistortion[6];
};

struct camera2_lens_sm {
    float       availableApertures[CAMERA2_MAX_AVAILABLE_MODE];
    float       availableFilterDensities[CAMERA2_MAX_AVAILABLE_MODE];
    float       availableFocalLength[CAMERA2_MAX_AVAILABLE_MODE];
    uint8_t     availableOpticalStabilization[CAMERA2_MAX_AVAILABLE_MODE];
    float       hyperfocalDistance;
    float       minimumFocusDistance;
    uint32_t    shadingMapSize[2];
    enum lens_focus_distance_calibration    focusDistanceCalibration;
    enum lens_facing    facing;
    float       poseRotation[4];
    float       poseTranslation[3];
    float       intrinsicCalibration[5];
    float       radialDistortion[6];
};

/* android.sensor */

enum sensor_test_pattern_mode {
    SENSOR_TEST_PATTERN_MODE_OFF = 1,
    SENSOR_TEST_PATTERN_MODE_SOLID_COLOR,
    SENSOR_TEST_PATTERN_MODE_COLOR_BARS,
    SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY,
    SENSOR_TEST_PATTERN_MODE_PN9,
    SENSOR_TEST_PATTERN_MODE_CUSTOM1 = 257,
};

enum sensor_colorfilterarrangement {
    SENSOR_COLORFILTERARRANGEMENT_RGGB,
    SENSOR_COLORFILTERARRANGEMENT_GRBG,
    SENSOR_COLORFILTERARRANGEMENT_GBRG,
    SENSOR_COLORFILTERARRANGEMENT_BGGR,
    SENSOR_COLORFILTERARRANGEMENT_RGB
};

enum sensor_timestamp_calibration {
    SENSOR_INFO_TIMESTAMP_CALIBRATION_UNCALIBRATED = 0,
    SENSOR_INFO_TIMESTAMP_CALIBRATION_CALIBRATED,
};

enum sensor_lensshading_applied {
    SENSOR_INFO_LENS_SHADING_APPLIED_FALSE = 0,
    SENSOR_INFO_LENS_SHADING_APPLIED_TRUE,
};

enum sensor_ref_illuminant {
    SENSOR_ILLUMINANT_DAYLIGHT = 1,
    SENSOR_ILLUMINANT_FLUORESCENT = 2,
    SENSOR_ILLUMINANT_TUNGSTEN = 3,
    SENSOR_ILLUMINANT_FLASH = 4,
    SENSOR_ILLUMINANT_FINE_WEATHER = 9,
    SENSOR_ILLUMINANT_CLOUDY_WEATHER = 10,
    SENSOR_ILLUMINANT_SHADE = 11,
    SENSOR_ILLUMINANT_DAYLIGHT_FLUORESCENT = 12,
    SENSOR_ILLUMINANT_DAY_WHITE_FLUORESCENT = 13,
    SENSOR_ILLUMINANT_COOL_WHITE_FLUORESCENT = 14,
    SENSOR_ILLUMINANT_WHITE_FLUORESCENT = 15,
    SENSOR_ILLUMINANT_STANDARD_A = 17,
    SENSOR_ILLUMINANT_STANDARD_B = 18,
    SENSOR_ILLUMINANT_STANDARD_C = 19,
    SENSOR_ILLUMINANT_D55 = 20,
    SENSOR_ILLUMINANT_D65 = 21,
    SENSOR_ILLUMINANT_D75 = 22,
    SENSOR_ILLUMINANT_D50 = 23,
    SENSOR_ILLUMINANT_ISO_STUDIO_TUNGSTEN = 24
};

struct camera2_sensor_ctl {
    uint64_t    exposureTime;
    uint64_t    frameDuration;
    uint32_t    sensitivity;
    int32_t     testPatternData[4];
    enum sensor_test_pattern_mode	testPatternMode;
};

struct camera2_sensor_dm {
    uint64_t        exposureTime;
    uint64_t        frameDuration;
    uint32_t        sensitivity;
    uint64_t        timeStamp;
    float           temperature;
    struct rational neutralColorPoint[3];
    double          noiseProfile[4][2];
    float           profileHueSatMap[2][2][2][3];
    float           profileToneCurve[32][2];
    float           greenSplit;
    int32_t         testPatternData[4];
    enum sensor_test_pattern_mode   testPatternMode;
    uint64_t        rollingShutterSkew;
};

struct camera2_sensor_sm {
    uint32_t    activeArraySize[4];
    uint32_t    preCorrectionActiveArraySize[4];
    uint32_t    sensitivityRange[2];
    enum sensor_colorfilterarrangement  colorFilterArrangement;
    uint64_t    exposureTimeRange[2];
    uint64_t    maxFrameDuration;
    float       physicalSize[2];
    uint32_t    pixelArraySize[2];
    uint32_t    whiteLevel;
    enum sensor_timestamp_calibration   timestampCalibration;
    enum sensor_lensshading_applied     lensShadingApplied;
    enum sensor_ref_illuminant          referenceIlluminant1;
    enum sensor_ref_illuminant          referenceIlluminant2;
    struct rational calibrationTransform1[9];
    struct rational calibrationTransform2[9];
    struct rational colorTransform1[9];
    struct rational colorTransform2[9];
    struct rational forwardMatrix1[9];
    struct rational forwardMatrix2[9];
    struct rational baseGainFactor;
    uint32_t    blackLevelPattern[4];
    uint32_t    maxAnalogSensitivity;
    uint32_t    orientation;
    uint32_t    profileHueSatMapDimensions[3];
    uint32_t    availableTestPatternModes[CAMERA2_MAX_AVAILABLE_MODE];
};


/* android.flash */

enum flash_mode {
    CAM2_FLASH_MODE_NONE = 0,
    CAM2_FLASH_MODE_OFF = 1,
    CAM2_FLASH_MODE_SINGLE,
    CAM2_FLASH_MODE_TORCH,

    /* vendor feature */
    CAM2_FLASH_MODE_BEST = 100,
    CAM2_FLASH_MODE_LCD = 101,
};

enum flash_state {
    FLASH_STATE_UNAVAILABLE = 0,
    FLASH_STATE_CHARGING,
    FLASH_STATE_READY,
    FLASH_STATE_FIRED,
    FLASH_STATE_PARTIAL,
};

enum capture_state {
    CAPTURE_STATE_NONE = 0,
    CAPTURE_STATE_FLASH = 1,
    CAPTURE_STATE_HDR_DARK = 12,
    CAPTURE_STATE_HDR_NORMAL = 13,
    CAPTURE_STATE_HDR_BRIGHT = 14,
    CAPTURE_STATE_ZSL_LIKE = 20,
    CAPTURE_STATE_STREAM_ON_CAPTURE = 30,
    CAPTURE_STATE_RAW_CAPTURE = 100,
}; /* firingStable state */

enum flash_info_available {
    FLASH_INFO_AVAILABLE_FALSE = 0,
    FLASH_INFO_AVAILABLE_TRUE,
};

struct camera2_flash_ctl {
    uint32_t            firingPower;
    uint64_t            firingTime;
    enum flash_mode     flashMode;
};

struct camera2_flash_dm {
    uint32_t            firingPower;
    uint64_t            firingTime;
    enum flash_mode     flashMode;
    enum flash_state    flashState;

    /* vendor feature */
    uint32_t            vendor_firingStable;
    uint32_t            vendor_decision;
    uint32_t            vendor_flashReady;
    uint32_t            vendor_flashOffReady;
};

struct camera2_flash_sm {
    enum flash_info_available   available;
    uint64_t                    chargeDuration;
    uint8_t                     colorTemperature;
    uint8_t                     maxEnergy;
};


/* android.hotpixel */

enum processing_mode {
    PROCESSING_MODE_OFF = 1,
    PROCESSING_MODE_FAST,
    PROCESSING_MODE_HIGH_QUALITY,
    PROCESSING_MODE_MINIMAL,

    /* vendor feature */
    PROCESSING_MODE_MANUAL = 100,
};


struct camera2_hotpixel_ctl {
    enum processing_mode    mode;
};

struct camera2_hotpixel_dm {
    enum processing_mode    mode;
};

struct camera2_hotpixel_sm {
    uint8_t availableHotPixelModes[CAMERA2_MAX_AVAILABLE_MODE];
};


/* android.demosaic */

enum demosaic_processing_mode {
    DEMOSAIC_PROCESSING_MODE_FAST = 1,
    DEMOSAIC_PROCESSING_MODE_HIGH_QUALITY
};

struct camera2_demosaic_ctl {
    enum demosaic_processing_mode	mode;
};

struct camera2_demosaic_dm {
    enum demosaic_processing_mode	mode;
};


/* android.noiseReduction */

struct camera2_noisereduction_ctl {
    enum processing_mode    mode;
    uint8_t                 strength;
};

struct camera2_noisereduction_dm {
    enum processing_mode    mode;
    uint8_t                 strength;
};

struct camera2_noisereduction_sm {
    uint8_t availableNoiseReductionModes[CAMERA2_MAX_AVAILABLE_MODE];
};


/* android.shading */

struct camera2_shading_ctl {
    enum processing_mode    mode;
    uint8_t                 strength; /* Range: 1 ~ 10 */ // TODO: [API32] not implemented yet
};

struct camera2_shading_dm {
    enum processing_mode    mode;
    uint8_t                 strength; /* Range: 1 ~ 10 */ // TODO: [API32] not implemented yet
};

struct camera2_shading_sm {
    enum processing_mode    availableModes[CAMERA2_MAX_AVAILABLE_MODE];
};


/* android.colorCorrection */

enum colorcorrection_mode {
    COLORCORRECTION_MODE_TRANSFORM_MATRIX = 1,
    COLORCORRECTION_MODE_FAST,
    COLORCORRECTION_MODE_HIGH_QUALITY,
};


struct camera2_colorcorrection_ctl {
    enum colorcorrection_mode   mode;
    struct rational             transform[9];
    float                       gains[4];
    enum processing_mode        aberrationCorrectionMode;

    /* vendor feature */
    uint32_t    vendor_hue;
    uint32_t    vendor_saturation;
    uint32_t    vendor_brightness;
    uint32_t    vendor_contrast;
};

struct camera2_colorcorrection_dm {
    enum colorcorrection_mode   mode;
    struct rational             transform[9];
    float                       gains[4];
    enum processing_mode        aberrationCorrectionMode;

    /* vendor feature */
    uint32_t    vendor_hue;
    uint32_t    vendor_saturation;
    uint32_t    vendor_brightness;
    uint32_t    vendor_contrast;
};

struct camera2_colorcorrection_sm {
    uint8_t     availableModes[CAMERA2_MAX_AVAILABLE_MODE];
    uint8_t     availableAberrationCorrectionModes[CAMERA2_MAX_AVAILABLE_MODE];

    /* vendor feature */
    uint32_t    vendor_hueRange[2];
    uint32_t    vendor_saturationRange[2];
    uint32_t    vendor_brightnessRange[2];
    uint32_t    vendor_contrastRange[2];
};


/* android.tonemap */

enum tonemap_mode {
    TONEMAP_MODE_CONTRAST_CURVE = 1,
    TONEMAP_MODE_FAST,
    TONEMAP_MODE_HIGH_QUALITY,
    TONEMAP_MODE_GAMMA_VALUE,
    TONEMAP_MODE_PRESET_CURVE,
};

enum tonemap_presetCurve {
    TONEMAP_PRESET_CURVE_SRGB,
    TONEMAP_PRESET_CURVE_REC709,
};

struct camera2_tonemap_ctl {
    float   curveBlue[64];
    float   curveGreen[64];
    float   curveRed[64];
    float   curve;
    enum tonemap_mode         mode;
    float   gamma;
    enum tonemap_presetCurve  presetCurve;
};

struct camera2_tonemap_dm {
    float   curveBlue[64];
    float   curveGreen[64];
    float   curveRed[64];
    float   curve;
    enum tonemap_mode         mode;
    float   gamma;
    enum tonemap_presetCurve  presetCurve;
};

struct camera2_tonemap_sm {
    uint32_t    maxCurvePoints;
    uint8_t     availableToneMapModes[CAMERA2_MAX_AVAILABLE_MODE];
};

/* android.edge */

struct camera2_edge_ctl {
    enum processing_mode    mode;
    uint8_t                 strength;
};

struct camera2_edge_dm {
    enum processing_mode    mode;
    uint8_t                 strength;
};

struct camera2_edge_sm {
    uint8_t     availableEdgeModes[CAMERA2_MAX_AVAILABLE_MODE];
};


/* android.scaler */

struct camera2_scaler_ctl {
    uint32_t    cropRegion[4];
};

struct camera2_scaler_dm {
    uint32_t    cropRegion[4];
};

enum available_stream_configurations {
    SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT = 0,
    SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT,
};

enum scaler_cropping_type {
    SCALER_CROPPING_TYPE_CENTER_ONLY = 0,
    SCALER_CROPPING_TYPE_FREEFORM,
};

struct camera2_scaler_sm {
    float       availableMaxDigitalZoom;
    int32_t     availableInputOutputFormatsMap;
    uint8_t     availableStreamConfigurations[CAMERA2_MAX_AVAILABLE_MODE][4];
    uint64_t    availableMinFrameDurations[CAMERA2_MAX_AVAILABLE_MODE][4];
    uint64_t    availableStallDurations[CAMERA2_MAX_AVAILABLE_MODE][4];
    int32_t     streamConfigurationMap;
    enum scaler_cropping_type   croppingType;
};

/* android.jpeg */
struct camera2_jpeg_ctl {
    uint8_t     gpsLocation;
    double      gpsCoordinates[3];
    uint8_t     gpsProcessingMethod[32];
    uint64_t    gpsTimestamp;
    uint32_t    orientation;
    uint8_t     quality;
    uint8_t     thumbnailQuality;
    uint32_t    thumbnailSize[2];
};

struct camera2_jpeg_dm {
    uint8_t     gpsLocation;
    double      gpsCoordinates[3];
    uint8_t     gpsProcessingMethod[32];
    uint64_t    gpsTimestamp;
    uint32_t    orientation;
    uint8_t     quality;
    uint32_t    size;
    uint8_t     thumbnailQuality;
    uint32_t    thumbnailSize[2];
};

struct camera2_jpeg_sm {
    uint32_t    availableThumbnailSizes[8][2];
    uint32_t    maxSize;
};

/* android.statistics */

enum facedetect_mode {
    FACEDETECT_MODE_OFF = 1,
    FACEDETECT_MODE_SIMPLE,
    FACEDETECT_MODE_FULL
};

enum stats_mode {
    STATS_MODE_OFF = 1,
    STATS_MODE_ON
};


enum stats_scene_flicker {
    STATISTICS_SCENE_FLICKER_NONE = 1,
    STATISTICS_SCENE_FLICKER_50HZ,
    STATISTICS_SCENE_FLICKER_60HZ,
};

enum stats_lowlightmode {
    STATE_LLS_LEVEL_ZSL                          = 0,
    STATE_LLS_LEVEL_LOW                          = 1,
    STATE_LLS_LEVEL_HIGH                         = 2,
    STATE_LLS_LEVEL_SIS                          = 3,
    STATE_LLS_LEVEL_ZSL_LIKE                     = 4,
    STATE_LLS_LEVEL_ZSL_LIKE1                    = 7,
    STATE_LLS_LEVEL_SHARPEN_SINGLE               = 8,
    STATE_LLS_MANUAL_ISO                         = 9,
    STATE_LLS_LEVEL_SHARPEN_DR                   = 10,
    STATE_LLS_LEVEL_SHARPEN_IMA                  = 11,
    STATE_LLS_LEVEL_STK                          = 12,
    STATE_LLS_LEVEL_FLASH                        = 16,
    STATE_LLS_LEVEL_MULTI_MERGE_2                = 18,
    STATE_LLS_LEVEL_MULTI_MERGE_3                = 19,
    STATE_LLS_LEVEL_MULTI_MERGE_4                = 20,
    STATE_LLS_LEVEL_MULTI_PICK_2                 = 34,
    STATE_LLS_LEVEL_MULTI_PICK_3                 = 35,
    STATE_LLS_LEVEL_MULTI_PICK_4                 = 36,
    STATE_LLS_LEVEL_MULTI_MERGE_INDICATOR_2      = 50,
    STATE_LLS_LEVEL_MULTI_MERGE_INDICATOR_3      = 51,
    STATE_LLS_LEVEL_MULTI_MERGE_INDICATOR_4      = 52,
    STATE_LLS_LEVEL_FLASH_2                      = 66,
    STATE_LLS_LEVEL_FLASH_3                      = 67,
    STATE_LLS_LEVEL_FLASH_4                      = 68,
    STATE_LLS_LEVEL_MULTI_MERGE_INDICATOR_LOW_2  = 82,
    STATE_LLS_LEVEL_MULTI_MERGE_INDICATOR_LOW_3  = 83,
    STATE_LLS_LEVEL_MULTI_MERGE_INDICATOR_LOW_4  = 84,
    STATE_LLS_LEVEL_FLASH_LOW_2                  = 98,
    STATE_LLS_LEVEL_FLASH_LOW_3                  = 99,
    STATE_LLS_LEVEL_FLASH_LOW_4                  = 100,
    STATE_LLS_LEVEL_DUMMY                        = 150,
};

enum stats_wdrAutoState {
    STATE_WDR_AUTO_OFF = 1,
    STATE_WDR_AUTO_REQUIRED = 2,
};

struct camera2_stats_ctl {
    enum facedetect_mode    faceDetectMode;
    enum stats_mode         histogramMode;
    enum stats_mode         sharpnessMapMode;
    enum stats_mode         hotPixelMapMode;
    enum stats_mode         lensShadingMapMode;
};


struct camera2_stats_dm {
    enum facedetect_mode        faceDetectMode;
    uint32_t                    faceIds[CAMERA2_MAX_FACES];
    uint32_t                    faceLandmarks[CAMERA2_MAX_FACES][6];
    uint32_t                    faceRectangles[CAMERA2_MAX_FACES][4];
    uint8_t                     faceScores[CAMERA2_MAX_FACES];
    uint32_t                    faceSrcImageSize[2];
    uint32_t                    faces[CAMERA2_MAX_FACES - 2];
    uint32_t                    histogram[3 * 256];
    enum stats_mode             histogramMode;
    int32_t                     sharpnessMap[2][2][3];
    enum stats_mode             sharpnessMapMode;
    uint8_t                     lensShadingCorrectionMap;
    float                       lensShadingMap[2][2][4];
    enum stats_scene_flicker    sceneFlicker;
    enum stats_mode             hotPixelMapMode;
    int32_t                     hotPixelMap[CAMERA2_MAX_AVAILABLE_MODE][2];
    enum stats_mode             lensShadingMapMode;

    /* vendor feature */
    enum stats_lowlightmode     vendor_LowLightMode;
    uint32_t                    vendor_lls_tuning_set_index;
    uint32_t                    vendor_lls_brightness_index;
    enum stats_wdrAutoState     vendor_wdrAutoState;
};


struct camera2_stats_sm {
    uint8_t         availableFaceDetectModes[CAMERA2_MAX_AVAILABLE_MODE];
    uint32_t        histogramBucketCount;
    uint32_t        maxFaceCount;
    uint32_t        maxHistogramCount;
    uint32_t        maxSharpnessMapValue;
    uint32_t        sharpnessMapSize[2];
    uint32_t        availableHotPixelMapModes[CAMERA2_MAX_AVAILABLE_MODE];
    enum stats_mode availableLensShadingMapModes[CAMERA2_MAX_AVAILABLE_MODE];
};

/* android.control */

enum aa_capture_intent {
    AA_CAPTURE_INTENT_CUSTOM = 0,
    AA_CAPTURE_INTENT_PREVIEW,
    AA_CAPTURE_INTENT_STILL_CAPTURE,
    AA_CAPTURE_INTENT_VIDEO_RECORD,
    AA_CAPTURE_INTENT_VIDEO_SNAPSHOT,
    AA_CAPTURE_INTENT_ZERO_SHUTTER_LAG,
    AA_CAPTURE_INTENT_MANUAL,

    /* vendor feature */
    AA_CAPTURE_INTENT_STILL_CAPTURE_OIS_SINGLE = 100,
    AA_CAPTURE_INTENT_STILL_CAPTURE_OIS_MULTI,
    AA_CAPTURE_INTENT_STILL_CAPTURE_OIS_BEST,
    AA_CAPTURE_INTENT_STILL_CAPTURE_COMP_BYPASS,
    AA_CAPTURE_INTENT_STILL_CAPTURE_RAWDUMP = AA_CAPTURE_INTENT_STILL_CAPTURE_COMP_BYPASS,
    AA_CAPTURE_INTENT_STILL_CAPTURE_OIS_DEBLUR,
    AA_CAPTURE_INTENT_STILL_CAPTURE_DEBLUR_DYNAMIC_SHOT,
    AA_CAPTURE_INTENT_STILL_CAPTURE_OIS_DYNAMIC_SHOT,
    AA_CAPTURE_INTENT_STILL_CAPTURE_EXPOSURE_DYNAMIC_SHOT,
    AA_CAPTURE_INTENT_STILL_CAPTURE_HDR_DYNAMIC_SHOT,
    AA_CAPTURE_INTENT_STILL_CAPTURE_CANCEL,
};

enum aa_mode {
    AA_CONTROL_OFF = 1,
    AA_CONTROL_AUTO,
    AA_CONTROL_USE_SCENE_MODE,
    AA_CONTROL_OFF_KEEP_STATE,
};

enum aa_scene_mode {
    AA_SCENE_MODE_DISABLED = 1,
    AA_SCENE_MODE_FACE_PRIORITY,
    AA_SCENE_MODE_ACTION,
    AA_SCENE_MODE_PORTRAIT,
    AA_SCENE_MODE_LANDSCAPE,
    AA_SCENE_MODE_NIGHT,
    AA_SCENE_MODE_NIGHT_PORTRAIT,
    AA_SCENE_MODE_THEATRE,
    AA_SCENE_MODE_BEACH,
    AA_SCENE_MODE_SNOW,
    AA_SCENE_MODE_SUNSET,
    AA_SCENE_MODE_STEADYPHOTO,
    AA_SCENE_MODE_FIREWORKS,
    AA_SCENE_MODE_SPORTS,
    AA_SCENE_MODE_PARTY,
    AA_SCENE_MODE_CANDLELIGHT,
    AA_SCENE_MODE_BARCODE,
    AA_SCENE_MODE_HIGH_SPEED_VIDEO,
    AA_SCENE_MODE_HDR,
    AA_SCENE_MODE_FACE_PRIORITY_LOW_LIGHT,

    /* vendor feature */
    AA_SCENE_MODE_NIGHT_CAPTURE = 100,
    AA_SCENE_MODE_ANTISHAKE,
    AA_SCENE_MODE_LLS,
    AA_SCENE_MODE_FDAE,
    AA_SCENE_MODE_DUAL,
    AA_SCENE_MODE_DRAMA,
    AA_SCENE_MODE_ANIMATED,
    AA_SCENE_MODE_PANORAMA,
    AA_SCENE_MODE_GOLF,
    AA_SCENE_MODE_PREVIEW,
    AA_SCENE_MODE_VIDEO,
    AA_SCENE_MODE_SLOWMOTION_2,
    AA_SCENE_MODE_SLOWMOTION_4_8,
    AA_SCENE_MODE_DUAL_PREVIEW,
    AA_SCENE_MODE_DUAL_VIDEO,
    AA_SCENE_MODE_120_PREVIEW,
    AA_SCENE_MODE_LIGHT_TRACE,
    AA_SCENE_MODE_FOOD,
    AA_SCENE_MODE_AQUA,
    AA_SCENE_MODE_THERMAL,
    AA_SCENE_MODE_VIDEO_COLLAGE,
    AA_SCENE_MODE_PRO_MODE,
    AA_SCENE_MODE_COLOR_IRIS,
    AA_SCENE_MODE_FACE_LOCK,
    AA_SCENE_MODE_LIVE_OUTFOCUS,
    AA_SCENE_MODE_REMOSAIC,
    AA_SCENE_MODE_SUPER_SLOWMOTION,
    AA_SCENE_MODE_HYPERLAPSE,
};

enum aa_effect_mode {
    AA_EFFECT_OFF = 1,
    AA_EFFECT_MONO,
    AA_EFFECT_NEGATIVE,
    AA_EFFECT_SOLARIZE,
    AA_EFFECT_SEPIA,
    AA_EFFECT_POSTERIZE,
    AA_EFFECT_WHITEBOARD,
    AA_EFFECT_BLACKBOARD,
    AA_EFFECT_AQUA,

    /* vendor feature */
    AA_EFFECT_EMBOSS = 100,
    AA_EFFECT_EMBOSS_MONO,
    AA_EFFECT_SKETCH,
    AA_EFFECT_RED_YELLOW_POINT,
    AA_EFFECT_GREEN_POINT,
    AA_EFFECT_BLUE_POINT,
    AA_EFFECT_MAGENTA_POINT,
    AA_EFFECT_WARM_VINTAGE,
    AA_EFFECT_COLD_VINTAGE,
    AA_EFFECT_WASHED,
    AA_EFFECT_BEAUTY_FACE,

};

enum aa_ae_lock {
    AA_AE_LOCK_OFF = 1,
    AA_AE_LOCK_ON,
};

enum aa_aemode {
    AA_AEMODE_OFF = 1,
    AA_AEMODE_ON,
    AA_AEMODE_ON_AUTO_FLASH,
    AA_AEMODE_ON_ALWAYS_FLASH,
    AA_AEMODE_ON_AUTO_FLASH_REDEYE,

    /* vendor feature */
    AA_AEMODE_CENTER = 100,
    AA_AEMODE_AVERAGE,
    AA_AEMODE_MATRIX,
    AA_AEMODE_SPOT,
    AA_AEMODE_CENTER_TOUCH,
    AA_AEMODE_AVERAGE_TOUCH,
    AA_AEMODE_MATRIX_TOUCH,
    AA_AEMODE_SPOT_TOUCH,
    UNKNOWN_AA_AE_MODE
};

enum aa_ae_flashmode {
    /*all flash control stop*/
    AA_FLASHMODE_OFF = 1,
    /*flash start*/
    AA_FLASHMODE_START,
    /*flash cancle*/
    AA_FLASHMODE_CANCEL,
    /*internal 3A can control flash*/
    AA_FLASHMODE_ON,
    /*internal 3A can do auto flash algorithm*/
    AA_FLASHMODE_AUTO,
    /*internal 3A can fire flash by auto result*/
    AA_FLASHMODE_CAPTURE,
    /*internal 3A can control flash forced*/
    AA_FLASHMODE_ON_ALWAYS
};

enum aa_ae_antibanding_mode {
    AA_AE_ANTIBANDING_OFF = 1,
    AA_AE_ANTIBANDING_50HZ,
    AA_AE_ANTIBANDING_60HZ,
    AA_AE_ANTIBANDING_AUTO,

    /* vendor feature */
    AA_AE_ANTIBANDING_AUTO_50HZ = 100,  /* 50Hz + Auto */
    AA_AE_ANTIBANDING_AUTO_60HZ         /* 60Hz + Auto */
};

enum aa_awb_lock {
    AA_AWB_LOCK_OFF = 1,
    AA_AWB_LOCK_ON,
};

enum aa_awbmode {
    AA_AWBMODE_OFF = 1,
    AA_AWBMODE_WB_AUTO,
    AA_AWBMODE_WB_INCANDESCENT,
    AA_AWBMODE_WB_FLUORESCENT,
    AA_AWBMODE_WB_WARM_FLUORESCENT,
    AA_AWBMODE_WB_DAYLIGHT,
    AA_AWBMODE_WB_CLOUDY_DAYLIGHT,
    AA_AWBMODE_WB_TWILIGHT,
    AA_AWBMODE_WB_SHADE,
    AA_AWBMODE_WB_CUSTOM_K
};

enum aa_ae_precapture_trigger {
    AA_AE_PRECAPTURE_TRIGGER_IDLE = 0,
    AA_AE_PRECAPTURE_TRIGGER_START,
    AA_AE_PRECAPTURE_TRIGGER_CANCEL,
};

enum aa_afmode {
    AA_AFMODE_OFF = 1,
    AA_AFMODE_AUTO,
    AA_AFMODE_MACRO,
    AA_AFMODE_CONTINUOUS_VIDEO,
    AA_AFMODE_CONTINUOUS_PICTURE,
    AA_AFMODE_EDOF,
};

enum aa_afmode_option_bit {
    AA_AFMODE_OPTION_BIT_VIDEO = 0,
    AA_AFMODE_OPTION_BIT_MACRO = 1,
    AA_AFMODE_OPTION_BIT_FACE = 2,
    AA_AFMODE_OPTION_BIT_DELAYED = 3,
    AA_AFMODE_OPTION_BIT_OUT_FOCUSING = 4,
    AA_AFMODE_OPTION_BIT_OBJECT_TRACKING = 5,
    AA_AFMODE_OPTION_BIT_AF_ROI_NO_CONV = 6,
    AA_AFMODE_OPTION_BIT_MULTI_AF = 7,
};

enum aa_afmode_ext {
    AA_AFMODE_EXT_OFF = 1,
    AA_AFMODE_EXT_ADVANCED_MACRO_FOCUS = 2,
    AA_AFMODE_EXT_FOCUS_LOCATION = 3,
    AA_AFMODE_EXT_FIXED_FACE = 4,
};

enum aa_af_trigger {
    AA_AF_TRIGGER_IDLE = 0,
    AA_AF_TRIGGER_START,
    AA_AF_TRIGGER_CANCEL,
};

enum aa_afstate {
    AA_AFSTATE_INACTIVE = 1,
    AA_AFSTATE_PASSIVE_SCAN,
    AA_AFSTATE_PASSIVE_FOCUSED,
    AA_AFSTATE_ACTIVE_SCAN,
    AA_AFSTATE_FOCUSED_LOCKED,
    AA_AFSTATE_NOT_FOCUSED_LOCKED,
    AA_AFSTATE_PASSIVE_UNFOCUSED,
};

enum ae_state {
    AE_STATE_INACTIVE = 1,
    AE_STATE_SEARCHING,
    AE_STATE_CONVERGED,
    AE_STATE_LOCKED,
    AE_STATE_FLASH_REQUIRED,
    AE_STATE_PRECAPTURE,
    AE_STATE_LOCKED_CONVERGED = 10,
    AE_STATE_LOCKED_FLASH_REQUIRED,
    AE_STATE_SEARCHING_FLASH_REQUIRED,
};

enum awb_state {
    AWB_STATE_INACTIVE = 1,
    AWB_STATE_SEARCHING,
    AWB_STATE_CONVERGED,
    AWB_STATE_LOCKED
};

enum aa_videostabilization_mode {
    VIDEO_STABILIZATION_MODE_OFF = 0,
    VIDEO_STABILIZATION_MODE_ON,
};

enum aa_isomode {
    AA_ISOMODE_AUTO = 1,
    AA_ISOMODE_MANUAL,
};

enum aa_cameraid {
    AA_CAMERAID_FRONT = 1,
    AA_CAMERAID_REAR,
};

enum aa_cameraMode{
    AA_CAMERAMODE_SINGLE = 1,
    AA_CAMERAMODE_DUAL_SYNC = 2,
    AA_CAMERAMODE_DUAL_ASYNC = 3,
    AA_CAMERAMODE_DUAL_ONE_SENSOR_OFF = 4,
    AA_CAMERAMODE_DUAL_SYNC_SAME_TIME_CONTROL = 5,
};

enum aa_sensorPlace{
    AA_SENSORPLACE_REAR = 0,
    AA_SENSORPLACE_FRONT = 1,
    AA_SENSORPLACE_REAR_SECOND = 2,
    AA_SENSORPLACE_FRONT_SECOND = 5,
};

enum aa_fallback{
    AA_FALLBACK_INACTIVE = 0,
    AA_FALLBACK_ACTIVE = 1,
};

enum aa_cameratype {
    AA_CAMERATYPE_SINGLE = 1,
    AA_CAMERATYPE_WIDE,
    AA_CAMERATYPE_TELE,
};

enum aa_videomode {
    AA_VIDEOMODE_OFF = 0,
    AA_VIDEOMODE_ON,
};

enum aa_ae_facemode {
    AA_AE_FACEMODE_OFF = 0,
    AA_AE_FACEMODE_ON,
};

enum aa_ae_lockavailable {
    AE_LOCK_AVAILABLE_FALSE = 0,
    AE_LOCK_AVAILABLE_TRUE,
};

enum aa_awb_lockavailable {
    AWB_LOCK_AVAILABLE_FALSE = 0,
    AWB_LOCK_AVAILABLE_TRUE,
};

enum aa_available_mode {
    AA_OFF = 0,
    AA_AUTO,
    /* AA_USE_SCENE_MODE,
     * AA_OFF_KEEP_STATE, */
};

struct camera2_aa_ctl {
    enum aa_ae_antibanding_mode     aeAntibandingMode;
    int32_t                         aeExpCompensation;
    enum aa_ae_lock                 aeLock;
    enum aa_aemode                  aeMode;
    uint32_t                        aeRegions[5];
    uint32_t                        aeTargetFpsRange[2];
    enum aa_ae_precapture_trigger   aePrecaptureTrigger;
    enum aa_afmode                  afMode;
    uint32_t                        afRegions[5];
    enum aa_af_trigger              afTrigger;
    enum aa_awb_lock                awbLock;
    enum aa_awbmode                 awbMode;
    uint32_t                        awbRegions[5];
    enum aa_capture_intent          captureIntent;
    enum aa_effect_mode             effectMode;
    enum aa_mode                    mode;
    enum aa_scene_mode              sceneMode;
    enum aa_videostabilization_mode videoStabilizationMode;

    /* vendor feature */
    float                   vendor_aeExpCompensationStep;
    uint32_t                vendor_afmode_option;
    enum aa_afmode_ext      vendor_afmode_ext;
    enum aa_ae_flashmode    vendor_aeflashMode;
    enum aa_isomode         vendor_isoMode;
    uint32_t                vendor_isoValue;
    int32_t                 vendor_awbValue;
    enum aa_cameraid        vendor_cameraId;
    enum aa_videomode       vendor_videoMode;
    enum aa_ae_facemode     vendor_aeFaceMode;
    enum aa_afstate         vendor_afState;
    int32_t                 vendor_exposureValue;
    uint32_t                vendor_touchAeDone;
    uint32_t                vendor_touchBvChange;
    uint32_t                vendor_captureCount;
    uint32_t                vendor_captureExposureTime;
#if 0
    float                   vendor_objectDistanceCm;
    uint32_t                vendor_reserved[9];
#else
    uint32_t                vendor_reserved[10];
#endif
};

struct camera2_aa_dm {
    enum aa_ae_antibanding_mode     aeAntibandingMode;
    int32_t                         aeExpCompensation;
    enum aa_ae_lock                 aeLock;
    enum aa_aemode                  aeMode;
    uint32_t                        aeRegions[5];
    uint32_t                        aeTargetFpsRange[2];
    enum aa_ae_precapture_trigger   aePrecaptureTrigger;
    enum ae_state                   aeState;
    enum aa_afmode                  afMode;
    uint32_t                        afRegions[5];
    enum aa_af_trigger              afTrigger;
    enum aa_afstate                 afState;
    enum aa_awb_lock                awbLock;
    enum aa_awbmode                 awbMode;
    uint32_t                        awbRegions[5];
    enum aa_capture_intent          captureIntent;
    enum awb_state                  awbState;
    enum aa_effect_mode             effectMode;
    enum aa_mode                    mode;
    enum aa_scene_mode              sceneMode;
    enum aa_videostabilization_mode videoStabilizationMode;

    /* vendor feature */
    float                   vendor_aeExpCompensationStep;
    uint32_t                vendor_afmode_option;
    enum aa_afmode_ext      vendor_afmode_ext;
    enum aa_ae_flashmode    vendor_aeflashMode;
    enum aa_isomode         vendor_isoMode;
    uint32_t                vendor_isoValue;
    int32_t                 vendor_awbValue;
    enum aa_cameraid        vendor_cameraId;
    enum aa_videomode       vendor_videoMode;
    enum aa_ae_facemode     vendor_aeFaceMode;
    enum aa_afstate         vendor_afState;
    int32_t                 vendor_exposureValue;
    uint32_t                vendor_touchAeDone;
    uint32_t                vendor_touchBvChange;
    uint32_t                vendor_captureCount;
    uint32_t                vendor_captureExposureTime;
    float                   vendor_objectDistanceCm;

    //For dual
    uint32_t                vendor_wideTeleConvEv;
    uint32_t                vendor_teleSync;
    uint32_t                vendor_fusionCaptureAeInfo;
    uint32_t                vendor_fusionCaptureAfInfo;
    uint32_t                vendor_reserved[9];
};

struct camera2_aa_sm {
    uint8_t         aeAvailableAntibandingModes[CAMERA2_MAX_AVAILABLE_MODE];
    uint8_t         aeAvailableModes[CAMERA2_MAX_AVAILABLE_MODE];
    uint32_t        aeAvailableTargetFpsRanges[CAMERA2_MAX_AVAILABLE_MODE][2];
    int32_t         aeCompensationRange[2];
    struct rational aeCompensationStep;
    uint8_t         afAvailableModes[CAMERA2_MAX_AVAILABLE_MODE];
    uint8_t         availableEffects[CAMERA2_MAX_AVAILABLE_MODE];
    uint8_t         availableSceneModes[CAMERA2_MAX_AVAILABLE_MODE];
    uint8_t         availableVideoStabilizationModes[4];
    uint8_t         awbAvailableModes[CAMERA2_MAX_AVAILABLE_MODE];
    uint32_t        maxRegions[3];
    uint32_t        maxRegionsAe;
    uint32_t        maxRegionsAwb;
    uint32_t        maxRegionsAf;
    uint8_t         sceneModeOverrides[CAMERA2_MAX_AVAILABLE_MODE][3];
    uint32_t        availableHighSpeedVideoConfigurations[CAMERA2_MAX_AVAILABLE_MODE][5];
    enum aa_ae_lockavailable        aeLockAvailable;
    enum aa_awb_lockavailable       awbLockAvailable;
    enum aa_available_mode          availableModes;

    /* vendor feature */
    uint32_t        vendor_isoRange[2];
};

/* android.led */

enum led_transmit {
    TRANSMIT_OFF = 0,
    TRANSMIT_ON,
};

struct camera2_led_ctl {
    enum led_transmit       transmit;
};

struct camera2_led_dm {
    enum led_transmit       transmit;
};

struct camera2_led_sm {
    uint8_t     availableLeds[CAMERA2_MAX_AVAILABLE_MODE];
};

/* android.info */

enum info_supported_hardware_level {
    INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED = 0,
    INFO_SUPPORTED_HARDWARE_LEVEL_FULL,
    INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY,
};

struct camera2_info_sm {
    enum info_supported_hardware_level  supportedHardwareLevel;
};

/* android.blacklevel */

enum blacklevel_lock {
    BLACK_LEVEL_LOCK_OFF = 0,
    BLACK_LEVEL_LOCK_ON,
};

struct camera2_blacklevel_ctl {
    enum blacklevel_lock        lock;
};

struct camera2_blacklevel_dm {
    enum blacklevel_lock        lock;
};

/* android.reprocess */

struct camera2_reprocess_ctl {
    float       effectiveExposureFactor;
};

struct camera2_reprocess_dm {
    float       effectiveExposureFactor;
};

struct camera2_reprocess_sm {
    uint32_t    maxCaptureStall;
};

/* android.depth */

enum depth_available_depth_stream_config {
    DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT,
    DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_INPUT,
};

enum depth_depth_is_exclusive {
    DEPTH_DEPTH_IS_EXCLUSIVE_FALSE,
    DEPTH_DEPTH_IS_EXCLUSIVE_TRUE,
};

struct camera2_depth_sm {
    uint32_t                                    maxDepthSamples;
    enum depth_available_depth_stream_config    availableDepthStreamConfigurations[CAMERA2_MAX_AVAILABLE_MODE][4];
    uint64_t                                    availableDepthMinFrameDurations[CAMERA2_MAX_AVAILABLE_MODE][4];
    uint64_t                                    availableDepthStallDurations[CAMERA2_MAX_AVAILABLE_MODE][4];
    enum depth_depth_is_exclusive               depthIsExclusive;
};

/* android.sync */

enum sync_frame_number {
    SYNC_FRAME_NUMBER_CONVERGING    = -1,
    SYNC_FRAME_NUMBER_UNKNOWN       = -2,
};

enum sync_max_latency {
    SYNC_MAX_LATENCY_PER_FRAME_CONTROL  = 0,
    SYNC_MAX_LATENCY_UNKNOWN            = -1,
};

struct camera2_sync_ctl {
    int64_t         frameNumber;
};

struct camera2_sync_dm {
    int32_t         maxLatency;
};

struct camera2_lens_usm {
    uint32_t    focusDistanceFrameDelay;
};

struct camera2_sensor_usm {
    uint32_t    exposureTimeFrameDelay;
    uint32_t    frameDurationFrameDelay;
    uint32_t    sensitivityFrameDelay;
};

struct camera2_flash_usm {
    uint32_t    flashModeFrameDelay;
    uint32_t    firingPowerFrameDelay;
    uint64_t    firingTimeFrameDelay;
};

struct camera2_ctl {
    struct camera2_colorcorrection_ctl  color;
    struct camera2_aa_ctl               aa;
    struct camera2_demosaic_ctl         demosaic;
    struct camera2_edge_ctl             edge;
    struct camera2_flash_ctl            flash;
    struct camera2_hotpixel_ctl         hotpixel;
    struct camera2_jpeg_ctl             jpeg;
    struct camera2_lens_ctl             lens;
    struct camera2_noisereduction_ctl   noise;
    struct camera2_request_ctl          request;
    struct camera2_scaler_ctl           scaler;
    struct camera2_sensor_ctl           sensor;
    struct camera2_shading_ctl          shading;
    struct camera2_stats_ctl            stats;
    struct camera2_tonemap_ctl          tonemap;
    struct camera2_led_ctl              led;
    struct camera2_blacklevel_ctl       blacklevel;
    struct camera2_sync_ctl             sync;
    struct camera2_reprocess_ctl        reprocess;

    /* vendor feature */
    struct camera2_entry_ctl            vendor_entry;
};

struct camera2_dm {
    struct camera2_colorcorrection_dm   color;
    struct camera2_aa_dm                aa;
    struct camera2_demosaic_dm          demosaic;
    struct camera2_edge_dm              edge;
    struct camera2_flash_dm             flash;
    struct camera2_hotpixel_dm          hotpixel;
    struct camera2_jpeg_dm              jpeg;
    struct camera2_lens_dm              lens;
    struct camera2_noisereduction_dm    noise;
    struct camera2_request_dm           request;
    struct camera2_scaler_dm            scaler;
    struct camera2_sensor_dm            sensor;
    struct camera2_shading_dm           shading;
    struct camera2_stats_dm             stats;
    struct camera2_tonemap_dm           tonemap;
    struct camera2_led_dm               led;
    struct camera2_blacklevel_dm        blacklevel;
    struct camera2_sync_dm              sync;
    struct camera2_reprocess_dm         reprocess;

    /* vendor feature */
    struct camera2_entry_dm             vendor_entry;
};

struct camera2_sm {
    struct camera2_colorcorrection_sm   color;
    struct camera2_aa_sm                aa;
    struct camera2_edge_sm              edge;
    struct camera2_flash_sm             flash;
    struct camera2_hotpixel_sm          hotpixel;
    struct camera2_jpeg_sm              jpeg;
    struct camera2_lens_sm              lens;
    struct camera2_noisereduction_sm    noise;
    struct camera2_request_sm           request;
    struct camera2_scaler_sm            scaler;
    struct camera2_sensor_sm            sensor;
    struct camera2_shading_sm           shading;
    struct camera2_stats_sm             stats;
    struct camera2_tonemap_sm           tonemap;
    struct camera2_led_sm               led;
    struct camera2_info_sm              info;
    struct camera2_reprocess_sm         reprocess;
    struct camera2_depth_sm             depth;

    /** User-defined(ispfw specific) static metadata. */
    struct camera2_lens_usm             lensUd;
    struct camera2_sensor_usm           sensorUd;
    struct camera2_flash_usm            flashUd;
};

struct camera2_obj_af_info {
    int32_t focusState;
    int32_t focusROILeft;
    int32_t focusROIRight;
    int32_t focusROITop;
    int32_t focusROIBottom;
    int32_t focusWeight;
    int32_t w_movement;
    int32_t h_movement;
    int32_t w_velocity;
    int32_t h_velocity;
};

struct camera2_hrm_sensor_info {
    uint32_t       visible_data;
    uint32_t       ir_data;
    uint32_t       flicker_data; // 0: No flicker detect, 100: 50Hz, 120: 60Hz
    int32_t        status;
};

struct camera2_illuminaion_sensor_info {
    uint16_t visible_cdata;
    uint16_t visible_rdata;
    uint16_t visible_gdata;
    uint16_t visible_bdata;
    uint16_t visible_gain;
    uint16_t visible_exptime;
    uint16_t ir_north;
    uint16_t ir_south;
    uint16_t ir_east;
    uint16_t ir_west;
    uint16_t ir_gain;
    uint16_t ir_exptime;
};

struct camera2_gyro_sensor_info {
    float x;
    float y;
    float z;
};

struct camera2_accelerometer_sensor_info {
    float x;
    float y;
    float z;
};

struct camera2_proximity_sensor_info {
    int32_t flicker_data;
};

struct camera2_temperature_info {
    int32_t usb_thermal;
};

struct camera2_aa_uctl {
    struct camera2_obj_af_info              af_data;
    struct camera2_hrm_sensor_info          hrmInfo;
    struct camera2_illuminaion_sensor_info  illuminationInfo;
    struct camera2_gyro_sensor_info         gyroInfo;
    struct camera2_accelerometer_sensor_info    accInfo;
    struct camera2_proximity_sensor_info    proximityInfo;
    struct camera2_temperature_info         temperatureInfo;
};

struct camera2_aa_udm {
    struct camera2_obj_af_info              af_data;
    struct camera2_hrm_sensor_info          hrmInfo;
    struct camera2_illuminaion_sensor_info  illuminationInfo;
    struct camera2_gyro_sensor_info         gyroInfo;
    struct camera2_accelerometer_sensor_info    accInfo;
    struct camera2_proximity_sensor_info    proximityInfo;
    struct camera2_temperature_info         temperatureInfo;
};

struct camera2_lens_uctl {
    uint32_t        pos;
    uint32_t        posSize;
    uint32_t        direction;
    uint32_t        slewRate;
    uint32_t        oisCoefVal;
};

struct camera2_lens_udm {
    uint32_t        pos;
    uint32_t        posSize;
    uint32_t        direction;
    uint32_t        slewRate;
    uint32_t        oisCoefVal;
};

struct camera2_ae_udm {
    uint32_t    vsLength;
    uint32_t    vendorSpecific[CAMERA2_MAX_VENDER_LENGTH];
    uint32_t    vs2Length;
    uint32_t    vendorSpecific2[CAMERA2_MAX_UDM_VENDOR2_LENGTH];
};

struct camera2_awb_udm {
    uint32_t    vsLength;
    uint32_t    vendorSpecific[CAMERA2_MAX_VENDER_LENGTH];
    uint32_t    vs2Length;
    uint32_t    vendorSpecific2[CAMERA2_MAX_UDM_VENDOR2_LENGTH];
};

struct camera2_af_uctl {
    uint32_t        vs2Length;
    uint32_t        vendorSpecific2[CAMERA2_MAX_UCTL_VENDOR2_LENGTH];
};

struct camera2_af_udm {
    uint32_t        vsLength;
    uint32_t        vendorSpecific[CAMERA2_MAX_VENDER_LENGTH];
    int32_t         lensPositionInfinity;
    int32_t         lensPositionMacro;
    int32_t         lensPositionCurrent;
    uint32_t        vs2Length;
    uint32_t        vendorSpecific2[CAMERA2_MAX_UDM_VENDOR2_LENGTH];
};

struct camera2_as_udm {
    uint32_t    vsLength;
    uint32_t    vendorSpecific[CAMERA2_MAX_VENDER_LENGTH];
};

struct camera2_ipc_udm {
    uint32_t    vsLength;
    uint32_t    vendorSpecific[CAMERA2_MAX_IPC_VENDER_LENGTH];
};

/** \brief
        User-defined metadata for rta debug info.
 */
struct camera2_rta_udm {
    uint32_t vsLength;
    uint32_t vendorSpecific[90];
};

struct camera2_drc_udm {
    uint16_t globalToneMap[32];
};

struct camera2_rgbGamma_udm {
    uint16_t xTable[32];
    uint16_t yTable[3 * 32]; // R [0~31], G [32~63], B [64~95]
};

struct camera2_ccm_udm {
    int16_t ccmVectors9[9 * 3];
};

struct camera2_internal_udm {
    uint32_t ProcessedFrameInfo;
    uint32_t vendorSpecific[4];
    /*
       vendorSpecific2[0] : 3aaIspSircSdk
       vendorSpedific2[1] : IspTpuSirdSdk
       vendorSpecific2[100] : exposure
       vendorSpecific2[101] : iso(gain)
       vendorSpecific2[102] : Bv
       vendorSpecific2[103] : Tv
     */
};

struct camera2_sensor_uctl {
    uint64_t    dynamicFrameDuration;
    uint32_t    analogGain;
    uint32_t    digitalGain;
    uint64_t    longExposureTime;
    uint64_t    shortExposureTime;
    uint32_t    longAnalogGain;
    uint32_t    shortAnalogGain;
    uint32_t    longDigitalGain;
    uint32_t    shortDigitalGain;
    uint64_t    exposureTime;
    uint32_t    frameDuration;
    uint32_t    sensitivity;
    uint32_t    CtrlFrameDuration;
};

struct camera2_sensor_udm {
    uint64_t    dynamicFrameDuration;
    uint32_t    analogGain;
    uint32_t    digitalGain;
    uint64_t    longExposureTime;
    uint64_t    shortExposureTime;
    uint32_t    longAnalogGain;
    uint32_t    shortAnalogGain;
    uint32_t    longDigitalGain;
    uint32_t    shortDigitalGain;
    uint64_t    timeStampBoot;
    uint32_t    multiLuminances[9];
};

enum mcsc_port {
    MCSC_PORT_NONE = -1,
    MCSC_PORT_0,
    MCSC_PORT_1,
    MCSC_PORT_2,
    MCSC_PORT_3,
    MCSC_PORT_4,
    MCSC_PORT_MAX,
};

enum mcsc_interface_type {
    INTERFACE_TYPE_YSUM = 0,
    INTERFACE_TYPE_DS,
    INTERFACE_TYPE_MAX,
};

struct ysum_data {
    uint32_t lower_ysum_value;
    uint32_t higher_ysum_value;
};

struct camera2_scaler_uctl {
    uint32_t sourceAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t txcTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t txpTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
	uint32_t mrgTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
	uint32_t efdTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t ixcTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t ixpTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint64_t mexcTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t sccTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t scpTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t sc0TargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t sc1TargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t sc2TargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t sc3TargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t sc4TargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t sc5TargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t dxcTargetAddress[EXYNOS_CAMERA_BUFFER_MAX_PLANES];
    uint32_t orientation;
    enum mcsc_port mcsc_sub_blk_port[INTERFACE_TYPE_MAX];
};

struct camera2_scaler_udm {
    struct ysum_data ysumdata;
};

struct camera2_flash_uctl {
    uint32_t        firingPower;
    uint64_t        firingTime;
    enum flash_mode flashMode;
};

struct camera2_flash_udm {
    uint32_t        firingPower;
    uint64_t        firingTime;
    enum flash_mode flashMode;
};

enum camera2_wdr_mode {
    CAMERA_WDR_OFF = 1,
    CAMERA_WDR_ON = 2,
    CAMERA_WDR_AUTO = 3,
    CAMERA_WDR_AUTO_LIKE = 4,
    TOTALCOUNT_CAMERA_WDR,
    CAMERA_WDR_UNKNOWN,
 };

enum camera2_paf_mode {
    CAMERA_PAF_OFF = 1,
    CAMERA_PAF_ON,
 };

enum camera2_disparity_mode {
    CAMERA_DISPARITY_OFF = 1,
    CAMERA_DISPARITY_SAD,
    CAMERA_DISPARITY_CENSUS_MEAN,
    CAMERA_DISPARITY_CENSUS_CENTER    // Disparity mode default
 };

enum camera_flash_mode {
   CAMERA_FLASH_MODE_OFF = 0,
   CAMERA_FLASH_MODE_AUTO,
   CAMERA_FLASH_MODE_ON,
   CAMERA_FLASH_MODE_RED_EYE,
   CAMERA_FLASH_MODE_TORCH
};

enum camera_op_mode {
    CAMERA_OP_MODE_GED = 0,   // default
    CAMERA_OP_MODE_TW,
    CAMERA_OP_MODE_HAL3_GED,
    CAMERA_OP_MODE_HAL3_TW,
    CAMERA_OP_MODE_FAC,
    CAMERA_OP_MODE_HAL3_FAC,
};

struct camera2_is_mode_uctl {
    enum camera2_wdr_mode     wdr_mode;
    enum camera2_paf_mode     paf_mode;
    enum camera2_disparity_mode   disparity_mode;
};

struct camera2_pdaf_single_result {
    uint16_t    mode;
    uint16_t    goalPos;
    uint16_t    reliability;
    uint16_t    currentPos;
};

struct camera2_pdaf_multi_result {
    uint16_t    mode;
    uint16_t    goalPos;
    uint16_t    reliability;
    uint16_t    focused;
};

struct camera2_pdaf_udm {
    uint16_t    numCol;
    uint16_t    numRow;
    struct camera2_pdaf_multi_result    multiResult[CAMERA2_MAX_PDAF_MULTIROI_ROW][CAMERA2_MAX_PDAF_MULTIROI_COLUMN];
    struct camera2_pdaf_single_result   singleResult;
    uint16_t    lensPosResolution;
};

struct camera2_is_mode_udm {
    enum camera2_wdr_mode     wdr_mode;
    enum camera2_paf_mode     paf_mode;
    enum camera2_disparity_mode     disparity_mode;
};

struct camera2_fd_uctl {
    enum facedetect_mode faceDetectMode;
    uint32_t  faceIds[CAMERA2_MAX_FACES];
    uint32_t  faceLandmarks[CAMERA2_MAX_FACES][6];
    uint32_t  faceRectangles[CAMERA2_MAX_FACES][4];
    uint8_t   faceScores[CAMERA2_MAX_FACES];
    uint32_t  faces[CAMERA2_MAX_FACES];
    uint32_t  vendorSpecific[CAMERA2_MAX_UCTL_VENDER_LENGTH];
/* ---------------------------------------------------------
        vendorSpecific[0] = fdMapAddress[0];
        vendorSpecific[1] = fdMapAddress[1];
        vendorSpecific[2] = fdMapAddress[2];
        vendorSpecific[4] = fdMapAddress[4];
        vendorSpecific[5] = fdMapAddress[5];
        vendorSpecific[6] = fdMapAddress[6];
        vendorSpecific[7] = fdMapAddress[7];
        vendorSpecific[8] = fdYMapAddress;
        vendorSpecific[9] = fdCoefK;
        vendorSpecific[10] = fdUp;
        vendorSpecific[11] = fdShift;
        vendorSpecific[12] ~ vendorSpecific[31] : reserved
    ---------------------------------------------------------
*/
};

struct camera2_fd_udm {
    uint32_t    vendorSpecific[CAMERA2_MAX_UCTL_VENDER_LENGTH];
/* ---------------------------------------------------------
        vendorSpecific[0] = fdSat;
        vendorSpecific[1] ~ vendorSpecific[31] : reserved
    ---------------------------------------------------------
*/
};

#define CAMERA2_MAX_ME_MV 200

struct camera2_me_udm {
    uint32_t motion_vector[CAMERA2_MAX_ME_MV];   /* for (n-2)th frame */
    uint32_t current_patch[CAMERA2_MAX_ME_MV];   /* for (n-1)th frame */
};

struct camera2_ni_udm {
    uint32_t currentFrameNoiseIndex; /* Noise Index for N */
    uint32_t nextFrameNoiseIndex; /* Noise Index for N+1 */
    uint32_t nextNextFrameNoiseIndex; /* Noise Index for N+2 */
};

enum camera2_drc_mode {
    DRC_OFF = 1,
    DRC_ON,
};

struct camera2_drc_uctl {
    enum camera2_drc_mode uDrcEn;
};

enum camera2_dcp_process_mode {
	DCP_PROCESS_OFF = 0,
	DCP_PROCESS_ON,
};

struct camera2_area {
	int32_t x;		/* !< x pos */
	int32_t y;	/* !< y pos */
	int32_t w;		/* !< width */
	int32_t h;		/* !< height */
};

struct camera2_dcp_homo_matrix {
	int32_t dx[7][9];	/* 7 rows x 9 columns, range precision */
	int32_t dy[7][9];
};

struct camera2_dcp_rgb_gamma_lut {
	enum camera2_dcp_process_mode mode;
	uint32_t x_LUT[32];
	uint32_t r_LUT[32];
	uint32_t g_LUT[32];
	uint32_t b_LUT[32];
};

struct camera2_dcp_uctl
{
    struct camera2_dcp_homo_matrix wide_gdc_grid_value;
    struct camera2_dcp_homo_matrix tele_gdc_grid_value;
    struct camera2_area wide_gdc_upscale_size;
    struct camera2_area tele_gdc_upscale_size;
    struct camera2_dcp_rgb_gamma_lut wide_gamma_LUT;
    struct camera2_dcp_rgb_gamma_lut tele_gamma_LUT;
};

enum camera_vt_mode {
    VT_MODE_OFF = 0,
    VT_MODE_1,
    VT_MODE_2,
    VT_MODE_3,
    VT_MODE_4,
    VT_MODE_5,   /* vga ~ hd 20Fps */
};

enum camera2_is_hw_lls_mode {
    CAMERA_HW_LLS_OFF = 0,
    CAMERA_HW_LLS_ON,
};

enum camera2_is_hw_lls_progress {
    CAMERA_HW_LLS_FIRST_FRAME = 0,
    CAMERA_HW_LLS_SECOND_FRAME,
    CAMERA_HW_LLS_INTERMEDIATE_FRAME,
    CAMERA_HW_LLS_LAST_FRAME,
};

struct camera2_is_hw_lls_uctl {
    enum camera2_is_hw_lls_mode    hwLlsMode;
    enum camera2_is_hw_lls_progress    hwLlsProgress;
};

struct camera2_dng_udm {
    uint32_t wbgain[4];
    uint32_t pedestal[3]; /* [0]:R, [1]:G, [2]:B */
    uint32_t gammaXpnt[32];
    uint32_t gammaYpnt[32];
};

#ifdef SUPPORT_GMV
struct camera2_gmv_uctl
{
    int16_t gmX;
    int16_t gmY;
};
#endif

struct camera2_uctl {
    uint32_t                        uUpdateBitMap;
    uint32_t                        uFrameNumber;
    struct camera2_aa_uctl          aaUd;
    struct camera2_af_uctl          af;
    struct camera2_lens_uctl        lensUd;
    struct camera2_sensor_uctl      sensorUd;
    struct camera2_flash_uctl       flashUd;
    struct camera2_scaler_uctl      scalerUd;
    struct camera2_is_mode_uctl     isModeUd;
    struct camera2_fd_uctl          fdUd;
    struct camera2_drc_uctl         drcUd;
    struct camera2_dcp_uctl         dcpUd;
    enum camera_vt_mode             vtMode;
    float                           zoomRatio;
    enum camera_flash_mode          flashMode;
    enum camera_op_mode             opMode;
    struct camera2_is_hw_lls_uctl   hwlls_mode;
    uint32_t                        statsRoi[4];
    enum aa_cameraMode              cameraMode;
    enum aa_sensorPlace             masterCamera;
#ifdef SUPPORT_GMV
    struct camera2_gmv_uctl         gmvUd;
    uint32_t                        reserved[8];
#else
    uint32_t                        reserved[9];
#endif
};

struct camera2_udm {
    struct camera2_aa_udm        aa;
    struct camera2_lens_udm      lens;
    struct camera2_sensor_udm	 sensor;
    struct camera2_flash_udm	 flash;
    struct camera2_ae_udm        ae;
    struct camera2_awb_udm       awb;
    struct camera2_af_udm        af;
    struct camera2_as_udm        as;
    struct camera2_ipc_udm       ipc;
    struct camera2_rta_udm       rta;
    struct camera2_internal_udm  internal;
    struct camera2_scaler_udm    scaler;
    struct camera2_is_mode_udm   isMode;
    struct camera2_pdaf_udm      pdaf;
    struct camera2_fd_udm        fd;
    struct camera2_me_udm        me;
    enum camera_vt_mode          vtMode;
    float                        zoomRatio;
    enum camera_flash_mode       flashMode;
    enum camera_op_mode          opMode;
    struct camera2_ni_udm        ni;
    struct camera2_drc_udm      drc;
    struct camera2_rgbGamma_udm rgbGamma;
    struct camera2_ccm_udm      ccm;
    enum aa_cameraMode          cameraMode;
    enum aa_sensorPlace         masterCamera;
    enum aa_fallback            fallback;
    uint32_t                     frame_id;
    uint32_t                     reserved[6];
};

struct camera2_shot {
    struct camera2_ctl    ctl;
    struct camera2_dm     dm;
    struct camera2_uctl   uctl;
    struct camera2_udm    udm;
    uint32_t              magicNumber;
};

struct camera2_node_input {
    uint32_t    cropRegion[4];
};

struct camera2_node_output {
    uint32_t    cropRegion[4];
};

struct camera2_node {
    uint32_t    vid;
    uint32_t    request;
    struct camera2_node_input    input;
    struct camera2_node_output   output;
/*
pixelformat : per-frame format
byteperline : stride for DMA
 */
    uint32_t    pixelformat;
};

struct camera2_node_group {
    struct camera2_node    leader;
    struct camera2_node    capture[CAPTURE_NODE_MAX];
};

struct hfd_meta {
    uint32_t    hfd_enable;
    uint32_t    faceIds[CAMERA2_MAX_FACES];
    uint32_t    faceLandmarks[CAMERA2_MAX_FACES][6];
    uint32_t    faceRectangles[CAMERA2_MAX_FACES][4];
    uint32_t    score[CAMERA2_MAX_FACES];
    uint32_t    is_rot[CAMERA2_MAX_FACES];
    uint32_t    is_yaw[CAMERA2_MAX_FACES];
    uint32_t    rot[CAMERA2_MAX_FACES];
    uint32_t    mirror_x[CAMERA2_MAX_FACES];
    uint32_t    hw_rot_mirror[CAMERA2_MAX_FACES];
};

struct camera2_tuning_info {
    uint32_t    tune_id;
    uint64_t    json_addr;
    uint32_t    json_size;
    uint32_t    reserved[8];
};

struct camera2_stream {
    uint32_t        address;
    uint32_t        fcount;
    uint32_t        rcount;
    uint32_t        findex;
    uint32_t        fvalid;
    uint32_t        input_crop_region[4];
    uint32_t        output_crop_region[4];
};

struct camera2_shot_ext {
    struct camera2_stream     reserved_stream;
    uint32_t                  setfile;
    struct camera2_node_group node_group;
    uint32_t                  drc_bypass;
    uint32_t                  dis_bypass;
    uint32_t                  dnr_bypass;
    uint32_t                  fd_bypass;
    uint32_t                  free_cnt;
    uint32_t                  request_cnt;
    uint32_t                  process_cnt;
    uint32_t                  complete_cnt;
    uint32_t                  invalid;
    struct hfd_meta           hfd;
    struct camera2_tuning_info tuning_info;
    uint32_t                  reserved[12];
    uint32_t                  timeZone[10][2];
    struct camera2_shot       shot;
};

#define CAM_LENS_CMD        (0x1 << 0x0)
#define CAM_SENSOR_CMD      (0x1 << 0x1)
#define CAM_FLASH_CMD       (0x1 << 0x2)

enum camera_pixel_size {
    CAMERA_PIXEL_SIZE_8BIT = 0,
    CAMERA_PIXEL_SIZE_10BIT,
    CAMERA_PIXEL_SIZE_PACKED_10BIT,
    CAMERA_PIXEL_SIZE_8_2BIT,
};

/* typedefs below are for firmware sources */

typedef enum metadata_mode metadata_mode_t;
typedef struct camera2_request_ctl camera2_request_ctl_t;
typedef struct camera2_request_dm camera2_request_dm_t;
typedef enum optical_stabilization_mode optical_stabilization_mode_t;
typedef enum lens_facing lens_facing_t;
typedef struct camera2_entry_ctl camera2_entry_ctl_t;
typedef struct camera2_entry_dm camera2_entry_dm_t;
typedef struct camera2_lens_ctl camera2_lens_ctl_t;
typedef struct camera2_lens_dm camera2_lens_dm_t;
typedef struct camera2_lens_sm camera2_lens_sm_t;
typedef enum sensor_colorfilterarrangement sensor_colorfilterarrangement_t;
typedef enum sensor_lensshading_applied sensor_lensshading_applied_t;
typedef enum sensor_ref_illuminant sensor_ref_illuminant_t;
typedef struct camera2_sensor_ctl camera2_sensor_ctl_t;
typedef struct camera2_sensor_dm camera2_sensor_dm_t;
typedef struct camera2_sensor_sm camera2_sensor_sm_t;
typedef enum flash_mode flash_mode_t;
typedef struct camera2_flash_ctl camera2_flash_ctl_t;
typedef struct camera2_flash_dm camera2_flash_dm_t;
typedef struct camera2_flash_sm camera2_flash_sm_t;
typedef enum processing_mode processing_mode_t;
typedef struct camera2_hotpixel_ctl camera2_hotpixel_ctl_t;
typedef struct camera2_hotpixel_dm camera2_hotpixel_dm_t;
typedef struct camera2_hotpixel_sm camera2_hotpixel_sm_t;

typedef struct camera2_demosaic_ctl camera2_demosaic_ctl_t;
typedef struct camera2_demosaic_dm camera2_demosaic_dm_t;
typedef struct camera2_noisereduction_ctl camera2_noisereduction_ctl_t;
typedef struct camera2_noisereduction_dm camera2_noisereduction_dm_t;
typedef struct camera2_noisereduction_sm camera2_noisereduction_sm_t;
typedef struct camera2_shading_ctl camera2_shading_ctl_t;
typedef struct camera2_shading_dm camera2_shading_dm_t;
typedef enum colorcorrection_mode colorcorrection_mode_t;
typedef struct camera2_colorcorrection_ctl camera2_colorcorrection_ctl_t;
typedef struct camera2_colorcorrection_dm camera2_colorcorrection_dm_t;
typedef struct camera2_colorcorrection_sm camera2_colorcorrection_sm_t;
typedef enum tonemap_mode tonemap_mode_t;
typedef enum tonemap_presetCurve tonemap_presetCurve_t;
typedef struct camera2_tonemap_ctl camera2_tonemap_ctl_t;
typedef struct camera2_tonemap_dm camera2_tonemap_dm_t;
typedef struct camera2_tonemap_sm camera2_tonemap_sm_t;

typedef struct camera2_edge_ctl camera2_edge_ctl_t;
typedef struct camera2_edge_dm camera2_edge_dm_t;
typedef struct camera2_edge_sm camera2_edge_sm_t;
typedef struct camera2_scaler_ctl camera2_scaler_ctl_t;
typedef struct camera2_scaler_dm camera2_scaler_dm_t;
typedef struct camera2_jpeg_ctl camera2_jpeg_ctl_t;
typedef struct camera2_jpeg_dm camera2_jpeg_dm_t;
typedef struct camera2_jpeg_sm camera2_jpeg_sm_t;
typedef enum facedetect_mode facedetect_mode_t;
typedef enum stats_mode stats_mode_t;
typedef struct camera2_stats_ctl camera2_stats_ctl_t;
typedef struct camera2_stats_dm camera2_stats_dm_t;
typedef struct camera2_stats_sm camera2_stats_sm_t;
typedef enum aa_capture_intent aa_capture_intent_t;
typedef enum aa_mode aa_mode_t;
typedef enum aa_scene_mode aa_scene_mode_t;
typedef enum aa_effect_mode aa_effect_mode_t;
typedef enum aa_aemode aa_aemode_t;
typedef enum aa_ae_antibanding_mode aa_ae_antibanding_mode_t;
typedef enum aa_awbmode aa_awbmode_t;
typedef enum aa_afmode aa_afmode_t;
typedef enum aa_afstate aa_afstate_t;
typedef enum aa_ae_lockavailable aa_ae_lockavailable_t;
typedef enum aa_awb_lockavailable aa_awb_lockavailable_t;
typedef enum aa_available_mode aa_available_mode_t;
typedef struct camera2_aa_ctl camera2_aa_ctl_t;
typedef struct camera2_aa_dm camera2_aa_dm_t;
typedef struct camera2_aa_sm camera2_aa_sm_t;
typedef struct camera2_lens_usm camera2_lens_usm_t;
typedef struct camera2_sensor_usm camera2_sensor_usm_t;
typedef struct camera2_flash_usm camera2_flash_usm_t;
typedef struct camera2_ctl camera2_ctl_t;
typedef struct camera2_uctl camera2_uctl_t;
typedef struct camera2_dm camera2_dm_t;
typedef struct camera2_sm camera2_sm_t;

typedef struct camera2_reprocess_ctl camera2_reprocess_ctl_t;
typedef struct camera2_reprocess_dm camera2_reprocess_dm_t;
typedef struct camera2_reprocess_sm camera2_reprocess_sm_t;
typedef enum depth_available_depth_stream_config depth_available_depth_stream_config_t;
typedef enum depth_depth_is_exclusive depth_depth_is_exclusive_t;
typedef struct camera2_depth_sm camera2_depth_ctl_t;

typedef struct camera2_scaler_sm camera2_scaler_sm_t;
typedef struct camera2_scaler_uctl camera2_scaler_uctl_t;

typedef struct camera2_fd_uctl camera2_fd_uctl_t;
typedef struct camera2_fd_udm camera2_fd_udm_t;

typedef struct camera2_sensor_uctl camera2_sensor_uctl_t;

typedef struct camera2_aa_uctl camera2_aa_uctl_t;
typedef struct camera2_aa_udm camera2_aa_udm_t;

typedef struct camera2_lens_uctl camera2_lens_uctl_t;
typedef struct camera2_lens_udm camera2_lens_udm_t;

typedef struct camera2_ae_udm camera2_ae_udm_t;
typedef struct camera2_awb_udm camera2_awb_udm_t;
typedef struct camera2_af_udm camera2_af_udm_t;
typedef struct camera2_as_udm camera2_as_udm_t;
typedef struct camera2_ipc_udm camera2_ipc_udm_t;
typedef struct camera2_udm camera2_udm_t;

typedef struct camera2_rta_udm camera2_rta_udm_t;
typedef struct camera2_internal_udm camera2_internal_udm_t;

typedef struct camera2_flash_uctl camera2_flash_uctl_t;

typedef struct camera2_is_mode_udm camera2_is_mode_udm_t;

typedef struct camera2_shot camera2_shot_t;

typedef struct camera2_ni_udm camera2_ni_udm_t;
#endif