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_operator.h"
17 #include <securec.h>
18 #include <vector>
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 const std::vector<int32_t> METADATATAGS = {
25 OHOS_ABILITY_CAMERA_POSITION,
26 OHOS_ABILITY_CAMERA_TYPE,
27 OHOS_ABILITY_CAMERA_CONNECTION_TYPE,
28 OHOS_ABILITY_MEMORY_TYPE,
29 OHOS_ABILITY_FPS_RANGES,
30 OHOS_ABILITY_FLASH_AVAILABLE,
31 OHOS_CAMERA_STREAM_ID,
32
33 OHOS_SENSOR_EXPOSURE_TIME,
34 OHOS_SENSOR_COLOR_CORRECTION_GAINS,
35 OHOS_SENSOR_ORIENTATION,
36 OHOS_ABILITY_MUTE_MODES,
37 OHOS_CONTROL_MUTE_MODE,
38
39 OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
40 OHOS_SENSOR_INFO_SENSITIVITY_RANGE,
41 OHOS_SENSOR_INFO_MAX_FRAME_DURATION,
42 OHOS_SENSOR_INFO_PHYSICAL_SIZE,
43 OHOS_SENSOR_INFO_PIXEL_ARRAY_SIZE,
44 OHOS_SENSOR_INFO_TIMESTAMP,
45
46 OHOS_STATISTICS_FACE_DETECT_MODE,
47 OHOS_STATISTICS_FACE_DETECT_SWITCH,
48 OHOS_STATISTICS_FACE_DETECT_MAX_NUM,
49 OHOS_STATISTICS_HISTOGRAM_MODE,
50 OHOS_STATISTICS_FACE_IDS,
51 OHOS_STATISTICS_FACE_LANDMARKS,
52 OHOS_STATISTICS_FACE_RECTANGLES,
53 OHOS_STATISTICS_FACE_SCORES,
54
55 OHOS_CONTROL_AE_ANTIBANDING_MODE,
56 OHOS_CONTROL_AE_EXPOSURE_COMPENSATION,
57 OHOS_CONTROL_AE_LOCK,
58 OHOS_CONTROL_AE_MODE,
59 OHOS_CONTROL_AE_REGIONS,
60 OHOS_CONTROL_AE_TARGET_FPS_RANGE,
61 OHOS_CONTROL_FPS_RANGES,
62 OHOS_CONTROL_AF_MODE,
63 OHOS_CONTROL_AF_REGIONS,
64 OHOS_CONTROL_AF_TRIGGER,
65 OHOS_CONTROL_AF_TRIGGER_ID,
66 OHOS_CONTROL_AF_STATE,
67 OHOS_CONTROL_AWB_LOCK,
68 OHOS_CONTROL_AWB_MODE,
69 OHOS_CONTROL_AWB_REGIONS,
70 OHOS_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
71 OHOS_CONTROL_AE_AVAILABLE_MODES,
72 OHOS_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
73 OHOS_CONTROL_AE_COMPENSATION_RANGE,
74 OHOS_CONTROL_AE_COMPENSATION_STEP,
75 OHOS_CONTROL_AF_AVAILABLE_MODES,
76 OHOS_CONTROL_AWB_AVAILABLE_MODES,
77 OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED,
78 OHOS_CONTROL_CAPTURE_MIRROR,
79 OHOS_CONTROL_FOCUS_STATE,
80 OHOS_CONTROL_METER_POINT,
81 OHOS_CONTROL_METER_MODE,
82 OHOS_CONTROL_EXPOSURE_STATE,
83
84 // Camera device image acquisition related
85 OHOS_ABILITY_DEVICE_AVAILABLE_EXPOSUREMODES,
86 OHOS_CONTROL_EXPOSUREMODE,
87 OHOS_ABILITY_EXPOSURE_MODES,
88 OHOS_CONTROL_EXPOSURE_MODE,
89 OHOS_ABILITY_METER_MODES,
90
91 OHOS_ABILITY_DEVICE_AVAILABLE_FOCUSMODES,
92 OHOS_CONTROL_FOCUSMODE,
93 OHOS_ABILITY_FOCUS_MODES,
94 OHOS_CONTROL_FOCUS_MODE,
95 OHOS_ABILITY_FOCAL_LENGTH,
96
97 OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES,
98 OHOS_CONTROL_FLASHMODE,
99 OHOS_ABILITY_FLASH_MODES,
100 OHOS_CONTROL_FLASH_MODE,
101 OHOS_CONTROL_FLASH_STATE,
102
103 OHOS_ABILITY_ZOOM_RATIO_RANGE,
104 OHOS_CONTROL_ZOOM_RATIO,
105 OHOS_CONTROL_ZOOM_CROP_REGION,
106 OHOS_ABILITY_ZOOM_CAP,
107 OHOS_ABILITY_SCENE_ZOOM_CAP,
108
109 // Camera flow control related
110 OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS,
111 OHOS_STREAM_AVAILABLE_FORMATS,
112 OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS,
113
114 OHOS_JPEG_GPS_COORDINATES,
115 OHOS_JPEG_GPS_PROCESSING_METHOD,
116 OHOS_JPEG_GPS_TIMESTAMP,
117 OHOS_JPEG_ORIENTATION,
118 OHOS_JPEG_QUALITY,
119 OHOS_JPEG_THUMBNAIL_QUALITY,
120 OHOS_JPEG_THUMBNAIL_SIZE,
121 OHOS_JPEG_AVAILABLE_THUMBNAIL_SIZES,
122 OHOS_JPEG_MAX_SIZE,
123 OHOS_JPEG_SIZE,
124
125 OHOS_ABILITY_VIDEO_STABILIZATION_MODES,
126 OHOS_CONTROL_VIDEO_STABILIZATION_MODE,
127
128 // camera effects & algorithms
129 OHOS_ABILITY_SCENE_FILTER_TYPES,
130 OHOS_CONTROL_FILTER_TYPE,
131 OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES,
132 OHOS_CONTROL_PORTRAIT_EFFECT_TYPE,
133 OHOS_ABILITY_SCENE_BEAUTY_TYPES,
134 OHOS_CONTROL_BEAUTY_TYPE,
135 OHOS_ABILITY_BEAUTY_AUTO_VALUES,
136 OHOS_CONTROL_BEAUTY_AUTO_VALUE,
137 OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES,
138 OHOS_CONTROL_BEAUTY_FACE_SLENDER_VALUE,
139 OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES,
140 OHOS_CONTROL_BEAUTY_SKIN_TONE_VALUE,
141 OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES,
142 OHOS_CONTROL_BEAUTY_SKIN_SMOOTH_VALUE,
143
144 // camera secure related
145 OHOS_CONTROL_SECURE_FACE_MODE,
146 OHOS_CONTROL_SECURE_FACE_INFO,
147 OHOS_CONTROL_SECURE_FACE_AUTH_RESULT,
148 OHOS_CONTROL_SECURE_FLASH_SEQ,
149 OHOS_CONTROL_SECURE_IR_LED_SWITCH,
150 OHOS_CONTROL_SECURE_IR_LOCKAE_SWITCH,
151 };
152
AlignTo(uint32_t val,uint32_t alignment)153 uint32_t AlignTo(uint32_t val, uint32_t alignment)
154 {
155 return static_cast<uint32_t>((static_cast<uintptr_t>(val) + ((alignment) - 1)) & ~((alignment) - 1));
156 }
157
MaxAlignment(uint32_t dataAlignment,uint32_t metadataAlignment)158 uint32_t MaxAlignment(uint32_t dataAlignment, uint32_t metadataAlignment)
159 {
160 return ((dataAlignment > metadataAlignment) ? dataAlignment : metadataAlignment);
161 }
162
GetMetadataData(const common_metadata_header_t * metadataHeader)163 uint8_t *GetMetadataData(const common_metadata_header_t *metadataHeader)
164 {
165 if (!metadataHeader) {
166 METADATA_ERR_LOG("GetMetadataData metadataHeader is null");
167 return nullptr;
168 }
169 return (uint8_t *)metadataHeader + metadataHeader->data_start;
170 }
171
GetMetadataItems(const common_metadata_header_t * metadataHeader)172 camera_metadata_item_entry_t *GetMetadataItems(const common_metadata_header_t *metadataHeader)
173 {
174 return reinterpret_cast<camera_metadata_item_entry_t *>(
175 (reinterpret_cast<uint8_t *>(const_cast<common_metadata_header_t *>(metadataHeader)) +
176 metadataHeader->items_start));
177 }
178
FillCameraMetadata(common_metadata_header_t * buffer,size_t memoryRequired,uint32_t itemCapacity,uint32_t dataCapacity)179 common_metadata_header_t *FillCameraMetadata(common_metadata_header_t *buffer, size_t memoryRequired,
180 uint32_t itemCapacity, uint32_t dataCapacity)
181 {
182 METADATA_DEBUG_LOG("FillCameraMetadata start");
183 if (buffer == nullptr) {
184 METADATA_ERR_LOG("FillCameraMetadata buffer is null");
185 return nullptr;
186 }
187
188 common_metadata_header_t *metadataHeader = static_cast<common_metadata_header_t *>(buffer);
189 metadataHeader->version = CURRENT_CAMERA_METADATA_VERSION;
190 metadataHeader->size = memoryRequired;
191 metadataHeader->item_count = 0;
192 metadataHeader->item_capacity = itemCapacity;
193 metadataHeader->items_start = AlignTo(sizeof(common_metadata_header_t), ITEM_ALIGNMENT);
194 metadataHeader->data_count = 0;
195 metadataHeader->data_capacity = dataCapacity;
196 size_t dataUnaligned = reinterpret_cast<uint8_t *>(GetMetadataItems(metadataHeader) +
197 metadataHeader->item_capacity) - reinterpret_cast<uint8_t *>(metadataHeader);
198 metadataHeader->data_start = AlignTo(dataUnaligned, DATA_ALIGNMENT);
199
200 METADATA_DEBUG_LOG("FillCameraMetadata end");
201 return metadataHeader;
202 }
203
CalculateCameraMetadataMemoryRequired(uint32_t itemCount,uint32_t dataCount)204 size_t CalculateCameraMetadataMemoryRequired(uint32_t itemCount, uint32_t dataCount)
205 {
206 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired start");
207 size_t memoryRequired = sizeof(common_metadata_header_t);
208 memoryRequired = AlignTo(memoryRequired, ITEM_ALIGNMENT);
209
210 memoryRequired += sizeof(camera_metadata_item_entry_t[itemCount]);
211 memoryRequired = AlignTo(memoryRequired, DATA_ALIGNMENT);
212
213 memoryRequired += sizeof(uint8_t[dataCount]);
214 memoryRequired = AlignTo(memoryRequired, METADATA_PACKET_ALIGNMENT);
215
216 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired memoryRequired: %{public}zu", memoryRequired);
217 METADATA_DEBUG_LOG("CalculateCameraMetadataMemoryRequired end");
218 return memoryRequired;
219 }
220
AllocateCameraMetadataBuffer(uint32_t item_capacity,uint32_t data_capacity)221 common_metadata_header_t *AllocateCameraMetadataBuffer(uint32_t item_capacity, uint32_t data_capacity)
222 {
223 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer start");
224 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer item_capacity: %{public}u, data_capacity: %{public}u",
225 item_capacity, data_capacity);
226 size_t memoryRequired = CalculateCameraMetadataMemoryRequired(item_capacity, data_capacity);
227 void *buffer = calloc(1, memoryRequired);
228 if (buffer == nullptr) {
229 METADATA_ERR_LOG("AllocateCameraMetadataBuffer memory allocation failed");
230 return reinterpret_cast<common_metadata_header_t *>(buffer);
231 }
232
233 common_metadata_header_t *metadataHeader = FillCameraMetadata(reinterpret_cast<common_metadata_header_t *>(buffer),
234 memoryRequired,
235 item_capacity, data_capacity);
236 if (metadataHeader == nullptr) {
237 METADATA_ERR_LOG("AllocateCameraMetadataBuffer metadataHeader is null");
238 free(buffer);
239 }
240
241 METADATA_DEBUG_LOG("AllocateCameraMetadataBuffer end");
242 return metadataHeader;
243 }
244
GetMetadataSection(uint32_t itemSection,uint32_t * section)245 int32_t GetMetadataSection(uint32_t itemSection, uint32_t *section)
246 {
247 METADATA_DEBUG_LOG("GetMetadataSection start");
248 if (itemSection < OHOS_CAMERA_PROPERTIES ||
249 itemSection >= OHOS_ABILITY_SECTION_END) {
250 METADATA_ERR_LOG("GetMetadataSection itemSection is not valid");
251 return CAM_META_FAILURE;
252 }
253
254 int32_t ret = CAM_META_SUCCESS;
255 switch (itemSection) {
256 case OHOS_CAMERA_PROPERTIES:
257 *section = OHOS_SECTION_CAMERA_PROPERTIES;
258 break;
259 case OHOS_CAMERA_SENSOR:
260 *section = OHOS_SECTION_CAMERA_SENSOR;
261 break;
262 case OHOS_CAMERA_SENSOR_INFO:
263 *section = OHOS_SECTION_CAMERA_SENSOR_INFO;
264 break;
265 case OHOS_CAMERA_STATISTICS:
266 *section = OHOS_SECTION_CAMERA_STATISTICS;
267 break;
268 case OHOS_DEVICE_CONTROL:
269 *section = OHOS_SECTION_CAMERA_CONTROL;
270 break;
271 case OHOS_DEVICE_EXPOSURE:
272 *section = OHOS_SECTION_DEVICE_EXPOSURE;
273 break;
274 case OHOS_DEVICE_FOCUS:
275 *section = OHOS_SECTION_DEVICE_FOCUS;
276 break;
277 case OHOS_DEVICE_FLASH:
278 *section = OHOS_SECTION_DEVICE_FLASH;
279 break;
280 case OHOS_DEVICE_ZOOM:
281 *section = OHOS_SECTION_DEVICE_ZOOM;
282 break;
283 case OHOS_STREAM_ABILITY:
284 *section = OHOS_SECTION_STREAM_ABILITY;
285 break;
286 case OHOS_STREAM_JPEG:
287 *section = OHOS_SECTION_STREAM_JPEG;
288 break;
289 case OHOS_STREAM_VIDEO:
290 *section = OHOS_SECTION_STREAM_VIDEO;
291 break;
292 case OHOS_CAMERA_EFFECT:
293 *section = OHOS_SECTION_CAMERA_EFFECT;
294 case OHOS_CAMERA_SECURE:
295 *section = OHOS_SECTION_CAMERA_SECURE;
296 break;
297 default:
298 METADATA_ERR_LOG("GetMetadataSection item section is not defined");
299 ret = CAM_META_FAILURE;
300 break;
301 }
302
303 METADATA_DEBUG_LOG("GetMetadataSection end");
304 return ret;
305 }
306
GetCameraMetadataItemType(uint32_t item,uint32_t * dataType)307 int32_t GetCameraMetadataItemType(uint32_t item, uint32_t *dataType)
308 {
309 METADATA_DEBUG_LOG("GetCameraMetadataItemType start");
310 if (dataType == nullptr) {
311 METADATA_ERR_LOG("GetCameraMetadataItemType dataType is null");
312 return CAM_META_INVALID_PARAM;
313 }
314 uint32_t section;
315 int32_t ret = GetMetadataSection(item >> BITWISE_SHIFT_16, §ion);
316 if (ret != CAM_META_SUCCESS) {
317 METADATA_ERR_LOG("GetCameraMetadataItemType section is not valid");
318 return ret;
319 }
320
321 if (item >= g_ohosCameraSectionBounds[section][1]) {
322 METADATA_ERR_LOG("GetCameraMetadataItemType item is not in section bound");
323 return CAM_META_FAILURE;
324 }
325
326 uint32_t itemIndex = item & 0xFFFF;
327 if (g_ohosItemInfo[section][itemIndex].item_type < META_TYPE_BYTE) {
328 METADATA_ERR_LOG("GetCameraMetadataItemType item is not initialized");
329 return CAM_META_FAILURE;
330 }
331
332 *dataType = g_ohosItemInfo[section][itemIndex].item_type;
333
334 METADATA_DEBUG_LOG("GetCameraMetadataItemType end");
335 return CAM_META_SUCCESS;
336 }
337
GetCameraMetadataItemName(uint32_t item)338 const char *GetCameraMetadataItemName(uint32_t item)
339 {
340 METADATA_DEBUG_LOG("GetCameraMetadataItemName start");
341 METADATA_DEBUG_LOG("GetCameraMetadataItemName item: %{public}u", item);
342 uint32_t section;
343 int32_t ret = GetMetadataSection(item >> BITWISE_SHIFT_16, §ion);
344 if (ret != CAM_META_SUCCESS) {
345 METADATA_ERR_LOG("GetCameraMetadataItemName section is not valid");
346 return nullptr;
347 }
348
349 if (item >= g_ohosCameraSectionBounds[section][1]) {
350 METADATA_ERR_LOG("GetCameraMetadataItemName item is not in section bound");
351 return nullptr;
352 }
353
354 uint32_t itemIndex = item & 0xFFFF;
355 METADATA_DEBUG_LOG("GetCameraMetadataItemName end");
356 return g_ohosItemInfo[section][itemIndex].item_name;
357 }
358
CalculateCameraMetadataItemDataSize(uint32_t type,size_t dataCount)359 size_t CalculateCameraMetadataItemDataSize(uint32_t type, size_t dataCount)
360 {
361 METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize start");
362 if (type < META_TYPE_BYTE || type >= META_NUM_TYPES) {
363 METADATA_ERR_LOG("CalculateCameraMetadataItemDataSize invalid type");
364 return 0;
365 }
366
367 size_t dataBytes = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[type];
368
369 METADATA_DEBUG_LOG("CalculateCameraMetadataItemDataSize end");
370 return (dataBytes <= METADATA_HEADER_DATA_SIZE) ? 0 : AlignTo(dataBytes, DATA_ALIGNMENT);
371 }
372
AddCameraMetadataItem(common_metadata_header_t * dst,uint32_t item,const void * data,size_t dataCount)373 int AddCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data, size_t dataCount)
374 {
375 METADATA_DEBUG_LOG("AddCameraMetadataItem start");
376 const char *name = GetCameraMetadataItemName(item);
377 if (name == nullptr) {
378 name = "<unknown>";
379 }
380 METADATA_DEBUG_LOG("AddCameraMetadataItem item id: %{public}u, name: %{public}s, "
381 "dataCount: %{public}zu", item, name, dataCount);
382
383 if (dst == nullptr) {
384 METADATA_ERR_LOG("AddCameraMetadataItem common_metadata_header_t is null");
385 return CAM_META_INVALID_PARAM;
386 }
387
388 if (!dataCount || data == nullptr) {
389 METADATA_ERR_LOG("AddCameraMetadataItem data is not valid. item: %{public}u, "
390 "dataCount: %{public}zu", item, dataCount);
391 return CAM_META_INVALID_PARAM;
392 }
393
394 if (dst->item_count == dst->item_capacity) {
395 METADATA_ERR_LOG("AddCameraMetadataItem item_capacity limit reached. "
396 "item_count: %{public}d, item_capacity: %{public}d",
397 dst->item_count, dst->item_capacity);
398 return CAM_META_ITEM_CAP_EXCEED;
399 }
400
401 uint32_t dataType;
402 int32_t ret = GetCameraMetadataItemType(item, &dataType);
403 if (ret != CAM_META_SUCCESS) {
404 METADATA_ERR_LOG("AddCameraMetadataItem invalid item type");
405 return CAM_META_INVALID_PARAM;
406 }
407
408 size_t dataBytes =
409 CalculateCameraMetadataItemDataSize(dataType, dataCount);
410 if (dataBytes + dst->data_count > dst->data_capacity) {
411 METADATA_ERR_LOG("AddCameraMetadataItem data_capacity limit reached");
412 return CAM_META_DATA_CAP_EXCEED;
413 }
414
415 size_t dataPayloadBytes =
416 dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[dataType];
417 camera_metadata_item_entry_t *metadataItem = GetMetadataItems(dst) + dst->item_count;
418 ret = memset_s(metadataItem, sizeof(camera_metadata_item_entry_t), 0, sizeof(camera_metadata_item_entry_t));
419 if (ret != EOK) {
420 METADATA_ERR_LOG("AddCameraMetadataItem: memset_s failed");
421 return CAM_META_FAILURE;
422 }
423 metadataItem->item = item;
424 metadataItem->data_type = dataType;
425 metadataItem->count = dataCount;
426
427 if (dataBytes == 0) {
428 ret = memcpy_s(metadataItem->data.value, METADATA_HEADER_DATA_SIZE, data, dataPayloadBytes);
429 if (ret != EOK) {
430 METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed");
431 return CAM_META_FAILURE;
432 }
433 } else {
434 metadataItem->data.offset = dst->data_count;
435 ret = memcpy_s(GetMetadataData(dst) + metadataItem->data.offset, dst->data_capacity - dst->data_count, data,
436 dataPayloadBytes);
437 if (ret != EOK) {
438 METADATA_ERR_LOG("AddCameraMetadataItem memory copy failed");
439 return CAM_META_FAILURE;
440 }
441 dst->data_count += dataBytes;
442 }
443 dst->item_count++;
444
445 METADATA_DEBUG_LOG("AddCameraMetadataItem end");
446 return CAM_META_SUCCESS;
447 }
448
GetCameraMetadataItem(const common_metadata_header_t * src,uint32_t index,camera_metadata_item_t * item)449 int GetCameraMetadataItem(const common_metadata_header_t *src, uint32_t index, camera_metadata_item_t *item)
450 {
451 METADATA_DEBUG_LOG("GetCameraMetadataItem start");
452 if (src == nullptr || item == nullptr) {
453 METADATA_ERR_LOG("GetCameraMetadataItem src or item is null");
454 return CAM_META_INVALID_PARAM;
455 }
456
457 int32_t ret = memset_s(item, sizeof(camera_metadata_item_t), 0, sizeof(camera_metadata_item_t));
458 if (ret != EOK) {
459 METADATA_ERR_LOG("GetCameraMetadataItem: memset_s failed");
460 return CAM_META_FAILURE;
461 }
462 if (index >= src->item_count) {
463 METADATA_ERR_LOG("GetCameraMetadataItem index is greater than item count");
464 return CAM_META_INVALID_PARAM;
465 }
466
467 camera_metadata_item_entry_t *localItem = GetMetadataItems(src) + index;
468
469 item->index = index;
470 item->item = localItem->item;
471 item->data_type = localItem->data_type;
472 item->count = localItem->count;
473
474 size_t dataBytes = CalculateCameraMetadataItemDataSize(localItem->data_type, localItem->count);
475 if (dataBytes == 0) {
476 item->data.u8 = localItem->data.value;
477 } else {
478 item->data.u8 = GetMetadataData(src) + localItem->data.offset;
479 }
480
481 METADATA_DEBUG_LOG("GetCameraMetadataItem end");
482 return CAM_META_SUCCESS;
483 }
484
FindCameraMetadataItemIndex(const common_metadata_header_t * src,uint32_t item,uint32_t * idx)485 int FindCameraMetadataItemIndex(const common_metadata_header_t *src, uint32_t item, uint32_t *idx)
486 {
487 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex start");
488 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex item: %{public}u", item);
489 if (src == nullptr || idx == nullptr) {
490 METADATA_ERR_LOG("FindCameraMetadataItemIndex src or index is null");
491 return CAM_META_INVALID_PARAM;
492 }
493
494 camera_metadata_item_entry_t *searchItem = GetMetadataItems(src);
495 uint32_t index;
496 for (index = 0; index < src->item_count; index++, searchItem++) {
497 if (searchItem->item == item) {
498 break;
499 }
500 }
501
502 if (index == src->item_count) {
503 METADATA_ERR_LOG("FindCameraMetadataItemIndex item: %{public}u not found", item);
504 return CAM_META_ITEM_NOT_FOUND;
505 }
506
507 *idx = index;
508 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex index: %{public}u", index);
509 METADATA_DEBUG_LOG("FindCameraMetadataItemIndex end");
510 return CAM_META_SUCCESS;
511 }
512
FindCameraMetadataItem(const common_metadata_header_t * src,uint32_t item,camera_metadata_item_t * metadataItem)513 int FindCameraMetadataItem(const common_metadata_header_t *src, uint32_t item, camera_metadata_item_t *metadataItem)
514 {
515 uint32_t index = 0;
516 const char *name = GetCameraMetadataItemName(item);
517 if (name == nullptr) {
518 name = "<unknown>";
519 }
520 METADATA_DEBUG_LOG("FindCameraMetadataItem item id: %{public}u, name: %{public}s", item, name);
521 int ret = FindCameraMetadataItemIndex(src, item, &index);
522 if (ret != CAM_META_SUCCESS) {
523 return ret;
524 }
525
526 return GetCameraMetadataItem(src, index, metadataItem);
527 }
528
SetOffset(camera_metadata_item_entry_t * metadataItems,camera_metadata_item_entry_t * item,size_t oldItemSize)529 void SetOffset(camera_metadata_item_entry_t *metadataItems, camera_metadata_item_entry_t *item, size_t oldItemSize)
530 {
531 if (CalculateCameraMetadataItemDataSize(metadataItems->data_type, metadataItems->count) > 0 &&
532 metadataItems->data.offset > item->data.offset) {
533 metadataItems->data.offset -= oldItemSize;
534 }
535 }
536
MetadataExpandItemMem(common_metadata_header_t * dst,camera_metadata_item_entry_t * item,size_t oldItemSize)537 int MetadataExpandItemMem(common_metadata_header_t *dst, camera_metadata_item_entry_t *item,
538 size_t oldItemSize)
539 {
540 if (item == nullptr || dst == nullptr) {
541 METADATA_ERR_LOG("MetadataExpandItemMem item is null or dst is null");
542 return CAM_META_INVALID_PARAM;
543 }
544 uint8_t *start = GetMetadataData(dst) + item->data.offset;
545 uint8_t *end = start + oldItemSize;
546 size_t length = dst->data_count - item->data.offset - oldItemSize;
547 if (length != 0) {
548 int32_t ret = memmove_s(start, length, end, length);
549 if (ret != EOK) {
550 METADATA_ERR_LOG("MetadataExpandItemMem memory move failed");
551 return CAM_META_FAILURE;
552 }
553 }
554 dst->data_count -= oldItemSize;
555
556 camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst);
557 for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) {
558 SetOffset(metadataItems, item, oldItemSize);
559 }
560
561 return CAM_META_SUCCESS;
562 }
563
UpdateCameraMetadataItemByIndex(common_metadata_header_t * dst,uint32_t index,const void * data,uint32_t dataCount,camera_metadata_item_t * updatedItem)564 int UpdateCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index, const void *data, uint32_t dataCount,
565 camera_metadata_item_t *updatedItem)
566 {
567 METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex start");
568 if ((dst == nullptr) || (index >= dst->item_count)) {
569 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex dst is null or invalid index");
570 return CAM_META_INVALID_PARAM;
571 }
572
573 if (!dataCount || data == nullptr) {
574 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data is not valid. "
575 "dataCount: %{public}u", dataCount);
576 return CAM_META_INVALID_PARAM;
577 }
578
579 int32_t ret = CAM_META_SUCCESS;
580 camera_metadata_item_entry_t *item = GetMetadataItems(dst) + index;
581 size_t dataSize = CalculateCameraMetadataItemDataSize(item->data_type, dataCount);
582 size_t dataPayloadSize = dataCount * OHOS_CAMERA_METADATA_TYPE_SIZE[item->data_type];
583
584 size_t oldItemSize = CalculateCameraMetadataItemDataSize(item->data_type, item->count);
585 if (dataSize != oldItemSize) {
586 if (dst->data_capacity < (dst->data_count + dataSize - oldItemSize)) {
587 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex data_capacity limit reached");
588 return CAM_META_DATA_CAP_EXCEED;
589 }
590
591 if (oldItemSize != 0) {
592 ret = MetadataExpandItemMem(dst, item, oldItemSize);
593 if (ret != CAM_META_SUCCESS) {
594 return ret;
595 }
596 }
597
598 if (dataSize != 0) {
599 item->data.offset = dst->data_count;
600 ret = memcpy_s(GetMetadataData(dst) + item->data.offset, dataPayloadSize, data, dataPayloadSize);
601 if (ret != EOK) {
602 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed");
603 return CAM_META_FAILURE;
604 }
605 dst->data_count += dataSize;
606 }
607 } else if (dataSize != 0) {
608 ret = memcpy_s(GetMetadataData(dst) + item->data.offset, dataPayloadSize, data, dataPayloadSize);
609 if (ret != EOK) {
610 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed");
611 return CAM_META_FAILURE;
612 }
613 }
614
615 if (dataSize == 0) {
616 ret = memcpy_s(item->data.value, dataPayloadSize, data, dataPayloadSize);
617 if (ret != EOK) {
618 METADATA_ERR_LOG("UpdateCameraMetadataItemByIndex memory copy failed");
619 return CAM_META_FAILURE;
620 }
621 }
622
623 item->count = dataCount;
624 if (updatedItem != nullptr) {
625 ret = GetCameraMetadataItem(dst, index, updatedItem);
626 if (ret != CAM_META_SUCCESS) {
627 return ret;
628 }
629 }
630
631 METADATA_DEBUG_LOG("UpdateCameraMetadataItemByIndex end");
632 return ret;
633 }
634
UpdateCameraMetadataItem(common_metadata_header_t * dst,uint32_t item,const void * data,uint32_t dataCount,camera_metadata_item_t * updatedItem)635 int UpdateCameraMetadataItem(common_metadata_header_t *dst, uint32_t item, const void *data,
636 uint32_t dataCount, camera_metadata_item_t *updatedItem)
637 {
638 METADATA_DEBUG_LOG("UpdateCameraMetadataItem item id: %{public}u, dataCount: %{public}u", item, dataCount);
639 const char *name = GetCameraMetadataItemName(item);
640 if (name == nullptr) {
641 name = "<unknown>";
642 }
643 METADATA_DEBUG_LOG("UpdateCameraMetadataItem item id: %{public}u, name: %{public}s, "
644 "dataCount: %{public}u", item, name, dataCount);
645 if (!dataCount || data == nullptr) {
646 METADATA_ERR_LOG("UpdateCameraMetadataItem data is not valid. item: %{public}u, "
647 "dataCount: %{public}u", item, dataCount);
648 return CAM_META_INVALID_PARAM;
649 }
650
651 uint32_t index = 0;
652 int32_t ret = FindCameraMetadataItemIndex(dst, item, &index);
653 if (ret != CAM_META_SUCCESS) {
654 return ret;
655 }
656
657 return UpdateCameraMetadataItemByIndex(dst, index, data, dataCount, updatedItem);
658 }
659
DeleteCameraMetadataItemByIndex(common_metadata_header_t * dst,uint32_t index)660 int DeleteCameraMetadataItemByIndex(common_metadata_header_t *dst, uint32_t index)
661 {
662 METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex start");
663 if (dst == nullptr) {
664 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex dst is null");
665 return CAM_META_INVALID_PARAM;
666 }
667
668 if (index >= dst->item_count) {
669 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex item not valid");
670 return CAM_META_INVALID_PARAM;
671 }
672
673 int32_t ret = CAM_META_SUCCESS;
674 camera_metadata_item_entry_t *itemToDelete = GetMetadataItems(dst) + index;
675 size_t dataBytes = CalculateCameraMetadataItemDataSize(itemToDelete->data_type, itemToDelete->count);
676 if (dataBytes > 0) {
677 uint8_t *start = GetMetadataData(dst) + itemToDelete->data.offset;
678 uint8_t *end = start + dataBytes;
679 size_t length = dst->data_count - itemToDelete->data.offset - dataBytes;
680 if (length != 0) {
681 ret = memmove_s(start, length, end, length);
682 if (ret != EOK) {
683 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed");
684 return CAM_META_FAILURE;
685 }
686 }
687 dst->data_count -= dataBytes;
688
689 camera_metadata_item_entry_t *metadataItems = GetMetadataItems(dst);
690 for (uint32_t i = 0; i < dst->item_count; i++, ++metadataItems) {
691 if (CalculateCameraMetadataItemDataSize(
692 metadataItems->data_type, metadataItems->count) > 0 &&
693 metadataItems->data.offset > itemToDelete->data.offset) {
694 metadataItems->data.offset -= dataBytes;
695 }
696 }
697 }
698
699 uint64_t length = sizeof(camera_metadata_item_entry_t) * (dst->item_count - index - 1);
700 if (length != 0) {
701 ret = memmove_s(itemToDelete, length, itemToDelete + 1, length);
702 if (ret != EOK) {
703 METADATA_ERR_LOG("DeleteCameraMetadataItemByIndex memory move failed");
704 return CAM_META_FAILURE;
705 }
706 }
707 dst->item_count -= 1;
708 METADATA_DEBUG_LOG("DeleteCameraMetadataItemByIndex end");
709 return ret;
710 }
711
DeleteCameraMetadataItem(common_metadata_header_t * dst,uint32_t item)712 int DeleteCameraMetadataItem(common_metadata_header_t *dst, uint32_t item)
713 {
714 METADATA_DEBUG_LOG("DeleteCameraMetadataItem item: %{public}u", item);
715 uint32_t index = 0;
716 int32_t ret = FindCameraMetadataItemIndex(dst, item, &index);
717 if (ret != CAM_META_SUCCESS) {
718 return ret;
719 }
720
721 return DeleteCameraMetadataItemByIndex(dst, index);
722 }
723
FreeCameraMetadataBuffer(common_metadata_header_t * dst)724 void FreeCameraMetadataBuffer(common_metadata_header_t *dst)
725 {
726 if (dst != nullptr) {
727 free(dst);
728 }
729 }
730
GetCameraMetadataItemCount(const common_metadata_header_t * metadataHeader)731 uint32_t GetCameraMetadataItemCount(const common_metadata_header_t *metadataHeader)
732 {
733 if (!metadataHeader) {
734 METADATA_ERR_LOG("GetCameraMetadataItemCount::metadataHeader is null");
735 return 0;
736 }
737 return metadataHeader->item_count;
738 }
739
GetCameraMetadataItemCapacity(const common_metadata_header_t * metadataHeader)740 uint32_t GetCameraMetadataItemCapacity(const common_metadata_header_t *metadataHeader)
741 {
742 if (!metadataHeader) {
743 METADATA_ERR_LOG("GetCameraMetadataItemCapacity::metadataHeader is null");
744 return 0;
745 }
746 return metadataHeader->item_capacity;
747 }
748
GetCameraMetadataDataSize(const common_metadata_header_t * metadataHeader)749 uint32_t GetCameraMetadataDataSize(const common_metadata_header_t *metadataHeader)
750 {
751 if (metadataHeader == nullptr) {
752 METADATA_ERR_LOG("GetCameraMetadataDataSize::metadataHeader is null");
753 return 0;
754 }
755 return metadataHeader->data_capacity;
756 }
757
CopyCameraMetadataItems(common_metadata_header_t * newMetadata,const common_metadata_header_t * oldMetadata)758 int32_t CopyCameraMetadataItems(common_metadata_header_t *newMetadata, const common_metadata_header_t *oldMetadata)
759 {
760 if (newMetadata == nullptr || oldMetadata == nullptr) {
761 return CAM_META_INVALID_PARAM;
762 }
763
764 int32_t ret;
765 if (oldMetadata->item_count != 0) {
766 ret = memcpy_s(GetMetadataItems(newMetadata), sizeof(camera_metadata_item_entry_t[oldMetadata->item_count]),
767 GetMetadataItems(oldMetadata), sizeof(camera_metadata_item_entry_t[oldMetadata->item_count]));
768 if (ret != EOK) {
769 METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed");
770 return CAM_META_FAILURE;
771 }
772 }
773
774 if (oldMetadata->data_count != 0) {
775 ret = memcpy_s(GetMetadataData(newMetadata), sizeof(uint8_t[oldMetadata->data_count]),
776 GetMetadataData(oldMetadata), sizeof(uint8_t[oldMetadata->data_count]));
777 if (ret != EOK) {
778 METADATA_ERR_LOG("CopyCameraMetadataItems memory copy failed");
779 return CAM_META_FAILURE;
780 }
781 }
782
783 newMetadata->item_count = oldMetadata->item_count;
784 newMetadata->data_count = oldMetadata->data_count;
785
786 return CAM_META_SUCCESS;
787 }
788
U8ItemToString(int32_t item,const camera_metadata_item_t entry)789 std::string U8ItemToString(int32_t item, const camera_metadata_item_t entry)
790 {
791 std::string st = {};
792 uint32_t count = entry.count;
793 std::string dataStr = std::to_string(*(entry.data.u8));
794 for (uint32_t i = 1; i < count; i++) {
795 if ((i % WRAP_LENGTH) == 0) {
796 dataStr += "]\n\t[" + std::to_string(*(entry.data.u8 + i));
797 } else {
798 dataStr += " " + std::to_string(*(entry.data.u8 + i));
799 }
800 }
801
802 const char *name = GetCameraMetadataItemName(item);
803 if (name == nullptr) {
804 METADATA_ERR_LOG("U8ItemToString: get u8 item name fail!");
805 return st;
806 }
807 std::string nameStr(name);
808
809 st = nameStr + " (" + std::to_string(entry.index) + "): " +
810 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
811
812 return st;
813 }
814
I32ItemToString(int32_t item,const camera_metadata_item_t entry)815 std::string I32ItemToString(int32_t item, const camera_metadata_item_t entry)
816 {
817 std::string st = {};
818 uint32_t count = entry.count;
819 std::string dataStr = std::to_string(*(entry.data.i32));
820 for (uint32_t i = 1; i < count; i++) {
821 if ((i % WRAP_LENGTH) == 0) {
822 dataStr += "]\n\t[" + std::to_string(*(entry.data.i32 + i));
823 } else {
824 dataStr += " " + std::to_string(*(entry.data.i32 + i));
825 }
826 }
827
828 const char *name = GetCameraMetadataItemName(item);
829 if (name == nullptr) {
830 METADATA_ERR_LOG("I32ItemToString: get i32 item name fail!");
831 return st;
832 }
833 std::string nameStr(name);
834
835 st = nameStr + " (" + std::to_string(entry.index) + "): " +
836 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
837
838 return st;
839 }
840
U32ItemToString(int32_t item,const camera_metadata_item_t entry)841 std::string U32ItemToString(int32_t item, const camera_metadata_item_t entry)
842 {
843 std::string st = {};
844 uint32_t count = entry.count;
845 std::string dataStr = std::to_string(*(entry.data.ui32));
846 for (uint32_t i = 1; i < count; i++) {
847 if ((i % WRAP_LENGTH) == 0) {
848 dataStr += "]\n\t[" + std::to_string(*(entry.data.ui32 + i));
849 } else {
850 dataStr += " " + std::to_string(*(entry.data.ui32 + i));
851 }
852 }
853
854 const char *name = GetCameraMetadataItemName(item);
855 if (name == nullptr) {
856 METADATA_ERR_LOG("U32ItemToString: get u32 item name fail!");
857 return st;
858 }
859 std::string nameStr(name);
860
861 st = nameStr + " (" + std::to_string(entry.index) + "): " +
862 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
863
864 return st;
865 }
866
I64ItemToString(int32_t item,const camera_metadata_item_t entry)867 std::string I64ItemToString(int32_t item, const camera_metadata_item_t entry)
868 {
869 std::string st = {};
870 uint32_t count = entry.count;
871 std::string dataStr = std::to_string(*(entry.data.i64));
872 for (uint32_t i = 1; i < count; i++) {
873 if ((i % WRAP_LENGTH) == 0) {
874 dataStr += "]\n\t[" + std::to_string(*(entry.data.i64 + i));
875 } else {
876 dataStr += " " + std::to_string(*(entry.data.i64 + i));
877 }
878 }
879
880 const char *name = GetCameraMetadataItemName(item);
881 if (name == nullptr) {
882 METADATA_ERR_LOG("I64ItemToString: get i64 item name fail!");
883 return st;
884 }
885 std::string nameStr(name);
886
887 st = nameStr + " (" + std::to_string(entry.index) + "): " +
888 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
889
890 return st;
891 }
892
FloatItemToString(int32_t item,const camera_metadata_item_t entry)893 std::string FloatItemToString(int32_t item, const camera_metadata_item_t entry)
894 {
895 std::string st = {};
896 uint32_t count = entry.count;
897 std::string dataStr = std::to_string(*(entry.data.f));
898 for (uint32_t i = 1; i < count; i++) {
899 if ((i % WRAP_LENGTH) == 0) {
900 dataStr += "]\n\t[" + std::to_string(*(entry.data.f + i));
901 } else {
902 dataStr += " " + std::to_string(*(entry.data.f + i));
903 }
904 }
905
906 const char *name = GetCameraMetadataItemName(item);
907 if (name == nullptr) {
908 METADATA_ERR_LOG("FloatItemToString: get float item name fail!");
909 return st;
910 }
911 std::string nameStr(name);
912
913 st = nameStr + " (" + std::to_string(entry.index) + "): " +
914 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
915
916 return st;
917 }
918
DoubleItemToString(int32_t item,const camera_metadata_item_t entry)919 std::string DoubleItemToString(int32_t item, const camera_metadata_item_t entry)
920 {
921 std::string st = {};
922 uint32_t count = entry.count;
923 std::string dataStr = std::to_string(*(entry.data.d));
924 for (uint32_t i = 1; i < count; i++) {
925 if ((i % WRAP_LENGTH) == 0) {
926 dataStr += "]\n\t[" + std::to_string(*(entry.data.d + i));
927 } else {
928 dataStr += " " + std::to_string(*(entry.data.d + i));
929 }
930 }
931
932 const char *name = GetCameraMetadataItemName(item);
933 if (name == nullptr) {
934 METADATA_ERR_LOG("DoubleItemToString: get double item name fail!");
935 return st;
936 }
937 std::string nameStr(name);
938
939 st = nameStr + " (" + std::to_string(entry.index) + "): " +
940 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
941
942 return st;
943 }
944
RationalItemToString(int32_t item,const camera_metadata_item_t entry)945 std::string RationalItemToString(int32_t item, const camera_metadata_item_t entry)
946 {
947 std::string st = {};
948 uint32_t count = entry.count;
949 std::string dataStr = std::to_string((*(entry.data.r)).numerator) + "/" +
950 std::to_string((*(entry.data.r)).denominator);
951 for (uint32_t i = 1; i < count; i++) {
952 if ((i % WRAP_LENGTH) == 0) {
953 dataStr += "]\n\t[" + std::to_string((*(entry.data.r + i)).numerator) + "/" +
954 std::to_string((*(entry.data.r + i)).denominator);
955 } else {
956 dataStr += " " + std::to_string((*(entry.data.r + i)).numerator) + "/" +
957 std::to_string((*(entry.data.r + i)).denominator);
958 }
959 }
960
961 const char *name = GetCameraMetadataItemName(item);
962 if (name == nullptr) {
963 METADATA_ERR_LOG("RationalItemToString: get rational item name fail!");
964 return st;
965 }
966 std::string nameStr(name);
967
968 st = nameStr + " (" + std::to_string(entry.index) + "): " +
969 OHOS_CAMERA_METADATA_TYPE[entry.data_type] + "[" + std::to_string(count) + "]" + "\n\t[" + dataStr + "]";
970
971 return st;
972 }
973
MetadataItemDump(const common_metadata_header_t * metadataHeader,uint32_t item)974 std::string MetadataItemDump(const common_metadata_header_t *metadataHeader, uint32_t item)
975 {
976 camera_metadata_item_t entry;
977 std::string st = {};
978
979 int ret = FindCameraMetadataItem(metadataHeader, item, &entry);
980 if (ret != 0) {
981 METADATA_ERR_LOG("get item error and item = %{public}d", item);
982 return st;
983 }
984
985 switch (entry.data_type) {
986 case META_TYPE_BYTE:
987 st = U8ItemToString(item, entry);
988 break;
989 case META_TYPE_INT32:
990 st = I32ItemToString(item, entry);
991 break;
992 case META_TYPE_UINT32:
993 st = U32ItemToString(item, entry);
994 break;
995 case META_TYPE_FLOAT:
996 st = FloatItemToString(item, entry);
997 break;
998 case META_TYPE_INT64:
999 st = I64ItemToString(item, entry);
1000 break;
1001 case META_TYPE_DOUBLE:
1002 st = DoubleItemToString(item, entry);
1003 break;
1004 case META_TYPE_RATIONAL:
1005 st = RationalItemToString(item, entry);
1006 break;
1007 default:
1008 METADATA_ERR_LOG("invalid param and item = %{public}d", item);
1009 break;
1010 }
1011
1012 if (!st.empty()) {
1013 st += "\n";
1014 }
1015 return st;
1016 }
1017
FormatCameraMetadataToString(const common_metadata_header_t * metadataHeader)1018 std::string FormatCameraMetadataToString(const common_metadata_header_t *metadataHeader)
1019 {
1020 std::string metaStr;
1021 if (metadataHeader == nullptr) {
1022 METADATA_ERR_LOG("metadataHeader is nullptr");
1023 return metaStr;
1024 }
1025
1026 for (auto it = METADATATAGS.begin(); it != METADATATAGS.end(); it++) {
1027 metaStr += MetadataItemDump(metadataHeader, *it);
1028 }
1029
1030 return metaStr;
1031 }
1032 } // Camera
1033