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