1 /*
2 * Copyright (c) 2021-2022 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_operator.h"
17 #include <cstring>
18 #include <securec.h>
19 #include "camera_metadata_item_info.h"
20 #include "metadata_log.h"
21
22 namespace OHOS::Camera {
23 const int METADATA_HEADER_DATA_SIZE = 4;
24
AlignTo(uint32_t val,uint32_t alignment)25 uint32_t AlignTo(uint32_t val, uint32_t alignment)
26 {
27 return (((uintptr_t)(val) + ((alignment) - 1)) & ~((alignment) - 1));
28 }
29
MaxAlignment(uint32_t dataAlignment,uint32_t metadataAlignment)30 uint32_t MaxAlignment(uint32_t dataAlignment, uint32_t metadataAlignment)
31 {
32 return ((dataAlignment > metadataAlignment) ? dataAlignment : metadataAlignment);
33 }
34
GetMetadataData(const common_metadata_header_t * metadataHeader)35 uint8_t *GetMetadataData(const common_metadata_header_t *metadataHeader)
36 {
37 return (uint8_t *)metadataHeader + metadataHeader->data_start;
38 }
39
GetMetadataItems(const common_metadata_header_t * metadataHeader)40 camera_metadata_item_entry_t *GetMetadataItems(const common_metadata_header_t *metadataHeader)
41 {
42 return (camera_metadata_item_entry_t *)
43 ((uint8_t *)metadataHeader + metadataHeader->items_start);
44 }
45
FillCameraMetadata(common_metadata_header_t * buffer,size_t memoryRequired,uint32_t itemCapacity,uint32_t dataCapacity)46 common_metadata_header_t *FillCameraMetadata(common_metadata_header_t *buffer, size_t memoryRequired,
47 uint32_t itemCapacity, uint32_t dataCapacity)
48 {
49 METADATA_DEBUG_LOG("FillCameraMetadata start");
50 if (buffer == nullptr) {
51 METADATA_ERR_LOG("FillCameraMetadata buffer is null");
52 return nullptr;
53 }
54
55 common_metadata_header_t *metadataHeader = (common_metadata_header_t *)buffer;
56 metadataHeader->version = CURRENT_CAMERA_METADATA_VERSION;
57 metadataHeader->size = memoryRequired;
58 metadataHeader->item_count = 0;
59 metadataHeader->item_capacity = itemCapacity;
60 metadataHeader->items_start = AlignTo(sizeof(common_metadata_header_t), ITEM_ALIGNMENT);
61 metadataHeader->data_count = 0;
62 metadataHeader->data_capacity = dataCapacity;
63 size_t dataUnaligned = (uint8_t *)(GetMetadataItems(metadataHeader) +
64 metadataHeader->item_capacity) - (uint8_t *)metadataHeader;
65 metadataHeader->data_start = AlignTo(dataUnaligned, DATA_ALIGNMENT);
66
67 METADATA_DEBUG_LOG("FillCameraMetadata end");
68 return metadataHeader;
69 }
70
CalculateCameraMetadataMemoryRequired(uint32_t itemCount,uint32_t dataCount)71 size_t CalculateCameraMetadataMemoryRequired(uint32_t itemCount, uint32_t dataCount)
72 {
73 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired start");
74 size_t memoryRequired = sizeof(common_metadata_header_t);
75 memoryRequired = AlignTo(memoryRequired, ITEM_ALIGNMENT);
76
77 memoryRequired += sizeof(camera_metadata_item_entry_t[itemCount]);
78 memoryRequired = AlignTo(memoryRequired, DATA_ALIGNMENT);
79
80 memoryRequired += sizeof(uint8_t[dataCount]);
81 memoryRequired = AlignTo(memoryRequired, METADATA_PACKET_ALIGNMENT);
82
83 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired memoryRequired: %{public}zu", memoryRequired);
84 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired end");
85 return memoryRequired;
86 }
87
AllocateCameraMetadataBuffer(uint32_t item_capacity,uint32_t data_capacity)88 common_metadata_header_t *AllocateCameraMetadataBuffer(uint32_t item_capacity, uint32_t data_capacity)
89 {
90 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer start");
91 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer item_capacity: %{public}u, data_capacity: %{public}u",
92 item_capacity, data_capacity);
93 size_t memoryRequired = CalculateCameraMetadataMemoryRequired(item_capacity, data_capacity);
94 void *buffer = calloc(1, memoryRequired);
95 if (buffer == nullptr) {
96 METADATA_ERR_LOG("AllocateCameraMetadataBuffer memory allocation failed");
97 return (common_metadata_header_t *) buffer;
98 }
99
100 common_metadata_header_t *metadataHeader = FillCameraMetadata((common_metadata_header_t *)buffer, memoryRequired,
101 item_capacity, data_capacity);
102 if (metadataHeader == nullptr) {
103 METADATA_ERR_LOG("AllocateCameraMetadataBuffer metadataHeader is null");
104 free(buffer);
105 }
106
107 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer end");
108 return metadataHeader;
109 }
110
GetMetadataSection(uint32_t itemSection,uint32_t * section)111 int32_t GetMetadataSection(uint32_t itemSection, uint32_t *section)
112 {
113 METADATA_DEBUG_LOG("GetMetadataSection start");
114 if (itemSection < OHOS_CAMERA_PROPERTIES ||
115 itemSection >= OHOS_ABILITY_SECTION_END) {
116 METADATA_ERR_LOG("GetMetadataSection itemSection is not valid");
117 return CAM_META_FAILURE;
118 }
119
120 int32_t ret = CAM_META_SUCCESS;
121 switch (itemSection) {
122 case OHOS_CAMERA_PROPERTIES:
123 *section = OHOS_SECTION_CAMERA_PROPERTIES;
124 break;
125 case OHOS_CAMERA_SENSOR:
126 *section = OHOS_SECTION_CAMERA_SENSOR;
127 break;
128 case OHOS_CAMERA_SENSOR_INFO:
129 *section = OHOS_SECTION_CAMERA_SENSOR_INFO;
130 break;
131 case OHOS_CAMERA_STATISTICS:
132 *section = OHOS_SECTION_CAMERA_STATISTICS;
133 break;
134 case OHOS_DEVICE_CONTROL:
135 *section = OHOS_SECTION_CAMERA_CONTROL;
136 break;
137 case OHOS_DEVICE_EXPOSURE:
138 *section = OHOS_SECTION_DEVICE_EXPOSURE;
139 break;
140 case OHOS_DEVICE_FOCUS:
141 *section = OHOS_SECTION_DEVICE_FOCUS;
142 break;
143 case OHOS_DEVICE_FLASH:
144 *section = OHOS_SECTION_DEVICE_FLASH;
145 break;
146 case OHOS_DEVICE_ZOOM:
147 *section = OHOS_SECTION_DEVICE_ZOOM;
148 break;
149 case OHOS_STREAM_ABILITY:
150 *section = OHOS_SECTION_STREAM_ABILITY;
151 break;
152 case OHOS_STREAM_JPEG:
153 *section = OHOS_SECTION_STREAM_JPEG;
154 break;
155 default:
156 METADATA_ERR_LOG("GetMetadataSection item section is not defined");
157 ret = CAM_META_FAILURE;
158 break;
159 }
160
161 METADATA_DEBUG_LOG("GetMetadataSection end");
162 return ret;
163 }
164
GetCameraMetadataItemType(uint32_t item,uint32_t * dataType)165 int32_t GetCameraMetadataItemType(uint32_t item, uint32_t *dataType)
166 {
167 METADATA_DEBUG_LOG("GetCameraMetadataItemType start");
168 if (dataType == nullptr) {
169 METADATA_ERR_LOG("GetCameraMetadataItemType dataType is null");
170 return CAM_META_INVALID_PARAM;
171 }
172 uint32_t section;
173 int32_t ret = GetMetadataSection(item >> BITWISE_SHIFT_16, §ion);
174 if (ret != CAM_META_SUCCESS) {
175 METADATA_ERR_LOG("GetCameraMetadataItemType section is not valid");
176 return ret;
177 }
178
179 if (item >= g_ohosCameraSectionBounds[section][1]) {
180 METADATA_ERR_LOG("GetCameraMetadataItemType item is not in section bound");
181 return CAM_META_FAILURE;
182 }
183
184 uint32_t itemIndex = item & 0xFFFF;
185 if (g_ohosItemInfo[section][itemIndex].item_type < META_TYPE_BYTE) {
186 METADATA_ERR_LOG("GetCameraMetadataItemType item is not initialized");
187 return CAM_META_FAILURE;
188 }
189
190 *dataType = g_ohosItemInfo[section][itemIndex].item_type;
191
192 METADATA_DEBUG_LOG("GetCameraMetadataItemType end");
193 return CAM_META_SUCCESS;
194 }
195
GetCameraMetadataItemName(uint32_t item)196 const char *GetCameraMetadataItemName(uint32_t item)
197 {
198 METADATA_DEBUG_LOG("GetCameraMetadataItemName start");
199 METADATA_DEBUG_LOG("GetCameraMetadataItemName item: %{public}u", item);
200 uint32_t section;
201 int32_t ret = GetMetadataSection(item >> BITWISE_SHIFT_16, §ion);
202 if (ret != CAM_META_SUCCESS) {
203 METADATA_ERR_LOG("GetCameraMetadataItemName section is not valid");
204 return nullptr;
205 }
206
207 if (item >= g_ohosCameraSectionBounds[section][1]) {
208 METADATA_ERR_LOG("GetCameraMetadataItemName item is not in section bound");
209 return nullptr;
210 }
211
212 uint32_t itemIndex = item & 0xFFFF;
213 METADATA_DEBUG_LOG("GetCameraMetadataItemName end");
214 return g_ohosItemInfo[section][itemIndex].item_name;
215 }
216
CalculateCameraMetadataItemDataSize(uint32_t type,size_t dataCount)217 size_t CalculateCameraMetadataItemDataSize(uint32_t type, size_t dataCount)
218 {
219 METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize start");
220 if (type < META_TYPE_BYTE || type >= META_NUM_TYPES) {
221 METADATA_ERR_LOG("CalculateCameraMetadataItemDataSize invalid type");
222 return 0;
223 }
224
225 size_t dataBytes = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[type];
226
227 METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize end");
228 return (dataBytes <= METADATA_HEADER_DATA_SIZE) ? 0 : AlignTo(dataBytes, DATA_ALIGNMENT);
229 }
230
AddCameraMetadataItem(common_metadata_header_t * dst,uint32_t item,const void * data,size_t dataCount)231 int AddCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data, size_t dataCount)
232 {
233 METADATA_DEBUG_LOG("AddCameraMetadataItem start");
234 const char *name = GetCameraMetadataItemName(item);
235 METADATA_INFO_LOG("AddCameraMetadataItem item id: %{public}u, name: %{public}s, "
236 "dataCount: %{public}zu", item, name ? name : "<unknown>", dataCount);
237
238 if (dst == nullptr) {
239 METADATA_ERR_LOG("AddCameraMetadataItem common_metadata_header_t is null");
240 return CAM_META_INVALID_PARAM;
241 }
242
243 if (!dataCount || data == nullptr) {
244 METADATA_ERR_LOG("AddCameraMetadataItem data is not valid. item: %{public}u, "
245 "dataCount: %{public}zu", item, dataCount);
246 return CAM_META_INVALID_PARAM;
247 }
248
249 if (dst->item_count == dst->item_capacity) {
250 METADATA_ERR_LOG("AddCameraMetadataItem item_capacity limit reached. "
251 "item_count: %{public}d, item_capacity: %{public}d",
252 dst->item_count, dst->item_capacity);
253 return CAM_META_ITEM_CAP_EXCEED;
254 }
255
256 uint32_t dataType;
257 int32_t ret = GetCameraMetadataItemType(item, &dataType);
258 if (ret != CAM_META_SUCCESS) {
259 METADATA_ERR_LOG("AddCameraMetadataItem invalid item type");
260 return CAM_META_INVALID_PARAM;
261 }
262
263 size_t dataBytes =
264 CalculateCameraMetadataItemDataSize(dataType, dataCount);
265 if (dataBytes + dst->data_count > dst->data_capacity) {
266 METADATA_ERR_LOG("AddCameraMetadataItem data_capacity limit reached");
267 return CAM_META_DATA_CAP_EXCEED;
268 }
269
270 size_t dataPayloadBytes =
271 dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[dataType];
272 camera_metadata_item_entry_t *metadataItem = GetMetadataItems(dst) + dst->item_count;
273 (void)memset_s(metadataItem, sizeof(camera_metadata_item_entry_t), 0, sizeof(camera_metadata_item_entry_t));
274 metadataItem->item = item;
275 metadataItem->data_type = dataType;
276 metadataItem->count = dataCount;
277
278 if (dataBytes == 0) {
279 ret = memcpy_s(metadataItem->data.value, dataPayloadBytes, data, dataPayloadBytes);
280 if (ret != CAM_META_SUCCESS) {
281 METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed");
282 return CAM_META_FAILURE;
283 }
284 } else {
285 metadataItem->data.offset = dst->data_count;
286 ret = memcpy_s(GetMetadataData(dst) + metadataItem->data.offset, dataPayloadBytes, data,
287 dataPayloadBytes);
288 if (ret != CAM_META_SUCCESS) {
289 METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed");
290 return CAM_META_FAILURE;
291 }
292 dst->data_count += dataBytes;
293 }
294 dst->item_count++;
295
296 METADATA_DEBUG_LOG("AddCameraMetadataItem end");
297 return CAM_META_SUCCESS;
298 }
299
GetCameraMetadataItem(const common_metadata_header_t * src,uint32_t index,camera_metadata_item_t * item)300 int GetCameraMetadataItem(const common_metadata_header_t *src, uint32_t index, camera_metadata_item_t *item)
301 {
302 METADATA_DEBUG_LOG("GetCameraMetadataItem start");
303 if (src == nullptr || item == nullptr) {
304 METADATA_ERR_LOG("GetCameraMetadataItem src or item is null");
305 return CAM_META_INVALID_PARAM;
306 }
307
308 (void)memset_s(item, sizeof(camera_metadata_item_t), 0, sizeof(camera_metadata_item_t));
309
310 if (index >= src->item_count) {
311 METADATA_ERR_LOG("GetCameraMetadataItem index is greater than item count");
312 return CAM_META_INVALID_PARAM;
313 }
314
315 camera_metadata_item_entry_t *localItem = GetMetadataItems(src) + index;
316
317 item->index = index;
318 item->item = localItem->item;
319 item->data_type = localItem->data_type;
320 item->count = localItem->count;
321
322 size_t dataBytes = CalculateCameraMetadataItemDataSize(localItem->data_type, localItem->count);
323 if (dataBytes == 0) {
324 item->data.u8 = localItem->data.value;
325 } else {
326 item->data.u8 = GetMetadataData(src) + localItem->data.offset;
327 }
328
329 METADATA_DEBUG_LOG("GetCameraMetadataItem end");
330 return CAM_META_SUCCESS;
331 }
332
FindCameraMetadataItemIndex(const common_metadata_header_t * src,uint32_t item,uint32_t * idx)333 int FindCameraMetadataItemIndex(const common_metadata_header_t *src, uint32_t item, uint32_t *idx)
334 {
335 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex start");
336 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex item: %{public}u", item);
337 if (src == nullptr) {
338 METADATA_ERR_LOG("FindCameraMetadataItemIndex src is null");
339 return CAM_META_INVALID_PARAM;
340 }
341
342 camera_metadata_item_entry_t *searchItem = GetMetadataItems(src);
343 uint32_t index;
344 for (index = 0; index < src->item_count; index++, searchItem++) {
345 if (searchItem->item == item) {
346 break;
347 }
348 }
349
350 if (index == src->item_count) {
351 METADATA_ERR_LOG("FindCameraMetadataItemIndex item: %{public}u not found", item);
352 return CAM_META_ITEM_NOT_FOUND;
353 }
354
355 *idx = index;
356 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex index: %{public}d", index);
357 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex end");
358 return CAM_META_SUCCESS;
359 }
360
FindCameraMetadataItem(const common_metadata_header_t * src,uint32_t item,camera_metadata_item_t * metadataItem)361 int FindCameraMetadataItem(const common_metadata_header_t *src, uint32_t item, camera_metadata_item_t *metadataItem)
362 {
363 uint32_t index = 0;
364 const char *name = GetCameraMetadataItemName(item);
365 METADATA_INFO_LOG("FindCameraMetadataItem item id: %{public}u, name: %{public}s",
366 item, name ? name : "<unknown>");
367 int ret = FindCameraMetadataItemIndex(src, item, &index);
368 if (ret != CAM_META_SUCCESS) {
369 return ret;
370 }
371
372 return GetCameraMetadataItem(src, index, metadataItem);
373 }
374
SetOffset(camera_metadata_item_entry_t * metadataItems,camera_metadata_item_entry_t * item,size_t oldItemSize)375 void SetOffset(camera_metadata_item_entry_t *metadataItems, camera_metadata_item_entry_t *item, size_t oldItemSize)
376 {
377 if (CalculateCameraMetadataItemDataSize(metadataItems->data_type, metadataItems->count) > 0 &&
378 metadataItems->data.offset > item->data.offset) {
379 metadataItems->data.offset -= oldItemSize;
380 }
381 }
382
MetadataExpandItemMem(common_metadata_header_t * dst,camera_metadata_item_entry_t * item,size_t oldItemSize)383 int MetadataExpandItemMem(common_metadata_header_t *dst, camera_metadata_item_entry_t *item,
384 size_t oldItemSize)
385 {
386 if (item == nullptr || dst == nullptr) {
387 METADATA_ERR_LOG("MetadataExpandItemMem item is null or dst is null");
388 return CAM_META_INVALID_PARAM;
389 }
390 int32_t ret = CAM_META_SUCCESS;
391 uint8_t *start = GetMetadataData(dst) + item->data.offset;
392 uint8_t *end = start + oldItemSize;
393 size_t length = dst->data_count - item->data.offset - oldItemSize;
394 if (length != 0) {
395 ret = memmove_s(start, length, end, length);
396 if (ret != CAM_META_SUCCESS) {
397 METADATA_ERR_LOG("MetadataExpandItemMem memory move failed");
398 return CAM_META_FAILURE;
399 }
400 }
401 dst->data_count -= oldItemSize;
402
403 camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst);
404 for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) {
405 SetOffset(metadataItems, item, oldItemSize);
406 }
407
408 return CAM_META_SUCCESS;
409 }
410
UpdateCameraMetadataItemByIndex(common_metadata_header_t * dst,uint32_t index,const void * data,uint32_t dataCount,camera_metadata_item_t * updatedItem)411 int UpdateCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index, const void *data, uint32_t dataCount,
412 camera_metadata_item_t *updatedItem)
413 {
414 METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex start");
415 if ((dst == nullptr) || (index >= dst->item_count)) {
416 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex dst is null or invalid index");
417 return CAM_META_INVALID_PARAM;
418 }
419
420 if (!dataCount || data == nullptr) {
421 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data is not valid. "
422 "dataCount: %{public}u", dataCount);
423 return CAM_META_INVALID_PARAM;
424 }
425
426 int32_t ret = CAM_META_SUCCESS;
427 camera_metadata_item_entry_t *item = GetMetadataItems(dst) + index;
428 size_t dataSize = CalculateCameraMetadataItemDataSize(item->data_type, dataCount);
429 size_t dataPayloadSize = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[item->data_type];
430
431 size_t oldItemSize = CalculateCameraMetadataItemDataSize(item->data_type, item->count);
432 if (dataSize != oldItemSize) {
433 if (dst->data_capacity < (dst->data_count + dataSize - oldItemSize)) {
434 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data_capacity limit reached");
435 return CAM_META_DATA_CAP_EXCEED;
436 }
437
438 if (oldItemSize != 0) {
439 MetadataExpandItemMem(dst, item, oldItemSize);
440 }
441
442 if (dataSize != 0) {
443 item->data.offset = dst->data_count;
444 ret = memcpy_s(GetMetadataData(dst) + item->data.offset, dataPayloadSize, data, dataPayloadSize);
445 if (ret != CAM_META_SUCCESS) {
446 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed");
447 return CAM_META_FAILURE;
448 }
449 dst->data_count += dataSize;
450 }
451 } else if (dataSize != 0) {
452 ret = memcpy_s(GetMetadataData(dst) + item->data.offset, dataPayloadSize, data, dataPayloadSize);
453 if (ret != CAM_META_SUCCESS) {
454 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed");
455 return CAM_META_FAILURE;
456 }
457 }
458
459 if (dataSize == 0) {
460 ret = memcpy_s(item->data.value, dataPayloadSize, data, dataPayloadSize);
461 if (ret != CAM_META_SUCCESS) {
462 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed");
463 return CAM_META_FAILURE;
464 }
465 }
466
467 item->count = dataCount;
468 if (updatedItem != nullptr) {
469 GetCameraMetadataItem(dst, index, updatedItem);
470 }
471
472 METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex end");
473 return CAM_META_SUCCESS;
474 }
475
UpdateCameraMetadataItem(common_metadata_header_t * dst,uint32_t item,const void * data,uint32_t dataCount,camera_metadata_item_t * updatedItem)476 int UpdateCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data,
477 uint32_t dataCount, camera_metadata_item_t *updatedItem)
478 {
479 METADATA_DEBUG_LOG("UpdateCameraMetadataItem item id: %{public}u, dataCount: %{public}u", item, dataCount);
480 const char *name = GetCameraMetadataItemName(item);
481 METADATA_INFO_LOG("UpdateCameraMetadataItem item id: %{public}u, name: %{public}s, "
482 "dataCount: %{public}u", item, name ? name : "<unknown>", dataCount);
483 if (!dataCount || data == nullptr) {
484 METADATA_ERR_LOG("UpdateCameraMetadataItem data is not valid. item: %{public}u, "
485 "dataCount: %{public}u", item, dataCount);
486 return CAM_META_INVALID_PARAM;
487 }
488
489 uint32_t index = 0;
490 int32_t ret = FindCameraMetadataItemIndex(dst, item, &index);
491 if (ret != CAM_META_SUCCESS) {
492 return ret;
493 }
494
495 return UpdateCameraMetadataItemByIndex(dst, index, data, dataCount, updatedItem);
496 }
497
DeleteCameraMetadataItemByIndex(common_metadata_header_t * dst,uint32_t index)498 int DeleteCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index)
499 {
500 METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex start");
501 if (dst == nullptr) {
502 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex dst is null");
503 return CAM_META_INVALID_PARAM;
504 }
505
506 if (index >= dst->item_count) {
507 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex item not valid");
508 return CAM_META_INVALID_PARAM;
509 }
510
511 int32_t ret = CAM_META_SUCCESS;
512 camera_metadata_item_entry_t *itemToDelete = GetMetadataItems(dst) + index;
513 size_t dataBytes = CalculateCameraMetadataItemDataSize(itemToDelete->data_type, itemToDelete->count);
514 if (dataBytes > 0) {
515 uint8_t *start = GetMetadataData(dst) + itemToDelete->data.offset;
516 uint8_t *end = start + dataBytes;
517 size_t length = dst->data_count - itemToDelete->data.offset - dataBytes;
518 if (length != 0) {
519 ret = memmove_s(start, length, end, length);
520 if (ret != CAM_META_SUCCESS) {
521 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed");
522 return CAM_META_FAILURE;
523 }
524 }
525 dst->data_count -= dataBytes;
526
527 camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst);
528 for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) {
529 if (CalculateCameraMetadataItemDataSize(
530 metadataItems->data_type, metadataItems->count) > 0 &&
531 metadataItems->data.offset > itemToDelete->data.offset) {
532 metadataItems->data.offset -= dataBytes;
533 }
534 }
535 }
536
537 uint64_t length = sizeof(camera_metadata_item_entry_t) * (dst->item_count - index - 1);
538 if (length != 0) {
539 ret = memmove_s(itemToDelete, length, itemToDelete + 1, length);
540 if (ret != CAM_META_SUCCESS) {
541 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed");
542 return CAM_META_FAILURE;
543 }
544 }
545 dst->item_count -= 1;
546 METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex end");
547 return CAM_META_SUCCESS;
548 }
549
DeleteCameraMetadataItem(common_metadata_header_t * dst,uint32_t item)550 int DeleteCameraMetadataItem(common_metadata_header_t *dst, uint32_t item)
551 {
552 METADATA_DEBUG_LOG("DeleteCameraMetadataItem item: %{public}u", item);
553 uint32_t index = 0;
554 int32_t ret = FindCameraMetadataItemIndex(dst, item, &index);
555 if (ret != CAM_META_SUCCESS) {
556 return ret;
557 }
558
559 return DeleteCameraMetadataItemByIndex(dst, index);
560 }
561
FreeCameraMetadataBuffer(common_metadata_header_t * dst)562 void FreeCameraMetadataBuffer(common_metadata_header_t *dst)
563 {
564 if (dst != nullptr) {
565 free(dst);
566 }
567 }
568
GetCameraMetadataItemCount(const common_metadata_header_t * metadataHeader)569 uint32_t GetCameraMetadataItemCount(const common_metadata_header_t *metadataHeader)
570 {
571 return metadataHeader->item_count;
572 }
573
GetCameraMetadataItemCapacity(const common_metadata_header_t * metadataHeader)574 uint32_t GetCameraMetadataItemCapacity(const common_metadata_header_t *metadataHeader)
575 {
576 return metadataHeader->item_capacity;
577 }
578
GetCameraMetadataDataSize(const common_metadata_header_t * metadataHeader)579 uint32_t GetCameraMetadataDataSize(const common_metadata_header_t *metadataHeader)
580 {
581 return metadataHeader->data_capacity;
582 }
583
CopyCameraMetadataItems(common_metadata_header_t * newMetadata,const common_metadata_header_t * oldMetadata)584 int32_t CopyCameraMetadataItems(common_metadata_header_t *newMetadata, const common_metadata_header_t *oldMetadata)
585 {
586 if (newMetadata == nullptr || oldMetadata == nullptr) {
587 return CAM_META_INVALID_PARAM;
588 }
589
590 int32_t ret;
591 if (oldMetadata->item_count != 0) {
592 ret = memcpy_s(GetMetadataItems(newMetadata), sizeof(camera_metadata_item_entry_t[oldMetadata->item_count]),
593 GetMetadataItems(oldMetadata), sizeof(camera_metadata_item_entry_t[oldMetadata->item_count]));
594 if (ret != CAM_META_SUCCESS) {
595 METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed");
596 return CAM_META_FAILURE;
597 }
598 }
599
600 if (oldMetadata->data_count != 0) {
601 ret = memcpy_s(GetMetadataData(newMetadata), sizeof(uint8_t[oldMetadata->data_count]),
602 GetMetadataData(oldMetadata), sizeof(uint8_t[oldMetadata->data_count]));
603 if (ret != CAM_META_SUCCESS) {
604 METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed");
605 return CAM_META_FAILURE;
606 }
607 }
608
609 newMetadata->item_count = oldMetadata->item_count;
610 newMetadata->data_count = oldMetadata->data_count;
611
612 return CAM_META_SUCCESS;
613 }
614 } // Camera
615
616