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 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 #include "double_preview_test.h"
16
17 using namespace testing::ext;
18
SetUpTestCase(void)19 void DoublePreviewTest::SetUpTestCase(void)
20 {}
TearDownTestCase(void)21 void DoublePreviewTest::TearDownTestCase(void)
22 {}
SetUp(void)23 void DoublePreviewTest::SetUp(void)
24 {
25 if (display_ == nullptr) {
26 display_ = std::make_shared<TestDisplay>();
27 }
28 display_->Init();
29 }
TearDown(void)30 void DoublePreviewTest::TearDown(void)
31 {
32 display_->Close();
33 }
34
SetStreamInfo(StreamInfo & streamInfo,const std::shared_ptr<StreamCustomer> & streamCustomer,const int streamId,const StreamIntent intent)35 void DoublePreviewTest::SetStreamInfo(StreamInfo &streamInfo,
36 const std::shared_ptr<StreamCustomer> &streamCustomer,
37 const int streamId, const StreamIntent intent)
38 {
39 sptr<OHOS::IBufferProducer> producer;
40 constexpr uint32_t DATA_SPACE = 8; // picture dataspace
41 constexpr uint32_t TUNNEL_MODE = 5; // tunnel mode
42 constexpr uint32_t BUFFER_QUEUE_SIZE = 8; // set bufferQueue size
43 if (intent == PREVIEW) {
44 streamInfo.width_ = PREVIEW_WIDTH;
45 streamInfo.height_ = PREVIEW_HEIGHT;
46 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
47 if (streamId == display_->STREAM_ID_PREVIEW) {
48 streamInfo.streamId_ = streamId;
49 } else if (streamId == STREAMID_PREVIEW_DOUBLE) {
50 streamInfo.streamId_ = streamId;
51 }
52 }
53 streamInfo.dataspace_ = DATA_SPACE;
54 streamInfo.intent_ = intent;
55 streamInfo.tunneledMode_ = TUNNEL_MODE;
56 producer = streamCustomer->CreateProducer();
57 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
58 streamInfo.bufferQueue_->producer_->SetQueueSize(BUFFER_QUEUE_SIZE);
59 }
60
CreateStream(int streamId,StreamIntent intent)61 void DoublePreviewTest::CreateStream(int streamId, StreamIntent intent)
62 {
63 StreamInfo streamInfo = {};
64
65 if (intent == PREVIEW) {
66 if (streamId == display_->STREAM_ID_PREVIEW) {
67 if (streamCustomerPreview_ == nullptr) {
68 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
69 SetStreamInfo(streamInfo, streamCustomerPreview_, streamId, intent);
70 std::vector<StreamInfo>().swap(streamInfos_);
71 streamInfos_.push_back(streamInfo);
72 }
73 } else if (streamId == STREAMID_PREVIEW_DOUBLE) {
74 if (streamCustomerPreviewDouble_ == nullptr) {
75 streamCustomerPreviewDouble_ = std::make_shared<StreamCustomer>();
76 SetStreamInfo(streamInfo, streamCustomerPreviewDouble_, streamId, intent);
77 std::vector<StreamInfo>().swap(streamInfos_);
78 streamInfos_.push_back(streamInfo);
79 }
80 }
81 }
82 result_ = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos_);
83 EXPECT_EQ(false, result_!= HDI::Camera::V1_0::NO_ERROR);
84 if (result_ == HDI::Camera::V1_0::NO_ERROR) {
85 std::cout << "==========[test log]CreateStreams success." << std::endl;
86 } else {
87 std::cout << "==========[test log]CreateStreams fail, result_ = " << result_ << std::endl;
88 }
89 }
90
CommitStream()91 void DoublePreviewTest::CommitStream()
92 {
93 result_ = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
94 EXPECT_EQ(false, result_ != HDI::Camera::V1_0::NO_ERROR);
95 if (result_ == HDI::Camera::V1_0::NO_ERROR) {
96 std::cout << "==========[test log]CommitStreams preview success." << std::endl;
97 } else {
98 std::cout << "==========[test log]CommitStreams preview fail, result_ = " << result_ << std::endl;
99 }
100 }
101
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming)102 void DoublePreviewTest::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming)
103 {
104 captureInfo_.streamIds_ = {streamId};
105 captureInfo_.captureSetting_ = display_->ability_;
106 captureInfo_.enableShutterCallback_ = shutterCallback;
107 constexpr uint32_t TIME_FOR_WAIT_IMAGE_PREVIEW = 2; // sleep two second
108 result_ = (CamRetCode)display_->streamOperator->Capture(captureId, captureInfo_, isStreaming);
109 EXPECT_EQ(true, result_ == HDI::Camera::V1_0::NO_ERROR);
110 if (result_ == HDI::Camera::V1_0::NO_ERROR) {
111 std::cout << "==========[test log]check Capture: Capture success, " << captureId << std::endl;
112 } else {
113 std::cout << "==========[test log]check Capture: Capture fail, result_ = " << result_ << captureId << std::endl;
114 }
115 if (captureId == display_->CAPTURE_ID_PREVIEW) {
116 streamCustomerPreview_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
117 std::cout << "==========[test log]preview size= " <<
118 size << std::endl;
119 });
120 } else if (captureId == CAPTUREID_PREVIEW_DOUBLE) {
121 streamCustomerPreviewDouble_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
122 std::cout << "==========[test log]preview double size= " <<
123 size << std::endl;
124 });
125 } else {
126 std::cout << "==========[test log]StartCapture ignore command " << std::endl;
127 }
128 sleep(TIME_FOR_WAIT_IMAGE_PREVIEW);
129 }
130
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)131 void DoublePreviewTest::StopStream(std::vector<int> &captureIds, std::vector<int> &streamIds)
132 {
133 if (sizeof(captureIds_) > 0) {
134 for (const auto &captureId : captureIds_) {
135 if (captureId == display_->CAPTURE_ID_PREVIEW) {
136 streamCustomerPreview_->ReceiveFrameOff();
137 } else if (captureId == CAPTUREID_PREVIEW_DOUBLE) {
138 streamCustomerPreviewDouble_->ReceiveFrameOff();
139 } else {
140 std::cout << "==========[test log]StopStream ignore command. " << std::endl;
141 }
142 }
143 for (auto &captureId : captureIds_) {
144 result_ = (CamRetCode)display_->streamOperator->CancelCapture(captureId);
145 EXPECT_EQ(true, result_ == HDI::Camera::V1_0::NO_ERROR);
146 if (result_ == HDI::Camera::V1_0::NO_ERROR) {
147 std::cout << "==========[test log]check Capture: CancelCapture success," << captureId << std::endl;
148 } else {
149 std::cout << "==========[test log]check Capture: CancelCapture fail, result_ = " << result_;
150 std::cout << "captureId = " << captureId << std::endl;
151 }
152 }
153 }
154
155 if (sizeof(streamIds_) > 0) {
156 result_ = (CamRetCode)display_->streamOperator->ReleaseStreams(streamIds_);
157 EXPECT_EQ(true, result_ == HDI::Camera::V1_0::NO_ERROR);
158 if (result_ == HDI::Camera::V1_0::NO_ERROR) {
159 std::cout << "==========[test log]check Capture: ReleaseStreams success." << std::endl;
160 } else {
161 std::cout << "==========[test log]check Capture: ReleaseStreams fail, result_ = " << result_ << std::endl;
162 std::cout << "streamIds_ = " << streamIds_.front() << std::endl;
163 }
164 }
165 }
166
167 /**
168 * @tc.name: double preview
169 * @tc.desc: Commit 2 streams together, Double preview streams, isStreaming is true.
170 * @tc.level: Level1
171 * @tc.size: MediumTest
172 * @tc.type: Function
173 */
174 static HWTEST_F(DoublePreviewTest, double_preview_001, TestSize.Level1)
175 {
176 // Get the stream manager
177 display_->AchieveStreamOperator();
178
179 // Start stream
180 CreateStream(display_->STREAM_ID_PREVIEW, PREVIEW);
181 CreateStream(STREAMID_PREVIEW_DOUBLE, PREVIEW);
182
183 // Commit stream
184 CommitStream();
185
186 // Get preview
187 StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
188 StartCapture(STREAMID_PREVIEW_DOUBLE, CAPTUREID_PREVIEW_DOUBLE, false, true);
189
190 constexpr uint32_t TIME_FOR_WAIT_IMAGE_PREVIEW = 10; // sleep ten second
191 sleep(TIME_FOR_WAIT_IMAGE_PREVIEW);
192
193 streamIds_ = {display_->STREAM_ID_PREVIEW, STREAMID_PREVIEW_DOUBLE};
194 captureIds_ = {display_->CAPTURE_ID_PREVIEW, CAPTUREID_PREVIEW_DOUBLE};
195 StopStream(captureIds_, streamIds_);
196 }
197
198 /**
199 * @tc.name: double preview and still_capture
200 * @tc.desc: Commit 3 streams together, Double preview and still_capture streams, isStreaming is true.
201 * @tc.level: Level1
202 * @tc.size: MediumTest
203 * @tc.type: Function
204 */
205 static HWTEST_F(DoublePreviewTest, double_preview_002, TestSize.Level1)
206 {
207 // Get the stream manager
208 display_->AchieveStreamOperator();
209
210 // Start stream
211 CreateStream(display_->STREAM_ID_PREVIEW, PREVIEW);
212 CreateStream(STREAMID_PREVIEW_DOUBLE, PREVIEW);
213 display_->intents = {STILL_CAPTURE};
214 display_->StartStream(display_->intents);
215
216 // Get preview
217 StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
218 StartCapture(STREAMID_PREVIEW_DOUBLE, CAPTUREID_PREVIEW_DOUBLE, false, true);
219 // add dumy exif info
220 constexpr double latitude = 27.987500; // dummy data: Qomolangma latitde
221 constexpr double longitude = 86.927500; // dummy data: Qomolangma longituude
222 constexpr double altitude = 8848.86; // dummy data: Qomolangma altitude
223 constexpr size_t entryCapacity = 100;
224 constexpr size_t dataCapacity = 2000;
225 std::shared_ptr<CameraSetting> captureSetting =
226 std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
227 std::vector<double> gps;
228 gps.push_back(latitude);
229 gps.push_back(longitude);
230 gps.push_back(altitude);
231 captureSetting->addEntry(OHOS_JPEG_GPS_COORDINATES, gps.data(), gps.size());
232 std::vector<uint8_t> setting;
233 MetadataUtils::ConvertMetadataToVec(captureSetting, setting);
234
235 CaptureInfo captureInfo = {};
236 captureInfo.streamIds_ = {display_->STREAM_ID_CAPTURE};
237 captureInfo.captureSetting_ = setting;
238 captureInfo.enableShutterCallback_ = false;
239 display_->rc = (CamRetCode)display_->streamOperator->Capture(display_->CAPTURE_ID_CAPTURE, captureInfo, true);
240 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
241 if (display_->rc == HDI::Camera::V1_0::NO_ERROR) {
242 std::cout << "==========[test log]check Capture: Capture success, " <<
243 display_->CAPTURE_ID_CAPTURE << std::endl;
244 } else {
245 std::cout << "==========[test log]check Capture: Capture fail, rc = " << display_->rc
246 << display_->CAPTURE_ID_CAPTURE << std::endl;
247 }
__anon453833590302(const unsigned char *addr, const uint32_t size) 248 display_->streamCustomerCapture_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
249 display_->StoreImage(addr, size);
250 });
251
252 constexpr uint32_t TIME_FOR_WAIT_IMAGE_PREVIEW = 5; // sleep five second
253 sleep(TIME_FOR_WAIT_IMAGE_PREVIEW);
254
255 streamIds_ = {display_->STREAM_ID_PREVIEW, STREAMID_PREVIEW_DOUBLE};
256 captureIds_ = {display_->CAPTURE_ID_PREVIEW, CAPTUREID_PREVIEW_DOUBLE};
257 std::vector<int> captureIds = {display_->CAPTURE_ID_CAPTURE};
258 std::vector<int> streamIds = {display_->STREAM_ID_CAPTURE};
259 StopStream(captureIds_, streamIds_);
260 display_->StopStream(captureIds, streamIds);
261 }
262
263 /**
264 * @tc.name: double preview and video
265 * @tc.desc: Commit 3 streams together, Double preview and video streams, isStreaming is true.
266 * @tc.level: Level1
267 * @tc.size: MediumTest
268 * @tc.type: Function
269 */
270 static HWTEST_F(DoublePreviewTest, double_preview_003, TestSize.Level1)
271 {
272 // Get the stream manager
273 display_->AchieveStreamOperator();
274
275 // Start stream
276 CreateStream(display_->STREAM_ID_PREVIEW, PREVIEW);
277 CreateStream(STREAMID_PREVIEW_DOUBLE, PREVIEW);
278 display_->intents = {VIDEO};
279 display_->StartStream(display_->intents);
280
281 // Get preview
282 StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
283 StartCapture(STREAMID_PREVIEW_DOUBLE, CAPTUREID_PREVIEW_DOUBLE, false, true);
284 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
285
286 constexpr uint32_t TIME_FOR_WAIT_IMAGE_PREVIEW = 5; // sleep five second
287 sleep(TIME_FOR_WAIT_IMAGE_PREVIEW);
288
289 streamIds_ = {display_->STREAM_ID_PREVIEW, STREAMID_PREVIEW_DOUBLE};
290 captureIds_ = {display_->CAPTURE_ID_PREVIEW, CAPTUREID_PREVIEW_DOUBLE};
291 std::vector<int> captureIds = {display_->CAPTURE_ID_VIDEO};
292 std::vector<int> streamIds = {display_->STREAM_ID_VIDEO};
293 StopStream(captureIds_, streamIds_);
294 display_->StopStream(captureIds, streamIds);
295 }
296