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 (cameraBase_ == nullptr) {
27         cameraBase_ = std::make_shared<TestCameraBase>();
28     }
29     cameraBase_->Init();
30 }
TearDown(void)31 void DoublePreviewTest::TearDown(void)
32 {
33     cameraBase_->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 dataSpace = 8; // picture dataspace
42     constexpr uint32_t tunnelMode = 5; // tunnel mode
43     constexpr uint32_t bufferQueueSize = 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_ = dataSpace;
51     streamInfo.intent_ = intent;
52     streamInfo.tunneledMode_ = tunnelMode;
53     producer = streamCustomer->CreateProducer();
54     streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
55     ASSERT_NE(streamInfo.bufferQueue_, nullptr);
56     streamInfo.bufferQueue_->producer_->SetQueueSize(bufferQueueSize);
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 == cameraBase_->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)cameraBase_->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)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->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_ = cameraBase_->ability_;
104     captureInfo_.enableShutterCallback_ = shutterCallback;
105     constexpr uint32_t timeForWaitImagePreview = 2; // sleep two second
106     result_ = (CamRetCode)cameraBase_->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 == cameraBase_->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(timeForWaitImagePreview);
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 (captureIds.size() == 0) {
131         return;
132     }
133     for (const auto &captureId : captureIds) {
134         if (captureId == cameraBase_->CAPTURE_ID_PREVIEW) {
135             streamCustomerPreview_->ReceiveFrameOff();
136         } else if (captureId == CAPTUREID_PREVIEW_DOUBLE) {
137             streamCustomerPreviewDouble_->ReceiveFrameOff();
138         }  else if (captureId == cameraBase_->CAPTURE_ID_CAPTURE) {
139             cameraBase_->streamCustomerCapture_->ReceiveFrameOff();
140         } else if (captureId == cameraBase_->CAPTURE_ID_VIDEO) {
141             cameraBase_->streamCustomerVideo_->ReceiveFrameOff();
142             sleep(TIME_FOR_WAIT_CANCEL_CAPTURE);
143             cameraBase_->CloseFd();
144         } else {
145             CAMERA_LOGE("StopStream ignore command.");
146         }
147     }
148     for (auto &captureId : captureIds) {
149         result_ = (CamRetCode)cameraBase_->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     cameraBase_->AchieveStreamOperator();
172 
173     // Start stream
174     CreateStream(cameraBase_->STREAM_ID_PREVIEW, PREVIEW);
175     CreateStream(STREAMID_PREVIEW_DOUBLE, PREVIEW);
176 
177     // Commit stream
178     CommitStream();
179 
180     // Get preview
181     StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
182     StartCapture(STREAMID_PREVIEW_DOUBLE, CAPTUREID_PREVIEW_DOUBLE, false, true);
183 
184     constexpr uint32_t timeForWaitImagePreview = 10; // sleep ten second
185     sleep(timeForWaitImagePreview);
186 
187     std::vector<int> captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, CAPTUREID_PREVIEW_DOUBLE};
188     std::vector<int> streamIds = {cameraBase_->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     cameraBase_->AchieveStreamOperator();
203 
204     // Start stream
205     CreateStream(cameraBase_->STREAM_ID_PREVIEW, PREVIEW);
206     CreateStream(STREAMID_PREVIEW_DOUBLE, PREVIEW);
207     cameraBase_->intents = {STILL_CAPTURE};
208     cameraBase_->StartStream(cameraBase_->intents);
209 
210     // Get preview
211     StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->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_ = {cameraBase_->STREAM_ID_CAPTURE};
231     captureInfo.captureSetting_ = setting;
232     captureInfo.enableShutterCallback_ = false;
233     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(cameraBase_->CAPTURE_ID_CAPTURE,
234         captureInfo, true);
235     EXPECT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
236     if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
237         CAMERA_LOGI("check Capture: Capture success, captureId = %{public}d", cameraBase_->CAPTURE_ID_CAPTURE);
238     } else {
239         CAMERA_LOGE("check Capture: Capture fail, captureId = %{public}d, rc = %{public}d",
240             cameraBase_->CAPTURE_ID_CAPTURE, cameraBase_->rc);
241     }
__anon8b2b98ec0302(const unsigned char *addr, const uint32_t size) 242     cameraBase_->streamCustomerCapture_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
243         cameraBase_->StoreImage(addr, size);
244     });
245 
246     constexpr uint32_t timeForWaitImagePreview = 5; // sleep five second
247     sleep(timeForWaitImagePreview);
248 
249     std::vector<int> captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, CAPTUREID_PREVIEW_DOUBLE,
250         cameraBase_->CAPTURE_ID_CAPTURE};
251     std::vector<int> streamIds = {cameraBase_->STREAM_ID_PREVIEW, STREAMID_PREVIEW_DOUBLE,
252         cameraBase_->STREAM_ID_CAPTURE};
253     StopStream(captureIds, streamIds);
254 }
255 
256 /**
257   * @tc.name: double preview and video
258   * @tc.desc: Commit 3 streams together, Double preview and video streams, isStreaming is true.
259   * @tc.level: Level1
260   * @tc.size: MediumTest
261   * @tc.type: Function
262   */
263 static HWTEST_F(DoublePreviewTest, double_preview_003, TestSize.Level1)
264 {
265     // Get the stream manager
266     cameraBase_->AchieveStreamOperator();
267 
268     // Start stream
269     CreateStream(cameraBase_->STREAM_ID_PREVIEW, PREVIEW);
270     CreateStream(STREAMID_PREVIEW_DOUBLE, PREVIEW);
271     cameraBase_->intents = {VIDEO};
272     cameraBase_->StartStream(cameraBase_->intents);
273 
274     // Get preview
275     StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
276     StartCapture(STREAMID_PREVIEW_DOUBLE, CAPTUREID_PREVIEW_DOUBLE, false, true);
277     cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
278 
279     constexpr uint32_t timeForWaitImagePreview = 5; // sleep five second
280     sleep(timeForWaitImagePreview);
281 
282     std::vector<int> captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, CAPTUREID_PREVIEW_DOUBLE,
283         cameraBase_->CAPTURE_ID_VIDEO};
284     std::vector<int> streamIds = {cameraBase_->STREAM_ID_PREVIEW, STREAMID_PREVIEW_DOUBLE,
285         cameraBase_->STREAM_ID_VIDEO};
286     StopStream(captureIds, streamIds);
287 }
288