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