1 /*
2 * Copyright (c) 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 #include "camera_video_test.h"
16
17 using namespace testing::ext;
18
SetUpTestCase(void)19 void CameraVideoTest::SetUpTestCase(void)
20 {}
TearDownTestCase(void)21 void CameraVideoTest::TearDownTestCase(void)
22 {}
SetUp(void)23 void CameraVideoTest::SetUp(void)
24 {
25 if (display_ == nullptr)
26 display_ = std::make_shared<TestDisplay>();
27 display_->Init();
28 }
TearDown(void)29 void CameraVideoTest::TearDown(void)
30 {
31 display_->Close();
32 }
33
34 /**
35 * @tc.name: Video
36 * @tc.desc: Preview + video, commit together, success.
37 * @tc.level: Level1
38 * @tc.size: MediumTest
39 * @tc.type: Function
40 */
41 HWTEST_F(CameraVideoTest, SUB_DriverSystem_CameraHdi_0250, TestSize.Level1)
42 {
43 std::cout << "==========[test log] 1 Preview + video, commit together, success." << std::endl;
44 // Create and get streamOperator information
45 display_->AchieveStreamOperator();
46 // start stream
47 display_->intents = {PREVIEW, VIDEO};
48 display_->StartStream(display_->intents);
49 // Get preview
50 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
51 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
52
53 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
54 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
55 display_->StopStream(display_->captureIds, display_->streamIds);
56 }
57
58 /**
59 * @tc.name: Video
60 * @tc.desc: Preview + video, commit together, set 3A, success.
61 * @tc.level: Level1
62 * @tc.size: MediumTest
63 * @tc.type: Function
64 */
65 HWTEST_F(CameraVideoTest, SUB_DriverSystem_CameraHdi_0260, TestSize.Level1)
66 {
67 std::cout << "==========[test log] Preview + video, commit together, set 3A, success." << std::endl;
68 // Create and get streamOperator information
69 display_->AchieveStreamOperator();
70
71 // start stream
72 display_->intents = {PREVIEW, VIDEO};
73 display_->StartStream(display_->intents);
74 // Get preview
75 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
76 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
77 // Issue 3A parameters to increase exposure
78 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 2000);
79 int32_t expo = 0xa0;
80 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
81 std::vector<uint8_t> setting;
82 MetadataUtils::ConvertMetadataToVec(meta, setting);
83 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
84 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
85 std::cout << "==========[test log] UpdateSettings success, for 5s." << std::endl;
86 } else {
87 std::cout << "==========[test log] UpdateSettings fail, rc = " << display_->rc << std::endl;
88 }
89 sleep(3);
90
91 // release stream
92 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
93 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
94 display_->StopStream(display_->captureIds, display_->streamIds);
95 }
96
97 /**
98 * @tc.name: Video
99 * @tc.desc: Preview + video, commit together, then close device, and preview + video again.
100 * @tc.level: Level1
101 * @tc.size: MediumTest
102 * @tc.type: Function
103 */
104 HWTEST_F(CameraVideoTest, SUB_DriverSystem_CameraHdi_0270, TestSize.Level1)
105 {
106 std::cout << "==========[test log] Preview + video, commit together, then close device,";
107 std::cout << "and preview + video again." << std::endl;
108 // Create and get streamOperator information
109 display_->AchieveStreamOperator();
110 // start stream
111 display_->intents = {PREVIEW, VIDEO};
112 display_->StartStream(display_->intents);
113 // Get preview
114 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
115 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
116 // release stream
117 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
118 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
119 display_->StopStream(display_->captureIds, display_->streamIds);
120
121 // Turn off the device
122 display_->Close();
123 // Turn on the device
124 display_->Init();
125 std::cout << "==========[test log] The 2nd time." << std::endl;
126
127 // Create and get streamOperator information
128 display_->AchieveStreamOperator();
129 // start stream
130 display_->intents = {PREVIEW, VIDEO};
131 display_->StartStream(display_->intents);
132 // Get preview
133 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
134 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
135 // release stream
136 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
137 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
138 display_->StopStream(display_->captureIds, display_->streamIds);
139 }
140
141 /**
142 * @tc.name: Video
143 * @tc.desc: Preview + video, commit together, then close device, and preview + capture.
144 * @tc.level: Level1
145 * @tc.size: MediumTest
146 * @tc.type: Function
147 */
148 HWTEST_F(CameraVideoTest, SUB_DriverSystem_CameraHdi_0280, TestSize.Level1)
149 {
150 std::cout << "==========[test log] Preview + video, commit together, then close device,";
151 std::cout << "and preview + capture." << std::endl;
152 // Create and get streamOperator information
153 display_->AchieveStreamOperator();
154 // start stream
155 display_->intents = {PREVIEW, VIDEO};
156 display_->StartStream(display_->intents);
157 // Get preview
158 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
159 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
160 // release stream
161 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
162 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
163 display_->StopStream(display_->captureIds, display_->streamIds);
164
165 // Turn off the device
166 display_->Close();
167 std::cout << "==========[test log] cameraDevice->Close" << std::endl;
168 // Turn on the device
169 display_->Init();
170
171 // Create and get streamOperator information
172 display_->AchieveStreamOperator();
173 // start stream
174 display_->intents = {PREVIEW, STILL_CAPTURE};
175 display_->StartStream(display_->intents);
176 // Get preview
177 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
178 display_->StartCapture(display_->streamId_capture, display_->captureId_capture, false, true);
179 // release stream
180 display_->captureIds = {display_->captureId_preview, display_->captureId_capture};
181 display_->streamIds = {display_->streamId_preview, display_->streamId_capture};
182 display_->StopStream(display_->captureIds, display_->streamIds);
183 }
184
185 /**
186 * @tc.name: Video
187 * @tc.desc: Preview + video, commit together, success.
188 * @tc.level: Level1
189 * @tc.size: MediumTest
190 * @tc.type: Function
191 */
192 HWTEST_F(CameraVideoTest, camera_video_005, TestSize.Level1)
193 {
194 std::cout << "==========[test log] 1 Preview + video, commit together, success." << std::endl;
195 // Create and get streamOperator information
196 display_->AchieveStreamOperator();
197 // start stream
198 display_->intents = {PREVIEW, VIDEO};
199 display_->StartStream(display_->intents);
200 // Get preview
201 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
202 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
203 // release stream
204 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
205 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
206 display_->StopStream(display_->captureIds, display_->streamIds);
207 }
208
209 /**
210 * @tc.name: Video
211 * @tc.desc: Video start&stop, for 5 times, success.
212 * @tc.level: Level2
213 * @tc.size: MediumTest
214 * @tc.type: Function
215 */
216 HWTEST_F(CameraVideoTest, camera_video_010, TestSize.Level2)
217 {
218 std::cout << "==========[test log] Video start&stop, for 5 times, success." << std::endl;
219 // Create and get streamOperator information
220 display_->AchieveStreamOperator();
221 for (int i = 0; i < 5; i++) {
222 // start stream
223 display_->intents = {PREVIEW, VIDEO};
224 display_->StartStream(display_->intents);
225 // Get preview
226 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
227 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
228 // release stream
229 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
230 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
231 display_->StopStream(display_->captureIds, display_->streamIds);
232 }
233 }
234
235 /**
236 * @tc.name: Video
237 * @tc.desc: Video start&stop, for 5 times, success.
238 * @tc.level: Level2
239 * @tc.size: MediumTest
240 * @tc.type: Function
241 */
242 HWTEST_F(CameraVideoTest, camera_video_011, TestSize.Level2)
243 {
244 std::cout << "==========[test log] Video start&stop, for 5 times, success." << std::endl;
245 // Create and get streamOperator information
246 display_->AchieveStreamOperator();
247 for (int i = 0; i < 5; i++) {
248 // start stream
249 display_->intents = {PREVIEW, VIDEO};
250 display_->StartStream(display_->intents);
251
252 // Start capture preview
253 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
254 // Start capture recording
255 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
256
257 // post-processing
258 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
259 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
260 display_->StopStream(display_->captureIds, display_->streamIds);
261 }
262 }
263
264 /**
265 * @tc.name: Video
266 * @tc.desc: Dynamic Video mode, preview, success.
267 * @tc.level: Level2
268 * @tc.size: MediumTest
269 * @tc.type: Function
270 */
271 HWTEST_F(CameraVideoTest, camera_video_020, TestSize.Level2)
272 {
273 std::cout << "==========[test log] Video mode, preview, success." << std::endl;
274 // Create and get streamOperator information
275 display_->AchieveStreamOperator();
276 // Create data stream
277 display_->intents = {PREVIEW};
278 display_->StartStream(display_->intents);
279 // capture
280 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
281 // Create video stream
282 display_->intents = {VIDEO};
283 display_->StartStream(display_->intents);
284 // Start capture preview
285 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
286 // Start capture recording
287 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
288
289 // post-processing
290 display_->streamCustomerPreview_->ReceiveFrameOff();
291 display_->streamCustomerVideo_->ReceiveFrameOff();
292 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->captureId_video);
293 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
294 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
295 std::cout << "==========[test log] CancelCapture success, captureId = ";
296 std::cout << display_->captureId_video << std::endl;
297 } else {
298 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
299 }
300 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->captureId_preview);
301 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
302 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
303 std::cout << "==========[test log] CancelCapture success, captureId = ";
304 std::cout << display_->captureId_preview << std::endl;
305 } else {
306 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
307 }
308 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
309 {display_->streamId_video});
310 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
311 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
312 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
313 } else {
314 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
315 }
316 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
317 {display_->streamId_preview});
318 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
319 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
320 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
321 } else {
322 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
323 }
324 }
325
326 /**
327 * @tc.name: Video
328 * @tc.desc: Video mode, preview, set 3A, success.
329 * @tc.level: Level1
330 * @tc.size: MediumTest
331 * @tc.type: Function
332 */
333 HWTEST_F(CameraVideoTest, camera_video_021, TestSize.Level1)
334 {
335 std::cout << "==========[test log] Video mode, preview, set 3A, success." << std::endl;
336 EXPECT_EQ(true, display_->cameraDevice != nullptr);
337 display_->AchieveStreamOperator();
338 // start stream
339 display_->intents = {PREVIEW, VIDEO};
340 display_->StartStream(display_->intents);
341 // capture
342 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
343 display_->StartCapture(display_->streamId_video, display_->captureId_video, false, true);
344 // Issue 3A parameters to increase exposure
345 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 2000);
346 int32_t expo = 0xa0;
347 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
348 std::vector<uint8_t> setting;
349 MetadataUtils::ConvertMetadataToVec(meta, setting);
350 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
351 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
352 std::cout << "==========[test log] UpdateSettings success, for 5s." << std::endl;
353 } else {
354 std::cout << "==========[test log] UpdateSettings fail, rc = " << display_->rc << std::endl;
355 }
356 sleep(3);
357
358 // post-processing
359 display_->captureIds = {display_->captureId_preview, display_->captureId_video};
360 display_->streamIds = {display_->streamId_preview, display_->streamId_video};
361 display_->StopStream(display_->captureIds, display_->streamIds);
362 }
363
364 /**
365 * @tc.name: Video
366 * @tc.desc: Video mode without preview, system not support, expected return fail.
367 * @tc.level: Level2
368 * @tc.size: MediumTest
369 * @tc.type: Function
370 */
371 HWTEST_F(CameraVideoTest, camera_video_030, TestSize.Level2)
372 {
373 std::cout << "==========[test log] Video mode without preview, system not support,";
374 std::cout << "expected return fail." << std::endl;
375
376 EXPECT_EQ(true, display_->cameraDevice != nullptr);
377 display_->AchieveStreamOperator();
378 // Create video stream
379 std::shared_ptr<StreamCustomer> streamCustomer = std::make_shared<StreamCustomer>();
380 OHOS::sptr<OHOS::IBufferProducer> producer = streamCustomer->CreateProducer();
381 producer->SetQueueSize(8); // 8:set bufferQueue size
382 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
383 std::cout << "~~~~~~~" << std::endl;
384 }
385
386 std::vector<StreamInfo> streamInfos;
387 display_->streamInfo.streamId_ = display_->streamId_video;
388 display_->streamInfo.width_ = 1280; // 1280:picture width
389 display_->streamInfo.height_ = 960; // 960:picture height
390 display_->streamInfo.format_ = PIXEL_FMT_RGBA_8888;
391 display_->streamInfo.dataspace_ = 10;
392 display_->streamInfo.intent_ = VIDEO;
393 display_->streamInfo.tunneledMode_ = 5; // 5:tunnel mode
394 display_->streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
395 streamInfos.push_back(display_->streamInfo);
396 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
397 EXPECT_EQ(false, display_->rc == OHOS::Camera::METHOD_NOT_SUPPORTED);
398 if (display_->rc == OHOS::Camera::METHOD_NOT_SUPPORTED) {
399 std::cout << "==========[test log] CreateStreams METHOD_NOT_SUPPORTED, streamId = ";
400 std::cout << display_->streamId_video <<", intent = VIDEO" << std::endl;
401 } else {
402 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
403 }
404 std::vector<uint8_t> modeSetting = {};
405 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, modeSetting);
406 EXPECT_EQ(false, display_->rc == HDI::Camera::V1_0::NO_ERROR);
407 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
408 std::cout << "==========[test log] CommitStreams success." << std::endl;
409 } else {
410 std::cout << "==========[test log] CommitStreams fail, rc = ." << display_->rc << std::endl;
411 }
412 }