1 /*
2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "camera_metadata_info.h"
17 #include <securec.h>
18 #include "metadata_log.h"
19 #include <dlfcn.h>
20 #include <memory>
21 #include <vector>
22 #include <map>
23 #include <mutex>
24 #include "camera_metadata_item_info.h"
25 #include "camera_vendor_tag.h"
26 #include "metadata_utils.h"
27
28 namespace OHOS::Camera {
29 static std::mutex g_mtx;
30 static std::mutex g_vendorTagImplMtx;
31 static CameraVendorTag* g_vendorTagImpl = nullptr;
32 const char* g_exampleVendorTagLib = "libcamera_example_vendor_tag_impl.z.so";
33 const char* g_vendorTagLib = "libcamera_vendor_tag_impl.z.so";
34 const int METADATA_HEADER_DATA_SIZE = 4;
35 const uint32_t itemLen = sizeof(camera_metadata_item_entry_t);
36 const std::vector<uint32_t> g_metadataTags = {
37 OHOS_ABILITY_CAMERA_POSITION,
38 OHOS_ABILITY_CAMERA_TYPE,
39 OHOS_ABILITY_CAMERA_CONNECTION_TYPE,
40 OHOS_ABILITY_MEMORY_TYPE,
41 OHOS_ABILITY_FPS_RANGES,
42 OHOS_ABILITY_FLASH_AVAILABLE,
43 OHOS_CAMERA_STREAM_ID,
44 OHOS_ABILITY_PRELAUNCH_AVAILABLE,
45 OHOS_ABILITY_CUSTOM_VIDEO_FPS,
46 OHOS_ABILITY_CAMERA_MODES,
47 OHOS_ABILITY_SKETCH_ENABLE_RATIO,
48 OHOS_ABILITY_SKETCH_REFERENCE_FOV_RATIO,
49 OHOS_ABILITY_SKETCH_INFO_NOTIFICATION,
50 OHOS_ABILITY_CAMERA_FOLDSCREEN_TYPE,
51 OHOS_ABILITY_AVAILABLE_COLOR_SPACES,
52 OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME,
53 OHOS_CAMERA_MESURE_EXPOSURE_TIME,
54 OHOS_CAMERA_EXPOSURE_MODE_PREVIEW_STATE,
55 OHOS_CAMERA_USER_ID,
56 OHOS_ABILITY_MOON_CAPTURE_BOOST,
57 OHOS_CONTROL_MOON_CAPTURE_BOOST,
58 OHOS_STATUS_MOON_CAPTURE_DETECTION,
59 OHOS_ABILITY_CAPTURE_DURATION_SUPPORTED,
60 OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION,
61 OHOS_ABILITY_MOVING_PHOTO,
62 OHOS_ABILITY_FLASH_SUGGESTION_SUPPORTED,
63 OHOS_CONTROL_FLASH_SUGGESTION_SWITCH,
64 OHOS_STATUS_FLASH_SUGGESTION,
65 OHOS_ABILITY_HIGH_QUALITY_SUPPORT,
66 OHOS_ABILITY_CAMERA_FOLD_STATUS,
67 OHOS_STATUS_CAMERA_OCCLUSION_DETECTION,
68 OHOS_ABILITY_STATISTICS_DETECT_TYPE,
69 OHOS_CONTROL_STATISTICS_DETECT_SETTING,
70 OHOS_ABILITY_AVAILABLE_EXTENDED_STREAM_INFO_TYPES,
71 OHOS_ABILITY_AUTO_DEFERRED_VIDEO_ENHANCE,
72 OHOS_CONTROL_AUTO_DEFERRED_VIDEO_ENHANCE,
73 OHOS_ABILITY_AUTO_CLOUD_IMAGE_ENHANCE,
74 OHOS_CONTROL_AUTO_CLOUD_IMAGE_ENHANCE,
75 OHOS_ABILITY_TRIPOD_DETECTION,
76 OHOS_CONTROL_TRIPOD_DETECTION,
77 OHOS_CONTROL_TRIPOD_STABLITATION,
78 OHOS_STATUS_TRIPOD_DETECTION_STATUS,
79 OHOS_STATUS_SKETCH_POINT,
80 OHOS_STATUS_SKETCH_STREAM_INFO,
81 OHOS_ABILITY_LOW_LIGHT_BOOST,
82 OHOS_CONTROL_LOW_LIGHT_DETECT,
83 OHOS_CONTROL_LOW_LIGHT_BOOST,
84 OHOS_STATUS_LOW_LIGHT_DETECTION,
85 OHOS_STATUS_CAMERA_LENS_DIRTY_DETECTION,
86 OHOS_DEVICE_PROTECTION_STATE,
87 OHOS_STATUS_TOF_SENSOR_ABNORMAL,
88 OHOS_ABILITY_SUN_BLOCK_PREVIEW_TYPES,
89 OHOS_ABILITY_SUN_BLOCK_BLEND_COLORS,
90 OHOS_ABILITY_SUN_BLOCK_RGB_CROP_REGION,
91 OHOS_ABILITY_SUN_BLOCK_RGB_UV_REGION,
92 OHOS_STATUS_SUN_BLOCK_HINT,
93 OHOS_ABILITY_AUTO_AIGC_PHOTO,
94 OHOS_CONTROL_AUTO_AIGC_PHOTO,
95 OHOS_ABILITY_CAMERA_LIMITED_CAPABILITIES,
96 OHOS_ABILITY_CAMERA_CONCURRENT_TYPE,
97 OHOS_ABILITY_CONCURRENT_SUPPORTED_CAMERAS,
98
99 OHOS_SENSOR_EXPOSURE_TIME,
100 OHOS_SENSOR_COLOR_CORRECTION_GAINS,
101 OHOS_SENSOR_ORIENTATION,
102 OHOS_ABILITY_MUTE_MODES,
103 OHOS_CONTROL_MUTE_MODE,
104 OHOS_ABILITY_SENSOR_ORIENTATION_VARIABLE,
105 OHOS_FOLD_STATE_SENSOR_ORIENTATION_MAP,
106
107 OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
108 OHOS_SENSOR_INFO_SENSITIVITY_RANGE,
109 OHOS_SENSOR_INFO_MAX_FRAME_DURATION,
110 OHOS_SENSOR_INFO_PHYSICAL_SIZE,
111 OHOS_SENSOR_INFO_PIXEL_ARRAY_SIZE,
112 OHOS_SENSOR_INFO_TIMESTAMP,
113
114 OHOS_STATISTICS_FACE_DETECT_MODE,
115 OHOS_STATISTICS_FACE_DETECT_SWITCH,
116 OHOS_STATISTICS_FACE_DETECT_MAX_NUM,
117 OHOS_STATISTICS_HISTOGRAM_MODE,
118 OHOS_STATISTICS_FACE_IDS,
119 OHOS_STATISTICS_FACE_LANDMARKS,
120 OHOS_STATISTICS_FACE_RECTANGLES,
121 OHOS_STATISTICS_FACE_SCORES,
122 OHOS_STATISTICS_DETECT_HUMAN_FACE_INFOS,
123 OHOS_STATISTICS_DETECT_HUMAN_BODY_INFOS,
124 OHOS_STATISTICS_DETECT_CAT_FACE_INFOS,
125 OHOS_STATISTICS_DETECT_CAT_BODY_INFOS,
126 OHOS_STATISTICS_DETECT_DOG_FACE_INFOS,
127 OHOS_STATISTICS_DETECT_DOG_BODY_INFOS,
128 OHOS_STATISTICS_DETECT_SALIENT_INFOS,
129 OHOS_STATISTICS_DETECT_BAR_CODE_INFOS,
130 OHOS_STATISTICS_DETECT_BASE_FACE_INFO,
131
132 OHOS_CONTROL_AE_ANTIBANDING_MODE,
133 OHOS_CONTROL_AE_EXPOSURE_COMPENSATION,
134 OHOS_CONTROL_AE_LOCK,
135 OHOS_CONTROL_AE_MODE,
136 OHOS_CONTROL_AE_REGIONS,
137 OHOS_CONTROL_AE_TARGET_FPS_RANGE,
138 OHOS_CONTROL_FPS_RANGES,
139 OHOS_CONTROL_AF_MODE,
140 OHOS_CONTROL_AF_REGIONS,
141 OHOS_CONTROL_AF_TRIGGER,
142 OHOS_CONTROL_AF_TRIGGER_ID,
143 OHOS_CONTROL_AF_STATE,
144 OHOS_CONTROL_AWB_LOCK,
145 OHOS_CONTROL_AWB_MODE,
146 OHOS_CONTROL_AWB_REGIONS,
147 OHOS_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
148 OHOS_CONTROL_AE_AVAILABLE_MODES,
149 OHOS_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
150 OHOS_CONTROL_AE_COMPENSATION_RANGE,
151 OHOS_CONTROL_AE_COMPENSATION_STEP,
152 OHOS_ABILITY_AE_COMPENSATION_RANGE,
153 OHOS_ABILITY_AE_COMPENSATION_STEP,
154 OHOS_CONTROL_AF_AVAILABLE_MODES,
155 OHOS_CONTROL_AWB_AVAILABLE_MODES,
156 OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED,
157 OHOS_CONTROL_CAPTURE_MIRROR,
158 OHOS_CONTROL_FOCUS_STATE,
159 OHOS_CONTROL_METER_POINT,
160 OHOS_CONTROL_METER_MODE,
161 OHOS_CONTROL_EXPOSURE_STATE,
162 OHOS_CONTROL_FOCUSED_POINT,
163 OHOS_CONTROL_NIGHT_MODE_TRY_AE,
164 OHOS_CONTROL_MANUAL_EXPOSURE_TIME,
165 OHOS_STATUS_CAMERA_CURRENT_FPS,
166 OHOS_ABILITY_ISO_VALUES,
167 OHOS_CONTROL_ISO_VALUE,
168 OHOS_STATUS_ISO_VALUE,
169 OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE,
170 OHOS_CONTROL_SENSOR_EXPOSURE_TIME,
171 OHOS_STATUS_SENSOR_EXPOSURE_TIME,
172 OHOS_CONTROL_MOVING_PHOTO,
173 OHOS_ABILITY_SENSOR_WB_VALUES,
174 OHOS_CONTROL_SENSOR_WB_VALUE,
175 OHOS_CONTROL_HIGH_QUALITY_MODE,
176 OHOS_CONTROL_BURST_CAPTURE,
177 OHOS_CONTROL_CAMERA_USED_AS_POSITION,
178 OHOS_CONTROL_CAMERA_SESSION_USAGE,
179 OHOS_CONTROL_EJECT_RETRY,
180 OHOS_CONTROL_FALL_PROTECTION,
181 OHOS_CONTROL_SUN_BLOCK_PREVIEW_TYPE,
182 OHOS_CONTROL_SUN_BLOCK_BLEND_COLOR,
183 OHOS_CONTROL_QUALITY_PRIORITIZATION,
184 OHOS_CONTROL_AUTO_VIDEO_FRAME_RATE,
185 OHOS_ABILITY_AUTO_VIDEO_FRAME_RATE,
186
187 // Camera device image acquisition related
188 OHOS_ABILITY_DEVICE_AVAILABLE_EXPOSUREMODES,
189 OHOS_CONTROL_EXPOSUREMODE,
190 OHOS_ABILITY_EXPOSURE_MODES,
191 OHOS_CONTROL_EXPOSURE_MODE,
192 OHOS_ABILITY_METER_MODES,
193 OHOS_ABILITY_SCENE_EXPOSURE_MODES,
194 OHOS_ABILITY_EXPOSURE_TIME,
195 OHOS_ABILITY_AE_LOCK,
196
197 OHOS_ABILITY_DEVICE_AVAILABLE_FOCUSMODES,
198 OHOS_CONTROL_FOCUSMODE,
199 OHOS_ABILITY_FOCUS_MODES,
200 OHOS_CONTROL_FOCUS_MODE,
201 OHOS_ABILITY_FOCAL_LENGTH,
202 OHOS_ABILITY_SCENE_FOCUS_MODES,
203 OHOS_ABILITY_FOCUS_ASSIST_FLASH_SUPPORTED_MODES,
204 OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE,
205 OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
206 OHOS_CONTROL_LENS_FOCUS_DISTANCE,
207 OHOS_ABILITY_EQUIVALENT_FOCUS,
208 OHOS_ABILITY_LENS_EQUIVALENT_FOCUS,
209 OHOS_CONTROL_FOCUS_DISTANCE,
210 OHOS_ABILITY_FOCUS_RANGE_TYPES,
211 OHOS_CONTROL_FOCUS_RANGE_TYPE,
212 OHOS_CONTROL_FOCUS_TRACKING_MODE,
213 OHOS_ABILITY_FOCUS_TRACKING_REGION,
214 OHOS_ABILITY_FOCUS_DRIVEN_TYPES,
215 OHOS_CONTROL_FOCUS_DRIVEN_TYPE,
216 OHOS_ABILITY_FOCUS_TRACKING_MECH_AVAILABLE,
217 OHOS_CONTROL_FOCUS_TRACKING_MECH,
218 OHOS_CONTROL_FOCUS_TRACKING_OBJECT_ID,
219
220 OHOS_ABILITY_DEVICE_AVAILABLE_AWBMODES,
221 OHOS_ABILITY_AWB_MODES,
222 OHOS_ABILITY_AWB_LOCK,
223 OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES,
224 OHOS_CONTROL_FLASHMODE,
225 OHOS_ABILITY_FLASH_MODES,
226 OHOS_CONTROL_FLASH_MODE,
227 OHOS_CONTROL_FLASH_STATE,
228 OHOS_ABILITY_SCENE_FLASH_MODES,
229
230 OHOS_ABILITY_ZOOM_RATIO_RANGE,
231 OHOS_CONTROL_ZOOM_RATIO,
232 OHOS_CONTROL_ZOOM_CROP_REGION,
233 OHOS_ABILITY_ZOOM_CAP,
234 OHOS_ABILITY_SCENE_ZOOM_CAP,
235 OHOS_STATUS_CAMERA_CURRENT_ZOOM_RATIO,
236 OHOS_CONTROL_SMOOTH_ZOOM_RATIOS,
237 OHOS_CONTROL_PREPARE_ZOOM,
238 OHOS_ABILITY_CAMERA_ZOOM_PERFORMANCE,
239 OHOS_STATUS_CAMERA_ZOOM_PERFORMANCE,
240 OHOS_ABILITY_CAMERA_ZOOM_BEZIER_CURVC_POINT,
241
242 // Camera flow control related
243 OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS,
244 OHOS_STREAM_AVAILABLE_FORMATS,
245 OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS,
246 OHOS_ABILITY_STREAM_QUICK_THUMBNAIL_AVAILABLE,
247 OHOS_ABILITY_PORTRAIT_RESOLUSION,
248 OHOS_ABILITY_SCENE_STREAM_QUICK_THUMBNAIL_AVAILABLE,
249 OHOS_ABILITY_DEFERRED_IMAGE_DELIVERY,
250 OHOS_CONTROL_DEFERRED_IMAGE_DELIVERY,
251 OHOS_ABILITY_PRERECORD,
252 OHOS_CONTROL_PRERECORD_MODE,
253 OHOS_CONTROL_RECORD_STATE,
254 OHOS_ABILITY_CHANGETO_OFFLINE_STREAM_OPEATOR,
255 OHOS_CONTROL_CHANGETO_OFFLINE_STREAM_OPEATOR,
256 OHOS_ABILITY_ROTATION_IN_IPS_SUPPORTED,
257
258 OHOS_JPEG_GPS_COORDINATES,
259 OHOS_JPEG_GPS_PROCESSING_METHOD,
260 OHOS_JPEG_GPS_TIMESTAMP,
261 OHOS_JPEG_ORIENTATION,
262 OHOS_JPEG_QUALITY,
263 OHOS_JPEG_THUMBNAIL_QUALITY,
264 OHOS_JPEG_THUMBNAIL_SIZE,
265 OHOS_JPEG_AVAILABLE_THUMBNAIL_SIZES,
266 OHOS_JPEG_MAX_SIZE,
267 OHOS_JPEG_SIZE,
268
269 OHOS_ABILITY_VIDEO_STABILIZATION_MODES,
270 OHOS_CONTROL_VIDEO_STABILIZATION_MODE,
271 OHOS_CONTROL_VIDEO_DEBUG_SWITCH,
272
273 // camera effects & algorithms
274 OHOS_ABILITY_SCENE_FILTER_TYPES,
275 OHOS_CONTROL_FILTER_TYPE,
276 OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES,
277 OHOS_CONTROL_PORTRAIT_EFFECT_TYPE,
278 OHOS_ABILITY_SCENE_BEAUTY_TYPES,
279 OHOS_CONTROL_BEAUTY_TYPE,
280 OHOS_ABILITY_BEAUTY_AUTO_VALUES,
281 OHOS_CONTROL_BEAUTY_AUTO_VALUE,
282 OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES,
283 OHOS_CONTROL_BEAUTY_FACE_SLENDER_VALUE,
284 OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES,
285 OHOS_CONTROL_BEAUTY_SKIN_TONE_VALUE,
286 OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES,
287 OHOS_CONTROL_BEAUTY_SKIN_SMOOTH_VALUE,
288 OHOS_ABILITY_CAMERA_MACRO_SUPPORTED,
289 OHOS_ABILITY_SCENE_MACRO_CAP,
290 OHOS_CAMERA_MACRO_STATUS,
291 OHOS_CONTROL_CAMERA_MACRO,
292 OHOS_ABILITY_CAMERA_VIRTUAL_APERTURE_RANGE,
293 OHOS_CONTROL_CAMERA_VIRTUAL_APERTURE_VALUE,
294 OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE,
295 OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE,
296 OHOS_STATUS_CAMERA_APERTURE_VALUE,
297 OHOS_DEVICE_EXITCAMERA_EVENT,
298 OHOS_CONTROL_MOTION_DETECTION_CHECK_AREA,
299 OHOS_STATUS_SLOW_MOTION_DETECTION,
300 OHOS_ABILITY_MOTION_DETECTION_SUPPORT,
301 OHOS_CONTROL_MOTION_DETECTION,
302 OHOS_ABILITY_EXPOSURE_HINT_SUPPORTED,
303 OHOS_CONTROL_EXPOSURE_HINT_MODE,
304 OHOS_STATUS_ALGO_MEAN_Y,
305 OHOS_STATUS_PREVIEW_PHYSICAL_CAMERA_ID,
306 OHOS_ABILITY_CAPTURE_EXPECT_TIME,
307 OHOS_ABILITY_EFFECT_SUGGESTION_SUPPORTED,
308 OHOS_CONTROL_EFFECT_SUGGESTION,
309 OHOS_CONTROL_EFFECT_SUGGESTION_DETECTION,
310 OHOS_CAMERA_EFFECT_SUGGESTION_TYPE,
311 OHOS_CONTROL_EFFECT_SUGGESTION_TYPE,
312 OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL,
313 OHOS_ABILITY_AVAILABLE_PREVIEW_PROFILE,
314 OHOS_ABILITY_AVAILABLE_PHOTO_PROFILE,
315 OHOS_ABILITY_AVAILABLE_VIDEO_PROFILE,
316 OHOS_ABILITY_AVAILABLE_METADATA_PROFILE,
317 OHOS_ABILITY_AVAILABLE_CONFIGURATIONS,
318 OHOS_ABILITY_CONFLICT_CONFIGURATIONS,
319 OHOS_ABILITY_LIGHT_PAINTING_TYPE,
320 OHOS_CONTROL_LIGHT_PAINTING_TYPE,
321 OHOS_CONTROL_LIGHT_PAINTING_FLASH,
322 OHOS_CONTROL_TIME_LAPSE_INTERVAL,
323 OHOS_CONTROL_TIME_LAPSE_TRYAE_STATE,
324 OHOS_STATUS_TIME_LAPSE_PREVIEW_TYPE,
325 OHOS_STATUS_TIME_LAPSE_TRYAE_HINT,
326 OHOS_STATUS_TIME_LAPSE_CAPTURE_INTERVAL,
327 OHOS_STATUS_TIME_LAPSE_TRYAE_DONE,
328 OHOS_CONTROL_TIME_LAPSE_RECORD_STATE,
329 OHOS_CONTROL_TIME_LAPSE_PREVIEW_TYPE,
330 OHOS_ABILITY_TIME_LAPSE_INTERVAL_RANGE,
331 OHOS_ABILITY_LCD_FLASH,
332 OHOS_CONTROL_LCD_FLASH_DETECTION,
333 OHOS_CONTROL_LCD_FLASH,
334 OHOS_STATUS_LCD_FLASH_STATUS,
335 OHOS_ABILITY_DEPTH_DATA_DELIVERY,
336 OHOS_CONTROL_DEPTH_DATA_DELIVERY_SWITCH,
337 OHOS_ABILITY_DEPTH_DATA_PROFILES,
338 OHOS_CONTROL_DEPTH_DATA_ACCURACY,
339 OHOS_ABILITY_CAMERA_IS_RETRACTABLE,
340 OHOS_CONTROL_CAMERA_CLOSE_AFTER_SECONDS,
341 OHOS_ABILITY_CAPTURE_MACRO_DEPTH_FUSION_SUPPORTED,
342 OHOS_ABILITY_CAPTURE_MACRO_DEPTH_FUSION_ZOOM_RANGE,
343 OHOS_CONTROL_CAPTURE_MACRO_DEPTH_FUSION,
344 OHOS_ABILITY_CAMERA_PORTRAIT_THEME_SUPPORTED,
345 OHOS_ABILITY_CAMERA_PORTRAIT_THEME_TYPES,
346 OHOS_CONTROL_CAMERA_PORTRAIT_THEME_TYPE,
347 OHOS_ABILITY_CAMERA_VIDEO_ROTATION_SUPPORTED,
348 OHOS_ABILITY_CAMERA_VIDEO_ROTATION,
349 OHOS_CONTROL_CAMERA_VIDEO_ROTATION,
350 OHOS_MOVING_PHOTO_BUFFER_DURATION,
351 OHOS_MOVING_PHOTO_START,
352 OHOS_MOVING_PHOTO_END,
353 OHOS_ABILITY_COLOR_RESERVATION_TYPES,
354 OHOS_CONTROL_COLOR_RESERVATION_TYPE,
355 OHOS_ABILITY_CONTROL_CENTER_SUPPORTED,
356 OHOS_ABILITY_CONTROL_CENTER_EFFECT_TYPE,
357
358 // camera secure related
359 OHOS_CONTROL_SECURE_FACE_MODE,
360 OHOS_CONTROL_SECURE_FACE_INFO,
361 OHOS_CONTROL_SECURE_FACE_AUTH_RESULT,
362 OHOS_CONTROL_SECURE_FLASH_SEQ,
363 OHOS_CONTROL_SECURE_IR_LED_SWITCH,
364 OHOS_CONTROL_SECURE_IR_LOCKAE_SWITCH,
365
366 //XMAGE MODES
367 OHOS_ABILITY_SUPPORTED_COLOR_MODES,
368 OHOS_CONTROL_SUPPORTED_COLOR_MODES,
369 };
370
371 std::map<uint32_t, uint32_t> g_metadataSectionMap = {
372 {OHOS_CAMERA_PROPERTIES, OHOS_SECTION_CAMERA_PROPERTIES},
373 {OHOS_CAMERA_SENSOR, OHOS_SECTION_CAMERA_SENSOR},
374 {OHOS_CAMERA_SENSOR_INFO, OHOS_SECTION_CAMERA_SENSOR_INFO},
375 {OHOS_CAMERA_STATISTICS, OHOS_SECTION_CAMERA_STATISTICS},
376 {OHOS_DEVICE_CONTROL, OHOS_SECTION_CAMERA_CONTROL},
377 {OHOS_DEVICE_EXPOSURE, OHOS_SECTION_DEVICE_EXPOSURE},
378 {OHOS_DEVICE_FOCUS, OHOS_SECTION_DEVICE_FOCUS},
379 {OHOS_DEVICE_WHITE_BLANCE, OHOS_SECTION_DEVICE_WHITE},
380 {OHOS_DEVICE_FLASH, OHOS_SECTION_DEVICE_FLASH},
381 {OHOS_DEVICE_ZOOM, OHOS_SECTION_DEVICE_ZOOM},
382 {OHOS_STREAM_ABILITY, OHOS_SECTION_STREAM_ABILITY},
383 {OHOS_STREAM_JPEG, OHOS_SECTION_STREAM_JPEG},
384 {OHOS_STREAM_VIDEO, OHOS_SECTION_STREAM_VIDEO},
385 {OHOS_CAMERA_EFFECT, OHOS_SECTION_CAMERA_EFFECT},
386 {OHOS_CAMERA_SECURE, OHOS_SECTION_CAMERA_SECURE},
387 {OHOS_XMAGE_COLOR_ABILITY, OHOS_SECTION_CAMERA_XMAGE},
388 {OHOS_STREAM_CONTROL, OHOS_SECTION_STREAM_CONTROL},
389 {OHOS_LIGHT_STATUS, OHOS_SECTION_LIGHT_STATUS},
390 };
391
392 std::map<uint32_t, uint32_t> g_itemDataTypeMap {
393 { OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, META_TYPE_INT32 },
394 { OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, META_TYPE_INT32 },
395 { OHOS_SENSOR_INFO_MAX_FRAME_DURATION, META_TYPE_INT64 },
396 { OHOS_JPEG_MAX_SIZE, META_TYPE_INT32 },
397 { OHOS_ABILITY_CAMERA_CONNECTION_TYPE, META_TYPE_BYTE }
398 };
399
CameraMetadata(size_t itemCapacity,size_t dataCapacity)400 CameraMetadata::CameraMetadata(size_t itemCapacity, size_t dataCapacity)
401 {
402 metadata_ = AllocateCameraMetadataBuffer(itemCapacity, AlignTo(dataCapacity, DATA_ALIGNMENT));
403 }
404
~CameraMetadata()405 CameraMetadata::~CameraMetadata()
406 {
407 std::lock_guard<std::mutex> lockGuard(g_mtx);
408 if (metadata_) {
409 FreeCameraMetadataBuffer(metadata_);
410 metadata_ = nullptr;
411 }
412 }
413
addEntry(uint32_t item,const void * data,size_t data_count)414 bool CameraMetadata::addEntry(uint32_t item, const void *data, size_t data_count)
415 {
416 if (metadata_ == nullptr) {
417 METADATA_ERR_LOG("metadata_ is null");
418 return false;
419 }
420
421 auto result = AddCameraMetadataItem(metadata_, item, data, data_count);
422 if (!result) {
423 return true;
424 }
425
426 if (result != CAM_META_ITEM_CAP_EXCEED && result != CAM_META_DATA_CAP_EXCEED) {
427 const char *name = GetCameraMetadataItemName(item);
428
429 if (name) {
430 METADATA_ERR_LOG("Failed to add tag. tagname = %{public}s", name);
431 } else {
432 METADATA_ERR_LOG("Failed to add unknown tag");
433 }
434 return false;
435 }
436
437 return resize_add_metadata(item, data, data_count);
438 }
439
resize_add_metadata(uint32_t item,const void * data,size_t data_count)440 bool CameraMetadata::resize_add_metadata(uint32_t item, const void *data, size_t data_count)
441 {
442 uint32_t data_type;
443
444 auto itemCapacity = GetCameraMetadataItemCapacity(metadata_);
445 auto data_capacity = GetCameraMetadataDataSize(metadata_);
446
447 int32_t ret = GetCameraMetadataItemType(item, &data_type);
448 if (ret != CAM_META_SUCCESS) {
449 METADATA_ERR_LOG("GetCameraMetadataItemType invalid item type");
450 return false;
451 }
452 int32_t size = CalculateCameraMetadataItemDataSize(data_type, data_count);
453 if (size == CAM_META_FAILURE) {
454 METADATA_ERR_LOG("CalculateCameraMetadataItemDataSize invalid datatype:%{public}d", data_type);
455 return false;
456 }
457
458 common_metadata_header_t *newMetadata = AllocateCameraMetadataBuffer((itemCapacity + 1) * INDEX_COUNTER,
459 AlignTo((data_capacity + size) * INDEX_COUNTER, DATA_ALIGNMENT));
460
461 if (newMetadata == nullptr) {
462 METADATA_ERR_LOG("Failed to resize the metadata buffer");
463 return false;
464 }
465
466 auto result = CopyCameraMetadataItems(newMetadata, metadata_);
467 if (result != CAM_META_SUCCESS) {
468 METADATA_ERR_LOG("Failed to copy the old metadata to new metadata");
469 FreeCameraMetadataBuffer(newMetadata);
470 newMetadata = nullptr;
471 return false;
472 }
473
474 result = AddCameraMetadataItem(newMetadata, item, data, data_count);
475 if (result != CAM_META_SUCCESS) {
476 METADATA_ERR_LOG("Failed to add new entry");
477 FreeCameraMetadataBuffer(newMetadata);
478 newMetadata = nullptr;
479 return false;
480 }
481 replace_metadata(newMetadata);
482
483 return true;
484 }
485
replace_metadata(common_metadata_header_t * newMetadata)486 void CameraMetadata::replace_metadata(common_metadata_header_t *newMetadata)
487 {
488 if (metadata_ == newMetadata) {
489 return;
490 }
491
492 std::lock_guard<std::mutex> lockGuard(g_mtx);
493 if (metadata_ != nullptr) {
494 FreeCameraMetadataBuffer(metadata_);
495 }
496 metadata_ = newMetadata;
497 }
498
updateEntry(uint32_t tag,const void * data,size_t dataCount)499 bool CameraMetadata::updateEntry(uint32_t tag, const void *data, size_t dataCount)
500 {
501 if (metadata_ == nullptr) {
502 METADATA_ERR_LOG("metadata_ is null");
503 return false;
504 }
505
506 const char *name = GetCameraMetadataItemName(tag);
507 (void)name;
508 camera_metadata_item_t item;
509 int ret = FindCameraMetadataItem(metadata_, tag, &item);
510 if (ret) {
511 METADATA_ERR_LOG("Failed to update tag tagname = %{public}s : not present", (name ? name : "<unknown>"));
512 return false;
513 }
514 METADATA_DEBUG_LOG("updateEntry item id: %{public}d, name: %{public}s, dataCount: %{public}zu",
515 tag, name ? name : "<unknown>", dataCount);
516 ret = UpdateCameraMetadataItemByIndex(metadata_, item.index, data, dataCount, nullptr);
517 if (ret) {
518 const char *name_ = GetCameraMetadataItemName(tag);
519 (void)name_;
520 METADATA_ERR_LOG("Failed to update tag tagname = %{public}s", (name_ ? name_ : "<unknown>"));
521 return false;
522 }
523
524 return true;
525 }
526
get()527 common_metadata_header_t *CameraMetadata::get()
528 {
529 return metadata_;
530 }
531
get() const532 const common_metadata_header_t *CameraMetadata::get() const
533 {
534 return metadata_;
535 }
536
isValid() const537 bool CameraMetadata::isValid() const
538 {
539 return metadata_ != nullptr;
540 }
541
Marshalling(Parcel & parcel) const542 bool CameraMetadata::Marshalling(Parcel &parcel) const
543 {
544 return MetadataUtils::WriteCameraMetadata(metadata_, static_cast<MessageParcel&>(parcel));
545 }
546
Unmarshalling(Parcel & parcel)547 CameraMetadata* CameraMetadata::Unmarshalling(Parcel &parcel)
548 {
549 uint32_t tagCount = parcel.ReadUint32();
550 uint32_t itemCapacity = parcel.ReadUint32();
551 uint32_t dataCapacity = parcel.ReadUint32();
552
553 if (tagCount > MAX_SUPPORTED_TAGS) {
554 tagCount = MAX_SUPPORTED_TAGS;
555 METADATA_ERR_LOG("CameraMetadata::Unmarshalling tagCount is more than supported value");
556 }
557
558 if (itemCapacity > MAX_ITEM_CAPACITY) {
559 itemCapacity = MAX_ITEM_CAPACITY;
560 METADATA_ERR_LOG("CameraMetadata::Unmarshalling itemCapacity is more than supported value");
561 }
562
563 if (dataCapacity > MAX_DATA_CAPACITY) {
564 dataCapacity = MAX_DATA_CAPACITY;
565 METADATA_ERR_LOG("CameraMetadata::Unmarshalling dataCapacity is more than supported value");
566 }
567 CameraMetadata* metadata = new (std::nothrow) CameraMetadata(itemCapacity, dataCapacity);
568 if (metadata == nullptr) {
569 METADATA_ERR_LOG("CameraMetadata::Unmarshalling metadata is nullptr");
570 return nullptr;
571 }
572 MetadataUtils::ReadCameraMetadata(static_cast<MessageParcel&>(parcel), metadata->get(), tagCount);
573
574 return metadata;
575 }
576
AlignTo(uint32_t val,uint32_t alignment)577 uint32_t CameraMetadata::AlignTo(uint32_t val, uint32_t alignment)
578 {
579 return static_cast<uint32_t>((static_cast<uintptr_t>(val) + ((alignment) - 1)) & ~((alignment) - 1));
580 }
581
MaxAlignment(uint32_t dataAlignment,uint32_t metadataAlignment)582 uint32_t CameraMetadata::MaxAlignment(uint32_t dataAlignment, uint32_t metadataAlignment)
583 {
584 return ((dataAlignment > metadataAlignment) ? dataAlignment : metadataAlignment);
585 }
586
GetMetadataData(const common_metadata_header_t * metadataHeader)587 uint8_t *CameraMetadata::GetMetadataData(const common_metadata_header_t *metadataHeader)
588 {
589 if (!metadataHeader) {
590 METADATA_ERR_LOG("GetMetadataData metadataHeader is null");
591 return nullptr;
592 }
593 return (uint8_t *)metadataHeader + metadataHeader->data_start;
594 }
595
GetMetadataItems(const common_metadata_header_t * metadataHeader)596 camera_metadata_item_entry_t *CameraMetadata::GetMetadataItems(const common_metadata_header_t *metadataHeader)
597 {
598 if (metadataHeader == nullptr) {
599 METADATA_ERR_LOG("GetMetadataItems metadataHeader is null");
600 return nullptr;
601 }
602 if (metadataHeader->data_start != 0) {
603 if (metadataHeader->size != metadataHeader->data_capacity + metadataHeader->data_start) {
604 METADATA_ERR_LOG("GetMetadataItems error size:%{public}u, data_capacity:%{public}u, data_start:%{public}u",
605 metadataHeader->size, metadataHeader->data_capacity, metadataHeader->data_start);
606 return nullptr;
607 }
608 }
609 return reinterpret_cast<camera_metadata_item_entry_t *>(
610 (reinterpret_cast<uint8_t *>(const_cast<common_metadata_header_t *>(metadataHeader)) +
611 metadataHeader->items_start));
612 }
613
FillCameraMetadata(common_metadata_header_t * buffer,size_t memoryRequired,uint32_t itemCapacity,uint32_t dataCapacity)614 common_metadata_header_t *CameraMetadata::FillCameraMetadata(common_metadata_header_t *buffer, size_t memoryRequired,
615 uint32_t itemCapacity, uint32_t dataCapacity)
616 {
617 METADATA_DEBUG_LOG("FillCameraMetadata start");
618 if (buffer == nullptr) {
619 METADATA_ERR_LOG("FillCameraMetadata buffer is null");
620 return nullptr;
621 }
622
623 common_metadata_header_t *metadataHeader = static_cast<common_metadata_header_t *>(buffer);
624 metadataHeader->version = CURRENT_CAMERA_METADATA_VERSION;
625 metadataHeader->size = memoryRequired;
626 metadataHeader->item_count = 0;
627 metadataHeader->item_capacity = itemCapacity;
628 metadataHeader->items_start = AlignTo(sizeof(common_metadata_header_t), ITEM_ALIGNMENT);
629 metadataHeader->data_count = 0;
630 metadataHeader->data_capacity = dataCapacity;
631 camera_metadata_item_entry_t *pItem = GetMetadataItems(metadataHeader);
632 if (pItem == nullptr) {
633 METADATA_ERR_LOG("FillCameraMetadata pItem is null");
634 return nullptr;
635 }
636 size_t dataUnaligned = reinterpret_cast<uint8_t *>(pItem + metadataHeader->item_capacity) -
637 reinterpret_cast<uint8_t *>(metadataHeader);
638 metadataHeader->data_start = AlignTo(dataUnaligned, DATA_ALIGNMENT);
639
640 METADATA_DEBUG_LOG("MetadataHeader ItemCapacity Size = %{public}u, DataCapacity Size = %{public}u",
641 metadataHeader->item_capacity, metadataHeader->data_capacity);
642 METADATA_DEBUG_LOG("FillCameraMetadata end");
643 return metadataHeader;
644 }
645
CalculateCameraMetadataMemoryRequired(uint32_t itemCount,uint32_t dataCount)646 size_t CameraMetadata::CalculateCameraMetadataMemoryRequired(uint32_t itemCount, uint32_t dataCount)
647 {
648 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired start");
649 size_t memoryRequired = sizeof(common_metadata_header_t);
650 memoryRequired = CameraMetadata::AlignTo(memoryRequired, ITEM_ALIGNMENT);
651
652 memoryRequired += sizeof(camera_metadata_item_entry_t[itemCount]);
653 memoryRequired = CameraMetadata::AlignTo(memoryRequired, DATA_ALIGNMENT);
654
655 memoryRequired += sizeof(uint8_t[dataCount]);
656 memoryRequired = CameraMetadata::AlignTo(memoryRequired, METADATA_PACKET_ALIGNMENT);
657
658 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired memoryRequired: %{public}zu", memoryRequired);
659 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired end");
660 return memoryRequired;
661 }
662
AllocateCameraMetadataBuffer(uint32_t item_capacity,uint32_t data_capacity)663 common_metadata_header_t *CameraMetadata::AllocateCameraMetadataBuffer(uint32_t item_capacity, uint32_t data_capacity)
664 {
665 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer start");
666 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer item_capacity: %{public}u, data_capacity: %{public}u",
667 item_capacity, data_capacity);
668 if (item_capacity > MAX_ITEM_CAPACITY || data_capacity > MAX_DATA_CAPACITY) {
669 METADATA_ERR_LOG("AllocateCameraMetadataBuffer invalid item_capacity or data_capacity");
670 return nullptr;
671 }
672 size_t memoryRequired = CalculateCameraMetadataMemoryRequired(item_capacity, data_capacity);
673 void *buffer = calloc(1, memoryRequired);
674 if (buffer == nullptr) {
675 METADATA_ERR_LOG("AllocateCameraMetadataBuffer memory allocation failed");
676 return reinterpret_cast<common_metadata_header_t *>(buffer);
677 }
678
679 common_metadata_header_t *metadataHeader = FillCameraMetadata(reinterpret_cast<common_metadata_header_t *>(buffer),
680 memoryRequired, item_capacity, data_capacity);
681 if (metadataHeader == nullptr) {
682 METADATA_ERR_LOG("AllocateCameraMetadataBuffer metadataHeader is null");
683 free(buffer);
684 }
685
686 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer end");
687 return metadataHeader;
688 }
689
690 // Load vendor tag impl
LoadVendorTagImpl()691 int32_t LoadVendorTagImpl()
692 {
693 std::lock_guard<std::mutex> lock(g_vendorTagImplMtx);
694 if (g_vendorTagImpl == nullptr) {
695 void* libHandle = nullptr;
696 #ifndef CAMERA_VENDOR_TAG
697 libHandle = dlopen(g_exampleVendorTagLib, RTLD_LAZY);
698 #else
699 libHandle = dlopen(g_vendorTagLib, RTLD_LAZY);
700 #endif
701 if (libHandle == nullptr) {
702 METADATA_ERR_LOG("dlopen failed %{public}s", __func__);
703 return CAM_META_FAILURE;
704 }
705
706 CreateCameraVendorTag* createVendorTag =
707 reinterpret_cast<CreateCameraVendorTag*>(dlsym(libHandle, "CreateVendorTagImpl"));
708 if (createVendorTag == nullptr) {
709 METADATA_ERR_LOG("CreateCameraVendorTag failed %{public}s", __func__);
710 dlclose(libHandle);
711 return CAM_META_FAILURE;
712 }
713
714 g_vendorTagImpl = createVendorTag();
715 if (g_vendorTagImpl == nullptr) {
716 METADATA_ERR_LOG("createVendorTag failed %{public}s", __func__);
717 dlclose(libHandle);
718 return CAM_META_FAILURE;
719 }
720 }
721
722 return CAM_META_SUCCESS;
723 }
724
GetMetadataSection(uint32_t itemSection,uint32_t * section)725 int32_t CameraMetadata::GetMetadataSection(uint32_t itemSection, uint32_t *section)
726 {
727 METADATA_DEBUG_LOG("GetMetadataSection start");
728 if (itemSection < OHOS_CAMERA_PROPERTIES ||
729 itemSection >= OHOS_ABILITY_SECTION_END) {
730 METADATA_ERR_LOG("GetMetadataSection itemSection is not valid");
731 return CAM_META_FAILURE;
732 }
733
734 if (section == nullptr) {
735 METADATA_ERR_LOG("GetMetadataSection section is nullptr");
736 return CAM_META_FAILURE;
737 }
738
739 int32_t ret = CAM_META_SUCCESS;
740 auto iter = g_metadataSectionMap.find(itemSection);
741 if (iter != g_metadataSectionMap.end()) {
742 *section = iter->second;
743 } else {
744 METADATA_ERR_LOG("GetMetadataSection item section is not defined");
745 ret = CAM_META_FAILURE;
746 }
747
748 METADATA_DEBUG_LOG("GetMetadataSection end");
749 return ret;
750 }
751
GetCameraMetadataItemType(uint32_t item,uint32_t * dataType)752 int32_t CameraMetadata::GetCameraMetadataItemType(uint32_t item, uint32_t *dataType)
753 {
754 METADATA_DEBUG_LOG("GetCameraMetadataItemType start");
755 if (dataType == nullptr) {
756 METADATA_ERR_LOG("GetCameraMetadataItemType dataType is null");
757 return CAM_META_INVALID_PARAM;
758 }
759 uint32_t section;
760 uint32_t itemTag = item >> BITWISE_SHIFT_16;
761 if (itemTag >= OHOS_VENDOR_SECTION) {
762 int32_t ret = LoadVendorTagImpl();
763 if (ret != CAM_META_SUCCESS) {
764 METADATA_ERR_LOG("LoadVendorTagImpl failed");
765 return CAM_META_FAILURE;
766 }
767 std::lock_guard<std::mutex> lock(g_vendorTagImplMtx);
768 *dataType = g_vendorTagImpl->GetVendorTagType(item);
769 return CAM_META_SUCCESS;
770 }
771 int32_t ret = GetMetadataSection(itemTag, §ion);
772 if (ret != CAM_META_SUCCESS) {
773 METADATA_ERR_LOG("GetCameraMetadataItemType section is not valid");
774 return ret;
775 }
776
777 if (item >= g_ohosCameraSectionBounds[section][1]) {
778 METADATA_ERR_LOG("GetCameraMetadataItemType item is not in section bound");
779 return CAM_META_FAILURE;
780 }
781
782 uint32_t itemIndex = item & 0xFFFF;
783 if (g_ohosItemInfo[section][itemIndex].item_type < META_TYPE_BYTE) {
784 METADATA_ERR_LOG("GetCameraMetadataItemType item is not initialized");
785 return CAM_META_FAILURE;
786 }
787
788 *dataType = g_ohosItemInfo[section][itemIndex].item_type;
789
790 METADATA_DEBUG_LOG("GetCameraMetadataItemType end");
791 return CAM_META_SUCCESS;
792 }
793
GetCameraMetadataItemName(uint32_t item)794 const char *CameraMetadata::GetCameraMetadataItemName(uint32_t item)
795 {
796 METADATA_DEBUG_LOG("GetCameraMetadataItemName start");
797 METADATA_DEBUG_LOG("GetCameraMetadataItemName item: %{public}u", item);
798 uint32_t section;
799 uint32_t itemTag = item >> BITWISE_SHIFT_16;
800 if (itemTag >= OHOS_VENDOR_SECTION) {
801 int32_t ret = LoadVendorTagImpl();
802 if (ret != CAM_META_SUCCESS) {
803 METADATA_ERR_LOG("LoadVendorTagImpl failed");
804 return nullptr;
805 }
806 std::lock_guard<std::mutex> lock(g_vendorTagImplMtx);
807 const char* tagName = g_vendorTagImpl->GetVendorTagName(item);
808 return tagName;
809 }
810 int32_t ret = GetMetadataSection(itemTag, §ion);
811 if (ret != CAM_META_SUCCESS) {
812 METADATA_ERR_LOG("GetCameraMetadataItemName section is not valid");
813 return nullptr;
814 }
815
816 if (item >= g_ohosCameraSectionBounds[section][1]) {
817 METADATA_ERR_LOG("GetCameraMetadataItemName item is not in section bound");
818 return nullptr;
819 }
820
821 uint32_t itemIndex = item & 0xFFFF;
822 METADATA_DEBUG_LOG("GetCameraMetadataItemName end");
823 return g_ohosItemInfo[section][itemIndex].item_name;
824 }
825
CalculateCameraMetadataItemDataSize(uint32_t type,size_t dataCount)826 int32_t CameraMetadata::CalculateCameraMetadataItemDataSize(uint32_t type, size_t dataCount)
827 {
828 METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize start");
829 if (type < META_TYPE_BYTE || type >= META_NUM_TYPES) {
830 METADATA_ERR_LOG("CalculateCameraMetadataItemDataSize invalid type");
831 return CAM_META_FAILURE;
832 }
833
834 size_t dataBytes = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[type];
835
836 METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize end");
837 return (dataBytes <= METADATA_HEADER_DATA_SIZE) ? 0 : AlignTo(dataBytes, DATA_ALIGNMENT);
838 }
839
AddCameraMetadataItemVerify(common_metadata_header_t * dst,uint32_t item,const void * data,size_t dataCount,uint32_t * dataType)840 int CameraMetadata::AddCameraMetadataItemVerify(common_metadata_header_t *dst,
841 uint32_t item, const void *data, size_t dataCount, uint32_t *dataType)
842 {
843 const char *name = GetCameraMetadataItemName(item);
844 if (name == nullptr) {
845 name = "<unknown>";
846 }
847 METADATA_DEBUG_LOG("AddCameraMetadataItemVerify item id: %{public}u, name: %{public}s, "
848 "dataCount: %{public}zu", item, name, dataCount);
849
850 if (dst == nullptr) {
851 METADATA_ERR_LOG("AddCameraMetadataItemVerify common_metadata_header_t is null");
852 return CAM_META_INVALID_PARAM;
853 }
854
855 if (!dataCount || data == nullptr) {
856 METADATA_ERR_LOG("AddCameraMetadataItemVerify data is not valid. item: %{public}u, "
857 "dataCount: %{public}zu", item, dataCount);
858 return CAM_META_INVALID_PARAM;
859 }
860
861 if (dst->item_count == dst->item_capacity) {
862 METADATA_ERR_LOG("AddCameraMetadataItemVerify item_capacity limit reached. "
863 "item_count: %{public}d, item_capacity: %{public}d", dst->item_count, dst->item_capacity);
864 return CAM_META_ITEM_CAP_EXCEED;
865 }
866
867 int32_t ret = GetCameraMetadataItemType(item, dataType);
868 if (ret != CAM_META_SUCCESS) {
869 METADATA_ERR_LOG("AddCameraMetadataItemVerify invalid item type");
870 return CAM_META_INVALID_PARAM;
871 }
872
873 if (*dataType < META_TYPE_BYTE || *dataType >= META_NUM_TYPES) {
874 METADATA_ERR_LOG("AddCameraMetadataItemVerify invalid type");
875 return CAM_META_INVALID_PARAM;
876 }
877
878 return CAM_META_SUCCESS;
879 }
880
AddCameraMetadataItem(common_metadata_header_t * dst,uint32_t item,const void * data,size_t dataCount)881 int CameraMetadata::AddCameraMetadataItem(common_metadata_header_t *dst, uint32_t item,
882 const void *data, size_t dataCount)
883 {
884 METADATA_DEBUG_LOG("AddCameraMetadataItem start");
885 uint32_t dataType;
886 int32_t ret = AddCameraMetadataItemVerify(dst, item, data, dataCount, &dataType);
887 if (ret != CAM_META_SUCCESS) return ret;
888
889 if ((dst->size - dst->items_start) < (uint64_t)dst->item_count * itemLen ||
890 (dst->size - dst->data_start) < dst->data_count) {
891 METADATA_ERR_LOG("AddCameraMetadataItem fail: invalid argument.");
892 return CAM_META_INVALID_PARAM;
893 }
894
895 int32_t dataBytes = CalculateCameraMetadataItemDataSize(dataType, dataCount);
896 if (dataBytes + dst->data_count > dst->data_capacity) {
897 METADATA_ERR_LOG("AddCameraMetadataItem data_capacity limit reached");
898 return CAM_META_DATA_CAP_EXCEED;
899 }
900
901 size_t dataPayloadBytes = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[dataType];
902 camera_metadata_item_entry_t *pItem = GetMetadataItems(dst);
903 if (pItem == nullptr) {
904 METADATA_ERR_LOG("AddCameraMetadataItem pItem is null");
905 return CAM_META_INVALID_PARAM;
906 }
907 camera_metadata_item_entry_t *metadataItem = pItem + dst->item_count;
908 ret = memset_s(metadataItem, sizeof(camera_metadata_item_entry_t), 0, sizeof(camera_metadata_item_entry_t));
909 if (ret != EOK) {
910 METADATA_ERR_LOG("AddCameraMetadataItem: memset_s failed");
911 return CAM_META_FAILURE;
912 }
913 metadataItem->item = item;
914 metadataItem->data_type = dataType;
915 metadataItem->count = dataCount;
916
917 if (dataBytes == 0) {
918 ret = memcpy_s(metadataItem->data.value, METADATA_HEADER_DATA_SIZE, data, dataPayloadBytes);
919 if (ret != EOK) {
920 METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed");
921 return CAM_META_FAILURE;
922 }
923 } else {
924 metadataItem->data.offset = dst->data_count;
925 uint8_t *dstMetadataData = GetMetadataData(dst);
926 if (dstMetadataData == nullptr) {
927 METADATA_ERR_LOG("AddCameraMetadataItem GetMetadataData failed");
928 return CAM_META_FAILURE;
929 }
930 ret = memcpy_s(dstMetadataData + metadataItem->data.offset, dst->data_capacity - dst->data_count, data,
931 dataPayloadBytes);
932 if (ret != EOK) {
933 METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed");
934 return CAM_META_FAILURE;
935 }
936 dst->data_count += dataBytes;
937 }
938 dst->item_count++;
939
940 METADATA_DEBUG_LOG("AddCameraMetadataItem end");
941 return CAM_META_SUCCESS;
942 }
943
GetCameraMetadataItem(const common_metadata_header_t * src,uint32_t index,camera_metadata_item_t * item)944 int CameraMetadata::GetCameraMetadataItem(const common_metadata_header_t *src, uint32_t index,
945 camera_metadata_item_t *item)
946 {
947 METADATA_DEBUG_LOG("GetCameraMetadataItem start");
948 if (src == nullptr || item == nullptr) {
949 METADATA_ERR_LOG("GetCameraMetadataItem src or item is null");
950 return CAM_META_INVALID_PARAM;
951 }
952
953 int32_t ret = memset_s(item, sizeof(camera_metadata_item_t), 0, sizeof(camera_metadata_item_t));
954 if (ret != EOK) {
955 METADATA_ERR_LOG("GetCameraMetadataItem: memset_s failed");
956 return CAM_META_FAILURE;
957 }
958 if (index >= src->item_count) {
959 METADATA_ERR_LOG("GetCameraMetadataItem index is greater than item count");
960 return CAM_META_INVALID_PARAM;
961 }
962 camera_metadata_item_entry_t *pItem = GetMetadataItems(src);
963 if (pItem == nullptr) {
964 METADATA_ERR_LOG("GetCameraMetadataItem pItem is null");
965 return CAM_META_INVALID_PARAM;
966 }
967 camera_metadata_item_entry_t *localItem = pItem + index;
968
969 item->index = index;
970 item->item = localItem->item;
971 item->data_type = localItem->data_type;
972 item->count = localItem->count;
973
974 int32_t dataBytes = CalculateCameraMetadataItemDataSize(localItem->data_type, localItem->count);
975 if (dataBytes == 0) {
976 item->data.u8 = localItem->data.value;
977 } else if (dataBytes == CAM_META_FAILURE) {
978 METADATA_ERR_LOG("GetCameraMetadataItem invalid datatype:%{public}d", localItem->data_type);
979 return CAM_META_FAILURE;
980 } else {
981 uint8_t *srcMetadataData = GetMetadataData(src);
982 if (srcMetadataData == nullptr) {
983 METADATA_ERR_LOG("GetCameraMetadataItem GetMetadataData failed");
984 return CAM_META_FAILURE;
985 }
986 if (localItem->data.offset > src->data_count) {
987 METADATA_ERR_LOG("GetCameraMetadataItem offset is greater than data count,"
988 " offset:%{public}u, data count:%{public}u", localItem->data.offset, src->data_count);
989 return CAM_META_FAILURE;
990 }
991 item->data.u8 = srcMetadataData + localItem->data.offset;
992 }
993
994 METADATA_DEBUG_LOG("GetCameraMetadataItem end");
995 return CAM_META_SUCCESS;
996 }
997
FindCameraMetadataItemIndex(const common_metadata_header_t * src,uint32_t item,uint32_t * idx,bool isPrintLog)998 int CameraMetadata::FindCameraMetadataItemIndex(const common_metadata_header_t *src, uint32_t item, uint32_t *idx,
999 bool isPrintLog)
1000 {
1001 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex start");
1002 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex item: %{public}u", item);
1003 if (src == nullptr || idx == nullptr) {
1004 METADATA_ERR_LOG("FindCameraMetadataItemIndex src or index is null");
1005 return CAM_META_INVALID_PARAM;
1006 }
1007
1008 camera_metadata_item_entry_t *searchItem = GetMetadataItems(src);
1009 if (searchItem == nullptr) {
1010 METADATA_ERR_LOG("FindCameraMetadataItemIndex item is null");
1011 return CAM_META_INVALID_PARAM;
1012 }
1013 uint32_t index;
1014 for (index = 0; index < src->item_count; index++, searchItem++) {
1015 if (searchItem->item == item) {
1016 break;
1017 }
1018 }
1019
1020 if (index == src->item_count) {
1021 if (isPrintLog) {
1022 METADATA_ERR_LOG("FindCameraMetadataItemIndex item: %{public}u not found", item);
1023 }
1024 return CAM_META_ITEM_NOT_FOUND;
1025 }
1026
1027 if (!CheckItemDataType(*searchItem)) {
1028 return CAM_META_INVALID_PARAM;
1029 }
1030
1031 *idx = index;
1032 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex index: %{public}u", index);
1033 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex end");
1034 return CAM_META_SUCCESS;
1035 }
1036
FindCameraMetadataItem(const common_metadata_header_t * src,uint32_t item,camera_metadata_item_t * metadataItem)1037 int CameraMetadata::FindCameraMetadataItem(const common_metadata_header_t *src, uint32_t item,
1038 camera_metadata_item_t *metadataItem)
1039 {
1040 uint32_t index = 0;
1041 const char *name = GetCameraMetadataItemName(item);
1042 if (name == nullptr) {
1043 name = "<unknown>";
1044 }
1045 METADATA_DEBUG_LOG("FindCameraMetadataItem item id: %{public}u, name: %{public}s", item, name);
1046 int ret = FindCameraMetadataItemIndex(src, item, &index);
1047 if (ret != CAM_META_SUCCESS) {
1048 return ret;
1049 }
1050
1051 return GetCameraMetadataItem(src, index, metadataItem);
1052 }
1053
IsCameraMetadataItemExist(const common_metadata_header_t * src,uint32_t item)1054 bool CameraMetadata::IsCameraMetadataItemExist(const common_metadata_header_t *src, uint32_t item)
1055 {
1056 uint32_t index = 0;
1057 int ret = FindCameraMetadataItemIndex(src, item, &index, false);
1058 return ret == CAM_META_SUCCESS;
1059 }
1060
SetOffset(camera_metadata_item_entry_t * metadataItems,camera_metadata_item_entry_t * item,size_t oldItemSize)1061 void SetOffset(camera_metadata_item_entry_t *metadataItems, camera_metadata_item_entry_t *item, size_t oldItemSize)
1062 {
1063 if (metadataItems == nullptr) {
1064 METADATA_ERR_LOG("SetOffset metadataItems is null");
1065 return;
1066 }
1067 if (CalculateCameraMetadataItemDataSize(metadataItems->data_type, metadataItems->count) > 0 &&
1068 metadataItems->data.offset > item->data.offset) {
1069 metadataItems->data.offset -= oldItemSize;
1070 }
1071 }
1072
MetadataExpandItemMem(common_metadata_header_t * dst,camera_metadata_item_entry_t * item,size_t oldItemSize)1073 int CameraMetadata::MetadataExpandItemMem(common_metadata_header_t *dst, camera_metadata_item_entry_t *item,
1074 size_t oldItemSize)
1075 {
1076 if (item == nullptr || dst == nullptr) {
1077 METADATA_ERR_LOG("MetadataExpandItemMem item is null or dst is null");
1078 return CAM_META_INVALID_PARAM;
1079 }
1080 uint8_t *dstMetadataData = GetMetadataData(dst);
1081 if (dstMetadataData == nullptr) {
1082 METADATA_ERR_LOG("MetadataExpandItemMem GetMetadataData failed");
1083 return CAM_META_FAILURE;
1084 }
1085 if (item->data.offset > UINT32_MAX - (uint32_t)oldItemSize ||
1086 item->data.offset + (uint32_t)oldItemSize > dst->data_count) {
1087 METADATA_ERR_LOG("MetadataExpandItemMem data.offset:%{public}u, oldItemSize:%{public}zu, "
1088 "dst->data_count:%{public}u", item->data.offset, oldItemSize, dst->data_count);
1089 return CAM_META_FAILURE;
1090 }
1091 uint8_t *start = dstMetadataData + item->data.offset;
1092 uint8_t *end = start + oldItemSize;
1093 size_t length = dst->data_count - item->data.offset - oldItemSize;
1094 if (length != 0) {
1095 int32_t ret = memmove_s(start, length, end, length);
1096 if (ret != EOK) {
1097 METADATA_ERR_LOG("MetadataExpandItemMem memory move failed");
1098 return CAM_META_FAILURE;
1099 }
1100 }
1101 dst->data_count -= oldItemSize;
1102
1103 camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst);
1104 for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) {
1105 SetOffset(metadataItems, item, oldItemSize);
1106 }
1107
1108 return CAM_META_SUCCESS;
1109 }
1110
copyMetadataMemory(common_metadata_header_t * dst,camera_metadata_item_entry_t * item,size_t dataPayloadSize,const void * data)1111 int CameraMetadata::copyMetadataMemory(common_metadata_header_t *dst, camera_metadata_item_entry_t *item,
1112 size_t dataPayloadSize, const void *data)
1113 {
1114 uint8_t *dstMetadataData = GetMetadataData(dst);
1115 int32_t ret = CAM_META_SUCCESS;
1116 if (dstMetadataData == nullptr) {
1117 METADATA_ERR_LOG("copyMetadataMemory GetMetadataData failed");
1118 return CAM_META_FAILURE;
1119 }
1120 if (dst->size < item->data.offset) {
1121 METADATA_ERR_LOG("copyMetadataMemory offset is greater than total size,"
1122 " offset:%{public}u, total size:%{public}u", item->data.offset, dst->size);
1123 return CAM_META_FAILURE;
1124 }
1125 ret = memcpy_s(dstMetadataData + item->data.offset, dataPayloadSize, data, dataPayloadSize);
1126 if (ret != EOK) {
1127 METADATA_ERR_LOG("copyMetadataMemory memory copy failed");
1128 return CAM_META_FAILURE;
1129 }
1130 return CAM_META_SUCCESS;
1131 }
1132
UpdateCameraMetadataItemSize(camera_metadata_item_entry_t * item,uint32_t dataCount,common_metadata_header_t * dst,const void * data)1133 int CameraMetadata::UpdateCameraMetadataItemSize(camera_metadata_item_entry_t *item, uint32_t dataCount,
1134 common_metadata_header_t *dst, const void *data)
1135 {
1136 if (item == nullptr) {
1137 METADATA_ERR_LOG("UpdateCameraMetadataItemSize item is null");
1138 return CAM_META_FAILURE;
1139 } else if (item->data_type < META_TYPE_BYTE || item->data_type >= META_NUM_TYPES) {
1140 METADATA_ERR_LOG("UpdateCameraMetadataItemSize invalid datatype:%{public}d", item->data_type);
1141 return CAM_META_FAILURE;
1142 }
1143 int32_t dataSize = CalculateCameraMetadataItemDataSize(item->data_type, dataCount);
1144 size_t dataPayloadSize = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[item->data_type];
1145 int32_t oldItemSize = CalculateCameraMetadataItemDataSize(item->data_type, item->count);
1146 int32_t ret = CAM_META_SUCCESS;
1147 if (item == nullptr || dst == nullptr) {
1148 METADATA_ERR_LOG("UpdateCameraMetadataItemSize item is null or dst is null");
1149 return CAM_META_FAILURE;
1150 }
1151 if (dataSize != oldItemSize) {
1152 if (dst->data_capacity < (dst->data_count + dataSize - oldItemSize)) {
1153 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data_capacity limit reached");
1154 return CAM_META_DATA_CAP_EXCEED;
1155 }
1156 if (oldItemSize != 0) {
1157 ret = MetadataExpandItemMem(dst, item, oldItemSize);
1158 if (ret != CAM_META_SUCCESS) {
1159 return ret;
1160 }
1161 }
1162 if (dataSize != 0) {
1163 item->data.offset = dst->data_count;
1164 ret = copyMetadataMemory(dst, item, dataPayloadSize, data);
1165 if (ret != CAM_META_SUCCESS) {
1166 return ret;
1167 }
1168 dst->data_count += dataSize;
1169 }
1170 } else if (dataSize != 0) {
1171 ret = copyMetadataMemory(dst, item, dataPayloadSize, data);
1172 if (ret != CAM_META_SUCCESS) {
1173 return ret;
1174 }
1175 }
1176 if (dataSize == 0) {
1177 ret = memcpy_s(item->data.value, dataPayloadSize, data, dataPayloadSize);
1178 if (ret != EOK) {
1179 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed");
1180 return CAM_META_FAILURE;
1181 }
1182 }
1183 return ret;
1184 }
1185
UpdateCameraMetadataItemByIndex(common_metadata_header_t * dst,uint32_t index,const void * data,uint32_t dataCount,camera_metadata_item_t * updatedItem)1186 int CameraMetadata::UpdateCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index,
1187 const void *data, uint32_t dataCount, camera_metadata_item_t *updatedItem)
1188 {
1189 METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex start");
1190 if ((dst == nullptr) || (index >= dst->item_count)) {
1191 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex dst is null or invalid index");
1192 return CAM_META_INVALID_PARAM;
1193 }
1194
1195 if (!dataCount || data == nullptr) {
1196 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data is not valid. "
1197 "dataCount: %{public}u", dataCount);
1198 return CAM_META_INVALID_PARAM;
1199 }
1200
1201 int32_t ret = CAM_META_SUCCESS;
1202 camera_metadata_item_entry_t *metadataItem = GetMetadataItems(dst);
1203 if (metadataItem == nullptr) {
1204 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex item is null");
1205 return CAM_META_INVALID_PARAM;
1206 }
1207 camera_metadata_item_entry_t *item = metadataItem + index;
1208
1209 ret = UpdateCameraMetadataItemSize(item, dataCount, dst, data);
1210 if (ret != CAM_META_SUCCESS) {
1211 return ret;
1212 }
1213
1214 item->count = dataCount;
1215 if (updatedItem != nullptr) {
1216 ret = GetCameraMetadataItem(dst, index, updatedItem);
1217 if (ret != CAM_META_SUCCESS) {
1218 return ret;
1219 }
1220 }
1221
1222 METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex end");
1223 return ret;
1224 }
1225
UpdateCameraMetadataItem(common_metadata_header_t * dst,uint32_t item,const void * data,uint32_t dataCount,camera_metadata_item_t * updatedItem)1226 int CameraMetadata::UpdateCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data,
1227 uint32_t dataCount, camera_metadata_item_t *updatedItem)
1228 {
1229 METADATA_DEBUG_LOG("UpdateCameraMetadataItem item id: %{public}u, dataCount: %{public}u", item, dataCount);
1230 const char *name = GetCameraMetadataItemName(item);
1231 if (name == nullptr) {
1232 name = "<unknown>";
1233 }
1234 METADATA_DEBUG_LOG("UpdateCameraMetadataItem item id: %{public}u, name: %{public}s, "
1235 "dataCount: %{public}u", item, name, dataCount);
1236 if (!dataCount || data == nullptr) {
1237 METADATA_ERR_LOG("UpdateCameraMetadataItem data is not valid. item: %{public}u, "
1238 "dataCount: %{public}u", item, dataCount);
1239 return CAM_META_INVALID_PARAM;
1240 }
1241
1242 uint32_t index = 0;
1243 int32_t ret = FindCameraMetadataItemIndex(dst, item, &index);
1244 if (ret != CAM_META_SUCCESS) {
1245 return ret;
1246 }
1247
1248 return UpdateCameraMetadataItemByIndex(dst, index, data, dataCount, updatedItem);
1249 }
1250
moveMetadataMemery(common_metadata_header_t * dst,camera_metadata_item_entry_t * itemToDelete,size_t dataBytes)1251 int CameraMetadata::moveMetadataMemery(common_metadata_header_t *dst, camera_metadata_item_entry_t *itemToDelete,
1252 size_t dataBytes)
1253 {
1254 if (itemToDelete == nullptr) {
1255 METADATA_ERR_LOG("UpdateCameraMetadataItemSize itemToDelete is null");
1256 return CAM_META_INVALID_PARAM;
1257 }
1258 uint8_t *dstMetadataData = GetMetadataData(dst);
1259 if (dstMetadataData == nullptr) {
1260 METADATA_ERR_LOG("UpdateCameraMetadataItemSize GetMetadataData failed");
1261 return CAM_META_FAILURE;
1262 }
1263 int32_t ret = CAM_META_SUCCESS;
1264 uint8_t *start = dstMetadataData + itemToDelete->data.offset;
1265 uint8_t *end = start + dataBytes;
1266 size_t length = dst->data_count - itemToDelete->data.offset - dataBytes;
1267 if (length != 0) {
1268 ret = memmove_s(start, length, end, length);
1269 if (ret != EOK) {
1270 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed");
1271 return CAM_META_FAILURE;
1272 }
1273 }
1274 return CAM_META_SUCCESS;
1275 }
1276
DeleteCameraMetadataItemByIndex(common_metadata_header_t * dst,uint32_t index)1277 int CameraMetadata::DeleteCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index)
1278 {
1279 METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex start");
1280 if (dst == nullptr) {
1281 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex dst is null");
1282 return CAM_META_INVALID_PARAM;
1283 }
1284
1285 if (index >= dst->item_count) {
1286 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex item not valid");
1287 return CAM_META_INVALID_PARAM;
1288 }
1289
1290 int32_t ret = CAM_META_SUCCESS;
1291 camera_metadata_item_entry_t *pItem = GetMetadataItems(dst);
1292 if (pItem == nullptr) {
1293 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex pItem is null");
1294 return CAM_META_INVALID_PARAM;
1295 }
1296 camera_metadata_item_entry_t *itemToDelete = pItem + index;
1297 int32_t dataBytes = CalculateCameraMetadataItemDataSize(itemToDelete->data_type, itemToDelete->count);
1298 if (dataBytes > 0) {
1299 ret = moveMetadataMemery(dst, itemToDelete, dataBytes);
1300 if (ret != CAM_META_SUCCESS) {
1301 return ret;
1302 }
1303 dst->data_count -= dataBytes;
1304
1305 camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst);
1306 for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) {
1307 if (CalculateCameraMetadataItemDataSize(
1308 metadataItems->data_type, metadataItems->count) > 0 &&
1309 metadataItems->data.offset > itemToDelete->data.offset) {
1310 metadataItems->data.offset -= dataBytes;
1311 }
1312 }
1313 } else if (dataBytes == CAM_META_FAILURE) {
1314 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex invalid datatype:%{public}d", itemToDelete->data_type);
1315 return CAM_META_FAILURE;
1316 }
1317
1318 uint64_t length = sizeof(camera_metadata_item_entry_t) * (dst->item_count - index - 1);
1319 if (length != 0) {
1320 ret = memmove_s(itemToDelete, length, itemToDelete + 1, length);
1321 if (ret != EOK) {
1322 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed");
1323 return CAM_META_FAILURE;
1324 }
1325 }
1326 dst->item_count -= 1;
1327 METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex end");
1328 return ret;
1329 }
1330
DeleteCameraMetadataItem(common_metadata_header_t * dst,uint32_t item)1331 int CameraMetadata::DeleteCameraMetadataItem(common_metadata_header_t *dst, uint32_t item)
1332 {
1333 METADATA_DEBUG_LOG("DeleteCameraMetadataItem item: %{public}u", item);
1334 uint32_t index = 0;
1335 int32_t ret = FindCameraMetadataItemIndex(dst, item, &index);
1336 if (ret != CAM_META_SUCCESS) {
1337 return ret;
1338 }
1339
1340 return DeleteCameraMetadataItemByIndex(dst, index);
1341 }
1342
FreeCameraMetadataBuffer(common_metadata_header_t * dst)1343 void CameraMetadata::FreeCameraMetadataBuffer(common_metadata_header_t *dst)
1344 {
1345 if (dst != nullptr) {
1346 free(dst);
1347 }
1348 }
1349
GetCameraMetadataItemCount(const common_metadata_header_t * metadataHeader)1350 uint32_t CameraMetadata::GetCameraMetadataItemCount(const common_metadata_header_t *metadataHeader)
1351 {
1352 if (!metadataHeader) {
1353 METADATA_ERR_LOG("GetCameraMetadataItemCount::metadataHeader is null");
1354 return 0;
1355 }
1356 return metadataHeader->item_count;
1357 }
1358
GetCameraMetadataItemCapacity(const common_metadata_header_t * metadataHeader)1359 uint32_t CameraMetadata::GetCameraMetadataItemCapacity(const common_metadata_header_t *metadataHeader)
1360 {
1361 if (!metadataHeader) {
1362 METADATA_ERR_LOG("GetCameraMetadataItemCapacity::metadataHeader is null");
1363 return 0;
1364 }
1365 return metadataHeader->item_capacity;
1366 }
1367
GetCameraMetadataDataSize(const common_metadata_header_t * metadataHeader)1368 uint32_t CameraMetadata::GetCameraMetadataDataSize(const common_metadata_header_t *metadataHeader)
1369 {
1370 if (metadataHeader == nullptr) {
1371 METADATA_ERR_LOG("GetCameraMetadataDataSize::metadataHeader is null");
1372 return 0;
1373 }
1374 return metadataHeader->data_capacity;
1375 }
1376
CopyCameraMetadataItems(common_metadata_header_t * newMetadata,const common_metadata_header_t * oldMetadata)1377 int32_t CameraMetadata::CopyCameraMetadataItems(common_metadata_header_t *newMetadata,
1378 const common_metadata_header_t *oldMetadata)
1379 {
1380 if (newMetadata == nullptr || oldMetadata == nullptr) {
1381 return CAM_META_INVALID_PARAM;
1382 }
1383
1384 int32_t ret;
1385 if (oldMetadata->item_count != 0) {
1386 ret = memcpy_s(GetMetadataItems(newMetadata), sizeof(camera_metadata_item_entry_t[newMetadata->item_capacity]),
1387 GetMetadataItems(oldMetadata), sizeof(camera_metadata_item_entry_t[oldMetadata->item_count]));
1388 if (ret != EOK) {
1389 METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed, ItemCapacity Size = %{public}u,"
1390 "ItemCount Size = %{public}u", newMetadata->item_capacity, oldMetadata->item_count);
1391 return CAM_META_FAILURE;
1392 }
1393 }
1394
1395 if (oldMetadata->data_count != 0) {
1396 uint8_t *newMetadataData = GetMetadataData(newMetadata);
1397 uint8_t *oldMetadataData = GetMetadataData(oldMetadata);
1398 if (newMetadataData == nullptr || oldMetadataData == nullptr) {
1399 METADATA_ERR_LOG("UpdateCameraMetadataItemSize GetMetadataData failed");
1400 return CAM_META_FAILURE;
1401 }
1402 ret = memcpy_s(newMetadataData, sizeof(uint8_t[newMetadata->data_capacity]), oldMetadataData,
1403 sizeof(uint8_t[oldMetadata->data_count]));
1404 if (ret != EOK) {
1405 METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed, DataCapacity Size = %{public}u,"
1406 "DataCount Size = %{public}u", newMetadata->data_capacity, oldMetadata->data_count);
1407 return CAM_META_FAILURE;
1408 }
1409 }
1410
1411 newMetadata->item_count = oldMetadata->item_count;
1412 newMetadata->data_count = oldMetadata->data_count;
1413
1414 return CAM_META_SUCCESS;
1415 }
1416
U8ItemToString(int32_t item,const camera_metadata_item_t entry)1417 std::string U8ItemToString(int32_t item, const camera_metadata_item_t entry)
1418 {
1419 std::string st = {};
1420 uint32_t count = entry.count;
1421 if (entry.data.u8 == nullptr) {
1422 METADATA_ERR_LOG("U8ItemToString: entry.data.u8 is null");
1423 return st;
1424 }
1425 std::string dataStr = std::to_string(*(entry.data.u8));
1426 for (uint32_t i = 1; i < count; i++) {
1427 if ((i % WRAP_LENGTH) == 0) {
1428 dataStr += "]\n\t[" + std::to_string(*(entry.data.u8 + i));
1429 } else {
1430 dataStr += " " + std::to_string(*(entry.data.u8 + i));
1431 }
1432 }
1433
1434 const char *name = GetCameraMetadataItemName(item);
1435 if (name == nullptr) {
1436 METADATA_ERR_LOG("U8ItemToString: get u8 item name fail");
1437 return st;
1438 }
1439 std::string nameStr(name);
1440
1441 st = nameStr + " (" + std::to_string(entry.index) + "): " +
1442 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
1443
1444 return st;
1445 }
1446
I32ItemToString(int32_t item,const camera_metadata_item_t entry)1447 std::string I32ItemToString(int32_t item, const camera_metadata_item_t entry)
1448 {
1449 std::string st = {};
1450 uint32_t count = entry.count;
1451 if (entry.data.i32 == nullptr) {
1452 METADATA_ERR_LOG("I32ItemToString: entry.data.i32 is null");
1453 return st;
1454 }
1455 std::string dataStr = std::to_string(*(entry.data.i32));
1456 for (uint32_t i = 1; i < count; i++) {
1457 if ((i % WRAP_LENGTH) == 0) {
1458 dataStr += "]\n\t[" + std::to_string(*(entry.data.i32 + i));
1459 } else {
1460 dataStr += " " + std::to_string(*(entry.data.i32 + i));
1461 }
1462 }
1463
1464 const char *name = GetCameraMetadataItemName(item);
1465 if (name == nullptr) {
1466 METADATA_ERR_LOG("I32ItemToString: get i32 item name fail");
1467 return st;
1468 }
1469 std::string nameStr(name);
1470
1471 st = nameStr + " (" + std::to_string(entry.index) + "): " +
1472 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
1473
1474 return st;
1475 }
1476
U32ItemToString(int32_t item,const camera_metadata_item_t entry)1477 std::string U32ItemToString(int32_t item, const camera_metadata_item_t entry)
1478 {
1479 std::string st = {};
1480 uint32_t count = entry.count;
1481 if (entry.data.ui32 == nullptr) {
1482 METADATA_ERR_LOG("U32ItemToString: entry.data.ui32 is null");
1483 return st;
1484 }
1485 std::string dataStr = std::to_string(*(entry.data.ui32));
1486 for (uint32_t i = 1; i < count; i++) {
1487 if ((i % WRAP_LENGTH) == 0) {
1488 dataStr += "]\n\t[" + std::to_string(*(entry.data.ui32 + i));
1489 } else {
1490 dataStr += " " + std::to_string(*(entry.data.ui32 + i));
1491 }
1492 }
1493
1494 const char *name = GetCameraMetadataItemName(item);
1495 if (name == nullptr) {
1496 METADATA_ERR_LOG("U32ItemToString: get u32 item name fail");
1497 return st;
1498 }
1499 std::string nameStr(name);
1500
1501 st = nameStr + " (" + std::to_string(entry.index) + "): " +
1502 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
1503
1504 return st;
1505 }
1506
I64ItemToString(int32_t item,const camera_metadata_item_t entry)1507 std::string I64ItemToString(int32_t item, const camera_metadata_item_t entry)
1508 {
1509 std::string st = {};
1510 uint32_t count = entry.count;
1511 if (entry.data.i64 == nullptr) {
1512 METADATA_ERR_LOG("I64ItemToString: entry.data.i64 is null");
1513 return st;
1514 }
1515 std::string dataStr = std::to_string(*(entry.data.i64));
1516 for (uint32_t i = 1; i < count; i++) {
1517 if ((i % WRAP_LENGTH) == 0) {
1518 dataStr += "]\n\t[" + std::to_string(*(entry.data.i64 + i));
1519 } else {
1520 dataStr += " " + std::to_string(*(entry.data.i64 + i));
1521 }
1522 }
1523
1524 const char *name = GetCameraMetadataItemName(item);
1525 if (name == nullptr) {
1526 METADATA_ERR_LOG("I64ItemToString: get i64 item name fail");
1527 return st;
1528 }
1529 std::string nameStr(name);
1530
1531 st = nameStr + " (" + std::to_string(entry.index) + "): " +
1532 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
1533
1534 return st;
1535 }
1536
FloatItemToString(int32_t item,const camera_metadata_item_t entry)1537 std::string FloatItemToString(int32_t item, const camera_metadata_item_t entry)
1538 {
1539 std::string st = {};
1540 uint32_t count = entry.count;
1541 if (entry.data.f == nullptr) {
1542 METADATA_ERR_LOG("FloatItemToString: entry.data.f is null");
1543 return st;
1544 }
1545 std::string dataStr = std::to_string(*(entry.data.f));
1546 for (uint32_t i = 1; i < count; i++) {
1547 if ((i % WRAP_LENGTH) == 0) {
1548 dataStr += "]\n\t[" + std::to_string(*(entry.data.f + i));
1549 } else {
1550 dataStr += " " + std::to_string(*(entry.data.f + i));
1551 }
1552 }
1553
1554 const char *name = GetCameraMetadataItemName(item);
1555 if (name == nullptr) {
1556 METADATA_ERR_LOG("FloatItemToString: get float item name fail");
1557 return st;
1558 }
1559 std::string nameStr(name);
1560
1561 st = nameStr + " (" + std::to_string(entry.index) + "): " +
1562 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
1563
1564 return st;
1565 }
1566
DoubleItemToString(int32_t item,const camera_metadata_item_t entry)1567 std::string DoubleItemToString(int32_t item, const camera_metadata_item_t entry)
1568 {
1569 std::string st = {};
1570 uint32_t count = entry.count;
1571 if (entry.data.d == nullptr) {
1572 METADATA_ERR_LOG("DoubleItemToString: entry.data.d is null");
1573 return st;
1574 }
1575 std::string dataStr = std::to_string(*(entry.data.d));
1576 for (uint32_t i = 1; i < count; i++) {
1577 if ((i % WRAP_LENGTH) == 0) {
1578 dataStr += "]\n\t[" + std::to_string(*(entry.data.d + i));
1579 } else {
1580 dataStr += " " + std::to_string(*(entry.data.d + i));
1581 }
1582 }
1583
1584 const char *name = GetCameraMetadataItemName(item);
1585 if (name == nullptr) {
1586 METADATA_ERR_LOG("DoubleItemToString: get double item name fail");
1587 return st;
1588 }
1589 std::string nameStr(name);
1590
1591 st = nameStr + " (" + std::to_string(entry.index) + "): " +
1592 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
1593
1594 return st;
1595 }
1596
RationalItemToString(int32_t item,const camera_metadata_item_t entry)1597 std::string RationalItemToString(int32_t item, const camera_metadata_item_t entry)
1598 {
1599 std::string st = {};
1600 uint32_t count = entry.count;
1601 if (entry.data.r == nullptr) {
1602 METADATA_ERR_LOG("RationalItemToString: entry.data.r is null");
1603 return st;
1604 }
1605 std::string dataStr = std::to_string((*(entry.data.r)).numerator) + "/" +
1606 std::to_string((*(entry.data.r)).denominator);
1607 for (uint32_t i = 1; i < count; i++) {
1608 if ((i % WRAP_LENGTH) == 0) {
1609 dataStr += "]\n\t[" + std::to_string((*(entry.data.r + i)).numerator) + "/" +
1610 std::to_string((*(entry.data.r + i)).denominator);
1611 } else {
1612 dataStr += " " + std::to_string((*(entry.data.r + i)).numerator) + "/" +
1613 std::to_string((*(entry.data.r + i)).denominator);
1614 }
1615 }
1616
1617 const char *name = GetCameraMetadataItemName(item);
1618 if (name == nullptr) {
1619 METADATA_ERR_LOG("RationalItemToString: get rational item name fail");
1620 return st;
1621 }
1622 std::string nameStr(name);
1623
1624 st = nameStr + " (" + std::to_string(entry.index) + "): " +
1625 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
1626
1627 return st;
1628 }
1629
MetadataItemDump(const common_metadata_header_t * metadataHeader,uint32_t item)1630 std::string CameraMetadata::MetadataItemDump(const common_metadata_header_t *metadataHeader, uint32_t item)
1631 {
1632 camera_metadata_item_t entry;
1633 std::string st = {};
1634
1635 int ret = FindCameraMetadataItem(metadataHeader, item, &entry);
1636 if (ret != 0) {
1637 METADATA_ERR_LOG("get item error and item = %{public}d", item);
1638 return st;
1639 }
1640
1641 switch (entry.data_type) {
1642 case META_TYPE_BYTE:
1643 st = U8ItemToString(item, entry);
1644 break;
1645 case META_TYPE_INT32:
1646 st = I32ItemToString(item, entry);
1647 break;
1648 case META_TYPE_UINT32:
1649 st = U32ItemToString(item, entry);
1650 break;
1651 case META_TYPE_FLOAT:
1652 st = FloatItemToString(item, entry);
1653 break;
1654 case META_TYPE_INT64:
1655 st = I64ItemToString(item, entry);
1656 break;
1657 case META_TYPE_DOUBLE:
1658 st = DoubleItemToString(item, entry);
1659 break;
1660 case META_TYPE_RATIONAL:
1661 st = RationalItemToString(item, entry);
1662 break;
1663 default:
1664 METADATA_ERR_LOG("invalid param and item = %{public}d", item);
1665 break;
1666 }
1667
1668 if (!st.empty()) {
1669 st += "\n";
1670 }
1671 return st;
1672 }
1673
FormatCameraMetadataToString(const common_metadata_header_t * metadataHeader)1674 std::string CameraMetadata::FormatCameraMetadataToString(const common_metadata_header_t *metadataHeader)
1675 {
1676 std::string metaStr;
1677 if (metadataHeader == nullptr) {
1678 METADATA_ERR_LOG("metadataHeader is nullptr");
1679 return metaStr;
1680 }
1681
1682 for (auto it = g_metadataTags.begin(); it != g_metadataTags.end(); it++) {
1683 metaStr += MetadataItemDump(metadataHeader, *it);
1684 }
1685 METADATA_DEBUG_LOG("metadataHeader item = %{public}s", metaStr.c_str());
1686 return metaStr;
1687 }
1688
GetAllVendorTags(std::vector<vendorTag_t> & tagVec)1689 int32_t CameraMetadata::GetAllVendorTags(std::vector<vendorTag_t>& tagVec)
1690 {
1691 int32_t ret = LoadVendorTagImpl();
1692 if (ret != CAM_META_SUCCESS) {
1693 METADATA_ERR_LOG("LoadVendorTagImpl failed");
1694 return CAM_META_FAILURE;
1695 }
1696 std::lock_guard<std::mutex> lock(g_vendorTagImplMtx);
1697 g_vendorTagImpl->GetAllVendorTags(tagVec);
1698 return CAM_META_SUCCESS;
1699 }
1700
CheckItemDataType(camera_metadata_item_entry_t & item)1701 bool CameraMetadata::CheckItemDataType(camera_metadata_item_entry_t &item)
1702 {
1703 auto iter = g_itemDataTypeMap.find(item.item);
1704 if (iter != g_itemDataTypeMap.end()) {
1705 if (iter->second != item.data_type) {
1706 METADATA_ERR_LOG("Invalid data type :%{public}u, item :%{public}u", item.data_type, item.item);
1707 return false;
1708 }
1709 }
1710 return true;
1711 }
1712 } // Camera
1713