| /* 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 |