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_unittest.h"
17 #include <securec.h>
18 #include "metadata_utils.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS::Camera {
SetUpTestCase(void)23 void CameraMetadataUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)24 void CameraMetadataUnitTest::TearDownTestCase(void) {}
25
SetUp()26 void CameraMetadataUnitTest::SetUp() {}
TearDown()27 void CameraMetadataUnitTest::TearDown() {}
28
29 /*
30 * Feature: Metadata
31 * Function: AllocateCameraMetadataBuffer
32 * SubFunction: NA
33 * FunctionPoints: NA
34 * EnvConditions: NA
35 * CaseDescription: Test allocation of camera metadata
36 */
37 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_001, TestSize.Level0)
38 {
39 uint32_t item_capacity = 1;
40 uint32_t data_capacity = 1;
41 common_metadata_header_t *metadata = AllocateCameraMetadataBuffer(item_capacity, data_capacity);
42 ASSERT_NE(metadata, nullptr);
43 EXPECT_EQ(metadata->item_count, 0U);
44 EXPECT_EQ(metadata->item_capacity, 1U);
45 EXPECT_EQ(metadata->data_count, 0U);
46 EXPECT_EQ(metadata->data_capacity, 1U);
47
48 FreeCameraMetadataBuffer(metadata);
49 }
50
51 /*
52 * Feature: Metadata
53 * Function: AddCameraMetadataItem
54 * SubFunction: NA
55 * FunctionPoints: NA
56 * EnvConditions: NA
57 * CaseDescription: Test add camera metadata item with camera type
58 */
59 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_002, TestSize.Level0)
60 {
61 uint32_t item_capacity = 1;
62 uint32_t data_capacity = 0;
63 common_metadata_header_t *metadata = AllocateCameraMetadataBuffer(item_capacity, data_capacity);
64 ASSERT_NE(metadata, nullptr);
65 EXPECT_TRUE(metadata->item_count == 0);
66 EXPECT_TRUE(metadata->item_capacity == 1);
67
68 uint8_t cameraType = OHOS_CAMERA_TYPE_ULTRA_WIDE;
69 int result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
70 EXPECT_TRUE(result == CAM_META_SUCCESS);
71 EXPECT_TRUE(metadata->item_count == 1);
72
73 camera_metadata_item_entry_t *metadata_item = GetMetadataItems(metadata);
74 EXPECT_TRUE(metadata_item->item == OHOS_ABILITY_CAMERA_TYPE);
75 EXPECT_TRUE(metadata_item->data_type == META_TYPE_BYTE);
76 EXPECT_TRUE(metadata_item->count == 1);
77 EXPECT_TRUE(metadata_item->data.value[0] == OHOS_CAMERA_TYPE_ULTRA_WIDE);
78
79 FreeCameraMetadataBuffer(metadata);
80 }
81
82 /*
83 * Feature: Metadata
84 * Function: AddCameraMetadataItem
85 * SubFunction: NA
86 * FunctionPoints: NA
87 * EnvConditions: NA
88 * CaseDescription: Test add camera metadata item with camera type and camera position
89 */
90 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_003, TestSize.Level0)
91 {
92 uint32_t item_capacity = 2;
93 uint32_t data_capacity = 0;
94 common_metadata_header_t *metadata = AllocateCameraMetadataBuffer(item_capacity, data_capacity);
95 ASSERT_NE(metadata, nullptr);
96 EXPECT_TRUE(metadata->item_count == 0);
97 EXPECT_TRUE(metadata->item_capacity == 2);
98
99 uint8_t cameraType = OHOS_CAMERA_TYPE_ULTRA_WIDE;
100 int result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
101
102 uint8_t cameraPosition = OHOS_CAMERA_POSITION_BACK;
103 result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
104 EXPECT_TRUE(result == CAM_META_SUCCESS);
105 EXPECT_TRUE(metadata->item_count == 2);
106
107 camera_metadata_item_entry_t *position_item = GetMetadataItems(metadata)
108 + metadata->item_count - 1;
109 EXPECT_TRUE(position_item->item == OHOS_ABILITY_CAMERA_POSITION);
110 EXPECT_TRUE(position_item->data_type == META_TYPE_BYTE);
111 EXPECT_TRUE(position_item->count == 1);
112 EXPECT_TRUE(position_item->data.value[0] == OHOS_CAMERA_POSITION_BACK);
113
114 FreeCameraMetadataBuffer(metadata);
115 }
116
117 /*
118 * Feature: Metadata
119 * Function: AddCameraMetadataItem
120 * SubFunction: NA
121 * FunctionPoints: NA
122 * EnvConditions: NA
123 * CaseDescription: Test add camera metadata item with camera type, camera position and available
124 * focus modes
125 */
126 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_004, TestSize.Level0)
127 {
128 uint32_t item_capacity = 3;
129 uint32_t data_capacity = 0;
130 common_metadata_header_t *metadata = AllocateCameraMetadataBuffer(item_capacity, data_capacity);
131 ASSERT_NE(metadata, nullptr);
132 EXPECT_TRUE(metadata->item_count == 0);
133 EXPECT_TRUE(metadata->item_capacity == 3);
134
135 uint8_t cameraType = OHOS_CAMERA_TYPE_ULTRA_WIDE;
136 int result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
137
138 uint8_t cameraPosition = OHOS_CAMERA_POSITION_FRONT;
139 result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
140
141 uint8_t focusModes[4] = { OHOS_CAMERA_AF_MODE_AUTO,
142 OHOS_CAMERA_AF_MODE_MACRO,
143 OHOS_CAMERA_AF_MODE_CONTINUOUS_VIDEO,
144 OHOS_CAMERA_AF_MODE_CONTINUOUS_PICTURE};
145 result = AddCameraMetadataItem(metadata, OHOS_CONTROL_AF_AVAILABLE_MODES, focusModes, 4);
146 EXPECT_TRUE(result == CAM_META_SUCCESS);
147 EXPECT_TRUE(metadata->item_count == 3);
148
149 camera_metadata_item_entry_t *avail_focusmodes_item = GetMetadataItems(metadata)
150 + metadata->item_count - 1;
151 EXPECT_TRUE(OHOS_CONTROL_AF_AVAILABLE_MODES == avail_focusmodes_item->item);
152 EXPECT_TRUE(META_TYPE_BYTE == avail_focusmodes_item->data_type);
153 EXPECT_TRUE(4 == avail_focusmodes_item->count);
154 EXPECT_TRUE(avail_focusmodes_item->data.value[0] == OHOS_CAMERA_AF_MODE_AUTO);
155 EXPECT_TRUE(avail_focusmodes_item->data.value[1] == OHOS_CAMERA_AF_MODE_MACRO);
156 EXPECT_TRUE(avail_focusmodes_item->data.value[2] == OHOS_CAMERA_AF_MODE_CONTINUOUS_VIDEO);
157 EXPECT_TRUE(avail_focusmodes_item->data.value[3] == OHOS_CAMERA_AF_MODE_CONTINUOUS_PICTURE);
158
159 FreeCameraMetadataBuffer(metadata);
160 }
161
162 /*
163 * Feature: Metadata
164 * Function: AddCameraMetadataItem
165 * SubFunction: NA
166 * FunctionPoints: NA
167 * EnvConditions: NA
168 * CaseDescription: Test add camera metadata item with camera type, camera position,
169 * focus mode and zoom ratio range
170 */
171 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_005, TestSize.Level0)
172 {
173 uint32_t item_capacity = 4;
174 uint32_t data_capacity = AlignTo(5 * sizeof(float), DATA_ALIGNMENT);
175 common_metadata_header_t *metadata = AllocateCameraMetadataBuffer(item_capacity, data_capacity);
176 ASSERT_NE(metadata, nullptr);
177 EXPECT_TRUE(metadata->item_count == 0);
178 EXPECT_TRUE(metadata->item_capacity == 4);
179
180 uint8_t cameraType = OHOS_CAMERA_TYPE_ULTRA_WIDE;
181 int result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
182
183 uint8_t cameraPosition = OHOS_CAMERA_POSITION_FRONT;
184 result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
185
186 uint8_t focusMode = OHOS_CAMERA_AF_MODE_AUTO;
187 result = AddCameraMetadataItem(metadata, OHOS_CONTROL_AF_MODE, &focusMode, 1);
188 EXPECT_TRUE(result == CAM_META_SUCCESS);
189 EXPECT_TRUE(metadata->item_count == 3);
190
191 float zoomRatioRange[5] = {1.0, 2.0, 4.0, 8.0, 16.1};
192 result = AddCameraMetadataItem(metadata, OHOS_ABILITY_ZOOM_RATIO_RANGE, zoomRatioRange,
193 sizeof(zoomRatioRange)/sizeof(zoomRatioRange[0]));
194 EXPECT_TRUE(result == CAM_META_SUCCESS);
195 EXPECT_TRUE(metadata->item_count == 4);
196
197 camera_metadata_item_entry_t *zoom_ratio_range_item = GetMetadataItems(metadata)
198 + metadata->item_count - 1;
199 EXPECT_TRUE(zoom_ratio_range_item->item == OHOS_ABILITY_ZOOM_RATIO_RANGE);
200 EXPECT_TRUE(zoom_ratio_range_item->data_type == META_TYPE_FLOAT);
201 EXPECT_TRUE(zoom_ratio_range_item->count == sizeof(zoomRatioRange)/sizeof(zoomRatioRange[0]));
202 uint8_t *zoom_ratios = GetMetadataData(metadata) + zoom_ratio_range_item->data.offset;
203 EXPECT_TRUE(memcmp(zoomRatioRange, zoom_ratios, sizeof(zoomRatioRange)) == 0);
204
205 FreeCameraMetadataBuffer(metadata);
206 }
207
208 /*
209 * Feature: Metadata
210 * Function: FindCameraMetadataItem and UpdateCameraMetadataItem
211 * SubFunction: NA
212 * FunctionPoints: NA
213 * EnvConditions: NA
214 * CaseDescription: Test find metadata and update metadata items with camera type, camera position,
215 * flash mode, exposure mode and zoom ratio range.
216 */
217 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_006, TestSize.Level0)
218 {
219 uint32_t item_capacity = 5;
220 uint32_t data_capacity = AlignTo(6 * sizeof(float), DATA_ALIGNMENT);
221 common_metadata_header_t *metadata = AllocateCameraMetadataBuffer(item_capacity, data_capacity);
222 ASSERT_NE(metadata, nullptr);
223
224 uint8_t cameraType = OHOS_CAMERA_TYPE_WIDE_ANGLE;
225 int result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
226 EXPECT_TRUE(result == CAM_META_SUCCESS);
227
228 uint8_t cameraPosition = OHOS_CAMERA_POSITION_FRONT;
229 result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
230 EXPECT_TRUE(result == CAM_META_SUCCESS);
231
232 float zoomRatioRange[4] = {1.0, 2.0, 4.0, 8.0};
233 result = AddCameraMetadataItem(metadata, OHOS_ABILITY_ZOOM_RATIO_RANGE, zoomRatioRange,
234 sizeof(zoomRatioRange)/sizeof(zoomRatioRange[0]));
235 EXPECT_TRUE(result == CAM_META_SUCCESS);
236
237 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_AUTO;
238 result = AddCameraMetadataItem(metadata, OHOS_CONTROL_FLASHMODE, &flashMode, 1);
239 EXPECT_TRUE(result == CAM_META_SUCCESS);
240
241 uint8_t exposureMode = OHOS_CAMERA_AE_MODE_ON_AUTO_FLASH;
242 result = AddCameraMetadataItem(metadata, OHOS_CONTROL_AE_MODE, &exposureMode, 1);
243 EXPECT_TRUE(result == CAM_META_SUCCESS);
244 EXPECT_TRUE(metadata->item_count == 5);
245
246 camera_metadata_item_t metadata_item;
247
248 // Find the focus mode. It should return item not found error
249 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AF_MODE, &metadata_item);
250 EXPECT_TRUE(result == CAM_META_ITEM_NOT_FOUND);
251
252 // Find the flash mode and verify the values returned
253 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASHMODE, &metadata_item);
254 EXPECT_TRUE(result == CAM_META_SUCCESS);
255 EXPECT_TRUE(metadata_item.item == OHOS_CONTROL_FLASHMODE);
256 EXPECT_TRUE(metadata_item.data_type == META_TYPE_BYTE);
257 EXPECT_TRUE(metadata_item.index == 3);
258 EXPECT_TRUE(metadata_item.count == 1);
259 EXPECT_TRUE(metadata_item.data.u8[0] == OHOS_CAMERA_FLASH_MODE_AUTO);
260
261 // Update focus mode should fail as it is not present and return item not found error
262 uint8_t focusMode = OHOS_CAMERA_AF_MODE_AUTO;
263 result = UpdateCameraMetadataItem(metadata, OHOS_CONTROL_AF_MODE, &focusMode, 1, &metadata_item);
264 EXPECT_TRUE(result == CAM_META_ITEM_NOT_FOUND);
265
266 // Find the current exposure mode
267 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AE_MODE, &metadata_item);
268 EXPECT_TRUE(result == CAM_META_SUCCESS);
269 EXPECT_TRUE(metadata_item.data.u8[0] == OHOS_CAMERA_AE_MODE_ON_AUTO_FLASH);
270
271 // Update exposure mode
272 exposureMode = OHOS_CAMERA_AE_MODE_ON;
273 result = UpdateCameraMetadataItem(metadata, OHOS_CONTROL_AE_MODE, &exposureMode, 1, &metadata_item);
274 EXPECT_TRUE(result == CAM_META_SUCCESS);
275 EXPECT_TRUE(metadata_item.item == OHOS_CONTROL_AE_MODE);
276 EXPECT_TRUE(metadata_item.data_type == META_TYPE_BYTE);
277 EXPECT_TRUE(metadata_item.index == 4);
278 EXPECT_TRUE(metadata_item.count == 1);
279 EXPECT_TRUE(metadata_item.data.u8[0] == OHOS_CAMERA_AE_MODE_ON);
280
281 // Update zoom ratio range
282 float updatedZoomRatioRange[6] = {1.0, 2.0, 4.0, 8.0, 16.0, 32.0};
283 result = UpdateCameraMetadataItem(metadata, OHOS_ABILITY_ZOOM_RATIO_RANGE, updatedZoomRatioRange,
284 sizeof(updatedZoomRatioRange)/sizeof(updatedZoomRatioRange[0]), &metadata_item);
285 EXPECT_TRUE(result == CAM_META_SUCCESS);
286 EXPECT_TRUE(metadata_item.item == OHOS_ABILITY_ZOOM_RATIO_RANGE);
287 EXPECT_TRUE(metadata_item.data_type == META_TYPE_FLOAT);
288 EXPECT_TRUE(metadata_item.index == 2);
289 EXPECT_TRUE(metadata_item.count == sizeof(updatedZoomRatioRange)/sizeof(updatedZoomRatioRange[0]));
290 EXPECT_TRUE(memcmp(updatedZoomRatioRange, metadata_item.data.f, sizeof(updatedZoomRatioRange)) == 0);
291
292 // Find to check if updated zoom ratio range is returned
293 camera_metadata_item_t updated_item;
294 result = FindCameraMetadataItem(metadata, OHOS_ABILITY_ZOOM_RATIO_RANGE, &updated_item);
295 EXPECT_TRUE(result == CAM_META_SUCCESS);
296 EXPECT_TRUE(memcmp(&updated_item, &metadata_item, sizeof(updated_item)) == 0);
297 EXPECT_TRUE(GetCameraMetadataItemName(OHOS_ABILITY_ZOOM_RATIO_RANGE) != nullptr);
298
299 // Free metadata
300 FreeCameraMetadataBuffer(metadata);
301 }
302
303 /*
304 * Feature: Metadata
305 * Function: DeleteCameraMetadataItem
306 * SubFunction: NA
307 * FunctionPoints: NA
308 * EnvConditions: NA
309 * CaseDescription: Test delete metadata item
310 */
311 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_007, TestSize.Level0)
312 {
313 uint32_t item_capacity = 3;
314 uint32_t data_capacity = 0;
315 common_metadata_header_t *metadata = AllocateCameraMetadataBuffer(item_capacity, data_capacity);
316 ASSERT_NE(metadata, nullptr);
317
318 uint8_t cameraType = OHOS_CAMERA_TYPE_TELTPHOTO;
319 int result = AddCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
320 EXPECT_TRUE(result == CAM_META_SUCCESS);
321
322 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_OPEN;
323 result = AddCameraMetadataItem(metadata, OHOS_CONTROL_FLASHMODE, &flashMode, 1);
324 EXPECT_TRUE(result == CAM_META_SUCCESS);
325
326 uint8_t focusMode = OHOS_CAMERA_AF_MODE_OFF;
327 result = AddCameraMetadataItem(metadata, OHOS_CONTROL_AF_MODE, &focusMode, 1);
328 EXPECT_TRUE(result == CAM_META_SUCCESS);
329
330 camera_metadata_item_t metadata_item;
331 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASHMODE, &metadata_item);
332 EXPECT_TRUE(result == CAM_META_SUCCESS);
333 EXPECT_TRUE(metadata_item.item == OHOS_CONTROL_FLASHMODE);
334 EXPECT_TRUE(metadata_item.data_type == META_TYPE_BYTE);
335 EXPECT_TRUE(metadata_item.index == 1);
336 EXPECT_TRUE(metadata_item.count == 1);
337 EXPECT_TRUE(metadata_item.data.u8[0] == OHOS_CAMERA_FLASH_MODE_OPEN);
338
339 // Delete exposure mode should return item not found error
340 result = DeleteCameraMetadataItem(metadata, OHOS_CONTROL_AE_MODE);
341 EXPECT_TRUE(result == CAM_META_ITEM_NOT_FOUND);
342
343 // delete flash mode
344 result = DeleteCameraMetadataItem(metadata, OHOS_CONTROL_FLASHMODE);
345 EXPECT_TRUE(result == CAM_META_SUCCESS);
346
347 // Verify if flash mode is deleted from metadata
348 camera_metadata_item_entry_t *base_item = GetMetadataItems(metadata);
349 uint32_t items[2] = {OHOS_ABILITY_CAMERA_TYPE, OHOS_CONTROL_AF_MODE};
350 uint8_t values[2] = {OHOS_CAMERA_TYPE_TELTPHOTO, OHOS_CAMERA_AF_MODE_OFF};
351 for (int i = 0; i < 2; i++, base_item++) {
352 EXPECT_TRUE(base_item->item == items[i]);
353 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
354 EXPECT_TRUE(base_item->count == 1);
355 EXPECT_TRUE(base_item->data.value[0] == values[i]);
356 }
357
358 // Free metadata
359 FreeCameraMetadataBuffer(metadata);
360 }
361
362 /*
363 * Feature: Metadata
364 * Function: addEntry
365 * SubFunction: NA
366 * FunctionPoints: NA
367 * EnvConditions: NA
368 * CaseDescription: Test addEntry
369 */
370 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_008, TestSize.Level0)
371 {
372 std::shared_ptr<CameraMetadata> meta = std::make_shared<CameraMetadata>(2, 0);
373 uint8_t cameraType = OHOS_CAMERA_TYPE_TRUE_DEAPTH;
374 bool ret = meta->addEntry(OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
375 EXPECT_TRUE(ret == true);
376
377 uint8_t cameraPosition = OHOS_CAMERA_POSITION_FRONT;
378 ret = meta->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
379 EXPECT_TRUE(ret == true);
380
381 // Verify if both the added metadata items are present in buffer
382 camera_metadata_item_entry_t *base_item = GetMetadataItems(meta->get());
383 uint32_t items[2] = {OHOS_ABILITY_CAMERA_TYPE, OHOS_ABILITY_CAMERA_POSITION};
384 uint8_t values[2] = {OHOS_CAMERA_TYPE_TRUE_DEAPTH, OHOS_CAMERA_POSITION_FRONT};
385 for (int i = 0; i < 2; i++, base_item++) {
386 EXPECT_TRUE(base_item->item == items[i]);
387 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
388 EXPECT_TRUE(base_item->count == 1);
389 EXPECT_TRUE(base_item->data.value[0] == values[i]);
390 }
391 }
392
393 /*
394 * Feature: Metadata
395 * Function: updateEntry and DeleteCameraMetadataItem
396 * SubFunction: NA
397 * FunctionPoints: NA
398 * EnvConditions: NA
399 * CaseDescription: Test updateEntry with metadata item data size more than 4 bytes and then delete item
400 */
401 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_009, TestSize.Level0)
402 {
403 std::shared_ptr<CameraMetadata> meta = std::make_shared<CameraMetadata>(3, AlignTo(7 * sizeof(float),
404 DATA_ALIGNMENT));
405 uint8_t cameraType = OHOS_CAMERA_TYPE_TRUE_DEAPTH;
406 bool ret = meta->addEntry(OHOS_ABILITY_CAMERA_TYPE, &cameraType, 1);
407 EXPECT_TRUE(ret == true);
408
409 float zoomRatioRange[5] = {1.0, 2.0, 4.0, 8.0, 16.0};
410 ret = meta->addEntry(OHOS_ABILITY_ZOOM_RATIO_RANGE, zoomRatioRange,
411 sizeof(zoomRatioRange)/sizeof(zoomRatioRange[0]));
412 EXPECT_TRUE(ret == true);
413
414 uint8_t cameraPosition = OHOS_CAMERA_POSITION_FRONT;
415 ret = meta->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
416 EXPECT_TRUE(ret == true);
417
418 // Verify all 3 added metadata items are present in buffer
419 camera_metadata_item_entry_t *base_item = GetMetadataItems(meta->get());
420 EXPECT_TRUE(base_item->item == OHOS_ABILITY_CAMERA_TYPE);
421 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
422 EXPECT_TRUE(base_item->count == 1);
423 EXPECT_TRUE(base_item->data.value[0] == OHOS_CAMERA_TYPE_TRUE_DEAPTH);
424
425 base_item++;
426 EXPECT_TRUE(base_item->item == OHOS_ABILITY_ZOOM_RATIO_RANGE);
427 EXPECT_TRUE(base_item->data_type == META_TYPE_FLOAT);
428 EXPECT_TRUE(base_item->count == sizeof(zoomRatioRange)/sizeof(zoomRatioRange[0]));
429 EXPECT_TRUE(memcmp(zoomRatioRange, GetMetadataData(meta->get()) + base_item->data.offset,
430 sizeof(zoomRatioRange)) == 0);
431
432 base_item++;
433 EXPECT_TRUE(base_item->item == OHOS_ABILITY_CAMERA_POSITION);
434 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
435 EXPECT_TRUE(base_item->count == 1);
436 EXPECT_TRUE(base_item->data.value[0] == OHOS_CAMERA_POSITION_FRONT);
437
438 // update the zoom ration range
439 float newZoomRatioRange[7] = {1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0};
440 ret = meta->updateEntry(OHOS_ABILITY_ZOOM_RATIO_RANGE, newZoomRatioRange,
441 sizeof(newZoomRatioRange)/sizeof(newZoomRatioRange[0]));
442 EXPECT_TRUE(ret == true);
443
444 // Verify metadata items in buffer
445 base_item = GetMetadataItems(meta->get());
446 EXPECT_TRUE(base_item->item == OHOS_ABILITY_CAMERA_TYPE);
447 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
448 EXPECT_TRUE(base_item->count == 1);
449 EXPECT_TRUE(base_item->data.value[0] == OHOS_CAMERA_TYPE_TRUE_DEAPTH);
450
451 base_item++;
452 EXPECT_TRUE(base_item->item == OHOS_ABILITY_ZOOM_RATIO_RANGE);
453 EXPECT_TRUE(base_item->data_type == META_TYPE_FLOAT);
454 EXPECT_TRUE(base_item->count == sizeof(newZoomRatioRange)/sizeof(newZoomRatioRange[0]));
455 EXPECT_TRUE(memcmp(newZoomRatioRange, GetMetadataData(meta->get()) + base_item->data.offset,
456 sizeof(newZoomRatioRange)) == 0);
457
458 base_item++;
459 EXPECT_TRUE(base_item->item == OHOS_ABILITY_CAMERA_POSITION);
460 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
461 EXPECT_TRUE(base_item->count == 1);
462 EXPECT_TRUE(base_item->data.value[0] == OHOS_CAMERA_POSITION_FRONT);
463
464 // delete the zoom ratio range
465 int result = DeleteCameraMetadataItem(meta->get(), OHOS_ABILITY_ZOOM_RATIO_RANGE);
466 EXPECT_TRUE(result == CAM_META_SUCCESS);
467
468 // Verify metadata items in buffer
469 base_item = GetMetadataItems(meta->get());
470 EXPECT_TRUE(base_item->item == OHOS_ABILITY_CAMERA_TYPE);
471 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
472 EXPECT_TRUE(base_item->count == 1);
473 EXPECT_TRUE(base_item->data.value[0] == OHOS_CAMERA_TYPE_TRUE_DEAPTH);
474
475 base_item++;
476 EXPECT_TRUE(base_item->item == OHOS_ABILITY_CAMERA_POSITION);
477 EXPECT_TRUE(base_item->data_type == META_TYPE_BYTE);
478 EXPECT_TRUE(base_item->count == 1);
479 EXPECT_TRUE(base_item->data.value[0] == OHOS_CAMERA_POSITION_FRONT);
480 }
481
482 /*
483 * Feature: Metadata
484 * Function: addEntry, EncodeCameraMetadata, DecodeCameraMetadata
485 * SubFunction: NA
486 * FunctionPoints: NA
487 * EnvConditions: NA
488 * CaseDescription: Test operations(add/find/delete) on metadata items with all data types
489 */
490 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_010, TestSize.Level0)
491 {
492 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(9, 80);
493
494 common_metadata_header_t *metadata = cameraMetadata->get();
495 ASSERT_NE(metadata, nullptr);
496
497 camera_metadata_item_t item;
498
499 // byte
500 uint8_t connectionType = OHOS_CAMERA_CONNECTION_TYPE_REMOTE;
501 bool ret = cameraMetadata->addEntry(OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &connectionType, 1);
502 EXPECT_TRUE(ret == true);
503
504 int result = FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
505 EXPECT_TRUE(result == CAM_META_SUCCESS);
506 EXPECT_TRUE(item.index == 0);
507 EXPECT_TRUE(item.item == OHOS_ABILITY_CAMERA_CONNECTION_TYPE);
508 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
509 EXPECT_TRUE(item.count == 1);
510 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_REMOTE);
511
512 // byte array
513 uint8_t scores[4] = {1, 2, 3, 0xFF};
514 ret = cameraMetadata->addEntry(OHOS_STATISTICS_FACE_SCORES, scores, sizeof(scores)/sizeof(scores[0]));
515 EXPECT_TRUE(ret == true);
516
517 result = FindCameraMetadataItem(metadata, OHOS_STATISTICS_FACE_SCORES, &item);
518 EXPECT_TRUE(result == CAM_META_SUCCESS);
519 EXPECT_TRUE(item.index == 1);
520 EXPECT_TRUE(item.item == OHOS_STATISTICS_FACE_SCORES);
521 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
522 EXPECT_TRUE(item.count == sizeof(scores)/sizeof(scores[0]));
523 EXPECT_TRUE(memcmp(item.data.u8, scores, sizeof(scores)) == 0);
524
525 // int32
526 int32_t exposureCompensation = 0xFFFFFFFF;
527 ret = cameraMetadata->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &exposureCompensation, 1);
528 EXPECT_TRUE(ret == true);
529
530 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &item);
531 EXPECT_TRUE(result == CAM_META_SUCCESS);
532 EXPECT_TRUE(item.index == 2);
533 EXPECT_TRUE(item.item == OHOS_CONTROL_AE_EXPOSURE_COMPENSATION);
534 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
535 EXPECT_TRUE(item.count == 1);
536 EXPECT_TRUE(item.data.i32[0] == exposureCompensation);
537
538 // int32 array
539 int32_t activeArray[4] = {0, 0, 2000, 1500};
540 ret = cameraMetadata->addEntry(OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, activeArray,
541 sizeof(activeArray)/sizeof(activeArray[0]));
542 EXPECT_TRUE(ret == true);
543
544 result = FindCameraMetadataItem(metadata, OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, &item);
545 EXPECT_TRUE(result == CAM_META_SUCCESS);
546 EXPECT_TRUE(item.index == 3);
547 EXPECT_TRUE(item.item == OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
548 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
549 EXPECT_TRUE(item.count == sizeof(activeArray)/sizeof(activeArray[0]));
550 EXPECT_TRUE(memcmp(item.data.i32, activeArray, sizeof(activeArray)) == 0);
551
552 // int64
553 int64_t exposureTime = 0xFFFFFFFFFFFFFFFF;
554 ret = cameraMetadata->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, 1);
555 EXPECT_TRUE(ret == true);
556
557 result = FindCameraMetadataItem(metadata, OHOS_SENSOR_EXPOSURE_TIME, &item);
558 EXPECT_TRUE(result == CAM_META_SUCCESS);
559 EXPECT_TRUE(item.index == 4);
560 EXPECT_TRUE(item.item == OHOS_SENSOR_EXPOSURE_TIME);
561 EXPECT_TRUE(item.data_type == META_TYPE_INT64);
562 EXPECT_TRUE(item.count == 1);
563 EXPECT_TRUE(item.data.i64[0] == exposureTime);
564
565 // float
566 float gain = 21.3;
567 ret = cameraMetadata->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &gain, 1);
568 EXPECT_TRUE(ret == true);
569
570 result = FindCameraMetadataItem(metadata, OHOS_SENSOR_COLOR_CORRECTION_GAINS, &item);
571 EXPECT_TRUE(result == CAM_META_SUCCESS);
572 EXPECT_TRUE(item.index == 5);
573 EXPECT_TRUE(item.item == OHOS_SENSOR_COLOR_CORRECTION_GAINS);
574 EXPECT_TRUE(item.data_type == META_TYPE_FLOAT);
575 EXPECT_TRUE(item.count == 1);
576 EXPECT_TRUE(item.data.f[0] == gain);
577
578 // float array
579 float zoomRatioRange[7] = {1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0};
580 ret = cameraMetadata->addEntry(OHOS_ABILITY_ZOOM_RATIO_RANGE, zoomRatioRange,
581 sizeof(zoomRatioRange)/sizeof(zoomRatioRange[0]));
582 EXPECT_TRUE(ret == true);
583
584 result = FindCameraMetadataItem(metadata, OHOS_ABILITY_ZOOM_RATIO_RANGE, &item);
585 EXPECT_TRUE(result == CAM_META_SUCCESS);
586 EXPECT_TRUE(item.index == 6);
587 EXPECT_TRUE(item.item == OHOS_ABILITY_ZOOM_RATIO_RANGE);
588 EXPECT_TRUE(item.data_type == META_TYPE_FLOAT);
589 EXPECT_TRUE(item.count == sizeof(zoomRatioRange)/sizeof(zoomRatioRange[0]));
590 EXPECT_TRUE(memcmp(item.data.f, zoomRatioRange, sizeof(zoomRatioRange)) == 0);
591
592 // double array
593 double gpsCoordinates[2] = {23.0166738, 77.7625576};
594 ret = cameraMetadata->addEntry(OHOS_JPEG_GPS_COORDINATES, gpsCoordinates,
595 sizeof(gpsCoordinates)/sizeof(gpsCoordinates[0]));
596 EXPECT_TRUE(ret == true);
597
598 result = FindCameraMetadataItem(metadata, OHOS_JPEG_GPS_COORDINATES, &item);
599 EXPECT_TRUE(result == CAM_META_SUCCESS);
600 EXPECT_TRUE(item.index == 7);
601 EXPECT_TRUE(item.item == OHOS_JPEG_GPS_COORDINATES);
602 EXPECT_TRUE(item.data_type == META_TYPE_DOUBLE);
603 EXPECT_TRUE(item.count == sizeof(gpsCoordinates)/sizeof(gpsCoordinates[0]));
604 EXPECT_TRUE(memcmp(item.data.d, gpsCoordinates, sizeof(gpsCoordinates)) == 0);
605
606 // rational
607 camera_rational_t rational = {1, 2};
608 ret = cameraMetadata->addEntry(OHOS_CONTROL_AE_COMPENSATION_STEP, &rational, 1);
609 EXPECT_TRUE(ret == true);
610
611 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AE_COMPENSATION_STEP, &item);
612 EXPECT_TRUE(result == CAM_META_SUCCESS);
613 EXPECT_TRUE(item.index == 8);
614 EXPECT_TRUE(item.item == OHOS_CONTROL_AE_COMPENSATION_STEP);
615 EXPECT_TRUE(item.data_type == META_TYPE_RATIONAL);
616 EXPECT_TRUE(item.count == 1);
617 EXPECT_TRUE(memcmp(item.data.r, &rational, sizeof(rational)) == 0);
618
619 // Delete zoom ratio range and check if items beneath are moved up
620 result = DeleteCameraMetadataItem(metadata, OHOS_ABILITY_ZOOM_RATIO_RANGE);
621 EXPECT_TRUE(result == CAM_META_SUCCESS);
622
623 result = FindCameraMetadataItem(metadata, OHOS_JPEG_GPS_COORDINATES, &item);
624 EXPECT_TRUE(result == CAM_META_SUCCESS);
625 EXPECT_TRUE(item.index == 6);
626 EXPECT_TRUE(item.item == OHOS_JPEG_GPS_COORDINATES);
627 EXPECT_TRUE(item.data_type == META_TYPE_DOUBLE);
628 EXPECT_TRUE(item.count == sizeof(gpsCoordinates)/sizeof(gpsCoordinates[0]));
629 EXPECT_TRUE(memcmp(item.data.d, gpsCoordinates, sizeof(gpsCoordinates)) == 0);
630
631 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AE_COMPENSATION_STEP, &item);
632 EXPECT_TRUE(result == CAM_META_SUCCESS);
633 EXPECT_TRUE(item.index == 7);
634 EXPECT_TRUE(item.item == OHOS_CONTROL_AE_COMPENSATION_STEP);
635 EXPECT_TRUE(item.data_type == META_TYPE_RATIONAL);
636 EXPECT_TRUE(item.count == 1);
637 EXPECT_TRUE(memcmp(item.data.r, &rational, sizeof(rational)) == 0);
638
639 // Encode camera metadata
640 OHOS::MessageParcel data;
641 ret = MetadataUtils::EncodeCameraMetadata(cameraMetadata, data);
642 EXPECT_TRUE(ret == true);
643
644 // Decode camera metadata
645 std::shared_ptr<CameraMetadata> decodedCameraMetadata;
646 MetadataUtils::DecodeCameraMetadata(data, decodedCameraMetadata);
647
648 // validate metadata
649 metadata = decodedCameraMetadata->get();
650 result = FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
651 EXPECT_TRUE(result == CAM_META_SUCCESS);
652 EXPECT_TRUE(item.index == 0);
653 EXPECT_TRUE(item.item == OHOS_ABILITY_CAMERA_CONNECTION_TYPE);
654 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
655 EXPECT_TRUE(item.count == 1);
656 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_REMOTE);
657
658 result = FindCameraMetadataItem(metadata, OHOS_STATISTICS_FACE_SCORES, &item);
659 EXPECT_TRUE(result == CAM_META_SUCCESS);
660 EXPECT_TRUE(item.index == 1);
661 EXPECT_TRUE(item.item == OHOS_STATISTICS_FACE_SCORES);
662 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
663 EXPECT_TRUE(item.count == sizeof(scores)/sizeof(scores[0]));
664 EXPECT_TRUE(memcmp(item.data.u8, scores, sizeof(scores)) == 0);
665
666 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &item);
667 EXPECT_TRUE(result == CAM_META_SUCCESS);
668 EXPECT_TRUE(item.index == 2);
669 EXPECT_TRUE(item.item == OHOS_CONTROL_AE_EXPOSURE_COMPENSATION);
670 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
671 EXPECT_TRUE(item.count == 1);
672 EXPECT_TRUE(item.data.i32[0] == exposureCompensation);
673
674 result = FindCameraMetadataItem(metadata, OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, &item);
675 EXPECT_TRUE(result == CAM_META_SUCCESS);
676 EXPECT_TRUE(item.index == 3);
677 EXPECT_TRUE(item.item == OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
678 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
679 EXPECT_TRUE(item.count == sizeof(activeArray)/sizeof(activeArray[0]));
680 EXPECT_TRUE(memcmp(item.data.i32, activeArray, sizeof(activeArray)) == 0);
681
682 result = FindCameraMetadataItem(metadata, OHOS_SENSOR_EXPOSURE_TIME, &item);
683 EXPECT_TRUE(result == CAM_META_SUCCESS);
684 EXPECT_TRUE(item.index == 4);
685 EXPECT_TRUE(item.item == OHOS_SENSOR_EXPOSURE_TIME);
686 EXPECT_TRUE(item.data_type == META_TYPE_INT64);
687 EXPECT_TRUE(item.count == 1);
688 EXPECT_TRUE(item.data.i64[0] == exposureTime);
689
690 result = FindCameraMetadataItem(metadata, OHOS_SENSOR_COLOR_CORRECTION_GAINS, &item);
691 EXPECT_TRUE(result == CAM_META_SUCCESS);
692 EXPECT_TRUE(item.index == 5);
693 EXPECT_TRUE(item.item == OHOS_SENSOR_COLOR_CORRECTION_GAINS);
694 EXPECT_TRUE(item.data_type == META_TYPE_FLOAT);
695 EXPECT_TRUE(item.count == 1);
696 EXPECT_TRUE(item.data.f[0] == gain);
697
698 result = FindCameraMetadataItem(metadata, OHOS_JPEG_GPS_COORDINATES, &item);
699 EXPECT_TRUE(result == CAM_META_SUCCESS);
700 EXPECT_TRUE(item.index == 6);
701 EXPECT_TRUE(item.item == OHOS_JPEG_GPS_COORDINATES);
702 EXPECT_TRUE(item.data_type == META_TYPE_DOUBLE);
703 EXPECT_TRUE(item.count == sizeof(gpsCoordinates)/sizeof(gpsCoordinates[0]));
704 EXPECT_TRUE(memcmp(item.data.f, gpsCoordinates, sizeof(gpsCoordinates)) == 0);
705
706 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AE_COMPENSATION_STEP, &item);
707 EXPECT_TRUE(result == CAM_META_SUCCESS);
708 EXPECT_TRUE(item.index == 7);
709 EXPECT_TRUE(item.item == OHOS_CONTROL_AE_COMPENSATION_STEP);
710 EXPECT_TRUE(item.data_type == META_TYPE_RATIONAL);
711 EXPECT_TRUE(item.count == 1);
712 EXPECT_TRUE(memcmp(item.data.r, &rational, sizeof(rational)) == 0);
713 }
714
715 /*
716 * Feature: Metadata
717 * Function: Capture Mirror Support
718 * SubFunction: NA
719 * FunctionPoints: NA
720 * EnvConditions: NA
721 * CaseDescription: Test operations(add/find) on mirroring metadata tags
722 */
723 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_011, TestSize.Level0)
724 {
725 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(2, 0);
726
727 common_metadata_header_t *metadata = cameraMetadata->get();
728 ASSERT_NE(metadata, nullptr);
729
730 camera_metadata_item_t item;
731
732 uint8_t captureMirrorSupport = 1;
733 bool ret = cameraMetadata->addEntry(OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED,
734 &captureMirrorSupport, 1);
735 EXPECT_TRUE(ret == true);
736
737 int32_t result = FindCameraMetadataItem(metadata, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &item);
738 EXPECT_TRUE(result == CAM_META_SUCCESS);
739 EXPECT_TRUE(item.index == 0);
740 EXPECT_TRUE(item.item == OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED);
741 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
742 EXPECT_TRUE(item.count == 1);
743 EXPECT_TRUE(item.data.u8[0] == captureMirrorSupport);
744
745 uint8_t captureMirror = 1;
746 ret = cameraMetadata->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &captureMirror, 1);
747 EXPECT_TRUE(ret == true);
748
749 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_CAPTURE_MIRROR, &item);
750 EXPECT_TRUE(result == CAM_META_SUCCESS);
751 EXPECT_TRUE(item.index == 1);
752 EXPECT_TRUE(item.item == OHOS_CONTROL_CAPTURE_MIRROR);
753 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
754 EXPECT_TRUE(item.count == 1);
755 EXPECT_TRUE(item.data.u8[0] == captureMirror);
756 }
757
758 /*
759 * Feature: Metadata
760 * Function: Flash Mode Support
761 * SubFunction: NA
762 * FunctionPoints: NA
763 * EnvConditions: NA
764 * CaseDescription: Test operations(add/find) on flash metadata tags
765 */
766 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_012, TestSize.Level0)
767 {
768 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(2, 0);
769
770 common_metadata_header_t *metadata = cameraMetadata->get();
771 ASSERT_NE(metadata, nullptr);
772
773 camera_metadata_item_t item;
774
775 uint8_t availFlashMode[4] = {OHOS_CAMERA_FLASH_MODE_CLOSE, OHOS_CAMERA_FLASH_MODE_OPEN,
776 OHOS_CAMERA_FLASH_MODE_AUTO, OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN};
777 bool ret = cameraMetadata->addEntry(OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES, availFlashMode,
778 sizeof(availFlashMode)/sizeof(availFlashMode[0]));
779 EXPECT_TRUE(ret == true);
780
781 int32_t result = FindCameraMetadataItem(metadata, OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES,
782 &item);
783 EXPECT_TRUE(result == CAM_META_SUCCESS);
784 EXPECT_TRUE(item.index == 0);
785 EXPECT_TRUE(item.item == OHOS_ABILITY_DEVICE_AVAILABLE_FLASHMODES);
786 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
787 EXPECT_TRUE(item.count == sizeof(availFlashMode)/sizeof(availFlashMode[0]));
788 EXPECT_TRUE(memcmp(item.data.u8, availFlashMode, sizeof(availFlashMode)) == 0);
789
790 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_AUTO;
791 ret = cameraMetadata->addEntry(OHOS_CONTROL_FLASHMODE, &flashMode, 1);
792 EXPECT_TRUE(ret == true);
793
794 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASHMODE, &item);
795 EXPECT_TRUE(result == CAM_META_SUCCESS);
796 EXPECT_TRUE(item.index == 1);
797 EXPECT_TRUE(item.item == OHOS_CONTROL_FLASHMODE);
798 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
799 EXPECT_TRUE(item.count == 1);
800 EXPECT_TRUE(item.data.u8[0] == flashMode);
801 }
802
803 /*
804 * Feature: Metadata
805 * Function: Available basic configurations
806 * SubFunction: NA
807 * FunctionPoints: NA
808 * EnvConditions: NA
809 * CaseDescription: Test operations(add/find) on stream configuration metadata tags
810 */
811 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_013, TestSize.Level0)
812 {
813 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(1, 0);
814
815 camera_metadata_item_t item;
816
817 int32_t availBasicConfig[12] = {OHOS_CAMERA_FORMAT_YCBCR_420_888, 4160, 3120,
818 OHOS_CAMERA_FORMAT_YCBCR_420_888, 4160, 2600,
819 OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1440, 1080,
820 OHOS_CAMERA_FORMAT_JPEG, 1440, 1080};
821
822 bool ret = cameraMetadata->addEntry(OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS,
823 availBasicConfig,
824 sizeof(availBasicConfig)/sizeof(availBasicConfig[0]));
825 EXPECT_TRUE(ret == true);
826
827 common_metadata_header_t *metadata = cameraMetadata->get();
828 ASSERT_NE(metadata, nullptr);
829
830 int32_t result = FindCameraMetadataItem(metadata,
831 OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item);
832 EXPECT_TRUE(result == CAM_META_SUCCESS);
833 EXPECT_TRUE(item.index == 0);
834 EXPECT_TRUE(item.item == OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS);
835 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
836 EXPECT_TRUE(item.count == sizeof(availBasicConfig)/sizeof(availBasicConfig[0]));
837 EXPECT_TRUE(memcmp(item.data.i32, availBasicConfig, sizeof(availBasicConfig)) == 0);
838 }
839
840 /*
841 * Feature: Metadata
842 * Function: Sensor active array, zoom cap and scene zoom cap tags
843 * SubFunction: NA
844 * FunctionPoints: NA
845 * EnvConditions: NA
846 * CaseDescription: Test operations(add/find) on sensor active array, zoom cap and scene zoom cap tags
847 */
848 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_014, TestSize.Level0)
849 {
850 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(3, 0);
851
852 camera_metadata_item_t item;
853
854 int32_t activeArray[4] = {0, 0, 2000, 1500};
855 bool ret = cameraMetadata->addEntry(OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, activeArray,
856 sizeof(activeArray) / sizeof(activeArray[0]));
857 EXPECT_TRUE(ret == true);
858
859 int32_t zoomCap[] = {100, 600};
860 ret = cameraMetadata->addEntry(OHOS_ABILITY_ZOOM_CAP, zoomCap, sizeof(zoomCap) / sizeof(zoomCap[0]));
861 EXPECT_TRUE(ret == true);
862
863 int32_t zoomSceneCap[] = {100, 1000};
864 ret = cameraMetadata->addEntry(OHOS_ABILITY_SCENE_ZOOM_CAP, zoomSceneCap,
865 sizeof(zoomSceneCap) / sizeof(zoomSceneCap[0]));
866 EXPECT_TRUE(ret == true);
867
868 common_metadata_header_t *metadata = cameraMetadata->get();
869 ASSERT_NE(metadata, nullptr);
870
871 int32_t result = FindCameraMetadataItem(metadata, OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, &item);
872 EXPECT_TRUE(result == CAM_META_SUCCESS);
873 EXPECT_TRUE(item.index == 0);
874 EXPECT_TRUE(item.item == OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
875 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
876 EXPECT_TRUE(item.count == sizeof(activeArray)/sizeof(activeArray[0]));
877 EXPECT_TRUE(memcmp(item.data.i32, activeArray, sizeof(activeArray)) == 0);
878
879 result = FindCameraMetadataItem(metadata, OHOS_ABILITY_ZOOM_CAP, &item);
880 EXPECT_TRUE(result == CAM_META_SUCCESS);
881 EXPECT_TRUE(item.index == 1);
882 EXPECT_TRUE(item.item == OHOS_ABILITY_ZOOM_CAP);
883 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
884 EXPECT_TRUE(item.count == sizeof(zoomCap)/sizeof(zoomCap[0]));
885 EXPECT_TRUE(memcmp(item.data.i32, zoomCap, sizeof(zoomCap)) == 0);
886
887 result = FindCameraMetadataItem(metadata, OHOS_ABILITY_SCENE_ZOOM_CAP, &item);
888 EXPECT_TRUE(result == CAM_META_SUCCESS);
889 EXPECT_TRUE(item.index == 2);
890 EXPECT_TRUE(item.item == OHOS_ABILITY_SCENE_ZOOM_CAP);
891 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
892 EXPECT_TRUE(item.count == sizeof(zoomSceneCap)/sizeof(zoomSceneCap[0]));
893 EXPECT_TRUE(memcmp(item.data.i32, zoomSceneCap, sizeof(zoomSceneCap)) == 0);
894 }
895
896 /*
897 * Feature: Metadata
898 * Function: Crop region tag
899 * SubFunction: NA
900 * FunctionPoints: NA
901 * EnvConditions: NA
902 * CaseDescription: Test operations(add/find) on crop region tag
903 */
904 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_015, TestSize.Level0)
905 {
906 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(1, 0);
907
908 camera_metadata_item_t item;
909
910 int32_t cropRegion[4] = {0, 0, 2000, 1500};
911 bool ret = cameraMetadata->addEntry(OHOS_CONTROL_ZOOM_CROP_REGION, cropRegion,
912 sizeof(cropRegion) / sizeof(cropRegion[0]));
913 EXPECT_TRUE(ret == true);
914
915 common_metadata_header_t *metadata = cameraMetadata->get();
916 ASSERT_NE(metadata, nullptr);
917
918 int32_t result = FindCameraMetadataItem(metadata, OHOS_CONTROL_ZOOM_CROP_REGION, &item);
919 EXPECT_TRUE(result == CAM_META_SUCCESS);
920 EXPECT_TRUE(item.index == 0);
921 EXPECT_TRUE(item.item == OHOS_CONTROL_ZOOM_CROP_REGION);
922 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
923 EXPECT_TRUE(item.count == sizeof(cropRegion) / sizeof(cropRegion[0]));
924 EXPECT_TRUE(memcmp(item.data.i32, cropRegion, sizeof(cropRegion)) == 0);
925 }
926
927 /*
928 * Feature: Metadata
929 * Function: Auto focus trigger and trigger Id
930 * SubFunction: NA
931 * FunctionPoints: NA
932 * EnvConditions: NA
933 * CaseDescription: Test operations(add/find) on auto focus trigger and trigger Id tags
934 */
935 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_016, TestSize.Level0)
936 {
937 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(2, 0);
938 camera_metadata_item_t item;
939
940 uint8_t trigger = OHOS_CAMERA_AF_TRIGGER_START;
941 bool ret = cameraMetadata->addEntry(OHOS_CONTROL_AF_TRIGGER, &trigger, 1);
942 EXPECT_TRUE(ret == true);
943
944 int32_t triggerId = 10;
945 ret = cameraMetadata->addEntry(OHOS_CONTROL_AF_TRIGGER_ID, &triggerId, 1);
946 EXPECT_TRUE(ret == true);
947
948 common_metadata_header_t *metadata = cameraMetadata->get();
949 ASSERT_NE(metadata, nullptr);
950
951 int32_t result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AF_TRIGGER, &item);
952 EXPECT_TRUE(result == CAM_META_SUCCESS);
953 EXPECT_TRUE(item.index == 0);
954 EXPECT_TRUE(item.item == OHOS_CONTROL_AF_TRIGGER);
955 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
956 EXPECT_TRUE(item.count == 1);
957 EXPECT_TRUE(item.data.u8[0] == trigger);
958
959 result = FindCameraMetadataItem(metadata, OHOS_CONTROL_AF_TRIGGER_ID, &item);
960 EXPECT_TRUE(result == CAM_META_SUCCESS);
961 EXPECT_TRUE(item.index == 1);
962 EXPECT_TRUE(item.item == OHOS_CONTROL_AF_TRIGGER_ID);
963 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
964 EXPECT_TRUE(item.count == 1);
965 EXPECT_TRUE(item.data.i32[0] == triggerId);
966 }
967
968 /*
969 * Feature: Metadata
970 * Function: JPEG quality
971 * SubFunction: NA
972 * FunctionPoints: NA
973 * EnvConditions: NA
974 * CaseDescription: Test operations(add/update/find) on JPEG quality tag
975 */
976 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_017, TestSize.Level0)
977 {
978 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(1, 0);
979 camera_metadata_item_t item;
980
981 uint8_t quality = 100;
982 bool ret = cameraMetadata->addEntry(OHOS_JPEG_QUALITY, &quality, 1);
983 EXPECT_TRUE(ret == true);
984
985 common_metadata_header_t *metadata = cameraMetadata->get();
986 ASSERT_NE(metadata, nullptr);
987
988 int32_t result = FindCameraMetadataItem(metadata, OHOS_JPEG_QUALITY, &item);
989 EXPECT_TRUE(result == CAM_META_SUCCESS);
990 EXPECT_TRUE(item.index == 0);
991 EXPECT_TRUE(item.item == OHOS_JPEG_QUALITY);
992 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
993 EXPECT_TRUE(item.count == 1);
994 EXPECT_TRUE(item.data.u8[0] == quality);
995
996 quality = 90;
997 ret = cameraMetadata->updateEntry(OHOS_JPEG_QUALITY, &quality, 1);
998 EXPECT_TRUE(ret == true);
999
1000 result = FindCameraMetadataItem(metadata, OHOS_JPEG_QUALITY, &item);
1001 EXPECT_TRUE(result == CAM_META_SUCCESS);
1002 EXPECT_TRUE(item.index == 0);
1003 EXPECT_TRUE(item.item == OHOS_JPEG_QUALITY);
1004 EXPECT_TRUE(item.data_type == META_TYPE_BYTE);
1005 EXPECT_TRUE(item.count == 1);
1006 EXPECT_TRUE(item.data.u8[0] == quality);
1007 }
1008
1009 /*
1010 * Feature: Metadata
1011 * Function: JPEG orientation
1012 * SubFunction: NA
1013 * FunctionPoints: NA
1014 * EnvConditions: NA
1015 * CaseDescription: Test operations(add/update/find) on JPEG orientation tag
1016 */
1017 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_018, TestSize.Level0)
1018 {
1019 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(1, 0);
1020 camera_metadata_item_t item;
1021
1022 int32_t orientation = 0;
1023 bool ret = cameraMetadata->addEntry(OHOS_JPEG_ORIENTATION, &orientation, 1);
1024 EXPECT_TRUE(ret == true);
1025
1026 common_metadata_header_t *metadata = cameraMetadata->get();
1027 ASSERT_NE(metadata, nullptr);
1028
1029 int32_t result = FindCameraMetadataItem(metadata, OHOS_JPEG_ORIENTATION, &item);
1030 EXPECT_TRUE(result == CAM_META_SUCCESS);
1031 EXPECT_TRUE(item.index == 0);
1032 EXPECT_TRUE(item.item == OHOS_JPEG_ORIENTATION);
1033 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
1034 EXPECT_TRUE(item.count == 1);
1035 EXPECT_TRUE(item.data.i32[0] == orientation);
1036
1037 orientation = 90;
1038 ret = cameraMetadata->updateEntry(OHOS_JPEG_ORIENTATION, &orientation, 1);
1039 EXPECT_TRUE(ret == true);
1040
1041 result = FindCameraMetadataItem(metadata, OHOS_JPEG_ORIENTATION, &item);
1042 EXPECT_TRUE(result == CAM_META_SUCCESS);
1043 EXPECT_TRUE(item.index == 0);
1044 EXPECT_TRUE(item.item == OHOS_JPEG_ORIENTATION);
1045 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
1046 EXPECT_TRUE(item.count == 1);
1047 EXPECT_TRUE(item.data.i32[0] == orientation);
1048
1049 orientation = 180;
1050 ret = cameraMetadata->updateEntry(OHOS_JPEG_ORIENTATION, &orientation, 1);
1051 EXPECT_TRUE(ret == true);
1052
1053 result = FindCameraMetadataItem(metadata, OHOS_JPEG_ORIENTATION, &item);
1054 EXPECT_TRUE(result == CAM_META_SUCCESS);
1055 EXPECT_TRUE(item.index == 0);
1056 EXPECT_TRUE(item.item == OHOS_JPEG_ORIENTATION);
1057 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
1058 EXPECT_TRUE(item.count == 1);
1059 EXPECT_TRUE(item.data.i32[0] == orientation);
1060
1061 orientation = 270;
1062 ret = cameraMetadata->updateEntry(OHOS_JPEG_ORIENTATION, &orientation, 1);
1063 EXPECT_TRUE(ret == true);
1064
1065 result = FindCameraMetadataItem(metadata, OHOS_JPEG_ORIENTATION, &item);
1066 EXPECT_TRUE(result == CAM_META_SUCCESS);
1067 EXPECT_TRUE(item.index == 0);
1068 EXPECT_TRUE(item.item == OHOS_JPEG_ORIENTATION);
1069 EXPECT_TRUE(item.data_type == META_TYPE_INT32);
1070 EXPECT_TRUE(item.count == 1);
1071 EXPECT_TRUE(item.data.i32[0] == orientation);
1072 }
1073
1074 /*
1075 * Feature: Metadata
1076 * Function: EncodeToString and DecodeFromString
1077 * SubFunction: NA
1078 * FunctionPoints: NA
1079 * EnvConditions: NA
1080 * CaseDescription: Test EncodeToString and DecodeFromString metadata object without data at the end of metadata items
1081 */
1082 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_019, TestSize.Level0)
1083 {
1084 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(1, 0);
1085
1086 uint8_t cameraPosition = OHOS_CAMERA_POSITION_BACK;
1087 bool ret = cameraMetadata->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
1088 EXPECT_TRUE(ret == true);
1089
1090 common_metadata_header_t *metadata = cameraMetadata->get();
1091 ASSERT_NE(metadata, nullptr);
1092
1093 // Encode camera metadata
1094 std::string metadataString = MetadataUtils::EncodeToString(cameraMetadata);
1095 EXPECT_TRUE(!metadataString.empty());
1096
1097 // Decode camera metadata
1098 std::shared_ptr<CameraMetadata> decodedMetadata = MetadataUtils::DecodeFromString(metadataString);
1099 ASSERT_NE(decodedMetadata, nullptr);
1100 ASSERT_NE(decodedMetadata->get(), nullptr);
1101
1102 // validate metadata
1103 EXPECT_TRUE(memcmp(decodedMetadata->get(), metadata, sizeof(common_metadata_header_t)) == 0);
1104 camera_metadata_item_entry_t *encodedItem = GetMetadataItems(metadata);
1105 camera_metadata_item_entry_t *decodedItem = GetMetadataItems(decodedMetadata->get());
1106 int32_t itemLen = sizeof(camera_metadata_item_entry_t);
1107 int32_t itemFixedLen = offsetof(camera_metadata_item_entry_t, data);
1108 EXPECT_TRUE(metadata->item_count == 1);
1109 EXPECT_TRUE(metadata->data_count == 0);
1110 EXPECT_TRUE(decodedMetadata->get()->data_count == metadata->data_count);
1111 EXPECT_TRUE(memcmp(decodedItem, encodedItem, itemFixedLen) == 0);
1112 EXPECT_TRUE(memcmp(&(decodedItem->data), &(encodedItem->data), itemLen - itemFixedLen) == 0);
1113 }
1114
1115 /*
1116 * Feature: Metadata
1117 * Function: EncodeToString and DecodeFromString
1118 * SubFunction: NA
1119 * FunctionPoints: NA
1120 * EnvConditions: NA
1121 * CaseDescription: Test EncodeToString and DecodeFromString metadata object with data at the end of metadata items
1122 */
1123 HWTEST_F(CameraMetadataUnitTest, camera_metadata_unittest_020, TestSize.Level0)
1124 {
1125 std::shared_ptr<CameraMetadata> cameraMetadata = std::make_shared<CameraMetadata>(3, 24);
1126
1127 int32_t activeArray[4] = {0, 0, 2000, 1500};
1128 bool ret = cameraMetadata->addEntry(OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, activeArray,
1129 sizeof(activeArray) / sizeof(activeArray[0]));
1130 EXPECT_TRUE(ret == true);
1131
1132 uint8_t connectionType = OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN;
1133 ret = cameraMetadata->addEntry(OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &connectionType, 1);
1134 EXPECT_TRUE(ret == true);
1135
1136 int32_t zoomCap[] = {100, 600};
1137 ret = cameraMetadata->addEntry(OHOS_ABILITY_ZOOM_CAP, zoomCap, sizeof(zoomCap) / sizeof(zoomCap[0]));
1138 EXPECT_TRUE(ret == true);
1139
1140 common_metadata_header_t *metadata = cameraMetadata->get();
1141 ASSERT_NE(metadata, nullptr);
1142
1143 // Encode camera metadata
1144 std::string metadataString = MetadataUtils::EncodeToString(cameraMetadata);
1145 EXPECT_TRUE(!metadataString.empty());
1146
1147 // Decode camera metadata
1148 std::shared_ptr<CameraMetadata> decodedMetadata = MetadataUtils::DecodeFromString(metadataString);
1149 ASSERT_NE(decodedMetadata, nullptr);
1150 ASSERT_NE(decodedMetadata->get(), nullptr);
1151
1152 // validate metadata
1153 EXPECT_TRUE(memcmp(decodedMetadata->get(), metadata, sizeof(common_metadata_header_t)) == 0);
1154 camera_metadata_item_entry_t *encodedItem = GetMetadataItems(metadata);
1155 camera_metadata_item_entry_t *decodedItem = GetMetadataItems(decodedMetadata->get());
1156 int32_t itemLen = sizeof(camera_metadata_item_entry_t);
1157 int32_t itemFixedLen = offsetof(camera_metadata_item_entry_t, data);
1158 for (uint32_t index = 0; index < metadata->item_count; index++, encodedItem++, decodedItem++) {
1159 EXPECT_TRUE(memcmp(decodedItem, encodedItem, itemFixedLen) == 0);
1160 EXPECT_TRUE(memcmp(&(decodedItem->data), &(encodedItem->data), itemLen - itemFixedLen) == 0);
1161 }
1162 EXPECT_TRUE(decodedMetadata->get()->data_count == metadata->data_count);
1163 EXPECT_TRUE(memcmp(GetMetadataData(decodedMetadata->get()), GetMetadataData(metadata), metadata->data_count) == 0);
1164 }
1165 } // Camera
1166