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