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