1 /*
2 * Copyright (c) 2021 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 "resolution_test.h"
16
17 using namespace OHOS;
18 using namespace std;
19 using namespace testing::ext;
20 using namespace OHOS::Camera;
21
SetUpTestCase(void)22 void ResolutionTest::SetUpTestCase(void) {}
TearDownTestCase(void)23 void ResolutionTest::TearDownTestCase(void) {}
SetUp(void)24 void ResolutionTest::SetUp(void)
25 {
26 Test_ = std::make_shared<OHOS::Camera::Test>();
27 Test_->Init();
28 Test_->Open();
29 }
TearDown(void)30 void ResolutionTest::TearDown(void)
31 {
32 Test_->Close();
33 }
34
35 /**
36 * @tc.name: preview and capture
37 * @tc.desc: Preview and still_capture streams, Commit 2 streams together,
38 * which Preview's resolution is 640 * 480 and Capture's resolution is 1280 * 960
39 * @tc.size: MediumTest
40 * @tc.type: Function
41 */
42 HWTEST_F(ResolutionTest, Camera_Resolution_0001, TestSize.Level3)
43 {
44 std::cout << "==========[test log]check Capture: Preview and still_capture streams.";
45 std::cout << "which Preview's resolution is 640 * 480";
46 std::cout << "and Capture's resolution is 1280 * 960" << std::endl;
47 Test_->CreateStreamOperatorCallback();
48 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
49 EXPECT_EQ(true, Test_->rc == Camera::NO_ERROR);
50 if (Test_->rc == Camera::NO_ERROR) {
51 std::cout << "==========[test log]GetStreamOperator success." << std::endl;
52 } else {
53 std::cout << "==========[test log]GetStreamOperator fail, rc = " << Test_->rc << std::endl;
54 }
55 // Configure preview stream information
56 Test_->streamInfo_pre = std::make_shared<Camera::StreamInfo>();
57 Test_->streamInfo_pre->streamId_ = Test_->streamId_preview;
58 Test_->streamInfo_pre->width_ = 640; // 640:width of stream
59 Test_->streamInfo_pre->height_ = 480; // 480: height of stream
60 #ifdef CAMERA_BUILT_ON_OHOS_LITE
61 Test_->streamInfo_pre->format_ = IMAGE_PIXEL_FORMAT_NV21;
62 #else
63 Test_->streamInfo_pre->format_ = PIXEL_FMT_YCRCB_420_SP;
64 #endif
65 Test_->streamInfo_pre->dataspace_ = 8; // 8:dataspace of stream
66 Test_->streamInfo_pre->intent_ = Camera::PREVIEW;
67 Test_->streamInfo_pre->tunneledMode_ = 5; // 5:tunneledMode of stream
68 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
69 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
70 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anone71a65810102(OHOS::SurfaceBuffer* buffer) 71 Test_->streamInfo_pre->bufferQueue_ = preview_consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
72 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
73 });
74 #else
__anone71a65810202(void* addr, uint32_t size) 75 Test_->streamInfo_pre->bufferQueue_ = preview_consumer->CreateProducer([this](void* addr, uint32_t size) {
76 Test_->SaveYUV("preview", addr, size);
77 });
78 #endif
79 Test_->streamInfo_pre->bufferQueue_->SetQueueSize(8); // 8:size of bufferQueue
80 Test_->consumerMap_[Camera::PREVIEW] = preview_consumer;
81 Test_->streamInfos.push_back(Test_->streamInfo_pre);
82 // Configure capture stream information
83 Test_->streamInfo_capture = std::make_shared<Camera::StreamInfo>();
84 Test_->streamInfo_capture->streamId_ = Test_->streamId_capture;
85 Test_->streamInfo_capture->width_ = 1280; // 1280:width of stream
86 Test_->streamInfo_capture->height_ = 960; // 960: height of stream
87 #ifdef CAMERA_BUILT_ON_OHOS_LITE
88 Test_->streamInfo_capture->format_ = IMAGE_PIXEL_FORMAT_NV21;
89 #else
90 Test_->streamInfo_capture->format_ = PIXEL_FMT_YCRCB_420_SP;
91 #endif
92 Test_->streamInfo_capture->dataspace_ = 8; // 8:dataspace of stream
93 Test_->streamInfo_capture->intent_ = Camera::STILL_CAPTURE;
94 Test_->streamInfo_capture->encodeType_ = ENCODE_TYPE_JPEG;
95 Test_->streamInfo_capture->tunneledMode_ = 5; // 5:tunneledMode of stream
96 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer_capture =
97 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
98 std::cout << "==========[test log]received a capture buffer ... 1" << std::endl;
99 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anone71a65810302(OHOS::SurfaceBuffer* buffer) 100 Test_->streamInfo_capture->bufferQueue_ = consumer_capture->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
101 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
102 });
103 #else
__anone71a65810402(void* addr, uint32_t size) 104 Test_->streamInfo_capture->bufferQueue_ = consumer_capture->CreateProducer([this](void* addr, uint32_t size) {
105 Test_->SaveYUV("preview", addr, size);
106 });
107 #endif
108 Test_->streamInfo_capture->bufferQueue_->SetQueueSize(8); // 8:bufferqueue size
109 Test_->consumerMap_[Camera::STILL_CAPTURE] = consumer_capture;
110 Test_->streamInfos.push_back(Test_->streamInfo_capture);
111 // distribution start
112 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
113 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR);
114 if (Test_->rc == Camera::NO_ERROR) {
115 std::cout << "==========[test log]CreateStreams success." << std::endl;
116 } else {
117 std::cout << "==========[test log]CreateStreams fail, rc = " << Test_->rc << std::endl;
118 }
119 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
120 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR);
121 if (Test_->rc == Camera::NO_ERROR) {
122 std::cout << "==========[test log]CommitStreams success." << std::endl;
123 } else {
124 std::cout << "==========[test log]CommitStreams fail, rc = " << Test_->rc << std::endl;
125 }
126 sleep(2); // 2:The program waits two seconds
127 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
128 // Capture preview stream
129 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
130 // Capture the capture stream
131 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
132 // post-processing
133 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
134 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
135 Test_->StopStream(Test_->captureIds, Test_->streamIds);
136 preview_consumer->StopConsumer();
137 consumer_capture->StopConsumer();
138 }
139
140 /**
141 * @tc.name: preview and capture
142 * @tc.desc: Preview and Video streams, Commit 2 streams together,
143 * which Preview's resolving power is 853 * 480 and Video's resolving power is 1280 * 720
144 * @tc.size: MediumTest
145 * @tc.type: Function
146 */
147 HWTEST_F(ResolutionTest, Camera_Resolution_0002, TestSize.Level3)
148 {
149 std::cout << "==========[test log]check Capture: Preview and Video streams.";
150 std::cout << "which Preview's resolution is 853 * 480";
151 std::cout << "and Video's resolution is 1280 * 720" << std::endl;
152 Test_->CreateStreamOperatorCallback();
153 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
154 EXPECT_EQ(true, Test_->rc == Camera::NO_ERROR);
155 if (Test_->rc == Camera::NO_ERROR) {
156 std::cout << "==========[test log]GetStreamOperator success." << std::endl;
157 } else {
158 std::cout << "==========[test log]GetStreamOperator fail, rc = " << Test_->rc << std::endl;
159 }
160 // Configure preview stream information
161 Test_->streamInfo_pre = std::make_shared<Camera::StreamInfo>();
162 Test_->streamInfo_pre->streamId_ = Test_->streamId_preview;
163 Test_->streamInfo_pre->width_ = 853; // 853:width of stream
164 Test_->streamInfo_pre->height_ = 480; // 480: height of stream
165 #ifdef CAMERA_BUILT_ON_OHOS_LITE
166 Test_->streamInfo_pre->format_ = IMAGE_PIXEL_FORMAT_NV21;
167 #else
168 Test_->streamInfo_pre->format_ = PIXEL_FMT_YCRCB_420_SP;
169 #endif
170 Test_->streamInfo_pre->dataspace_ = 8; // 8:dataspace of stream
171 Test_->streamInfo_pre->intent_ = Camera::PREVIEW;
172 Test_->streamInfo_pre->tunneledMode_ = 5; // 5:tunneledMode of stream
173 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
174 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
175 std::cout << "==========[test log]received a preview buffer ... 0" << std::endl;
176 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anone71a65810502(OHOS::SurfaceBuffer* buffer) 177 Test_->streamInfo_pre->bufferQueue_ = preview_consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
178 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
179 });
180 #else
__anone71a65810602(void* addr, uint32_t size) 181 Test_->streamInfo_pre->bufferQueue_ = preview_consumer->CreateProducer([this](void* addr, uint32_t size) {
182 Test_->SaveYUV("preview", addr, size);
183 });
184 #endif
185 Test_->streamInfo_pre->bufferQueue_->SetQueueSize(8); // 8:size of bufferQueue
186 Test_->consumerMap_[Camera::PREVIEW] = preview_consumer;
187 Test_->streamInfos.push_back(Test_->streamInfo_pre);
188 // Configure video stream information
189 Test_->streamInfo_video = std::make_shared<Camera::StreamInfo>();
190 Test_->streamInfo_video->streamId_ = Test_->streamId_video;
191 Test_->streamInfo_video->width_ = 1280; // 1280:width of stream
192 Test_->streamInfo_video->height_ = 720; // 960: height of stream
193 #ifdef CAMERA_BUILT_ON_OHOS_LITE
194 Test_->streamInfo_video->format_ = IMAGE_PIXEL_FORMAT_NV21;
195 #else
196 Test_->streamInfo_video->format_ = PIXEL_FMT_YCRCB_420_SP;
197 #endif
198 Test_->streamInfo_video->dataspace_ = 8; // 8:dataspace of stream
199 Test_->streamInfo_video->intent_ = Camera::VIDEO;
200 Test_->streamInfo_video->encodeType_ = ENCODE_TYPE_H265;
201 Test_->streamInfo_video->tunneledMode_ = 5; // 5:tunneledMode of stream
202 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer_video =
203 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
204 std::cout << "==========[test log]received a video buffer ... 1" << std::endl;
205 Test_->SaveVideoFile("video", nullptr, 0, 0);
206 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anone71a65810702(OHOS::SurfaceBuffer* buffer) 207 Test_->streamInfo_video->bufferQueue_ = consumer_video->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
208 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
209 });
210 #else
__anone71a65810802(void* addr, uint32_t size) 211 Test_->streamInfo_video->bufferQueue_ = consumer_video->CreateProducer([this](void* addr, uint32_t size) {
212 Test_->SaveYUV("preview", addr, size);
213 });
214 #endif
215 Test_->streamInfo_video->bufferQueue_->SetQueueSize(8); // 8:bufferqueue size
216 Test_->consumerMap_[Camera::VIDEO] = consumer_video;
217 Test_->streamInfos.push_back(Test_->streamInfo_video);
218 // distribution start
219 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
220 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR);
221 if (Test_->rc == Camera::NO_ERROR) {
222 std::cout << "==========[test log]CreateStreams success." << std::endl;
223 } else {
224 std::cout << "==========[test log]CreateStreams fail, rc = " << Test_->rc << std::endl;
225 }
226 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
227 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR);
228 if (Test_->rc == Camera::NO_ERROR) {
229 std::cout << "==========[test log]CommitStreams success." << std::endl;
230 } else {
231 std::cout << "==========[test log]CommitStreams fail, rc = " << Test_->rc << std::endl;
232 }
233 sleep(2); // 2:The program waits two seconds
234 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
235 // Capture preview stream
236 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
237 // Capture video stream,Continuous capture
238 Test_->StartCapture(Test_->streamId_video, Test_->captureId_video, false, true);
239 // post-processing
240 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_video};
241 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_video};
242 Test_->StopStream(Test_->captureIds, Test_->streamIds);
243 preview_consumer->StopConsumer();
244 consumer_video->StopConsumer();
245 }
246
247 /**
248 * @tc.name: preview and capture
249 * @tc.desc: Preview and Video streams, Commit 2 streams together,
250 * which Preview's resolving power is 640 * 360 and Video's resolving power is 1280 * 720
251 * @tc.size: MediumTest
252 * @tc.type: Function
253 */
254 HWTEST_F(ResolutionTest, Camera_Resolution_0003, TestSize.Level3)
255 {
256 std::cout << "==========[test log]check Capture: Preview and Video streams.";
257 std::cout << "which Preview's resolution is 640 * 360";
258 std::cout << "and Video's resolution is 1280 * 720" << std::endl;
259 Test_->CreateStreamOperatorCallback();
260 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
261 EXPECT_EQ(true, Test_->rc == Camera::NO_ERROR);
262 if (Test_->rc == Camera::NO_ERROR) {
263 std::cout << "==========[test log]GetStreamOperator success." << std::endl;
264 } else {
265 std::cout << "==========[test log]GetStreamOperator fail, rc = " << Test_->rc << std::endl;
266 }
267 // Configure preview stream information
268 Test_->streamInfo_pre = std::make_shared<Camera::StreamInfo>();
269 Test_->streamInfo_pre->streamId_ = Test_->streamId_preview;
270 Test_->streamInfo_pre->width_ = 640; // 640:width of stream
271 Test_->streamInfo_pre->height_ = 360; // 360: height of stream
272 #ifdef CAMERA_BUILT_ON_OHOS_LITE
273 Test_->streamInfo_pre->format_ = IMAGE_PIXEL_FORMAT_NV21;
274 #else
275 Test_->streamInfo_pre->format_ = PIXEL_FMT_YCRCB_420_SP;
276 #endif
277 Test_->streamInfo_pre->dataspace_ = 8; // 8:dataspace of stream
278 Test_->streamInfo_pre->intent_ = Camera::PREVIEW;
279 Test_->streamInfo_pre->tunneledMode_ = 5; // 5:tunneledMode of stream
280 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
281 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
282 std::cout << "==========[test log]received a preview buffer ... 0" << std::endl;
283 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anone71a65810902(OHOS::SurfaceBuffer* buffer) 284 Test_->streamInfo_pre->bufferQueue_ = preview_consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
285 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
286 });
287 #else
__anone71a65810a02(void* addr, uint32_t size) 288 Test_->streamInfo_pre->bufferQueue_ = preview_consumer->CreateProducer([this](void* addr, uint32_t size) {
289 Test_->SaveYUV("preview", addr, size);
290 });
291 #endif
292 Test_->streamInfo_pre->bufferQueue_->SetQueueSize(8); // 8:size of bufferQueue
293 Test_->consumerMap_[Camera::PREVIEW] = preview_consumer;
294 Test_->streamInfos.push_back(Test_->streamInfo_pre);
295 // Configure video stream information
296 Test_->streamInfo_video = std::make_shared<Camera::StreamInfo>();
297 Test_->streamInfo_video->streamId_ = Test_->streamId_video;
298 Test_->streamInfo_video->width_ = 1280; // 1280:width of stream
299 Test_->streamInfo_video->height_ = 720; // 960: height of stream
300 #ifdef CAMERA_BUILT_ON_OHOS_LITE
301 Test_->streamInfo_video->format_ = IMAGE_PIXEL_FORMAT_NV21;
302 #else
303 Test_->streamInfo_video->format_ = PIXEL_FMT_YCRCB_420_SP;
304 #endif
305 Test_->streamInfo_video->dataspace_ = 8; // 8:dataspace of stream
306 Test_->streamInfo_video->intent_ = Camera::VIDEO;
307 Test_->streamInfo_video->encodeType_ = ENCODE_TYPE_H265;
308 Test_->streamInfo_video->tunneledMode_ = 5; // 5:tunneledMode of stream
309 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer_video =
310 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
311 std::cout << "==========[test log]received a video buffer ... 1" << std::endl;
312 Test_->SaveVideoFile("video", nullptr, 0, 0);
313 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anone71a65810b02(OHOS::SurfaceBuffer* buffer) 314 Test_->streamInfo_video->bufferQueue_ = consumer_video->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
315 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
316 });
317 #else
__anone71a65810c02(void* addr, uint32_t size) 318 Test_->streamInfo_video->bufferQueue_ = consumer_video->CreateProducer([this](void* addr, uint32_t size) {
319 Test_->SaveYUV("preview", addr, size);
320 });
321 #endif
322 Test_->streamInfo_video->bufferQueue_->SetQueueSize(8); // 8:bufferqueue size
323 Test_->consumerMap_[Camera::VIDEO] = consumer_video;
324 Test_->streamInfos.push_back(Test_->streamInfo_video);
325 // distribution start
326 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
327 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR);
328 if (Test_->rc == Camera::NO_ERROR) {
329 std::cout << "==========[test log]CreateStreams success." << std::endl;
330 } else {
331 std::cout << "==========[test log]CreateStreams fail, rc = " << Test_->rc << std::endl;
332 }
333 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
334 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR);
335 if (Test_->rc == Camera::NO_ERROR) {
336 std::cout << "==========[test log]CommitStreams success." << std::endl;
337 } else {
338 std::cout << "==========[test log]CommitStreams fail, rc = " << Test_->rc << std::endl;
339 }
340 sleep(2); // 2:The program waits two seconds
341 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
342 // Capture preview stream
343 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
344 // Capture video stream,Continuous capture
345 Test_->StartCapture(Test_->streamId_video, Test_->captureId_video, false, true);
346 // post-processing
347 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_video};
348 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_video};
349 Test_->StopStream(Test_->captureIds, Test_->streamIds);
350 preview_consumer->StopConsumer();
351 consumer_video->StopConsumer();
352 }