diff --git a/adapter/uhdf2/hdi.gni b/adapter/uhdf2/hdi.gni index 87869dc856e32663a4585fa5557e7a0e0cf72dae..b1bfb5ee049e3a9aaef8e1e0f0555d2ffc84e890 100644 --- a/adapter/uhdf2/hdi.gni +++ b/adapter/uhdf2/hdi.gni @@ -150,8 +150,8 @@ template("hdi") { deps = [ ":hdi_gen" ] if (is_standard_system) { public_deps = [] - if (defined(invoker.sequenceable)) { - public_deps += invoker.sequenceable + if (defined(invoker.sequenceable_pub_deps)) { + public_deps += invoker.sequenceable_pub_deps } public_deps += hdi_build_info.proxy_deps @@ -162,7 +162,9 @@ template("hdi") { "hdf_core:libpub_utils", "hiviewdfx_hilog_native:libhilog", ] - + if (defined(invoker.sequenceable_ext_deps)) { + external_deps += invoker.sequenceable_ext_deps + } if (invoker.language == "c") { external_deps += [ "hdf_core:libhdf_ipc_adapter" ] } else if (invoker.language == "cpp") { @@ -194,8 +196,8 @@ template("hdi") { deps = [ ":hdi_gen" ] if (is_standard_system) { public_deps = [] - if (defined(invoker.sequenceable)) { - public_deps += invoker.sequenceable + if (defined(invoker.sequenceable_pub_deps)) { + public_deps += invoker.sequenceable_pub_deps } public_deps += hdi_build_info.stub_deps @@ -205,7 +207,9 @@ template("hdi") { "hdf_core:libhdi", "hiviewdfx_hilog_native:libhilog", ] - + if (defined(invoker.sequenceable_ext_deps)) { + external_deps += invoker.sequenceable_ext_deps + } if (invoker.language == "c") { external_deps += [ "hdf_core:libhdf_ipc_adapter", diff --git a/adapter/uhdf2/model/camera/metadata/BUILD.gn b/adapter/uhdf2/model/camera/metadata/BUILD.gn deleted file mode 100644 index fafe0cd7a2e180f05ffa9f56caa6499d3f5d561c..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/BUILD.gn +++ /dev/null @@ -1,51 +0,0 @@ -# Copyright (c) 2021 - 2023 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import("//build/ohos.gni") - -config("camera_metadata_config") { - include_dirs = [ "./include" ] -} - -ohos_shared_library("metadata") { - install_enable = true - cflags = [ - "-fPIC", - "-Wall", - ] - cflags_cc = cflags - all_dependent_configs = [ ":camera_metadata_config" ] - if (defined(ohos_lite)) { - sources = [ - "src/camera_metadata_info.cpp", - "src/camera_metadata_operator.cpp", - ] - external_deps = [ "hilog_lite:hilog_shared" ] - } else { - sources = [ - "src/camera_metadata_info.cpp", - "src/camera_metadata_operator.cpp", - "src/metadata_utils.cpp", - ] - external_deps = [ - "c_utils:utils", - "drivers_interface_camera:libcamera_proxy_1.0", - "hiviewdfx_hilog_native:libhilog", - ] - } - - install_images = [ system_base_dir ] - relative_install_dir = "chipset-sdk" - part_name = "drivers_interface_camera" - subsystem_name = "hdf" -} diff --git a/adapter/uhdf2/model/camera/metadata/include/camera_device_ability_items.h b/adapter/uhdf2/model/camera/metadata/include/camera_device_ability_items.h deleted file mode 100644 index 82d1d311100dfb59cc6b9c8d6608e4c2f1bdc73c..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/include/camera_device_ability_items.h +++ /dev/null @@ -1,432 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef CAMERA_DEVICE_ABILITY_ITEMS_H -#define CAMERA_DEVICE_ABILITY_ITEMS_H - -typedef enum camera_ability_section { - // Camera attribute information: position(facing), type, connection, description, sensor, lens description - OHOS_CAMERA_PROPERTIES = 0, - OHOS_CAMERA_LENS, - OHOS_CAMERA_SENSOR, - OHOS_CAMERA_SENSOR_INFO, - OHOS_CAMERA_STATISTICS, - - // Camera device image acquisition - OHOS_DEVICE_CONTROL = 0x1000, // Overall control, such as turning off automatic 3A, operating mode - OHOS_DEVICE_EXPOSURE, - OHOS_DEVICE_FOCUS, - OHOS_DEVICE_WHITE_BLANCE, - OHOS_DEVICE_FLASH, - OHOS_DEVICE_ZOOM, - - // Camera image post-processing related - OHOS_POST_PROCESS_CONTROL = 0x2000, - OHOS_POST_PROCESS_COLOR, - OHOS_POST_PROCESS_HDR, - OHOS_POST_PROCESS_PORTRAIT, - OHOS_POST_PROCESS_NIGHT, - - // Camera flow control related - OHOS_STREAM_ABILITY = 0x3000, - OHOS_STREAM_CONTROL, // General control: frame rate, resolution, mirroring - OHOS_STREAM_JPEG, - OHOS_STREAM_VIDEO, // Video encoding related - OHOS_STREAM_DEPTH, - OHOS_STREAM_METADATA, - OHOS_STREAM_METADATA_FACE, - OHOS_STREAM_METADATA_BODY, - - OHOS_ABILITY_SECTION_END -} camera_ability_section_t; - -typedef enum camera_device_metadata_section_start { - OHOS_CAMERA_PROPERTIES_START = OHOS_CAMERA_PROPERTIES << 16, - OHOS_CAMERA_LENS_START = OHOS_CAMERA_LENS << 16, - OHOS_CAMERA_SENSOR_START = OHOS_CAMERA_SENSOR << 16, - OHOS_CAMERA_SENSOR_INFO_START = OHOS_CAMERA_SENSOR_INFO << 16, - OHOS_CAMERA_STATISTICS_START = OHOS_CAMERA_STATISTICS << 16, - - OHOS_DEVICE_CONTROL_START = OHOS_DEVICE_CONTROL << 16, - OHOS_DEVICE_EXPOSURE_START = OHOS_DEVICE_EXPOSURE << 16, - OHOS_DEVICE_FOCUS_START = OHOS_DEVICE_FOCUS << 16, - OHOS_DEVICE_WHITE_BLANCE_START = OHOS_DEVICE_WHITE_BLANCE << 16, - OHOS_DEVICE_FLASH_START = OHOS_DEVICE_FLASH << 16, - OHOS_DEVICE_ZOOM_START = OHOS_DEVICE_ZOOM << 16, - - OHOS_POST_PROCESS_CONTROL_START = OHOS_POST_PROCESS_CONTROL << 16, - OHOS_POST_PROCESS_COLOR_START = OHOS_POST_PROCESS_COLOR << 16, - OHOS_POST_PROCESS_HDR_START = OHOS_POST_PROCESS_HDR << 16, - OHOS_POST_PROCESS_PORTRAIT_START = OHOS_POST_PROCESS_PORTRAIT << 16, - OHOS_POST_PROCESS_NIGHT_START = OHOS_POST_PROCESS_NIGHT << 16, - - OHOS_STREAM_ABILITY_START = OHOS_STREAM_ABILITY << 16, - OHOS_STREAM_CONTROL_START = OHOS_STREAM_CONTROL << 16, - OHOS_STREAM_JPEG_START = OHOS_STREAM_JPEG << 16, - OHOS_STREAM_VIDEO_START = OHOS_STREAM_VIDEO << 16, - OHOS_STREAM_DEPTH_START = OHOS_STREAM_DEPTH << 16, - OHOS_STREAM_METADATA_START = OHOS_STREAM_METADATA << 16, - OHOS_STREAM_METADATA_FACE_START = OHOS_STREAM_METADATA_FACE << 16, - OHOS_STREAM_METADATA_BODY_START = OHOS_STREAM_METADATA_BODY << 16 -} camera_device_info_section_start_t; - -typedef enum camera_device_metadata_tag { - // Camera attribute related item - OHOS_ABILITY_CAMERA_POSITION = OHOS_CAMERA_PROPERTIES_START, - OHOS_ABILITY_CAMERA_TYPE, - OHOS_ABILITY_CAMERA_CONNECTION_TYPE, - OHOS_ABILITY_MEMORY_TYPE, - OHOS_ABILITY_FPS_RANGES, - OHOS_ABILITY_FLASH_AVAILABLE, - OHOS_CAMERA_STREAM_ID, - OHOS_CAMERA_PROPERTIES_END, - - OHOS_SENSOR_EXPOSURE_TIME = OHOS_CAMERA_SENSOR_START, - OHOS_SENSOR_COLOR_CORRECTION_GAINS, - OHOS_SENSOR_ORIENTATION, - OHOS_ABILITY_MUTE_MODES, - OHOS_CONTROL_MUTE_MODE, - OHOS_CAMERA_SENSOR_END, - - OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE = OHOS_CAMERA_SENSOR_INFO_START, - OHOS_SENSOR_INFO_SENSITIVITY_RANGE, - OHOS_SENSOR_INFO_MAX_FRAME_DURATION, - OHOS_SENSOR_INFO_PHYSICAL_SIZE, - OHOS_SENSOR_INFO_PIXEL_ARRAY_SIZE, - OHOS_SENSOR_INFO_TIMESTAMP, - OHOS_CAMERA_SENSOR_INFO_END, - - OHOS_STATISTICS_FACE_DETECT_MODE = OHOS_CAMERA_STATISTICS_START, - OHOS_STATISTICS_FACE_DETECT_SWITCH, - OHOS_STATISTICS_FACE_DETECT_MAX_NUM, - OHOS_STATISTICS_HISTOGRAM_MODE, - OHOS_STATISTICS_FACE_IDS, - OHOS_STATISTICS_FACE_LANDMARKS, - OHOS_STATISTICS_FACE_RECTANGLES, - OHOS_STATISTICS_FACE_SCORES, - OHOS_CAMERA_STATISTICS_END, - - OHOS_CONTROL_AE_ANTIBANDING_MODE = OHOS_DEVICE_CONTROL_START, - OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, - OHOS_CONTROL_AE_LOCK, - OHOS_CONTROL_AE_MODE, - OHOS_CONTROL_AE_REGIONS, - OHOS_CONTROL_AE_TARGET_FPS_RANGE, - OHOS_CONTROL_FPS_RANGES, - OHOS_CONTROL_AF_MODE, - OHOS_CONTROL_AF_REGIONS, - OHOS_CONTROL_AF_TRIGGER, - OHOS_CONTROL_AF_TRIGGER_ID, - OHOS_CONTROL_AF_STATE, - OHOS_CONTROL_AWB_LOCK, - OHOS_CONTROL_AWB_MODE, - OHOS_CONTROL_AWB_REGIONS, - OHOS_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, - OHOS_CONTROL_AE_AVAILABLE_MODES, - OHOS_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, - OHOS_CONTROL_AE_COMPENSATION_RANGE, - OHOS_CONTROL_AE_COMPENSATION_STEP, - OHOS_CONTROL_AF_AVAILABLE_MODES, - OHOS_CONTROL_AWB_AVAILABLE_MODES, - OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, - OHOS_CONTROL_CAPTURE_MIRROR, - OHOS_CONTROL_FOCUS_STATE, - OHOS_CONTROL_METER_POINT, - OHOS_CONTROL_METER_MODE, - OHOS_CONTROL_EXPOSURE_STATE, - OHOS_DEVICE_CONTROL_END, - - // Camera device image acquisition related - OHOS_ABILITY_DEVICE_AVAILABLE_EXPOSUREMODES = OHOS_DEVICE_EXPOSURE_START, - OHOS_CONTROL_EXPOSUREMODE, - OHOS_ABILITY_EXPOSURE_MODES, - OHOS_CONTROL_EXPOSURE_MODE, - OHOS_ABILITY_METER_MODES, - OHOS_DEVICE_EXPOSURE_END, - - OHOS_ABILITY_DEVICE_AVAILABLE_FOCUSMODES = OHOS_DEVICE_FOCUS_START, - OHOS_CONTROL_FOCUSMODE, - OHOS_ABILITY_FOCUS_MODES, - OHOS_CONTROL_FOCUS_MODE, - OHOS_ABILITY_FOCAL_LENGTH, - OHOS_DEVICE_FOCUS_END, - - OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES = OHOS_DEVICE_FLASH_START, - OHOS_CONTROL_FLASHMODE, - OHOS_ABILITY_FLASH_MODES, - OHOS_CONTROL_FLASH_MODE, - OHOS_CONTROL_FLASH_STATE, - OHOS_DEVICE_FLASH_END, - - OHOS_ABILITY_ZOOM_RATIO_RANGE = OHOS_DEVICE_ZOOM_START, - OHOS_CONTROL_ZOOM_RATIO, - OHOS_CONTROL_ZOOM_CROP_REGION, - OHOS_ABILITY_ZOOM_CAP, - OHOS_ABILITY_SCENE_ZOOM_CAP, - OHOS_DEVICE_ZOOM_END, - - // Camera flow control related - OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS = OHOS_STREAM_ABILITY_START, - OHOS_STREAM_AVAILABLE_FORMATS, - OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, - OHOS_ABILITY_STREAM_THUMBNAIL_AVAILABLE, - OHOS_STREAM_ABILITY_END, - - OHOS_JPEG_GPS_COORDINATES = OHOS_STREAM_JPEG_START, - OHOS_JPEG_GPS_PROCESSING_METHOD, - OHOS_JPEG_GPS_TIMESTAMP, - OHOS_JPEG_ORIENTATION, - OHOS_JPEG_QUALITY, - OHOS_JPEG_THUMBNAIL_QUALITY, - OHOS_JPEG_THUMBNAIL_SIZE, - OHOS_JPEG_AVAILABLE_THUMBNAIL_SIZES, - OHOS_JPEG_MAX_SIZE, - OHOS_JPEG_SIZE, - OHOS_STREAM_JPEG_END, - - OHOS_ABILITY_VIDEO_STABILIZATION_MODES = OHOS_STREAM_VIDEO_START, - OHOS_CONTROL_VIDEO_STABILIZATION_MODE, - OHOS_STREAM_VIDEO_END, -} camera_device_metadata_tag_t; - -// OHOS_ABILITY_CAMERA_POSITION enumeration values -typedef enum camera_position_enum { - OHOS_CAMERA_POSITION_FRONT = 0, - OHOS_CAMERA_POSITION_BACK, - OHOS_CAMERA_POSITION_OTHER -} camera_position_enum_t; - -// OHOS_ABILITY_CAMERA_TYPE enumeration values -typedef enum camera_type_enum { - OHOS_CAMERA_TYPE_WIDE_ANGLE = 0, - OHOS_CAMERA_TYPE_ULTRA_WIDE, - OHOS_CAMERA_TYPE_TELTPHOTO, - OHOS_CAMERA_TYPE_TRUE_DEAPTH, - OHOS_CAMERA_TYPE_LOGICAL, - OHOS_CAMERA_TYPE_UNSPECIFIED, -} camera_type_enum_t; - -// OHOS_ABILITY_CAMERA_CONNECTION_TYPE enumeration values -typedef enum camera_connection_type { - OHOS_CAMERA_CONNECTION_TYPE_BUILTIN = 0, - OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN, - OHOS_CAMERA_CONNECTION_TYPE_REMOTE, -} camera_connection_type_t; - -// OHOS_CONTROL_EXPOSUREMODE -// and OHOS_ABILITY_EXPOSURE_MODES enumeration values -typedef enum camera_exposure_mode_enum { - OHOS_CAMERA_EXPOSURE_MODE_MANUAL = 0, - OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO, - OHOS_CAMERA_EXPOSURE_MODE_LOCKED, - OHOS_CAMERA_EXPOSURE_MODE_AUTO -} camera_exposure_mode_enum_t; - -// OHOS_CONTROL_FOCUS_MODE and OHOS_ABILITY_FOCUS_MODES enumeration values -typedef enum camera_focus_mode_enum { - OHOS_CAMERA_FOCUS_MODE_MANUAL = 0, - OHOS_CAMERA_FOCUS_MODE_CONTINUOUS_AUTO, - OHOS_CAMERA_FOCUS_MODE_AUTO, - OHOS_CAMERA_FOCUS_MODE_LOCKED -} camera_focus_mode_enum_t; - -// OHOS_CONTROL_FLASHMODE and OHOS_ABILITY_FLASH_MODES enumeration values -typedef enum camera_flash_mode_enum { - OHOS_CAMERA_FLASH_MODE_CLOSE = 0, - OHOS_CAMERA_FLASH_MODE_OPEN, - OHOS_CAMERA_FLASH_MODE_AUTO, - OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN -} camera_flash_mode_enum_t; - -// OHOS_CONTROL_FLASH_STATE enumeration values -typedef enum camera_flash_state_enum { - OHOS_CAMERA_FLASH_STATE_UNAVAILABLE = 0, - OHOS_CAMERA_FLASH_STATE_CHARGING, - OHOS_CAMERA_FLASH_STATE_READY, - OHOS_CAMERA_FLASH_STATE_FLASHING, - OHOS_CAMERA_FLASH_STATE_UNKNOWN -} camera_flash_state_enum_t; - -// OHOS_CONTROL_AE_ANTIBANDING_MODE enumeration values -typedef enum camera_ae_antibanding_mode { - OHOS_CAMERA_AE_ANTIBANDING_MODE_OFF, - OHOS_CAMERA_AE_ANTIBANDING_MODE_50HZ, - OHOS_CAMERA_AE_ANTIBANDING_MODE_60HZ, - OHOS_CAMERA_AE_ANTIBANDING_MODE_AUTO, -} camera_ae_antibanding_mode_t; - -// OHOS_CONTROL_AE_LOCK enumeration values -typedef enum camera_ae_lock { - OHOS_CAMERA_AE_LOCK_OFF, - OHOS_CAMERA_AE_LOCK_ON, -} camera_ae_lock_t; - -// OHOS_CONTROL_AE_MODE enumeration values -typedef enum camera_ae_mode { - OHOS_CAMERA_AE_MODE_OFF, - OHOS_CAMERA_AE_MODE_ON, - OHOS_CAMERA_AE_MODE_ON_AUTO_FLASH, - OHOS_CAMERA_AE_MODE_ON_ALWAYS_FLASH, - OHOS_CAMERA_AE_MODE_ON_AUTO_FLASH_REDEYE, - OHOS_CAMERA_AE_MODE_ON_EXTERNAL_FLASH, -} camera_ae_mode_t; - -// OHOS_CONTROL_AF_MODE -// and OHOS_CONTROL_AF_AVAILABLE_MODES enumeration values -typedef enum camera_af_mode { - OHOS_CAMERA_AF_MODE_OFF, - OHOS_CAMERA_AF_MODE_AUTO, - OHOS_CAMERA_AF_MODE_MACRO, - OHOS_CAMERA_AF_MODE_CONTINUOUS_VIDEO, - OHOS_CAMERA_AF_MODE_CONTINUOUS_PICTURE, - OHOS_CAMERA_AF_MODE_EDOF, -} camera_af_mode_t; - -// OHOS_CONTROL_AF_TRIGGER enumeration values -typedef enum camera_af_trigger { - OHOS_CAMERA_AF_TRIGGER_IDLE, - OHOS_CAMERA_AF_TRIGGER_START, - OHOS_CAMERA_AF_TRIGGER_CANCEL, -} camera_af_trigger_t; - -// OHOS_CONTROL_AF_STATE enumeration values -typedef enum camera_af_state { - OHOS_CAMERA_AF_STATE_INACTIVE, - OHOS_CAMERA_AF_STATE_PASSIVE_SCAN, - OHOS_CAMERA_AF_STATE_PASSIVE_FOCUSED, - OHOS_CAMERA_AF_STATE_ACTIVE_SCAN, - OHOS_CAMERA_AF_STATE_FOCUSED_LOCKED, - OHOS_CAMERA_AF_STATE_NOT_FOCUSED_LOCKED, - OHOS_CAMERA_AF_STATE_PASSIVE_UNFOCUSED, -} camera_af_state_t; - -// OHOS_CONTROL_AWB_LOCK enumeration values -typedef enum camera_awb_lock { - OHOS_CAMERA_AWB_LOCK_OFF, - OHOS_CAMERA_AWB_LOCK_ON, -} camera_awb_lock_t; - -// OHOS_CONTROL_AWB_MODE enumeration values -typedef enum camera_awb_mode { - OHOS_CAMERA_AWB_MODE_OFF, - OHOS_CAMERA_AWB_MODE_AUTO, - OHOS_CAMERA_AWB_MODE_INCANDESCENT, - OHOS_CAMERA_AWB_MODE_FLUORESCENT, - OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT, - OHOS_CAMERA_AWB_MODE_DAYLIGHT, - OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT, - OHOS_CAMERA_AWB_MODE_TWILIGHT, - OHOS_CAMERA_AWB_MODE_SHADE, -} camera_awb_mode_t; - -// OHOS_STATISTICS_FACE_DETECT_MODE -// and OHOS_STATISTICS_FACE_DETECT_SWITCH enumeration values -typedef enum camera_face_detect_mode { - OHOS_CAMERA_FACE_DETECT_MODE_OFF, - OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE -} camera_face_detect_mode_t; - -// OHOS_STATISTICS_HISTOGRAM_MODE enumeration values -typedef enum camera_histogram_mode { - OHOS_CAMERA_HISTOGRAM_MODE_OFF, - OHOS_CAMERA_HISTOGRAM_MODE_ON, -} camera_histogram_mode_t; - -// OHOS_STREAM_AVAILABLE_FORMATS -// and OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS enumeration values -typedef enum camera_format { - OHOS_CAMERA_FORMAT_RGBA_8888 = 1, - OHOS_CAMERA_FORMAT_YCBCR_420_888, - OHOS_CAMERA_FORMAT_YCRCB_420_SP, - OHOS_CAMERA_FORMAT_JPEG, -} camera_format_t; - -// OHOS_ABILITY_STREAM_THUMBNAIL_AVAILABLE enumeration values -typedef enum camera_thumbnail_available { - OHOS_CAMERA_THUMBNAIL_FALSE = 0, - OHOS_CAMERA_THUMBNAIL_TRUE, -} camera_thumbnail_available_t; - -// OHOS_CONTROL_FOCUS_STATE enumeration values -typedef enum camera_focus_state { - OHOS_CAMERA_FOCUS_STATE_SCAN, - OHOS_CAMERA_FOCUS_STATE_FOCUSED, - OHOS_CAMERA_FOCUS_STATE_UNFOCUSED, -} camera_focus_state_t; - -// OHOS_CONTROL_METER_MODE and OHOS_ABILITY_METER_MODES enumeration values -typedef enum camera_meter_mode { - OHOS_CAMERA_SPOT_METERING = 0, - OHOS_CAMERA_REGION_METERING, - OHOS_CAMERA_OVERALL_METERING, -} camera_meter_mode_t; - -typedef enum camera_exposure_state { - OHOS_CAMERA_EXPOSURE_STATE_SCAN, - OHOS_CAMERA_EXPOSURE_STATE_CONVERGED, -} camera_exposure_state_t; - -// OHOS_CONTROL_CAPTURE_MIRROR -// and OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED enumeration values -typedef enum camera_mirror { - OHOS_CAMERA_MIRROR_OFF = 0, - OHOS_CAMERA_MIRROR_ON, -} camera_mirror_t; - -// OHOS_JPEG_ORIENTATION enumeration values -typedef enum camera_jpeg_orientation { - OHOS_CAMERA_JPEG_ROTATION_0 = 0, - OHOS_CAMERA_JPEG_ROTATION_90 = 90, - OHOS_CAMERA_JPEG_ROTATION_180 = 180, - OHOS_CAMERA_JPEG_ROTATION_270 = 270, -} camera_jpeg_orientation_t; - -// OHOS_JPEG_QUALITY enumeration values -typedef enum camera_jpeg_quality { - OHOS_CAMERA_JPEG_LEVEL_LOW = 0, - OHOS_CAMERA_JPEG_LEVEL_MIDDLE, - OHOS_CAMERA_JPEG_LEVEL_HIGH, -} camera_jpeg_quality_t; - -// OHOS_ABILITY_VIDEO_STABILIZATION_MODES -// and OHOS_CONTROL_VIDEO_STABILIZATION_MODE enumeration values -typedef enum camera_video_stabilization_mode { - OHOS_CAMERA_VIDEO_STABILIZATION_OFF = 0, - OHOS_CAMERA_VIDEO_STABILIZATION_LOW, - OHOS_CAMERA_VIDEO_STABILIZATION_MIDDLE, - OHOS_CAMERA_VIDEO_STABILIZATION_HIGH, - OHOS_CAMERA_VIDEO_STABILIZATION_AUTO, -} CameraVideoStabilizationMode; - -// OHOS_ABILITY_FLASH_AVAILABLE enumeration values -typedef enum camera_flash_available { - OHOS_CAMERA_FLASH_FALSE = 0, - OHOS_CAMERA_FLASH_TRUE, -} CameraFlashAvailable; - -// OHOS_ABILITY_MEMORY_TYPE enumeration values -typedef enum camera_memory_type_enum { - OHOS_CAMERA_MEMORY_MMAP = 1, - OHOS_CAMERA_MEMORY_USERPTR, - OHOS_CAMERA_MEMORY_OVERLAY, - OHOS_CAMERA_MEMORY_DMABUF, -} camera_memory_type_enum_t; - -// OHOS_ABILITY_MUTE_MODES and OHOS_CONTROL_MUTE_MODE enumeration values -typedef enum camera_mute_mode { - OHOS_CAMERA_MUTE_MODE_OFF, - OHOS_CAMERA_MUTE_MODE_SOLID_COLOR_BLACK, -} camera_mute_mode_t; -#endif diff --git a/adapter/uhdf2/model/camera/metadata/include/camera_metadata_info.h b/adapter/uhdf2/model/camera/metadata/include/camera_metadata_info.h deleted file mode 100644 index 933b8d4bd2a1e31a546704479d5d1c9719b4a535..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/include/camera_metadata_info.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) 2021 - 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef CAMERA_METADATA_INFO_H -#define CAMERA_METADATA_INFO_H - -#include -#include -#include "camera_metadata_operator.h" - -namespace OHOS::Camera { -class CameraMetadata { -public: - CameraMetadata(size_t itemCapacity, size_t dataCapacity); - ~CameraMetadata(); - - bool addEntry(uint32_t item, const void *data, size_t data_count); - bool updateEntry(uint32_t tag, const void *data, size_t data_count); - common_metadata_header_t *get(); - const common_metadata_header_t *get() const; - bool isValid() const; - -private: - common_metadata_header_t *metadata_; - - bool resize_add_metadata(uint32_t item, const void *data, size_t data_count); - void replace_metadata(common_metadata_header_t *newMetadata); -}; -} // namespace Camera -#endif /* CAMERA_METADATA_INFO_H */ diff --git a/adapter/uhdf2/model/camera/metadata/include/camera_metadata_item_info.h b/adapter/uhdf2/model/camera/metadata/include/camera_metadata_item_info.h deleted file mode 100644 index 016663a5b3a48cc5fa43af0a023a54abde926a22..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/include/camera_metadata_item_info.h +++ /dev/null @@ -1,212 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef CAMERA_METADATA_ITEM_INFO_H -#define CAMERA_METADATA_ITEM_INFO_H - -#include "camera_metadata_operator.h" - -namespace OHOS::Camera { -const static size_t OHOS_CAMERA_METADATA_TYPE_SIZE[META_NUM_TYPES] = { - [META_TYPE_BYTE] = sizeof(uint8_t), - [META_TYPE_INT32] = sizeof(int32_t), - [META_TYPE_UINT32] = sizeof(uint32_t), - [META_TYPE_FLOAT] = sizeof(float), - [META_TYPE_INT64] = sizeof(int64_t), - [META_TYPE_DOUBLE] = sizeof(double), - [META_TYPE_RATIONAL] = sizeof(camera_rational_t) -}; - -static uint32_t g_ohosCameraSectionBounds[OHOS_SECTION_COUNT][2] = { - [OHOS_SECTION_CAMERA_PROPERTIES] = {OHOS_CAMERA_PROPERTIES_START, OHOS_CAMERA_PROPERTIES_END }, - [OHOS_SECTION_CAMERA_SENSOR] = {OHOS_CAMERA_SENSOR_START, OHOS_CAMERA_SENSOR_END }, - [OHOS_SECTION_CAMERA_SENSOR_INFO] = {OHOS_CAMERA_SENSOR_INFO_START, OHOS_CAMERA_SENSOR_INFO_END}, - [OHOS_SECTION_CAMERA_STATISTICS] = {OHOS_CAMERA_STATISTICS_START, OHOS_CAMERA_STATISTICS_END }, - [OHOS_SECTION_CAMERA_CONTROL] = {OHOS_DEVICE_CONTROL_START, OHOS_DEVICE_CONTROL_END }, - [OHOS_SECTION_DEVICE_EXPOSURE] = {OHOS_DEVICE_EXPOSURE_START, OHOS_DEVICE_EXPOSURE_END }, - [OHOS_SECTION_DEVICE_FOCUS] = {OHOS_DEVICE_FOCUS_START, OHOS_DEVICE_FOCUS_END }, - [OHOS_SECTION_DEVICE_FLASH] = {OHOS_DEVICE_FLASH_START, OHOS_DEVICE_FLASH_END }, - [OHOS_SECTION_DEVICE_ZOOM] = {OHOS_DEVICE_ZOOM_START, OHOS_DEVICE_ZOOM_END }, - [OHOS_SECTION_STREAM_ABILITY] = {OHOS_STREAM_ABILITY_START, OHOS_STREAM_ABILITY_END }, - [OHOS_SECTION_STREAM_JPEG] = {OHOS_STREAM_JPEG_START, OHOS_STREAM_JPEG_END }, - [OHOS_SECTION_STREAM_VIDEO] = {OHOS_STREAM_VIDEO_START, OHOS_STREAM_VIDEO_END }, -}; - -static item_info_t g_ohosCameraProperties[OHOS_CAMERA_PROPERTIES_END - OHOS_CAMERA_PROPERTIES_START] = { - [OHOS_ABILITY_CAMERA_POSITION - OHOS_CAMERA_PROPERTIES_START] = {"cameraPosition", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_CAMERA_TYPE - OHOS_CAMERA_PROPERTIES_START] = {"cameraType", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_CAMERA_CONNECTION_TYPE - - OHOS_CAMERA_PROPERTIES_START] = {"cameraConnectionType", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_MEMORY_TYPE - OHOS_CAMERA_PROPERTIES_START] = {"cameraMemoryType", META_TYPE_BYTE, 1}, - [OHOS_ABILITY_FPS_RANGES - OHOS_CAMERA_PROPERTIES_START] = {"fpsAvailableRanges", META_TYPE_INT32, -1}, - [OHOS_ABILITY_FLASH_AVAILABLE - OHOS_CAMERA_PROPERTIES_START] = {"flashAvailable", META_TYPE_BYTE, 1 }, - [OHOS_CAMERA_STREAM_ID - OHOS_CAMERA_PROPERTIES_START] = {"streamId", META_TYPE_INT32, 1 }, -}; - -static item_info_t g_ohosCameraSensor[OHOS_CAMERA_SENSOR_END - OHOS_CAMERA_SENSOR_START] = { - [OHOS_SENSOR_EXPOSURE_TIME - OHOS_CAMERA_SENSOR_START] = {"exposureTime", META_TYPE_INT64, 1}, - [OHOS_SENSOR_COLOR_CORRECTION_GAINS - OHOS_CAMERA_SENSOR_START] = {"colorCorrectuonGain", META_TYPE_FLOAT, 1}, - [OHOS_SENSOR_ORIENTATION - OHOS_CAMERA_SENSOR_START] = {"orientation", META_TYPE_INT32, 1}, - [OHOS_ABILITY_MUTE_MODES - OHOS_CAMERA_SENSOR_START] = {"muteAvailableModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_MUTE_MODE - OHOS_CAMERA_SENSOR_START] = {"muteMode", META_TYPE_BYTE, 1}, -}; - -static item_info_t g_ohosCameraSensorInfo[OHOS_CAMERA_SENSOR_INFO_END - OHOS_CAMERA_SENSOR_INFO_START] = { - [OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE - - OHOS_CAMERA_SENSOR_INFO_START] = {"activeArraySize", META_TYPE_INT32, -1}, - [OHOS_SENSOR_INFO_SENSITIVITY_RANGE - - OHOS_CAMERA_SENSOR_INFO_START] = {"sensitivityRange", META_TYPE_INT32, -1}, - [OHOS_SENSOR_INFO_MAX_FRAME_DURATION - - OHOS_CAMERA_SENSOR_INFO_START] = {"maxFrameDuration", META_TYPE_INT64, 1 }, - [OHOS_SENSOR_INFO_PHYSICAL_SIZE - OHOS_CAMERA_SENSOR_INFO_START] = {"physicalSize", META_TYPE_FLOAT, 1 }, - [OHOS_SENSOR_INFO_PIXEL_ARRAY_SIZE - - OHOS_CAMERA_SENSOR_INFO_START] = {"pixelArraySize", META_TYPE_INT32, -1}, - [OHOS_SENSOR_INFO_TIMESTAMP - OHOS_CAMERA_SENSOR_INFO_START] = {"sensorOutputTimeStamp", META_TYPE_INT64, 1 }, -}; - -static item_info_t g_ohosCameraStatistics[OHOS_CAMERA_STATISTICS_END - OHOS_CAMERA_STATISTICS_START] = { - [OHOS_STATISTICS_FACE_DETECT_MODE - OHOS_CAMERA_STATISTICS_START] = {"faceDetectMode", META_TYPE_BYTE, 1 }, - [OHOS_STATISTICS_FACE_DETECT_SWITCH - OHOS_CAMERA_STATISTICS_START] = {"faceDetectSwitch", META_TYPE_BYTE, 1 }, - [OHOS_STATISTICS_FACE_DETECT_MAX_NUM - OHOS_CAMERA_STATISTICS_START] = {"faceDetectMaxNum", META_TYPE_BYTE, 1 }, - [OHOS_STATISTICS_HISTOGRAM_MODE - OHOS_CAMERA_STATISTICS_START] = {"histogramMode", META_TYPE_BYTE, 1 }, - [OHOS_STATISTICS_FACE_IDS - OHOS_CAMERA_STATISTICS_START] = {"faceIds", META_TYPE_INT32, -1}, - [OHOS_STATISTICS_FACE_LANDMARKS - OHOS_CAMERA_STATISTICS_START] = {"faceLandmarks", META_TYPE_INT32, -1}, - [OHOS_STATISTICS_FACE_RECTANGLES - OHOS_CAMERA_STATISTICS_START] = {"faceRectangles", META_TYPE_FLOAT, -1}, - [OHOS_STATISTICS_FACE_SCORES - OHOS_CAMERA_STATISTICS_START] = {"faceScores", META_TYPE_BYTE, -1}, -}; - -static item_info_t g_ohosCameraControl[OHOS_DEVICE_CONTROL_END - OHOS_DEVICE_CONTROL_START] = { - [OHOS_CONTROL_AE_ANTIBANDING_MODE - - OHOS_DEVICE_CONTROL_START] = {"aeAntibandingMode", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AE_EXPOSURE_COMPENSATION - - OHOS_DEVICE_CONTROL_START] = {"aeExposureCompensation", META_TYPE_INT32, 1 }, - [OHOS_CONTROL_AE_LOCK - OHOS_DEVICE_CONTROL_START] = {"aeLock", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AE_MODE - OHOS_DEVICE_CONTROL_START] = {"aeMode", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AE_REGIONS - OHOS_DEVICE_CONTROL_START] = {"aeRegions", META_TYPE_INT32, -1}, - [OHOS_CONTROL_AE_TARGET_FPS_RANGE - - OHOS_DEVICE_CONTROL_START] = {"aeTargetFpsRange", META_TYPE_INT32, -1}, - [OHOS_CONTROL_FPS_RANGES - OHOS_DEVICE_CONTROL_START] = {"fpsRange", META_TYPE_INT32, -1}, - [OHOS_CONTROL_AF_MODE - OHOS_DEVICE_CONTROL_START] = {"afMode", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AF_REGIONS - OHOS_DEVICE_CONTROL_START] = {"afRegions", META_TYPE_INT32, -1}, - [OHOS_CONTROL_AF_TRIGGER - OHOS_DEVICE_CONTROL_START] = {"afTrigger", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AF_TRIGGER_ID - OHOS_DEVICE_CONTROL_START] = {"afTriggerId", META_TYPE_INT32, 1 }, - [OHOS_CONTROL_AF_STATE - OHOS_DEVICE_CONTROL_START] = {"afState", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AWB_LOCK - OHOS_DEVICE_CONTROL_START] = {"awbLock", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AWB_MODE - OHOS_DEVICE_CONTROL_START] = {"awbMode", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_AWB_REGIONS - OHOS_DEVICE_CONTROL_START] = {"awbRegions", META_TYPE_INT32, -1}, - [OHOS_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES - - OHOS_DEVICE_CONTROL_START] = {"aeAvailableAntibandingModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_AE_AVAILABLE_MODES - - OHOS_DEVICE_CONTROL_START] = {"aeAvailableModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES - - OHOS_DEVICE_CONTROL_START] = {"aeAvailableTargetFpsRanges", META_TYPE_INT32, -1}, - [OHOS_CONTROL_AE_COMPENSATION_RANGE - - OHOS_DEVICE_CONTROL_START] = {"aeCompensationRange", META_TYPE_INT32, -1}, - [OHOS_CONTROL_AE_COMPENSATION_STEP - - OHOS_DEVICE_CONTROL_START] = {"aeCompensationStep", META_TYPE_RATIONAL, 1 }, - [OHOS_CONTROL_AF_AVAILABLE_MODES - - OHOS_DEVICE_CONTROL_START] = {"afAvailableModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_AWB_AVAILABLE_MODES - - OHOS_DEVICE_CONTROL_START] = {"awbAvailableModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED - - OHOS_DEVICE_CONTROL_START] = {"mirrorSupported", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_CAPTURE_MIRROR - OHOS_DEVICE_CONTROL_START] = {"mirror", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_FOCUS_STATE - OHOS_DEVICE_CONTROL_START] = {"focusState", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_METER_POINT - OHOS_DEVICE_CONTROL_START] = {"meterPoint", META_TYPE_INT32, -1}, - [OHOS_CONTROL_METER_MODE - OHOS_DEVICE_CONTROL_START] = {"meterMode", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_EXPOSURE_STATE - OHOS_DEVICE_CONTROL_START] = {"exposureState", META_TYPE_BYTE, 1 }, -}; - -static item_info_t g_ohosDeviceExposure[OHOS_DEVICE_EXPOSURE_END - OHOS_DEVICE_EXPOSURE_START] = { - [OHOS_ABILITY_DEVICE_AVAILABLE_EXPOSUREMODES - - OHOS_DEVICE_EXPOSURE_START] = {"exposureAvailableModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_EXPOSUREMODE - OHOS_DEVICE_EXPOSURE_START] = {"exposureMode", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_EXPOSURE_MODES - OHOS_DEVICE_EXPOSURE_START] = {"exposureSupportiveModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_EXPOSURE_MODE - OHOS_DEVICE_EXPOSURE_START] = {"exMode", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_METER_MODES - OHOS_DEVICE_EXPOSURE_START] = {"meterAvailableModes", META_TYPE_BYTE, -1}, -}; - -static item_info_t g_ohosDeviceFocus[OHOS_DEVICE_FOCUS_END - OHOS_DEVICE_FOCUS_START] = { - [OHOS_ABILITY_DEVICE_AVAILABLE_FOCUSMODES - - OHOS_DEVICE_FOCUS_START] = {"focusAvailablesModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_FOCUSMODE - OHOS_DEVICE_FOCUS_START] = {"focusMode", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_FOCUS_MODES - OHOS_DEVICE_FOCUS_START] = {"focusSupportiveModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_FOCUS_MODE - OHOS_DEVICE_FOCUS_START] = {"fMode", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_FOCAL_LENGTH - OHOS_DEVICE_FOCUS_START] = {"focalLength", META_TYPE_FLOAT, 1 }, -}; - -static item_info_t g_ohosDeviceFlash[OHOS_DEVICE_FLASH_END - OHOS_DEVICE_FLASH_START] = { - [OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES - OHOS_DEVICE_FLASH_START] = {"flashAvailablesModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_FLASHMODE - OHOS_DEVICE_FLASH_START] = {"flashMode", META_TYPE_BYTE, 1 }, - [OHOS_ABILITY_FLASH_MODES - OHOS_DEVICE_FLASH_START] = {"flashSupportiveModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_FLASH_MODE - OHOS_DEVICE_FLASH_START] = {"flaMode", META_TYPE_BYTE, 1 }, - [OHOS_CONTROL_FLASH_STATE - OHOS_DEVICE_FLASH_START] = {"flashstate", META_TYPE_BYTE, 1 }, -}; - -static item_info_t g_ohosDeviceZoom[OHOS_DEVICE_ZOOM_END - OHOS_DEVICE_ZOOM_START] = { - [OHOS_ABILITY_ZOOM_RATIO_RANGE - OHOS_DEVICE_ZOOM_START] = {"zoomRange", META_TYPE_FLOAT, -1}, - [OHOS_CONTROL_ZOOM_RATIO - OHOS_DEVICE_ZOOM_START] = {"zoomRatio", META_TYPE_FLOAT, 1 }, - [OHOS_CONTROL_ZOOM_CROP_REGION - OHOS_DEVICE_ZOOM_START] = {"zoomCropRegion", META_TYPE_INT32, -1}, - [OHOS_ABILITY_ZOOM_CAP - OHOS_DEVICE_ZOOM_START] = {"zoomCap", META_TYPE_INT32, -1}, - [OHOS_ABILITY_SCENE_ZOOM_CAP - OHOS_DEVICE_ZOOM_START] = {"sceneZoomCap", META_TYPE_INT32, -1}, -}; - -static item_info_t g_ohosStreamAbility[OHOS_STREAM_ABILITY_END - OHOS_STREAM_ABILITY_START] = { - [OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS - - OHOS_STREAM_ABILITY_START] = {"streamAvailableConfigurations", META_TYPE_INT32, -1}, - [OHOS_STREAM_AVAILABLE_FORMATS - - OHOS_STREAM_ABILITY_START] = {"streamAvailableFormats", META_TYPE_INT32, -1}, - [OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS - - OHOS_STREAM_ABILITY_START] = {"streamExtendConfigurations", META_TYPE_INT32, -1}, - [OHOS_ABILITY_STREAM_THUMBNAIL_AVAILABLE - - OHOS_STREAM_ABILITY_START] = {"streamThumbnailAvailable", META_TYPE_BYTE, 1}, -}; - -static item_info_t g_ohosStreamJpeg[OHOS_STREAM_JPEG_END - OHOS_STREAM_JPEG_START] = { - [OHOS_JPEG_GPS_COORDINATES - OHOS_STREAM_JPEG_START] = {"gpsCoordinates", META_TYPE_DOUBLE, -1}, - [OHOS_JPEG_GPS_PROCESSING_METHOD - OHOS_STREAM_JPEG_START] = {"gpsProcessingMethod", META_TYPE_BYTE, 1 }, - [OHOS_JPEG_GPS_TIMESTAMP - OHOS_STREAM_JPEG_START] = {"gpsTimestamp", META_TYPE_INT64, 1 }, - [OHOS_JPEG_ORIENTATION - OHOS_STREAM_JPEG_START] = {"orientation", META_TYPE_INT32, 1 }, - [OHOS_JPEG_QUALITY - OHOS_STREAM_JPEG_START] = {"quality", META_TYPE_BYTE, 1 }, - [OHOS_JPEG_THUMBNAIL_QUALITY - OHOS_STREAM_JPEG_START] = {"thumbnailQuality", META_TYPE_BYTE, 1 }, - [OHOS_JPEG_THUMBNAIL_SIZE - OHOS_STREAM_JPEG_START] = {"thumbnailSize", META_TYPE_INT32, -1}, - [OHOS_JPEG_AVAILABLE_THUMBNAIL_SIZES - OHOS_STREAM_JPEG_START] = {"availableThumbnailSizes", META_TYPE_INT32, -1}, - [OHOS_JPEG_MAX_SIZE - OHOS_STREAM_JPEG_START] = {"maxSize", META_TYPE_INT32, 1 }, - [OHOS_JPEG_SIZE - OHOS_STREAM_JPEG_START] = {"size", META_TYPE_INT32, 1 }, -}; - -static item_info_t g_ohosStreamVideo[OHOS_STREAM_VIDEO_END - OHOS_STREAM_VIDEO_START] = { - [OHOS_ABILITY_VIDEO_STABILIZATION_MODES - - OHOS_STREAM_VIDEO_START] = {"videoAvailableStabilizationModes", META_TYPE_BYTE, -1}, - [OHOS_CONTROL_VIDEO_STABILIZATION_MODE - - OHOS_STREAM_VIDEO_START] = {"videoStabilizationMode", META_TYPE_BYTE, 1 }, -}; - -const static item_info_t *g_ohosItemInfo[OHOS_SECTION_COUNT] = { - g_ohosCameraProperties, - g_ohosCameraSensor, - g_ohosCameraSensorInfo, - g_ohosCameraStatistics, - g_ohosCameraControl, - g_ohosDeviceExposure, - g_ohosDeviceFocus, - g_ohosDeviceFlash, - g_ohosDeviceZoom, - g_ohosStreamAbility, - g_ohosStreamJpeg, - g_ohosStreamVideo, -}; -} // namespace Camera -#endif /* CAMERA_METADATA_ITEM_INFO_H */ diff --git a/adapter/uhdf2/model/camera/metadata/include/camera_metadata_operator.h b/adapter/uhdf2/model/camera/metadata/include/camera_metadata_operator.h deleted file mode 100644 index 4ee4a7c7695dc1ff0685ff2111cd559021e11421..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/include/camera_metadata_operator.h +++ /dev/null @@ -1,204 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef CAMERA_METADATA_OPERATOR_H -#define CAMERA_METADATA_OPERATOR_H - -#include -#include -#include - -#include "camera_device_ability_items.h" - -/** Versioning information */ -#define CURRENT_CAMERA_METADATA_VERSION 1 - -#define ITEM_ALIGNMENT ((size_t) 4) - -#define DATA_ALIGNMENT ((size_t) 8) - -#define METADATA_ALIGNMENT ((size_t) 4) - -#define METADATA_PACKET_ALIGNMENT \ - MaxAlignment(MaxAlignment(DATA_ALIGNMENT, METADATA_ALIGNMENT), ITEM_ALIGNMENT) - -#define INDEX_COUNTER 2 -#define WRAP_LENGTH 4 - -// data type -enum { - // uint8_t - META_TYPE_BYTE = 0, - // int32_t - META_TYPE_INT32 = 1, - // uint32_t - META_TYPE_UINT32 = 2, - // float - META_TYPE_FLOAT = 3, - // int64_t - META_TYPE_INT64 = 4, - // double - META_TYPE_DOUBLE = 5, - // A 64-bit fraction (camera_metadata_rational_t) - META_TYPE_RATIONAL = 6, - // Number of data type - META_NUM_TYPES -}; - -const static char *OHOS_CAMERA_METADATA_TYPE[META_NUM_TYPES] = { - [META_TYPE_BYTE] = "byte", - [META_TYPE_INT32] = "int32", - [META_TYPE_UINT32] = "uint32", - [META_TYPE_FLOAT] = "float", - [META_TYPE_INT64] = "int64", - [META_TYPE_DOUBLE] = "double", - [META_TYPE_RATIONAL] = "rational" -}; - -typedef struct camera_rational { - int32_t numerator; - int32_t denominator; -} camera_rational_t; - -// common metadata header -typedef struct common_metadata_header { - uint32_t version; - uint32_t size; - uint32_t item_count; - uint32_t item_capacity; - uint32_t items_start; // Offset from common_metadata_header - uint32_t data_count; - uint32_t data_capacity; - uint32_t data_start; // Offset from common_metadata_header -} common_metadata_header_t; - -typedef struct camera_metadata_item_entry { - uint32_t item; - uint32_t data_type; - uint32_t count; - union { - uint32_t offset; - uint8_t value[4]; - } data; -} camera_metadata_item_entry_t; - -typedef struct camera_metadata_item { - uint32_t index; - uint32_t item; - uint32_t data_type; - uint32_t count; - union { - uint8_t *u8; - int32_t *i32; - uint32_t *ui32; - float *f; - int64_t *i64; - double *d; - camera_rational_t *r; - } data; -} camera_metadata_item_t; - -typedef struct item_info { - const char *item_name; - uint8_t item_type; - int32_t dataCnt; -} item_info_t; - -/* camera_metadata_section */ -typedef enum camera_metadata_sec { - OHOS_SECTION_CAMERA_PROPERTIES, - OHOS_SECTION_CAMERA_SENSOR, - OHOS_SECTION_CAMERA_SENSOR_INFO, - OHOS_SECTION_CAMERA_STATISTICS, - OHOS_SECTION_CAMERA_CONTROL, - OHOS_SECTION_DEVICE_EXPOSURE, - OHOS_SECTION_DEVICE_FOCUS, - OHOS_SECTION_DEVICE_FLASH, - OHOS_SECTION_DEVICE_ZOOM, - OHOS_SECTION_STREAM_ABILITY, - OHOS_SECTION_STREAM_JPEG, - OHOS_SECTION_STREAM_VIDEO, - OHOS_SECTION_COUNT, -} camera_metadata_sec_t; - -/* Return codes */ -#define CAM_META_FAILURE (-1) -#define CAM_META_SUCCESS 0 -#define CAM_META_INVALID_PARAM 2 -#define CAM_META_ITEM_NOT_FOUND 3 -#define CAM_META_ITEM_CAP_EXCEED 4 -#define CAM_META_DATA_CAP_EXCEED 5 - -/* for shift opereration */ -#define BITWISE_SHIFT_16 16 - -namespace OHOS::Camera { -uint32_t AlignTo(uint32_t val, uint32_t alignment); - -uint32_t MaxAlignment(uint32_t dataAlignment, uint32_t metadataAlignment); - -// Allocate a new camera metadata buffer and return the metadata header -common_metadata_header_t *AllocateCameraMetadataBuffer(uint32_t item_capacity, uint32_t data_capacity); - -// Find camera metadata item and fill the found item -int FindCameraMetadataItem(const common_metadata_header_t *src, uint32_t item, camera_metadata_item_t *metadataItem); - -// Find camera metadata item index if the item exists -int FindCameraMetadataItemIndex(const common_metadata_header_t *src, uint32_t item, uint32_t *index); - -// Get camera metadata item name -const char *GetCameraMetadataItemName(uint32_t item); - -// Update camera metadata item and fill the updated item -int UpdateCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data, uint32_t dataCount, - camera_metadata_item_t *updatedItem); - -// Update camera metadata item by index and fill the updated item -int UpdateCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index, const void *data, - uint32_t dataCount, camera_metadata_item_t *updated_item); - -// Add camera metadata item -int AddCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data, size_t dataCount); - -// Delete camera metadata item -int DeleteCameraMetadataItem(common_metadata_header_t *dst, uint32_t item); - -// Delete camera metadata item by index -int DeleteCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index); - -// Free camera metadata buffer -void FreeCameraMetadataBuffer(common_metadata_header_t *dst); - -std::string MetadataItemDump(const common_metadata_header_t *metadataHeader, uint32_t item); - -std::string FormatCameraMetadataToString(const common_metadata_header_t *metadataHeader); - -// Internal use -camera_metadata_item_entry_t *GetMetadataItems(const common_metadata_header_t *metadataHeader); -uint8_t *GetMetadataData(const common_metadata_header_t *metadataHeader); -int GetCameraMetadataItem(const common_metadata_header_t *src, uint32_t index, camera_metadata_item_t *item); -uint32_t GetCameraMetadataItemCount(const common_metadata_header_t *metadata_header); -uint32_t GetCameraMetadataItemCapacity(const common_metadata_header_t *metadata_header); -uint32_t GetCameraMetadataDataSize(const common_metadata_header_t *metadata_header); -int32_t CopyCameraMetadataItems(common_metadata_header_t *newMetadata, const common_metadata_header_t *oldMetadata); -size_t CalculateCameraMetadataItemDataSize(uint32_t type, size_t data_count); -int32_t GetCameraMetadataItemType(uint32_t item, uint32_t *data_type); -common_metadata_header_t *FillCameraMetadata(common_metadata_header_t *buffer, size_t memoryRequired, - uint32_t itemCapacity, uint32_t dataCapacity); -int32_t GetMetadataSection(uint32_t itemSection, uint32_t *section); -int MetadataExpandItemMem(common_metadata_header_t *dst, camera_metadata_item_entry_t *item, - size_t oldItemSize); -} // Camera -#endif // CAMERA_METADATA_OPERATOR_H diff --git a/adapter/uhdf2/model/camera/metadata/include/metadata_log.h b/adapter/uhdf2/model/camera/metadata/include/metadata_log.h deleted file mode 100644 index 1db3e599edeb04255c4f167d999ffda03e0390ec..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/include/metadata_log.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_CAMERA_LOG_H -#define OHOS_CAMERA_LOG_H - -#include - -#include "hilog/log.h" - -#undef LOG_DOMAIN -#undef LOG_TAG -#define LOG_DOMAIN 0xD002B00 -#define LOG_TAG "METADATA" - -#define FILENAME (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__) - -#ifndef OHOS_DEBUG -#define DECORATOR_HILOG(op, fmt, args...) \ - do { \ - op(LOG_CORE, fmt, ##args); \ - } while (0) -#else -#define DECORATOR_HILOG(op, fmt, args...) \ - do { \ - op(LOG_CORE, "{%s()-%s:%d} " fmt, __FUNCTION__, FILENAME, __LINE__, ##args); \ - } while (0) -#endif - -#ifdef DEBUG_BUILD -#define METADATA_DEBUG_LOG(fmt, ...) DECORATOR_HILOG(HILOG_DEBUG, fmt, ##__VA_ARGS__) -#else -#define METADATA_DEBUG_LOG(fmt, ...) -#endif - -#define METADATA_ERR_LOG(fmt, ...) DECORATOR_HILOG(HILOG_ERROR, fmt, ##__VA_ARGS__) -#define METADATA_WARNING_LOG(fmt, ...) DECORATOR_HILOG(HILOG_WARN, fmt, ##__VA_ARGS__) -#define METADATA_INFO_LOG(fmt, ...) DECORATOR_HILOG(HILOG_INFO, fmt, ##__VA_ARGS__) -#define METADATA_FATAL_LOG(fmt, ...) DECORATOR_HILOG(HILOG_FATAL, fmt, ##__VA_ARGS__) - -#define METADATA_OK 0 -#define METADATA_INVALID_PARAM (-1) -#define METADATA_INIT_FAIL (-2) -#define METADATA_ERR (-3) -#define METADATA_PERMISSION_DENIED (-4) - -#endif // OHOS_CAMERA_LOG_H diff --git a/adapter/uhdf2/model/camera/metadata/include/metadata_utils.h b/adapter/uhdf2/model/camera/metadata/include/metadata_utils.h deleted file mode 100644 index 830fbc2a929859aaa388d2f4218a3f48747dfb25..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/include/metadata_utils.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_CAMERA_METADATA_UTILS_H -#define OHOS_CAMERA_METADATA_UTILS_H - -#include -#include -#include -#include - -#include "camera_metadata_info.h" -#include "message_parcel.h" - -namespace OHOS::Camera { -class MetadataUtils { -public: - static bool EncodeCameraMetadata(const std::shared_ptr &metadata, - MessageParcel &data); - static void DecodeCameraMetadata(MessageParcel &data, std::shared_ptr &metadata); - - static std::string EncodeToString(std::shared_ptr metadata); - static std::shared_ptr DecodeFromString(std::string setting); - static bool ConvertMetadataToVec(const std::shared_ptr &metadata, - std::vector& cameraAbility); - static void ConvertVecToMetadata(const std::vector& cameraAbility, - std::shared_ptr &metadata); - static void FreeMetadataBuffer(camera_metadata_item_t &entry); - -private: - static bool WriteMetadata(const camera_metadata_item_t &item, MessageParcel &data); - static bool ReadMetadata(camera_metadata_item_t &item, MessageParcel &data); - static void ItemDataToBuffer(const camera_metadata_item_t &item, void **buffer); - static bool WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector& cameraAbility); - static bool ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry, - const std::vector& cameraAbility); - template static void WriteData(T data, std::vector& cameraAbility); - template static void ReadData(T &data, int32_t &index, const std::vector& cameraAbility); -}; - -template -void MetadataUtils::WriteData(T data, std::vector& cameraAbility) -{ - T dataTemp = data; - uint8_t *dataPtr = reinterpret_cast(&dataTemp); - for (size_t j = 0; j < sizeof(T); j++) { - cameraAbility.push_back(*(dataPtr + j)); - } -} - -template -void MetadataUtils::ReadData(T &data, int32_t &index, const std::vector& cameraAbility) -{ - constexpr uint32_t typeLen = sizeof(T); - uint8_t array[typeLen] = {0}; - T *ptr = nullptr; - for (size_t j = 0; j < sizeof(T); j++) { - array[j] = cameraAbility.at(index++); - } - ptr = reinterpret_cast(array); - data = *ptr; -} -} // namespace Camera -#endif // OHOS_CAMERA_METADATA_UTILS_H diff --git a/adapter/uhdf2/model/camera/metadata/src/camera_metadata_info.cpp b/adapter/uhdf2/model/camera/metadata/src/camera_metadata_info.cpp deleted file mode 100644 index 60f9623bcacda4bb3c1b17feeac76e9d446b1665..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/src/camera_metadata_info.cpp +++ /dev/null @@ -1,152 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "camera_metadata_info.h" -#include -#include "metadata_log.h" - -namespace OHOS::Camera { -CameraMetadata::CameraMetadata(size_t itemCapacity, size_t dataCapacity) -{ - metadata_ = AllocateCameraMetadataBuffer(itemCapacity, AlignTo(dataCapacity, DATA_ALIGNMENT)); -} - -CameraMetadata::~CameraMetadata() -{ - if (metadata_) { - FreeCameraMetadataBuffer(metadata_); - metadata_ = nullptr; - } -} - -bool CameraMetadata::addEntry(uint32_t item, const void *data, size_t data_count) -{ - if (metadata_ == nullptr) { - METADATA_ERR_LOG("metadata_ is null"); - return false; - } - - auto result = AddCameraMetadataItem(metadata_, item, data, data_count); - if (!result) { - return true; - } - - if (result != CAM_META_ITEM_CAP_EXCEED && result != CAM_META_DATA_CAP_EXCEED) { - const char *name = GetCameraMetadataItemName(item); - - if (name) { - METADATA_ERR_LOG("Failed to add tag. tagname = %{public}s", name); - } else { - METADATA_ERR_LOG("Failed to add unknown tag"); - } - return false; - } - - return resize_add_metadata(item, data, data_count); -} - -bool CameraMetadata::resize_add_metadata(uint32_t item, const void *data, size_t data_count) -{ - uint32_t data_type; - - auto itemCapacity = GetCameraMetadataItemCapacity(metadata_); - auto data_capacity = GetCameraMetadataDataSize(metadata_); - - int32_t ret = GetCameraMetadataItemType(item, &data_type); - if (ret != CAM_META_SUCCESS) { - METADATA_ERR_LOG("GetCameraMetadataItemType invalid item type"); - return false; - } - size_t size = CalculateCameraMetadataItemDataSize(data_type, data_count); - - common_metadata_header_t *newMetadata = AllocateCameraMetadataBuffer((itemCapacity + 1) * INDEX_COUNTER, - AlignTo((data_capacity + size) * INDEX_COUNTER, DATA_ALIGNMENT)); - - if (newMetadata == nullptr) { - METADATA_ERR_LOG("Failed to resize the metadata buffer"); - return false; - } - - auto result = CopyCameraMetadataItems(newMetadata, metadata_); - if (result != CAM_META_SUCCESS) { - METADATA_ERR_LOG("Failed to copy the old metadata to new metadata"); - FreeCameraMetadataBuffer(newMetadata); - return false; - } - - result = AddCameraMetadataItem(newMetadata, item, data, data_count); - if (result != CAM_META_SUCCESS) { - METADATA_ERR_LOG("Failed to add new entry"); - FreeCameraMetadataBuffer(newMetadata); - return false; - } - replace_metadata(newMetadata); - - return true; -} - -void CameraMetadata::replace_metadata(common_metadata_header_t *newMetadata) -{ - if (metadata_ == newMetadata) { - return; - } - - FreeCameraMetadataBuffer(metadata_); - metadata_ = newMetadata; -} - -bool CameraMetadata::updateEntry(uint32_t tag, const void *data, size_t dataCount) -{ - if (metadata_ == nullptr) { - METADATA_ERR_LOG("metadata_ is null"); - return false; - } - - const char *name = GetCameraMetadataItemName(tag); - (void)name; - camera_metadata_item_t item; - int ret = FindCameraMetadataItem(metadata_, tag, &item); - if (ret) { - METADATA_ERR_LOG("Failed to update tag tagname = %{public}s : not present", (name ? name : "")); - return false; - } - METADATA_INFO_LOG("updateEntry item id: %{public}d, name: %{public}s, " - "dataCount: %{public}zu", tag, name ? name : "", dataCount); - ret = UpdateCameraMetadataItemByIndex(metadata_, item.index, data, dataCount, nullptr); - if (ret) { - const char *name_ = GetCameraMetadataItemName(tag); - (void)name_; - METADATA_ERR_LOG("Failed to update tag tagname = %{public}s", (name_ ? name_ : "")); - return false; - } - - return true; -} - -common_metadata_header_t *CameraMetadata::get() -{ - return metadata_; -} - -const common_metadata_header_t *CameraMetadata::get() const -{ - return metadata_; -} - -bool CameraMetadata::isValid() const -{ - return metadata_ != nullptr; -} -} // Camera diff --git a/adapter/uhdf2/model/camera/metadata/src/camera_metadata_operator.cpp b/adapter/uhdf2/model/camera/metadata/src/camera_metadata_operator.cpp deleted file mode 100644 index 6bfb5595560be1326de92e7fc8991c2af5b96a2c..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/src/camera_metadata_operator.cpp +++ /dev/null @@ -1,1003 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "camera_metadata_operator.h" -#include -#include -#include "camera_metadata_item_info.h" -#include "metadata_log.h" - -namespace OHOS::Camera { -const int METADATA_HEADER_DATA_SIZE = 4; -const std::vector METADATATAGS = { - OHOS_ABILITY_CAMERA_POSITION, - OHOS_ABILITY_CAMERA_TYPE, - OHOS_ABILITY_CAMERA_CONNECTION_TYPE, - OHOS_ABILITY_MEMORY_TYPE, - OHOS_ABILITY_FPS_RANGES, - OHOS_ABILITY_FLASH_AVAILABLE, - OHOS_CAMERA_STREAM_ID, - - OHOS_SENSOR_EXPOSURE_TIME, - OHOS_SENSOR_COLOR_CORRECTION_GAINS, - OHOS_SENSOR_ORIENTATION, - OHOS_ABILITY_MUTE_MODES, - OHOS_CONTROL_MUTE_MODE, - - OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, - OHOS_SENSOR_INFO_SENSITIVITY_RANGE, - OHOS_SENSOR_INFO_MAX_FRAME_DURATION, - OHOS_SENSOR_INFO_PHYSICAL_SIZE, - OHOS_SENSOR_INFO_PIXEL_ARRAY_SIZE, - OHOS_SENSOR_INFO_TIMESTAMP, - - OHOS_STATISTICS_FACE_DETECT_MODE, - OHOS_STATISTICS_FACE_DETECT_SWITCH, - OHOS_STATISTICS_FACE_DETECT_MAX_NUM, - OHOS_STATISTICS_HISTOGRAM_MODE, - OHOS_STATISTICS_FACE_IDS, - OHOS_STATISTICS_FACE_LANDMARKS, - OHOS_STATISTICS_FACE_RECTANGLES, - OHOS_STATISTICS_FACE_SCORES, - - OHOS_CONTROL_AE_ANTIBANDING_MODE, - OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, - OHOS_CONTROL_AE_LOCK, - OHOS_CONTROL_AE_MODE, - OHOS_CONTROL_AE_REGIONS, - OHOS_CONTROL_AE_TARGET_FPS_RANGE, - OHOS_CONTROL_FPS_RANGES, - OHOS_CONTROL_AF_MODE, - OHOS_CONTROL_AF_REGIONS, - OHOS_CONTROL_AF_TRIGGER, - OHOS_CONTROL_AF_TRIGGER_ID, - OHOS_CONTROL_AF_STATE, - OHOS_CONTROL_AWB_LOCK, - OHOS_CONTROL_AWB_MODE, - OHOS_CONTROL_AWB_REGIONS, - OHOS_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, - OHOS_CONTROL_AE_AVAILABLE_MODES, - OHOS_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, - OHOS_CONTROL_AE_COMPENSATION_RANGE, - OHOS_CONTROL_AE_COMPENSATION_STEP, - OHOS_CONTROL_AF_AVAILABLE_MODES, - OHOS_CONTROL_AWB_AVAILABLE_MODES, - OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, - OHOS_CONTROL_CAPTURE_MIRROR, - OHOS_CONTROL_FOCUS_STATE, - OHOS_CONTROL_METER_POINT, - OHOS_CONTROL_METER_MODE, - OHOS_CONTROL_EXPOSURE_STATE, - - // Camera device image acquisition related - OHOS_ABILITY_DEVICE_AVAILABLE_EXPOSUREMODES, - OHOS_CONTROL_EXPOSUREMODE, - OHOS_ABILITY_EXPOSURE_MODES, - OHOS_CONTROL_EXPOSURE_MODE, - OHOS_ABILITY_METER_MODES, - - OHOS_ABILITY_DEVICE_AVAILABLE_FOCUSMODES, - OHOS_CONTROL_FOCUSMODE, - OHOS_ABILITY_FOCUS_MODES, - OHOS_CONTROL_FOCUS_MODE, - OHOS_ABILITY_FOCAL_LENGTH, - - OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES, - OHOS_CONTROL_FLASHMODE, - OHOS_ABILITY_FLASH_MODES, - OHOS_CONTROL_FLASH_MODE, - OHOS_CONTROL_FLASH_STATE, - - OHOS_ABILITY_ZOOM_RATIO_RANGE, - OHOS_CONTROL_ZOOM_RATIO, - OHOS_CONTROL_ZOOM_CROP_REGION, - OHOS_ABILITY_ZOOM_CAP, - OHOS_ABILITY_SCENE_ZOOM_CAP, - - // Camera flow control related - OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, - OHOS_STREAM_AVAILABLE_FORMATS, - OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, - - OHOS_JPEG_GPS_COORDINATES, - OHOS_JPEG_GPS_PROCESSING_METHOD, - OHOS_JPEG_GPS_TIMESTAMP, - OHOS_JPEG_ORIENTATION, - OHOS_JPEG_QUALITY, - OHOS_JPEG_THUMBNAIL_QUALITY, - OHOS_JPEG_THUMBNAIL_SIZE, - OHOS_JPEG_AVAILABLE_THUMBNAIL_SIZES, - OHOS_JPEG_MAX_SIZE, - OHOS_JPEG_SIZE, - - OHOS_ABILITY_VIDEO_STABILIZATION_MODES, - OHOS_CONTROL_VIDEO_STABILIZATION_MODE, -}; - -uint32_t AlignTo(uint32_t val, uint32_t alignment) -{ - return static_cast((static_cast(val) + ((alignment) - 1)) & ~((alignment) - 1)); -} - -uint32_t MaxAlignment(uint32_t dataAlignment, uint32_t metadataAlignment) -{ - return ((dataAlignment > metadataAlignment) ? dataAlignment : metadataAlignment); -} - -uint8_t *GetMetadataData(const common_metadata_header_t *metadataHeader) -{ - if (!metadataHeader) { - METADATA_ERR_LOG("GetMetadataData metadataHeader is null"); - return nullptr; - } - return (uint8_t *)metadataHeader + metadataHeader->data_start; -} - -camera_metadata_item_entry_t *GetMetadataItems(const common_metadata_header_t *metadataHeader) -{ - return reinterpret_cast( - (reinterpret_cast(const_cast(metadataHeader)) + - metadataHeader->items_start)); -} - -common_metadata_header_t *FillCameraMetadata(common_metadata_header_t *buffer, size_t memoryRequired, - uint32_t itemCapacity, uint32_t dataCapacity) -{ - METADATA_DEBUG_LOG("FillCameraMetadata start"); - if (buffer == nullptr) { - METADATA_ERR_LOG("FillCameraMetadata buffer is null"); - return nullptr; - } - - common_metadata_header_t *metadataHeader = static_cast(buffer); - metadataHeader->version = CURRENT_CAMERA_METADATA_VERSION; - metadataHeader->size = memoryRequired; - metadataHeader->item_count = 0; - metadataHeader->item_capacity = itemCapacity; - metadataHeader->items_start = AlignTo(sizeof(common_metadata_header_t), ITEM_ALIGNMENT); - metadataHeader->data_count = 0; - metadataHeader->data_capacity = dataCapacity; - size_t dataUnaligned = reinterpret_cast(GetMetadataItems(metadataHeader) + - metadataHeader->item_capacity) - reinterpret_cast(metadataHeader); - metadataHeader->data_start = AlignTo(dataUnaligned, DATA_ALIGNMENT); - - METADATA_DEBUG_LOG("FillCameraMetadata end"); - return metadataHeader; -} - -size_t CalculateCameraMetadataMemoryRequired(uint32_t itemCount, uint32_t dataCount) -{ - METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired start"); - size_t memoryRequired = sizeof(common_metadata_header_t); - memoryRequired = AlignTo(memoryRequired, ITEM_ALIGNMENT); - - memoryRequired += sizeof(camera_metadata_item_entry_t[itemCount]); - memoryRequired = AlignTo(memoryRequired, DATA_ALIGNMENT); - - memoryRequired += sizeof(uint8_t[dataCount]); - memoryRequired = AlignTo(memoryRequired, METADATA_PACKET_ALIGNMENT); - - METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired memoryRequired: %{public}zu", memoryRequired); - METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired end"); - return memoryRequired; -} - -common_metadata_header_t *AllocateCameraMetadataBuffer(uint32_t item_capacity, uint32_t data_capacity) -{ - METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer start"); - METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer item_capacity: %{public}u, data_capacity: %{public}u", - item_capacity, data_capacity); - size_t memoryRequired = CalculateCameraMetadataMemoryRequired(item_capacity, data_capacity); - void *buffer = calloc(1, memoryRequired); - if (buffer == nullptr) { - METADATA_ERR_LOG("AllocateCameraMetadataBuffer memory allocation failed"); - return reinterpret_cast(buffer); - } - - common_metadata_header_t *metadataHeader = FillCameraMetadata(reinterpret_cast(buffer), - memoryRequired, - item_capacity, data_capacity); - if (metadataHeader == nullptr) { - METADATA_ERR_LOG("AllocateCameraMetadataBuffer metadataHeader is null"); - free(buffer); - } - - METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer end"); - return metadataHeader; -} - -int32_t GetMetadataSection(uint32_t itemSection, uint32_t *section) -{ - METADATA_DEBUG_LOG("GetMetadataSection start"); - if (itemSection < OHOS_CAMERA_PROPERTIES || - itemSection >= OHOS_ABILITY_SECTION_END) { - METADATA_ERR_LOG("GetMetadataSection itemSection is not valid"); - return CAM_META_FAILURE; - } - - int32_t ret = CAM_META_SUCCESS; - switch (itemSection) { - case OHOS_CAMERA_PROPERTIES: - *section = OHOS_SECTION_CAMERA_PROPERTIES; - break; - case OHOS_CAMERA_SENSOR: - *section = OHOS_SECTION_CAMERA_SENSOR; - break; - case OHOS_CAMERA_SENSOR_INFO: - *section = OHOS_SECTION_CAMERA_SENSOR_INFO; - break; - case OHOS_CAMERA_STATISTICS: - *section = OHOS_SECTION_CAMERA_STATISTICS; - break; - case OHOS_DEVICE_CONTROL: - *section = OHOS_SECTION_CAMERA_CONTROL; - break; - case OHOS_DEVICE_EXPOSURE: - *section = OHOS_SECTION_DEVICE_EXPOSURE; - break; - case OHOS_DEVICE_FOCUS: - *section = OHOS_SECTION_DEVICE_FOCUS; - break; - case OHOS_DEVICE_FLASH: - *section = OHOS_SECTION_DEVICE_FLASH; - break; - case OHOS_DEVICE_ZOOM: - *section = OHOS_SECTION_DEVICE_ZOOM; - break; - case OHOS_STREAM_ABILITY: - *section = OHOS_SECTION_STREAM_ABILITY; - break; - case OHOS_STREAM_JPEG: - *section = OHOS_SECTION_STREAM_JPEG; - break; - case OHOS_STREAM_VIDEO: - *section = OHOS_SECTION_STREAM_VIDEO; - break; - default: - METADATA_ERR_LOG("GetMetadataSection item section is not defined"); - ret = CAM_META_FAILURE; - break; - } - - METADATA_DEBUG_LOG("GetMetadataSection end"); - return ret; -} - -int32_t GetCameraMetadataItemType(uint32_t item, uint32_t *dataType) -{ - METADATA_DEBUG_LOG("GetCameraMetadataItemType start"); - if (dataType == nullptr) { - METADATA_ERR_LOG("GetCameraMetadataItemType dataType is null"); - return CAM_META_INVALID_PARAM; - } - uint32_t section; - int32_t ret = GetMetadataSection(item >> BITWISE_SHIFT_16, §ion); - if (ret != CAM_META_SUCCESS) { - METADATA_ERR_LOG("GetCameraMetadataItemType section is not valid"); - return ret; - } - - if (item >= g_ohosCameraSectionBounds[section][1]) { - METADATA_ERR_LOG("GetCameraMetadataItemType item is not in section bound"); - return CAM_META_FAILURE; - } - - uint32_t itemIndex = item & 0xFFFF; - if (g_ohosItemInfo[section][itemIndex].item_type < META_TYPE_BYTE) { - METADATA_ERR_LOG("GetCameraMetadataItemType item is not initialized"); - return CAM_META_FAILURE; - } - - *dataType = g_ohosItemInfo[section][itemIndex].item_type; - - METADATA_DEBUG_LOG("GetCameraMetadataItemType end"); - return CAM_META_SUCCESS; -} - -const char *GetCameraMetadataItemName(uint32_t item) -{ - METADATA_DEBUG_LOG("GetCameraMetadataItemName start"); - METADATA_DEBUG_LOG("GetCameraMetadataItemName item: %{public}u", item); - uint32_t section; - int32_t ret = GetMetadataSection(item >> BITWISE_SHIFT_16, §ion); - if (ret != CAM_META_SUCCESS) { - METADATA_ERR_LOG("GetCameraMetadataItemName section is not valid"); - return nullptr; - } - - if (item >= g_ohosCameraSectionBounds[section][1]) { - METADATA_ERR_LOG("GetCameraMetadataItemName item is not in section bound"); - return nullptr; - } - - uint32_t itemIndex = item & 0xFFFF; - METADATA_DEBUG_LOG("GetCameraMetadataItemName end"); - return g_ohosItemInfo[section][itemIndex].item_name; -} - -size_t CalculateCameraMetadataItemDataSize(uint32_t type, size_t dataCount) -{ - METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize start"); - if (type < META_TYPE_BYTE || type >= META_NUM_TYPES) { - METADATA_ERR_LOG("CalculateCameraMetadataItemDataSize invalid type"); - return 0; - } - - size_t dataBytes = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[type]; - - METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize end"); - return (dataBytes <= METADATA_HEADER_DATA_SIZE) ? 0 : AlignTo(dataBytes, DATA_ALIGNMENT); -} - -int AddCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data, size_t dataCount) -{ - METADATA_DEBUG_LOG("AddCameraMetadataItem start"); - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - name = ""; - } - METADATA_DEBUG_LOG("AddCameraMetadataItem item id: %{public}u, name: %{public}s, " - "dataCount: %{public}zu", item, name, dataCount); - - if (dst == nullptr) { - METADATA_ERR_LOG("AddCameraMetadataItem common_metadata_header_t is null"); - return CAM_META_INVALID_PARAM; - } - - if (!dataCount || data == nullptr) { - METADATA_ERR_LOG("AddCameraMetadataItem data is not valid. item: %{public}u, " - "dataCount: %{public}zu", item, dataCount); - return CAM_META_INVALID_PARAM; - } - - if (dst->item_count == dst->item_capacity) { - METADATA_ERR_LOG("AddCameraMetadataItem item_capacity limit reached. " - "item_count: %{public}d, item_capacity: %{public}d", - dst->item_count, dst->item_capacity); - return CAM_META_ITEM_CAP_EXCEED; - } - - uint32_t dataType; - int32_t ret = GetCameraMetadataItemType(item, &dataType); - if (ret != CAM_META_SUCCESS) { - METADATA_ERR_LOG("AddCameraMetadataItem invalid item type"); - return CAM_META_INVALID_PARAM; - } - - size_t dataBytes = - CalculateCameraMetadataItemDataSize(dataType, dataCount); - if (dataBytes + dst->data_count > dst->data_capacity) { - METADATA_ERR_LOG("AddCameraMetadataItem data_capacity limit reached"); - return CAM_META_DATA_CAP_EXCEED; - } - - size_t dataPayloadBytes = - dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[dataType]; - camera_metadata_item_entry_t *metadataItem = GetMetadataItems(dst) + dst->item_count; - ret = memset_s(metadataItem, sizeof(camera_metadata_item_entry_t), 0, sizeof(camera_metadata_item_entry_t)); - if (ret != EOK) { - METADATA_ERR_LOG("AddCameraMetadataItem: memset_s failed"); - return CAM_META_FAILURE; - } - metadataItem->item = item; - metadataItem->data_type = dataType; - metadataItem->count = dataCount; - - if (dataBytes == 0) { - ret = memcpy_s(metadataItem->data.value, METADATA_HEADER_DATA_SIZE, data, dataPayloadBytes); - if (ret != EOK) { - METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed"); - return CAM_META_FAILURE; - } - } else { - metadataItem->data.offset = dst->data_count; - ret = memcpy_s(GetMetadataData(dst) + metadataItem->data.offset, dst->data_capacity - dst->data_count, data, - dataPayloadBytes); - if (ret != EOK) { - METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed"); - return CAM_META_FAILURE; - } - dst->data_count += dataBytes; - } - dst->item_count++; - - METADATA_DEBUG_LOG("AddCameraMetadataItem end"); - return CAM_META_SUCCESS; -} - -int GetCameraMetadataItem(const common_metadata_header_t *src, uint32_t index, camera_metadata_item_t *item) -{ - METADATA_DEBUG_LOG("GetCameraMetadataItem start"); - if (src == nullptr || item == nullptr) { - METADATA_ERR_LOG("GetCameraMetadataItem src or item is null"); - return CAM_META_INVALID_PARAM; - } - - int32_t ret = memset_s(item, sizeof(camera_metadata_item_t), 0, sizeof(camera_metadata_item_t)); - if (ret != EOK) { - METADATA_ERR_LOG("GetCameraMetadataItem: memset_s failed"); - return CAM_META_FAILURE; - } - if (index >= src->item_count) { - METADATA_ERR_LOG("GetCameraMetadataItem index is greater than item count"); - return CAM_META_INVALID_PARAM; - } - - camera_metadata_item_entry_t *localItem = GetMetadataItems(src) + index; - - item->index = index; - item->item = localItem->item; - item->data_type = localItem->data_type; - item->count = localItem->count; - - size_t dataBytes = CalculateCameraMetadataItemDataSize(localItem->data_type, localItem->count); - if (dataBytes == 0) { - item->data.u8 = localItem->data.value; - } else { - item->data.u8 = GetMetadataData(src) + localItem->data.offset; - } - - METADATA_DEBUG_LOG("GetCameraMetadataItem end"); - return CAM_META_SUCCESS; -} - -int FindCameraMetadataItemIndex(const common_metadata_header_t *src, uint32_t item, uint32_t *idx) -{ - METADATA_DEBUG_LOG("FindCameraMetadataItemIndex start"); - METADATA_DEBUG_LOG("FindCameraMetadataItemIndex item: %{public}u", item); - if (src == nullptr || idx == nullptr) { - METADATA_ERR_LOG("FindCameraMetadataItemIndex src or index is null"); - return CAM_META_INVALID_PARAM; - } - - camera_metadata_item_entry_t *searchItem = GetMetadataItems(src); - uint32_t index; - for (index = 0; index < src->item_count; index++, searchItem++) { - if (searchItem->item == item) { - break; - } - } - - if (index == src->item_count) { - METADATA_ERR_LOG("FindCameraMetadataItemIndex item: %{public}u not found", item); - return CAM_META_ITEM_NOT_FOUND; - } - - *idx = index; - METADATA_DEBUG_LOG("FindCameraMetadataItemIndex index: %{public}u", index); - METADATA_DEBUG_LOG("FindCameraMetadataItemIndex end"); - return CAM_META_SUCCESS; -} - -int FindCameraMetadataItem(const common_metadata_header_t *src, uint32_t item, camera_metadata_item_t *metadataItem) -{ - uint32_t index = 0; - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - name = ""; - } - METADATA_DEBUG_LOG("FindCameraMetadataItem item id: %{public}u, name: %{public}s", item, name); - int ret = FindCameraMetadataItemIndex(src, item, &index); - if (ret != CAM_META_SUCCESS) { - return ret; - } - - return GetCameraMetadataItem(src, index, metadataItem); -} - -void SetOffset(camera_metadata_item_entry_t *metadataItems, camera_metadata_item_entry_t *item, size_t oldItemSize) -{ - if (CalculateCameraMetadataItemDataSize(metadataItems->data_type, metadataItems->count) > 0 && - metadataItems->data.offset > item->data.offset) { - metadataItems->data.offset -= oldItemSize; - } -} - -int MetadataExpandItemMem(common_metadata_header_t *dst, camera_metadata_item_entry_t *item, - size_t oldItemSize) -{ - if (item == nullptr || dst == nullptr) { - METADATA_ERR_LOG("MetadataExpandItemMem item is null or dst is null"); - return CAM_META_INVALID_PARAM; - } - uint8_t *start = GetMetadataData(dst) + item->data.offset; - uint8_t *end = start + oldItemSize; - size_t length = dst->data_count - item->data.offset - oldItemSize; - if (length != 0) { - int32_t ret = memmove_s(start, length, end, length); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataExpandItemMem memory move failed"); - return CAM_META_FAILURE; - } - } - dst->data_count -= oldItemSize; - - camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst); - for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) { - SetOffset(metadataItems, item, oldItemSize); - } - - return CAM_META_SUCCESS; -} - -int UpdateCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index, const void *data, uint32_t dataCount, - camera_metadata_item_t *updatedItem) -{ - METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex start"); - if ((dst == nullptr) || (index >= dst->item_count)) { - METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex dst is null or invalid index"); - return CAM_META_INVALID_PARAM; - } - - if (!dataCount || data == nullptr) { - METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data is not valid. " - "dataCount: %{public}u", dataCount); - return CAM_META_INVALID_PARAM; - } - - int32_t ret = CAM_META_SUCCESS; - camera_metadata_item_entry_t *item = GetMetadataItems(dst) + index; - size_t dataSize = CalculateCameraMetadataItemDataSize(item->data_type, dataCount); - size_t dataPayloadSize = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[item->data_type]; - - size_t oldItemSize = CalculateCameraMetadataItemDataSize(item->data_type, item->count); - if (dataSize != oldItemSize) { - if (dst->data_capacity < (dst->data_count + dataSize - oldItemSize)) { - METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data_capacity limit reached"); - return CAM_META_DATA_CAP_EXCEED; - } - - if (oldItemSize != 0) { - ret = MetadataExpandItemMem(dst, item, oldItemSize); - if (ret != CAM_META_SUCCESS) { - return ret; - } - } - - if (dataSize != 0) { - item->data.offset = dst->data_count; - ret = memcpy_s(GetMetadataData(dst) + item->data.offset, dataPayloadSize, data, dataPayloadSize); - if (ret != EOK) { - METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed"); - return CAM_META_FAILURE; - } - dst->data_count += dataSize; - } - } else if (dataSize != 0) { - ret = memcpy_s(GetMetadataData(dst) + item->data.offset, dataPayloadSize, data, dataPayloadSize); - if (ret != EOK) { - METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed"); - return CAM_META_FAILURE; - } - } - - if (dataSize == 0) { - ret = memcpy_s(item->data.value, dataPayloadSize, data, dataPayloadSize); - if (ret != EOK) { - METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed"); - return CAM_META_FAILURE; - } - } - - item->count = dataCount; - if (updatedItem != nullptr) { - ret = GetCameraMetadataItem(dst, index, updatedItem); - if (ret != CAM_META_SUCCESS) { - return ret; - } - } - - METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex end"); - return ret; -} - -int UpdateCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data, - uint32_t dataCount, camera_metadata_item_t *updatedItem) -{ - METADATA_DEBUG_LOG("UpdateCameraMetadataItem item id: %{public}u, dataCount: %{public}u", item, dataCount); - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - name = ""; - } - METADATA_DEBUG_LOG("UpdateCameraMetadataItem item id: %{public}u, name: %{public}s, " - "dataCount: %{public}u", item, name, dataCount); - if (!dataCount || data == nullptr) { - METADATA_ERR_LOG("UpdateCameraMetadataItem data is not valid. item: %{public}u, " - "dataCount: %{public}u", item, dataCount); - return CAM_META_INVALID_PARAM; - } - - uint32_t index = 0; - int32_t ret = FindCameraMetadataItemIndex(dst, item, &index); - if (ret != CAM_META_SUCCESS) { - return ret; - } - - return UpdateCameraMetadataItemByIndex(dst, index, data, dataCount, updatedItem); -} - -int DeleteCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index) -{ - METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex start"); - if (dst == nullptr) { - METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex dst is null"); - return CAM_META_INVALID_PARAM; - } - - if (index >= dst->item_count) { - METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex item not valid"); - return CAM_META_INVALID_PARAM; - } - - int32_t ret = CAM_META_SUCCESS; - camera_metadata_item_entry_t *itemToDelete = GetMetadataItems(dst) + index; - size_t dataBytes = CalculateCameraMetadataItemDataSize(itemToDelete->data_type, itemToDelete->count); - if (dataBytes > 0) { - uint8_t *start = GetMetadataData(dst) + itemToDelete->data.offset; - uint8_t *end = start + dataBytes; - size_t length = dst->data_count - itemToDelete->data.offset - dataBytes; - if (length != 0) { - ret = memmove_s(start, length, end, length); - if (ret != EOK) { - METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed"); - return CAM_META_FAILURE; - } - } - dst->data_count -= dataBytes; - - camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst); - for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) { - if (CalculateCameraMetadataItemDataSize( - metadataItems->data_type, metadataItems->count) > 0 && - metadataItems->data.offset > itemToDelete->data.offset) { - metadataItems->data.offset -= dataBytes; - } - } - } - - uint64_t length = sizeof(camera_metadata_item_entry_t) * (dst->item_count - index - 1); - if (length != 0) { - ret = memmove_s(itemToDelete, length, itemToDelete + 1, length); - if (ret != EOK) { - METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed"); - return CAM_META_FAILURE; - } - } - dst->item_count -= 1; - METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex end"); - return ret; -} - -int DeleteCameraMetadataItem(common_metadata_header_t *dst, uint32_t item) -{ - METADATA_DEBUG_LOG("DeleteCameraMetadataItem item: %{public}u", item); - uint32_t index = 0; - int32_t ret = FindCameraMetadataItemIndex(dst, item, &index); - if (ret != CAM_META_SUCCESS) { - return ret; - } - - return DeleteCameraMetadataItemByIndex(dst, index); -} - -void FreeCameraMetadataBuffer(common_metadata_header_t *dst) -{ - if (dst != nullptr) { - free(dst); - } -} - -uint32_t GetCameraMetadataItemCount(const common_metadata_header_t *metadataHeader) -{ - if (!metadataHeader) { - METADATA_ERR_LOG("GetCameraMetadataItemCount::metadataHeader is null"); - return 0; - } - return metadataHeader->item_count; -} - -uint32_t GetCameraMetadataItemCapacity(const common_metadata_header_t *metadataHeader) -{ - if (!metadataHeader) { - METADATA_ERR_LOG("GetCameraMetadataItemCapacity::metadataHeader is null"); - return 0; - } - return metadataHeader->item_capacity; -} - -uint32_t GetCameraMetadataDataSize(const common_metadata_header_t *metadataHeader) -{ - if (metadataHeader == nullptr) { - METADATA_ERR_LOG("GetCameraMetadataDataSize::metadataHeader is null"); - return 0; - } - return metadataHeader->data_capacity; -} - -int32_t CopyCameraMetadataItems(common_metadata_header_t *newMetadata, const common_metadata_header_t *oldMetadata) -{ - if (newMetadata == nullptr || oldMetadata == nullptr) { - return CAM_META_INVALID_PARAM; - } - - int32_t ret; - if (oldMetadata->item_count != 0) { - ret = memcpy_s(GetMetadataItems(newMetadata), sizeof(camera_metadata_item_entry_t[oldMetadata->item_count]), - GetMetadataItems(oldMetadata), sizeof(camera_metadata_item_entry_t[oldMetadata->item_count])); - if (ret != EOK) { - METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed"); - return CAM_META_FAILURE; - } - } - - if (oldMetadata->data_count != 0) { - ret = memcpy_s(GetMetadataData(newMetadata), sizeof(uint8_t[oldMetadata->data_count]), - GetMetadataData(oldMetadata), sizeof(uint8_t[oldMetadata->data_count])); - if (ret != EOK) { - METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed"); - return CAM_META_FAILURE; - } - } - - newMetadata->item_count = oldMetadata->item_count; - newMetadata->data_count = oldMetadata->data_count; - - return CAM_META_SUCCESS; -} - -std::string U8ItemToString(int32_t item, const camera_metadata_item_t entry) -{ - std::string st = {}; - uint32_t count = entry.count; - std::string dataStr = std::to_string(*(entry.data.u8)); - for (uint32_t i = 1; i < count; i++) { - if ((i % WRAP_LENGTH) == 0) { - dataStr += "]\n\t[" + std::to_string(*(entry.data.u8 + i)); - } else { - dataStr += " " + std::to_string(*(entry.data.u8 + i)); - } - } - - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - METADATA_ERR_LOG("U8ItemToString: get u8 item name fail!"); - return st; - } - std::string nameStr(name); - - st = nameStr + " (" + std::to_string(entry.index) + "): " + - OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]"; - - return st; -} - -std::string I32ItemToString(int32_t item, const camera_metadata_item_t entry) -{ - std::string st = {}; - uint32_t count = entry.count; - std::string dataStr = std::to_string(*(entry.data.i32)); - for (uint32_t i = 1; i < count; i++) { - if ((i % WRAP_LENGTH) == 0) { - dataStr += "]\n\t[" + std::to_string(*(entry.data.i32 + i)); - } else { - dataStr += " " + std::to_string(*(entry.data.i32 + i)); - } - } - - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - METADATA_ERR_LOG("I32ItemToString: get i32 item name fail!"); - return st; - } - std::string nameStr(name); - - st = nameStr + " (" + std::to_string(entry.index) + "): " + - OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]"; - - return st; -} - -std::string U32ItemToString(int32_t item, const camera_metadata_item_t entry) -{ - std::string st = {}; - uint32_t count = entry.count; - std::string dataStr = std::to_string(*(entry.data.ui32)); - for (uint32_t i = 1; i < count; i++) { - if ((i % WRAP_LENGTH) == 0) { - dataStr += "]\n\t[" + std::to_string(*(entry.data.ui32 + i)); - } else { - dataStr += " " + std::to_string(*(entry.data.ui32 + i)); - } - } - - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - METADATA_ERR_LOG("U32ItemToString: get u32 item name fail!"); - return st; - } - std::string nameStr(name); - - st = nameStr + " (" + std::to_string(entry.index) + "): " + - OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]"; - - return st; -} - -std::string I64ItemToString(int32_t item, const camera_metadata_item_t entry) -{ - std::string st = {}; - uint32_t count = entry.count; - std::string dataStr = std::to_string(*(entry.data.i64)); - for (uint32_t i = 1; i < count; i++) { - if ((i % WRAP_LENGTH) == 0) { - dataStr += "]\n\t[" + std::to_string(*(entry.data.i64 + i)); - } else { - dataStr += " " + std::to_string(*(entry.data.i64 + i)); - } - } - - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - METADATA_ERR_LOG("I64ItemToString: get i64 item name fail!"); - return st; - } - std::string nameStr(name); - - st = nameStr + " (" + std::to_string(entry.index) + "): " + - OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]"; - - return st; -} - -std::string FloatItemToString(int32_t item, const camera_metadata_item_t entry) -{ - std::string st = {}; - uint32_t count = entry.count; - std::string dataStr = std::to_string(*(entry.data.f)); - for (uint32_t i = 1; i < count; i++) { - if ((i % WRAP_LENGTH) == 0) { - dataStr += "]\n\t[" + std::to_string(*(entry.data.f + i)); - } else { - dataStr += " " + std::to_string(*(entry.data.f + i)); - } - } - - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - METADATA_ERR_LOG("FloatItemToString: get float item name fail!"); - return st; - } - std::string nameStr(name); - - st = nameStr + " (" + std::to_string(entry.index) + "): " + - OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]"; - - return st; -} - -std::string DoubleItemToString(int32_t item, const camera_metadata_item_t entry) -{ - std::string st = {}; - uint32_t count = entry.count; - std::string dataStr = std::to_string(*(entry.data.d)); - for (uint32_t i = 1; i < count; i++) { - if ((i % WRAP_LENGTH) == 0) { - dataStr += "]\n\t[" + std::to_string(*(entry.data.d + i)); - } else { - dataStr += " " + std::to_string(*(entry.data.d + i)); - } - } - - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - METADATA_ERR_LOG("DoubleItemToString: get double item name fail!"); - return st; - } - std::string nameStr(name); - - st = nameStr + " (" + std::to_string(entry.index) + "): " + - OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]"; - - return st; -} - -std::string RationalItemToString(int32_t item, const camera_metadata_item_t entry) -{ - std::string st = {}; - uint32_t count = entry.count; - std::string dataStr = std::to_string((*(entry.data.r)).numerator) + "/" + - std::to_string((*(entry.data.r)).denominator); - for (uint32_t i = 1; i < count; i++) { - if ((i % WRAP_LENGTH) == 0) { - dataStr += "]\n\t[" + std::to_string((*(entry.data.r + i)).numerator) + "/" + - std::to_string((*(entry.data.r + i)).denominator); - } else { - dataStr += " " + std::to_string((*(entry.data.r + i)).numerator) + "/" + - std::to_string((*(entry.data.r + i)).denominator); - } - } - - const char *name = GetCameraMetadataItemName(item); - if (name == nullptr) { - METADATA_ERR_LOG("RationalItemToString: get rational item name fail!"); - return st; - } - std::string nameStr(name); - - st = nameStr + " (" + std::to_string(entry.index) + "): " + - OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]"; - - return st; -} - -std::string MetadataItemDump(const common_metadata_header_t *metadataHeader, uint32_t item) -{ - camera_metadata_item_t entry; - std::string st = {}; - - int ret = FindCameraMetadataItem(metadataHeader, item, &entry); - if (ret != 0) { - METADATA_ERR_LOG("get item error and item = %{public}d", item); - return st; - } - - switch (entry.data_type) { - case META_TYPE_BYTE: - st = U8ItemToString(item, entry); - break; - case META_TYPE_INT32: - st = I32ItemToString(item, entry); - break; - case META_TYPE_UINT32: - st = U32ItemToString(item, entry); - break; - case META_TYPE_FLOAT: - st = FloatItemToString(item, entry); - break; - case META_TYPE_INT64: - st = I64ItemToString(item, entry); - break; - case META_TYPE_DOUBLE: - st = DoubleItemToString(item, entry); - break; - case META_TYPE_RATIONAL: - st = RationalItemToString(item, entry); - break; - default: - METADATA_ERR_LOG("invalid param and item = %{public}d", item); - break; - } - - if (!st.empty()) { - st += "\n"; - } - return st; -} - -std::string FormatCameraMetadataToString(const common_metadata_header_t *metadataHeader) -{ - std::string metaStr; - if (metadataHeader == nullptr) { - METADATA_ERR_LOG("metadataHeader is nullptr"); - return metaStr; - } - - for (auto it = METADATATAGS.begin(); it != METADATATAGS.end(); it++) { - metaStr += MetadataItemDump(metadataHeader, *it); - } - - return metaStr; -} -} // Camera diff --git a/adapter/uhdf2/model/camera/metadata/src/metadata_utils.cpp b/adapter/uhdf2/model/camera/metadata/src/metadata_utils.cpp deleted file mode 100644 index f3155129d1a68c567f9e743fe83c0adf728561f4..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/metadata/src/metadata_utils.cpp +++ /dev/null @@ -1,585 +0,0 @@ -/* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "metadata_utils.h" -#include -#include "metadata_log.h" - -namespace OHOS::Camera { -bool MetadataUtils::WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector& cameraAbility) -{ - if (entry.data_type == META_TYPE_BYTE) { - for (size_t i = 0; i < entry.count; i++) { - WriteData(*(entry.data.u8 + i), cameraAbility); - } - } else if (entry.data_type == META_TYPE_INT32) { - for (size_t i = 0; i < entry.count; i++) { - WriteData(*(entry.data.i32 + i), cameraAbility); - } - } else if (entry.data_type == META_TYPE_FLOAT) { - for (size_t i = 0; i < entry.count; i++) { - WriteData(*(entry.data.f + i), cameraAbility); - } - } else if (entry.data_type == META_TYPE_INT64) { - for (size_t i = 0; i < entry.count; i++) { - WriteData(*(entry.data.i64 + i), cameraAbility); - } - } else if (entry.data_type == META_TYPE_DOUBLE) { - for (size_t i = 0; i < entry.count; i++) { - WriteData(*(entry.data.d + i), cameraAbility); - } - } else if (entry.data_type == META_TYPE_RATIONAL) { - for (size_t i = 0; i < entry.count; i++) { - WriteData((*(entry.data.r + i)).numerator, cameraAbility); - WriteData((*(entry.data.r + i)).denominator, cameraAbility); - } - } - - return true; -} - -bool MetadataUtils::ConvertMetadataToVec(const std::shared_ptr &metadata, - std::vector& cameraAbility) -{ - if (metadata == nullptr) { - return false; - } - - bool bRet = true; - uint32_t tagCount = 0; - common_metadata_header_t *meta = metadata->get(); - if (meta != nullptr) { - tagCount = GetCameraMetadataItemCount(meta); - WriteData(tagCount, cameraAbility); - WriteData(GetCameraMetadataItemCapacity(meta), cameraAbility); - WriteData(GetCameraMetadataDataSize(meta), cameraAbility); - for (uint32_t i = 0; i < tagCount; i++) { - camera_metadata_item_t item; - int ret = GetCameraMetadataItem(meta, i, &item); - if (ret != CAM_META_SUCCESS) { - return false; - } - - WriteData(item.index, cameraAbility); - WriteData(item.item, cameraAbility); - WriteData(item.data_type, cameraAbility); - WriteData(item.count, cameraAbility); - - bRet = WriteMetadataDataToVec(item, cameraAbility); - } - } else { - cameraAbility.push_back(tagCount); - } - - return bRet; -} - -bool MetadataUtils::EncodeCameraMetadata(const std::shared_ptr &metadata, - MessageParcel &data) -{ - if (metadata == nullptr) { - return false; - } - - bool bRet = true; - uint32_t tagCount = 0; - common_metadata_header_t *meta = metadata->get(); - if (meta != nullptr) { - tagCount = GetCameraMetadataItemCount(meta); - bRet = bRet && data.WriteUint32(tagCount); - bRet = bRet && data.WriteUint32(GetCameraMetadataItemCapacity(meta)); - bRet = bRet && data.WriteUint32(GetCameraMetadataDataSize(meta)); - for (uint32_t i = 0; i < tagCount; i++) { - camera_metadata_item_t item; - int ret = GetCameraMetadataItem(meta, i, &item); - if (ret != CAM_META_SUCCESS) { - return false; - } - - bRet = bRet && data.WriteUint32(item.index); - bRet = bRet && data.WriteUint32(item.item); - bRet = bRet && data.WriteUint32(item.data_type); - bRet = bRet && data.WriteUint32(item.count); - bRet = bRet && MetadataUtils::WriteMetadata(item, data); - } - } else { - bRet = data.WriteUint32(tagCount); - } - return bRet; -} - -bool MetadataUtils::ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry, - const std::vector& cameraAbility) -{ - if (entry.data_type == META_TYPE_BYTE) { - entry.data.u8 = new(std::nothrow) uint8_t[entry.count]; - if (entry.data.u8 != nullptr) { - for (size_t i = 0; i < entry.count; i++) { - ReadData(entry.data.u8[i], index, cameraAbility); - } - } - } else if (entry.data_type == META_TYPE_INT32) { - entry.data.i32 = new(std::nothrow) int32_t[entry.count]; - if (entry.data.i32 != nullptr) { - for (size_t i = 0; i < entry.count; i++) { - ReadData(entry.data.i32[i], index, cameraAbility); - } - } - } else if (entry.data_type == META_TYPE_FLOAT) { - entry.data.f = new(std::nothrow) float[entry.count]; - if (entry.data.f != nullptr) { - for (size_t i = 0; i < entry.count; i++) { - ReadData(entry.data.f[i], index, cameraAbility); - } - } - } else if (entry.data_type == META_TYPE_INT64) { - entry.data.i64 = new(std::nothrow) int64_t[entry.count]; - if (entry.data.i64 != nullptr) { - for (size_t i = 0; i < entry.count; i++) { - ReadData(entry.data.i64[i], index, cameraAbility); - } - } - } else if (entry.data_type == META_TYPE_DOUBLE) { - entry.data.d = new(std::nothrow) double[entry.count]; - if (entry.data.d != nullptr) { - for (size_t i = 0; i < entry.count; i++) { - ReadData(entry.data.d[i], index, cameraAbility); - } - } - } else if (entry.data_type == META_TYPE_RATIONAL) { - entry.data.r = new(std::nothrow) camera_rational_t[entry.count]; - if (entry.data.r != nullptr) { - for (size_t i = 0; i < entry.count; i++) { - ReadData(entry.data.r[i].numerator, index, cameraAbility); - ReadData(entry.data.r[i].denominator, index, cameraAbility); - } - } - } - - return true; -} - -void MetadataUtils::ConvertVecToMetadata(const std::vector& cameraAbility, - std::shared_ptr &metadata) -{ - int32_t index = 0; - uint32_t tagCount = 0; - uint32_t itemCapacity = 0; - uint32_t dataCapacity = 0; - constexpr uint32_t MAX_SUPPORTED_TAGS = 1000; - constexpr uint32_t MAX_SUPPORTED_ITEMS = 1000; - constexpr uint32_t MAX_ITEM_CAPACITY = (1000 * 10); - constexpr uint32_t MAX_DATA_CAPACITY = (1000 * 10 * 10); - - ReadData(tagCount, index, cameraAbility); - if (tagCount > MAX_SUPPORTED_TAGS) { - tagCount = MAX_SUPPORTED_TAGS; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value"); - } - ReadData(itemCapacity, index, cameraAbility); - if (itemCapacity > MAX_ITEM_CAPACITY) { - itemCapacity = MAX_ITEM_CAPACITY; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata itemCapacity is more than supported value"); - } - ReadData(dataCapacity, index, cameraAbility); - if (dataCapacity > MAX_DATA_CAPACITY) { - dataCapacity = MAX_DATA_CAPACITY; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata dataCapacity is more than supported value"); - } - - std::vector items; - for (uint32_t i = 0; i < tagCount; i++) { - camera_metadata_item_t item; - ReadData(item.index, index, cameraAbility); - ReadData(item.item, index, cameraAbility); - ReadData(item.data_type, index, cameraAbility); - ReadData(item.count, index, cameraAbility); - if (item.count > MAX_SUPPORTED_ITEMS) { - item.count = MAX_SUPPORTED_ITEMS; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata item.count is more than supported value"); - } - ReadMetadataDataFromVec(index, item, cameraAbility); - items.push_back(item); - } - - metadata = std::make_shared(itemCapacity, dataCapacity); - common_metadata_header_t *meta = metadata->get(); - for (auto &item_ : items) { - void *buffer = nullptr; - MetadataUtils::ItemDataToBuffer(item_, &buffer); - (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count); - FreeMetadataBuffer(item_); - } -} - -void MetadataUtils::DecodeCameraMetadata(MessageParcel &data, std::shared_ptr &metadata) -{ - uint32_t tagCount = data.ReadUint32(); - uint32_t itemCapacity = data.ReadUint32(); - uint32_t dataCapacity = data.ReadUint32(); - constexpr uint32_t MAX_SUPPORTED_TAGS = 1000; - constexpr uint32_t MAX_SUPPORTED_ITEMS = 1000; - constexpr uint32_t MAX_ITEM_CAPACITY = (1000 * 10); - constexpr uint32_t MAX_DATA_CAPACITY = (1000 * 10 * 10); - - if (tagCount > MAX_SUPPORTED_TAGS) { - tagCount = MAX_SUPPORTED_TAGS; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value"); - } - - if (itemCapacity > MAX_ITEM_CAPACITY) { - itemCapacity = MAX_ITEM_CAPACITY; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata itemCapacity is more than supported value"); - } - - if (dataCapacity > MAX_DATA_CAPACITY) { - dataCapacity = MAX_DATA_CAPACITY; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata dataCapacity is more than supported value"); - } - - std::vector items; - for (uint32_t i = 0; i < tagCount; i++) { - camera_metadata_item_t item; - item.index = data.ReadUint32(); - item.item = data.ReadUint32(); - item.data_type = data.ReadUint32(); - item.count = data.ReadUint32(); - if (item.count > MAX_SUPPORTED_ITEMS) { - item.count = MAX_SUPPORTED_ITEMS; - METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata item.count is more than supported value"); - } - MetadataUtils::ReadMetadata(item, data); - items.push_back(item); - } - - metadata = std::make_shared(itemCapacity, dataCapacity); - common_metadata_header_t *meta = metadata->get(); - for (auto &item_ : items) { - void *buffer = nullptr; - MetadataUtils::ItemDataToBuffer(item_, &buffer); - (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count); - FreeMetadataBuffer(item_); - } -} - -bool MetadataUtils::WriteMetadata(const camera_metadata_item_t &item, MessageParcel &data) -{ - bool bRet = false; - size_t i; - if (item.data_type == META_TYPE_BYTE) { - std::vector byteBuffers; - for (i = 0; i < item.count; i++) { - byteBuffers.push_back(*(item.data.u8 + i)); - } - bRet = data.WriteUInt8Vector(byteBuffers); - } else if (item.data_type == META_TYPE_INT32) { - std::vector int32Buffers; - for (i = 0; i < item.count; i++) { - int32Buffers.push_back(*(item.data.i32 + i)); - } - bRet = data.WriteInt32Vector(int32Buffers); - } else if (item.data_type == META_TYPE_FLOAT) { - std::vector floatBuffers; - for (i = 0; i < item.count; i++) { - floatBuffers.push_back(*(item.data.f + i)); - } - bRet = data.WriteFloatVector(floatBuffers); - } else if (item.data_type == META_TYPE_UINT32) { - std::vector uInt32Buffers; - for (i = 0; i < item.count; i++) { - uInt32Buffers.push_back(*(item.data.ui32 + i)); - } - bRet = data.WriteUInt32Vector(uInt32Buffers); - } else if (item.data_type == META_TYPE_INT64) { - std::vector int64Buffers; - for (i = 0; i < item.count; i++) { - int64Buffers.push_back(*(item.data.i64 + i)); - } - bRet = data.WriteInt64Vector(int64Buffers); - } else if (item.data_type == META_TYPE_DOUBLE) { - std::vector doubleBuffers; - for (i = 0; i < item.count; i++) { - doubleBuffers.push_back(*(item.data.d + i)); - } - bRet = data.WriteDoubleVector(doubleBuffers); - } else if (item.data_type == META_TYPE_RATIONAL) { - std::vector rationalBuffers; - for (i = 0; i < item.count; i++) { - rationalBuffers.push_back((*(item.data.r + i)).numerator); - rationalBuffers.push_back((*(item.data.r + i)).denominator); - } - bRet = data.WriteInt32Vector(rationalBuffers); - } - - return bRet; -} - -std::string MetadataUtils::EncodeToString(std::shared_ptr metadata) -{ - int32_t ret; - const int32_t headerLength = sizeof(common_metadata_header_t); - const int32_t itemLen = sizeof(camera_metadata_item_entry_t); - const int32_t itemFixedLen = static_cast(offsetof(camera_metadata_item_entry_t, data)); - - if (metadata == nullptr || metadata->get() == nullptr) { - METADATA_ERR_LOG("MetadataUtils::EncodeToString Metadata is invalid"); - return {}; - } - - common_metadata_header_t *meta = metadata->get(); - int32_t encodeDataLen = headerLength + (itemLen * meta->item_count) + meta->data_count; - std::string s(encodeDataLen, '\0'); - char *encodeData = &s[0]; - ret = memcpy_s(encodeData, encodeDataLen, meta, headerLength); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for metadata header"); - return {}; - } - encodeData += headerLength; - encodeDataLen -= headerLength; - camera_metadata_item_entry_t *item = GetMetadataItems(meta); - for (uint32_t index = 0; index < meta->item_count; index++, item++) { - ret = memcpy_s(encodeData, encodeDataLen, item, itemFixedLen); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for item fixed fields"); - return {}; - } - encodeData += itemFixedLen; - encodeDataLen -= itemFixedLen; - int32_t dataLen = itemLen - itemFixedLen; - ret = memcpy_s(encodeData, encodeDataLen, &(item->data), dataLen); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for item data field"); - return {}; - } - encodeData += dataLen; - encodeDataLen -= dataLen; - } - - if (meta->data_count != 0) { - ret = memcpy_s(encodeData, encodeDataLen, GetMetadataData(meta), meta->data_count); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for data"); - return {}; - } - encodeData += meta->data_count; - } - METADATA_DEBUG_LOG("MetadataUtils::EncodeToString Calculated length: %{public}d, encoded length: %{public}d", - s.capacity(), (encodeData - &s[0])); - - return s; -} - -std::shared_ptr MetadataUtils::DecodeFromString(std::string setting) -{ - uint32_t ret; - uint32_t totalLen = setting.capacity(); - const uint32_t headerLength = sizeof(common_metadata_header_t); - const uint32_t itemLen = sizeof(camera_metadata_item_entry_t); - const uint32_t itemFixedLen = offsetof(camera_metadata_item_entry_t, data); - - if (totalLen < headerLength) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Length is less than metadata header length"); - return {}; - } - - char *decodeData = &setting[0]; - common_metadata_header_t header; - ret = memcpy_s(&header, headerLength, decodeData, headerLength); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed to copy memory for metadata header"); - return {}; - } - std::shared_ptr metadata - = std::make_shared(header.item_capacity, header.data_capacity); - common_metadata_header_t *meta = metadata->get(); - if (!meta) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed to get metadata header"); - return {}; - } - ret = memcpy_s(meta, headerLength, &header, headerLength); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed to copy memory for metadata header"); - return {}; - } - decodeData += headerLength; - camera_metadata_item_entry_t *item = GetMetadataItems(meta); - for (uint32_t index = 0; index < meta->item_count; index++, item++) { - if (totalLen < ((decodeData - &setting[0]) + itemLen)) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed at item index: %{public}d", index); - return {}; - } - ret = memcpy_s(item, itemFixedLen, decodeData, itemFixedLen); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed to copy memory for item fixed fields"); - return {}; - } - decodeData += itemFixedLen; - uint32_t dataLen = itemLen - itemFixedLen; - ret = memcpy_s(&(item->data), dataLen, decodeData, dataLen); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed to copy memory for item data field"); - return {}; - } - decodeData += dataLen; - } - - if (meta->data_count != 0) { - if (totalLen < static_cast(((decodeData - &setting[0]) + meta->data_count))) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed at data copy"); - return {}; - } - ret = memcpy_s(GetMetadataData(meta), meta->data_count, decodeData, meta->data_count); - if (ret != EOK) { - METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed to copy memory for data"); - return {}; - } - decodeData += meta->data_count; - } - - METADATA_DEBUG_LOG("MetadataUtils::DecodeFromString String length: %{public}d, Decoded length: %{public}d", - setting.capacity(), (decodeData - &setting[0])); - return metadata; -} - -bool MetadataUtils::ReadMetadata(camera_metadata_item_t &item, MessageParcel &data) -{ - size_t i, j; - if (item.data_type == META_TYPE_BYTE) { - std::vector byteBuffers; - data.ReadUInt8Vector(&byteBuffers); - item.data.u8 = new(std::nothrow) uint8_t[item.count]; - if (item.data.u8 != nullptr) { - for (i = 0; i < item.count && i < byteBuffers.size(); i++) { - item.data.u8[i] = byteBuffers.at(i); - } - } - } else if (item.data_type == META_TYPE_INT32) { - std::vector int32Buffers; - data.ReadInt32Vector(&int32Buffers); - item.data.i32 = new(std::nothrow) int32_t[item.count]; - if (item.data.i32 != nullptr) { - for (i = 0; i < item.count && i < int32Buffers.size(); i++) { - item.data.i32[i] = int32Buffers.at(i); - } - } - } else if (item.data_type == META_TYPE_FLOAT) { - std::vector floatBuffers; - data.ReadFloatVector(&floatBuffers); - item.data.f = new(std::nothrow) float[item.count]; - if (item.data.f != nullptr) { - for (i = 0; i < item.count && i < floatBuffers.size(); i++) { - item.data.f[i] = floatBuffers.at(i); - } - } - } else if (item.data_type == META_TYPE_UINT32) { - std::vector uInt32Buffers; - data.ReadUInt32Vector(&uInt32Buffers); - item.data.ui32 = new(std::nothrow) uint32_t[item.count]; - if (item.data.ui32 != nullptr) { - for (i = 0; i < item.count && i < uInt32Buffers.size(); i++) { - item.data.ui32[i] = uInt32Buffers.at(i); - } - } - } else if (item.data_type == META_TYPE_INT64) { - std::vector int64uBffers; - data.ReadInt64Vector(&int64uBffers); - item.data.i64 = new(std::nothrow) int64_t[item.count]; - if (item.data.i64 != nullptr) { - for (i = 0; i < item.count && i < int64uBffers.size(); i++) { - item.data.i64[i] = int64uBffers.at(i); - } - } - } else if (item.data_type == META_TYPE_DOUBLE) { - std::vector doubleBuffers; - data.ReadDoubleVector(&doubleBuffers); - item.data.d = new(std::nothrow) double[item.count]; - if (item.data.d != nullptr) { - for (i = 0; i < item.count && i < doubleBuffers.size(); i++) { - item.data.d[i] = doubleBuffers.at(i); - } - } - } else if (item.data_type == META_TYPE_RATIONAL) { - std::vector rationalBuffers; - data.ReadInt32Vector(&rationalBuffers); - item.data.r = new(std::nothrow) camera_rational_t[item.count]; - if (item.data.r != nullptr) { - for (i = 0, j = 0; - i < item.count && j < static_cast(rationalBuffers.size() - 1); - i++, j += INDEX_COUNTER) { - item.data.r[i].numerator = rationalBuffers.at(j); - item.data.r[i].denominator = rationalBuffers.at(j + 1); - } - } - } - return true; -} - -void MetadataUtils::ItemDataToBuffer(const camera_metadata_item_t &item, void **buffer) -{ - if (buffer == nullptr) { - METADATA_ERR_LOG("MetadataUtils::ItemDataToBuffer buffer is null"); - return; - } - if (item.data_type == META_TYPE_BYTE) { - *buffer = reinterpret_cast(item.data.u8); - } else if (item.data_type == META_TYPE_INT32) { - *buffer = reinterpret_cast(item.data.i32); - } else if (item.data_type == META_TYPE_FLOAT) { - *buffer = reinterpret_cast(item.data.f); - } else if (item.data_type == META_TYPE_UINT32) { - *buffer = reinterpret_cast(item.data.ui32); - } else if (item.data_type == META_TYPE_INT64) { - *buffer = reinterpret_cast(item.data.i64); - } else if (item.data_type == META_TYPE_DOUBLE) { - *buffer = reinterpret_cast(item.data.d); - } else if (item.data_type == META_TYPE_RATIONAL) { - *buffer = reinterpret_cast(item.data.r); - } -} - -void MetadataUtils::FreeMetadataBuffer(camera_metadata_item_t &entry) -{ - if (entry.data_type == META_TYPE_BYTE) { - if (entry.data.u8 != nullptr) { - delete[] entry.data.u8; - } - } else if (entry.data_type == META_TYPE_INT32) { - if (entry.data.i32 != nullptr) { - delete[] entry.data.i32; - } - } else if (entry.data_type == META_TYPE_FLOAT) { - if (entry.data.f != nullptr) { - delete[] entry.data.f; - } - } else if (entry.data_type == META_TYPE_INT64) { - if (entry.data.i64 != nullptr) { - delete[] entry.data.i64; - } - } else if (entry.data_type == META_TYPE_UINT32) { - if (entry.data.ui32 != nullptr) { - delete[] entry.data.ui32; - } - } else if (entry.data_type == META_TYPE_DOUBLE) { - if (entry.data.d != nullptr) { - delete[] entry.data.d; - } - } else if (entry.data_type == META_TYPE_RATIONAL) { - if (entry.data.r != nullptr) { - delete[] entry.data.r; - } - } -} -} // Camera diff --git a/adapter/uhdf2/model/camera/sequenceable/buffer_producer/BUILD.gn b/adapter/uhdf2/model/camera/sequenceable/buffer_producer/BUILD.gn deleted file mode 100644 index 60b402d4646946f73ebb2c2350cd1d79cf173648..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/sequenceable/buffer_producer/BUILD.gn +++ /dev/null @@ -1,39 +0,0 @@ -# Copyright (C) 2022 - 2023 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import("//build/ohos.gni") -import("../../../../uhdf.gni") - -config("camera_sequenceable_config") { - include_dirs = [ "./" ] -} - -ohos_shared_library("libbuffer_producer_sequenceable_1.0") { - sources = [ "buffer_producer_sequenceable.cpp" ] - - all_dependent_configs = [ ":camera_sequenceable_config" ] - - public_deps = [ "../../../../../../../../foundation/graphic/graphic_2d/frameworks/surface:surface" ] - - external_deps = [ - "c_utils:utils", - "ipc:ipc_single", - - #"graphic_chipsetsdk:surface", - ] - - install_images = [ system_base_dir ] - relative_install_dir = "chipset-sdk" - subsystem_name = "hdf" - part_name = "drivers_interface_camera" -} diff --git a/adapter/uhdf2/model/camera/sequenceable/buffer_producer/buffer_producer_sequenceable.cpp b/adapter/uhdf2/model/camera/sequenceable/buffer_producer/buffer_producer_sequenceable.cpp deleted file mode 100644 index 5e6fd3da09319fa37c85dc84b11b6abc12512a85..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/sequenceable/buffer_producer/buffer_producer_sequenceable.cpp +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "buffer_producer_sequenceable.h" - -#include - -namespace OHOS { -namespace HDI { -namespace Camera { -namespace V1_0 { -bool BufferProducerSequenceable::Marshalling(Parcel &parcel) const -{ - if (producer_ == nullptr) { - return false; - } - - OHOS::MessageParcel &dataParcel = static_cast(parcel); - - if (!dataParcel.WriteRemoteObject(producer_->AsObject())) { - return false; - } - - return true; -} - -sptr BufferProducerSequenceable::Unmarshalling(Parcel &parcel) -{ - sptr sequenceData = new BufferProducerSequenceable(); - - OHOS::MessageParcel &dataParcel = static_cast(parcel); - - sptr remoteObj = dataParcel.ReadRemoteObject(); - sptr bufferProducer = OHOS::iface_cast(remoteObj); - sequenceData->producer_ = bufferProducer; - - return sequenceData; -} - -BufferProducerSequenceable &BufferProducerSequenceable::operator=(const BufferProducerSequenceable &other) -{ - if (&other != this) - producer_ = other.producer_; - return *this; -} -} // V1_0 -} // Camera -} // HDI -} // OHOS diff --git a/adapter/uhdf2/model/camera/sequenceable/buffer_producer/buffer_producer_sequenceable.h b/adapter/uhdf2/model/camera/sequenceable/buffer_producer/buffer_producer_sequenceable.h deleted file mode 100644 index 1cb477d95b981fbe63bee6c6e6e971ef0a343018..0000000000000000000000000000000000000000 --- a/adapter/uhdf2/model/camera/sequenceable/buffer_producer/buffer_producer_sequenceable.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_HDI_SEQUENCE_DATA_H -#define OHOS_HDI_SEQUENCE_DATA_H - -#include -#include -#include -#include "surface.h" - -namespace OHOS { -namespace HDI { -namespace Camera { -namespace V1_0 { -using OHOS::Parcelable; -using OHOS::Parcel; -using OHOS::sptr; -using OHOS::IBufferProducer; - -class BufferProducerSequenceable : public Parcelable { -public: - BufferProducerSequenceable() = default; - virtual ~BufferProducerSequenceable() = default; - - explicit BufferProducerSequenceable(const sptr &producer):producer_(producer) {} - BufferProducerSequenceable &operator=(const BufferProducerSequenceable &other); - - BufferProducerSequenceable(const BufferProducerSequenceable &other):producer_(other.producer_) {} - - bool Marshalling(Parcel &parcel) const override; - - static sptr Unmarshalling(Parcel &parcel); - - sptr producer_; -}; -} // V1_0 -} // Camera -} // HDI -} // OHOS -#endif // OHOS_HDI_SEQUENCE_DATA_H