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