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