1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "usb_camera_3a_test.h"
17 
18 const TestMetadata CAMERA_3A_TEST_SETS[] = {
19     // test OHOS_CONTROL_EXPOSURE_MODE
20     {
21         .tag =OHOS_CONTROL_EXPOSURE_MODE,
22         .value = OHOS_CAMERA_EXPOSURE_MODE_MANUAL
23     },
24     {
25         .tag =OHOS_CONTROL_EXPOSURE_MODE,
26         .value = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO
27     },
28     {
29         .tag =OHOS_CONTROL_EXPOSURE_MODE,
30         .value = OHOS_CAMERA_EXPOSURE_MODE_AUTO
31     },
32     // test OHOS_CONTROL_AE_LOCK
33     {
34         .tag =OHOS_CONTROL_AE_LOCK,
35         .value = OHOS_CAMERA_AE_LOCK_ON
36     },
37     {
38         .tag =OHOS_CONTROL_AE_LOCK,
39         .value = OHOS_CAMERA_AE_LOCK_OFF
40     },
41 
42     // test OHOS_CONTROL_FOCUS_MODE
43     {
44         .tag =OHOS_CONTROL_FOCUS_MODE,
45         .value = OHOS_CAMERA_FOCUS_MODE_CONTINUOUS_AUTO
46     },
47     {
48         .tag =OHOS_CONTROL_FOCUS_MODE,
49         .value = OHOS_CAMERA_FOCUS_MODE_MANUAL
50     },
51     {
52         .tag =OHOS_CONTROL_FOCUS_MODE,
53         .value = OHOS_CAMERA_FOCUS_MODE_AUTO
54     },
55     {
56         .tag =OHOS_CONTROL_FOCUS_MODE,
57         .value = OHOS_CAMERA_FOCUS_MODE_LOCKED
58     },
59     // test OHOS_CONTROL_METER_MODE
60     {
61         .tag =OHOS_CONTROL_METER_MODE,
62         .value = OHOS_CAMERA_SPOT_METERING
63     },
64     {
65         .tag =OHOS_CONTROL_METER_MODE,
66         .value = OHOS_CAMERA_OVERALL_METERING
67     },
68 
69     // test OHOS_CONTROL_AWB_MODE
70     {
71         .tag =OHOS_CONTROL_AWB_MODE,
72         .value = OHOS_CAMERA_AWB_MODE_AUTO
73     },
74     {
75         .tag =OHOS_CONTROL_AWB_MODE,
76         .value = OHOS_CAMERA_AWB_MODE_OFF
77     },
78     {
79         .tag =OHOS_CONTROL_AWB_MODE,
80         .value = OHOS_CAMERA_AWB_MODE_INCANDESCENT
81     },
82     {
83         .tag =OHOS_CONTROL_AWB_MODE,
84         .value = OHOS_CAMERA_AWB_MODE_FLUORESCENT
85     },
86     {
87         .tag =OHOS_CONTROL_AWB_MODE,
88         .value = OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT
89     },
90     {
91         .tag =OHOS_CONTROL_AWB_MODE,
92         .value = OHOS_CAMERA_AWB_MODE_TWILIGHT
93     },
94     {
95         .tag =OHOS_CONTROL_AWB_MODE,
96         .value = OHOS_CAMERA_AWB_MODE_DAYLIGHT
97     },
98     {
99         .tag =OHOS_CONTROL_AWB_MODE,
100         .value = OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT
101     },
102     {
103         .tag =OHOS_CONTROL_AWB_MODE,
104         .value = OHOS_CAMERA_AWB_MODE_SHADE
105     },
106 
107     // test OHOS_CONTROL_AWB_LOCK
108     {
109         .tag =OHOS_CONTROL_AWB_LOCK,
110         .value = OHOS_CAMERA_AWB_LOCK_ON
111     },
112     {
113         .tag =OHOS_CONTROL_AWB_LOCK,
114         .value = OHOS_CAMERA_AWB_LOCK_OFF
115     }
116 };
117 
SetUpTestCase(void)118 void UtestUSBCamera3ATest::SetUpTestCase(void)
119 {}
120 
TearDownTestCase(void)121 void UtestUSBCamera3ATest::TearDownTestCase(void)
122 {}
123 
SetUp(void)124 void UtestUSBCamera3ATest::SetUp(void)
125 {
126     if (cameraBase_ == nullptr)
127     cameraBase_ = std::make_shared<TestCameraBase>();
128     cameraBase_->UsbInit();
129 }
130 
TearDown(void)131 void UtestUSBCamera3ATest::TearDown(void)
132 {
133     cameraBase_->Close();
134 }
135 
RunCamera3AWithCapture(TestMetadata & metadata)136 bool UtestUSBCamera3ATest::RunCamera3AWithCapture(TestMetadata& metadata)
137 {
138     // Get the device manager
139     cameraBase_->OpenUsbCamera();
140     ability_ = cameraBase_->GetCameraAbility();
141     EXPECT_NE(ability_, nullptr);
142 
143     // Get the stream manager
144     cameraBase_->AchieveStreamOperator();
145 
146     // start stream
147     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
148     cameraBase_->StartStream(cameraBase_->intents);
149 
150     // updateSettings
151     const uint32_t itemCapacity = 100;
152     const uint32_t dataCapacity = 2000;
153     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
154         itemCapacity, dataCapacity);
155 
156     int ohosTag = metadata.tag;
157     const uint8_t tagVal = metadata.value;
158     if (!meta->addEntry(ohosTag, &tagVal, 1)) {
159         std::cout << GetCameraMetadataItemName(ohosTag) << " tag(" << ohosTag << ") value(" <<
160             static_cast<int>(tagVal) << ") add failed" << std::endl;
161         return false;
162     }
163     std::cout << GetCameraMetadataItemName(ohosTag) << " tag(" << ohosTag << ") value(" << static_cast<int>(tagVal) <<
164         ") add succesed" << std::endl;
165     const int32_t deviceStreamId = 0;
166     meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
167     std::vector<uint8_t> setting;
168     MetadataUtils::ConvertMetadataToVec(meta, setting);
169     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
170     if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
171         std::cout << "UpdateSettings (" << ohosTag << ")" << " success" << std::endl;
172     } else {
173         std::cout << "UpdateSettings (" << ohosTag << ")" << " fail" << std::endl;
174         return false;
175     }
176 
177     // Get preview
178     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
179     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
180     // release stream
181     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
182     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
183     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
184     return cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR;
185 }
186 
RunCamera3AWithVideo(TestMetadata & metadata)187 bool UtestUSBCamera3ATest::RunCamera3AWithVideo(TestMetadata& metadata)
188 {
189     // Get the device manager
190     cameraBase_->OpenUsbCamera();
191     ability_ = cameraBase_->GetCameraAbility();
192     EXPECT_NE(ability_, nullptr);
193 
194     // Get the stream manager
195     cameraBase_->AchieveStreamOperator();
196 
197     // start stream
198     cameraBase_->intents = {PREVIEW, VIDEO};
199     cameraBase_->StartStream(cameraBase_->intents);
200 
201     // updateSettings
202     const uint32_t itemCapacity = 100;
203     const uint32_t dataCapacity = 2000;
204     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
205         itemCapacity, dataCapacity);
206 
207     int ohosTag = metadata.tag;
208     const uint8_t tagVal = metadata.value;
209     if (!meta->addEntry(ohosTag, &tagVal, 1)) {
210         std::cout << GetCameraMetadataItemName(ohosTag) << "tag(" << ohosTag << ") value(" <<
211             static_cast<int>(tagVal) << ") add failed" << std::endl;
212         return false;
213     }
214     std::cout << GetCameraMetadataItemName(ohosTag) << "tag(" << ohosTag << ") value(" << static_cast<int>(tagVal) <<
215         ") add succesed" << std::endl;
216     const int32_t deviceStreamId = 0;
217     meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
218     std::vector<uint8_t> setting;
219     MetadataUtils::ConvertMetadataToVec(meta, setting);
220     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
221     if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
222         std::cout << "UpdateSettings (" << ohosTag << ")" << " success" << std::endl;
223     } else {
224         std::cout << "UpdateSettings (" << ohosTag << ")" << " fail" << std::endl;
225         return false;
226     }
227 
228     // get preview
229     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
230     cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
231 
232     // release stream
233     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
234     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
235     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
236     return cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR;
237 }
238 
TEST_P(UtestUSBCamera3ATest,CaptureTest)239 TEST_P(UtestUSBCamera3ATest, CaptureTest)
240 {
241     TestMetadata params = GetParam();
242     bool ret = RunCamera3AWithCapture(params);
243     EXPECT_EQ(ret, true);
244 }
245 
TEST_P(UtestUSBCamera3ATest,VideoTest)246 TEST_P(UtestUSBCamera3ATest, VideoTest)
247 {
248     TestMetadata params = GetParam();
249     bool ret = RunCamera3AWithVideo(params);
250     EXPECT_EQ(ret, true);
251 }
252 
253 INSTANTIATE_TEST_SUITE_P(Test3A, UtestUSBCamera3ATest, ::testing::ValuesIn(CAMERA_3A_TEST_SETS));
254 
255 /**
256   * @tc.name: USB Camera 3A
257   * @tc.desc: set OHOS_SENSOR_EXPOSURE_TIME
258   * @tc.level: Level0
259   * @tc.size: MediumTest
260   * @tc.type: Function
261   */
TEST_F(UtestUSBCamera3ATest,usb_camera_3a_001)262 TEST_F(UtestUSBCamera3ATest, usb_camera_3a_001)
263 {
264     cameraBase_->OpenUsbCamera();
265     ability_ = cameraBase_->GetCameraAbility();
266     EXPECT_NE(ability_, nullptr);
267 
268     cameraBase_->AchieveStreamOperator();
269     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
270     cameraBase_->StartStream(cameraBase_->intents);
271 
272     const uint32_t itemCapacity = 100;
273     const uint32_t dataCapacity = 2000;
274     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(itemCapacity, dataCapacity);
275 
276     int ohosTag = OHOS_SENSOR_EXPOSURE_TIME;
277     const int tagVal = 100;
278     if (!meta->addEntry(ohosTag, &tagVal, 1)) {
279         GTEST_SKIP();
280     }
281     const int32_t deviceStreamId = 0;
282     meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
283     std::vector<uint8_t> setting;
284     MetadataUtils::ConvertMetadataToVec(meta, setting);
285     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
286     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR) {
287         GTEST_SKIP();
288     }
289 
290     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
291     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
292     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
293     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
294     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
295     EXPECT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
296 }
297 
298 /**
299   * @tc.name: USB Camera 3A
300   * @tc.desc: set OHOS_CAMERA_SPOT_METERING first, then set OHOS_CAMERA_REGION_METERING
301   * @tc.level: Level0
302   * @tc.size: MediumTest
303   * @tc.type: Function
304   */
TEST_F(UtestUSBCamera3ATest,usb_camera_3a_002)305 TEST_F(UtestUSBCamera3ATest, usb_camera_3a_002)
306 {
307     cameraBase_->OpenUsbCamera();
308     ability_ = cameraBase_->GetCameraAbility();
309     EXPECT_NE(ability_, nullptr);
310 
311     cameraBase_->AchieveStreamOperator();
312     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
313     cameraBase_->StartStream(cameraBase_->intents);
314 
315     const uint32_t itemCapacity = 100;
316     const uint32_t dataCapacity = 2000;
317     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
318         itemCapacity, dataCapacity);
319 
320     int ohosTag = OHOS_CONTROL_METER_MODE;
321     uint8_t tagVal = OHOS_CAMERA_OVERALL_METERING;
322     if (!meta->addEntry(ohosTag, &tagVal, 1)) {
323         GTEST_SKIP();
324     }
325 
326     const int32_t deviceStreamId = 0;
327     meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
328     std::vector<uint8_t> setting;
329     MetadataUtils::ConvertMetadataToVec(meta, setting);
330     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
331     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR) {
332         GTEST_SKIP();
333     }
334 
335     tagVal = OHOS_CAMERA_REGION_METERING;
336     std::vector<uint8_t> valVector;
337     valVector.push_back(tagVal);
338     if (!meta->updateEntry(ohosTag, valVector.data(), valVector.size())) {
339         CAMERA_LOGE("update %{public}s failed", GetCameraMetadataItemName(ohosTag));
340     }
341 
342     setting.clear();
343     MetadataUtils::ConvertMetadataToVec(meta, setting);
344     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
345     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR) {
346         GTEST_SKIP();
347     }
348 
349     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
350     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
351     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
352     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
353     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
354     EXPECT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
355 }
356 
357 /**
358   * @tc.name: USB Camera 3A
359   * @tc.desc: set OHOS_CONTROL_AE_LOCK first, then set OHOS_CAMERA_EXPOSURE_MODE_LOCKED
360   * @tc.level: Level0
361   * @tc.size: MediumTest
362   * @tc.type: Function
363   */
TEST_F(UtestUSBCamera3ATest,usb_camera_3a_003)364 TEST_F(UtestUSBCamera3ATest, usb_camera_3a_003)
365 {
366     cameraBase_->OpenUsbCamera();
367     ability_ = cameraBase_->GetCameraAbility();
368     EXPECT_NE(ability_, nullptr);
369 
370     cameraBase_->AchieveStreamOperator();
371     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
372     cameraBase_->StartStream(cameraBase_->intents);
373 
374     const uint32_t itemCapacity = 100;
375     const uint32_t dataCapacity = 2000;
376     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(itemCapacity, dataCapacity);
377 
378     int ohosTag = OHOS_CONTROL_AE_LOCK;
379     const uint8_t tagVal = OHOS_CAMERA_AE_LOCK_OFF;
380     if (!meta->addEntry(ohosTag, &tagVal, 1)) {
381         GTEST_SKIP();
382     }
383 
384     const int32_t deviceStreamId = 0;
385     meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
386     std::vector<uint8_t> setting;
387     MetadataUtils::ConvertMetadataToVec(meta, setting);
388     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
389     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR) {
390         GTEST_SKIP();
391     }
392 
393     ohosTag = OHOS_CONTROL_EXPOSURE_MODE;
394     const uint8_t newTagVal = OHOS_CAMERA_EXPOSURE_MODE_LOCKED;
395     if (!meta->addEntry(ohosTag, &newTagVal, 1)) {
396         GTEST_SKIP();
397     }
398 
399     setting.clear();
400     MetadataUtils::ConvertMetadataToVec(meta, setting);
401     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
402     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR) {
403         GTEST_SKIP();
404     }
405 
406     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
407     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
408     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
409     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
410     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
411     EXPECT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
412 }
413 
414 /**
415   * @tc.name: USB Camera 3A
416   * @tc.desc: set OHOS_CAMERA_FOCUS_MODE_CONTINUOUS_AUTO first, then set OHOS_CAMERA_FOCUS_MODE_MANUAL
417   * @tc.level: Level0
418   * @tc.size: MediumTest
419   * @tc.type: Function
420   */
TEST_F(UtestUSBCamera3ATest,usb_camera_3a_004)421 TEST_F(UtestUSBCamera3ATest, usb_camera_3a_004)
422 {
423     cameraBase_->OpenUsbCamera();
424     ability_ = cameraBase_->GetCameraAbility();
425     EXPECT_NE(ability_, nullptr);
426 
427     cameraBase_->AchieveStreamOperator();
428     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
429     cameraBase_->StartStream(cameraBase_->intents);
430 
431     const uint32_t itemCapacity = 100;
432     const uint32_t dataCapacity = 2000;
433     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
434         itemCapacity, dataCapacity);
435 
436     int ohosTag = OHOS_CONTROL_FOCUS_MODE;
437     uint8_t tagVal = OHOS_CAMERA_FOCUS_MODE_CONTINUOUS_AUTO;
438     if (!meta->addEntry(ohosTag, &tagVal, 1)) {
439         GTEST_SKIP();
440     }
441 
442     const int32_t deviceStreamId = 0;
443     meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
444     std::vector<uint8_t> setting;
445     MetadataUtils::ConvertMetadataToVec(meta, setting);
446     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
447     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR) {
448         GTEST_SKIP();
449     }
450 
451     tagVal = OHOS_CAMERA_FOCUS_MODE_MANUAL;
452     std::vector<uint8_t> valVector;
453     valVector.push_back(tagVal);
454     if (!meta->updateEntry(ohosTag, valVector.data(), valVector.size())) {
455         CAMERA_LOGE("update %{public}s failed", GetCameraMetadataItemName(ohosTag));
456     }
457 
458     setting.clear();
459     MetadataUtils::ConvertMetadataToVec(meta, setting);
460     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
461     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR) {
462         GTEST_SKIP();
463     }
464 
465     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
466     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
467     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
468     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
469     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
470     EXPECT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
471 }