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_capture_test.h"
16
17 using namespace testing::ext;
18
SetUpTestCase(void)19 void CameraCaptureTest::SetUpTestCase(void)
20 {}
TearDownTestCase(void)21 void CameraCaptureTest::TearDownTestCase(void)
22 {}
SetUp(void)23 void CameraCaptureTest::SetUp(void)
24 {
25 if (display_ == nullptr)
26 display_ = std::make_shared<TestDisplay>();
27 display_->Init();
28 }
TearDown(void)29 void CameraCaptureTest::TearDown(void)
30 {
31 display_->Close();
32 }
33
34 /**
35 * @tc.name: preview and capture
36 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
37 * @tc.level: Level1
38 * @tc.size: MediumTest
39 * @tc.type: Function
40 */
41 HWTEST_F(CameraCaptureTest, SUB_DriverSystem_CameraHdi_0150, TestSize.Level1)
42 {
43 // Get the stream manager
44 display_->AchieveStreamOperator();
45 // start stream
46 display_->intents = {PREVIEW, STILL_CAPTURE};
47 display_->StartStream(display_->intents);
48 // Get preview
49 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
50 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
51 // release stream
52 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
53 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
54 display_->StopStream(display_->captureIds, display_->streamIds);
55 }
56
57 /**
58 * @tc.name: preview and capture
59 * @tc.desc: Preview + capture, then close camera, and preview + capture again.
60 * @tc.level: Level1
61 * @tc.size: MediumTest
62 * @tc.type: Function
63 */
64 HWTEST_F(CameraCaptureTest, SUB_DriverSystem_CameraHdi_0160, TestSize.Level1)
65 {
66 std::cout << "==========[test log] Preview + capture, then cloase camera,";
67 std::cout << "and preview + capture again." << std::endl;
68 // Get the stream manager
69 display_->AchieveStreamOperator();
70 // start stream
71 display_->intents = {PREVIEW, STILL_CAPTURE};
72 display_->StartStream(display_->intents);
73 // Get preview
74 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
75 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
76 // release stream
77 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
78 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
79 display_->StopStream(display_->captureIds, display_->streamIds);
80
81 // the 2nd time
82 // Configure two streams of information
83 // Get the stream manager
84 display_->AchieveStreamOperator();
85 // start stream
86 display_->intents = {PREVIEW, STILL_CAPTURE};
87 display_->StartStream(display_->intents);
88 // Get preview
89 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
90 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
91 // release stream
92 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
93 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
94 display_->StopStream(display_->captureIds, display_->streamIds);
95 }
96
97 /**
98 * @tc.name: preview and capture
99 * @tc.desc: Preview + capture with 3A, success.
100 * @tc.level: Level1
101 * @tc.size: MediumTest
102 * @tc.type: Function
103 */
104 HWTEST_F(CameraCaptureTest, SUB_DriverSystem_CameraHdi_0170, TestSize.Level1)
105 {
106 std::cout << "==========[test log] Capture with 3A, success." << std::endl;
107 // Get the stream manager
108 display_->AchieveStreamOperator();
109 // start stream
110 display_->intents = {PREVIEW, STILL_CAPTURE};
111 display_->StartStream(display_->intents);
112 // Get preview
113 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
114 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
115 // Issue 3A parameters to increase exposure
116 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 2000);
117 int32_t expo = 0xa0;
118 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
119 const int32_t deviceStreamId = display_->STREAM_ID_CAPTURE;
120 meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
121 std::vector<uint8_t> setting;
122 MetadataUtils::ConvertMetadataToVec(meta, setting);
123 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
124 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
125 std::cout << "==========[test log] UpdateSettings success, for 10s." << std::endl;
126 } else {
127 std::cout << "==========[test log] UpdateSettings fail, rc = " << display_->rc << std::endl;
128 }
129 // release stream
130 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
131 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
132 display_->StopStream(display_->captureIds, display_->streamIds);
133 }
134
135 /**
136 * @tc.name: preview and capture
137 * @tc.desc: Preview + capture, then switch to preview + video.
138 * @tc.level: Level1
139 * @tc.size: MediumTest
140 * @tc.type: Function
141 */
142 HWTEST_F(CameraCaptureTest, SUB_DriverSystem_CameraHdi_0180, TestSize.Level1)
143 {
144 std::cout << "==========[test log] Preview + capture, then switch to preview + video." << std::endl;
145 std::cout << "==========[test log] First, create preview + capture." << std::endl;
146 // Get the stream manager
147 display_->AchieveStreamOperator();
148 // start stream
149 display_->intents = {PREVIEW, STILL_CAPTURE};
150 display_->StartStream(display_->intents);
151 // Get preview
152 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
153 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
154 // release stream
155 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
156 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
157 display_->StopStream(display_->captureIds, display_->streamIds);
158 sleep(3);
159
160 std::cout << "==========[test log] Next, switch to preview + video." << display_->rc << std::endl;
161 // Get the stream manager
162 display_->AchieveStreamOperator();
163 // start stream
164 display_->intents = {PREVIEW, VIDEO};
165 display_->StartStream(display_->intents);
166 // Get preview
167 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
168 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
169 // release stream
170 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
171 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
172 display_->StopStream(display_->captureIds, display_->streamIds);
173 }
174
175 /**
176 * @tc.name: preview and capture
177 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is false.
178 * @tc.level: Level1
179 * @tc.size: MediumTest
180 * @tc.type: Function
181 */
182 HWTEST_F(CameraCaptureTest, SUB_DriverSystem_CameraHdi_0200, TestSize.Level1)
183 {
184 // Get the stream manager
185 display_->AchieveStreamOperator();
186 // start stream
187 display_->intents = {PREVIEW, STILL_CAPTURE};
188 display_->StartStream(display_->intents);
189 // Get preview
190 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
191 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, false);
192
193 sleep(3);
194 CAMERA_LOGD("frame off.");
195 display_->streamCustomerPreview_->ReceiveFrameOff();
196 display_->streamCustomerCapture_->ReceiveFrameOff();
197
198 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
199 {display_->STREAM_ID_CAPTURE});
200 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
201 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
202 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
203 } else {
204 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
205 }
206 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
207 {display_->STREAM_ID_PREVIEW});
208 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
209 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
210 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
211 } else {
212 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
213 }
214 }
215
216 /**
217 * @tc.name: preview and capture
218 * @tc.desc: Commit 2 streams in order, Preview and still_capture streams.
219 * @tc.level: Level1
220 * @tc.size: MediumTest
221 * @tc.type: Function
222 */
223 HWTEST_F(CameraCaptureTest, SUB_DriverSystem_CameraHdi_0210, TestSize.Level1)
224 {
225 std::cout << "==========[test log] Preview and still_capture streams." << std::endl;
226 // Configure two streams of information
227 EXPECT_EQ(true, display_->cameraDevice != nullptr);
228 display_->AchieveStreamOperator();
229 // start stream
230 display_->intents = {PREVIEW};
231 display_->StartStream(display_->intents);
232 // Start capture
233 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
234
235 // Configure capture stream information
236 display_->intents = {STILL_CAPTURE};
237 display_->StartStream(display_->intents);
238 // Start capture
239 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
240 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
241 sleep(2);
242
243 // post-processing
244 display_->streamCustomerPreview_->ReceiveFrameOff();
245 display_->streamCustomerCapture_->ReceiveFrameOff();
246 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->CAPTURE_ID_CAPTURE);
247 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
248 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
249 std::cout << "==========[test log] CancelCapture success." << std::endl;
250 } else {
251 std::cout << "==========[test log] CancelCapture fail, rc = ." << display_->rc << std::endl;
252 }
253 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->CAPTURE_ID_PREVIEW);
254 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
255 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
256 std::cout << "==========[test log] CancelCapture success." << std::endl;
257 } else {
258 std::cout << "==========[test log] CancelCapture fail, rc = ." << display_->rc << std::endl;
259 }
260 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
261 {display_->STREAM_ID_CAPTURE});
262 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
263 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
264 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
265 } else {
266 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
267 }
268 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
269 {display_->STREAM_ID_PREVIEW});
270 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
271 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
272 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
273 } else {
274 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
275 }
276 }
277
278 /**
279 * @tc.name: Only Still_capture stream
280 * @tc.desc: Only Still_capture stream, capture->isStreaming = false.
281 * @tc.level: Level1
282 * @tc.size: MediumTest
283 * @tc.type: Function
284 */
285 HWTEST_F(CameraCaptureTest, camera_capture_020, TestSize.Level1)
286 {
287 std::cout << "==========[test log] No preview, only still_capture." << std::endl;
288 // start stream
289 display_->AchieveStreamOperator();
290 std::shared_ptr<StreamCustomer> streamCustomer = std::make_shared<StreamCustomer>();
291 OHOS::sptr<OHOS::IBufferProducer> producer = streamCustomer->CreateProducer();
292 producer->SetQueueSize(8); // buffer queue size
293 if (producer->GetQueueSize() != 8) { // buffer queue size
294 std::cout << "~~~~~~~" << std::endl;
295 }
__anonc5b614240102(const unsigned char *addr, const uint32_t size) 296 streamCustomer->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
297 display_->StoreImage(addr, size);
298 });
299 std::vector<StreamInfo> streamInfos;
300 display_->streamInfo.streamId_ = 1001;
301 display_->streamInfo.width_ = 1280; // picture width
302 display_->streamInfo.height_ = 960; // picture height
303 display_->streamInfo.format_ = PIXEL_FMT_RGBA_8888;
304 display_->streamInfo.dataspace_ = 8; // picture dataspace
305 display_->streamInfo.intent_ = STILL_CAPTURE;
306 display_->streamInfo.tunneledMode_ = 5; // tunnel mode
307 display_->streamInfo.encodeType_ = ENCODE_TYPE_JPEG;
308 display_->streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
309 ASSERT_NE(display_->streamInfo.bufferQueue_, nullptr);
310 streamInfos.push_back(display_->streamInfo);
311 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
312 CAMERA_LOGE("CreateStreams! rc:0x%x\n", display_->rc);
313
314 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
315 CAMERA_LOGE("CommitStreams! rc:0x%x\n", display_->rc);
316 int captureId = 2001;
317 CaptureInfo captureInfo = {};
318 captureInfo.streamIds_ = {1001};
319 captureInfo.captureSetting_ = display_->ability_;
320 captureInfo.enableShutterCallback_ = false;
321
322 display_->rc = (CamRetCode)display_->streamOperator->Capture(captureId, captureInfo, false);
323 CAMERA_LOGE("Capture! rc:0x%x\n", display_->rc);
324 sleep(3);
325 streamCustomer->ReceiveFrameOff();
326 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(captureId);
327 CAMERA_LOGE("CancelCapture! rc:0x%x\n", display_->rc);
328 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(captureInfo.streamIds_);
329 CAMERA_LOGE("ReleaseStreams! rc:0x%x\n", display_->rc);
330 }
331
332 /**
333 * @tc.name: Only Still_capture stream
334 * @tc.desc: Only Still_capture stream, capture->isStreaming = true.
335 * @tc.level: Level1
336 * @tc.size: MediumTest
337 * @tc.type: Function
338 */
339 HWTEST_F(CameraCaptureTest, camera_capture_021, TestSize.Level1)
340 {
341 std::cout << "==========[test log] Still_capture stream, capture->isStreaming = true." << std::endl;
342 // start stream
343 display_->AchieveStreamOperator();
344 std::shared_ptr<StreamCustomer> streamCustomer = std::make_shared<StreamCustomer>();
345 OHOS::sptr<OHOS::IBufferProducer> producer = streamCustomer->CreateProducer();
346 producer->SetQueueSize(8); // 8:set bufferqueue size
347 if (producer->GetQueueSize() != 8) { // 8:get bufferqueue size
348 std::cout << "~~~~~~~" << std::endl;
349 }
__anonc5b614240202(const unsigned char *addr, const uint32_t size) 350 streamCustomer->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
351 display_->StoreImage(addr, size);
352 });
353 std::vector<StreamInfo> streamInfos;
354 display_->streamInfo.streamId_ = 1001;
355 display_->streamInfo.width_ = 1280; // 640:picture width
356 display_->streamInfo.height_ = 960; // 640:picture height
357 display_->streamInfo.format_ = PIXEL_FMT_RGBA_8888;
358 display_->streamInfo.dataspace_ = 8; // 8:picture dataspace
359 display_->streamInfo.intent_ = STILL_CAPTURE;
360 display_->streamInfo.tunneledMode_ = 5; // 5:tunnel mode
361 display_->streamInfo.encodeType_ = ENCODE_TYPE_JPEG;
362 display_->streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
363 ASSERT_NE(display_->streamInfo.bufferQueue_, nullptr);
364 streamInfos.push_back(display_->streamInfo);
365 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
366 CAMERA_LOGE("CreateStreams! rc:0x%x\n", display_->rc);
367
368 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
369 CAMERA_LOGE("CommitStreams! rc:0x%x\n", display_->rc);
370 int captureId = 2001;
371 CaptureInfo captureInfo = {};
372 captureInfo.streamIds_ = {1001};
373 captureInfo.captureSetting_ = display_->ability_;
374 captureInfo.enableShutterCallback_ = false;
375
376 display_->rc = (CamRetCode)display_->streamOperator->Capture(captureId, captureInfo, true);
377 CAMERA_LOGE("Capture! rc:0x%x\n", display_->rc);
378 sleep(3);
379 streamCustomer->ReceiveFrameOff();
380 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(captureId);
381 CAMERA_LOGE("CancelCapture! rc:0x%x\n", display_->rc);
382 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(captureInfo.streamIds_);
383 CAMERA_LOGE("ReleaseStreams! rc:0x%x\n", display_->rc);
384 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
385 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
386 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
387 } else {
388 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
389 }
390 }
391
392 /**
393 * @tc.name: RE_CONFIGURED_REQUIRED
394 * @tc.desc: RE_CONFIGURED_REQUIRED
395 * @tc.size: MediumTest
396 * @tc.type: Function
397 */
398 HWTEST_F(CameraCaptureTest, Camera_Capture_022, TestSize.Level1)
399 {
400 std::cout << "==========[test log]check Capture: Preview + video, then capture a photo." << std::endl;
401 std::cout << "==========[test log]check Capture: First, create Preview + video." << std::endl;
402 // Configure two streams of information
403 display_->AchieveStreamOperator();
404 display_->intents = {PREVIEW, VIDEO};
405 display_->StartStream(display_->intents);
406 // Capture preview stream
407 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
408 // Capture video stream
409 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
410
411 // Start the capture stream
412 std::shared_ptr<HDI::Camera::V1_0::StreamInfo> streamInfo_capture =
413 std::make_shared<HDI::Camera::V1_0::StreamInfo>();
414 streamInfo_capture->streamId_ = display_->STREAM_ID_CAPTURE;
415 streamInfo_capture->width_ = 640;
416 streamInfo_capture->height_ = 480;
417 streamInfo_capture->format_ = PIXEL_FMT_YCRCB_420_SP;
418 streamInfo_capture->dataspace_ = 8;
419 streamInfo_capture->intent_ = HDI::Camera::V1_0::STILL_CAPTURE;
420 streamInfo_capture->tunneledMode_ = 5;
421
422 // Query whether the IsStreamsSupported interface supports
423 HDI::Camera::V1_0::StreamSupportType pType;
424 std::vector<HDI::Camera::V1_0::StreamInfo> stre;
425 stre.push_back(*streamInfo_capture);
426 display_->rc = (CamRetCode)display_->streamOperator->IsStreamsSupported(HDI::Camera::V1_0::NORMAL,
427 display_->ability_, stre, pType);
428 EXPECT_EQ(display_->rc, HDI::Camera::V1_0::NO_ERROR);
429 std::cout << "ptype = " << pType << std::endl;
430 EXPECT_EQ(true, pType == HDI::Camera::V1_0::RE_CONFIGURED_REQUIRED);
431 // post-processing
432 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
433 display_->streamIds.push_back(display_->STREAM_ID_PREVIEW);
434 display_->streamIds.push_back(display_->STREAM_ID_VIDEO);
435 display_->StopStream(display_->captureIds, display_->streamIds);
436 }