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_offline_stream_operator.h"
17 #include "camera.h"
18 #include "camera_metadata_info.h"
19 #include "ibuffer.h"
20 #include "idevice_manager.h"
21 #include "if_system_ability_manager.h"
22 #include "v1_0/ioffline_stream_operator.h"
23 #include "iservice_registry.h"
24 #include <surface.h>
25 #include <display_type.h>
26 #include <fcntl.h>
27 #include <stdio.h>
28 #include <sys/ioctl.h>
29 #include <sys/wait.h>
30 #include <unistd.h>
31
32 #define SURFACE_ID (12345 + 666 + 2333)
33
34 using namespace OHOS;
35 using namespace std;
36 using namespace testing::ext;
37
38 const int CAMERA_BUFFER_QUEUE_IPC = 654320;
GetCurrentLocalTimeStampOFL()39 uint64_t GetCurrentLocalTimeStampOFL()
40 {
41 std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> tp =
42 std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
43 auto tmp = std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch());
44 return tmp.count();
45 }
46
SaveToFile(const char * type,const void * buffer,int32_t size)47 int32_t SaveToFile(const char* type, const void* buffer, int32_t size)
48 {
49 int ret;
50 char path[PATH_MAX] = {0};
51 ret = sprintf_s(path, PATH_MAX, "/mnt/%s_%lld.yuv", type, GetCurrentLocalTimeStampOFL());
52 if (ret < 0) {
53 std::cout << "sprintf_s failed, errno = " << strerror(errno) << std::endl;
54 return -1;
55 }
56 int imgFd = open(path, O_RDWR | O_CREAT, 00766);
57 if (imgFd == -1) {
58 std::cout << "open file failed, errno = " << strerror(errno) << std::endl;
59 return -1;
60 }
61
62 ret = write(imgFd, buffer, size);
63 if (ret == -1) {
64 std::cout << "write file failed, errno = " << strerror(errno) << std::endl;
65 close(imgFd);
66 return -1;
67 }
68
69 close(imgFd);
70 return 0;
71 }
72
SetUpTestCase(void)73 void OffileStreamOperatorImplTest::SetUpTestCase(void)
74 {
75 std::cout << "Camera::StreamOperatorImp SetUpTestCase" << std::endl;
76 }
77
TearDownTestCase(void)78 void OffileStreamOperatorImplTest::TearDownTestCase(void)
79 {
80 std::cout << "Camera::StreamOperatorImp TearDownTestCase" << std::endl;
81 }
82
SetUp(void)83 void OffileStreamOperatorImplTest::SetUp(void)
84 {
85 bool ret = InitCameraHost();
86 if (!ret) {
87 std::cout << "OffileStreamOperatorImplTest init camerahost failed" << std::endl;
88 return;
89 }
90
91 ret = GetCameraIds();
92 if (!ret) {
93 std::cout << "OffileStreamOperatorImplTest init GetCameraIds failed" << std::endl;
94 return;
95 }
96
97 ret = GetCameraDevice();
98 if (!ret) {
99 std::cout << "OffileStreamOperatorImplTest init GetCameraDevice failed" << std::endl;
100 return;
101 }
102
103 ret = GetStreamOperator();
104 if (!ret) {
105 std::cout << "OffileStreamOperatorImplTest init GetStreamOperator failed" << std::endl;
106 return;
107 }
108 }
109
TearDown(void)110 void OffileStreamOperatorImplTest::TearDown(void)
111 {
112 std::cout << "Camera::StreamOperatorImp TearDown.." << std::endl;
113 }
114
115 HWTEST_F(OffileStreamOperatorImplTest, UTestPreviewAndSnapshotCombineCapture, TestSize.Level0)
116 {
117 sptr<OHOS::IBufferProducer> producer;
118 sptr<OHOS::IBufferProducer> producer_;
119 std::vector<StreamInfo> streamInfos;
120 StreamInfo streamInfo = {};
121 streamInfo.streamId_ = 1201;
122 streamInfo.width_ = 720;
123 streamInfo.height_ = 480;
124 streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP;
125 streamInfo.dataspace_ = 8;
126 streamInfo.intent_ = PREVIEW;
127 streamInfo.tunneledMode_ = 5;
128 std::shared_ptr<StreamConsumer> previewConsumer = std::make_shared<StreamConsumer>();
129 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon806fcbc40102(OHOS::SurfaceBuffer* buffer) 130 producer = previewConsumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
131 SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
132 });
133 #else
__anon806fcbc40202(void* addr, uint32_t size) 134 producer = previewConsumer->CreateProducer([this](void* addr, uint32_t size) {
135 SaveYUV("preview", addr, size);
136 });
137 #endif
138 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
139 streamInfo.bufferQueue_->producer_->SetQueueSize(8);
140 streamInfos.push_back(streamInfo);
141
142 StreamInfo streamInfoSnapshot = {};
143 streamInfoSnapshot.streamId_ = 1202;
144 streamInfoSnapshot.width_ = 720;
145 streamInfoSnapshot.height_ = 480;
146 streamInfoSnapshot.format_ = PIXEL_FMT_YCRCB_420_SP;
147 streamInfoSnapshot.dataspace_ = 8;
148 streamInfoSnapshot.intent_ = STILL_CAPTURE;
149 streamInfoSnapshot.tunneledMode_ = 5;
150 std::shared_ptr<StreamConsumer> snapshotConsumer = std::make_shared<StreamConsumer>();;
151 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon806fcbc40302(OHOS::SurfaceBuffer* buffer) 152 producer = snapshotConsumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
153 SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
154 });
155 #else
__anon806fcbc40402(void* addr, uint32_t size) 156 producer = snapshotConsumer->CreateProducer([this](void* addr, uint32_t size) {
157 SaveYUV("preview", addr, size);
158 });
159 #endif
160 streamInfoSnapshot.bufferQueue_ = new BufferProducerSequenceable(producer_);
161 streamInfo.bufferQueue_->producer_->SetQueueSize(8);
162 streamInfos.push_back(streamInfoSnapshot);
163
164 CamRetCode rc = (CamRetCode)streamOperator_->CreateStreams(streamInfos);
165 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
166 std::shared_ptr<CameraMetadata> modeSetting = std::make_shared<CameraMetadata>(2, 128);
167 int64_t expoTime = 0;
168 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
169 int64_t colorGains[4] = {0};
170 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
171
172 std::vector<uint8_t> setting;
173 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(modeSetting, setting);
174 rc = (CamRetCode)streamOperator_->CommitStreams(NORMAL, setting);
175 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
176
177 std::vector<std::string> cameraIds;
178 rc = (CamRetCode)cameraHost_->GetCameraIds(cameraIds);
179 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
180
181 std::vector<uint8_t> ability;
182 std::string cameraId = cameraIds.front();
183 rc = (CamRetCode)cameraHost_->GetCameraAbility(cameraId, ability);
184 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
185
186 int captureId = 2020;
187 CaptureInfo captureInfo = {};
188 captureInfo.streamIds_ = {streamInfo.streamId_, streamInfoSnapshot.streamId_};
189 captureInfo.captureSetting_ = ability;
190 captureInfo.enableShutterCallback_ = false;
191 rc = (CamRetCode)streamOperator_->Capture(captureId, captureInfo, true);
192 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
193 sleep(5);
194 #ifdef CAMERA_BUILT_ON_OHOS_LITE
195 std::shared_ptr<IStreamOperatorCallback> streamOperatorCallback = std::make_shared<DemoStreamOperatorCallback>();
196 std::shared_ptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
197 #else
198 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = new DemoStreamOperatorCallback();
199 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
200 #endif
201 rc = (CamRetCode)streamOperator_->ChangeToOfflineStream({ streamInfoSnapshot.streamId_ }, streamOperatorCallback,
202 offlineStreamOperator);
203 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
204
205 cameraDevice_->Close();
206 sleep(5);
207
208 std::cout << "begin to release offlne stream" << std::endl;
209 rc = (CamRetCode)offlineStreamOperator->CancelCapture(2020);
210 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
211
212 std::vector<int> streamIds = {1202};
213 rc = (CamRetCode)offlineStreamOperator->ReleaseStreams(streamIds);
214 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
215
216 rc = (CamRetCode)offlineStreamOperator->Release();
217 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
218
219 sleep(5);
220 }
221