1 /*
2 * Copyright (c) 2023 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 "camera_benchmark_test.h"
17
18 using namespace OHOS;
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Camera;
22
23 constexpr int32_t ITERATION_FREQUENCY = 100;
24 constexpr int32_t REPETITION_FREQUENCY = 3;
25
26 constexpr uint32_t ITEM_CAPACITY = 100;
27 constexpr uint32_t DATA_CAPACITY = 2000;
28 constexpr uint32_t DATA_COUNT = 1;
29
SetUp(const::benchmark::State & state)30 void CameraBenchmarkTest::SetUp(const ::benchmark::State &state)
31 {
32 cameraTest = std::make_shared<OHOS::Camera::Test>();
33 cameraTest->Init();
34 cameraTest->OpenCameraV1_2(DEVICE_0);
35 }
36
TearDown(const::benchmark::State & state)37 void CameraBenchmarkTest::TearDown(const ::benchmark::State &state)
38 {
39 cameraTest->Close();
40 }
41
42 /**
43 * @tc.name: NotifyDeviceStateChangeInfo
44 * @tc.desc: benchmark
45 * @tc.level: Level0
46 * @tc.size: MediumTest
47 * @tc.type: Function
48 */
BENCHMARK_F(CameraBenchmarkTest,NotifyDeviceStateChangeInfo_benchmark_001)49 BENCHMARK_F(CameraBenchmarkTest, NotifyDeviceStateChangeInfo_benchmark_001)(
50 benchmark::State &st)
51 {
52 EXPECT_EQ(false, cameraTest->serviceV1_2 == nullptr);
53 int notifyType = 1;
54 int deviceState = 1008;
55 for (auto _ : st) {
56 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
57 }
58 }
59 BENCHMARK_REGISTER_F(CameraBenchmarkTest, NotifyDeviceStateChangeInfo_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
60 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
61
62 /**
63 * @tc.name: PreCameraSwitch
64 * @tc.desc: benchmark
65 * @tc.level: Level0
66 * @tc.size: MediumTest
67 * @tc.type: Function
68 */
BENCHMARK_F(CameraBenchmarkTest,PreCameraSwitch_benchmark_001)69 BENCHMARK_F(CameraBenchmarkTest, PreCameraSwitch_benchmark_001)(
70 benchmark::State &st)
71 {
72 EXPECT_EQ(false, cameraTest->serviceV1_2 == nullptr);
73 cameraTest->serviceV1_2->GetCameraIds(cameraTest->cameraIds);
74 for (auto _ : st) {
75 cameraTest->rc = cameraTest->serviceV1_2->PreCameraSwitch(cameraTest->cameraIds.front());
76 }
77 }
78 BENCHMARK_REGISTER_F(CameraBenchmarkTest, PreCameraSwitch_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
79 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
80
81 /**
82 * @tc.name: PrelaunchWithOpMode
83 * @tc.desc: Prelaunch, benchmark.
84 * @tc.level: Level0
85 * @tc.size: MediumTest
86 * @tc.type: Function
87 */
BENCHMARK_F(CameraBenchmarkTest,PrelaunchWithOpMode_benchmark_001)88 BENCHMARK_F(CameraBenchmarkTest, PrelaunchWithOpMode_benchmark_001)(
89 benchmark::State &st)
90 {
91 EXPECT_EQ(false, cameraTest->serviceV1_2 == nullptr);
92 cameraTest->serviceV1_2->GetCameraIds(cameraTest->cameraIds);
93
94 cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
95 cameraTest->prelaunchConfig->cameraId = cameraTest->cameraIds.front();
96 cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
97 cameraTest->prelaunchConfig->setting = {};
98 for (auto _ : st) {
99 cameraTest->rc = cameraTest->serviceV1_2->PrelaunchWithOpMode(
100 *cameraTest->prelaunchConfig, OHOS::HDI::Camera::V1_2::NORMAL);
101 }
102 }
103 BENCHMARK_REGISTER_F(CameraBenchmarkTest, PrelaunchWithOpMode_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
104 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
105
106 /**
107 * @tc.name: UpdateStreams
108 * @tc.desc: benchmark
109 * @tc.level: Level0
110 * @tc.size: MediumTest
111 * @tc.type: Function
112 */
BENCHMARK_F(CameraBenchmarkTest,UpdateStreams_benchmark_001)113 BENCHMARK_F(CameraBenchmarkTest, UpdateStreams_benchmark_001)(
114 benchmark::State &st)
115 {
116 cameraTest->streamOperatorCallbackV1_2 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_2();
117 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_2(cameraTest->streamOperatorCallbackV1_2,
118 cameraTest->streamOperator_V1_2);
119 EXPECT_NE(cameraTest->streamOperator_V1_2, nullptr);
120 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
121 cameraTest->streamInfoV1_1->v1_0.streamId_ = 100;
122 cameraTest->streamInfoV1_1->v1_0.width_ = 1920;
123 cameraTest->streamInfoV1_1->v1_0.height_ = 1080;
124 cameraTest->streamInfoV1_1->v1_0.intent_ = StreamIntent::PREVIEW;
125 cameraTest->streamInfoV1_1->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
126 cameraTest->streamInfoV1_1->v1_0.dataspace_ = OHOS_CAMERA_SRGB_FULL;
127 cameraTest->streamInfoV1_1->v1_0.format_ = PIXEL_FMT_YCRCB_420_SP;
128 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
129 // capture streamInfo
130 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
131 cameraTest->streamInfoCapture->v1_0.streamId_ = 101;
132 cameraTest->streamInfoCapture->v1_0.width_ = 1920;
133 cameraTest->streamInfoCapture->v1_0.height_ = 1080;
134 cameraTest->streamInfoCapture->v1_0.intent_ = StreamIntent::STILL_CAPTURE;
135 cameraTest->streamInfoCapture->v1_0.encodeType_ = ENCODE_TYPE_H265;
136 cameraTest->streamInfoCapture->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
137 cameraTest->streamInfoCapture->v1_0.dataspace_ = OHOS_CAMERA_SRGB_FULL;
138 cameraTest->streamInfoCapture->v1_0.format_ = PIXEL_FMT_YCRCB_420_SP;
139 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
140 for (auto _ : st) {
141 cameraTest->rc = cameraTest->streamOperator_V1_2->UpdateStreams(cameraTest->streamInfosV1_1);
142 }
143 }
144 BENCHMARK_REGISTER_F(CameraBenchmarkTest, UpdateStreams_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
145 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
146
147 /**
148 * @tc.name: ConfirmCapture
149 * @tc.desc: benchmark
150 * @tc.level: Level0
151 * @tc.size: MediumTest
152 * @tc.type: Function
153 */
BENCHMARK_F(CameraBenchmarkTest,ConfirmCapture_benchmark_001)154 BENCHMARK_F(CameraBenchmarkTest, ConfirmCapture_benchmark_001)(
155 benchmark::State &st)
156 {
157 cameraTest->streamOperatorCallbackV1_2 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_2();
158 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_2(cameraTest->streamOperatorCallbackV1_2,
159 cameraTest->streamOperator_V1_2);
160 for (auto _ : st) {
161 cameraTest->streamOperator_V1_2->ConfirmCapture(cameraTest->streamIdCapture);
162 }
163 }
164 BENCHMARK_REGISTER_F(CameraBenchmarkTest, ConfirmCapture_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
165 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
166
167 /**
168 * @tc.name: GetStatus
169 * @tc.desc: benchmark
170 * @tc.level: Level0
171 * @tc.size: MediumTest
172 * @tc.type: Function
173 */
BENCHMARK_F(CameraBenchmarkTest,GetStatus_benchmark_001)174 BENCHMARK_F(CameraBenchmarkTest, GetStatus_benchmark_001)(
175 benchmark::State &st)
176 {
177 // cover GetStatus(), OHOS_STATUS_CAMERA_CURRENT_FPS and OHOS_STATUS_CAMERA_CURRENT_ZOOM_RATIO
178 std::shared_ptr<CameraSetting> metaIn = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
179 std::shared_ptr<CameraSetting> metaOut = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
180 // no sense
181 uint32_t current_fps = 0;
182 uint32_t current_zoom_ratio = 0;
183 metaIn->addEntry(OHOS_STATUS_CAMERA_CURRENT_FPS, ¤t_fps, DATA_COUNT);
184 metaIn->addEntry(OHOS_STATUS_CAMERA_CURRENT_ZOOM_RATIO, ¤t_zoom_ratio, DATA_COUNT);
185
186 std::vector<uint8_t> settingIn, settingOut;
187 MetadataUtils::ConvertMetadataToVec(metaIn, settingIn);
188
189 for (auto _ : st) {
190 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStatus(settingIn, settingOut);
191 }
192 }
193 BENCHMARK_REGISTER_F(CameraBenchmarkTest, GetStatus_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
194 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
195
196 /**
197 * @tc.name: Defferred Image
198 * @tc.desc: benchmark
199 * @tc.level: Level0
200 * @tc.size: MediumTest
201 * @tc.type: Function
202 */
BENCHMARK_F(CameraBenchmarkTest,DefferredImage_benchmark_001)203 BENCHMARK_F(CameraBenchmarkTest, DefferredImage_benchmark_001)(
204 benchmark::State &st)
205 {
206 int taskCount = 0;
207 int ret = cameraTest->DefferredImageTestInit();
208 for (auto _ : st) {
209 if (ret == 0) {
210 cameraTest->rc = cameraTest->imageProcessSession_->GetCoucurrency(\
211 OHOS::HDI::Camera::V1_2::HIGH_PREFORMANCE, taskCount);
212 }
213 }
214 }
215 BENCHMARK_REGISTER_F(CameraBenchmarkTest, DefferredImage_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
216 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
217
218 /**
219 * @tc.name: Defferred Image
220 * @tc.desc: benchmark
221 * @tc.level: Level0
222 * @tc.size: MediumTest
223 * @tc.type: Function
224 */
BENCHMARK_F(CameraBenchmarkTest,DefferredImage_benchmark_002)225 BENCHMARK_F(CameraBenchmarkTest, DefferredImage_benchmark_002)(
226 benchmark::State &st)
227 {
228 int ret = cameraTest->DefferredImageTestInit();
229 for (auto _ : st) {
230 if (ret == 0) {
231 cameraTest->rc = cameraTest->imageProcessSession_->SetExecutionMode(\
232 OHOS::HDI::Camera::V1_2::HIGH_PREFORMANCE);
233 }
234 }
235 }
236 BENCHMARK_REGISTER_F(CameraBenchmarkTest, DefferredImage_benchmark_002)->Iterations(ITERATION_FREQUENCY)->
237 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
238
239 /**
240 * @tc.name: Defferred Image
241 * @tc.desc: benchmark
242 * @tc.level: Level0
243 * @tc.size: MediumTest
244 * @tc.type: Function
245 */
BENCHMARK_F(CameraBenchmarkTest,DefferredImage_benchmark_004)246 BENCHMARK_F(CameraBenchmarkTest, DefferredImage_benchmark_004)(
247 benchmark::State &st)
248 {
249 int ret = cameraTest->DefferredImageTestInit();
250 for (auto _ : st) {
251 if (ret == 0) {
252 cameraTest->rc = cameraTest->imageProcessSession_->Interrupt();
253 }
254 }
255 }
256 BENCHMARK_REGISTER_F(CameraBenchmarkTest, DefferredImage_benchmark_004)->Iterations(ITERATION_FREQUENCY)->
257 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
258
259 /**
260 * @tc.name: Defferred Image
261 * @tc.desc: benchmark
262 * @tc.level: Level0
263 * @tc.size: MediumTest
264 * @tc.type: Function
265 */
BENCHMARK_F(CameraBenchmarkTest,DefferredImage_benchmark_005)266 BENCHMARK_F(CameraBenchmarkTest, DefferredImage_benchmark_005)(
267 benchmark::State &st)
268 {
269 int ret = cameraTest->DefferredImageTestInit();
270 for (auto _ : st) {
271 if (ret == 0) {
272 cameraTest->imageProcessSession_->GetPendingImages(cameraTest->pendingImageIds_);
273 for (auto imageId : cameraTest->pendingImageIds_) {
274 cameraTest->rc = cameraTest->imageProcessSession_->ProcessImage(imageId);
275 }
276 }
277 }
278 }
279 BENCHMARK_REGISTER_F(CameraBenchmarkTest, DefferredImage_benchmark_005)->Iterations(ITERATION_FREQUENCY)->
280 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
281
282 /**
283 * @tc.name: Defferred Image
284 * @tc.desc: benchmark
285 * @tc.level: Level0
286 * @tc.size: MediumTest
287 * @tc.type: Function
288 */
BENCHMARK_F(CameraBenchmarkTest,DefferredImage_benchmark_006)289 BENCHMARK_F(CameraBenchmarkTest, DefferredImage_benchmark_006)(
290 benchmark::State &st)
291 {
292 int ret = cameraTest->DefferredImageTestInit();
293 for (auto _ : st) {
294 if (ret == 0) {
295 cameraTest->imageProcessSession_->GetPendingImages(cameraTest->pendingImageIds_);
296 for (auto imageId : cameraTest->pendingImageIds_) {
297 cameraTest->rc = cameraTest->imageProcessSession_->RemoveImage(imageId);
298 }
299 }
300 }
301 }
302 BENCHMARK_REGISTER_F(CameraBenchmarkTest, DefferredImage_benchmark_006)->Iterations(ITERATION_FREQUENCY)->
303 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
304
305 BENCHMARK_MAIN();
306
307