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
SetUp(const::benchmark::State & state)26 void CameraBenchmarkTest::SetUp(const ::benchmark::State &state)
27 {
28 cameraTest = std::make_shared<OHOS::Camera::Test>();
29 cameraTest->Init();
30 }
31
TearDown(const::benchmark::State & state)32 void CameraBenchmarkTest::TearDown(const ::benchmark::State &state)
33 {
34 cameraTest->Close();
35 }
36
37 /**
38 * @tc.name: OpenCamera
39 * @tc.desc: OpenCamera, benchmark.
40 * @tc.level: Level0
41 * @tc.size: MediumTest
42 * @tc.type: Function
43 */
BENCHMARK_F(CameraBenchmarkTest,SUB_OpenCamera_benchmark_001)44 BENCHMARK_F(CameraBenchmarkTest, SUB_OpenCamera_benchmark_001)(
45 benchmark::State &st)
46 {
47 EXPECT_EQ(true, cameraTest->cameraDevice == nullptr);
48 if (cameraTest->cameraDevice == nullptr) {
49 cameraTest->service->GetCameraIds(cameraTest->cameraIds);
50 cameraTest->deviceCallback = new OHOS::Camera::Test::DemoCameraDeviceCallback();
51 for (auto _ : st) {
52 cameraTest->rc = cameraTest->service->OpenCamera(cameraTest->cameraIds.front(),
53 cameraTest->deviceCallback,cameraTest->cameraDevice);
54 }
55 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
56 }
57 }
58 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_OpenCamera_benchmark_001)->Iterations(ITERATION_FREQUENCY)->
59 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
60
61 /**
62 * @tc.name: GetCameraIds
63 * @tc.desc: GetCameraIds, benchmark.
64 * @tc.level: Level0
65 * @tc.size: MediumTest
66 * @tc.type: Function
67 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetCameraIds_benchmark_002)68 BENCHMARK_F(CameraBenchmarkTest, SUB_GetCameraIds_benchmark_002)(
69 benchmark::State &st)
70 {
71 //std::cout << "==========[test log] GetCameraIds, success."<< std::endl;
72 for (auto _ : st) {
73 cameraTest->rc = cameraTest->service->GetCameraIds(cameraTest->cameraIds);
74 }
75 }
76 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetCameraIds_benchmark_002)->Iterations(ITERATION_FREQUENCY)->
77 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
78
79 /**
80 * @tc.name: GetStreamOperator
81 * @tc.desc: GetStreamOperator, benchmark.
82 * @tc.level: Level0
83 * @tc.size: MediumTest
84 * @tc.type: Function
85 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetStreamOperator_benchmark_003)86 BENCHMARK_F(CameraBenchmarkTest, SUB_GetStreamOperator_benchmark_003)(
87 benchmark::State &st)
88 {
89 cameraTest->Open();
90 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
91 for (auto _ : st) {
92 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
93 cameraTest->streamOperator);
94 }
95 }
96
97 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetStreamOperator_benchmark_003)->
98 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
99
100 /**
101 * @tc.name: GetCameraAbility
102 * @tc.desc: GetCameraAbility, benchmark.
103 * @tc.level: Level0
104 * @tc.size: MediumTest
105 * @tc.type: Function
106 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetCameraAbility_benchmark_004)107 BENCHMARK_F(CameraBenchmarkTest, SUB_GetCameraAbility_benchmark_004)(
108 benchmark::State &st)
109 {
110 cameraTest->rc = cameraTest->service->GetCameraIds(cameraTest->cameraIds);
111 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
112 for (int i = 0; i < cameraTest->cameraIds.size(); i++) {
113 for (auto _ : st) {
114 cameraTest->rc = cameraTest->service->GetCameraAbility(cameraTest->cameraIds[i], cameraTest->abilityVec);
115 }
116 }
117 }
118 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetCameraAbility_benchmark_004)->
119 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
120
121 /**
122 * @tc.name: SetFlashlight
123 * @tc.desc: SetFlashlight, benchmark.
124 * @tc.level: Level0
125 * @tc.size: MediumTest
126 * @tc.type: Function
127 */
BENCHMARK_F(CameraBenchmarkTest,SUB_SetFlashlight_benchmark_005)128 BENCHMARK_F(CameraBenchmarkTest, SUB_SetFlashlight_benchmark_005)(
129 benchmark::State &st)
130 {
131 cameraTest->service->GetCameraIds(cameraTest->cameraIds);
132 cameraTest->status = true;
133 for (auto _ : st) {
134 cameraTest->rc = cameraTest->service->SetFlashlight(cameraTest->cameraIds.front(), cameraTest->status);
135 }
136 }
137 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_SetFlashlight_benchmark_005)->
138 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
139
140
141 /**
142 * @tc.name: SetResultMode
143 * @tc.desc: SetResultMode, benchmark.
144 * @tc.level: Level0
145 * @tc.size: MediumTest
146 * @tc.type: Function
147 */
BENCHMARK_F(CameraBenchmarkTest,SUB_SetResultMode_benchmark_006)148 BENCHMARK_F(CameraBenchmarkTest, SUB_SetResultMode_benchmark_006)(
149 benchmark::State &st)
150 {
151 cameraTest->Open();
152 for (auto _ : st) {
153 cameraTest->rc = cameraTest->cameraDevice->SetResultMode(PER_FRAME);
154 }
155 }
156 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_SetResultMode_benchmark_006)->
157 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
158
159 /**
160 * @tc.name: CreateStreams
161 * @tc.desc: CreateStreams, benchmark.
162 * @tc.level: Level0
163 * @tc.size: MediumTest
164 * @tc.type: Function
165 */
BENCHMARK_F(CameraBenchmarkTest,SUB_CreateStreams_benchmark_007)166 BENCHMARK_F(CameraBenchmarkTest, SUB_CreateStreams_benchmark_007)(
167 benchmark::State &st)
168 {
169 cameraTest->Open();
170 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
171 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
172 cameraTest->streamOperator);
173 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
174 std::shared_ptr<StreamInfo> streamInfoPre = std::make_shared<StreamInfo>();
175 streamInfoPre->streamId_ = cameraTest->streamIdPreview;
176 streamInfoPre->width_ = cameraTest->previewWidth;
177 streamInfoPre->height_ = cameraTest->previewHeight;
178 streamInfoPre->format_ = cameraTest->previewFormat;
179 streamInfoPre->dataspace_ = OHOS::Camera::UT_DATA_SIZE;
180 streamInfoPre->intent_ = PREVIEW;
181 streamInfoPre->tunneledMode_ = OHOS::Camera::UT_TUNNEL_MODE;
182 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer_pre =
183 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
184 if (streamInfoPre->bufferQueue_ == nullptr) {
185 streamInfoPre->bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
186 CAMERA_LOGD("On Buffer Available: size = %{public}u", size);
187 });
188 }
189 streamInfoPre->bufferQueue_->producer_->SetQueueSize(OHOS::Camera::UT_DATA_SIZE);
190 std::vector<StreamInfo> streamInfos;
191 streamInfos.push_back(*streamInfoPre);
192 for (auto _ : st) {
193 cameraTest->rc = cameraTest->streamOperator->CreateStreams(streamInfos);
194 }
195 }
196 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_CreateStreams_benchmark_007)->
197 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
198
199 /**
200 * @tc.name: CommitStreams
201 * @tc.desc: CommitStreams, benchmark.
202 * @tc.level: Level0
203 * @tc.size: MediumTest
204 * @tc.type: Function
205 */
BENCHMARK_F(CameraBenchmarkTest,SUB_CommitStreams_benchmark_008)206 BENCHMARK_F(CameraBenchmarkTest, SUB_CommitStreams_benchmark_008)(
207 benchmark::State &st)
208 {
209 cameraTest->Open();
210 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
211 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
212 cameraTest->streamOperator);
213 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
214 std::shared_ptr<StreamInfo> streamInfoPre = std::make_shared<StreamInfo>();
215 streamInfoPre->streamId_ = cameraTest->streamIdPreview;
216 streamInfoPre->width_ = cameraTest->previewWidth;
217 streamInfoPre->height_ = cameraTest->previewHeight;
218 streamInfoPre->format_ = cameraTest->previewFormat;
219 streamInfoPre->dataspace_ = OHOS::Camera::UT_DATA_SIZE;
220 streamInfoPre->intent_ = PREVIEW;
221 streamInfoPre->tunneledMode_ = OHOS::Camera::UT_TUNNEL_MODE;
222 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer_pre =
223 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
224 streamInfoPre->bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
225 CAMERA_LOGD("On Buffer Available: size = %{public}u", size);
226 });
227 streamInfoPre->bufferQueue_->producer_->SetQueueSize(OHOS::Camera::UT_DATA_SIZE);
228 std::vector<StreamInfo> streamInfos;
229 streamInfos.push_back(*streamInfoPre);
230 cameraTest->rc = cameraTest->streamOperator->CreateStreams(streamInfos);
231 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
232
233 for (auto _ : st) {
234 cameraTest->rc = cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
235 }
236 }
237 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_CommitStreams_benchmark_008)->
238 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
239
240 /**
241 * @tc.name: GetStreamAttributes
242 * @tc.desc: GetStreamAttributes, benchmark.
243 * @tc.level: Level0
244 * @tc.size: MediumTest
245 * @tc.type: Function
246 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetStreamAttributes_benchmark_009)247 BENCHMARK_F(CameraBenchmarkTest, SUB_GetStreamAttributes_benchmark_009)(
248 benchmark::State &st)
249 {
250 cameraTest->Open();
251 cameraTest->intents = {PREVIEW};
252 cameraTest->StartStream(cameraTest->intents);
253 std::vector<StreamAttribute> attributes;
254 for (auto _ : st) {
255 cameraTest->rc = cameraTest->streamOperator->GetStreamAttributes(attributes);
256 }
257 }
258 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetStreamAttributes_benchmark_009)->
259 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
260
261 /**
262 * @tc.name: ReleaseStreams
263 * @tc.desc: ReleaseStreams, benchmark.
264 * @tc.level: Level0
265 * @tc.size: MediumTest
266 * @tc.type: Function
267 */
BENCHMARK_F(CameraBenchmarkTest,SUB_ReleaseStreams_benchmark_0010)268 BENCHMARK_F(CameraBenchmarkTest, SUB_ReleaseStreams_benchmark_0010)(
269 benchmark::State &st)
270 {
271 cameraTest->Open();
272 cameraTest->intents = {PREVIEW};
273 cameraTest->StartStream(cameraTest->intents);
274 for (auto _ : st) {
275 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamIdPreview});
276 }
277 }
278 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_ReleaseStreams_benchmark_0010)->
279 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
280
281 /**
282 * @tc.name: Capture
283 * @tc.desc: Capture, benchmark.
284 * @tc.level: Level0
285 * @tc.size: MediumTest
286 * @tc.type: Function
287 */
BENCHMARK_F(CameraBenchmarkTest,SUB_Capture_benchmark_0011)288 BENCHMARK_F(CameraBenchmarkTest, SUB_Capture_benchmark_0011)(
289 benchmark::State &st)
290 {
291 cameraTest->Open();
292 cameraTest->intents = {PREVIEW};
293 cameraTest->StartStream(cameraTest->intents);
294 int captureId = 2001;
295 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
296 cameraTest->captureInfo->streamIds_ = {-1};
297 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
298 cameraTest->captureInfo->enableShutterCallback_ = true;
299 for (auto _ : st) {
300 cameraTest->rc = cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, true);
301 }
302 }
303 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_Capture_benchmark_0011)->
304 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
305
306 /**
307 * @tc.name: Close
308 * @tc.desc: Close, benchmark.
309 * @tc.level: Level0
310 * @tc.size: MediumTest
311 * @tc.type: Function
312 */
BENCHMARK_F(CameraBenchmarkTest,SUB_Close_benchmark_0012)313 BENCHMARK_F(CameraBenchmarkTest, SUB_Close_benchmark_0012)(
314 benchmark::State &st)
315 {
316 cameraTest->Open();
317 for (auto _ : st) {
318 cameraTest->cameraDevice->Close();
319 }
320 }
321 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_Close_benchmark_0012)->
322 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
323
324 /**
325 * @tc.name: CancelCapture
326 * @tc.desc: CancelCapture, benchmark.
327 * @tc.level: Level0
328 * @tc.size: MediumTest
329 * @tc.type: Function
330 */
BENCHMARK_F(CameraBenchmarkTest,SUB_CancelCapture_benchmark_0013)331 BENCHMARK_F(CameraBenchmarkTest, SUB_CancelCapture_benchmark_0013)(
332 benchmark::State &st)
333 {
334 cameraTest->Open();
335 cameraTest->intents = {PREVIEW};
336 cameraTest->StartStream(cameraTest->intents);
337 int captureId = 2001;
338 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
339 cameraTest->captureInfo->streamIds_ = {-1};
340 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
341 cameraTest->captureInfo->enableShutterCallback_ = true;
342 cameraTest->rc = cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, true);
343 for (auto _ : st) {
344 cameraTest->streamOperator->CancelCapture(captureId);
345 }
346 }
347 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_CancelCapture_benchmark_0013)->Iterations(100)->
348 Repetitions(3)->ReportAggregatesOnly();
349
350 /**
351 * @tc.name: EnableResult
352 * @tc.desc: EnableResult, benchmark.
353 * @tc.level: Level0
354 * @tc.size: MediumTest
355 * @tc.type: Function
356 */
BENCHMARK_F(CameraBenchmarkTest,SUB_EnableResult_benchmark_0014)357 BENCHMARK_F(CameraBenchmarkTest, SUB_EnableResult_benchmark_0014)(
358 benchmark::State &st)
359 {
360 cameraTest->Open();
361 std::vector<int32_t> resultsList;
362 resultsList.push_back(OHOS_CAMERA_STREAM_ID);
363 resultsList.push_back(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION);
364 for (auto _ : st) {
365 cameraTest->cameraDevice->EnableResult(resultsList);
366 }
367 }
368 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_EnableResult_benchmark_0014)->Iterations(100)->
369 Repetitions(3)->ReportAggregatesOnly();
370
371 /**
372 * @tc.name: DisableResult
373 * @tc.desc: DisableResult, benchmark.
374 * @tc.level: Level0
375 * @tc.size: MediumTest
376 * @tc.type: Function
377 */
BENCHMARK_F(CameraBenchmarkTest,SUB_DisableResult_benchmark_0015)378 BENCHMARK_F(CameraBenchmarkTest, SUB_DisableResult_benchmark_0015)(
379 benchmark::State &st)
380 {
381 cameraTest->Open();
382 std::vector<OHOS::Camera::MetaType> resultsOriginal;
383 for (auto _ : st) {
384 cameraTest->cameraDevice->DisableResult(resultsOriginal);
385 }
386 }
387 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_DisableResult_benchmark_0015)->Iterations(100)->
388 Repetitions(3)->ReportAggregatesOnly();
389
390 /**
391 * @tc.name: UpdateSettings
392 * @tc.desc: UpdateSettings, benchmark.
393 * @tc.level: Level0
394 * @tc.size: MediumTest
395 * @tc.type: Function
396 */
BENCHMARK_F(CameraBenchmarkTest,SUB_UpdateSettings_benchmark_0016)397 BENCHMARK_F(CameraBenchmarkTest, SUB_UpdateSettings_benchmark_0016)(
398 benchmark::State &st)
399 {
400 cameraTest->Open();
401 cameraTest->intents = {PREVIEW};
402 cameraTest->StartStream(cameraTest->intents);
403 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
404 std::shared_ptr<OHOS::Camera::CameraMetadata> meta = std::make_shared<OHOS::Camera::CameraSetting>(100, 200);
405 int32_t expo = 0xa0;
406 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
407 std::vector<uint8_t> metaVec;
408 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(meta, metaVec);
409 for (auto _ : st) {
410 cameraTest->cameraDevice->UpdateSettings(metaVec);
411 }
412 }
413 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_UpdateSettings_benchmark_0016)->Iterations(100)->
414 Repetitions(3)->ReportAggregatesOnly();
415
416 /**
417 * @tc.name: GetEnabledResults
418 * @tc.desc: GetEnabledResults, benchmark.
419 * @tc.level: Level0
420 * @tc.size: MediumTest
421 * @tc.type: Function
422 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetEnabledResults_benchmark_0017)423 BENCHMARK_F(CameraBenchmarkTest, SUB_GetEnabledResults_benchmark_0017)(
424 benchmark::State &st)
425 {
426 cameraTest->Open();
427 std::vector<OHOS::Camera::MetaType> enableTypes;
428 for (auto _ : st) {
429 cameraTest->cameraDevice->GetEnabledResults(enableTypes);
430 }
431 }
432 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetEnabledResults_benchmark_0017)->Iterations(100)->
433 Repetitions(3)->ReportAggregatesOnly();
434
435 /**
436 * @tc.name: IsStreamsSupported
437 * @tc.desc: IsStreamsSupported, benchmark.
438 * @tc.level: Level0
439 * @tc.size: MediumTest
440 * @tc.type: Function
441 */
BENCHMARK_F(CameraBenchmarkTest,SUB_IsStreamsSupported_benchmark_0018)442 BENCHMARK_F(CameraBenchmarkTest, SUB_IsStreamsSupported_benchmark_0018)(
443 benchmark::State &st)
444 {
445 cameraTest->Open();
446 EXPECT_EQ(false, cameraTest->cameraDevice == nullptr);
447 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
448 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
449 cameraTest->streamOperator);
450 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
451 std::shared_ptr<OHOS::Camera::CameraMetadata> modeSetting = std::make_shared<OHOS::Camera::CameraMetadata>(2, 128);
452 int64_t expoTime = 0;
453 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
454 int64_t colorGains[4] = {0};
455 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
456
457 cameraTest->streamInfo = std::make_shared<StreamInfo>();
458 cameraTest->streamInfo->streamId_ = 1001;
459 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
460 cameraTest->streamInfo->height_ = 480;
461 cameraTest->streamInfo->width_ = 640;
462 cameraTest->streamInfo->dataspace_ = 8;
463
464 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
465 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
466 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
467 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
468 });
469
470 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
471 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
472 cameraTest->streamInfo->intent_ = PREVIEW;
473 cameraTest->streamInfo->tunneledMode_ = 5;
474 StreamSupportType pType;
475 std::vector<StreamInfo> streams;
476 streams.push_back(*cameraTest->streamInfo);
477 std::vector<uint8_t> modeSettingVec;
478 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(modeSetting, modeSettingVec);
479 for (auto _ : st) {
480 cameraTest->streamOperator->IsStreamsSupported(OperationMode::NORMAL, modeSettingVec,
481 streams, pType);
482 }
483 }
484 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_IsStreamsSupported_benchmark_0018)->Iterations(100)->
485 Repetitions(3)->ReportAggregatesOnly();
486
487 /**
488 * @tc.name: AttachBufferQueue
489 * @tc.desc: AttachBufferQueue, benchmark.
490 * @tc.level: Level0
491 * @tc.size: MediumTest
492 * @tc.type: Function
493 */
BENCHMARK_F(CameraBenchmarkTest,SUB_AttachBufferQueue_benchmark_0019)494 BENCHMARK_F(CameraBenchmarkTest, SUB_AttachBufferQueue_benchmark_0019)(
495 benchmark::State &st)
496 {
497 cameraTest->Open();
498 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
499 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
500 cameraTest->streamOperator);
501
502 cameraTest->streamInfo = std::make_shared<StreamInfo>();
503 cameraTest->streamInfo->streamId_ = 1201; // PREVIEW streamId
504 cameraTest->streamInfo->width_ = 720; // Pixel Width
505 cameraTest->streamInfo->height_ = 480; // Pixel height
506 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
507 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
508 cameraTest->streamInfo->intent_ = PREVIEW;
509 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
510 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
511 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
512 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
513 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
514 });
515
516 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
517 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
518 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
519
520 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
521 cameraTest->streamInfoSnapshot->streamId_ = 1202; // STILL_CAPTURE streamId
522 cameraTest->streamInfoSnapshot->width_ = 720; // Pixel Width
523 cameraTest->streamInfoSnapshot->height_ = 480; // Pixel height
524 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
525 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
526 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
527 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
528 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> snapshotConsumer =
529 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
530 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
531 uint32_t size) {
532 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
533 });
534
535 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
536 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
537 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
538
539 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
540 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
541
542 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
543 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
544 OHOS::sptr<OHOS::IBufferProducer> producerTemp = preview_consumer->CreateProducer([this](void* addr,
545 uint32_t size) {
546 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
547 });
548
549 OHOS::sptr<BufferProducerSequenceable> bufferQueue = new BufferProducerSequenceable(producerTemp);
550 for (auto _ : st) {
551 cameraTest->streamOperator->AttachBufferQueue(cameraTest->streamInfoSnapshot->streamId_,
552 bufferQueue);
553 }
554 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
555
556 cameraTest->rc = cameraTest->streamOperator->DetachBufferQueue(cameraTest->streamInfoSnapshot->streamId_);
557 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
558
559 std::vector<int> streamIds = {cameraTest->streamInfo->streamId_, cameraTest->streamInfoSnapshot->streamId_};
560 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams(streamIds);
561 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
562 }
563 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_AttachBufferQueue_benchmark_0019)->Iterations(100)->
564 Repetitions(3)->ReportAggregatesOnly();
565
566 /**
567 * @tc.name: DetachBufferQueue
568 * @tc.desc: DetachBufferQueue, benchmark.
569 * @tc.level: Level0
570 * @tc.size: MediumTest
571 * @tc.type: Function
572 */
BENCHMARK_F(CameraBenchmarkTest,SUB_DetachBufferQueue_benchmark_0020)573 BENCHMARK_F(CameraBenchmarkTest, SUB_DetachBufferQueue_benchmark_0020)(
574 benchmark::State &st)
575 {
576 cameraTest->Open();
577 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
578 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
579 cameraTest->streamOperator);
580
581 cameraTest->streamInfo = std::make_shared<StreamInfo>();
582 cameraTest->streamInfo->streamId_ = 1201; // PREVIEW streamId
583 cameraTest->streamInfo->width_ = 720; // Pixel Width
584 cameraTest->streamInfo->height_ = 480; // Pixel height
585 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
586 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
587 cameraTest->streamInfo->intent_ = PREVIEW;
588 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
589 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
590 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
591 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
592 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
593 });
594
595 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
596 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
597 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
598
599 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
600 cameraTest->streamInfoSnapshot->streamId_ = 1202; // STILL_CAPTURE streamId
601 cameraTest->streamInfoSnapshot->width_ = 720; // Pixel Width
602 cameraTest->streamInfoSnapshot->height_ = 480; // Pixel height
603 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
604 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
605 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
606 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
607 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> snapshotConsumer =
608 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
609 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
610 uint32_t size) {
611 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
612 });
613
614 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
615 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
616 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
617
618 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
619 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
620
621 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
622 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
623 OHOS::sptr<OHOS::IBufferProducer> producerTemp = preview_consumer->CreateProducer([this](void* addr,
624 uint32_t size) {
625 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
626 });
627
628 OHOS::sptr<BufferProducerSequenceable> bufferQueue = new BufferProducerSequenceable(producerTemp);
629
630 cameraTest->rc = cameraTest->streamOperator->AttachBufferQueue(cameraTest->streamInfoSnapshot->streamId_,
631 bufferQueue);
632 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
633
634 for (auto _ : st) {
635 cameraTest->streamOperator->DetachBufferQueue(cameraTest->streamInfoSnapshot->streamId_);
636 }
637
638 std::vector<int> streamIds = {cameraTest->streamInfo->streamId_, cameraTest->streamInfoSnapshot->streamId_};
639 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams(streamIds);
640 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
641 }
642 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_DetachBufferQueue_benchmark_0020)->Iterations(100)->
643 Repetitions(3)->ReportAggregatesOnly();
644
645 /**
646 * @tc.name: ChangeToOfflineStream
647 * @tc.desc: ChangeToOfflineStream, benchmark.
648 * @tc.level: Level0
649 * @tc.size: MediumTest
650 * @tc.type: Function
651 */
BENCHMARK_F(CameraBenchmarkTest,SUB_ChangeToOfflineStream_benchmark_021)652 BENCHMARK_F(CameraBenchmarkTest, SUB_ChangeToOfflineStream_benchmark_021)(
653 benchmark::State &st)
654 {
655 cameraTest->Open();
656 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
657 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
658 cameraTest->streamOperator);
659
660 cameraTest->streamInfo = std::make_shared<StreamInfo>();
661 cameraTest->streamInfo->streamId_ = 1201;
662 cameraTest->streamInfo->width_ = 720;
663 cameraTest->streamInfo->height_ = 480;
664 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
665 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
666 cameraTest->streamInfo->intent_ = PREVIEW;
667 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
668 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
669 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
670 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
671 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
672 });
673 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
674 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
675 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
676
677 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
678 cameraTest->streamInfoSnapshot->streamId_ = 1202;
679 cameraTest->streamInfoSnapshot->width_ = 720;
680 cameraTest->streamInfoSnapshot->height_ = 480;
681 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
682 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
683 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
684 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
685 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> snapshotConsumer =
686 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
687 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
688 uint32_t size) {
689 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
690 });
691 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
692 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
693 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
694
695 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
696 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
697
698 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL,
699 cameraTest->abilityVec);
700 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
701
702 int captureId = 2001;
703 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
704 cameraTest->captureInfo->streamIds_ = {1202};
705 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
706 cameraTest->captureInfo->enableShutterCallback_ = true;
707 bool isStreaming = true;
708 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
709 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
710 sleep(UT_SECOND_TIMES);
711
712 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
713 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
714 for (auto _ : st) {
715 cameraTest->streamOperator->ChangeToOfflineStream({cameraTest->streamInfoSnapshot->streamId_},
716 streamOperatorCallback, offlineStreamOperator);
717 }
718
719 sleep(UT_SECOND_TIMES);
720 cameraTest->rc = (CamRetCode)offlineStreamOperator->CancelCapture(2020);
721 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR
722 || cameraTest->rc == HDI::Camera::V1_0::METHOD_NOT_SUPPORTED);
723
724 std::vector<int> streamIds = {1202};
725 cameraTest->rc = (CamRetCode)offlineStreamOperator->ReleaseStreams(streamIds);
726 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR
727 || cameraTest->rc == HDI::Camera::V1_0::METHOD_NOT_SUPPORTED);
728 cameraTest->rc = (CamRetCode)offlineStreamOperator->Release();
729 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR
730 || cameraTest->rc == HDI::Camera::V1_0::METHOD_NOT_SUPPORTED);
731 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ReleaseStreams({1201});
732 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
733 sleep(UT_SECOND_TIMES);
734 }
735 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_ChangeToOfflineStream_benchmark_021)->Iterations(ITERATION_FREQUENCY)->
736 Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
737
738 BENCHMARK_MAIN();
739
740