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