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