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
16 #include "utest_stream_operator_impl.h"
17 #include "stream_operator_callback.h"
18 #include "istream_operator_callback.h"
19
20 #define SURFACE_ID (12345 + 666 + 2333)
21 const int CAMERA_BUFFER_QUEUE_IPC = 654320;
22
SetUpTestCase(void)23 void StreamOperatorImplTest::SetUpTestCase(void)
24 {
25 std::cout << "Camera::StreamOperatorImpl SetUpTestCase" << std::endl;
26 }
27
TearDownTestCase(void)28 void StreamOperatorImplTest::TearDownTestCase(void)
29 {
30 std::cout << "Camera::StreamOperatorImpl TearDownTestCase" << std::endl;
31 }
32
SetUp(void)33 void StreamOperatorImplTest::SetUp(void)
34 {
35 bool ret = InitCameraHost();
36 if (!ret) {
37 std::cout << "StreamOperatorImplTest init camerahost failed" << std::endl;
38 return;
39 }
40
41 ret = GetCameraIds();
42 if (!ret) {
43 std::cout << "StreamOperatorImplTest init GetCameraIds failed" << std::endl;
44 return;
45 }
46
47 ret = GetCameraDevice();
48 if (!ret) {
49 std::cout << "StreamOperatorImplTest init GetCameraDevice failed" << std::endl;
50 return;
51 }
52
53 ret = GetStreamOperator();
54 if (!ret) {
55 std::cout << "StreamOperatorImplTest init GetStreamOperator failed" << std::endl;
56 return;
57 }
58 }
59
TearDown(void)60 void StreamOperatorImplTest::TearDown(void)
61 {
62 std::cout << "Camera::StreamOperatorImpl TearDown.." << std::endl;
63 }
64
65 HWTEST_F(StreamOperatorImplTest, UTestIsStreamsSupported, TestSize.Level0)
66 {
67 EXPECT_EQ(false, cameraDevice_ == nullptr);
68 bool rc = GetStreamOperator();
69 EXPECT_EQ(true, rc);
70
71 OperationMode mode = NORMAL;
72 std::shared_ptr<CameraMetadata> modeSetting = std::make_shared<CameraMetadata>(2, 128);
73 int64_t expoTime = 0;
74 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
75 int64_t colorGains[4] = {0};
76 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
77 std::shared_ptr<StreamInfo> streamInfo = std::make_shared<StreamInfo>();
78 streamInfo->width_ = 1280;
79 streamInfo->height_ = 720;
80 streamInfo->format_ = CAMERA_FORMAT_RGBA_8888;
81 streamInfo->datasapce_ = 10;
82 streamInfo->intent_ = PREVIEW;
83 streamInfo->tunneledMode_ = 5;
84 std::vector<std::shared_ptr<StreamInfo>> infos;
85 infos.push_back(streamInfo);
86 StreamSupportType pType;
87 OHOS::Camera::CamRetCode ret = streamOperator_->IsStreamsSupported(
88 mode, modeSetting, infos, pType);
89 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
90 }
91
92 HWTEST_F(StreamOperatorImplTest, UTestCapture, TestSize.Level0)
93 {
94 OperationMode operationMode = NORMAL;
95 StreamSupportType supportType;
96 std::vector<std::shared_ptr<StreamInfo>> streamInfos;
97 std::shared_ptr<StreamInfo> streamInfo = std::make_shared<StreamInfo>();
98 streamInfo->streamId_ = 1005;
99 streamInfo->width_ = 640;
100 streamInfo->height_ = 480;
101 streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
102 streamInfo->datasapce_ = 8;
103 streamInfo->intent_ = PREVIEW;
104 std::shared_ptr<StreamConsumer> previewConsumer = std::make_shared<StreamConsumer>();
105 #ifdef CAMERA_BUILT_ON_OHOS_LITE
106 streamInfo->bufferQueue_ = previewConsumer->CreateProducer(
__anon66092c730102(OHOS::SurfaceBuffer* buffer) 107 [](OHOS::SurfaceBuffer* buffer) {
108 std::cout << "received a preview buffer ..." << std::endl; });
109 #else
110 streamInfo->bufferQueue_ = previewConsumer->CreateProducer(
__anon66092c730202(void* addr, uint32_t size) 111 [](void* addr, uint32_t size) {
112 std::cout << "received a preview buffer ..." << std::endl; });
113 #endif
114 streamInfo->bufferQueue_->SetQueueSize(8);
115 streamInfo->tunneledMode_ = 5;
116 streamInfos.push_back(streamInfo);
117
118 OHOS::Camera::CamRetCode ret = streamOperator_->CreateStreams(streamInfos);
119 std::cout << "streamOperator->CreateStreams = " << ret << std::endl;
120 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
121
122 std::vector<std::string> cameraIds;
123 ret = cameraHost_->GetCameraIds(cameraIds);
124 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
125
126 std::shared_ptr<CameraAbility> ability = nullptr;
127 std::string cameraId = cameraIds.front();
128 ret = cameraHost_->GetCameraAbility(cameraId, ability);
129 ret = streamOperator_->CommitStreams(NORMAL, ability);
130 EXPECT_EQ(true, ret == Camera::NO_ERROR);
131
132 int captureId = 2001;
133 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
134 captureInfo->streamIds_ = {streamInfo->streamId_};
135 captureInfo->captureSetting_ = ability;
136 captureInfo->enableShutterCallback_ = false;
137 ret = streamOperator_->Capture(captureId, captureInfo, true);
138 std::cout << "streamOperator->Capture = " << ret << std::endl;
139 EXPECT_EQ(true, ret == Camera::NO_ERROR);
140 sleep(5);
141
142 ret = streamOperator_->CancelCapture(captureId);
143 EXPECT_EQ(true, ret == Camera::NO_ERROR);
144
145 std::vector<int> streamIds = {1005};
146 ret = streamOperator_->ReleaseStreams(streamIds);
147 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
148 }
149
150 HWTEST_F(StreamOperatorImplTest, UTestCreateStreams, TestSize.Level0)
151 {
152 OperationMode operationMode = NORMAL;
153 StreamSupportType supportType;
154 std::vector<std::shared_ptr<StreamInfo>> streamInfos;
155 std::shared_ptr<StreamInfo> streamInfo = std::make_shared<StreamInfo>();
156 streamInfo->streamId_ = 1001;
157 streamInfo->width_ = 720;
158 streamInfo->height_ = 480;
159 streamInfo->intent_ = PREVIEW;
160 streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
161 streamInfo->datasapce_ = 8;
162 StreamConsumer previewConsumer;
163 streamInfo->tunneledMode_ = 5;
164 #ifdef CAMERA_BUILT_ON_OHOS_LITE
165 streamInfo->bufferQueue_ = previewConsumer.CreateProducer(
__anon66092c730302(OHOS::SurfaceBuffer* buffer) 166 [](OHOS::SurfaceBuffer* buffer) {
167 std::cout << "received a preview buffer ..." << std::endl; });
168 #else
169 streamInfo->bufferQueue_ = previewConsumer.CreateProducer(
__anon66092c730402(void* addr, uint32_t size) 170 [](void* addr, uint32_t size) {
171 std::cout << "received a preview buffer ..." << std::endl; });
172 #endif
173 streamInfos.push_back(streamInfo);
174
175 std::shared_ptr<StreamInfo> streamInfoSnapshot = std::make_shared<StreamInfo>();
176 streamInfoSnapshot->streamId_ = 1002;
177 streamInfoSnapshot->width_ = 720;
178 streamInfoSnapshot->height_ = 480;
179 streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
180 streamInfoSnapshot->datasapce_ = 8;
181 streamInfoSnapshot->intent_ = STILL_CAPTURE;
182 StreamConsumer snapshotConsumer;
183 #ifdef CAMERA_BUILT_ON_OHOS_LITE
184 streamInfoSnapshot->bufferQueue_ = snapshotConsumer.CreateProducer(
__anon66092c730502(OHOS::SurfaceBuffer* buffer) 185 [](OHOS::SurfaceBuffer* buffer) {
186 std::cout << "received a snapshot buffer ..." << std::endl; });
187 #else
188 streamInfoSnapshot->bufferQueue_ = snapshotConsumer.CreateProducer(
__anon66092c730602(void* addr, uint32_t size) 189 [](void* addr, uint32_t size) {
190 std::cout << "received a snapshot buffer ..." << std::endl; });
191 #endif
192 streamInfoSnapshot->tunneledMode_ = 5;
193 streamInfos.push_back(streamInfoSnapshot);
194
195 OHOS::Camera::CamRetCode ret = streamOperator_->CreateStreams(streamInfos);
196 std::cout << "streamOperator->CreateStreams = " << ret << std::endl;
197 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
198
199 std::vector<int> streamIds = {1001, 1002};
200 ret = streamOperator_->ReleaseStreams(streamIds);
201 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
202 }
203 #ifdef CAMERA_BUILT_ON_OHOS_LITE
204 HWTEST_F(StreamOperatorImplTest, UTestAttachBufferQueue, TestSize.Level0)
205 {
206 OperationMode operationMode = NORMAL;
207 StreamSupportType supportType;
208 std::vector<std::shared_ptr<StreamInfo>> streamInfos;
209 std::shared_ptr<StreamInfo> streamInfo = std::make_shared<StreamInfo>();
210 streamInfo->streamId_ = 1011;
211 streamInfo->width_ = 720;
212 streamInfo->height_ = 480;
213 streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
214 streamInfo->datasapce_ = 8;
215 streamInfo->intent_ = PREVIEW;
216 StreamConsumer previewConsumer;
217 streamInfo->bufferQueue_ = previewConsumer.CreateProducer(
__anon66092c730702(OHOS::SurfaceBuffer* buffer) 218 [](OHOS::SurfaceBuffer* buffer) {
219 std::cout << "received a preview buffer ..." << std::endl; });
220 streamInfo->tunneledMode_ = 5;
221 streamInfos.push_back(streamInfo);
222
223 std::shared_ptr<StreamInfo> streamInfoSnapshot = std::make_shared<StreamInfo>();
224 streamInfoSnapshot->streamId_ = 1012;
225 streamInfoSnapshot->width_ = 1920;
226 streamInfoSnapshot->datasapce_ = 8;
227 streamInfoSnapshot->height_ = 960;
228 streamInfoSnapshot->intent_ = STILL_CAPTURE;
229 streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
230 StreamConsumer snapshotConsumer;
231 streamInfoSnapshot->bufferQueue_ = snapshotConsumer.CreateProducer(
__anon66092c730802(OHOS::SurfaceBuffer* buffer) 232 [](OHOS::SurfaceBuffer* buffer) {
233 std::cout << "received a snapshot buffer ..." << std::endl; });
234 streamInfoSnapshot->tunneledMode_ = 5;
235 streamInfos.push_back(streamInfoSnapshot);
236
237 OHOS::Camera::CamRetCode ret = streamOperator_->CreateStreams(streamInfos);
238 std::cout << "streamOperator->CreateStreams = " << ret << std::endl;
239 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
240
241 StreamConsumer preview_consumer;
242 OHOS::sptr<OHOS::IBufferProducer> producer =
__anon66092c730902(OHOS::SurfaceBuffer* buffer) 243 preview_consumer.CreateProducer([](OHOS::SurfaceBuffer* buffer) {
244 std::cout << "receive a frame..." << std::endl;
245 });
246 ret = streamOperator_->AttachBufferQueue(streamInfo->streamId_, producer);
247 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
248
249 ret = streamOperator_->DetachBufferQueue(streamInfo->streamId_);
250 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
251
252 std::vector<int> streamIds = {1011, 1012};
253 ret = streamOperator_->ReleaseStreams(streamIds);
254 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
255 }
256 #else
257 HWTEST_F(StreamOperatorImplTest, UTestAttachBufferQueue, TestSize.Level0)
258 {
259 OperationMode operationMode = NORMAL;
260 StreamSupportType supportType;
261 std::vector<std::shared_ptr<StreamInfo>> streamInfos;
262 std::shared_ptr<StreamInfo> streamInfo = std::make_shared<StreamInfo>();
263 streamInfo->streamId_ = 1011;
264 streamInfo->width_ = 720;
265 streamInfo->height_ = 480;
266 streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
267 streamInfo->datasapce_ = 8;
268 streamInfo->intent_ = PREVIEW;
269 StreamConsumer previewConsumer;
270 streamInfo->bufferQueue_ = previewConsumer.CreateProducer(
__anon66092c730a02(void* addr, uint32_t size) 271 [](void* addr, uint32_t size) {
272 std::cout << "received a preview buffer ..." << std::endl; });
273 streamInfo->tunneledMode_ = 5;
274 streamInfos.push_back(streamInfo);
275
276 std::shared_ptr<StreamInfo> streamInfoSnapshot = std::make_shared<StreamInfo>();
277 streamInfoSnapshot->streamId_ = 1012;
278 streamInfoSnapshot->width_ = 1920;
279 streamInfoSnapshot->datasapce_ = 8;
280 streamInfoSnapshot->height_ = 960;
281 streamInfoSnapshot->intent_ = STILL_CAPTURE;
282 streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
283 StreamConsumer snapshotConsumer;
284 streamInfoSnapshot->bufferQueue_ = snapshotConsumer.CreateProducer(
__anon66092c730b02(void* addr, uint32_t size) 285 [](void* addr, uint32_t size) {
286 std::cout << "received a snapshot buffer ..." << std::endl; });
287 streamInfoSnapshot->tunneledMode_ = 5;
288 streamInfos.push_back(streamInfoSnapshot);
289
290 OHOS::Camera::CamRetCode ret = streamOperator_->CreateStreams(streamInfos);
291 std::cout << "streamOperator->CreateStreams = " << ret << std::endl;
292 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
293
294 StreamConsumer preview_consumer;
295 OHOS::sptr<OHOS::IBufferProducer> producer =
__anon66092c730c02(void* addr, uint32_t size) 296 preview_consumer.CreateProducer([this](void* addr, uint32_t size) {
297 std::cout << "receive a frame..." << std::endl;
298 });
299 ret = streamOperator_->AttachBufferQueue(streamInfo->streamId_, producer);
300 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
301
302 ret = streamOperator_->DetachBufferQueue(streamInfo->streamId_);
303 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
304
305 std::vector<int> streamIds = {1011, 1012};
306 ret = streamOperator_->ReleaseStreams(streamIds);
307 EXPECT_EQ(true, ret == OHOS::Camera::NO_ERROR);
308 }
309 #endif
310