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