1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected 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 "pipeline_test.h"
17
18 using namespace OHOS;
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Camera;
22
23 const int STREAMINFO_WIDTH1 = 640;
24 const int STREAMINFO_WIDTH2 = 1280;
25 const int STREAMINFO_HEIGHT1 = 480;
26 const int STREAMINFO_HEIGHT2 = 960;
27 const int STREAMINFO_DATASPACE1 = 10;
28 const int STREAMINFO_DATASPACE2 = 8;
29 const int STREAMINFO_TUNNELED_MODE = 5;
30 const int QUEUE_SIZE = 8;
31
SetUpTestCase(void)32 void PipelineTest::SetUpTestCase(void) {}
TearDownTestCase(void)33 void PipelineTest::TearDownTestCase(void) {}
SetUp(void)34 void PipelineTest::SetUp(void)
35 {
36 Test_ = std::make_shared<OHOS::Camera::Test>();
37 Test_->Init();
38 Test_->Open();
39 }
TearDown(void)40 void PipelineTest::TearDown(void)
41 {
42 Test_->Close();
43 }
44
45 /**
46 * @tc.name: Check ppl
47 * @tc.desc: preview success.
48 * @tc.size: MediumTest
49 * @tc.type: Function
50 */
51 HWTEST_F(PipelineTest, Camera_Ppl_0001, TestSize.Level0)
52 {
53 std::cout << "==========[test log]Check ppl: preview success." << std::endl;
54 // Start stream
55 Test_->intents = {Camera::PREVIEW};
56 Test_->StartStream(Test_->intents);
57 // Get preview
58 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
59 // Release stream
60 Test_->captureIds = {Test_->captureId_preview};
61 Test_->streamIds = {Test_->streamId_preview};
62 Test_->StopStream(Test_->captureIds, Test_->streamIds);
63 Test_->StopConsumer(Test_->intents);
64 }
65
66 /**
67 * @tc.name: Check ppl
68 * @tc.desc: preview + capture success.
69 * @tc.size: MediumTest
70 * @tc.type: Function
71 */
72 HWTEST_F(PipelineTest, Camera_Ppl_0002, TestSize.Level1)
73 {
74 std::cout << "==========[test log]Check ppl: preview + capture success." << std::endl;
75 // Configure two stream information
76 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
77 Test_->StartStream(Test_->intents);
78 // Capture preview stream
79 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
80 // Capture camera stream, continuous capture
81 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
82 // Post-processing
83 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
84 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
85 Test_->StopStream(Test_->captureIds, Test_->streamIds);
86 }
87
88 /**
89 * @tc.name: Check ppl
90 * @tc.desc: preview + video success.
91 * @tc.size: MediumTest
92 * @tc.type: Function
93 */
94 HWTEST_F(PipelineTest, Camera_Ppl_0003, TestSize.Level1)
95 {
96 std::cout << "==========[test log]Check ppl:Check ppl: preview + video success." << std::endl;
97 // Configure two stream information
98 Test_->intents = {Camera::PREVIEW, Camera::VIDEO};
99 Test_->StartStream(Test_->intents);
100 // Capture preview stream
101 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
102 // Capture video stream
103 Test_->StartCapture(Test_->streamId_video, Test_->captureId_video, false, true);
104 // Post-processing
105 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_video};
106 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_video};
107 Test_->StopStream(Test_->captureIds, Test_->streamIds);
108 }
109
110 /**
111 * @tc.name: Check ppl
112 * @tc.desc: video mode without preview, system not support, expected return fail.
113 * @tc.size: MediumTest
114 * @tc.type: Function
115 */
116 HWTEST_F(PipelineTest, Camera_Ppl_0004, TestSize.Level2)
117 {
118 std::cout << "==========[test log]Check ppl:Video mode no preview, not support, expected fail." << std::endl;
119 EXPECT_EQ(true, Test_->cameraDevice != nullptr);
120 Test_->CreateStreamOperatorCallback();
121 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
122 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
123 if (Test_->rc == Camera::NO_ERROR) {
124 std::cout << "==========[test log]Check ppl: GetStreamOperator success." << std::endl;
125 } else {
126 std::cout << "==========[test log]Check ppl: GetStreamOperator fail, rc = " << Test_->rc << std::endl;
127 }
128 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
129 Test_->streamInfo->streamId_ = Test_->streamId_video;
130 Test_->streamInfo->width_ = STREAMINFO_WIDTH1;
131 Test_->streamInfo->height_ = STREAMINFO_HEIGHT1;
132 Test_->StreamInfoFormat();
133 Test_->streamInfo->datasapce_ = STREAMINFO_DATASPACE1;
134 Test_->streamInfo->intent_ = Camera::VIDEO;
135 Test_->streamInfo->tunneledMode_ = STREAMINFO_TUNNELED_MODE;
136 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
137 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
138 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon21311b120102(OHOS::SurfaceBuffer* buffer) 139 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
140 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
141 });
142 #else
__anon21311b120202(void* addr, uint32_t size) 143 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) {
144 Test_->SaveYUV("preview", addr, size);
145 });
146 #endif
147 Test_->streamInfo->bufferQueue_->SetQueueSize(QUEUE_SIZE);
148 Test_->consumerMap_[Camera::PREVIEW] = consumer;
149 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
150 Test_->streamInfos.push_back(Test_->streamInfo);
151 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
152 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
153 std::cout << "==========[test log]CreateStreams rc = " << Test_->rc << std::endl;
154 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
155 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT);
156 std::cout << "==========[test log]CommitStreams rc = " << Test_->rc << std::endl;
157 // Post-processing
158 Test_->streamIds = {Test_->streamId_video};
159 Test_->StopStream(Test_->captureIds, Test_->streamIds);
160 }
161
162 /**
163 * @tc.name: Only Still_capture stream
164 * @tc.desc: Only Still_capture stream, capture->isStreaming = false.
165 * @tc.size: MediumTest
166 * @tc.type: Function
167 */
168 HWTEST_F(PipelineTest, Camera_Ppl_0005, TestSize.Level1)
169 {
170 std::cout << "==========[test log]check ppl: Still_capture stream, capture->isStreaming = false." << std::endl;
171 // Start stream
172 Test_->intents = {Camera::STILL_CAPTURE};
173 Test_->StartStream(Test_->intents);
174 // Start capture
175 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, false);
176 // Post-processing
177 Test_->streamIds = {Test_->streamId_capture};
178 Test_->StopStream(Test_->captureIds, Test_->streamIds);
179 }
180
181 /**
182 * @tc.name: Only Still_capture stream
183 * @tc.desc: Only Still_capture stream, capture->isStreaming = true.
184 * @tc.size: MediumTest
185 * @tc.type: Function
186 */
187 HWTEST_F(PipelineTest, Camera_Ppl_0006, TestSize.Level1)
188 {
189 std::cout << "==========[test log]check ppl: Still_capture stream, capture->isStreaming = true." << std::endl;
190 // Start stream
191 Test_->intents = {Camera::STILL_CAPTURE};
192 Test_->StartStream(Test_->intents);
193 // Start capture
194 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
195 // Post-processing
196 Test_->captureIds = {Test_->captureId_capture};
197 Test_->streamIds = {Test_->streamId_capture};
198 Test_->StopStream(Test_->captureIds, Test_->streamIds);
199 }
200
201 #ifndef CAMERA_BUILT_ON_OHOS_LITE
202 /**
203 * @tc.name: Check ppl
204 * @tc.desc: double preview streams.
205 * @tc.size: MediumTest
206 * @tc.type: Function
207 */
208 HWTEST_F(PipelineTest, Camera_Ppl_0007, TestSize.Level1)
209 {
210 std::cout << "==========[test log]Check ppl: double preview streams." << std::endl;
211 // Create and get streamOperator information
212 Test_->streamOperatorCallback = new StreamOperatorCallback();
213 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
214 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
215 // Create data stream 1
216 Test_->streamInfo = std::make_shared<StreamInfo>();
217 Test_->streamInfo->streamId_ = Test_->streamId_preview;
218 Test_->streamInfo->width_ = STREAMINFO_WIDTH2;
219 Test_->streamInfo->height_ = STREAMINFO_HEIGHT2;
220 Test_->streamInfo->datasapce_ = STREAMINFO_DATASPACE2;
221 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
222 Test_->streamInfo->intent_ = Camera::PREVIEW;
223 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
224 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon21311b120302(void* addr, uint32_t size) 225 Test_->streamInfo->bufferQueue_ = preview_consumer->CreateProducer([this](void* addr, uint32_t size) {
226 Test_->SaveYUV("preview", addr, size);
227 });
228 Test_->streamInfo->bufferQueue_->SetQueueSize(QUEUE_SIZE);
229 Test_->consumerMap_[Camera::PREVIEW] = preview_consumer;
230 Test_->streamInfo->tunneledMode_ = STREAMINFO_TUNNELED_MODE;
231 std::vector<std::shared_ptr<StreamInfo>>().swap(Test_->streamInfos);
232 Test_->streamInfos.push_back(Test_->streamInfo);
233
234 // Create data stream 2
235 Test_->streamInfo2 = std::make_shared<StreamInfo>();
236 Test_->streamInfo2->streamId_ = Test_->streamId_preview_double;
237 Test_->streamInfo2->width_ = STREAMINFO_WIDTH2;
238 Test_->streamInfo2->height_ = STREAMINFO_HEIGHT2;
239 Test_->streamInfo2->datasapce_ = STREAMINFO_DATASPACE2;
240 Test_->streamInfo2->format_ = PIXEL_FMT_YCRCB_420_SP;
241 Test_->streamInfo2->intent_ = Camera::PREVIEW;
242 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer2 =
243 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon21311b120402(void* addr, uint32_t size) 244 Test_->streamInfo2->bufferQueue_ = preview_consumer2->CreateProducer([this](void* addr, uint32_t size) {
245 Test_->SaveYUV("preview2", addr, size);
246 });
247 Test_->streamInfo2->bufferQueue_->SetQueueSize(QUEUE_SIZE);
248 Test_->consumerMap_[Camera::PREVIEW] = preview_consumer2;
249 Test_->streamInfo2->tunneledMode_ = STREAMINFO_TUNNELED_MODE;
250 Test_->streamInfos.push_back(Test_->streamInfo2);
251
252 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
253 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
254 // Flow distribution
255 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
256 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
257 // Get preview
258 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
259 Test_->StartCapture(Test_->streamId_preview_double, Test_->captureId_preview_double, false, true);
260 // Release stream
261 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_preview_double};
262 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_preview_double};
263 Test_->StopStream(Test_->captureIds, Test_->streamIds);
264 }
265 #endif