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