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