From 17e2ae7fd9cb072c84d883839b7dea86ab263802 Mon Sep 17 00:00:00 2001 From: Matthew Date: Fri, 11 Apr 2025 23:16:13 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BD=BF=E7=94=A8mtk=E5=86=85=E7=BD=AE?= =?UTF-8?q?=E6=89=A9=E5=B1=95MFNR=E7=AE=97=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/src/main/cpp/camera2/mtk_metadata_tag.h | 1741 +++++++++++++++++ .../cpp/camera2/mtk_platform_metadata_tag.h | 724 +++++++ app/src/main/cpp/camera2/ndkcamera.cpp | 14 + 3 files changed, 2479 insertions(+) create mode 100644 app/src/main/cpp/camera2/mtk_metadata_tag.h create mode 100644 app/src/main/cpp/camera2/mtk_platform_metadata_tag.h diff --git a/app/src/main/cpp/camera2/mtk_metadata_tag.h b/app/src/main/cpp/camera2/mtk_metadata_tag.h new file mode 100644 index 00000000..160430c5 --- /dev/null +++ b/app/src/main/cpp/camera2/mtk_metadata_tag.h @@ -0,0 +1,1741 @@ +/* Copyright Statement: + * + * This software/firmware and related documentation ("MediaTek Software") are + * protected under relevant copyright laws. The information contained herein is + * confidential and proprietary to MediaTek Inc. and/or its licensors. Without + * the prior written permission of MediaTek inc. and/or its licensors, any + * reproduction, modification, use or disclosure of MediaTek Software, and + * information contained herein, in whole or in part, shall be strictly + * prohibited. + * + * MediaTek Inc. (C) 2010. All rights reserved. + * + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER + * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL + * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH + * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, + * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES + * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. + * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO + * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK + * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE + * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S + * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE + * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE + * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE + * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. + * + * The following software/firmware and/or related documentation ("MediaTek + * Software") have been modified by MediaTek Inc. All revisions are subject to + * any receiver's applicable license agreements with MediaTek Inc. + */ + + +#ifndef _MTK_HARDWARE_MTKCAM_INCLUDE_MTKCAM_UTILS_METADATA_CLIENT_MTK_METADATA_TAG_H_ +#define _MTK_HARDWARE_MTKCAM_INCLUDE_MTKCAM_UTILS_METADATA_CLIENT_MTK_METADATA_TAG_H_ + +typedef enum mtk_camera_metadata_section { + MTK_COLOR_CORRECTION, + MTK_CONTROL, + MTK_DEMOSAIC, + MTK_EDGE, + MTK_FLASH, + MTK_FLASH_INFO, + MTK_HOT_PIXEL, + MTK_JPEG, + MTK_LENS, + MTK_LENS_INFO, + MTK_NOISE_REDUCTION, + MTK_QUIRKS, + MTK_REQUEST, + MTK_SCALER, + MTK_SENSOR, + MTK_SENSOR_INFO, + MTK_SHADING, + MTK_STATISTICS, + MTK_STATISTICS_INFO, + MTK_TONEMAP, + MTK_LED, + MTK_INFO, + MTK_BLACK_LEVEL, + MTK_SYNC, + MTK_REPROCESS, + MTK_DEPTH, + MTK_LOGICAL_MULTI_CAMERA, + MTK_DISTORTION_CORRECTION, + MTK_HEIC, + MTK_HEIC_INFO, + MTK_HAL_INFO, + MTK_IOPIPE_INFO, + MTK_SECTION_COUNT, + + //vendor tag + MTK_VENDOR_TAG_SECTION = 0x8000, + MTK_FACE_FEATURE = 0, + MTK_NR_FEATURE = 1, + MTK_STEREO_FEATURE = 2, + MTK_HDR_FEATURE = 3, + MTK_MFNR_FEATURE = 4, + MTK_CSHOT_FEATURE = 5, + MTK_3A_FEATURE = 6, + MTK_EIS_FEATURE = 7, + MTK_STREAMING_FEATURE = 8, + MTK_VSDOF_FEATURE = 9, + MTK_MULTI_CAM_FEATURE = 10, + MTK_CONTROL_CAPTURE = 11, + MTK_BGSERVICE_FEATURE = 12, + MTK_CONFIGURE_SETTING = 13, + MTK_FLASH_FEATURE = 14, + MTK_SMVR_FEATURE = 15, + MTK_SINGLEHW_SETTING = 16, + MTK_ABF_FEATURE = 17, + MTK_VENDOR_SECTION_COUNT, +} mtk_camera_metadata_section_t; + +/** + * Hierarchy positions in enum space. All vendor extension tags must be + * defined with tag >= VENDOR_SECTION_START + */ + +typedef enum mtk_camera_metadata_section_start { + MTK_COLOR_CORRECTION_START = MTK_COLOR_CORRECTION << 16, + MTK_CONTROL_START = MTK_CONTROL << 16, + MTK_DEMOSAIC_START = MTK_DEMOSAIC << 16, + MTK_EDGE_START = MTK_EDGE << 16, + MTK_FLASH_START = MTK_FLASH << 16, + MTK_FLASH_INFO_START = MTK_FLASH_INFO << 16, + MTK_HOT_PIXEL_START = MTK_HOT_PIXEL << 16, + MTK_JPEG_START = MTK_JPEG << 16, + MTK_LENS_START = MTK_LENS << 16, + MTK_LENS_INFO_START = MTK_LENS_INFO << 16, + MTK_NOISE_REDUCTION_START = MTK_NOISE_REDUCTION << 16, + MTK_QUIRKS_START = MTK_QUIRKS << 16, + MTK_REQUEST_START = MTK_REQUEST << 16, + MTK_SCALER_START = MTK_SCALER << 16, + MTK_SENSOR_START = MTK_SENSOR << 16, + MTK_SENSOR_INFO_START = MTK_SENSOR_INFO << 16, + MTK_SHADING_START = MTK_SHADING << 16, + MTK_STATISTICS_START = MTK_STATISTICS << 16, + MTK_STATISTICS_INFO_START = MTK_STATISTICS_INFO << 16, + MTK_TONEMAP_START = MTK_TONEMAP << 16, + MTK_LED_START = MTK_LED << 16, + MTK_INFO_START = MTK_INFO << 16, + MTK_BLACK_LEVEL_START = MTK_BLACK_LEVEL << 16, + MTK_SYNC_START = MTK_SYNC << 16, + MTK_REPROCESS_START = MTK_REPROCESS << 16, + MTK_DEPTH_START = MTK_DEPTH << 16, + MTK_LOGICAL_MULTI_CAMERA_START = MTK_LOGICAL_MULTI_CAMERA << 16, + MTK_DISTORTION_CORRECTION_START = MTK_DISTORTION_CORRECTION << 16, + MTK_HEIC_START = MTK_HEIC << 16, + MTK_HEIC_INFO_START = MTK_HEIC_INFO << 16, + MTK_HAL_INFO_START = MTK_HAL_INFO << 16, + MTK_IOPIPE_INFO_START = MTK_IOPIPE_INFO << 16, + + MTK_VENDOR_TAG_SECTION_START = MTK_VENDOR_TAG_SECTION << 16, + MTK_FACE_FEATURE_START = (MTK_FACE_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_NR_FEATURE_START = (MTK_NR_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_STEREO_FEATURE_START = (MTK_STEREO_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_HDR_FEATURE_START = (MTK_HDR_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_MFNR_FEATURE_START = (MTK_MFNR_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_CSHOT_FEATURE_START = (MTK_CSHOT_FEATURE+ MTK_VENDOR_TAG_SECTION) << 16, + MTK_3A_FEATURE_START = (MTK_3A_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_EIS_FEATURE_START = (MTK_EIS_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_STREAMING_FEATURE_START = (MTK_STREAMING_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_VSDOF_FEATURE_START = (MTK_VSDOF_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_MULTI_CAM_FEATURE_START = (MTK_MULTI_CAM_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_CONTROL_CAPTURE_START = (MTK_CONTROL_CAPTURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_BGSERVICE_FEATURE_START = (MTK_BGSERVICE_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_CONFIGURE_SETTING_START = (MTK_CONFIGURE_SETTING + MTK_VENDOR_TAG_SECTION) << 16, + MTK_FLASH_FEATURE_START = (MTK_FLASH_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_SMVR_FEATURE_START = (MTK_SMVR_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, + MTK_SINGLEHW_SETTING_START = (MTK_SINGLEHW_SETTING + MTK_VENDOR_TAG_SECTION) << 16, + MTK_ABF_FEATURE_START = (MTK_ABF_FEATURE + MTK_VENDOR_TAG_SECTION) << 16, +} mtk_camera_metadata_section_start_t; + + + +/** + * Main enum for defining camera metadata tags. New entries must always go + * before the section _END tag to preserve existing enumeration values. In + * addition, the name and type of the tag needs to be added to + * "" + */ +typedef enum mtk_camera_metadata_tag { + MTK_COLOR_CORRECTION_MODE = MTK_COLOR_CORRECTION_START, + MTK_COLOR_CORRECTION_TRANSFORM, + MTK_COLOR_CORRECTION_GAINS, + MTK_COLOR_CORRECTION_ABERRATION_MODE, + MTK_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, + MTK_COLOR_CORRECTION_END, + + MTK_CONTROL_AE_ANTIBANDING_MODE = MTK_CONTROL_START, + MTK_CONTROL_AE_EXPOSURE_COMPENSATION, + MTK_CONTROL_AE_LOCK, + MTK_CONTROL_AE_MODE, + MTK_CONTROL_AE_REGIONS, + MTK_CONTROL_AE_TARGET_FPS_RANGE, + MTK_CONTROL_AE_PRECAPTURE_TRIGGER, + MTK_CONTROL_AF_MODE, + MTK_CONTROL_AF_REGIONS, + MTK_CONTROL_AF_TRIGGER, + MTK_CONTROL_AWB_LOCK, + MTK_CONTROL_AWB_MODE, + MTK_CONTROL_AWB_REGIONS, + MTK_CONTROL_CAPTURE_INTENT, + MTK_CONTROL_EFFECT_MODE, + MTK_CONTROL_MODE, + MTK_CONTROL_SCENE_MODE, + MTK_CONTROL_VIDEO_STABILIZATION_MODE, + MTK_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, + MTK_CONTROL_AE_AVAILABLE_MODES, + MTK_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, + MTK_CONTROL_AE_COMPENSATION_RANGE, + MTK_CONTROL_AE_COMPENSATION_STEP, + MTK_CONTROL_AF_AVAILABLE_MODES, + MTK_CONTROL_AVAILABLE_EFFECTS, + MTK_CONTROL_AVAILABLE_SCENE_MODES, + MTK_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, + MTK_CONTROL_AWB_AVAILABLE_MODES, + MTK_CONTROL_MAX_REGIONS, + MTK_CONTROL_SCENE_MODE_OVERRIDES, + MTK_CONTROL_AE_PRECAPTURE_ID, + MTK_CONTROL_AE_STATE, + MTK_CONTROL_AF_STATE, + MTK_CONTROL_AF_TRIGGER_ID, + MTK_CONTROL_AWB_STATE, + MTK_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS, + MTK_CONTROL_AE_LOCK_AVAILABLE, + MTK_CONTROL_AWB_LOCK_AVAILABLE, + MTK_CONTROL_AVAILABLE_MODES, + MTK_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE, + MTK_CONTROL_POST_RAW_SENSITIVITY_BOOST, + MTK_CONTROL_ENABLE_ZSL, + MTK_CONTROL_AF_SCENE_CHANGE, + MTK_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES, + MTK_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES, + MTK_CONTROL_EXTENDED_SCENE_MODE, + MTK_CONTROL_ZOOM_RATIO_RANGE, + MTK_CONTROL_ZOOM_RATIO, + // Camera1 + MTK_CONTROL_ISP_EDGE, + MTK_CONTROL_ISP_HUE, + MTK_CONTROL_ISP_SATURATION, + MTK_CONTROL_ISP_BRIGHTNESS, + MTK_CONTROL_ISP_CONTRAST, + MTK_CONTROL_END, + + MTK_DEMOSAIC_MODE = MTK_DEMOSAIC_START, + MTK_DEMOSAIC_END, + + MTK_EDGE_MODE = MTK_EDGE_START, + MTK_EDGE_STRENGTH, + MTK_EDGE_AVAILABLE_EDGE_MODES, + MTK_EDGE_END, + + MTK_FLASH_FIRING_POWER = MTK_FLASH_START, + MTK_FLASH_FIRING_TIME, + MTK_FLASH_MODE, + MTK_FLASH_COLOR_TEMPERATURE, + MTK_FLASH_MAX_ENERGY, + MTK_FLASH_STATE, + MTK_FLASH_END, + + MTK_FLASH_INFO_AVAILABLE = MTK_FLASH_INFO_START, + MTK_FLASH_INFO_CHARGE_DURATION, + MTK_FLASH_INFO_END, + + MTK_HOT_PIXEL_MODE = MTK_HOT_PIXEL_START, + MTK_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES, + MTK_HOT_PIXEL_END, + + MTK_JPEG_GPS_COORDINATES = MTK_JPEG_START, + MTK_JPEG_GPS_PROCESSING_METHOD, + MTK_JPEG_GPS_TIMESTAMP, + MTK_JPEG_ORIENTATION, + MTK_JPEG_QUALITY, + MTK_JPEG_THUMBNAIL_QUALITY, + MTK_JPEG_THUMBNAIL_SIZE, + MTK_JPEG_AVAILABLE_THUMBNAIL_SIZES, + MTK_JPEG_MAX_SIZE, + MTK_JPEG_SIZE, + MTK_JPEG_END, + + MTK_LENS_APERTURE = MTK_LENS_START, + MTK_LENS_FILTER_DENSITY, + MTK_LENS_FOCAL_LENGTH, + MTK_LENS_FOCUS_DISTANCE, + MTK_LENS_OPTICAL_STABILIZATION_MODE, + MTK_LENS_FACING, + MTK_SENSOR_INFO_FACING = MTK_LENS_FACING, + MTK_LENS_POSE_ROTATION, + MTK_LENS_POSE_TRANSLATION, + MTK_LENS_FOCUS_RANGE, + MTK_LENS_STATE, + MTK_LENS_INTRINSIC_CALIBRATION, + MTK_LENS_RADIAL_DISTORTION, + MTK_LENS_POSE_REFERENCE, + MTK_LENS_DISTORTION, + MTK_LENS_END, + + MTK_LENS_INFO_AVAILABLE_APERTURES = MTK_LENS_INFO_START, + MTK_LENS_INFO_AVAILABLE_FILTER_DENSITIES, + MTK_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, + MTK_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, + MTK_LENS_INFO_HYPERFOCAL_DISTANCE, + MTK_LENS_INFO_MINIMUM_FOCUS_DISTANCE, + MTK_LENS_INFO_SHADING_MAP_SIZE, + MTK_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, + MTK_LENS_INFO_END, + + MTK_NOISE_REDUCTION_MODE = MTK_NOISE_REDUCTION_START, + MTK_NOISE_REDUCTION_STRENGTH, + MTK_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, + MTK_NOISE_REDUCTION_END, + + MTK_QUIRKS_METERING_CROP_REGION = MTK_QUIRKS_START, + MTK_QUIRKS_TRIGGER_AF_WITH_AUTO, + MTK_QUIRKS_USE_ZSL_FORMAT, + MTK_QUIRKS_USE_PARTIAL_RESULT, + MTK_QUIRKS_PARTIAL_RESULT, + MTK_QUIRKS_END, + + MTK_REQUEST_FRAME_COUNT = MTK_REQUEST_START, + MTK_REQUEST_ID, + MTK_REQUEST_INPUT_STREAMS, + MTK_REQUEST_METADATA_MODE, + MTK_REQUEST_OUTPUT_STREAMS, + MTK_REQUEST_TYPE, + MTK_REQUEST_MAX_NUM_OUTPUT_STREAMS, + MTK_REQUEST_MAX_NUM_REPROCESS_STREAMS, + MTK_REQUEST_MAX_NUM_INPUT_STREAMS, + MTK_REQUEST_PIPELINE_DEPTH, + MTK_REQUEST_PIPELINE_MAX_DEPTH, + MTK_REQUEST_PARTIAL_RESULT_COUNT, + MTK_REQUEST_AVAILABLE_CAPABILITIES, + MTK_REQUEST_AVAILABLE_REQUEST_KEYS, + MTK_REQUEST_AVAILABLE_RESULT_KEYS, + MTK_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, + MTK_REQUEST_AVAILABLE_SESSION_KEYS, // int32[] | ndk_public | HIDL v3.3 + MTK_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS, + // int32[] | hidden | HIDL v3.3 + MTK_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION, + // int32[] | hidden | HIDL v3.4 + MTK_REQUEST_END, + + MTK_SCALER_CROP_APP_REGION = MTK_SCALER_START, + MTK_SCALER_AVAILABLE_FORMATS, + MTK_SCALER_AVAILABLE_JPEG_MIN_DURATIONS, + MTK_SCALER_AVAILABLE_JPEG_SIZES, + MTK_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, + MTK_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS, + MTK_SCALER_AVAILABLE_PROCESSED_SIZES, + MTK_SCALER_AVAILABLE_RAW_MIN_DURATIONS, + MTK_SCALER_AVAILABLE_RAW_SIZES, + MTK_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP, + MTK_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, + MTK_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, + MTK_SCALER_AVAILABLE_STALL_DURATIONS, + MTK_SCALER_CROPPING_TYPE, + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS, + // enum[] | ndk_public | HIDL v3.4 + MTK_SCALER_AVAILABLE_RECOMMENDED_INPUT_OUTPUT_FORMATS_MAP, + // int32 | ndk_public | HIDL v3.4 + MTK_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES, // byte[] | hidden | HIDL v3.5 + MTK_SCALER_ROTATE_AND_CROP, // enum | hidden | HIDL v3.5 + MTK_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_WITH_DURATIONS, // int64[] | mtk extension + MTK_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_WITH_DURATIONS_CANDIDATES, // int64[] | mtk extension + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_CANDIDATES, + /* + MTK_SCALER_CROP_REGION is neither app tag nor vendor tag now because ANDROID_SCALER_CROP_REGION may + have another meaning. + + Before Android R, MTK_SCALER_CROP_REGION is the desired region of the sensor to read out, so Left + and Top can be negative to represent ultra wide FOV if active array is wide sensor. + + In Android R, the application can choose to use CONTROL_ZOOM_RATIO to specify the desired zoom level, + and MTK_SCALER_CROP_REGION is used to achieve aspect ratios. + + HAL implementation still use previous version. We create MTK_SCALER_CROP_APP_REGION to correspond + ANDROID_SCALER_CROP_REGION, and convert to MTK_SCALER_CROP_REGION for backward compatible. + */ + MTK_SCALER_CROP_REGION, + MTK_SCALER_END, + + MTK_IOPIPE_INFO_AVAILABLE_IN_PORT_INFO + = MTK_IOPIPE_INFO_START, + MTK_IOPIPE_INFO_AVAILABLE_OUT_PORT_INFO, + MTK_IOPIPE_INFO_PORT_ID, + MTK_IOPIPE_INFO_TRANSFORM, + MTK_IOPIPE_INFO_CROP, + MTK_IOPIPE_INFO_SCALE_DOWN_RATIO, + MTK_IOPIPE_INFO_SCALE_UP_RATIO, + MTK_IOPIPE_INFO_LINEBUFFER, + MTK_IOPIPE_INFO_AVAILABLE_FORMATS, + MTK_IOPIPE_INFO_END, + + MTK_SENSOR_EXPOSURE_TIME = MTK_SENSOR_START, + MTK_SENSOR_FRAME_DURATION, + MTK_SENSOR_SENSITIVITY, + MTK_SENSOR_REFERENCE_ILLUMINANT1, + MTK_SENSOR_REFERENCE_ILLUMINANT2, + MTK_SENSOR_CALIBRATION_TRANSFORM1, + MTK_SENSOR_CALIBRATION_TRANSFORM2, + MTK_SENSOR_COLOR_TRANSFORM1, + MTK_SENSOR_COLOR_TRANSFORM2, + MTK_SENSOR_FORWARD_MATRIX1, + MTK_SENSOR_FORWARD_MATRIX2, + MTK_SENSOR_BASE_GAIN_FACTOR, + MTK_SENSOR_BLACK_LEVEL_PATTERN, + MTK_SENSOR_MAX_ANALOG_SENSITIVITY, + MTK_SENSOR_ORIENTATION, + MTK_SENSOR_PROFILE_HUE_SAT_MAP_DIMENSIONS, + MTK_SENSOR_TIMESTAMP, + MTK_SENSOR_TEMPERATURE, + MTK_SENSOR_NEUTRAL_COLOR_POINT, + MTK_SENSOR_NOISE_PROFILE, + MTK_SENSOR_PROFILE_HUE_SAT_MAP, + MTK_SENSOR_PROFILE_TONE_CURVE, + MTK_SENSOR_GREEN_SPLIT, + MTK_SENSOR_TEST_PATTERN_DATA, + MTK_SENSOR_TEST_PATTERN_MODE, + MTK_SENSOR_AVAILABLE_TEST_PATTERN_MODES, + MTK_SENSOR_ROLLING_SHUTTER_SKEW, + MTK_SENSOR_OPTICAL_BLACK_REGIONS, + MTK_SENSOR_DYNAMIC_BLACK_LEVEL, + MTK_SENSOR_DYNAMIC_WHITE_LEVEL, + MTK_SENSOR_OPAQUE_RAW_SIZE, + MTK_SENSOR_END, + + MTK_SENSOR_INFO_ACTIVE_ARRAY_REGION = MTK_SENSOR_INFO_START, + MTK_SENSOR_INFO_SENSITIVITY_RANGE, + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, + MTK_SENSOR_INFO_EXPOSURE_TIME_RANGE, + MTK_SENSOR_INFO_MAX_FRAME_DURATION, + MTK_SENSOR_INFO_PHYSICAL_SIZE, + MTK_SENSOR_INFO_PIXEL_ARRAY_SIZE, + MTK_SENSOR_INFO_WHITE_LEVEL, + MTK_SENSOR_INFO_TIMESTAMP_SOURCE, + MTK_SENSOR_INFO_LENS_SHADING_APPLIED, + MTK_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE, + MTK_SENSOR_INFO_ORIENTATION, + MTK_SENSOR_INFO_PACKAGE, + MTK_SENSOR_INFO_DEV, + MTK_SENSOR_INFO_SCENARIO_ID, + MTK_SENSOR_INFO_FRAME_RATE, + MTK_SENSOR_INFO_REAL_OUTPUT_SIZE, + MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY, + MTK_SENSOR_INFO_WANTED_ORIENTATION, + MTK_SENSOR_INFO_END, + + MTK_SHADING_MODE = MTK_SHADING_START, + MTK_SHADING_STRENGTH, + MTK_SHADING_AVAILABLE_MODES, + MTK_SHADING_END, + + MTK_STATISTICS_FACE_DETECT_MODE = MTK_STATISTICS_START, + MTK_STATISTICS_HISTOGRAM_MODE, + MTK_STATISTICS_SHARPNESS_MAP_MODE, + MTK_STATISTICS_HOT_PIXEL_MAP_MODE, + MTK_STATISTICS_FACE_IDS, + MTK_STATISTICS_FACE_LANDMARKS, + MTK_STATISTICS_FACE_RECTANGLES, + MTK_STATISTICS_FACE_SCORES, + MTK_STATISTICS_HISTOGRAM, + MTK_STATISTICS_SHARPNESS_MAP, + MTK_STATISTICS_LENS_SHADING_CORRECTION_MAP, + MTK_STATISTICS_LENS_SHADING_MAP, + MTK_STATISTICS_PREDICTED_COLOR_GAINS, + MTK_STATISTICS_PREDICTED_COLOR_TRANSFORM, + MTK_STATISTICS_SCENE_FLICKER, + MTK_STATISTICS_HOT_PIXEL_MAP, + MTK_STATISTICS_LENS_SHADING_MAP_MODE, + MTK_STATISTICS_OIS_DATA_MODE, + MTK_STATISTICS_OIS_TIMESTAMPS, + MTK_STATISTICS_OIS_X_SHIFTS, + MTK_STATISTICS_OIS_Y_SHIFTS, + MTK_STATISTICS_OBJECT_TRACKING_ENABLE, + MTK_STATISTICS_OBJECT_TRACKING_INIT, + MTK_STATISTICS_OBJECT_TRACKING_SCORE, + MTK_STATISTICS_OBJECT_TRACKING_RECT, + MTK_STATISTICS_END, + + MTK_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES + = MTK_STATISTICS_INFO_START, + MTK_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, + MTK_STATISTICS_INFO_MAX_FACE_COUNT, + MTK_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, + MTK_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE, + MTK_STATISTICS_INFO_SHARPNESS_MAP_SIZE, + MTK_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES, + MTK_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, + MTK_STATISTICS_INFO_AVAILABLE_OIS_DATA_MODES, + MTK_STATISTICS_INFO_END, + + MTK_TONEMAP_CURVE_BLUE = MTK_TONEMAP_START, + MTK_TONEMAP_CURVE_GREEN, + MTK_TONEMAP_CURVE_RED, + MTK_TONEMAP_MODE, + MTK_TONEMAP_MAX_CURVE_POINTS, + MTK_TONEMAP_AVAILABLE_TONE_MAP_MODES, + MTK_TONEMAP_GAMMA, + MTK_TONEMAP_PRESET_CURVE, + MTK_TONEMAP_END, + + MTK_LED_TRANSMIT = MTK_LED_START, + MTK_LED_AVAILABLE_LEDS, + MTK_LED_END, + + MTK_INFO_SUPPORTED_HARDWARE_LEVEL = MTK_INFO_START, + MTK_INFO_VERSION, + MTK_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, + MTK_INFO_END, + + MTK_BLACK_LEVEL_LOCK = MTK_BLACK_LEVEL_START, + MTK_BLACK_LEVEL_END, + + MTK_SYNC_FRAME_NUMBER = MTK_SYNC_START, + MTK_SYNC_MAX_LATENCY, + MTK_SYNC_END, + + MTK_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR + = MTK_REPROCESS_START, + MTK_REPROCESS_MAX_CAPTURE_STALL, + MTK_REPROCESS_END, + + MTK_DEPTH_MAX_DEPTH_SAMPLES = MTK_DEPTH_START, + MTK_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, + MTK_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, + MTK_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, + MTK_DEPTH_DEPTH_IS_EXCLUSIVE, + MTK_DEPTH_AVAILABLE_RECOMMENDED_DEPTH_STREAM_CONFIGURATIONS, + MTK_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS, + MTK_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS, + MTK_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS, + MTK_DEPTH_END, + + MTK_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS = MTK_LOGICAL_MULTI_CAMERA_START, + MTK_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE, + MTK_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID, + MTK_LOGICAL_MULTI_CAMERA_END, + + MTK_DISTORTION_CORRECTION_MODE = // enum | public | HIDL v3.3 + MTK_DISTORTION_CORRECTION_START, + MTK_DISTORTION_CORRECTION_AVAILABLE_MODES, // byte[] | public | HIDL v3.3 + MTK_DISTORTION_CORRECTION_END, + + MTK_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS = + // enum[] | ndk_public | HIDL v3.4 + MTK_HEIC_START, + MTK_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS, // int64[] | ndk_public | HIDL v3.4 + MTK_HEIC_AVAILABLE_HEIC_STALL_DURATIONS, // int64[] | ndk_public | HIDL v3.4 + MTK_HEIC_END, + + MTK_HEIC_INFO_SUPPORTED = // enum | system | HIDL v3.4 + MTK_HEIC_INFO_START, + MTK_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT,// byte | system | HIDL v3.4 + MTK_HEIC_INFO_END, + + MTK_FACE_FEATURE_GESTURE_MODE = MTK_FACE_FEATURE_START, + MTK_FACE_FEATURE_GESTURE_RESULT, + MTK_FACE_FEATURE_SMILE_DETECT_MODE, + MTK_FACE_FEATURE_SMILE_DETECT_RESULT, + MTK_FACE_FEATURE_ASD_MODE, + MTK_FACE_FEATURE_ASD_RESULT, + MTK_FACE_FEATURE_AVAILABLE_GESTURE_MODES, + MTK_FACE_FEATURE_AVAILABLE_SMILE_DETECT_MODES, + MTK_FACE_FEATURE_AVAILABLE_ASD_MODES, + MTK_FACE_FEATURE_FORCE_FACE_3A, + MTK_FACE_FEATURE_AVAILABLE_FORCE_FACE_3A, + MTK_FACE_FEATURE_FACE_ADDITIONAL_RESULT, + MTK_FACE_FEATURE_POSE_ORIENTATIONS, + MTK_FACE_FEATURE_END, + + MTK_NR_FEATURE_3DNR_MODE = MTK_NR_FEATURE_START, + MTK_NR_FEATURE_AVAILABLE_3DNR_MODES, + MTK_NR_FEATURE_END, + + MTK_HDR_FEATURE_HDR_MODE = MTK_HDR_FEATURE_START, // Control Meta + MTK_HDR_FEATURE_SESSION_PARAM_HDR_MODE, //control meta for config usage + MTK_HDR_FEATURE_HDR_DETECTION_RESULT, // Dynamic Meta, reply hdr detector result + MTK_HDR_FEATURE_AVAILABLE_HDR_MODES_PHOTO, // Static Meta, for App query use, runtime decided in MetadataProvider + MTK_HDR_FEATURE_AVAILABLE_HDR_MODES_VIDEO, // Static Meta, for App query use, runtime decided in MetadataProvider + MTK_HDR_FEATURE_AVAILABLE_VHDR_MODES, // Static Meta, for middleware query use + MTK_HDR_FEATURE_AVAILABLE_MSTREAM_HDR_MODES,// Static Meta, for App query use + MTK_HDR_FEATURE_AVAILABLE_SINGLE_FRAME_HDR, // Static Meta, for middleware query use + MTK_HDR_FEATURE_AVAILABLE_STAGGER_HDR_MODES,// Static Meta, for App query use + MTK_HDR_FEATURE_VHDR_RESULT, // Dynamic Meta, reply vhdr result + MTK_HDR_FEATURE_END, + + // Dynamic Meta, middleware use, for override timestamp need or not use + // [0] : need override or not + // [1] : overrided or not. ( If overrided, can send shutter time to Framework) + MTK_EIS_FEATURE_EIS_MODE = MTK_EIS_FEATURE_START, + MTK_EIS_FEATURE_ISNEED_OVERRIDE_TIMESTAMP, + MTK_EIS_FEATURE_NEW_SHUTTER_TIMESTAMP, // Dynamic Meta, middleware use, override timestamp for record + MTK_EIS_FEATURE_PREVIEW_EIS, + MTK_EIS_FEATURE_END, + + MTK_STREAMING_FEATURE_RECORD_STATE = MTK_STREAMING_FEATURE_START, // Control Meta, app use, tell recording or stopping + MTK_STREAMING_FEATURE_AVAILABLE_RECORD_STATES, // Static Meta, for app query use + MTK_STREAMING_FEATURE_HFPS_MODE, + MTK_STREAMING_FEATURE_AVAILABLE_HFPS_MODES, // Static Meta, for app query use + MTK_STREAMING_FEATURE_AVAILABLE_HFPS_MAX_RESOLUTIONS, // Static Meta, for app query use [maxW, maxH, fps] + MTK_STREAMING_FEATURE_AVAILABLE_HFPS_EIS_MAX_RESOLUTIONS, + MTK_STREAMING_FEATURE_HDR10, + MTK_STREAMING_FEATURE_CROP_OUTER_LINES_ENABLE, + MTK_STREAMING_FEATURE_PIP_DEVICES, + MTK_STREAMING_FEATURE_DEMO_FB, + MTK_STREAMING_FEATURE_DEMO_EIS, + MTK_STREAMING_FEATURE_DEMO_ASD, + MTK_STREAMING_FEATURE_END, + + MTK_STEREO_FEATURE_DOF_LEVEL = MTK_STEREO_FEATURE_START, + MTK_STEREO_FEATURE_SUPPORTED_DOF_LEVEL, + MTK_STEREO_FEATURE_RESULT_DOF_LEVEL, + MTK_STEREO_FEATURE_WARNING, + MTK_STEREO_FEATURE_DEPTH_AF_ON, + MTK_STEREO_FEATURE_DISTANCE_MEASURE_ON, + MTK_STEREO_FEATURE_RESULT_DISTANCE, + MTK_STEREO_FEATURE_TOUCH_POSITION, + MTK_STEREO_FEATURE_SHOT_MODE, + MTK_STEREO_FEATURE_STATE, + MTK_STEREO_FEATURE_END, + + + MTK_MFNR_FEATURE_MFB_MODE = MTK_MFNR_FEATURE_START, + MTK_MFNR_FEATURE_MFB_RESULT, + MTK_MFNR_FEATURE_AVAILABLE_MFB_MODES, + MTK_MFNR_FEATURE_AIS_MODE, + MTK_MFNR_FEATURE_AIS_RESULT, + MTK_MFNR_FEATURE_AVAILABLE_AIS_MODES, + MTK_MFNR_FEATURE_BSS_GOLDEN_INDEX, + MTK_MFNR_FEATURE_DO_ZIP_WITH_BSS, + MTK_MFNR_FEATURE_END, + + MTK_CSHOT_FEATURE_AVAILABLE_MODES = MTK_CSHOT_FEATURE_START, + MTK_CSHOT_FEATURE_CAPTURE, + MTK_CSHOT_FEATURE_END, + + MTK_3A_FEATURE_AE_ROI = MTK_3A_FEATURE_START, + MTK_3A_FEATURE_AF_ROI, + MTK_3A_FEATURE_AWB_ROI, + MTK_3A_FEATURE_AE_REQUEST_ISO_SPEED, + MTK_3A_FEATURE_AE_AVAILABLE_METERING, + MTK_3A_FEATURE_AE_REQUEST_METERING_MODE, + MTK_3A_FEATURE_AE_AVERAGE_BRIGHTNESS, + MTK_3A_FEATURE_AE_CAPTURE_SELECTION_SHUTTER, + MTK_3A_FEATURE_AE_CAPTURE_SELECTION_ISO, + MTK_3A_FEATURE_AE_PLINE_INDEX, + MTK_3A_FEATURE_AE_CUSTOM_PLINE_MODE, + MTK_3A_FEATURE_AWB_AVAILABL_RANGE, + MTK_3A_FEATURE_AWB_REQUEST_VALUE, + MTK_3A_FEATURE_AWB_CCT, + MTK_3A_FEATURE_LENS_AVAILABLE_FOCAL_LENGTHS_35MM, + MTK_3A_FEATURE_AE_SENSOR_GAIN_VALUE, + MTK_3A_FEATURE_AE_ISP_GAIN_VALUE, + MTK_3A_FEATURE_AE_LUX_INDEX_VALUE, + MTK_3A_FEATURE_ADRC_GAIN_VALUE, + MTK_3A_FEATURE_AE_METER_FD_TARGET, + MTK_3A_FEATURE_AE_METER_FD_LINK_TARGET, + MTK_3A_FEATURE_AISHUT_EXIST_MOTION, + MTK_3A_FEATURE_AISHUT_EXPOSURETIME, + MTK_3A_FEATURE_AISHUT_ISO, + MTK_3A_FEATURE_AISHUT_CAPTURE, + MTK_3A_FEATURE_END, + + MTK_HAL_VERSION = MTK_HAL_INFO_START, + + MTK_VSDOF_FEATURE_CALLBACK_BUFFERS = MTK_VSDOF_FEATURE_START, + MTK_VSDOF_FEATURE_DENOISE_MODE, + MTK_VSDOF_FEATURE_DENOISE_SUPPORTED_MODULE, + MTK_VSDOF_FEATURE_3RDPARTY_MODE, + MTK_VSDOF_FEATURE_3RDPARTY_SUPPORTED_MODULE, + MTK_VSDOF_FEATURE_PREVIEW_ENABLE, + MTK_VSDOF_FEATURE_SHOT_MODE, + MTK_VSDOF_FEATURE_PREVIEW_SIZE, + MTK_VSDOF_FEATURE_PREVIEW_MODE, // full or half + MTK_VSDOF_FEATURE_AVAILABLE_PREVIEW_MODE, // for app static metadata use, and it will set in metadata provider. + MTK_VSDOF_FEATURE_WARNING, // [vendor tag] for vsdof feature warning message + MTK_VSDOF_FEATURE_CAPTURE_WARNING_MSG, // [vendor tag] for vsdof capture request in takePicture. + MTK_VSDOF_FEATURE_RECORD_MODE, + MTK_VSDOF_FEATURE_SUPPORTED_DEPTH_MAP_SIZES, // [vendor tag] for vsdof depth stream sizes. + MTK_VSDOF_FEATURE_REFOCUS_CAPTURE_FLOW, // [vendor tag] for vsdof refocus capture flow decision. + MTK_VSDOF_FEATURE_END, + + MTK_MULTI_CAM_FEATURE_MODE = MTK_MULTI_CAM_FEATURE_START, + MTK_MULTI_CAM_FEATURE_AVAILABLE_MODE, // for app static metadata use, and it will set in metadata provider. + MTK_MULTI_CAM_FEATURE_SENSOR_MANUAL_UPDATED, + MTK_MULTI_CAM_AF_ROI, + MTK_MULTI_CAM_AE_ROI, + MTK_MULTI_CAM_AWB_ROI, + MTK_MULTI_CAM_MASTER_ID, + MTK_MULTI_CAM_FOV_CROP_REGION, + MTK_MULTI_CAM_SENSOR_CROP_REGION, + MTK_MULTI_CAM_ZOOM_RANGE, + MTK_MULTI_CAM_ZOOM_VALUE, + MTK_MULTI_CAM_ZOOM_STEPS, + MTK_MULTI_CAM_STREAMING_ID, + MTK_MULTI_CAM_CAPTURE_COUNT, + MTK_MULTI_CAM_CONFIG_SCALER_CROP_REGION, + MTK_MULTI_CAM_FEATURE_END, + + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_SUPPORT = MTK_CONTROL_CAPTURE_START, + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_TRIGGER, + MTK_CONTROL_CAPTURE_NEXT_READY, + MTK_CONTROL_CAPTURE_JPEG_FLIP_MODE, + MTK_CONTROL_CAPTURE_AVAILABLE_POSTVIEW_MODES, + MTK_CONTROL_CAPTURE_POSTVIEW_SIZE, + MTK_CONTROL_CAPTURE_REMOSAIC_EN, + MTK_CONTROL_CAPTURE_AVAILABLE_ZSL_MODES, // zsl + MTK_CONTROL_CAPTURE_DEFAULT_ZSL_MODE, + MTK_CONTROL_CAPTURE_ZSL_MODE, + MTK_CONTROL_CAPTURE_SINGLE_YUV_NR, // To enable or disable P2C output high quality yuv + MTK_CONTROL_CAPTURE_HIGH_QUALITY_YUV, // To enable or disable single YUV NR + MTK_CONTROL_CAPTURE_HINT_FOR_RAW_REPROCESS, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_FRAME_COUNT, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_FRAME_INDEX, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_FRAME_TUNING_INDEX, + MTK_CONTROL_CAPTURE_ISP_TUNING_DATA_ENABLE, + MTK_CONTROL_CAPTURE_ISP_TUNING_DATA_SIZE_FOR_RAW, + MTK_CONTROL_CAPTURE_ISP_TUNING_DATA_SIZE_FOR_YUV, + MTK_CONTROL_CAPTURE_ISP_TUNING_REQUEST, + MTK_CONTROL_CAPTURE_ISP_TUNING_DATA_RAW, + MTK_CONTROL_CAPTURE_ISP_TUNING_DATA_YUV, + MTK_CONTROL_CAPTURE_PACKED_RAW_SUPPORT, + MTK_CONTROL_CAPTURE_PACKED_RAW_ENABLE, + MTK_CONTROL_CAPTURE_PROCESS_RAW_ENABLE, + MTK_CONTROL_CAPTURE_RAW_BPP, + MTK_CONTROL_CAPTURE_YUV_NO_MARGIN, + MTK_CONTROL_CAPTURE_SINGLE_YUV_NR_MODE, // set in sessionparam to enable singel YUV NR + MTK_CONTROL_CAPTURE_INSENSORZOOM_MODE, + MTK_CONTROL_CAPTURE_HIDL_JPEGYUV_TUNING, + MTK_CONTROL_CAPTURE_END, + + MTK_BGSERVICE_FEATURE_PRERELEASE_AVAILABLE_MODES = MTK_BGSERVICE_FEATURE_START, + MTK_BGSERVICE_FEATURE_PRERELEASE, + MTK_BGSERVICE_FEATURE_IMAGEREADERID, + MTK_BGSERVICE_FEATURE_END, + + MTK_CONFIGURE_SETTING_INIT_REQUEST = MTK_CONFIGURE_SETTING_START, + MTK_CONFIGURE_ISP_YUV_DIRECT_JPEG, + MTK_CONFIGURE_SETTING_PROPRIETARY, + MTK_CONFIGURE_SETTING_END, + + MTK_FLASH_FEATURE_CALIBRATION_AVAILABLE = MTK_FLASH_FEATURE_START, // flash calibration available + MTK_FLASH_FEATURE_CALIBRATION_ENABLE, // flash calibration enable + MTK_FLASH_FEATURE_CALIBRATION_RESULT, // flash calibration result + MTK_FLASH_FEATURE_CALIBRATION_STATE, // flash calibration state + MTK_FLASH_FEATURE_CUSTOMIZATION_AVAILABLE, + MTK_FLASH_FEATURE_CUSTOMIZED_RESULT, + MTK_FLASH_FEATURE_CUSTOMIZED_TORCH_DUTY, + MTK_FLASH_FEATURE_END, + + MTK_SMVR_FEATURE_SMVR_MODE = MTK_SMVR_FEATURE_START, + MTK_SMVR_FEATURE_AVAILABLE_SMVR_MODES, + MTK_SMVR_FEATURE_SMVR_RESULT, + MTK_SMVR_FEATURE_END, + + MTK_SINGLEHW_SETTING_MODULE = MTK_SINGLEHW_SETTING_START, + MTK_SINGLEHW_SETTING_SOURCE_CROP, + MTK_SINGLEHW_SETTING_TRANSFORM, + MTK_SINGLEHW_SETTING_VIDEO_STREAM, + MTK_SINGLEHW_SETTING_WARP_MAP_X, + MTK_SINGLEHW_SETTING_WARP_MAP_Y, + MTK_SINGLEHW_SETTING_WARP_MAP_Z, + MTK_SINGLEHW_SETTING_OUT_STREAM_STRIDE, + MTK_SINGLEHW_SETTING_WARP_OUTPUT, + MTK_SINGLEHW_SETTING_END, + + MTK_ABF_FEATURE_ABF_MODE = MTK_ABF_FEATURE_START, + MTK_ABF_FEATURE_ABF_RESULT, + MTK_ABF_FEATURE_AVAILABLE_ABF_MODES, + MTK_ABF_FEATURE_END, +} mtk_camera_metadata_tag_t; + +/** + * Enumeration definitions for the various entries that need them + */ + +// MTK_COLOR_CORRECTION_MODE +typedef enum mtk_camera_metadata_enum_android_color_correction_mode { + MTK_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX, + MTK_COLOR_CORRECTION_MODE_FAST, + MTK_COLOR_CORRECTION_MODE_HIGH_QUALITY, +} mtk_camera_metadata_enum_android_color_correction_mode_t; + +// MTK_COLOR_CORRECTION_ABERRATION_MODE +typedef enum mtk_camera_metadata_enum_android_color_correction_aberration_mode { + MTK_COLOR_CORRECTION_ABERRATION_MODE_OFF, + MTK_COLOR_CORRECTION_ABERRATION_MODE_FAST, + MTK_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY, +} mtk_camera_metadata_enum_android_color_correction_aberration_mode_t; + +// MTK_CONTROL_AE_ANTIBANDING_MODE +typedef enum mtk_camera_metadata_enum_android_control_ae_antibanding_mode { + MTK_CONTROL_AE_ANTIBANDING_MODE_OFF, + MTK_CONTROL_AE_ANTIBANDING_MODE_50HZ, + MTK_CONTROL_AE_ANTIBANDING_MODE_60HZ, + MTK_CONTROL_AE_ANTIBANDING_MODE_AUTO, +} mtk_camera_metadata_enum_android_control_ae_antibanding_mode_t; + +// MTK_CONTROL_AE_LOCK +typedef enum mtk_camera_metadata_enum_android_control_ae_lock { + MTK_CONTROL_AE_LOCK_OFF, + MTK_CONTROL_AE_LOCK_ON, +} mtk_camera_metadata_enum_android_control_ae_lock_t; + +// MTK_CONTROL_AE_MODE +typedef enum mtk_camera_metadata_enum_android_control_ae_mode { + MTK_CONTROL_AE_MODE_OFF, + MTK_CONTROL_AE_MODE_ON, + MTK_CONTROL_AE_MODE_ON_AUTO_FLASH, + MTK_CONTROL_AE_MODE_ON_ALWAYS_FLASH, + MTK_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE, + MTK_CONTROL_AE_MODE_ON_EXTERNAL_FLASH, +} mtk_camera_metadata_enum_android_control_ae_mode_t; + +// MTK_CONTROL_AE_PRECAPTURE_TRIGGER +typedef enum mtk_camera_metadata_enum_android_control_ae_precapture_trigger { + MTK_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE, + MTK_CONTROL_AE_PRECAPTURE_TRIGGER_START, + MTK_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL, +} mtk_camera_metadata_enum_android_control_ae_precapture_trigger_t; + +// MTK_CONTROL_AF_MODE +typedef enum mtk_camera_metadata_enum_android_control_af_mode { + MTK_CONTROL_AF_MODE_OFF, + MTK_CONTROL_AF_MODE_AUTO, + MTK_CONTROL_AF_MODE_MACRO, + MTK_CONTROL_AF_MODE_CONTINUOUS_VIDEO, + MTK_CONTROL_AF_MODE_CONTINUOUS_PICTURE, + MTK_CONTROL_AF_MODE_EDOF, +} mtk_camera_metadata_enum_android_control_af_mode_t; + +// MTK_CONTROL_AF_TRIGGER +typedef enum mtk_camera_metadata_enum_android_control_af_trigger { + MTK_CONTROL_AF_TRIGGER_IDLE, + MTK_CONTROL_AF_TRIGGER_START, + MTK_CONTROL_AF_TRIGGER_CANCEL, +} mtk_camera_metadata_enum_android_control_af_trigger_t; + +// MTK_CONTROL_AWB_LOCK +typedef enum mtk_camera_metadata_enum_android_control_awb_lock { + MTK_CONTROL_AWB_LOCK_OFF, + MTK_CONTROL_AWB_LOCK_ON, +} mtk_camera_metadata_enum_android_control_awb_lock_t; + +// MTK_CONTROL_AWB_MODE +typedef enum mtk_camera_metadata_enum_android_control_awb_mode { + MTK_CONTROL_AWB_MODE_OFF, + MTK_CONTROL_AWB_MODE_AUTO, + MTK_CONTROL_AWB_MODE_INCANDESCENT, + MTK_CONTROL_AWB_MODE_FLUORESCENT, + MTK_CONTROL_AWB_MODE_WARM_FLUORESCENT, + MTK_CONTROL_AWB_MODE_DAYLIGHT, + MTK_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT, + MTK_CONTROL_AWB_MODE_TWILIGHT, + MTK_CONTROL_AWB_MODE_SHADE, + MTK_CONTROL_AWB_MODE_GRAYWORLD, //deprecated + MTK_CONTROL_AWB_MODE_MWB, +} mtk_camera_metadata_enum_android_control_awb_mode_t; + +// MTK_CONTROL_CAPTURE_INTENT +typedef enum mtk_camera_metadata_enum_android_control_capture_intent { + MTK_CONTROL_CAPTURE_INTENT_CUSTOM, + MTK_CONTROL_CAPTURE_INTENT_PREVIEW, + MTK_CONTROL_CAPTURE_INTENT_STILL_CAPTURE, + MTK_CONTROL_CAPTURE_INTENT_VIDEO_RECORD, + MTK_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT, + MTK_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG, + MTK_CONTROL_CAPTURE_INTENT_MANUAL, + MTK_CONTROL_CAPTURE_INTENT_MOTION_TRACKING, +} mtk_camera_metadata_enum_android_control_capture_intent_t; + +// MTK_CONTROL_EFFECT_MODE +typedef enum mtk_camera_metadata_enum_android_control_effect_mode { + MTK_CONTROL_EFFECT_MODE_OFF, + MTK_CONTROL_EFFECT_MODE_MONO, + MTK_CONTROL_EFFECT_MODE_NEGATIVE, + MTK_CONTROL_EFFECT_MODE_SOLARIZE, + MTK_CONTROL_EFFECT_MODE_SEPIA, + MTK_CONTROL_EFFECT_MODE_POSTERIZE, + MTK_CONTROL_EFFECT_MODE_WHITEBOARD, + MTK_CONTROL_EFFECT_MODE_BLACKBOARD, + MTK_CONTROL_EFFECT_MODE_AQUA, //, + MTK_CONTROL_EFFECT_MODE_SEPIAGREEN, + MTK_CONTROL_EFFECT_MODE_SEPIABLUE, + MTK_CONTROL_EFFECT_MODE_NASHVILLE , //LOMO + MTK_CONTROL_EFFECT_MODE_HEFE , + MTK_CONTROL_EFFECT_MODE_VALENCIA , + MTK_CONTROL_EFFECT_MODE_XPROII , + MTK_CONTROL_EFFECT_MODE_LOFI , + MTK_CONTROL_EFFECT_MODE_SIERRA , + MTK_CONTROL_EFFECT_MODE_KELVIN , + MTK_CONTROL_EFFECT_MODE_WALDEN, + MTK_CONTROL_EFFECT_MODE_F1977 , //LOMO + MTK_CONTROL_EFFECT_MODE_NUM +} mtk_camera_metadata_enum_android_control_effect_mode_t; + +// MTK_CONTROL_MODE +typedef enum mtk_camera_metadata_enum_android_control_mode { + MTK_CONTROL_MODE_OFF, + MTK_CONTROL_MODE_AUTO, + MTK_CONTROL_MODE_USE_SCENE_MODE, + MTK_CONTROL_MODE_OFF_KEEP_STATE, + MTK_CONTROL_MODE_USE_EXTENDED_SCENE_MODE +} mtk_camera_metadata_enum_android_control_mode_t; + +// MTK_CONTROL_SCENE_MODE +typedef enum mtk_camera_metadata_enum_android_control_scene_mode { + MTK_CONTROL_SCENE_MODE_DISABLED = 0, + MTK_CONTROL_SCENE_MODE_UNSUPPORTED = MTK_CONTROL_SCENE_MODE_DISABLED, + MTK_CONTROL_SCENE_MODE_FACE_PRIORITY, + MTK_CONTROL_SCENE_MODE_ACTION, + MTK_CONTROL_SCENE_MODE_PORTRAIT, + MTK_CONTROL_SCENE_MODE_LANDSCAPE, + MTK_CONTROL_SCENE_MODE_NIGHT, + MTK_CONTROL_SCENE_MODE_NIGHT_PORTRAIT, + MTK_CONTROL_SCENE_MODE_THEATRE, + MTK_CONTROL_SCENE_MODE_BEACH, + MTK_CONTROL_SCENE_MODE_SNOW, + MTK_CONTROL_SCENE_MODE_SUNSET, + MTK_CONTROL_SCENE_MODE_STEADYPHOTO, + MTK_CONTROL_SCENE_MODE_FIREWORKS, + MTK_CONTROL_SCENE_MODE_SPORTS, + MTK_CONTROL_SCENE_MODE_PARTY, + MTK_CONTROL_SCENE_MODE_CANDLELIGHT, + MTK_CONTROL_SCENE_MODE_BARCODE, + MTK_CONTROL_SCENE_MODE_HIGH_SPEED_VIDEO, + MTK_CONTROL_SCENE_MODE_HDR, + MTK_CONTROL_SCENE_MODE_FACE_PRIORITY_LOW_LIGHT, + MTK_CONTROL_SCENE_MODE_DEVICE_CUSTOM_START = 100, + MTK_CONTROL_SCENE_MODE_DEVICE_CUSTOM_END = 127, + // Camera1 + MTK_CONTROL_SCENE_MODE_NORMAL, + MTK_CONTROL_SCENE_MODE_NUM +} mtk_camera_metadata_enum_android_control_scene_mode_t; + +// MTK_CONTROL_VIDEO_STABILIZATION_MODE +typedef enum mtk_camera_metadata_enum_android_control_video_stabilization_mode { + MTK_CONTROL_VIDEO_STABILIZATION_MODE_OFF, + MTK_CONTROL_VIDEO_STABILIZATION_MODE_ON, +} mtk_camera_metadata_enum_android_control_video_stabilization_mode_t; + +// MTK_CONTROL_AE_STATE +typedef enum mtk_camera_metadata_enum_android_control_ae_state { + MTK_CONTROL_AE_STATE_INACTIVE, + MTK_CONTROL_AE_STATE_SEARCHING, + MTK_CONTROL_AE_STATE_CONVERGED, + MTK_CONTROL_AE_STATE_LOCKED, + MTK_CONTROL_AE_STATE_FLASH_REQUIRED, + MTK_CONTROL_AE_STATE_PRECAPTURE, +} mtk_camera_metadata_enum_android_control_ae_state_t; + +// MTK_CONTROL_AF_STATE +typedef enum mtk_camera_metadata_enum_android_control_af_state { + MTK_CONTROL_AF_STATE_INACTIVE, + MTK_CONTROL_AF_STATE_PASSIVE_SCAN, + MTK_CONTROL_AF_STATE_PASSIVE_FOCUSED, + MTK_CONTROL_AF_STATE_ACTIVE_SCAN, + MTK_CONTROL_AF_STATE_FOCUSED_LOCKED, + MTK_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED, + MTK_CONTROL_AF_STATE_PASSIVE_UNFOCUSED, +} mtk_camera_metadata_enum_android_control_af_state_t; + +// MTK_CONTROL_AWB_STATE +typedef enum mtk_camera_metadata_enum_android_control_awb_state { + MTK_CONTROL_AWB_STATE_INACTIVE, + MTK_CONTROL_AWB_STATE_SEARCHING, + MTK_CONTROL_AWB_STATE_CONVERGED, + MTK_CONTROL_AWB_STATE_LOCKED, +} mtk_camera_metadata_enum_android_control_awb_state_t; + +// MTK_CONTROL_AE_LOCK_AVAILABLE +typedef enum mtk_camera_metadata_enum_android_control_ae_lock_available { + MTK_CONTROL_AE_LOCK_AVAILABLE_FALSE, + MTK_CONTROL_AE_LOCK_AVAILABLE_TRUE, +} mtk_camera_metadata_enum_android_control_ae_lock_available_t; + +// MTK_CONTROL_AWB_LOCK_AVAILABLE +typedef enum mtk_camera_metadata_enum_android_control_awb_lock_available { + MTK_CONTROL_AWB_LOCK_AVAILABLE_FALSE, + MTK_CONTROL_AWB_LOCK_AVAILABLE_TRUE, +} mtk_camera_metadata_enum_android_control_awb_lock_available_t; + +// MTK_CONTROL_ENABLE_ZSL +typedef enum mtk_camera_metadata_enum_android_control_enable_zsl { + MTK_CONTROL_ENABLE_ZSL_FALSE, + MTK_CONTROL_ENABLE_ZSL_TRUE, +} mtk_camera_metadata_enum_android_control_enable_zsl_t; + +// MTK_CONTROL_AF_SCENE_CHANGE +typedef enum mtk_camera_metadata_enum_android_control_af_scene_change { + MTK_CONTROL_AF_SCENE_CHANGE_NOT_DETECTED, + MTK_CONTROL_AF_SCENE_CHANGE_DETECTED, +} mtk_camera_metadata_enum_android_control_af_scene_change_t; + +// MTK_CONTROL_EXTENDED_SCENE_MODE +typedef enum mtk_camera_metadata_enum_android_control_extended_scene_mode { + MTK_CONTROL_EXTENDED_SCENE_MODE_DISABLED = 0, // HIDL v3.5 + MTK_CONTROL_EXTENDED_SCENE_MODE_BOKEH_STILL_CAPTURE, // HIDL v3.5 + MTK_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS, // HIDL v3.5 + MTK_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START = 0x40, // HIDL v3.5 +} mtk_camera_metadata_enum_android_control_extended_scene_mode_t; + +// MTK_CONTROL_ISP_EDGE +typedef enum mtk_camera_metadata_enum_android_control_isp_edge { + MTK_CONTROL_ISP_EDGE_LOW, + MTK_CONTROL_ISP_EDGE_MIDDLE, + MTK_CONTROL_ISP_EDGE_HIGH +} mtk_camera_metadata_enum_android_control_isp_edge_t; + +// MTK_CONTROL_ISP_HUE +typedef enum mtk_camera_metadata_enum_android_control_isp_hue { + MTK_CONTROL_ISP_HUE_LOW, + MTK_CONTROL_ISP_HUE_MIDDLE, + MTK_CONTROL_ISP_HUE_HIGH +} mtk_camera_metadata_enum_android_control_isp_hue_t; + +// MTK_CONTROL_ISP_SATURATION +typedef enum mtk_camera_metadata_enum_android_control_isp_saturation { + MTK_CONTROL_ISP_SATURATION_LOW, + MTK_CONTROL_ISP_SATURATION_MIDDLE, + MTK_CONTROL_ISP_SATURATION_HIGH +} mtk_camera_metadata_enum_android_control_isp_saturation_t; + +// MTK_CONTROL_ISP_BRIGHTNESS +typedef enum mtk_camera_metadata_enum_android_control_isp_brightness { + MTK_CONTROL_ISP_BRIGHTNESS_LOW, + MTK_CONTROL_ISP_BRIGHTNESS_MIDDLE, + MTK_CONTROL_ISP_BRIGHTNESS_HIGH +} mtk_camera_metadata_enum_android_control_isp_brightness_t; + +// MTK_CONTROL_ISP_CONTRAST +typedef enum mtk_camera_metadata_enum_android_control_isp_contrast { + MTK_CONTROL_ISP_CONTRAST_LOW, + MTK_CONTROL_ISP_CONTRAST_MIDDLE, + MTK_CONTROL_ISP_CONTRAST_HIGH +} mtk_camera_metadata_enum_android_control_isp_contrast_t; + +// MTK_DEMOSAIC_MODE +typedef enum mtk_camera_metadata_enum_android_demosaic_mode { + MTK_DEMOSAIC_MODE_FAST, + MTK_DEMOSAIC_MODE_HIGH_QUALITY, +} mtk_camera_metadata_enum_android_demosaic_mode_t; + +// MTK_EDGE_MODE +typedef enum mtk_camera_metadata_enum_android_edge_mode { + MTK_EDGE_MODE_OFF, + MTK_EDGE_MODE_FAST, + MTK_EDGE_MODE_HIGH_QUALITY, + MTK_EDGE_MODE_ZERO_SHUTTER_LAG, +} mtk_camera_metadata_enum_android_edge_mode_t; + +// MTK_FLASH_MODE +typedef enum mtk_camera_metadata_enum_android_flash_mode { + MTK_FLASH_MODE_OFF, + MTK_FLASH_MODE_SINGLE, + MTK_FLASH_MODE_TORCH, +} mtk_camera_metadata_enum_android_flash_mode_t; + +// MTK_FLASH_STATE +typedef enum mtk_camera_metadata_enum_android_flash_state { + MTK_FLASH_STATE_UNAVAILABLE, + MTK_FLASH_STATE_CHARGING, + MTK_FLASH_STATE_READY, + MTK_FLASH_STATE_FIRED, + MTK_FLASH_STATE_PARTIAL, +} mtk_camera_metadata_enum_android_flash_state_t; + +// MTK_FLASH_FEATURE_CUSTOMIZED_TORCH_DUTY +typedef enum mtk_camera_metadata_enum_android_flash_feature_customized_torch_duty { + MTK_FLASH_FEATURE_CUSTOMIZED_TORCH_DUTY_LOW, + MTK_FLASH_FEATURE_CUSTOMIZED_TORCH_DUTY_MID, + MTK_FLASH_FEATURE_CUSTOMIZED_TORCH_DUTY_HIGH, +} mtk_camera_metadata_enum_android_flash_feature_customized_torch_duty_t; + +// MTK_FLASH_INFO_AVAILABLE +typedef enum mtk_camera_metadata_enum_android_flash_info_available { + MTK_FLASH_INFO_AVAILABLE_FALSE, + MTK_FLASH_INFO_AVAILABLE_TRUE, +} mtk_camera_metadata_enum_android_flash_info_available_t; + +// MTK_HOT_PIXEL_MODE +typedef enum mtk_camera_metadata_enum_android_hot_pixel_mode { + MTK_HOT_PIXEL_MODE_OFF, + MTK_HOT_PIXEL_MODE_FAST, + MTK_HOT_PIXEL_MODE_HIGH_QUALITY, +} mtk_camera_metadata_enum_android_hot_pixel_mode_t; + +// MTK_LENS_OPTICAL_STABILIZATION_MODE +typedef enum mtk_camera_metadata_enum_android_lens_optical_stabilization_mode { + MTK_LENS_OPTICAL_STABILIZATION_MODE_OFF, + MTK_LENS_OPTICAL_STABILIZATION_MODE_ON, +} mtk_camera_metadata_enum_android_lens_optical_stabilization_mode_t; + +// MTK_LENS_FACING +typedef enum mtk_camera_metadata_enum_android_lens_facing { + MTK_LENS_FACING_FRONT, + MTK_LENS_FACING_BACK, + MTK_LENS_FACING_EXTERNAL, +} mtk_camera_metadata_enum_android_lens_facing_t; + +// MTK_LENS_STATE +typedef enum mtk_camera_metadata_enum_android_lens_state { + MTK_LENS_STATE_STATIONARY, + MTK_LENS_STATE_MOVING, +} mtk_camera_metadata_enum_android_lens_state_t; + +// MTK_LENS_POSE_REFERENCE +typedef enum mtk_camera_metadata_enum_android_lens_pose_reference { + MTK_LENS_POSE_REFERENCE_PRIMARY_CAMERA, + MTK_LENS_POSE_REFERENCE_GYROSCOPE, + MTK_LENS_POSE_REFERENCE_UNDEFINED +} mtk_camera_metadata_enum_android_lens_pose_reference_t; + +// MTK_LENS_INFO_FOCUS_DISTANCE_CALIBRATION +typedef enum mtk_camera_metadata_enum_android_lens_info_focus_distance_calibration { + MTK_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED, + MTK_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE, + MTK_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED, +} mtk_camera_metadata_enum_android_lens_info_focus_distance_calibration_t; + +// MTK_NOISE_REDUCTION_MODE +typedef enum mtk_camera_metadata_enum_android_noise_reduction_mode { + MTK_NOISE_REDUCTION_MODE_OFF, + MTK_NOISE_REDUCTION_MODE_FAST, + MTK_NOISE_REDUCTION_MODE_HIGH_QUALITY, + MTK_NOISE_REDUCTION_MODE_MINIMAL, + MTK_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG, +} mtk_camera_metadata_enum_android_noise_reduction_mode_t; + +// MTK_QUIRKS_PARTIAL_RESULT +typedef enum mtk_metadata_enum_android_quirks_partial_result { + MTK_QUIRKS_PARTIAL_RESULT_FINAL, + MTK_QUIRKS_PARTIAL_RESULT_PARTIAL, +} mtk_metadata_enum_android_quirks_partial_result_t; + +// MTK_REQUEST_METADATA_MODE +typedef enum mtk_camera_metadata_enum_android_request_metadata_mode { + MTK_REQUEST_METADATA_MODE_NONE, + MTK_REQUEST_METADATA_MODE_FULL, +} mtk_camera_metadata_enum_android_request_metadata_mode_t; + +// MTK_REQUEST_TYPE +typedef enum mtk_camera_metadata_enum_android_request_type { + MTK_REQUEST_TYPE_CAPTURE, + MTK_REQUEST_TYPE_REPROCESS, +} mtk_camera_metadata_enum_android_request_type_t; + +// MTK_REQUEST_AVAILABLE_CAPABILITIES +typedef enum mtk_camera_metadata_enum_android_request_available_capabilities { + MTK_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE, + MTK_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR, + MTK_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING, + MTK_REQUEST_AVAILABLE_CAPABILITIES_RAW, + MTK_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING, + MTK_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS, + MTK_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE, + MTK_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING, + MTK_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT, + MTK_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO, + MTK_REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING, // HIDL v3.3 + MTK_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA, // HIDL v3.3 + MTK_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME, // HIDL v3.3 + MTK_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA, // HIDL v3.4 + MTK_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA, // HIDL v3.5 + MTK_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING, // HIDL v3.5 +} mtk_camera_metadata_enum_android_request_available_capabilities_t; + +// MTK_SCALER_AVAILABLE_FORMATS +typedef enum mtk_camera_metadata_enum_android_scaler_available_formats { + MTK_SCALER_AVAILABLE_FORMATS_RAW16 = 0x20, + MTK_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE = 0x24, + MTK_SCALER_AVAILABLE_FORMATS_YV12 = 0x32315659, + MTK_SCALER_AVAILABLE_FORMATS_YCrCb_420_SP = 0x11, + MTK_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED = 0x22, + MTK_SCALER_AVAILABLE_FORMATS_YCbCr_420_888 = 0x23, + MTK_SCALER_AVAILABLE_FORMATS_BLOB = 0x21, + MTK_SCALER_AVAILABLE_FORMATS_RAW10 = 0x25, // HIDL v3.4 + MTK_SCALER_AVAILABLE_FORMATS_RAW12 = 0x26, // HIDL v3.4 + MTK_SCALER_AVAILABLE_FORMATS_Y8 = 0x20203859, // HIDL v3.4: +} mtk_camera_metadata_enum_android_scaler_available_formats_t; + +// MTK_SCALER_AVAILABLE_STREAM_CONFIGURATIONS +typedef enum mtk_camera_metadata_enum_android_scaler_available_stream_configurations { + MTK_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, + MTK_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT, +} mtk_camera_metadata_enum_android_scaler_available_stream_configurations_t; + +// MTK_SCALER_CROPPING_TYPE +typedef enum mtk_camera_metadata_enum_android_scaler_cropping_type { + MTK_SCALER_CROPPING_TYPE_CENTER_ONLY, + MTK_SCALER_CROPPING_TYPE_FREEFORM, +} mkt_camera_metadata_enum_android_scaler_cropping_type_t; + +// MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS +typedef enum mtk_camera_metadata_enum_android_scaler_available_recommended_stream_configurations {// HIDL v3.4 + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW + = 0x1 << 0x0, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PREVIEW + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD + = 0x1 << 0x1, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RECORD + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT + = 0x1 << 0x2, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VIDEO_SNAPSHOT + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT + = 0x1 << 0x3, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_SNAPSHOT + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL = 0x1 << 0x4, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_ZSL + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW = 0x1 << 0x5, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_RAW + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT + = 0x1 << 0x6, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_LOW_LATENCY_SNAPSHOT + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END + = 0x1 << 0x7, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_PUBLIC_END + MTK_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START + = 0x1 << 0x18, // 1 << ANDROID_SCALER_AVAILABLE_RECOMMENDED_STREAM_CONFIGURATIONS_VENDOR_START +} mtk_camera_metadata_enum_android_scaler_available_recommended_stream_configurations_t; + +// MTK_SCALER_ROTATE_AND_CROP +typedef enum mtk_camera_metadata_enum_android_scaler_rotate_and_crop { + MTK_SCALER_ROTATE_AND_CROP_NONE, // HIDL v3.5 + MTK_SCALER_ROTATE_AND_CROP_90, // HIDL v3.5 + MTK_SCALER_ROTATE_AND_CROP_180, // HIDL v3.5 + MTK_SCALER_ROTATE_AND_CROP_270, // HIDL v3.5 + MTK_SCALER_ROTATE_AND_CROP_AUTO, // HIDL v3.5 +} mtk_camera_metadata_enum_android_scaler_rotate_and_crop_t; + + +// MTK_IOPIPE_INFO_CROP +typedef enum mtk_camera_metadata_enum_android_iopipe_info_crop { + MTK_IOPIPE_INFO_CROP_NOT_SUPPORT, + MTK_IOPIPE_INFO_CROP_SYMMETRIC, + MTK_IOPIPE_INFO_CROP_ASYMMETRIC, +} mtk_camera_metadata_enum_android_iopipe_info_crop_t; + +// MTK_SENSOR_REFERENCE_ILLUMINANT1 +typedef enum mtk_camera_metadata_enum_android_sensor_reference_illuminant1 { + MTK_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT = 1, + MTK_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT = 2, + MTK_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN = 3, + MTK_SENSOR_REFERENCE_ILLUMINANT1_FLASH = 4, + MTK_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER = 9, + MTK_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER = 10, + MTK_SENSOR_REFERENCE_ILLUMINANT1_SHADE = 11, + MTK_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT = 12, + MTK_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT = 13, + MTK_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT = 14, + MTK_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT = 15, + MTK_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A = 17, + MTK_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B = 18, + MTK_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C = 19, + MTK_SENSOR_REFERENCE_ILLUMINANT1_D55 = 20, + MTK_SENSOR_REFERENCE_ILLUMINANT1_D65 = 21, + MTK_SENSOR_REFERENCE_ILLUMINANT1_D75 = 22, + MTK_SENSOR_REFERENCE_ILLUMINANT1_D50 = 23, + MTK_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN = 24, +} mtk_camera_metadata_enum_android_sensor_reference_illuminant1_t; + +// MTK_SENSOR_TEST_PATTERN_MODE +typedef enum mtk_camera_metadata_enum_android_sensor_test_pattern_mode { + MTK_SENSOR_TEST_PATTERN_MODE_OFF, + MTK_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR, + MTK_SENSOR_TEST_PATTERN_MODE_COLOR_BARS, + MTK_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY, + MTK_SENSOR_TEST_PATTERN_MODE_PN9, + MTK_SENSOR_TEST_PATTERN_MODE_CUSTOM1 = 256, +} mkt_camera_metadata_enum_android_sensor_test_pattern_mode_t; + +// MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT +typedef enum mtk_camera_metadata_enum_android_sensor_info_color_filter_arrangement { + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB, + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG, + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG, + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR, + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB, + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO, // HIDL v3.4 + MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR, // HIDL v3.4 +} mtk_camera_metadata_enum_android_sensor_info_color_filter_arrangement_t; + +// MTK_SENSOR_INFO_TIMESTAMP_SOURCE +typedef enum mtk_camera_metadata_enum_android_sensor_info_timestamp_source { + MTK_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN, + MTK_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME, +} mtk_camera_metadata_enum_android_sensor_info_timestamp_source_t; + +// MTK_SENSOR_INFO_LENS_SHADING_APPLIED +typedef enum mtk_camera_metadata_enum_android_sensor_info_lens_shading_applied { + MTK_SENSOR_INFO_LENS_SHADING_APPLIED_FALSE, + MTK_SENSOR_INFO_LENS_SHADING_APPLIED_TRUE, +} mtk_camera_metadata_enum_android_sensor_info_lens_shading_applied_t; + +// MTK_SENSOR_INFO_SCENARIO_ID +typedef enum mtk_camera_metadata_enum_android_sensor_info_scenario_id { + MTK_SENSOR_INFO_SCENARIO_ID_ZSD, + MTK_SENSOR_INFO_SCENARIO_ID_NORMAL_PREVIEW, + MTK_SENSOR_INFO_SCENARIO_ID_NORMAL_CAPTURE, + MTK_SENSOR_INFO_SCENARIO_ID_NORMAL_VIDEO, + /************************************************************************** + * All unnamed scenario id for a specific sensor must be started with + * values >= MTK_SENSOR_INFO_SCENARIO_ID_UNNAMED_START. + **************************************************************************/ + MTK_SENSOR_INFO_SCENARIO_ID_UNNAMED_START = 0x100, +} mtk_camera_metadata_enum_android_sensor_info_scenario_id_t; + +// MTK_SHADING_MODE +typedef enum mtk_camera_metadata_enum_android_shading_mode { + MTK_SHADING_MODE_OFF, + MTK_SHADING_MODE_FAST, + MTK_SHADING_MODE_HIGH_QUALITY, +} mtk_camera_metadata_enum_android_shading_mode_t; + +// MTK_STATISTICS_FACE_DETECT_MODE +typedef enum mtk_camera_metadata_enum_android_statistics_face_detect_mode { + MTK_STATISTICS_FACE_DETECT_MODE_OFF, + MTK_STATISTICS_FACE_DETECT_MODE_SIMPLE, + MTK_STATISTICS_FACE_DETECT_MODE_FULL, +} mtk_camera_metadata_enum_android_statistics_face_detect_mode_t; + +// MTK_STATISTICS_HISTOGRAM_MODE +typedef enum mtk_camera_metadata_enum_android_statistics_histogram_mode { + MTK_STATISTICS_HISTOGRAM_MODE_OFF, + MTK_STATISTICS_HISTOGRAM_MODE_ON, +} mtk_camera_metadata_enum_android_statistics_histogram_mode_t; + +// MTK_STATISTICS_SHARPNESS_MAP_MODE +typedef enum mtk_camera_metadata_enum_android_statistics_sharpness_map_mode { + MTK_STATISTICS_SHARPNESS_MAP_MODE_OFF, + MTK_STATISTICS_SHARPNESS_MAP_MODE_ON, +} mtk_camera_metadata_enum_android_statistics_sharpness_map_mode_t; + +// MTK_STATISTICS_HOT_PIXEL_MAP_MODE +typedef enum mtk_camera_metadata_enum_android_statistics_hot_pixel_map_mode { + MTK_STATISTICS_HOT_PIXEL_MAP_MODE_OFF, + MTK_STATISTICS_HOT_PIXEL_MAP_MODE_ON, +} mtk_camera_metadata_enum_android_statistics_hot_pixel_map_mode_t; + +// MTK_STATISTICS_SCENE_FLICKER +typedef enum mtk_camera_metadata_enum_android_statistics_scene_flicker { + MTK_STATISTICS_SCENE_FLICKER_NONE, + MTK_STATISTICS_SCENE_FLICKER_50HZ, + MTK_STATISTICS_SCENE_FLICKER_60HZ, +} mtk_camera_metadata_enum_android_statistics_scene_flicker_t; + +// MTK_STATISTICS_LENS_SHADING_MAP_MODE +typedef enum mtk_camera_metadata_enum_android_statistics_lens_shading_map_mode { + MTK_STATISTICS_LENS_SHADING_MAP_MODE_OFF, + MTK_STATISTICS_LENS_SHADING_MAP_MODE_ON, +} mtk_camera_metadata_enum_android_statistics_lens_shading_map_mode_t; + +// MTK_STATISTICS_OIS_DATA_MODE +typedef enum mtk_camera_metadata_enum_android_statistics_ois_data_mode { + MTK_STATISTICS_OIS_DATA_MODE_OFF, + MTK_STATISTICS_OIS_DATA_MODE_ON +} mtk_camera_metadata_enum_android_statistics_ois_data_mode_t; + + + +// MTK_TONEMAP_MODE +typedef enum mtk_camera_metadata_enum_android_tonemap_mode { + MTK_TONEMAP_MODE_CONTRAST_CURVE, + MTK_TONEMAP_MODE_FAST, + MTK_TONEMAP_MODE_HIGH_QUALITY, + MTK_TONEMAP_MODE_GAMMA_VALUE, + MTK_TONEMAP_MODE_PRESET_CURVE, +} mtk_camera_metadata_enum_android_tonemap_mode_t; + +// MTK_TONEMAP_PRESET_CURVE +typedef enum mtk_camera_metadata_enum_android_tonemap_preset_curve { + MTK_TONEMAP_PRESET_CURVE_SRGB, + MTK_TONEMAP_PRESET_CURVE_REC709, +} mtk_camera_metadata_enum_android_tonemap_preset_curve_t; + +// MTK_LED_TRANSMIT +typedef enum mtk_camera_metadata_enum_android_led_transmit { + MTK_LED_TRANSMIT_OFF, + MTK_LED_TRANSMIT_ON, +} mtk_camera_metadata_enum_android_led_transmit_t; + +// MTK_LED_AVAILABLE_LEDS +typedef enum mtk_camera_metadata_enum_android_led_available_leds { + MTK_LED_AVAILABLE_LEDS_TRANSMIT, +} mtk_camera_metadata_enum_android_led_available_leds_t; + +// MTK_INFO_SUPPORTED_HARDWARE_LEVEL +typedef enum mtk_camera_metadata_enum_android_info_supported_hardware_level { + MTK_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED, + MTK_INFO_SUPPORTED_HARDWARE_LEVEL_FULL, + MTK_INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY, + MTK_INFO_SUPPORTED_HARDWARE_LEVEL_3, + MTK_INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL, +} mtk_camera_metadata_enum_android_info_supported_hardware_level_t; + +// MTK_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION +typedef enum mtk_camera_metadata_enum_android_info_supported_buffer_management_version { + MTK_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5, // HIDL v3.4 +} mtk_camera_metadata_enum_android_info_supported_buffer_management_version_t; + +// MTK_BLACK_LEVEL_LOCK +typedef enum mtk_camera_metadata_enum_android_black_level_lock { + MTK_BLACK_LEVEL_LOCK_OFF, + MTK_BLACK_LEVEL_LOCK_ON, +} mtk_camera_metadata_enum_android_black_level_lock_t; + +// MTK_SYNC_FRAME_NUMBER +typedef enum mtk_camera_metadata_enum_android_sync_frame_number { + MTK_SYNC_FRAME_NUMBER_CONVERGING = -1, + MTK_SYNC_FRAME_NUMBER_UNKNOWN = -2, +} mtk_camera_metadata_enum_android_sync_frame_number_t; + +// MTK_SYNC_MAX_LATENCY +typedef enum mtk_camera_metadata_enum_android_sync_max_latency { + MTK_SYNC_MAX_LATENCY_PER_FRAME_CONTROL = 0, + MTK_SYNC_MAX_LATENCY_UNKNOWN = -1, +} mtk_camera_metadata_enum_android_sync_max_latency_t; + +// MTK_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS +typedef enum mtk_camera_metadata_enum_android_depth_available_depth_stream_configurations { + MTK_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT, + MTK_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_INPUT, +} mtk_camera_metadata_enum_android_depth_available_depth_stream_configurations_t; + +// MTK_DEPTH_DEPTH_IS_EXCLUSIVE +typedef enum mtk_camera_metadata_enum_android_depth_depth_is_exclusive { + MTK_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE, + MTK_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE, +} mtk_camera_metadata_enum_android_depth_depth_is_exclusive_t; + +// MTK_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS +typedef enum mtk_camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations { + MTK_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT + , // HIDL v3.4 + MTK_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT + , // HIDL v3.4 +} mtk_camera_metadata_enum_android_depth_available_dynamic_depth_stream_configurations_t; + +// MTK_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE +typedef enum mtk_camera_metadata_enum_android_logic_multi_camera_sensor_sync_type { + MTK_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_APPROXIMATE, + MTK_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED, +} mtk_camera_metadata_enum_android_logic_multi_camera_sensor_sync_type_t; + +// MTK_DISTORTION_CORRECTION_MODE +typedef enum mtk_camera_metadata_enum_android_distortion_correction_mode { + MTK_DISTORTION_CORRECTION_MODE_OFF , // HIDL v3.3 + MTK_DISTORTION_CORRECTION_MODE_FAST , // HIDL v3.3 + MTK_DISTORTION_CORRECTION_MODE_HIGH_QUALITY , // HIDL v3.3 +} mtk_camera_metadata_enum_android_distortion_correction_mode_t; + +// MTK_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS +typedef enum mtk_camera_metadata_enum_android_heic_available_heic_stream_configurations { + MTK_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT , // HIDL v3.4 + MTK_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_INPUT , // HIDL v3.4 +} mtk_camera_metadata_enum_android_heic_available_heic_stream_configurations_t; + +// MTK_HEIC_INFO_SUPPORTED +typedef enum mtk_camera_metadata_enum_android_heic_info_supported { + MTK_HEIC_INFO_SUPPORTED_FALSE , // HIDL v3.4 + MTK_HEIC_INFO_SUPPORTED_TRUE , // HIDL v3.4 +} mtk_camera_metadata_enum_android_heic_info_supported_t; + +// MTK_HAL_VERSION +#define MTKCAM_DEVICE_API_VERSION(maj,min) ((((maj) & 0xff) << 8) | ((min) & 0xff)) +typedef enum mtk_camera_metadata_num_hal_version { + MTK_HAL_VERSION_1_0 = MTKCAM_DEVICE_API_VERSION(1, 0), + MTK_HAL_VERSION_3_0 = MTKCAM_DEVICE_API_VERSION(3, 0), + MTK_HAL_VERSION_3_1 = MTKCAM_DEVICE_API_VERSION(3, 1), + MTK_HAL_VERSION_3_2 = MTKCAM_DEVICE_API_VERSION(3, 2), + MTK_HAL_VERSION_3_3 = MTKCAM_DEVICE_API_VERSION(3, 3), + MTK_HAL_VERSION_3_4 = MTKCAM_DEVICE_API_VERSION(3, 4), + MTK_HAL_VERSION_3_5 = MTKCAM_DEVICE_API_VERSION(3, 5), +} mtk_camera_metadata_num_hal_version_t; + +// MTK GESTURE SHOT FEATURE +typedef enum mtk_camera_metadata_enum_gesture_shot_mode { + MTK_FACE_FEATURE_GESTURE_MODE_OFF = 0, + MTK_FACE_FEATURE_GESTURE_MODE_SIMPLE, +} mtk_camera_metadata_enum_gesture_shot_mode_t; + +// MTK SMILE SHOT FEATURE +typedef enum mtk_camera_metadata_enum_smile_detect_mode { + MTK_FACE_FEATURE_SMILE_DETECT_MODE_OFF = 0, + MTK_FACE_FEATURE_SMILE_DETECT_MODE_SIMPLE, +} mtk_camera_metadata_enum_smile_detect_mode_t; + +// MTK AUTO SCENE DETECTION FEATURE +typedef enum mtk_camera_metadata_enum_asd_mode { + MTK_FACE_FEATURE_ASD_MODE_OFF = 0, + MTK_FACE_FEATURE_ASD_MODE_SIMPLE, + MTK_FACE_FEATURE_ASD_MODE_FULL, +} mtk_camera_metadata_enum_asd_mode_t; + +// MTK 3DNR +typedef enum mtk_camera_metadata_enum_3dnr_mode { + MTK_NR_FEATURE_3DNR_MODE_OFF = 0, + MTK_NR_FEATURE_3DNR_MODE_ON, +} mtk_camera_metadata_enum_3dnr_mode_t; + +// MTK HDR +typedef enum mtk_camera_metadata_enum_hdr_mode { // Need align include/mtkcam/feature/hdrDetection/Defs.h + MTK_HDR_FEATURE_HDR_MODE_OFF = 0, + MTK_HDR_FEATURE_HDR_MODE_ON, + MTK_HDR_FEATURE_HDR_MODE_AUTO, + MTK_HDR_FEATURE_HDR_MODE_VIDEO_ON, + MTK_HDR_FEATURE_HDR_MODE_VIDEO_AUTO, +} mtk_camera_metadata_enum_hdr_mode_t; + +typedef enum mtk_camera_metadata_enum_vhdr_mode { // Need align include/mtkcam/drv/IHalSensor.h + MTK_HDR_FEATURE_VHDR_MODE_OFF = 0, + MTK_HDR_FEATURE_VHDR_MODE_IVHDR = 1, + MTK_HDR_FEATURE_VHDR_MODE_MVHDR = 2, + MTK_HDR_FEATURE_VHDR_MODE_ZVHDR = 9, +} mtk_camera_metadata_enum_vhdr_mode_t; + +typedef enum mtk_camera_metadata_enum_hdr_hal_mode { + MTK_HDR_FEATURE_HDR_HAL_MODE_OFF = 0x0, + MTK_HDR_FEATURE_HDR_HAL_MODE_MVHDR = 0x1, + MTK_HDR_FEATURE_HDR_HAL_MODE_MSTREAM_CAPTURE = 0x2, + MTK_HDR_FEATURE_HDR_HAL_MODE_MSTREAM_PREVIEW = 0x4, + MTK_HDR_FEATURE_HDR_HAL_MODE_MSTREAM_CAPTURE_PREVIEW = ( MTK_HDR_FEATURE_HDR_HAL_MODE_MSTREAM_CAPTURE | + MTK_HDR_FEATURE_HDR_HAL_MODE_MSTREAM_PREVIEW ), + MTK_HDR_FEATURE_HDR_HAL_MODE_STAGGER_2EXP = 0x8, + MTK_HDR_FEATURE_HDR_HAL_MODE_STAGGER_3EXP = 0x10, + MTK_HDR_FEATURE_HDR_HAL_MODE_STAGGER = ( MTK_HDR_FEATURE_HDR_HAL_MODE_STAGGER_2EXP | + MTK_HDR_FEATURE_HDR_HAL_MODE_STAGGER_3EXP ), +} mtk_camera_metadata_enum_multi_exposure_hdr_mode_t; + +typedef enum mtk_camera_metadata_enum_single_frame_hdr { + MTK_HDR_FEATURE_SINGLE_FRAME_HDR_NOT_SUPPORTED = 0, + MTK_HDR_FEATURE_SINGLE_FRAME_HDR_SUPPORTED = 1, +} mtk_camera_metadata_enum_single_frame_hdr_t; + +// MTK_STREAMING_FEATURE_HDR10 +typedef enum mtk_camera_metadata_enum_hdr10 { + MTK_STREAMING_FEATURE_HDR10_OFF = 0, + MTK_STREAMING_FEATURE_HDR10_ON, +} mtk_camera_metadata_enum_hdr10_t; + +// MTK_STEREO_FEATURE_STATE +typedef enum mtk_camera_metadata_enum_stereo_feature_status { + MTK_STEREO_FEATURE_STATUS_OFF = 0, + MTK_STEREO_FEATURE_STATUS_PREVIEW, + MTK_STEREO_FEATURE_STATUS_CAPTURE, + MTK_STEREO_FEATURE_STATUS_RECORD, +} mtk_camera_metadata_enum_stereo_feature_status_t; + +// MTK MFB +typedef enum mtk_camera_metadata_enum_mfnr_mfb { + MTK_MFNR_FEATURE_MFB_OFF = 0, + MTK_MFNR_FEATURE_MFB_MFLL, + MTK_MFNR_FEATURE_MFB_AIS, + MTK_MFNR_FEATURE_MFB_AUTO = 0xFF, +} mtk_camera_metadata_enum_mfnr_mfb_t; + +// MTK MFNR AIS +typedef enum mtk_camera_metadata_enum_mfnr_ais { + MTK_MFNR_FEATURE_AIS_OFF = 0, + MTK_MFNR_FEATURE_AIS_ON, +} mtk_camera_metadata_enum_mfnr_ais_t; + +// MTK CShot +typedef enum mtk_camera_metadata_enum_cshot_mode { + MTK_CSHOT_FEATURE_AVAILABLE_MODE_OFF = 0, + MTK_CSHOT_FEATURE_AVAILABLE_MODE_ON, +} mtk_camera_metadata_enum_cshot_mode_t; + +typedef enum mtk_camera_metadata_enum_cshot_capture { + MTK_CSHOT_FEATURE_CAPTURE_OFF = 0, + MTK_CSHOT_FEATURE_CAPTURE_ON, +} mtk_camera_metadata_enum_cshot_capture_t; + + +//postview +typedef enum mtk_camera_metadata_enum_control_capture_available_postview_modes { + MTK_CONTROL_CAPTURE_POSTVIEW_MODE_OFF = 0, + MTK_CONTROL_CAPTURE_POSTVIEW_MODE_ON, +} mtk_camera_metadata_enum_control_capture_available_postview_modes; + +typedef enum mtk_camera_metadata_enum_control_capture_postview_size { + MTK_CONTROL_CAPTURE_POSTVIEW_SIZE_WIDTH = 0, + MTK_CONTROL_CAPTURE_POSTVIEW_SIZE_HEIGHT = 0, +} mtk_camera_metadata_enum_control_capture_postview_size; + +//p2done callback +typedef enum mtk_camera_metadata_enum_control_capture_early_notification_support { + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_SUPPORT_OFF = 0, + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_SUPPORT_ON, +} mtk_camera_metadata_enum_control_capture_early_notification_support; + +typedef enum mtk_camera_metadata_enum_control_capture_early_notification_trigger { + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_TRIGGER_OFF = 0, + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_TRIGGER_ON, +} mtk_camera_metadata_enum_control_capture_early_notification_trigger; + +typedef enum mtk_camera_metadata_enum_control_capture_early_next_ready { + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_NOT_READY = 0, + MTK_CONTROL_CAPTURE_EARLY_NOTIFICATION_READY, +} mtk_camera_metadata_enum_control_capture_early_next_ready; + +// raw reprocess hint +typedef enum mtk_camera_metadata_enum_control_capture_hint_for_raw_reprocess { + MTK_CONTROL_CAPTURE_HINT_FOR_RAW_REPROCESS_FALSE = 0, + MTK_CONTROL_CAPTURE_HINT_FOR_RAW_REPROCESS_TRUE, +} mtk_camera_metadata_enum_control_capture_hint_for_raw_reprocess; + +// raw reprocess hint +typedef enum mtk_camera_metadata_enum_control_capture_hint_for_isp_tuning { + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_DEFAULT_NONE = 0, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_MFNR, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_AINR, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_YUV_REPROCESS, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_AIHDR, + // Above only for MTK turn key feautre usage + + // MUST add customer hint as below. (reserved for customer features' hint) + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_FOR_3RD_PARTY = 5000, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_CUSTOMER_YUV_HDR, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_CUSTOMER_RAW_HDR, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_CUSTOMER_SUPER_NIGHT, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_CUSTOMER_SUPER_RESOLUTION, + MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_END, +} mtk_camera_metadata_enum_control_capture_hint_for_isp_tuning; + +// Jpeg flip +typedef enum mtk_camera_metadata_enum_control_capture_jpeg_flip_mode { + MTK_CONTROL_CAPTURE_JPEG_FLIP_MODE_OFF = 0, + MTK_CONTROL_CAPTURE_JPEG_FLIP_MODE_ON, +} mtk_camera_metadata_enum_control_capture_jpeg_flip_mode; + +// zsl +typedef enum mtk_camera_metadata_enum_control_capture_zsl_mode { + MTK_CONTROL_CAPTURE_ZSL_MODE_OFF = 0, + MTK_CONTROL_CAPTURE_ZSL_MODE_ON, +} mtk_camera_metadata_enum_control_capture_zsl_mode; + +// isp tuning +typedef enum mtk_camera_metadata_enum_control_capture_tuning_request { + MTK_CONTROL_CAPTURE_ISP_TUNING_REQ_RAW = 0x1, + MTK_CONTROL_CAPTURE_ISP_TUNING_REQ_YUV = 0x2, +} mtk_camera_metadata_enum_control_capture_tuning_request; + +//packed raw +typedef enum mtk_camera_metadata_enum_control_capture_packed_raw_support { + MTK_CONTROL_CAPTURE_PACKED_RAW_SUPPORT_OFF = 0, + MTK_CONTROL_CAPTURE_PACKED_RAW_SUPPORT_ON, +} mtk_camera_metadata_enum_control_capture_packed_raw_support; + +//bgservice +typedef enum mtk_camera_metadata_enum_bgservice_prerelease_availablemode { + MTK_BGSERVICE_FEATURE_PRERELEASE_MODE_OFF = 0, + MTK_BGSERVICE_FEATURE_PRERELEASE_MODE_ON, +} mtk_camera_metadata_enum_bgservice_prerelease_availablemode; + +typedef enum mtk_camera_metadata_enum_bgservice_prerelease { + MTK_BGSERVICE_FEATURE_PRERELEASE_OFF = 0, + MTK_BGSERVICE_FEATURE_PRERELEASE_ON, +} mtk_camera_metadata_enum_bgservice_prerelease; + +// MTK EIS +typedef enum mtk_camera_metadata_enum_eis_mode { + MTK_EIS_FEATURE_EIS_MODE_OFF = 0, + MTK_EIS_FEATURE_EIS_MODE_ON = 1, +} mtk_camera_metadata_enum_eis_mode_t; + +typedef enum mtk_camera_metadata_enum_preview_eis { + MTK_EIS_FEATURE_PREVIEW_EIS_OFF = 0, + MTK_EIS_FEATURE_PREVIEW_EIS_ON = 1, +} mtk_camera_metadata_enum_preview_eis_t; + +typedef enum mtk_camera_metadata_enum_record_state { + // STATE_PREVIEW : It can be video preview or recording stop state, decided by has encode buffer or not + MTK_STREAMING_FEATURE_RECORD_STATE_PREVIEW = 0, + MTK_STREAMING_FEATURE_RECORD_STATE_RECORD, +} mtk_camera_metadata_enum_record_state_t; + +typedef enum mtk_camera_metadata_enum_streaming_hfps_mode { + MTK_STREAMING_FEATURE_HFPS_MODE_NORMAL = 0, + MTK_STREAMING_FEATURE_HFPS_MODE_60FPS, +} mtk_camera_metadata_enum_streaming_hfps_mode_t; + +typedef enum mtk_camera_metadata_enum_streaming_crop_outer_lines_enable { + MTK_STREAMING_FEATURE_CROP_OUTER_LINES_OFF = 0, + MTK_STREAMING_FEATURE_CROP_OUTER_LINES_ON, +} mtk_camera_metadata_enum_streaming_crop_outer_lines_enable_t; + +// MTK_VSDOF_FEATURE_DENOISE_MODE +typedef enum mtk_camera_metadata_enum_vsdof_feature_denoise_mode { + MTK_VSDOF_FEATURE_DENOISE_OFF = 0, + MTK_VSDOF_FEATURE_DENOISE_ON, +} mtk_camera_metadata_enum_vsdof_feature_denoise_mode_t; + +// MTK_VSDOF_FEATURE_3RDPARTY_MODE +typedef enum mtk_camera_metadata_enum_vsdof_feature_3rdparty_mode { + MTK_VSDOF_FEATURE_3RDPARTY_OFF = 0, + MTK_VSDOF_FEATURE_3RDPARTY_ON, +} mtk_camera_metadata_enum_vsdof_feature_3rdparty_mode_t; + +//MTK_VSDOF_FEATURE_PREVIEW_ENABLE +typedef enum mtk_camera_metadata_enum_vsdof_feature_preview_enable { + MTK_VSDOF_FEATURE_PREVIEW_OFF = 0, + MTK_VSDOF_FEATURE_PREVIEW_ON, +} mtk_camera_metadata_enum_vsdof_feature_preview_enable_t; + +//MTK_LOGICALMULTICAMERA_SENSOR_SYNC_TYPE +typedef enum mtk_camera_metadata_enum_android_logicalmulticamera_sensor_sync_type { + MTK_LOGICALMULTICAMERA_SENSOR_SYNC_TYPE_APPROXIMATE, + MTK_LOGICALMULTICAMERA_SENSOR_SYNC_TYPE_CALIBRATED, +} mtk_camera_metadata_enum_android_logicalmulticamera_sensor_sync_type_t; + +//MTK_MULTI_CAM_FEATURE +typedef enum mtk_camera_metadata_enum_multi_cam_mode { + MTK_MULTI_CAM_FEATURE_MODE_ZOOM = 0, + MTK_MULTI_CAM_FEATURE_MODE_VSDOF, + MTK_MULTI_CAM_FEATURE_MODE_DENOISE, +} mtk_camera_metadata_enum_multi_cam_mode_t; + +//MTK_MULTI_CAM_FEATURE_PREVIEW_MODE +typedef enum mtk_camera_metadata_enum_vsdof_feature_preview_mode { + MTK_VSDOF_FEATURE_PREVIEW_MODE_FULL = 0, + MTK_VSDOF_FEATURE_PREVIEW_MODE_HALF, +} mtk_camera_metadata_enum_stereo_vsdof_preview_mode; + +//MTK_CONTROL_CAPTURE_SINGLE_YUV_NR_MODE +typedef enum mtk_camera_metadata_enum_single_yuvnr_mode { + MTK_CONTROL_CAPTURE_SINGLE_YUV_NR_MODE_OFF = 0, + MTK_CONTROL_CAPTURE_SINGLE_YUV_NR_MODE_ON, +} mtk_camera_metadata_enum_single_yuvnr_mode_t; + +//MTK_CONTROL_CAPTURE_INSENSORZOOM_MODE +typedef enum mtk_camera_metadata_enum_insensorzoom_mode { + MTK_CONTROL_CAPTURE_INSENSORZOOM_MODE_OFF = 0, + MTK_CONTROL_CAPTURE_INSENSORZOOM_MODE_ON, +} mtk_camera_metadata_enum_insensorzoom_mode_t; +//MTK_SINGLEHW_SETTING_MODULE +typedef enum mtk_camera_metadata_enum_singlehw_module { + MTK_SINGLEHW_SETTING_MODULE_NONE = 0, + MTK_SINGLEHW_SETTING_MODULE_MDP, + MTK_SINGLEHW_SETTING_MODULE_WPE, +} mtk_camera_metadata_enum_singlehw_module_t; + +//MTK_SINGLEHW_SETTING_TRANSFORM +typedef enum mtk_camera_metadata_enum_singlehw_transform { + MTK_SINGLEHW_SETTING_TRANSFORM_NONE = 0, + MTK_SINGLEHW_SETTING_TRANSFORM_FLIP_H, + MTK_SINGLEHW_SETTING_TRANSFORM_FLIP_V, + MTK_SINGLEHW_SETTING_TRANSFORM_ROT_90, + MTK_SINGLEHW_SETTING_TRANSFORM_ROT_180, + MTK_SINGLEHW_SETTING_TRANSFORM_ROT_270, + MTK_SINGLEHW_SETTING_TRANSFORM_ROT_90_FLIP_H, + MTK_SINGLEHW_SETTING_TRANSFORM_ROT_90_FLIP_V, +} mtk_camera_metadata_enum_singlehw_transform_t; + +//MTK_ABF_FEATURE_ABF_MODE +typedef enum mtk_camera_metadata_enum_afb { + MTK_ABF_FEATURE_ABF_OFF = 0, + MTK_ABF_FEATURE_ABF_ON, +} mtk_camera_metadata_enum_afb_t; + +#endif diff --git a/app/src/main/cpp/camera2/mtk_platform_metadata_tag.h b/app/src/main/cpp/camera2/mtk_platform_metadata_tag.h new file mode 100644 index 00000000..4d0ab352 --- /dev/null +++ b/app/src/main/cpp/camera2/mtk_platform_metadata_tag.h @@ -0,0 +1,724 @@ +/* Copyright Statement: + * + * This software/firmware and related documentation ("MediaTek Software") are + * protected under relevant copyright laws. The information contained herein is + * confidential and proprietary to MediaTek Inc. and/or its licensors. Without + * the prior written permission of MediaTek inc. and/or its licensors, any + * reproduction, modification, use or disclosure of MediaTek Software, and + * information contained herein, in whole or in part, shall be strictly + * prohibited. + * + * MediaTek Inc. (C) 2010. All rights reserved. + * + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER + * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL + * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH + * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, + * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES + * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. + * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO + * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK + * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE + * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S + * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE + * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE + * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE + * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. + * + * The following software/firmware and/or related documentation ("MediaTek + * Software") have been modified by MediaTek Inc. All revisions are subject to + * any receiver's applicable license agreements with MediaTek Inc. + */ + +#ifndef _MTK_HARDWARE_MTKCAM_INCLUDE_MTKCAM_UTILS_METADATA_HAL_MTKPLATFORMMETADATATAG_H_ +#define _MTK_HARDWARE_MTKCAM_INCLUDE_MTKCAM_UTILS_METADATA_HAL_MTKPLATFORMMETADATATAG_H_ + +/****************************************************************************** + * + ******************************************************************************/ +typedef enum mtk_platform_metadata_section { + MTK_HAL_REQUEST = 0xC000, // MTK HAL internal metadata become from 0xC000 0000 + MTK_P1NODE, + MTK_P2NODE, + MTK_3A_TUNINING, + MTK_3A_EXIF, + MTK_MF_EXIF, + MTK_EIS, + MTK_STEREO, + MTK_FRAMESYNC, + MTK_VHDR, + MTK_PIPELINE, + MTK_NR, + MTK_PLUGIN, + MTK_DUALZOOM, + MTK_FEATUREPIPE, + MTK_POSTPROC, + MTK_FEATURE, + MTK_FSC, +} mtk_platform_metadata_section_t; + + +/****************************************************************************** + * + ******************************************************************************/ +typedef enum mtk_platform_metadata_section_start { + MTK_HAL_REQUEST_START = MTK_HAL_REQUEST << 16, + MTK_P1NODE_START = MTK_P1NODE << 16, + MTK_P2NODE_START = MTK_P2NODE << 16, + MTK_3A_TUNINING_START = MTK_3A_TUNINING << 16, + MTK_3A_EXIF_START = MTK_3A_EXIF << 16, + MTK_EIS_START = MTK_EIS << 16, + MTK_STEREO_START = MTK_STEREO << 16, + MTK_FRAMESYNC_START = MTK_FRAMESYNC << 16, + MTK_VHDR_START = MTK_VHDR << 16, + MTK_PIPELINE_START = MTK_PIPELINE << 16, + MTK_NR_START = MTK_NR << 16, + MTK_PLUGIN_START = MTK_PLUGIN << 16, + MTK_DUALZOOM_START = MTK_DUALZOOM << 16, + MTK_FEATUREPIPE_START = MTK_FEATUREPIPE << 16, + MTK_POSTPROC_START = MTK_POSTPROC << 16, + MTK_FEATURE_START = MTK_FEATURE << 16, + MTK_FSC_START = MTK_FSC << 16, +} mtk_platform_metadata_section_start_t; + + +/****************************************************************************** + * + ******************************************************************************/ +typedef enum mtk_platform_metadata_tag { + MTK_HAL_REQUEST_REQUIRE_EXIF = MTK_HAL_REQUEST_START, //MUINT8 + MTK_HAL_REQUEST_DUMP_EXIF, //MUINT8 + MTK_HAL_REQUEST_REPEAT, //MUINT8 + MTK_HAL_REQUEST_DUMMY, //MUINT8 + MTK_HAL_REQUEST_SENSOR_SIZE, //MSize + MTK_HAL_REQUEST_SENSOR_ID, //MINT32 + MTK_HAL_REQUEST_DEVICE_ID, //MINT32 + MTK_HAL_REQUEST_HIGH_QUALITY_CAP, //MUINT8 + MTK_HAL_REQUEST_ISO_SPEED, //MINT32 + MTK_HAL_REQUEST_BRIGHTNESS_MODE, //MINT32 + MTK_HAL_REQUEST_CONTRAST_MODE, //MINT32 + MTK_HAL_REQUEST_HUE_MODE, //MINT32 + MTK_HAL_REQUEST_SATURATION_MODE, //MINT32 + MTK_HAL_REQUEST_EDGE_MODE, //MINT32 + MTK_HAL_REQUEST_PASS1_DISABLE, //MINT32 + MTK_HAL_REQUEST_ERROR_FRAME, // used for error handling //MUINT8 + MTK_HAL_REQUEST_PRECAPTURE_START, // 4cell //MUINT8 + MTK_HAL_REQUEST_AF_TRIGGER_START, // 4cell //MUINT8 + MTK_HAL_REQUEST_IMG_IMGO_FORMAT, //MINT32 + MTK_HAL_REQUEST_IMG_RRZO_FORMAT, //MINT32 + MTK_HAL_REQUEST_INDEX, //MINT32 + MTK_HAL_REQUEST_COUNT, //MINT32 + MTK_HAL_REQUEST_SMVR_FPS, //MUINT8 // 0: NOT batch request + MTK_HAL_REQUEST_REMOSAIC_ENABLE, //MUINT8 // 0: preview mode 1: capture mode + MTK_HAL_REQUEST_INDEX_BSS, //MINT32 + MTK_HAL_REQUEST_ZSD_CAPTURE_INTENT, //MUINT8 + MTK_HAL_REQUEST_REAL_CAPTURE_SIZE, //MSize + MTK_HAL_REQUEST_VIDEO_SIZE, //MSize + MTK_HAL_REQUEST_RAW_IMAGE_INFO, //MINT32 // index[0]: raw fmt, index[1]: raw stride, index[2]: raw size(width), index[3]: raw size(height) + MTK_HAL_REQUEST_ISP_PIPELINE_MODE, //MINT32 + MTK_P1NODE_SCALAR_CROP_REGION = MTK_P1NODE_START, //MRect + MTK_P1NODE_BIN_CROP_REGION, //MRect + MTK_P1NODE_DMA_CROP_REGION, //MRect + MTK_P1NODE_BIN_SIZE, //MSize + MTK_P1NODE_RESIZER_SIZE, //MSize + MTK_P1NODE_RESIZER_SET_SIZE, //MSize + MTK_P1NODE_CTRL_RESIZE_FLUSH, //MBOOL + MTK_P1NODE_CTRL_READOUT_FLUSH, //MBOOL + MTK_P1NODE_CTRL_RECONFIG_SENSOR_SETTING, //MBOOL + MTK_P1NODE_PROCESSOR_MAGICNUM, //MINT32 + MTK_P1NODE_MIN_FRM_DURATION, //MINT64 + MTK_P1NODE_RAW_TYPE, //MINT32 + MTK_P1NODE_SENSOR_CROP_REGION, //MRect + MTK_P1NODE_YUV_RESIZER1_CROP_REGION, //MRect + MTK_P1NODE_YUV_RESIZER2_CROP_REGION, //MRect + MTK_P1NODE_YUV_RESIZER1_SIZE, //MSize + MTK_P1NODE_SENSOR_MODE, //MINT32 + MTK_P1NODE_SENSOR_VHDR_MODE, //MINT32 + MTK_P1NODE_METADATA_TAG_INDEX, //MINT32 + MTK_P1NODE_RSS_SIZE, //MSize + MTK_P1NODE_SENSOR_STATUS, //MINT32 + MTK_P1NODE_SENSOR_RAW_ORDER, //MINT32 + MTK_P1NODE_TWIN_SWITCH, //MINT32 + MTK_P1NODE_TWIN_STATUS, //MINT32 + MTK_P1NODE_RESIZE_QUALITY_SWITCH, //MINT32 + MTK_P1NODE_RESIZE_QUALITY_STATUS, //MINT32 + MTK_P1NODE_RESIZE_QUALITY_LEVEL, //MINT32 + MTK_P1NODE_RESIZE_QUALITY_SWITCHING, //MBOOL + MTK_P1NODE_RESUME_SHUTTER_TIME_US, //MINT32 + MTK_P1NODE_FRAME_START_TIMESTAMP, //MINT64 + MTK_P1NODE_FRAME_START_TIMESTAMP_BOOT, //MINT64 + MTK_P1NODE_REQUEST_PROCESSED_WITHOUT_WB, //MBOOL + MTK_P1NODE_ISNEED_GMV, //MBOOL + MTK_P2NODE_HIGH_SPEED_VDO_FPS = MTK_P2NODE_START, //MINT32 + MTK_P2NODE_HIGH_SPEED_VDO_SIZE, //MSize + MTK_P2NODE_CTRL_CALTM_ENABLE, //MBOOL + MTK_P2NODE_FD_CROP_REGION, //MRect + MTK_P2NODE_CROP_REGION, //MRect // for removing black edge + MTK_P2NODE_DSDN_ENABLE, //MBOOL // for DSDN on/off controled by Policy + MTK_P2NODE_SENSOR_CROP_REGION, //MRect + MTK_3A_AE_HIGH_ISO_BINNING, //MBOOL // for 3HDR high iso binning mode + MTK_SENSOR_SCALER_CROP_REGION, //MRect + MTK_PROCESSOR_CAMINFO = MTK_3A_TUNINING_START, //IMemory + MTK_ISP_ATMS_MAPPING_INFO, //IMemory + MTK_3A_ISP_PROFILE, //MUINT8 + MTK_3A_ISP_P1_PROFILE, //MUINT8 + MTK_CAMINFO_LCSOUT_INFO, //IMemory + MTK_3A_ISP_BYPASS_LCE, //MBOOL + MTK_3A_ISP_DISABLE_NR, //MBOOL + MTK_3A_ISP_NR3D_SW_PARAMS, //MINT32[14] //GMVX, GMVY, confX, confY, MAX_GMV, frameReset, GMV_Status,ISO_cutoff + MTK_3A_ISP_NR3D_HW_PARAMS, //IMemory + MTK_3A_ISP_LCE_GAIN, //MINT32, bits[0:15]: LCE gain, bits[16:31]: LCE gain confidence ratio (0-100) + MTK_3A_ISP_FUS_NUM, //MINT32 + MTK_3A_AE_CAP_PARAM, //IMemory + MTK_3A_AE_CAP_SINGLE_FRAME_HDR, //MUINT8 + MTK_3A_AE_BV_TRIGGER, //MBOOL + MTK_3A_AF_LENS_POSITION, //MINT32 + MTK_3A_FLICKER_RESULT, //MINT32 + MTK_3A_DUMMY_BEFORE_REQUEST_FRAME, //MBOOL // Dummy frame before capture, only for capture intent, preview don't use + MTK_3A_DUMMY_AFTER_REQUEST_FRAME, //MBOOL // Dummy frame after capture, only for capture intent, preview don't use + MTK_3A_MANUAL_AWB_COLORTEMPERATURE_MAX, //MINT32 + MTK_3A_MANUAL_AWB_COLORTEMPERATURE_MIN, //MINT32 + MTK_3A_MANUAL_AWB_COLORTEMPERATURE, //MINT32 + MTK_3A_HDR_MODE, //MUINT8 + MTK_3A_AE_HDR_MIXED_ISO, //MUINT32 + MTK_3A_AE_ZSL_STABLE, //MINT32 ( MBOOL ) + MTK_3A_PGN_ENABLE, //MUINT8 + MTK_3A_SKIP_HIGH_QUALITY_CAPTURE, //MUINT8 + MTK_3A_AI_SHUTTER, //MBOOL + MTK_3A_FEATURE_AE_EXPOSURE_LEVEL, //MINT32 + MTK_3A_FEATURE_AE_TARGET_MODE, //MINT32 + MTK_3A_OPEN_ID, //MINT32 + MTK_LSC_TBL_DATA, //IMemory + MTK_LSC_TSF_DATA, //IMemory + MTK_LSC_TSF_DUMP_NO, //IMemory + MTK_ISP_P2_ORIGINAL_SIZE, //MSize + MTK_ISP_P2_CROP_REGION, //MRect + MTK_ISP_P2_RESIZER_SIZE, //MSize + MTK_ISP_P2_IN_IMG_FMT, //MINT32, 0 or not exist: RAW->YUV, 1: YUV->YUV + MTK_ISP_P2_TUNING_UPDATE_MODE, //MUINT8, [0 or not exist]: as default; [1]: keep existed parameters but some parts will be updated; [2]: keep all existed parameters (force mode) [3] LPCNR Pass1 [4] LPCNR Pass2 + MTK_ISP_P2_IN_IMG_RES_REVISED, //MINT32, describes P2 input image revised resolution. bit[0:15] width in pixel, bit[16:31] height in pixel. May be not exist. + MTK_ISP_APP_TARGET_SIZE, //MINT32, describes APP Target resolution. bit[0:15] width in pixel, bit[16:31] height in pixel. May be not exist. + MTK_MSF_SCALE_INDEX, //MINT32, which scale stage index, would only exist with scaling flow + MTK_MSF_FRAME_NUM, //MINT32, After BSS which frame number is this stage using + MTK_TOTAL_MULTI_FRAME_NUM, //MINT32, MSYUV fuction used this input to know frame nunber + MTK_TOTAL_MULTI_FRAME_NUM_CAPTURED, //MINT32, MSF function used + MTK_SW_DSDN_VERSION, //MINT32, distinguish different dsdn version + MTK_ISP_COLOR_SPACE, //MINT32 + MTK_ISP_DRC_CURVE, //IMemory + MTK_ISP_DRC_CURVE_SIZE, //MINT32 + MTK_ISP_FEO_DATA, //IMemory + MTK_ISP_FEO_ENABLE, //MINT32 + MTK_ISP_FEO_INFO, //IMemory + MTK_ISP_HLR_RATIO, //MINT32, which is a HDR ratio applied in HLR + MTK_ISP_STAGE, //MINT32 + MTK_FOCUS_AREA_POSITION, //MINT32 + MTK_FOCUS_AREA_SIZE, //MSize + MTK_FOCUS_AREA_RESULT, //MUINT8 + MTK_FOCUS_PAUSE, //MUINT8 + MTK_FOCUS_MZ_ON, //MUINT8 + MTK_3A_AF_FOCUS_VALUE, //MINT64 + MTK_3A_PRV_CROP_REGION, //MRect + MTK_3A_ISP_MDP_TARGET_SIZE, //MSize + MTK_3A_REPEAT_RESULT, //MUINT8 + MTK_3A_SKIP_PRECAPTURE, //MBOOL //if CUST_ENABLE_FLASH_DURING_TOUCH is true, MW can skip precapture + MTK_3A_SKIP_BAD_FRAME, //MBOOL + MTK_3A_FLARE_IN_MANUAL_CTRL_ENABLE, //MBOOL + MTK_3A_DYNAMIC_SUBSAMPLE_COUNT, //MINT32 30fps = 1, 60fps = 2, ... , 120fps = 4 + MTK_3A_AE_LV_VALUE, //MINT32 + MTK_APP_CONTROL, //MINT32 + MTK_3A_CUST_PARAMS, //IMemory + MTK_3A_SETTING_CUST_PARAMS, //IMemory + MTK_3A_PERFRAME_INFO, //IMemory + MTK_SENSOR_MODE_INFO_ACTIVE_ARRAY_CROP_REGION, //MRect + MTK_3A_AE_BV, //MINT32 + MTK_3A_AE_CWV, //MINT32 + MTK_ISP_P2_PROCESSED_RAW, //MINT32 + MTK_3A_EXIF_METADATA = MTK_3A_EXIF_START, //IMetadata + MTK_EIS_REGION = MTK_EIS_START, //MINT32 + MTK_EIS_INFO, //MINT64 + MTK_EIS_VIDEO_SIZE, //MRect + MTK_EIS_NEED_OVERRIDE_TIMESTAMP, //MBOOL + MTK_EIS_LMV_DATA, //IMemory + MTK_STEREO_JPS_MAIN1_CROP = MTK_STEREO_START, //MRect + MTK_STEREO_JPS_MAIN2_CROP, //MRect + MTK_STEREO_SYNC2A_MODE, //MINT32 + MTK_STEREO_SYNCAF_MODE, //MINT32 + MTK_STEREO_HW_FRM_SYNC_MODE, //MINT32 + MTK_STEREO_NOTIFY, //MINT32 + MTK_STEREO_SYNC2A_MASTER_SLAVE, //MINT32[2] + MTK_STEREO_SYNC2A_STATUS, //IMemory + MTK_JPG_ENCODE_TYPE, //MINT8 + MTK_CONVERGENCE_DEPTH_OFFSET, //MFLOAT + MTK_N3D_WARPING_MATRIX_SIZE, //MUINT32 + MTK_P1NODE_MAIN2_HAL_META, //IMetadata + MTK_P2NODE_BOKEH_ISP_PROFILE, //MUINT8 + MTK_STEREO_FEATURE_DENOISE_MODE, //MINT32 + MTK_STEREO_FEATURE_SENSOR_PROFILE, //MINT32 + MTK_P1NODE_MAIN2_APP_META, //IMetadata + MTK_STEREO_FEATURE_OPEN_ID, //MINT32 + MTK_STEREO_FRAME_PER_CAPTURE, //MINT32 + MTK_STEREO_ENABLE_MFB, //MINT32 + MTK_STEREO_BSS_RESULT, //MINT32 + MTK_STEREO_FEATURE_FOV_CROP_REGION, //MINT32[6] // p.x, p.y, p.w, p.h, srcW, srcH + MTK_STEREO_DCMF_FEATURE_MODE, //MINT32 // mtk_platform_metadata_enum_dcmf_feature_mode + MTK_STEREO_HDR_EV, //MINT32 + MTK_STEREO_DELAY_FRAME_COUNT, //MINT32 + MTK_STEREO_DCMF_DEPTHMAP_SIZE, //MSize + MTK_STEREO_WITH_CAMSV, //MBOOL + MTK_FRAMESYNC_ID = MTK_FRAMESYNC_START, //MINT32 + MTK_FRAMESYNC_TOLERANCE, //MINT64 + MTK_FRAMESYNC_FAILHANDLE, //MINT32 + MTK_FRAMESYNC_RESULT, //MINT64 + MTK_FRAMESYNC_TYPE, //MINT32 + MTK_FRAMESYNC_MODE, //MUINT8 + MTK_VHDR_LCEI_DATA = MTK_VHDR_START, //Memory + MTK_VHDR_IMGO_3A_ISP_PROFILE, //MUINT8 + MTK_HDR_FEATURE_HDR_HAL_MODE, + MTK_3A_FEATURE_AE_VALID_EXPOSURE_NUM, + MTK_VHDR_MULTIFRAME_TIMESTAMP, //MINT64 + MTK_VHDR_MULTIFRAME_EXPOSURE_TIME, //MINT64 + MTK_PIPELINE_UNIQUE_KEY = MTK_PIPELINE_START, //MINT32 + MTK_PIPELINE_FRAME_NUMBER, //MINT32 + MTK_PIPELINE_REQUEST_NUMBER, //MINT32 + MTK_PIPELINE_EV_VALUE, //MINT32 + MTK_PIPELINE_DUMP_UNIQUE_KEY, //MINT32 + MTK_PIPELINE_DUMP_FRAME_NUMBER, //MINT32 + MTK_PIPELINE_DUMP_REQUEST_NUMBER, //MINT32 + MTK_PIPELINE_VIDEO_RECORD, //MINT32 + MTK_NR_MODE = MTK_NR_START, //MINT32 + MTK_NR_MNR_THRESHOLD_ISO, //MINT32 + MTK_NR_SWNR_THRESHOLD_ISO, //MINT32 + MTK_REAL_LV, //MINT32 + MTK_ANALOG_GAIN, //MUINT32 + MTK_AWB_RGAIN, //MINT32 + MTK_AWB_GGAIN, //MINT32 + MTK_AWB_BGAIN, //MINT32 + MTK_PLUGIN_MODE = MTK_PLUGIN_START, //MINT64 + MTK_PLUGIN_COMBINATION_KEY, //MINT64 + MTK_PLUGIN_P2_COMBINATION, //MINT64 + MTK_PLUGIN_PROCESSED_FRAME_COUNT, //MINT32 + MTK_PLUGIN_CUSTOM_HINT, //MINT32 + MTK_PLUGIN_DETACT_JOB_SYNC_TOKEN, //MINT64, may be not exists. + MTK_PLUGIN_UNIQUEKEY, + MTK_DUALZOOM_DROP_REQ = MTK_DUALZOOM_START, //MINT32 + MTK_DUALZOOM_FORCE_ENABLE_P2, //MINT32 + MTK_DUALZOOM_DO_FRAME_SYNC, //MINT32 + MTK_DUALZOOM_ZOOM_FACTOR, //MINT32 + MTK_DUALZOOM_DO_FOV, //MINT32 + MTK_DUALZOOM_FOV_RECT_INFO, //MINT32 + MTK_DUALZOOM_FOV_CALB_INFO, //MINT32 + MTK_DUALZOOM_FOV_MARGIN_PIXEL, //MSize + MTK_DUALCAM_AF_STATE, //MUINT8 + MTK_DUALCAM_LENS_STATE, //MUINT8 + MTK_DUALCAM_TIMESTAMP, //MINT64 + MTK_DUALZOOM_3DNR_MODE, //MINT32 + MTK_DUALZOOM_ZOOMRATIO, //MINT32 + MTK_DUALZOOM_CENTER_SHIFT, //MINT32 + MTK_DUALZOOM_FOV_RATIO, //MFLOAT + MTK_DUALZOOM_REAL_MASTER, //MINT32 + MTK_DUALZOOM_FD_TARGET_MASTER, //MINT32 + MTK_DUALZOOM_FD_REAL_MASTER, //MINT32 // maybe not set + MTK_LMV_SEND_SWITCH_OUT, //MINT32 + MTK_LMV_SWITCH_OUT_RESULT, //MINT32 + MTK_LMV_VALIDITY, //MINT32 + MTK_VSDOF_P1_MAIN1_ISO, //MINT32 + MTK_DUALZOOM_IS_STANDBY, //MBOOL + MTK_DUALZOOM_CAP_CROP, //MRect + MTK_DUALZOOM_MASTER_UPDATE_MODE, //MBOOL + MTK_DUALZOOM_STREAMING_NR, //MINT32 + MTK_FEATUREPIPE_APP_MODE = MTK_FEATUREPIPE_START, //MINT32 + MTK_POSTPROC_TYPE = MTK_POSTPROC_START, //MINT32 + MTK_FEATURE_STREAMING = MTK_FEATURE_START, //MINT64 + MTK_FEATURE_CAPTURE, //MINT64 + MTK_FEATURE_CAPTURE_PHYSICAL, //MINT64 + MTK_FEATURE_FREE_MEMORY_MBYTE, //MINT32 + MTK_FEATURE_MFNR_NVRAM_QUERY_INDEX, //MINT32 + MTK_FEATURE_MFNR_NVRAM_DECISION_ISO, //MINT32 + MTK_FEATURE_MFNR_TUNING_INDEX_HINT, //MINT64 + MTK_FEATURE_MFNR_FINAL_EXP, //MINT32 + MTK_FEATURE_MFNR_OPEN_ID, //MINT32 + MTK_FEATURE_AINR_MDLA_MODE, //MINT32 + MTK_ISP_AINR_MDLA_MODE, //MINT32 + MTK_ISP_LTM_BIT_MODE, //MINT32 + MTK_FEATURE_BSS_SELECTED_FRAME_COUNT, //MINT32 + MTK_FEATURE_BSS_FORCE_DROP_NUM, //MINT32 + MTK_FEATURE_BSS_FIXED_LSC_TBL_DATA, //MUINT8 + MTK_FEATURE_BSS_PROCESS, //MINT32 + MTK_FEATURE_BSS_ISGOLDEN, //MBOOL + MTK_FEATURE_BSS_REORDER, //MBOOL + MTK_FEATURE_BSS_MANUAL_ORDER, //MUINT8 + MTK_FEATURE_BSS_RRZO_DATA, //MUINT8 + MTK_FEATURE_BSS_DOWNSAMPLE, //MBOOL + MTK_FEATURE_PACK_RRZO, //MUINT8 + MTK_FEATURE_FACE_RECTANGLES, //MRect array + MTK_FEATURE_FACE_POSE_ORIENTATIONS, //MINT32[n*3] array, each struct include: xAsix, yAsix, zAsix + MTK_FEATURE_CAP_YUV_PROCESSING, //MUINT8 + MTK_FEATURE_CAP_PIPE_DCE_CONTROL, //MUINT8 + MTK_FEATURE_MULTIFRAMENODE_BYPASSED, //MUINT8 + MTK_FEATURE_FACE_APPLIED_GAMMA, //MINT32 + MTK_FEATURE_CAP_PQ_USERID, //MINT64 + MTK_FEATURE_FLIP_IN_P2A, //MINT32 + MTK_FSC_CROP_DATA = MTK_FSC_START, //IMemory + MTK_FSC_WARP_DATA, //IMemory + MTK_STAGGER_ME_META, //IMetadata + MTK_STAGGER_SE_META, //IMetadata + MTK_STAGGER_BLOB_IMGO_ORDER //MUINT8 +} mtk_platform_metadata_tag_t; + + +/****************************************************************************** + * + ******************************************************************************/ +typedef enum mtk_platform_3a_exif_metadata_tag { + MTK_3A_EXIF_FNUMBER, //MINT32 + MTK_3A_EXIF_FOCAL_LENGTH, //MINT32 + MTK_3A_EXIF_FOCAL_LENGTH_35MM, //MINT32 + MTK_3A_EXIF_SCENE_MODE, //MINT32 + MTK_3A_EXIF_AWB_MODE, //MINT32 + MTK_3A_EXIF_LIGHT_SOURCE, //MINT32 + MTK_3A_EXIF_EXP_PROGRAM, //MINT32 + MTK_3A_EXIF_SCENE_CAP_TYPE, //MINT32 + MTK_3A_EXIF_FLASH_LIGHT_TIME_US, //MINT32 + MTK_3A_EXIF_AE_METER_MODE, //MINT32 + MTK_3A_EXIF_AE_EXP_BIAS, //MINT32 + MTK_3A_EXIF_CAP_EXPOSURE_TIME, //MINT32 + MTK_3A_EXIF_AE_ISO_SPEED, //MINT32 + MTK_3A_EXIF_REAL_ISO_VALUE, //MINT32 + MTK_3A_EXIF_AE_BRIGHTNESS_VALUE, //MINT32 + MTK_3A_EXIF_FLASH_FIRING_STATUS, //MINT32 + MTK_3A_EXIF_FLASH_RETURN_DETECTION, //MINT32 + MTK_3A_EXIF_FLASH_MODE, //MINT32 + MTK_3A_EXIF_FLASH_FUNCTION, //MINT32 + MTK_3A_EXIF_FLASH_REDEYE, //MINT32 + MTK_3A_EXIF_DEBUGINFO_BEGIN, // debug info begin + // key: MINT32 + MTK_3A_EXIF_DBGINFO_AAA_KEY = MTK_3A_EXIF_DEBUGINFO_BEGIN, //MINT32 + MTK_3A_EXIF_DBGINFO_AAA_DATA, + MTK_3A_EXIF_DBGINFO_SDINFO_KEY, + MTK_3A_EXIF_DBGINFO_SDINFO_DATA, + MTK_3A_EXIF_DBGINFO_ISP_KEY, + MTK_3A_EXIF_DBGINFO_ISP_DATA, + // + MTK_CMN_EXIF_DBGINFO_KEY, + MTK_CMN_EXIF_DBGINFO_DATA, + // + MTK_MF_EXIF_DBGINFO_MF_KEY, + MTK_MF_EXIF_DBGINFO_MF_DATA, + // + MTK_N3D_EXIF_DBGINFO_KEY, + MTK_N3D_EXIF_DBGINFO_DATA, + // + MTK_POSTNR_EXIF_DBGINFO_NR_KEY, + MTK_POSTNR_EXIF_DBGINFO_NR_DATA, + // + MTK_RESVB_EXIF_DBGINFO_KEY, + MTK_RESVB_EXIF_DBGINFO_DATA, + // + MTK_RESVC_EXIF_DBGINFO_KEY, + MTK_RESVC_EXIF_DBGINFO_DATA, + // data: Memory + MTK_3A_EXIF_DEBUGINFO_END, // debug info end +} mtk_platform_3a_exif_metadata_tag_t; + +// MTK_3A_FEATURE_AE_EXPOSURE_LEVEL +typedef enum mtk_camera_metadata_enum_ae_exposure_level { + MTK_3A_FEATURE_AE_EXPOSURE_LEVEL_NONE = 0, + MTK_3A_FEATURE_AE_EXPOSURE_LEVEL_SHORT, + MTK_3A_FEATURE_AE_EXPOSURE_LEVEL_NORMAL, + MTK_3A_FEATURE_AE_EXPOSURE_LEVEL_LONG, +} mtk_camera_metadata_enum_ae_exposure_level_t; + +// MTK_3A_FEATURE_AE_TARGET_MODE +typedef enum mtk_camera_metadata_enum_ae_target_mode { + MTK_3A_FEATURE_AE_TARGET_MODE_NORMAL = 0, + MTK_3A_FEATURE_AE_TARGET_MODE_IVHDR, + MTK_3A_FEATURE_AE_TARGET_MODE_MVHDR, + MTK_3A_FEATURE_AE_TARGET_MODE_ZVHDR, + MTK_3A_FEATURE_AE_TARGET_MODE_LE_FIX, + MTK_3A_FEATURE_AE_TARGET_MODE_SE_FIX, + MTK_3A_FEATURE_AE_TARGET_MODE_4CELL_MVHDR, + MTK_3A_FEATURE_AE_TARGET_MODE_MSTREAM_VHDR, + MTK_3A_FEATURE_AE_TARGET_MODE_MSTREAM_VHDR_RTO1X, + MTK_3A_FEATURE_AE_TARGET_MODE_STAGGER_2EXP, + MTK_3A_FEATURE_AE_TARGET_MODE_STAGGER_3EXP, +} mtk_camera_metadata_enum_ae_target_mode_t; + +//MTK_3A_FEATURE_AE_VALID_EXPOSURE_NUM +typedef enum mtk_camera_metadata_enum_stagger_valid_exposure_num { + MTK_STAGGER_VALID_EXPOSURE_NON = 0, + MTK_STAGGER_VALID_EXPOSURE_1 = 1, + MTK_STAGGER_VALID_EXPOSURE_2 = 2, + MTK_STAGGER_VALID_EXPOSURE_3 = 3 +} mtk_camera_metadata_enum_stagger_valid_exposure_num_t; + +//MTK_3A_ISP_FUS_NUM +typedef enum mtk_camera_metadata_enum_3a_isp_fus_num { + MTK_3A_ISP_FUS_NUM_NON = 0, + MTK_3A_ISP_FUS_NUM_1 = 1, + MTK_3A_ISP_FUS_NUM_2 = 2, + MTK_3A_ISP_FUS_NUM_3 = 3, +} mtk_camera_metadata_enum_3a_isp_fus_num_t; + +/****************************************************************************** + * + ******************************************************************************/ +typedef enum mtk_platform_metadata_enum_nr_mode { + MTK_NR_MODE_OFF = 0, + MTK_NR_MODE_MNR, + MTK_NR_MODE_SWNR, + MTK_NR_MODE_AUTO +} mtk_platform_metadata_enum_nr_mode_t; + +typedef enum mtk_platform_metadata_enum_mfb_mode { + MTK_MFB_MODE_OFF = 0, + MTK_MFB_MODE_MFLL, + MTK_MFB_MODE_AIS, + MTK_MFB_MODE_NUM, +} mtk_platform_metadata_enum_mfb_mode_t; + +typedef enum mtk_platform_metadata_enum_custom_hint { + MTK_CUSTOM_HINT_0 = 0, + MTK_CUSTOM_HINT_1, + MTK_CUSTOM_HINT_2, + MTK_CUSTOM_HINT_3, + MTK_CUSTOM_HINT_4, + MTK_CUSTOM_HINT_NUM, +} mtk_platform_metadata_enum_custom_hint_t; + +typedef enum mtk_platform_metadata_enum_plugin_mode { + MTK_PLUGIN_MODE_COMBINATION = 1 << 0, + MTK_PLUGIN_MODE_NR = 1 << 1, + MTK_PLUGIN_MODE_HDR = 1 << 2, + MTK_PLUGIN_MODE_MFNR = 1 << 3, + MTK_PLUGIN_MODE_COPY = 1 << 4, + MTK_PLUGIN_MODE_TEST_PRV = 1 << 5, + MTK_PLUGIN_MODE_BMDN = 1 << 6, + MTK_PLUGIN_MODE_MFHR = 1 << 7, + MTK_PLUGIN_MODE_BMDN_3rdParty = 1 << 8, + MTK_PLUGIN_MODE_MFHR_3rdParty = 1 << 9, + MTK_PLUGIN_MODE_FUSION_3rdParty = 1 << 10, + MTK_PLUGIN_MODE_VSDOF_3rdParty = 1 << 11, + MTK_PLUGIN_MODE_COLLECT = 1 << 12, + MTK_PLUGIN_MODE_HDR_3RD_PARTY = 1 << 13, + MTK_PLUGIN_MODE_MFNR_3RD_PARTY = 1 << 14, + MTK_PLUGIN_MODE_BOKEH_3RD_PARTY = 1 << 15, + MTK_PLUGIN_MODE_DCMF_3RD_PARTY = 1 << 16, +} mtk_platform_metadata_enum_plugin_mode_t; + +typedef enum mtk_platform_metadata_enum_p2_plugin_combination { + MTK_P2_RAW_PROCESSOR = 1 << 0, + MTK_P2_ISP_PROCESSOR = 1 << 1, + MTK_P2_YUV_PROCESSOR = 1 << 2, + MTK_P2_MDP_PROCESSOR = 1 << 3, + MTK_P2_CAPTURE_REQUEST = 1 << 4, + MTK_P2_PREVIEW_REQUEST = 1 << 5 +} mtk_platform_metadata_enum_p2_plugin_combination; + +typedef enum mtk_platform_metadata_enum_isp_color_space { + MTK_ISP_COLOR_SPACE_SRGB = 0 , + MTK_ISP_COLOR_SPACE_DISPLAY_P3 = 1 , + MTK_ISP_COLOR_SPACE_CUSTOM_1 = 2 +} mtk_platform_metadata_enum_isp_color_space; + +typedef enum mtk_platform_metadata_enum_dualzoom_drop_req { + MTK_DUALZOOM_DROP_NEVER_DROP = 0, + MTK_DUALZOOM_DROP_NONE = 1, + MTK_DUALZOOM_DROP_DIRECTLY = 2, + MTK_DUALZOOM_DROP_NEED_P1, + MTK_DUALZOOM_DROP_NEED_SYNCMGR, + MTK_DUALZOOM_DROP_NEED_SYNCMGR_NEED_STREAM_F_PIPE, +} mtk_platform_metadata_enum_dualzoom_drop_req_t; + +typedef enum mtk_platform_metadata_enum_p1_sensor_status { + MTK_P1_SENSOR_STATUS_NONE = 0, + MTK_P1_SENSOR_STATUS_STREAMING = 1, + MTK_P1_SENSOR_STATUS_SW_STANDBY = 2, + MTK_P1_SENSOR_STATUS_HW_STANDBY = 3, +} mtk_platform_metadata_enum_p1_sensor_status_t; + +typedef enum mtk_platform_metadata_enum_p1_twin_switch { + MTK_P1_TWIN_SWITCH_NONE = 0, + MTK_P1_TWIN_SWITCH_ONE_TG = 1, + MTK_P1_TWIN_SWITCH_TWO_TG = 2 +} mtk_platform_metadata_enum_p1_twin_switch_t; + +typedef enum mtk_platform_metadata_enum_p1_twin_status { + MTK_P1_TWIN_STATUS_NONE = 0, + MTK_P1_TWIN_STATUS_TG_MODE_1 = 1, + MTK_P1_TWIN_STATUS_TG_MODE_2 = 2, + MTK_P1_TWIN_STATUS_TG_MODE_3 = 3, +} mtk_platform_metadata_enum_p1_twin_status_t; + +typedef enum mtk_platform_metadata_enum_p1_resize_quality_switch { + MTK_P1_RESIZE_QUALITY_SWITCH_NONE = 0, + MTK_P1_RESIZE_QUALITY_SWITCH_L_L = 1, + MTK_P1_RESIZE_QUALITY_SWITCH_L_H = 2, + MTK_P1_RESIZE_QUALITY_SWITCH_H_L = 3, + MTK_P1_RESIZE_QUALITY_SWITCH_H_H = 4, +} mtk_platform_metadata_enum_p1_resize_quality_switch_t; + +typedef enum mtk_platform_metadata_enum_p1_resize_quality_status { + MTK_P1_RESIZE_QUALITY_STATUS_NONE = 0, + MTK_P1_RESIZE_QUALITY_STATUS_ACCEPT = 1, + MTK_P1_RESIZE_QUALITY_STATUS_IGNORE = 2, + MTK_P1_RESIZE_QUALITY_STATUS_REJECT = 3, + MTK_P1_RESIZE_QUALITY_STATUS_ILLEGAL = 4, +} mtk_platform_metadata_enum_p1_resize_quality_status_t; + +typedef enum mtk_platform_metadata_enum_p1_resize_quality_level { + MTK_P1_RESIZE_QUALITY_LEVEL_UNKNOWN = 0, + MTK_P1_RESIZE_QUALITY_LEVEL_L = 1, + MTK_P1_RESIZE_QUALITY_LEVEL_H = 2, +} mtk_platform_metadata_enum_p1_resize_quality_level_t; + +typedef enum mtk_platform_metadata_enum_lmv_result { + MTK_LMV_RESULT_OK = 0, + MTK_LMV_RESULT_FAILED, + MTK_LMV_RESULT_SWITCHING +} mtk_platform_metadata_enum_lmv_result_t; + +typedef enum mtk_platform_metadata_enum_featurepipe_app_mode { + MTK_FEATUREPIPE_PHOTO_PREVIEW = 0, + MTK_FEATUREPIPE_VIDEO_PREVIEW = 1, + MTK_FEATUREPIPE_VIDEO_RECORD = 2, + MTK_FEATUREPIPE_VIDEO_STOP = 3, +} mtk_platform_metadata_enum_featurepipe_app_mode_t; + +typedef enum mtk_platform_metadata_enum_dcmf_feature_mode { + MTK_DCMF_FEATURE_BOKEH = 0, + MTK_DCMF_FEATURE_MFNR_BOKEH = 1, + MTK_DCMF_FEATURE_HDR_BOKEH = 2, +} mtk_platform_metadata_enum_dcmf_feature_mode_t; + +typedef enum mtk_platform_metadata_enum_smvr_fps { + MTK_SMVR_FPS_30 = 0, + MTK_SMVR_FPS_120 = 1, + MTK_SMVR_FPS_240 = 2, + MTK_SMVR_FPS_480 = 3, + MTK_SMVR_FPS_960 = 4, +} mtk_platform_metadata_enum_smvr_fps_t; + +//MTK_FRAMESYNC_FAILHANDLE +typedef enum mtk_platform_metadata_enum_fremesync_failhandle { + MTK_FRAMESYNC_FAILHANDLE_CONTINUE, + MTK_FRAMESYNC_FAILHANDLE_DROP, +} mtk_platform_metadata_enum_fremesync_failhandle_t; + +//MTK_FRAMESYNC_RESULT +typedef enum mtk_platform_metadata_enum_fremesync_result { + MTK_FRAMESYNC_RESULT_PASS, + MTK_FRAMESYNC_RESULT_FAIL_CONTINUE, + MTK_FRAMESYNC_RESULT_FAIL_DROP, +} mtk_platform_metadata_enum_fremesync_result_t; + +//MTK_FRAMESYNC_MODE +typedef enum mtk_platform_metadata_enum_fremesync_mode { + MTK_FRAMESYNC_MODE_VSYNC_ALIGNMENT, + MTK_FRAMESYNC_MODE_READOUT_CENTER_ALIGNMENT, +} mtk_platform_metadata_enum_fremesync_mode_t; + +//MTK_FEATURE_MULTIFRAMENODE_BYPASSED +typedef enum mtk_platform_metadata_enum_multiframenode_bypassed { + MTK_FEATURE_MULTIFRAMENODE_NOT_BYPASSED = 0, + MTK_FEATURE_MULTIFRAMENODE_TO_BE_BYPASSED = 1 +} mtk_platform_metadata_enum_mfllnode_bypassed_t; + +//MTK_FEATURE_BSS_PROCESS +typedef enum mtk_platform_metadata_enum_bss_processing { + MTK_FEATURE_BSS_PROCESS_ENABLE = 0, + MTK_FEATURE_BSS_PROCESS_DISABLE = 1 +} mtk_platform_metadata_enum_bss_processing_t; + +//MTK_FEATURE_BSS_MANUAL_ORDER +typedef enum mtk_platform_metadata_enum_bss_manual_order { + MTK_FEATURE_BSS_MANUAL_ORDER_OFF = 0, + MTK_FEATURE_BSS_MANUAL_ORDER_GOLDEN = 1 +} mtk_platform_metadata_enum_bss_manual_order_t; + +//MTK_FEATURE_CAP_YUV_PROCESSING +typedef enum mtk_platform_metadata_enum_cap_yuv_processing { + MTK_FEATURE_CAP_YUV_PROCESSING_NOT_NEEDED = 0, + MTK_FEATURE_CAP_YUV_PROCESSING_NEEDED = 1 +} mtk_platform_metadata_enum_cap_yuv_processing_t; + +//MTK_FEATURE_CAP_PIPE_DCE_CONTROL +typedef enum mtk_platform_metadata_enum_cap_pipe_control { + MTK_FEATURE_CAP_PIPE_DCE_ENABLE_BUT_NOT_APPLY = 2, + MTK_FEATURE_CAP_PIPE_DCE_MANUAL_DISABLE = 1, + MTK_FEATURE_CAP_PIPE_DCE_DEFAULT_APPLY = 0 +} mtk_platform_metadata_enum_cap_pipe_dce_control_t; + +// MTK_FEATURE_AINR_MDLA_MODE, MTK_ISP_AINR_MDLA_MODE +typedef enum mtk_platform_metadata_enum_ainr_mdla_mode { + MTK_FEATURE_AINR_MDLA_MODE_NONE = 0, + MTK_FEATURE_AINR_MDLA_MODE_DRCOUT_16BIT = 1, + MTK_FEATURE_AINR_MDLA_MODE_NNOUT_12BIT = 2, + MTK_FEATURE_AINR_MDLA_MODE_NNOUT_16BIT = 3, +} mtk_platform_metadata_enum_ainr_mdla_mode_t; + +//MTK_ISP_P2_PROCESSED_RAW +typedef enum mtk_platform_metadata_enum_p2_processed_raw { + MTK_ISP_P2_PROCESSED_RAW_NOT_NEEDED = 0, + MTK_ISP_P2_PROCESSED_RAW_NEEDED = 1 +} mtk_platform_metadata_enum_p2_processed_raw_t; + +//MTK_DUALZOOM_STREAMING_NR +typedef enum mtk_platform_metadata_enum_dualzoom_streaming_nr { + MTK_DUALZOOM_STREAMING_NR_AUTO = 0, + MTK_DUALZOOM_STREAMING_NR_OFF = 1 +} mtk_platform_metadata_enum_dualzoom_streaming_nr_t; + +//MTK_STAGGER_BLOB_IMGO_ORDER +typedef enum mtk_platform_metadata_enum_stagger_blob_imgo_order { + MTK_STAGGER_IMGO_NONE = 0, + MTK_STAGGER_IMGO_NE = 1, + MTK_STAGGER_IMGO_ME = 2, + MTK_STAGGER_IMGO_SE = 3 +} mtk_platform_metadata_enum_stagger_blob_imgo_order_t; + +//MTK_3A_EXIF_FLASH_FIRING_STATUS +typedef enum mtk_platform_metadata_enum_3a_exif_flash_firing_status_t { + MTK_3A_EXIF_FLASH_FIRING_STATUS_NOT_FIRED = 0, + MTK_3A_EXIF_FLASH_FIRING_STATUS_FIRED = 1, +} mtk_platform_metadata_enum_3a_exif_flash_firing_status_t; + +//MTK_3A_EXIF_FLASH_RETURN_DETECTION +typedef enum mtk_platform_metadata_enum_3a_exif_flash_return_detection_t { + MTK_3A_EXIF_FLASH_RETURN_DETECTION_NOT_SUPPORT = 0, + MTK_3A_EXIF_FLASH_RETURN_DETECTION_RESERVED = 1, + MTK_3A_EXIF_FLASH_RETURN_DETECTION_STROBE_NOT_DETECTED = 2, + MTK_3A_EXIF_FLASH_RETURN_DETECTION_STROBE_DETECTED = 3, +} mtk_platform_metadata_enum_3a_exif_flash_return_detection_t; + +//MTK_3A_EXIF_FLASH_MODE +typedef enum mtk_platform_metadata_enum_3a_exif_flash_mode_t { + MTK_3A_EXIF_FLASH_MODE_UNKNOWN = 0, + MTK_3A_EXIF_FLASH_MODE_COMPULSORY_FIRING = 1, + MTK_3A_EXIF_FLASH_MODE_COMPULSORY_SUPPRESSION = 2, + MTK_3A_EXIF_FLASH_MODE_AUTO = 3, +} mtk_platform_metadata_enum_3a_exif_flash_mode_t; + +//MTK_3A_EXIF_FLASH_FUNCTION +typedef enum mtk_platform_metadata_enum_3a_exif_flash_function_t { + MTK_3A_EXIF_FLASH_FUNCTION_SUPPORT = 0, + MTK_3A_EXIF_FLASH_FUNCTION_NOT_SUPPORT = 1, +} mtk_platform_metadata_enum_3a_exif_flash_function_t; + +//MTK_3A_EXIF_FLASH_REDEYE +typedef enum mtk_platform_metadata_enum_3a_exif_flash_redeye_t { + MTK_3A_EXIF_FLASH_REDEYE_NOT_SUPPORT = 0, + MTK_3A_EXIF_FLASH_REDEYE_SUPPORT = 1, +} mtk_platform_metadata_enum_3a_exif_flash_redeye_t; + +//MTK_FEATURE_ABF +typedef enum mtk_platform_metadata_enum_abf_mode { + MTK_ABF_MODE_OFF = 0, + MTK_ABF_MODE_ON, +} mtk_platform_metadata_enum_abf_mode_t; + +#endif diff --git a/app/src/main/cpp/camera2/ndkcamera.cpp b/app/src/main/cpp/camera2/ndkcamera.cpp index 517c7687..bed31299 100644 --- a/app/src/main/cpp/camera2/ndkcamera.cpp +++ b/app/src/main/cpp/camera2/ndkcamera.cpp @@ -29,6 +29,9 @@ #include #include "DngCreator.h" +#include "mtk_platform_metadata_tag.h" +#include "mtk_metadata_tag.h" + #define MTK_MFBMODE_TAG "com.mediatek.mfbmode" #define MTK_MFNR_ENABLE_TAG "com.mediatek.3afeature.mfnrenable" @@ -41,6 +44,8 @@ #define MTK_MFNR_FEATURE_MFB_AUTO 0xFF +#define MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_MFNR 1 + // #define MTK_3A_MFNR_ENABLE "com.mediatek.3afeature.mfnrenable" #define MTK_3A_MFNR_INTENSITY_TAG "com.mediatek.3afeature.mfnrintensity" @@ -74,6 +79,15 @@ void SetupMFNR(ACameraMetadata* characteristics, ACaptureRequest* request) { uint8_t nrMode = ACAMERA_NOISE_REDUCTION_MODE_HIGH_QUALITY; status = ACaptureRequest_setEntry_u8(request, ACAMERA_NOISE_REDUCTION_MODE, 1, &nrMode); + uint8_t reqRemosaicEnable = 1; + status = ACaptureRequest_setEntry_u8(request, MTK_HAL_REQUEST_REMOSAIC_ENABLE, 1, &reqRemosaicEnable); + + int32_t ispTuning = MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING_MFNR; + status = ACaptureRequest_setEntry_i32(request, MTK_CONTROL_CAPTURE_HINT_FOR_ISP_TUNING, 1, &ispTuning); + + uint8_t aeMode = MTK_CONTROL_AE_MODE_ON; + status = ACaptureRequest_setEntry_u8(request, MTK_CONTROL_AE_MODE, 1, &aeMode); + // 2. 设置 MediaTek 特定的 MFNR 参数 // 使用 vendor tag 描述符 int32_t mfbMode = MTK_MFNR_FEATURE_MFB_AUTO; // 1 Enable MFNR