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, camera_capture_001, 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, camera_capture_002, 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, camera_capture_003, 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 std::vector<uint8_t> setting;
120 MetadataUtils::ConvertMetadataToVec(meta, setting);
121 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
122 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
123 std::cout << "==========[test log] UpdateSettings success, for 10s." << std::endl;
124 } else {
125 std::cout << "==========[test log] UpdateSettings fail, rc = " << display_->rc << std::endl;
126 }
127 // release stream
128 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
129 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
130 display_->StopStream(display_->captureIds, display_->streamIds);
131 }
132
133 /**
134 * @tc.name: preview and capture
135 * @tc.desc: Preview + capture, then switch to preview + video.
136 * @tc.level: Level1
137 * @tc.size: MediumTest
138 * @tc.type: Function
139 */
140 HWTEST_F(CameraCaptureTest, camera_capture_004, TestSize.Level1)
141 {
142 std::cout << "==========[test log] Preview + capture, then switch to preview + video." << std::endl;
143 std::cout << "==========[test log] First, create preview + capture." << std::endl;
144 // Get the stream manager
145 display_->AchieveStreamOperator();
146 // start stream
147 display_->intents = {PREVIEW, STILL_CAPTURE};
148 display_->StartStream(display_->intents);
149 // Get preview
150 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
151 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
152 // release stream
153 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
154 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
155 display_->StopStream(display_->captureIds, display_->streamIds);
156 sleep(5);
157
158 std::cout << "==========[test log] Next, switch to preview + video." << display_->rc << std::endl;
159 // Get the stream manager
160 display_->AchieveStreamOperator();
161 // start stream
162 display_->intents = {PREVIEW, VIDEO};
163 display_->StartStream(display_->intents);
164 // Get preview
165 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
166 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
167 // release stream
168 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
169 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
170 display_->StopStream(display_->captureIds, display_->streamIds);
171 }
172
173 /**
174 * @tc.name: preview and capture
175 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is false.
176 * @tc.level: Level1
177 * @tc.size: MediumTest
178 * @tc.type: Function
179 */
180 HWTEST_F(CameraCaptureTest, camera_capture_006, TestSize.Level1)
181 {
182 // Get the stream manager
183 display_->AchieveStreamOperator();
184 // start stream
185 display_->intents = {PREVIEW, STILL_CAPTURE};
186 display_->StartStream(display_->intents);
187 // Get preview
188 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
189 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, false);
190
191 sleep(5);
192 std::cout << "==========[test log] frame off." << std::endl;
193 display_->streamCustomerPreview_->ReceiveFrameOff();
194 display_->streamCustomerCapture_->ReceiveFrameOff();
195
196 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
197 {display_->STREAM_ID_CAPTURE});
198 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
199 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
200 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
201 } else {
202 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
203 }
204 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
205 {display_->STREAM_ID_PREVIEW});
206 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
207 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
208 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
209 } else {
210 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
211 }
212 }
213
214 /**
215 * @tc.name: preview and capture
216 * @tc.desc: Commit 2 streams in order, Preview and still_capture streams.
217 * @tc.level: Level1
218 * @tc.size: MediumTest
219 * @tc.type: Function
220 */
221 HWTEST_F(CameraCaptureTest, camera_capture_010, TestSize.Level1)
222 {
223 std::cout << "==========[test log] Preview and still_capture streams." << std::endl;
224 // Configure two streams of information
225 EXPECT_EQ(true, display_->cameraDevice != nullptr);
226 display_->AchieveStreamOperator();
227 // start stream
228 display_->intents = {PREVIEW};
229 display_->StartStream(display_->intents);
230 // Start capture
231 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
232
233 // Configure capture stream information
234 display_->intents = {STILL_CAPTURE};
235 display_->StartStream(display_->intents);
236 // Start capture
237 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
238 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
239 sleep(2);
240
241 // post-processing
242 display_->streamCustomerPreview_->ReceiveFrameOff();
243 display_->streamCustomerCapture_->ReceiveFrameOff();
244 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->CAPTURE_ID_CAPTURE);
245 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
246 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
247 std::cout << "==========[test log] CancelCapture success." << std::endl;
248 } else {
249 std::cout << "==========[test log] CancelCapture fail, rc = ." << display_->rc << std::endl;
250 }
251 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(display_->CAPTURE_ID_PREVIEW);
252 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
253 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
254 std::cout << "==========[test log] CancelCapture success." << std::endl;
255 } else {
256 std::cout << "==========[test log] CancelCapture fail, rc = ." << display_->rc << std::endl;
257 }
258 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
259 {display_->STREAM_ID_CAPTURE});
260 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
261 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
262 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
263 } else {
264 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
265 }
266 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(
267 {display_->STREAM_ID_PREVIEW});
268 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
269 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
270 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
271 } else {
272 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
273 }
274 }
275
276 /**
277 * @tc.name: Only Still_capture stream
278 * @tc.desc: Only Still_capture stream, capture->isStreaming = false.
279 * @tc.level: Level1
280 * @tc.size: MediumTest
281 * @tc.type: Function
282 */
283 HWTEST_F(CameraCaptureTest, camera_capture_020, TestSize.Level1)
284 {
285 std::cout << "==========[test log] No preview, only still_capture." << std::endl;
286 // start stream
287 display_->AchieveStreamOperator();
288 std::shared_ptr<StreamCustomer> streamCustomer = std::make_shared<StreamCustomer>();
289 OHOS::sptr<OHOS::IBufferProducer> producer = streamCustomer->CreateProducer();
290 producer->SetQueueSize(8); // buffer queue size
291 if (producer->GetQueueSize() != 8) { // buffer queue size
292 std::cout << "~~~~~~~" << std::endl;
293 }
__anonbf5ca5190102(const unsigned char *addr, const uint32_t size) 294 streamCustomer->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
295 display_->StoreImage(addr, size);
296 });
297 std::vector<StreamInfo> streamInfos;
298 display_->streamInfo.streamId_ = 1001;
299 display_->streamInfo.width_ = 1280; // picture width
300 display_->streamInfo.height_ = 960; // picture height
301 display_->streamInfo.format_ = PIXEL_FMT_RGBA_8888;
302 display_->streamInfo.dataspace_ = 8; // picture dataspace
303 display_->streamInfo.intent_ = STILL_CAPTURE;
304 display_->streamInfo.tunneledMode_ = 5; // tunnel mode
305 display_->streamInfo.encodeType_ = ENCODE_TYPE_JPEG;
306 display_->streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
307 streamInfos.push_back(display_->streamInfo);
308 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
309 CAMERA_LOGE("CreateStreams! rc:0x%x\n", display_->rc);
310
311 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
312 CAMERA_LOGE("CommitStreams! rc:0x%x\n", display_->rc);
313 int captureId = 2001;
314 CaptureInfo captureInfo = {};
315 captureInfo.streamIds_ = {1001};
316 captureInfo.captureSetting_ = display_->ability_;
317 captureInfo.enableShutterCallback_ = false;
318
319 display_->rc = (CamRetCode)display_->streamOperator->Capture(captureId, captureInfo, false);
320 CAMERA_LOGE("Capture! rc:0x%x\n", display_->rc);
321 sleep(5);
322 streamCustomer->ReceiveFrameOff();
323 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(captureId);
324 CAMERA_LOGE("CancelCapture! rc:0x%x\n", display_->rc);
325 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(captureInfo.streamIds_);
326 CAMERA_LOGE("ReleaseStreams! rc:0x%x\n", display_->rc);
327 }
328
329 /**
330 * @tc.name: Only Still_capture stream
331 * @tc.desc: Only Still_capture stream, capture->isStreaming = true.
332 * @tc.level: Level1
333 * @tc.size: MediumTest
334 * @tc.type: Function
335 */
336 HWTEST_F(CameraCaptureTest, camera_capture_021, TestSize.Level1)
337 {
338 std::cout << "==========[test log] Still_capture stream, capture->isStreaming = true." << std::endl;
339 // start stream
340 display_->AchieveStreamOperator();
341 std::shared_ptr<StreamCustomer> streamCustomer = std::make_shared<StreamCustomer>();
342 OHOS::sptr<OHOS::IBufferProducer> producer = streamCustomer->CreateProducer();
343 producer->SetQueueSize(8); // 8:set bufferqueue size
344 if (producer->GetQueueSize() != 8) { // 8:get bufferqueue size
345 std::cout << "~~~~~~~" << std::endl;
346 }
__anonbf5ca5190202(const unsigned char *addr, const uint32_t size) 347 streamCustomer->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
348 display_->StoreImage(addr, size);
349 });
350 std::vector<StreamInfo> streamInfos;
351 display_->streamInfo.streamId_ = 1001;
352 display_->streamInfo.width_ = 1280; // 640:picture width
353 display_->streamInfo.height_ = 960; // 640:picture height
354 display_->streamInfo.format_ = PIXEL_FMT_RGBA_8888;
355 display_->streamInfo.dataspace_ = 8; // 8:picture dataspace
356 display_->streamInfo.intent_ = STILL_CAPTURE;
357 display_->streamInfo.tunneledMode_ = 5; // 5:tunnel mode
358 display_->streamInfo.encodeType_ = ENCODE_TYPE_JPEG;
359 display_->streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
360 streamInfos.push_back(display_->streamInfo);
361 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
362 CAMERA_LOGE("CreateStreams! rc:0x%x\n", display_->rc);
363
364 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
365 CAMERA_LOGE("CommitStreams! rc:0x%x\n", display_->rc);
366 int captureId = 2001;
367 CaptureInfo captureInfo = {};
368 captureInfo.streamIds_ = {1001};
369 captureInfo.captureSetting_ = display_->ability_;
370 captureInfo.enableShutterCallback_ = false;
371
372 display_->rc = (CamRetCode)display_->streamOperator->Capture(captureId, captureInfo, true);
373 CAMERA_LOGE("Capture! rc:0x%x\n", display_->rc);
374 sleep(5);
375 streamCustomer->ReceiveFrameOff();
376 display_->rc = (CamRetCode)display_->streamOperator->CancelCapture(captureId);
377 CAMERA_LOGE("CancelCapture! rc:0x%x\n", display_->rc);
378 display_->rc = (CamRetCode)display_->streamOperator->ReleaseStreams(captureInfo.streamIds_);
379 CAMERA_LOGE("ReleaseStreams! rc:0x%x\n", display_->rc);
380 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
381 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
382 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
383 } else {
384 std::cout << "==========[test log] ReleaseStreams fail, rc = ." << display_->rc << std::endl;
385 }
386 }