1 /*
2 * Copyright (c) 2022-2024 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 #include <benchmark/benchmark.h>
16 #include "camera_benchmark_test.h"
17 using namespace OHOS;
18 using namespace std;
19 using namespace testing::ext;
20 using namespace OHOS::Camera;
21
22
SetUp(const::benchmark::State & state)23 void CameraBenchmarkTest::SetUp(const ::benchmark::State &state)
24 {
25 cameraTest = std::make_shared<OHOS::Camera::HdiCommon>();
26 cameraTest->Init();
27 }
TearDown(const::benchmark::State & state)28 void CameraBenchmarkTest::TearDown(const ::benchmark::State &state)
29 {
30 cameraTest->Close();
31 }
32
33 /**
34 * @tc.name: OpenCamera
35 * @tc.desc: OpenCamera, benchmark.
36 * @tc.level: Level0
37 * @tc.size: MediumTest
38 * @tc.type: Function
39 */
BENCHMARK_F(CameraBenchmarkTest,SUB_OpenCamera_benchmark_0010)40 BENCHMARK_F(CameraBenchmarkTest, SUB_OpenCamera_benchmark_0010)(
41 benchmark::State &st)
42 {
43 EXPECT_EQ(true, cameraTest->cameraDevice == nullptr);
44 if (cameraTest->cameraDevice == nullptr) {
45 cameraTest->service->GetCameraIds(cameraTest->cameraIds);
46 cameraTest->deviceCallback = new OHOS::Camera::HdiCommon::DemoCameraDeviceCallback();
47 for (auto _ : st) {
48 cameraTest->rc = cameraTest->service->OpenCamera(cameraTest->cameraIds.front(), cameraTest->deviceCallback,
49 cameraTest->cameraDevice);
50 }
51 }
52 }
53 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_OpenCamera_benchmark_0010)->Iterations(100)->
54 Repetitions(3)->ReportAggregatesOnly();
55
56 /**
57 * @tc.name: GetCameraIds
58 * @tc.desc: GetCameraIds, benchmark.
59 * @tc.level: Level0
60 * @tc.size: MediumTest
61 * @tc.type: Function
62 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetCameraIds_benchmark_0010)63 BENCHMARK_F(CameraBenchmarkTest, SUB_GetCameraIds_benchmark_0010)(
64 benchmark::State &st)
65 {
66 //std::cout << "==========[test log] GetCameraIds, success."<< std::endl;
67 for (auto _ : st) {
68 cameraTest->rc = cameraTest->service->GetCameraIds(cameraTest->cameraIds);
69 }
70 }
71 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetCameraIds_benchmark_0010)->Iterations(100)->
72 Repetitions(3)->ReportAggregatesOnly();
73
74 /**
75 * @tc.name: GetStreamOperator
76 * @tc.desc: GetStreamOperator, benchmark.
77 * @tc.level: Level0
78 * @tc.size: MediumTest
79 * @tc.type: Function
80 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetStreamOperator_benchmark_0010)81 BENCHMARK_F(CameraBenchmarkTest, SUB_GetStreamOperator_benchmark_0010)(
82 benchmark::State &st)
83 {
84 cameraTest->Open();
85 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
86 for (auto _ : st) {
87 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
88 cameraTest->streamOperator);
89 }
90 }
91 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetStreamOperator_benchmark_0010)->Iterations(100)->
92 Repetitions(3)->ReportAggregatesOnly();
93 /**
94 * @tc.name: GetCameraAbility
95 * @tc.desc: GetCameraAbility, benchmark.
96 * @tc.level: Level0
97 * @tc.size: MediumTest
98 * @tc.type: Function
99 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetCameraAbility_benchmark_0010)100 BENCHMARK_F(CameraBenchmarkTest, SUB_GetCameraAbility_benchmark_0010)(
101 benchmark::State &st)
102 {
103 cameraTest->rc = cameraTest->service->GetCameraIds(cameraTest->cameraIds);
104 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
105 for (auto _ : st) {
106 cameraTest->rc = cameraTest->service->GetCameraAbility(cameraTest->cameraIds.front(), cameraTest->abilityVec);
107 }
108 }
109 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetCameraAbility_benchmark_0010)->Iterations(100)->
110 Repetitions(3)->ReportAggregatesOnly();
111
112 /**
113 * @tc.name: SetFlashlight
114 * @tc.desc: SetFlashlight, benchmark.
115 * @tc.level: Level0
116 * @tc.size: MediumTest
117 * @tc.type: Function
118 */
BENCHMARK_F(CameraBenchmarkTest,SUB_SetFlashlight_benchmark_0010)119 BENCHMARK_F(CameraBenchmarkTest, SUB_SetFlashlight_benchmark_0010)(
120 benchmark::State &st)
121 {
122 cameraTest->service->GetCameraIds(cameraTest->cameraIds);
123 cameraTest->status = true;
124 for (auto _ : st) {
125 cameraTest->rc = cameraTest->service->SetFlashlight(cameraTest->cameraIds.front(), cameraTest->status);
126 }
127 }
128 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_SetFlashlight_benchmark_0010)->Iterations(100)->
129 Repetitions(3)->ReportAggregatesOnly();
130
131 /**
132 * @tc.name: SetResultMode
133 * @tc.desc: SetResultMode, benchmark.
134 * @tc.level: Level0
135 * @tc.size: MediumTest
136 * @tc.type: Function
137 */
BENCHMARK_F(CameraBenchmarkTest,SUB_SetResultMode_benchmark_0010)138 BENCHMARK_F(CameraBenchmarkTest, SUB_SetResultMode_benchmark_0010)(
139 benchmark::State &st)
140 {
141 cameraTest->Open();
142 for (auto _ : st) {
143 cameraTest->rc = cameraTest->cameraDevice->SetResultMode(PER_FRAME);
144 }
145 }
146 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_SetResultMode_benchmark_0010)->Iterations(100)->
147 Repetitions(3)->ReportAggregatesOnly();
148
149 /**
150 * @tc.name: CreateStreams
151 * @tc.desc: CreateStreams, benchmark.
152 * @tc.level: Level0
153 * @tc.size: MediumTest
154 * @tc.type: Function
155 */
BENCHMARK_F(CameraBenchmarkTest,SUB_CreateStreams_benchmark_0010)156 BENCHMARK_F(CameraBenchmarkTest, SUB_CreateStreams_benchmark_0010)(
157 benchmark::State &st)
158 {
159 cameraTest->Open();
160 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
161 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
162 cameraTest->streamOperator);
163 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
164 std::shared_ptr<StreamInfo> streamInfoPre = std::make_shared<StreamInfo>();
165 streamInfoPre->streamId_ = cameraTest->streamIdPreview;
166 streamInfoPre->width_ = cameraTest->previewWidth;
167 streamInfoPre->height_ = cameraTest->previewHeight;
168 streamInfoPre->format_ = cameraTest->previewFormat;
169 streamInfoPre->dataspace_ = OHOS::Camera::UT_DATA_SIZE;
170 streamInfoPre->intent_ = PREVIEW;
171 streamInfoPre->tunneledMode_ = OHOS::Camera::UT_TUNNEL_MODE;
172 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer_pre =
173 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
174 if (streamInfoPre->bufferQueue_ == nullptr) {
175 streamInfoPre->bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
176 CAMERA_LOGD("On Buffer Available: size = %{public}u", size);
177 });
178 }
179 streamInfoPre->bufferQueue_->producer_->SetQueueSize(OHOS::Camera::UT_DATA_SIZE);
180 std::vector<StreamInfo> streamInfos;
181 streamInfos.push_back(*streamInfoPre);
182 for (auto _ : st) {
183 cameraTest->rc = cameraTest->streamOperator->CreateStreams(streamInfos);
184 }
185 }
186 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_CreateStreams_benchmark_0010)->Iterations(100)->
187 Repetitions(3)->ReportAggregatesOnly();
188
189 /**
190 * @tc.name: CommitStreams
191 * @tc.desc: CommitStreams, benchmark.
192 * @tc.level: Level0
193 * @tc.size: MediumTest
194 * @tc.type: Function
195 */
BENCHMARK_F(CameraBenchmarkTest,SUB_CommitStreams_benchmark_0010)196 BENCHMARK_F(CameraBenchmarkTest, SUB_CommitStreams_benchmark_0010)(
197 benchmark::State &st)
198 {
199 cameraTest->Open();
200 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
201 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
202 cameraTest->streamOperator);
203 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
204 std::shared_ptr<StreamInfo> streamInfoPre = std::make_shared<StreamInfo>();
205 streamInfoPre->streamId_ = cameraTest->streamIdPreview;
206 streamInfoPre->width_ = cameraTest->previewWidth;
207 streamInfoPre->height_ = cameraTest->previewHeight;
208 streamInfoPre->format_ = cameraTest->previewFormat;
209 streamInfoPre->dataspace_ = OHOS::Camera::UT_DATA_SIZE;
210 streamInfoPre->intent_ = PREVIEW;
211 streamInfoPre->tunneledMode_ = OHOS::Camera::UT_TUNNEL_MODE;
212 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer_pre =
213 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
214 streamInfoPre->bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
215 CAMERA_LOGD("On Buffer Available: size = %{public}u", size);
216 });
217 streamInfoPre->bufferQueue_->producer_->SetQueueSize(OHOS::Camera::UT_DATA_SIZE);
218 std::vector<StreamInfo> streamInfos;
219 streamInfos.push_back(*streamInfoPre);
220 cameraTest->rc = cameraTest->streamOperator->CreateStreams(streamInfos);
221 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
222
223 for (auto _ : st) {
224 cameraTest->rc = cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
225 }
226 }
227 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_CommitStreams_benchmark_0010)->Iterations(100)->
228 Repetitions(3)->ReportAggregatesOnly();
229
230 /**
231 * @tc.name: GetStreamAttributes
232 * @tc.desc: GetStreamAttributes, benchmark.
233 * @tc.level: Level0
234 * @tc.size: MediumTest
235 * @tc.type: Function
236 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetStreamAttributes_benchmark_0010)237 BENCHMARK_F(CameraBenchmarkTest, SUB_GetStreamAttributes_benchmark_0010)(
238 benchmark::State &st)
239 {
240 cameraTest->Open();
241 cameraTest->intents = {PREVIEW};
242 cameraTest->StartStream(cameraTest->intents);
243 std::vector<StreamAttribute> attributes;
244 for (auto _ : st) {
245 cameraTest->rc = cameraTest->streamOperator->GetStreamAttributes(attributes);
246 }
247 }
248 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetStreamAttributes_benchmark_0010)->Iterations(100)->
249 Repetitions(3)->ReportAggregatesOnly();
250 /**
251 * @tc.name: ReleaseStreams
252 * @tc.desc: ReleaseStreams, benchmark.
253 * @tc.level: Level0
254 * @tc.size: MediumTest
255 * @tc.type: Function
256 */
BENCHMARK_F(CameraBenchmarkTest,SUB_ReleaseStreams_benchmark_0010)257 BENCHMARK_F(CameraBenchmarkTest, SUB_ReleaseStreams_benchmark_0010)(
258 benchmark::State &st)
259 {
260 cameraTest->Open();
261 cameraTest->intents = {PREVIEW};
262 cameraTest->StartStream(cameraTest->intents);
263 for (auto _ : st) {
264 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamIdPreview});
265 }
266 }
267 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_ReleaseStreams_benchmark_0010)->Iterations(100)->
268 Repetitions(3)->ReportAggregatesOnly();
269
270 /**
271 * @tc.name: Capture
272 * @tc.desc: Capture, benchmark.
273 * @tc.level: Level0
274 * @tc.size: MediumTest
275 * @tc.type: Function
276 */
BENCHMARK_F(CameraBenchmarkTest,SUB_Capture_benchmark_0010)277 BENCHMARK_F(CameraBenchmarkTest, SUB_Capture_benchmark_0010)(
278 benchmark::State &st)
279 {
280 cameraTest->Open();
281 cameraTest->intents = {PREVIEW};
282 cameraTest->StartStream(cameraTest->intents);
283 int captureId = 2001;
284 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
285 cameraTest->captureInfo->streamIds_ = {-1};
286 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
287 cameraTest->captureInfo->enableShutterCallback_ = true;
288 for (auto _ : st) {
289 cameraTest->rc = cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, true);
290 }
291 }
292 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_Capture_benchmark_0010)->Iterations(100)->
293 Repetitions(3)->ReportAggregatesOnly();
294
295 /**
296 * @tc.name: CancelCapture
297 * @tc.desc: CancelCapture, benchmark.
298 * @tc.level: Level0
299 * @tc.size: MediumTest
300 * @tc.type: Function
301 */
BENCHMARK_F(CameraBenchmarkTest,SUB_CancelCapture_benchmark_0010)302 BENCHMARK_F(CameraBenchmarkTest, SUB_CancelCapture_benchmark_0010)(
303 benchmark::State &st)
304 {
305 cameraTest->Open();
306 cameraTest->intents = {PREVIEW};
307 cameraTest->StartStream(cameraTest->intents);
308 int captureId = 2001;
309 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
310 cameraTest->captureInfo->streamIds_ = {-1};
311 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
312 cameraTest->captureInfo->enableShutterCallback_ = true;
313 cameraTest->rc = cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, true);
314 for (auto _ : st) {
315 cameraTest->streamOperator->CancelCapture(captureId);
316 }
317 }
318 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_CancelCapture_benchmark_0010)->Iterations(100)->
319 Repetitions(3)->ReportAggregatesOnly();
320
321 /**
322 * @tc.name: Close
323 * @tc.desc: Close, benchmark.
324 * @tc.level: Level0
325 * @tc.size: MediumTest
326 * @tc.type: Function
327 */
BENCHMARK_F(CameraBenchmarkTest,SUB_Close_benchmark_0010)328 BENCHMARK_F(CameraBenchmarkTest, SUB_Close_benchmark_0010)(
329 benchmark::State &st)
330 {
331 cameraTest->Open();
332 for (auto _ : st) {
333 cameraTest->cameraDevice->Close();
334 }
335 }
336 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_Close_benchmark_0010)->Iterations(100)->
337 Repetitions(3)->ReportAggregatesOnly();
338
339 /**
340 * @tc.name: EnableResult
341 * @tc.desc: EnableResult, benchmark.
342 * @tc.level: Level0
343 * @tc.size: MediumTest
344 * @tc.type: Function
345 */
BENCHMARK_F(CameraBenchmarkTest,SUB_EnableResult_benchmark_0010)346 BENCHMARK_F(CameraBenchmarkTest, SUB_EnableResult_benchmark_0010)(
347 benchmark::State &st)
348 {
349 cameraTest->Open();
350 std::vector<int32_t> resultsList;
351 resultsList.push_back(OHOS_CAMERA_STREAM_ID);
352 resultsList.push_back(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION);
353 for (auto _ : st) {
354 cameraTest->cameraDevice->EnableResult(resultsList);
355 }
356 }
357 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_EnableResult_benchmark_0010)->Iterations(100)->
358 Repetitions(3)->ReportAggregatesOnly();
359
360 /**
361 * @tc.name: DisableResult
362 * @tc.desc: DisableResult, benchmark.
363 * @tc.level: Level0
364 * @tc.size: MediumTest
365 * @tc.type: Function
366 */
BENCHMARK_F(CameraBenchmarkTest,SUB_DisableResult_benchmark_0010)367 BENCHMARK_F(CameraBenchmarkTest, SUB_DisableResult_benchmark_0010)(
368 benchmark::State &st)
369 {
370 cameraTest->Open();
371 std::vector<OHOS::Camera::MetaType> resultsOriginal;
372 for (auto _ : st) {
373 cameraTest->cameraDevice->DisableResult(resultsOriginal);
374 }
375 }
376 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_DisableResult_benchmark_0010)->Iterations(100)->
377 Repetitions(3)->ReportAggregatesOnly();
378
379 /**
380 * @tc.name: UpdateSettings
381 * @tc.desc: UpdateSettings, benchmark.
382 * @tc.level: Level0
383 * @tc.size: MediumTest
384 * @tc.type: Function
385 */
BENCHMARK_F(CameraBenchmarkTest,SUB_UpdateSettings_benchmark_0010)386 BENCHMARK_F(CameraBenchmarkTest, SUB_UpdateSettings_benchmark_0010)(
387 benchmark::State &st)
388 {
389 cameraTest->Open();
390 cameraTest->intents = {PREVIEW};
391 cameraTest->StartStream(cameraTest->intents);
392 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
393 std::shared_ptr<OHOS::Camera::CameraMetadata> meta = std::make_shared<OHOS::Camera::CameraSetting>(100, 200);
394 int32_t expo = 0xa0;
395 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
396 std::vector<uint8_t> metaVec;
397 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(meta, metaVec);
398 for (auto _ : st) {
399 cameraTest->cameraDevice->UpdateSettings(metaVec);
400 }
401 }
402 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_UpdateSettings_benchmark_0010)->Iterations(100)->
403 Repetitions(3)->ReportAggregatesOnly();
404
405 /**
406 * @tc.name: GetEnabledResults
407 * @tc.desc: GetEnabledResults, benchmark.
408 * @tc.level: Level0
409 * @tc.size: MediumTest
410 * @tc.type: Function
411 */
BENCHMARK_F(CameraBenchmarkTest,SUB_GetEnabledResults_benchmark_0010)412 BENCHMARK_F(CameraBenchmarkTest, SUB_GetEnabledResults_benchmark_0010)(
413 benchmark::State &st)
414 {
415 cameraTest->Open();
416 std::vector<OHOS::Camera::MetaType> enableTypes;
417 for (auto _ : st) {
418 cameraTest->cameraDevice->GetEnabledResults(enableTypes);
419 }
420 }
421 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_GetEnabledResults_benchmark_0010)->Iterations(100)->
422 Repetitions(3)->ReportAggregatesOnly();
423
424 /**
425 * @tc.name: IsStreamsSupported
426 * @tc.desc: IsStreamsSupported, benchmark.
427 * @tc.level: Level0
428 * @tc.size: MediumTest
429 * @tc.type: Function
430 */
BENCHMARK_F(CameraBenchmarkTest,SUB_IsStreamsSupported_benchmark_0010)431 BENCHMARK_F(CameraBenchmarkTest, SUB_IsStreamsSupported_benchmark_0010)(
432 benchmark::State &st)
433 {
434 cameraTest->Open();
435 EXPECT_EQ(false, cameraTest->cameraDevice == nullptr);
436 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
437 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
438 cameraTest->streamOperator);
439 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
440 std::shared_ptr<OHOS::Camera::CameraMetadata> modeSetting = std::make_shared<OHOS::Camera::CameraMetadata>(2, 128);
441 int64_t expoTime = 0;
442 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
443 int64_t colorGains[4] = {0};
444 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
445
446 cameraTest->streamInfo = std::make_shared<StreamInfo>();
447 cameraTest->streamInfo->streamId_ = 101;
448 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
449 cameraTest->streamInfo->height_ = 480;
450 cameraTest->streamInfo->width_ = 640;
451 cameraTest->streamInfo->dataspace_ = 8;
452
453 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer =
454 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
455 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
456 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
457 });
458
459 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
460 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
461 cameraTest->streamInfo->intent_ = PREVIEW;
462 cameraTest->streamInfo->tunneledMode_ = 5;
463 StreamSupportType pType;
464 std::vector<StreamInfo> streams;
465 streams.push_back(*cameraTest->streamInfo);
466 std::vector<uint8_t> modeSettingVec;
467 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(modeSetting, modeSettingVec);
468 for (auto _ : st) {
469 cameraTest->streamOperator->IsStreamsSupported(OperationMode::NORMAL, modeSettingVec,
470 streams, pType);
471 }
472 }
473 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_IsStreamsSupported_benchmark_0010)->Iterations(100)->
474 Repetitions(3)->ReportAggregatesOnly();
475
476 /**
477 * @tc.name: AttachBufferQueue
478 * @tc.desc: AttachBufferQueue, benchmark.
479 * @tc.level: Level0
480 * @tc.size: MediumTest
481 * @tc.type: Function
482 */
BENCHMARK_F(CameraBenchmarkTest,SUB_AttachBufferQueue_benchmark_0010)483 BENCHMARK_F(CameraBenchmarkTest, SUB_AttachBufferQueue_benchmark_0010)(
484 benchmark::State &st)
485 {
486 cameraTest->Open();
487 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
488 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
489 cameraTest->streamOperator);
490
491 cameraTest->streamInfo = std::make_shared<StreamInfo>();
492 cameraTest->streamInfo->streamId_ = 101; // PREVIEW streamId
493 cameraTest->streamInfo->width_ = 720; // Pixel Width
494 cameraTest->streamInfo->height_ = 480; // Pixel height
495 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
496 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
497 cameraTest->streamInfo->intent_ = PREVIEW;
498 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
499 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer =
500 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
501 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
502 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
503 });
504
505 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
506 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
507 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
508
509 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
510 cameraTest->streamInfoSnapshot->streamId_ = 102; // STILL_CAPTURE streamId
511 cameraTest->streamInfoSnapshot->width_ = 720; // Pixel Width
512 cameraTest->streamInfoSnapshot->height_ = 480; // Pixel height
513 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
514 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
515 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
516 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
517 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> snapshotConsumer =
518 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
519 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
520 uint32_t size) {
521 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
522 });
523
524 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
525 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
526 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
527
528 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
529 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
530
531 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> preview_consumer =
532 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
533 OHOS::sptr<OHOS::IBufferProducer> producerTemp = preview_consumer->CreateProducer([this](void* addr,
534 uint32_t size) {
535 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
536 });
537
538 OHOS::sptr<BufferProducerSequenceable> bufferQueue = new BufferProducerSequenceable(producerTemp);
539 for (auto _ : st) {
540 cameraTest->streamOperator->AttachBufferQueue(cameraTest->streamInfoSnapshot->streamId_,
541 bufferQueue);
542 }
543 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
544
545 cameraTest->rc = cameraTest->streamOperator->DetachBufferQueue(cameraTest->streamInfoSnapshot->streamId_);
546 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
547
548 std::vector<int> streamIds = {cameraTest->streamInfo->streamId_, cameraTest->streamInfoSnapshot->streamId_};
549 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams(streamIds);
550 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
551 }
552 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_AttachBufferQueue_benchmark_0010)->Iterations(100)->
553 Repetitions(3)->ReportAggregatesOnly();
554
555 /**
556 * @tc.name: DetachBufferQueue
557 * @tc.desc: DetachBufferQueue, benchmark.
558 * @tc.level: Level0
559 * @tc.size: MediumTest
560 * @tc.type: Function
561 */
BENCHMARK_F(CameraBenchmarkTest,SUB_DetachBufferQueue_benchmark_0010)562 BENCHMARK_F(CameraBenchmarkTest, SUB_DetachBufferQueue_benchmark_0010)(
563 benchmark::State &st)
564 {
565 cameraTest->Open();
566 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
567 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
568 cameraTest->streamOperator);
569
570 cameraTest->streamInfo = std::make_shared<StreamInfo>();
571 cameraTest->streamInfo->streamId_ = 101; // PREVIEW streamId
572 cameraTest->streamInfo->width_ = 720; // Pixel Width
573 cameraTest->streamInfo->height_ = 480; // Pixel height
574 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
575 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
576 cameraTest->streamInfo->intent_ = PREVIEW;
577 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
578 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer =
579 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
580 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
581 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
582 });
583
584 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
585 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
586 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
587
588 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
589 cameraTest->streamInfoSnapshot->streamId_ = 102; // STILL_CAPTURE streamId
590 cameraTest->streamInfoSnapshot->width_ = 720; // Pixel Width
591 cameraTest->streamInfoSnapshot->height_ = 480; // Pixel height
592 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
593 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
594 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
595 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
596 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> snapshotConsumer =
597 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
598 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
599 uint32_t size) {
600 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
601 });
602
603 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
604 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
605 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
606
607 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
608 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
609
610 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> preview_consumer =
611 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
612 OHOS::sptr<OHOS::IBufferProducer> producerTemp = preview_consumer->CreateProducer([this](void* addr,
613 uint32_t size) {
614 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
615 });
616
617 OHOS::sptr<BufferProducerSequenceable> bufferQueue = new BufferProducerSequenceable(producerTemp);
618
619 cameraTest->rc = cameraTest->streamOperator->AttachBufferQueue(cameraTest->streamInfoSnapshot->streamId_,
620 bufferQueue);
621 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
622
623 for (auto _ : st) {
624 cameraTest->streamOperator->DetachBufferQueue(cameraTest->streamInfoSnapshot->streamId_);
625 }
626
627 std::vector<int> streamIds = {cameraTest->streamInfo->streamId_, cameraTest->streamInfoSnapshot->streamId_};
628 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams(streamIds);
629 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
630 }
631 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_DetachBufferQueue_benchmark_0010)->Iterations(100)->
632 Repetitions(3)->ReportAggregatesOnly();
633
634 /**
635 * @tc.name: ChangeToOfflineStream
636 * @tc.desc: ChangeToOfflineStream, benchmark.
637 * @tc.level: Level0
638 * @tc.size: MediumTest
639 * @tc.type: Function
640 */
BENCHMARK_F(CameraBenchmarkTest,SUB_ChangeToOfflineStream_benchmark_0010)641 BENCHMARK_F(CameraBenchmarkTest, SUB_ChangeToOfflineStream_benchmark_0010)(
642 benchmark::State &st)
643 {
644 cameraTest->Open();
645 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
646 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
647 cameraTest->streamOperator);
648
649 cameraTest->streamInfo = std::make_shared<StreamInfo>();
650 cameraTest->streamInfo->streamId_ = 101;
651 cameraTest->streamInfo->width_ = 720;
652 cameraTest->streamInfo->height_ = 480;
653 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
654 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
655 cameraTest->streamInfo->intent_ = PREVIEW;
656 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
657 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer =
658 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
659 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
660 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
661 });
662 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
663 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
664 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
665
666 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
667 cameraTest->streamInfoSnapshot->streamId_ = 102;
668 cameraTest->streamInfoSnapshot->width_ = 720;
669 cameraTest->streamInfoSnapshot->height_ = 480;
670 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
671 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
672 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
673 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
674 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> snapshotConsumer =
675 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
676 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
677 uint32_t size) {
678 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
679 });
680 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
681 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
682 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
683
684 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
685 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
686
687 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL,
688 cameraTest->abilityVec);
689 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
690
691 int captureId = 2001;
692 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
693 cameraTest->captureInfo->streamIds_ = {102};
694 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
695 cameraTest->captureInfo->enableShutterCallback_ = true;
696 bool isStreaming = true;
697 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
698 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
699 sleep(UT_SECOND_TIMES);
700
701 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
702 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
703 for (auto _ : st) {
704 cameraTest->streamOperator->ChangeToOfflineStream({cameraTest->streamInfoSnapshot->streamId_},
705 streamOperatorCallback, offlineStreamOperator);
706 }
707
708 sleep(UT_SECOND_TIMES);
709 cameraTest->rc = (CamRetCode)offlineStreamOperator->CancelCapture(captureId);
710 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
711
712 std::vector<int> streamIds = {102};
713 cameraTest->rc = (CamRetCode)offlineStreamOperator->ReleaseStreams(streamIds);
714 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
715 cameraTest->rc = (CamRetCode)offlineStreamOperator->Release();
716 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
717 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ReleaseStreams({1201});
718 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
719 sleep(UT_SECOND_TIMES);
720 }
721 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_ChangeToOfflineStream_benchmark_0010)->Iterations(100)->
722 Repetitions(3)->ReportAggregatesOnly();
723
724 /**
725 * @tc.name: OfflineStream-CancelCapture
726 * @tc.desc: OfflineStream-CancelCapture, benchmark.
727 * @tc.level: Level0
728 * @tc.size: MediumTest
729 * @tc.type: Function
730 */
BENCHMARK_F(CameraBenchmarkTest,SUB_OfflineCancelCapture_benchmark_0010)731 BENCHMARK_F(CameraBenchmarkTest, SUB_OfflineCancelCapture_benchmark_0010)(
732 benchmark::State &st)
733 {
734 cameraTest->Open();
735 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
736 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
737 cameraTest->streamOperator);
738
739 cameraTest->streamInfo = std::make_shared<StreamInfo>();
740 cameraTest->streamInfo->streamId_ = 101;
741 cameraTest->streamInfo->width_ = 720;
742 cameraTest->streamInfo->height_ = 480;
743 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
744 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
745 cameraTest->streamInfo->intent_ = PREVIEW;
746 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
747 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer =
748 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
749 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
750 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
751 });
752 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
753 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
754 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
755
756 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
757 cameraTest->streamInfoSnapshot->streamId_ = 102;
758 cameraTest->streamInfoSnapshot->width_ = 720;
759 cameraTest->streamInfoSnapshot->height_ = 480;
760 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
761 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
762 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
763 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
764 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> snapshotConsumer =
765 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
766 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
767 uint32_t size) {
768 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
769 });
770 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
771 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
772 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
773
774 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
775 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
776
777 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL,
778 cameraTest->abilityVec);
779 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
780
781 int captureId = 2001;
782 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
783 cameraTest->captureInfo->streamIds_ = {102};
784 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
785 cameraTest->captureInfo->enableShutterCallback_ = true;
786 bool isStreaming = true;
787 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
788 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
789 sleep(UT_SECOND_TIMES);
790
791 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
792 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
793 cameraTest->streamOperator->ChangeToOfflineStream({cameraTest->streamInfoSnapshot->streamId_},
794 streamOperatorCallback, offlineStreamOperator);
795 sleep(UT_SECOND_TIMES);
796 for (auto _ : st) {
797 cameraTest->rc = (CamRetCode)offlineStreamOperator->CancelCapture(captureId);
798 }
799 std::vector<int> streamIds = {102};
800 cameraTest->rc = (CamRetCode)offlineStreamOperator->ReleaseStreams(streamIds);
801 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
802
803 cameraTest->rc = (CamRetCode)offlineStreamOperator->Release();
804 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
805
806 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ReleaseStreams({1201});
807 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
808 sleep(UT_SECOND_TIMES);
809 }
810 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_OfflineCancelCapture_benchmark_0010)->Iterations(100)->
811 Repetitions(3)->ReportAggregatesOnly();
812
813 /**
814 * @tc.name: OfflineStream-ReleaseStreams
815 * @tc.desc: OfflineStream-ReleaseStreams, benchmark.
816 * @tc.level: Level0
817 * @tc.size: MediumTest
818 * @tc.type: Function
819 */
BENCHMARK_F(CameraBenchmarkTest,SUB_OfflineReleaseStreams_benchmark_0010)820 BENCHMARK_F(CameraBenchmarkTest, SUB_OfflineReleaseStreams_benchmark_0010)(
821 benchmark::State &st)
822 {
823 cameraTest->Open();
824 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
825 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
826 cameraTest->streamOperator);
827 cameraTest->streamInfo = std::make_shared<StreamInfo>();
828 cameraTest->streamInfo->streamId_ = 101;
829 cameraTest->streamInfo->width_ = 720;
830 cameraTest->streamInfo->height_ = 480;
831 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
832 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
833 cameraTest->streamInfo->intent_ = PREVIEW;
834 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
835 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer =
836 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
837 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
838 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
839 });
840 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
841 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
842 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
843
844 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
845 cameraTest->streamInfoSnapshot->streamId_ = 102;
846 cameraTest->streamInfoSnapshot->width_ = 720;
847 cameraTest->streamInfoSnapshot->height_ = 480;
848 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
849 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
850 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
851 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
852 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> snapshotConsumer =
853 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
854 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
855 uint32_t size) {
856 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
857 });
858 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
859 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
860 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
861
862 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
863 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
864
865 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL,
866 cameraTest->abilityVec);
867 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
868
869 int captureId = 2001;
870 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
871 cameraTest->captureInfo->streamIds_ = {102};
872 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
873 cameraTest->captureInfo->enableShutterCallback_ = true;
874 bool isStreaming = true;
875 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
876 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
877 sleep(UT_SECOND_TIMES);
878
879 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
880 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
881 cameraTest->streamOperator->ChangeToOfflineStream({cameraTest->streamInfoSnapshot->streamId_},
882 streamOperatorCallback, offlineStreamOperator);
883 cameraTest->rc = (CamRetCode)offlineStreamOperator->CancelCapture(captureId);
884 std::vector<int> streamIds = {102};
885 sleep(UT_SECOND_TIMES);
886 for (auto _ : st) {
887 cameraTest->rc = (CamRetCode)offlineStreamOperator->ReleaseStreams(streamIds);
888 }
889 cameraTest->rc = (CamRetCode)offlineStreamOperator->Release();
890 sleep(UT_SECOND_TIMES);
891 }
892 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_OfflineReleaseStreams_benchmark_0010)->Iterations(100)->
893 Repetitions(3)->ReportAggregatesOnly();
894
895 /**
896 * @tc.name: OfflineStream-Release
897 * @tc.desc: OfflineStream-Release, benchmark.
898 * @tc.level: Level0
899 * @tc.size: MediumTest
900 * @tc.type: Function
901 */
BENCHMARK_F(CameraBenchmarkTest,SUB_OfflineRelease_benchmark_0010)902 BENCHMARK_F(CameraBenchmarkTest, SUB_OfflineRelease_benchmark_0010)(
903 benchmark::State &st)
904 {
905 cameraTest->Open();
906 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
907 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
908 cameraTest->streamOperator);
909
910 cameraTest->streamInfo = std::make_shared<StreamInfo>();
911 cameraTest->streamInfo->streamId_ = 101;
912 cameraTest->streamInfo->width_ = 720;
913 cameraTest->streamInfo->height_ = 480;
914 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
915 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
916 cameraTest->streamInfo->intent_ = PREVIEW;
917 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
918 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> consumer =
919 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
920 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
921 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
922 });
923 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
924 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
925 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
926
927 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
928 cameraTest->streamInfoSnapshot->streamId_ = 102;
929 cameraTest->streamInfoSnapshot->width_ = 720;
930 cameraTest->streamInfoSnapshot->height_ = 480;
931 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
932 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
933 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
934 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
935 std::shared_ptr<OHOS::Camera::HdiCommon::StreamConsumer> snapshotConsumer =
936 std::make_shared<OHOS::Camera::HdiCommon::StreamConsumer>();
937 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
938 uint32_t size) {
939 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
940 });
941 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
942 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
943 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
944
945 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
946 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
947
948 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL,
949 cameraTest->abilityVec);
950 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
951
952 int captureId = 2001;
953 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
954 cameraTest->captureInfo->streamIds_ = {102};
955 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
956 cameraTest->captureInfo->enableShutterCallback_ = true;
957 bool isStreaming = true;
958 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
959 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
960 sleep(UT_SECOND_TIMES);
961
962 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
963 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
964 cameraTest->streamOperator->ChangeToOfflineStream({cameraTest->streamInfoSnapshot->streamId_},
965 streamOperatorCallback, offlineStreamOperator);
966 cameraTest->rc = (CamRetCode)offlineStreamOperator->CancelCapture(captureId);
967 std::vector<int> streamIds = {102};
968 cameraTest->rc = (CamRetCode)offlineStreamOperator->ReleaseStreams(streamIds);
969 sleep(UT_SECOND_TIMES);
970 for (auto _ : st) {
971 cameraTest->rc = (CamRetCode)offlineStreamOperator->Release();
972 }
973 }
974 BENCHMARK_REGISTER_F(CameraBenchmarkTest, SUB_OfflineRelease_benchmark_0010)->Iterations(100)->
975 Repetitions(3)->ReportAggregatesOnly();
976
977 BENCHMARK_MAIN();