1 /*
2  * Copyright (c) 2020 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file expected 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 <fstream>
16 #include "performance_hdi_test.h"
17 namespace {
18     const int CYCLE_TIMES = 1000; // 1000:Cycle 1000 times
19     const int TIME_TRANSFORMATION_US = 1000000; // 1000000:1000000 microseconds
20     std::ofstream g_writeIntoFile;
21 }
22 
23 using namespace OHOS;
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS::Camera;
calTime(struct timeval start,struct timeval end)27 float PerformanceHdiTest::calTime(struct timeval start, struct timeval end)
28 {
29     float time_use = 0;
30     time_use = (end.tv_sec - start.tv_sec) * TIME_TRANSFORMATION_US + (end.tv_usec - start.tv_usec);
31     return time_use;
32     // return time us
33 }
SetUpTestCase(void)34 void PerformanceHdiTest::SetUpTestCase(void) {}
TearDownTestCase(void)35 void PerformanceHdiTest::TearDownTestCase(void) {}
SetUp(void)36 void PerformanceHdiTest::SetUp(void)
37 {
38     Test_ = std::make_shared<OHOS::Camera::Test>();
39     Test_->Init();
40 }
TearDown(void)41 void PerformanceHdiTest::TearDown(void)
42 {
43     Test_->Close();
44 }
45 
46 /**
47   * @tc.name: HDI_GetCameraIds's time consuming.
48   * @tc.desc: the average time for 1000 times.
49   * @tc.size: MediumTest
50   * @tc.type: Function
51   */
52 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0010, TestSize.Level3)
53 {
54     std::cout << "==========[test log] Performance: HDI_GetCameraIds's time consuming."<< std::endl;
55     struct timeval start;
56     struct timeval end;
57     float time_use;
58     float totle_time_use = 0;
59     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
60     for (int i= 0; i < CYCLE_TIMES; i++) {
61         std::cout << "Running " << i << " time" << std::endl;
62         gettimeofday(&start, NULL);
63         Test_->rc = Test_->service->GetCameraIds(Test_->cameraIds);
64         gettimeofday(&end, NULL);
65         time_use = calTime(start, end);
66         totle_time_use = totle_time_use + time_use;
67         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
68     }
69     float avrg_time = totle_time_use / CYCLE_TIMES;
70     std::cout << "==========[test log] Performance: HDI_GetCameraIds's average time consuming: ";
71     std::cout << avrg_time << "us." << std::endl;
72     g_writeIntoFile << "==========[test log] Performance: HDI_GetCameraIds's average time consuming: ";
73     g_writeIntoFile << avrg_time << "us." << std::endl;
74 }
75 
76 /**
77   * @tc.name: GetCameraAbility
78   * @tc.desc: the average time for 1000 times.
79   * @tc.size: MediumTest
80   * @tc.type: Function
81   */
82 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0020, TestSize.Level0)
83 {
84     std::cout << "==========[test log] Performance: GetCameraAbility's average time consuming." << std::endl;
85     struct timeval start;
86     struct timeval end;
87     float time_use;
88     float totle_time_use = 0;
89     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
90     if (Test_->cameraDevice == nullptr) {
91         Test_->rc = Test_->service->GetCameraIds(Test_->cameraIds);
92         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
93         for (int i= 0; i < CYCLE_TIMES; i++) {
94             std::cout << "Running " << i << " time" << std::endl;
95             gettimeofday(&start, NULL);
96             Test_->rc = Test_->service->GetCameraAbility(Test_->cameraIds.front(), Test_->ability);
97             gettimeofday(&end, NULL);
98             time_use = calTime(start, end);
99             totle_time_use = totle_time_use + time_use;
100             EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
101         }
102         float avrg_time = totle_time_use / CYCLE_TIMES;
103         std::cout << "==========[test log] Performance: GetCameraAbility's average time consuming: ";
104         std::cout << avrg_time << "us." << std::endl;
105         g_writeIntoFile << "==========[test log] Performance: GetCameraAbility's average time consuming: ";
106         g_writeIntoFile << avrg_time << "us." << std::endl;
107     }
108 }
109 
110 /**
111   * @tc.name: HDI_OpenCamera's time consuming.
112   * @tc.desc: the average time for 1000 times.
113   * @tc.size: MediumTest
114   * @tc.type: Function
115   */
116 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0030, TestSize.Level3)
117 {
118     std::cout << "==========[test log] Performance: HDI_OpenCamera's time consuming."<< std::endl;
119     Test_->service->GetCameraIds(Test_->cameraIds);
120     std::string cameraId = Test_->cameraIds.front();
121     Test_->CreateDeviceCallback();
122     struct timeval start;
123     struct timeval end;
124     float time_use;
125     float totle_time_use = 0;
126     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
127     for (int i= 0; i < CYCLE_TIMES; i++) {
128         std::cout << "Running " << i << " time" << std::endl;
129         gettimeofday(&start, NULL);
130         Test_->rc = Test_->service->OpenCamera(cameraId, Test_->deviceCallback, Test_->cameraDevice);
131         gettimeofday(&end, NULL);
132         time_use = calTime(start, end);
133         totle_time_use = totle_time_use + time_use;
134         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
135     }
136     float avrg_time = totle_time_use / CYCLE_TIMES;
137     std::cout << "==========[test log] Performance: HDI_OpenCamera's average time consuming: ";
138     std::cout << avrg_time << "us." << std::endl;
139     g_writeIntoFile << "==========[test log] Performance: HDI_OpenCamera's average time consuming: ";
140     g_writeIntoFile << avrg_time << "us." << std::endl;
141     g_writeIntoFile.close();
142 }
143 
144 /**
145   * @tc.name: HDI_SetFlashlight's time consuming.
146   * @tc.desc: the average time for 1000 times.
147   * @tc.size: MediumTest
148   * @tc.type: Function
149   */
150 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0040, TestSize.Level3)
151 {
152     std::cout << "==========[test log] Performance: HDI_SetFlashlight's time consuming." << std::endl;
153     // Open camera
154     Test_->Open();
155     // Cycle to turn on and off the flashlight
156     struct timeval start;
157     struct timeval end;
158     float time_use;
159     float totle_time_use = 0;
160     for (int i = 0; i < CYCLE_TIMES / 2; i++) {
161         bool status;
162         std::cout << "Running " << i << " time" << std::endl;
163         // Turn on the flashlight
164         status = true;
165         gettimeofday(&start, NULL);
166         Test_->rc = Test_->service->SetFlashlight(Test_->cameraIds.front(), status);
167         gettimeofday(&end, NULL);
168         time_use = calTime(start, end);
169         totle_time_use = totle_time_use + time_use;
170         // Turn off the flashlight
171         status = false;
172         gettimeofday(&start, NULL);
173         Test_->rc = Test_->service->SetFlashlight(Test_->cameraIds.front(), status);
174         gettimeofday(&end, NULL);
175         time_use = calTime(start, end);
176         totle_time_use = totle_time_use + time_use;
177     }
178     float avrg_time = totle_time_use / CYCLE_TIMES;
179     std::cout << "==========[test log] Performance: HDI_SetFlashlight's average time consuming: ";
180     std::cout << avrg_time << "us. " << std::endl;
181     g_writeIntoFile << "==========[test log] Performance: HDI_SetFlashlight's average time consuming: ";
182     g_writeIntoFile << avrg_time << "us. " << std::endl;
183     g_writeIntoFile.close();
184 }
185 
186 /**
187   * @tc.name: GetStreamOperator's time consuming.
188   * @tc.desc: the average time for 1000 times.
189   * @tc.size: MediumTest
190   * @tc.type: Function
191   */
192 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0050, TestSize.Level3)
193 {
194     std::cout << "==========[test log] Performance: GetStreamOperator success, 1000 times." << std::endl;
195     // Get the configured cameraId
196     Test_->service->GetCameraIds(Test_->cameraIds);
197     std::cout << "cameraIds.front() = " << Test_->cameraIds.front() << std::endl;
198     // Open camera
199     Test_->Open();
200     // Call the GetStreamOperator function of the device to get the streamOperator
201     Test_->CreateStreamOperatorCallback();
202     struct timeval start;
203     struct timeval end;
204     float time_use;
205     float totle_time_use = 0;
206     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
207     for (int i = 0; i < CYCLE_TIMES; i++) {
208         std::cout << "Running " << i << " time" << std::endl;
209         gettimeofday(&start, NULL);
210         Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
211         gettimeofday(&end, NULL);
212         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
213         time_use = calTime(start, end);
214         totle_time_use = totle_time_use + time_use;
215     }
216     float avrg_time = totle_time_use / CYCLE_TIMES;
217     std::cout << "==========[test log] Performance: HDI_cameraDevice->GetStreamOperator's average time: ";
218     std::cout << avrg_time << "us. " << std::endl;
219     g_writeIntoFile << "==========[test log] Performance: HDI_cameraDevice->GetStreamOperator's average time: ";
220     g_writeIntoFile << avrg_time << "us. " << std::endl;
221     g_writeIntoFile.close();
222 }
223 
224 /**
225   * @tc.name: HDI_UpdateSettings's time consuming.
226   * @tc.desc: the average time for 1000 times.
227   * @tc.size: MediumTest
228   * @tc.type: Function
229   */
230 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0060, TestSize.Level3)
231 {
232     std::cout << "==========[test log] Check HDI_UpdateSettings's time consuming." << std::endl;
233     Test_->Open();
234     // Issue 3A parameters
235     std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
236     std::vector<uint8_t> awbMode = {
237         OHOS_CAMERA_AWB_MODE_OFF,
238         OHOS_CAMERA_AWB_MODE_TWILIGHT,
239         OHOS_CAMERA_AWB_MODE_AUTO,
240         OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT,
241         OHOS_CAMERA_AWB_MODE_DAYLIGHT,
242         OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT,
243         OHOS_CAMERA_AWB_MODE_INCANDESCENT,
244         OHOS_CAMERA_AWB_MODE_FLUORESCENT,
245         OHOS_CAMERA_AWB_MODE_SHADE
246     };
247     struct timeval start;
248     struct timeval end;
249     float time_use;
250     float totle_time_use = 0;
251     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
252     for (int round = 0; round < CYCLE_TIMES; round ++) {
253         int i = rand() % 9;
254         std::cout << "round = "<< round << ", i = " << i << std::endl;
255         meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode.at(i), 1);
256         gettimeofday(&start, NULL);
257         Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
258         gettimeofday(&end, NULL);
259         std::cout << "rc = "<< Test_->rc << std::endl;
260         time_use = calTime(start, end);
261         totle_time_use = totle_time_use + time_use;
262     }
263     float avrg_time = totle_time_use / CYCLE_TIMES;
264     std::cout << "==========[test log] Performance: HDI_UpdateSettings's  turn on average time : ";
265     std::cout << avrg_time << "us. " << std::endl;
266     g_writeIntoFile << "==========[test log] Performance: HDI_UpdateSettings's  turn on average time : ";
267     g_writeIntoFile << avrg_time << "us. " << std::endl;
268     g_writeIntoFile.close();
269 }
270 
271 /**
272   * @tc.name: SetResultMode's time consuming.
273   * @tc.desc: the average time for 1000 times.
274   * @tc.size: MediumTest
275   * @tc.type: Function
276   */
277 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0070, TestSize.Level3)
278 {
279     std::cout << "==========[test log]Check Performance: HDI_cameraDevice->SetResultMode's average time" << std::endl;
280     struct timeval start;
281     struct timeval end;
282     float time_use;
283     float totle_time_use = 0;
284     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
285     Test_->Open();
286     EXPECT_EQ(true, Test_->cameraDevice != nullptr);
287     std::vector<Camera::MetaType> enableTypes;
288     Test_->rc = Test_->cameraDevice->GetEnabledResults(enableTypes);
289     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
290     for (int i = 0; i < CYCLE_TIMES; i++) {
291         std::cout << "Running " << i << " time" << std::endl;
292         gettimeofday(&start, NULL);
293         Test_->rc = Test_->cameraDevice->SetResultMode(Camera::PER_FRAME);
294         gettimeofday(&end, NULL);
295         time_use = calTime(start, end);
296         totle_time_use = totle_time_use + time_use;
297         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
298     }
299     float avrg_time = totle_time_use / CYCLE_TIMES;
300     std::cout << "==========[test log] Performance: HDI_cameraDevice->SetResultMode's average time: ";
301     std::cout << avrg_time << "us. " << std::endl;
302     g_writeIntoFile << "==========[test log] Performance: HDI_cameraDevice->SetResultMode's average time: ";
303     g_writeIntoFile << avrg_time << "us. " << std::endl;
304     g_writeIntoFile.close();
305 }
306 
307 /**
308   * @tc.name: GetEnabledResults
309   * @tc.desc: the average time for 1000 times.
310   * @tc.size: MediumTest
311   * @tc.type: Function
312   */
313 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0080, TestSize.Level3)
314 {
315     std::cout << "==========[test log]Performance: HDI_cameraDevice->GetEnabledResults's average time." << std::endl;
316     struct timeval start;
317     struct timeval end;
318     float time_use;
319     float totle_time_use = 0;
320     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
321     Test_->Open();
322     std::vector<Camera::MetaType> results;
323     for (int i = 0; i < CYCLE_TIMES; i++) {
324         std::cout << "Running " << i << " time" << std::endl;
325         gettimeofday(&start, NULL);
326         Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
327         gettimeofday(&end, NULL);
328         time_use = calTime(start, end);
329         totle_time_use = totle_time_use + time_use;
330         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
331     }
332     float avrg_time = totle_time_use / CYCLE_TIMES;
333     std::cout << "==========[test log] Performance: HDI_cameraDevice->GetEnabledResults's average time: ";
334     std::cout << avrg_time << "us. " << std::endl;
335     g_writeIntoFile << "==========[test log] Performance: HDI_cameraDevice->GetEnabledResults's average time: ";
336     g_writeIntoFile << avrg_time << "us. " << std::endl;
337     g_writeIntoFile.close();
338 }
339 
340 /**
341   * @tc.name: EnableResult
342   * @tc.desc: the average time for 1000 times.
343   * @tc.size: MediumTest
344   * @tc.type: Function
345   */
346 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0090, TestSize.Level3)
347 {
348     std::cout << "==========[test log]Performance: HDI_cameraDevice->EnableResult's average time." << std::endl;
349     struct timeval start;
350     struct timeval end;
351     float time_use;
352     float totle_time_use = 0;
353     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
354     Test_->Open();
355     // Get the parameter tag currently supported by the device
356     std::cout << "==========[test log]Check hdi_device: 1. Get the tags..." << std::endl;
357     std::vector<Camera::MetaType> results_original;
358     results_original.push_back(OHOS_SENSOR_EXPOSURE_TIME);
359     results_original.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
360     Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
361     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
362     // Add this tag
363     std::vector<Camera::MetaType> enable_tag;
364     enable_tag.push_back(results_original[1]);
365     for (int i = 0; i < CYCLE_TIMES; i++) {
366         std::cout << "Running " << i << " time" << std::endl;
367         gettimeofday(&start, NULL);
368         Test_->rc = Test_->cameraDevice->EnableResult(enable_tag);
369         gettimeofday(&end, NULL);
370         time_use = calTime(start, end);
371         totle_time_use = totle_time_use + time_use;
372         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
373     }
374     float avrg_time = totle_time_use / CYCLE_TIMES;
375     std::cout << "==========[test log] Performance: HDI_cameraDevice->EnableResult's average time: ";
376     std::cout << avrg_time << "us. " << std::endl;
377     g_writeIntoFile << "==========[test log] Performance: HDI_cameraDevice->EnableResult's average time: ";
378     g_writeIntoFile << avrg_time << "us. " << std::endl;
379     g_writeIntoFile.close();
380 }
381 
382 /**
383   * @tc.name: DisableResult
384   * @tc.desc: the average time for 1000 times.
385   * @tc.size: MediumTest
386   * @tc.type: Function
387   */
388 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0100, TestSize.Level3)
389 {
390     std::cout << "==========[test log]Performance: HDI_cameraDevice->DisableResult's average time." << std::endl;
391     struct timeval start;
392     struct timeval end;
393     float time_use;
394     float totle_time_use = 0;
395     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
396     Test_->Open();
397     // Get the parameter tag currently supported by the device
398     std::cout << "==========[test log]Check hdi_device: 1. Get the tags..." << std::endl;
399     std::vector<Camera::MetaType> results_original;
400     results_original.push_back(OHOS_SENSOR_EXPOSURE_TIME);
401     results_original.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
402     Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
403     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
404     // Disable this tag
405     std::vector<Camera::MetaType> disable_tag;
406     disable_tag.push_back(results_original[1]);
407     for (int i = 0; i < CYCLE_TIMES; i++) {
408         std::cout << "Running " << i << " time" << std::endl;
409         gettimeofday(&start, NULL);
410         Test_->rc = Test_->cameraDevice->DisableResult(disable_tag);
411         gettimeofday(&end, NULL);
412         time_use = calTime(start, end);
413         totle_time_use = totle_time_use + time_use;
414         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
415     }
416     float avrg_time = totle_time_use / CYCLE_TIMES;
417     std::cout << "==========[test log] Performance: HDI_cameraDevice->DisableResult's average time: ";
418     std::cout << avrg_time << "us. " << std::endl;
419     g_writeIntoFile << "==========[test log] Performance: HDI_cameraDevice->DisableResult's average time: ";
420     g_writeIntoFile << avrg_time << "us. " << std::endl;
421     g_writeIntoFile.close();
422 }
423 
424 /**
425   * @tc.name: IsStreamsSupported
426   * @tc.desc: the average time for 1000 times.
427   * @tc.size: MediumTest
428   * @tc.type: Function
429   */
430 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0120, TestSize.Level0)
431 {
432     std::cout << "==========[test log]Performance: HDI_IsStreamsSupported's average time." << std::endl;
433     struct timeval start;
434     struct timeval end;
435     float time_use;
436     float totle_time_use = 0;
437     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
438     // Open camera
439     Test_->Open();
440     EXPECT_EQ(false, Test_->cameraDevice == nullptr);
441     // Get streamOperator
442     Test_->CreateStreamOperatorCallback();
443     Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
444     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
445     // Configure mode and modeSetting
446     Camera::OperationMode mode = Camera::NORMAL;
447     std::shared_ptr<CameraMetadata> modeSetting =
448         std::make_shared<CameraMetadata>(2, 128);
449     int64_t colorGains[4] = {0};
450     modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
451     int64_t expoTime = 0;
452     modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
453     // Configure stream information
454     Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
455     Test_->streamInfo->streamId_ = 1001; // 1001:streamId
456     Test_->streamInfo->dataspace_ = 8;
457     Test_->streamInfo->intent_ = Camera::PREVIEW;
458     Test_->streamInfo->width_ = 640; // 640:Stream width
459     Test_->streamInfo->height_ = 480; // 480:Stream height
460     Test_->StreamInfoFormat();
461     Test_->streamInfo->tunneledMode_ = 5;
462     std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
463       std::make_shared<OHOS::Camera::Test::StreamConsumer>();
464 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon9ef6ec330202(OHOS::SurfaceBuffer* buffer) 465     Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
466         Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
467     });
468 #else
__anon9ef6ec330302(void* addr, uint32_t size) 469     Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) {
470         Test_->SaveYUV("preview", addr, size);
471     });
472 #endif
473     Test_->streamInfo->bufferQueue_->SetQueueSize(8);
474     Test_->consumerMap_[Test_->streamInfo->intent_] = consumer;
475     Camera::StreamSupportType pType;
476     for (int i = 0; i < CYCLE_TIMES; i++) {
477         std::cout << "Running " << i << " time" << std::endl;
478         gettimeofday(&start, NULL);
479         std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> stre;
480         stre.push_back(Test_->streamInfo);
481         Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, modeSetting, stre, pType);
482         gettimeofday(&end, NULL);
483         time_use = calTime(start, end);
484         totle_time_use = totle_time_use + time_use;
485         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
486     }
487     float avrg_time = totle_time_use / CYCLE_TIMES;
488     std::cout << "==========[test log] Performance: HDI_IsStreamsSupported's average time: ";
489     std::cout << avrg_time << "us. " << std::endl;
490     g_writeIntoFile << "HDI_IsStreamsSupported's average time: " << avrg_time << "us. " << std::endl;
491     g_writeIntoFile.close();
492 }
493 
494 /**
495   * @tc.name: HDI_CreateStreams's time consuming.
496   * @tc.desc: the average time for 1000 times.
497   * @tc.size: MediumTest
498   * @tc.type: Function
499   */
500 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0130, TestSize.Level3)
501 {
502     std::cout << "==========[test log] Performance: HDI_CreateStreams's time consuming." << std::endl;
503     struct timeval start;
504     struct timeval end;
505     float time_use;
506     float totle_time_use = 0;
507     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
508     Test_->Open();
509     for (int i = 0; i < CYCLE_TIMES; i ++) {
510         std::cout << "Running " << i << " time" << std::endl;
511         // Create and get streamOperator information
512         Test_->CreateStreamOperatorCallback();
513         Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
514         EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr);
515         // Create data flow
516         Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
517         Test_->streamInfo->streamId_ = 1001;
518         Test_->streamInfo->width_ = 1920;
519         Test_->streamInfo->height_ = 1080;
520         Test_->StreamInfoFormat();
521         Test_->streamInfo->dataspace_ = 10;
522         Test_->streamInfo->intent_ = Camera::PREVIEW;
523         Test_->streamInfo->tunneledMode_ = 5;
524         std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
525             std::make_shared<OHOS::Camera::Test::StreamConsumer>();
526 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon9ef6ec330402(OHOS::SurfaceBuffer* buffer) 527         Test_->streamInfo->bufferQueue_ = preview_consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
528             Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
529         });
530 #else
__anon9ef6ec330502(void* addr, uint32_t size) 531         Test_->streamInfo->bufferQueue_ = preview_consumer->CreateProducer([this](void* addr, uint32_t size) {
532             Test_->SaveYUV("preview", addr, size);
533         });
534 #endif
535         Test_->streamInfo->bufferQueue_->SetQueueSize(8);
536         Test_->consumerMap_[Camera::PREVIEW] = preview_consumer;
537         std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
538         Test_->streamInfos.push_back(Test_->streamInfo);
539         gettimeofday(&start, NULL);
540         Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
541         gettimeofday(&end, NULL);
542         std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
543         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
544         time_use = calTime(start, end);
545         totle_time_use = totle_time_use + time_use;
546         // Release stream
547         Test_->rc = Test_->streamOperator->ReleaseStreams({1001});
548         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
549     }
550     float avrg_time = totle_time_use / CYCLE_TIMES;
551     std::cout << "==========[test log] Performance: HDI_CreateStreams's average time consuming: ";
552     std::cout << avrg_time << "us. " << std::endl;
553     g_writeIntoFile << "==========[test log] Performance: HDI_CreateStreams's average time consuming: ";
554     g_writeIntoFile << avrg_time << "us. " << std::endl;
555     g_writeIntoFile.close();
556 }
557 
558 /**
559   * @tc.name: HDI_ReleaseStreams's time consuming.
560   * @tc.desc: the average time for 1000 times.
561   * @tc.size: MediumTest
562   * @tc.type: Function
563   */
564 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0160, TestSize.Level3)
565 {
566     std::cout << "==========[test log] Performance: HDI_ReleaseStreams's time consuming."<< std::endl;
567     struct timeval start;
568     struct timeval end;
569     float time_use;
570     float totle_time_use = 0;
571     Test_->Open();
572     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
573     for (int i = 0; i < CYCLE_TIMES; i ++) {
574         std::cout  << "CYCLE_TIMES =" << i << std::endl;
575         // Start stream
576         Test_->intents = {Camera::PREVIEW};
577         Test_->StartStream(Test_->intents);
578         // Release stream
579         gettimeofday(&start, NULL);
580         Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamId_preview});
581         gettimeofday(&end, NULL);
582         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
583         time_use = calTime(start, end);
584         totle_time_use = totle_time_use + time_use;
585     }
586     float avrg_time = totle_time_use / CYCLE_TIMES;
587     std::cout << "==========[test log] Performance: HDI_ReleaseStreams's average time consuming: ";
588     std::cout  << avrg_time << "us. " << std::endl;
589     g_writeIntoFile << "==========[test log] Performance: HDI_ReleaseStreams's average time consuming: ";
590     g_writeIntoFile  << avrg_time << "us. " << std::endl;
591     g_writeIntoFile.close();
592 }
593 
594 /**
595   * @tc.name: CommitStreams's time consuming.
596   * @tc.desc: the average time for 1000 times.
597   * @tc.size: MediumTest
598   * @tc.type: Function
599   */
600 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0170, TestSize.Level3)
601 {
602     std::cout << "==========[test log] Performance: CommitStreams's time consuming." << std::endl;
603 
604     struct timeval start;
605     struct timeval end;
606     float time_use;
607     float totle_time_use = 0;
608     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
609     Test_->Open();
610     for (int i = 0; i < CYCLE_TIMES; i ++) {
611         std::cout << "Running " << i << " time" << std::endl;
612         // Create and get streamOperator information
613         Test_->CreateStreamOperatorCallback();
614         Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
615         EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr);
616         // Create data flow
617         Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
618         Test_->streamInfo->streamId_ = 1001;
619         Test_->streamInfo->width_ = 1920;
620         Test_->streamInfo->height_ = 1080;
621         Test_->StreamInfoFormat();
622         Test_->streamInfo->dataspace_ = 10;
623         Test_->streamInfo->intent_ = Camera::PREVIEW;
624         Test_->streamInfo->tunneledMode_ = 5;
625         std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
626         std::make_shared<OHOS::Camera::Test::StreamConsumer>();
627 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon9ef6ec330602(OHOS::SurfaceBuffer* buffer) 628         Test_->streamInfo->bufferQueue_ = preview_consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
629             Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
630         });
631 #else
__anon9ef6ec330702(void* addr, uint32_t size) 632         Test_->streamInfo->bufferQueue_ = preview_consumer->CreateProducer([this](void* addr, uint32_t size) {
633             Test_->SaveYUV("preview", addr, size);
634         });
635 #endif
636         Test_->streamInfo->bufferQueue_->SetQueueSize(8);
637         Test_->consumerMap_[Camera::PREVIEW] = preview_consumer;
638         std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
639         Test_->streamInfos.push_back(Test_->streamInfo);
640         Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
641         std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
642         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
643         // Flow distribution
644         gettimeofday(&start, NULL);
645         Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
646         gettimeofday(&end, NULL);
647         std::cout << "streamOperator->CommitStreams's rc " << Test_->rc << std::endl;
648         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
649         time_use = calTime(start, end);
650         totle_time_use = totle_time_use + time_use;
651         // Release stream
652         Test_->rc = Test_->streamOperator->ReleaseStreams({1001});
653         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
654     }
655     float avrg_time = totle_time_use / CYCLE_TIMES;
656     std::cout << "==========[test log] Performance: CommitStreams's average time consuming: ";
657     std::cout << avrg_time << "us. " << std::endl;
658     g_writeIntoFile << "==========[test log] Performance: CommitStreams's average time consuming: ";
659     g_writeIntoFile << avrg_time << "us. " << std::endl;
660     g_writeIntoFile.close();
661 }
662 
663 /**
664   * @tc.name: GetStreamAttributes
665   * @tc.desc: the average time for 1000 times.
666   * @tc.size: MediumTest
667   * @tc.type: Function
668   */
669 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0180, TestSize.Level3)
670 {
671     std::cout << "==========[test log]Check Performance: HDI_GetStreamAttributes's average time." << std::endl;
672     struct timeval start;
673     struct timeval end;
674     float time_use;
675     float totle_time_use = 0;
676     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
677     Test_->Open();
678     // Start stream
679     Test_->intents = {Camera::PREVIEW};
680     Test_->StartStream(Test_->intents);
681     std::vector<std::shared_ptr<Camera::StreamAttribute>> attributes;
682     for (int i = 0; i < CYCLE_TIMES; i++) {
683         std::cout << "Running " << i << " time" << std::endl;
684         gettimeofday(&start, NULL);
685         Test_->rc = Test_->streamOperator->GetStreamAttributes(attributes);
686         gettimeofday(&end, NULL);
687         time_use = calTime(start, end);
688         totle_time_use = totle_time_use + time_use;
689         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
690     }
691     float avrg_time = totle_time_use / CYCLE_TIMES;
692     std::cout << "==========[test log] Performance: HDI_GetStreamAttributes's average time: ";
693     std::cout << avrg_time << "us. " << std::endl;
694     g_writeIntoFile << "==========[test log] Performance: HDI_GetStreamAttributes's average time: ";
695     g_writeIntoFile << avrg_time << "us. " << std::endl;
696     g_writeIntoFile.close();
697     // Release stream
698     Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamId_preview});
699     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
700     std::cout << "streamOperator->ReleaseStreams's rc " << Test_->rc << std::endl;
701 }
702 
703 /**
704   * @tc.name: HDI_Capture's time consuming.
705   * @tc.desc: the average time for 1000 times.
706   * @tc.size: MediumTest
707   * @tc.type: Function
708   */
709 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0190, TestSize.Level3)
710 {
711     std::cout << "==========[test log] Performance: HDI_Capture's average time consuming." << std::endl;
712     struct timeval start;
713     struct timeval end;
714     float time_use;
715     float totle_time_use = 0;
716     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
717     // Open camera
718     Test_->Open();
719     // Start stream
720     Test_->intents = {Camera::PREVIEW};
721     Test_->StartStream(Test_->intents);
722     // Get preview
723     int captureId = 2001;
724     Test_->captureInfo = std::make_shared<Camera::CaptureInfo>();
725     Test_->captureInfo->streamIds_ = {Test_->streamId_preview};
726     Test_->captureInfo->captureSetting_ = Test_->ability;
727     Test_->captureInfo->enableShutterCallback_ = true;
728     for (int i = 0; i < CYCLE_TIMES; i++) {
729         std::cout  << "CYCLE_TIMES =" << i << std::endl;
730         gettimeofday(&start, NULL);
731         Test_->rc = Test_->streamOperator->Capture(captureId, Test_->captureInfo, true);
732         if (Test_->rc == Camera::NO_ERROR) {
733             std::cout << "==========[test log]check Capture: Capture success, " << captureId << std::endl;
734         } else {
735             std::cout << "==========[test log]check Capture: Capture fail, rc = " << Test_->rc << std::endl;
736         }
737         gettimeofday(&end, NULL);
738         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
739         time_use = calTime(start, end);
740         totle_time_use = totle_time_use + time_use;
741         sleep(1);
742         Test_->rc = Test_->streamOperator->CancelCapture(captureId++);
743         if (Test_->rc == Camera::NO_ERROR) {
744             std::cout << "==========[test log]check Capture: CancelCapture success," << captureId << std::endl;
745         } else {
746             std::cout << "==========[test log]check Capture: CancelCapture fail, rc = " << Test_->rc << std::endl;
747             std::cout << "captureId = " << captureId << std::endl;
748         }
749         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
750     }
751     float avrg_time = totle_time_use / CYCLE_TIMES;
752     std::cout << "==========[test log] Performance: HDI_Capture's average time consuming: ";
753     std::cout << avrg_time << "us. " << std::endl;
754     g_writeIntoFile << "==========[test log] Performance: HDI_Capture's average time consuming: ";
755     g_writeIntoFile << avrg_time << "us. " << std::endl;
756     g_writeIntoFile.close();
757     // post-processing
758     Test_->streamIds.push_back(Test_->streamId_preview);
759     Test_->rc = Test_->streamOperator->ReleaseStreams(Test_->streamIds);
760     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
761 }
762 
763 /**
764   * @tc.name: HDI_CancelCapture's time consuming.
765   * @tc.desc: the average time for 1000 times.
766   * @tc.size: MediumTest
767   * @tc.type: Function
768   */
769 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0200, TestSize.Level3)
770 {
771     std::cout << "==========[test log] Performance: HDI_CancelCapture's average time consuming." << std::endl;
772     struct timeval start;
773     struct timeval end;
774     float time_use;
775     float totle_time_use = 0;
776     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
777     // Open camera
778     Test_->Open();
779     // Start stream
780     Test_->intents = {Camera::PREVIEW};
781     Test_->StartStream(Test_->intents);
782     // Get preview
783     int captureId = 2001;
784     Test_->captureInfo = std::make_shared<Camera::CaptureInfo>();
785     Test_->captureInfo->streamIds_ = {Test_->streamId_preview};
786     Test_->captureInfo->captureSetting_ = Test_->ability;
787     Test_->captureInfo->enableShutterCallback_ = true;
788     for (int i = 0; i < CYCLE_TIMES; i++) {
789         std::cout  << "CYCLE_TIMES =" << i << std::endl;
790         Test_->rc = Test_->streamOperator->Capture(captureId, Test_->captureInfo, true);
791         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
792         sleep(1);
793         gettimeofday(&start, NULL);
794         Test_->rc = Test_->streamOperator->CancelCapture(captureId);
795         gettimeofday(&end, NULL);
796         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
797         time_use = calTime(start, end);
798         totle_time_use = totle_time_use + time_use;
799         captureId++;
800     }
801     float avrg_time = totle_time_use / CYCLE_TIMES;
802     std::cout << "==========[test log] Performance: HDI_CancelCapture's average time consuming: ";
803     std::cout << avrg_time << "us. " << std::endl;
804     g_writeIntoFile << "==========[test log] Performance: HDI_CancelCapture's average time consuming: ";
805     g_writeIntoFile << avrg_time << "us. " << std::endl;
806     g_writeIntoFile.close();
807     // post-processing
808     Test_->streamIds.push_back(Test_->streamId_preview);
809     Test_->rc = Test_->streamOperator->ReleaseStreams(Test_->streamIds);
810     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
811 }
812 
813 /**
814   * @tc.name: AttachBufferQueue
815   * @tc.desc: the average time for 1000 times.
816   * @tc.size: MediumTest
817   * @tc.type: Function
818   */
819 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0210, TestSize.Level3)
820 {
821     std::cout << "==========[test log] Performance: HDI_AttachBufferQueue's average time consuming." << std::endl;
822     struct timeval start;
823     struct timeval end;
824     float time_use;
825     float totle_time_use = 0;
826     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
827     // Open camera
828     Test_->Open();
829     Test_->CreateStreamOperatorCallback();
830     Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
831     EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
832     for (int i = 0; i < CYCLE_TIMES; i++) {
833         std::cout << "Running " << i << " time" << std::endl;
834         // Create data flow
835         Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
836         Test_->streamInfo->streamId_ = Test_->streamId_preview;
837         Test_->streamInfo->width_ = 640;
838         Test_->streamInfo->height_ = 480;
839         Test_->StreamInfoFormat();
840         Test_->streamInfo->intent_ = Camera::PREVIEW;
841         Test_->streamInfo->dataspace_ = 8;
842         Test_->streamInfo->tunneledMode_ = 5;
843         std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
844         Test_->streamInfos.push_back(Test_->streamInfo);
845         Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
846         std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
847         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
848         // Flow distribution
849         Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
850         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
851         std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl;
852         std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
853         std::make_shared<OHOS::Camera::Test::StreamConsumer>();
854 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon9ef6ec330802(OHOS::SurfaceBuffer* buffer) 855         std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
856             Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
857         });
858 #else
__anon9ef6ec330902(void* addr, uint32_t size) 859         OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) {
860             Test_->SaveYUV("preview", addr, size);
861         });
862 #endif
863         gettimeofday(&start, NULL);
864         Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer);
865         std::cout << "==========[test log]Check hdi: streamOperator->AttachBufferQueue's rc " << Test_->rc << std::endl;
866         gettimeofday(&end, NULL);
867         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
868         time_use = calTime(start, end);
869         totle_time_use = totle_time_use + time_use;
870         Test_->rc = Test_->streamOperator->DetachBufferQueue(Test_->streamInfo->streamId_);
871         std::cout << "==========[test log]Check hdi: streamOperator->DetachBufferQueue's rc " << Test_->rc << std::endl;
872         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
873         // Release stream
874         Test_->streamIds.push_back(Test_->streamId_preview);
875         Test_->rc = Test_->streamOperator->ReleaseStreams(Test_->streamIds);
876         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
877     }
878     float avrg_time = totle_time_use / CYCLE_TIMES;
879     std::cout << "==========[test log] Performance: HDI_AttachBufferQueue's average time consuming: ";
880     std::cout << avrg_time << "us. " << std::endl;
881     g_writeIntoFile << "==========[test log] Performance: HDI_AttachBufferQueue's average time consuming: ";
882     g_writeIntoFile << avrg_time << "us. " << std::endl;
883     g_writeIntoFile.close();
884 }
885 
886 /**
887   * @tc.name: DetachBufferQueue
888   * @tc.desc: the average time for 1000 times.
889   * @tc.size: MediumTest
890   * @tc.type: Function
891   */
892 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0220, TestSize.Level3)
893 {
894     std::cout << "==========[test log] Performance: HDI_DetachBufferQueue's average time consuming." << std::endl;
895     struct timeval start;
896     struct timeval end;
897     float time_use;
898     float totle_time_use = 0;
899     Test_->Open();
900     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
901     for (int i = 0; i < CYCLE_TIMES; i++) {
902         std::cout << "Running " << i << " time" << std::endl;
903         Test_->CreateStreamOperatorCallback();
904         Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
905         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
906         // Create data flow
907         Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
908         Test_->streamInfo->intent_ = Camera::PREVIEW;
909         Test_->streamInfo->streamId_ = Test_->streamId_preview;
910         Test_->streamInfo->width_ = 640;
911         Test_->streamInfo->height_ = 480;
912         Test_->StreamInfoFormat();
913         Test_->streamInfo->dataspace_ = 8;
914         Test_->streamInfo->tunneledMode_ = 5;
915         std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
916         Test_->streamInfos.push_back(Test_->streamInfo);
917         Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
918         std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
919         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
920         // Flow distribution
921         Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
922         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
923         std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl;
924         std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
925         std::make_shared<OHOS::Camera::Test::StreamConsumer>();
926 #ifdef CAMERA_BUILT_ON_OHOS_LITE
__anon9ef6ec330a02(OHOS::SurfaceBuffer* buffer) 927         std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
928             Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
929         });
930 #else
__anon9ef6ec330b02(void* addr, uint32_t size) 931         OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) {
932             Test_->SaveYUV("preview", addr, size);
933         });
934 #endif
935         Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer);
936         std::cout << "==========[test log]Check hdi: streamOperator->AttachBufferQueue's rc ";
937         std::cout << Test_->rc << std::endl;
938         gettimeofday(&start, NULL);
939         Test_->rc = Test_->streamOperator->DetachBufferQueue(Test_->streamInfo->streamId_);
940         std::cout << "==========[test log]Check hdi: streamOperator->DetachBufferQueue's rc ";
941         std::cout << Test_->rc << std::endl;
942         gettimeofday(&end, NULL);
943         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
944         time_use = calTime(start, end);
945         totle_time_use = totle_time_use + time_use;
946         // Release stream
947         Test_->streamIds.push_back(Test_->streamId_preview);
948         Test_->rc = Test_->streamOperator->ReleaseStreams(Test_->streamIds);
949         EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
950     }
951     float avrg_time = totle_time_use / CYCLE_TIMES;
952     std::cout << "==========[test log] Performance: HDI_DetachBufferQueue's average time consuming: ";
953     std::cout << avrg_time << "us. " << std::endl;
954     g_writeIntoFile << "==========[test log] Performance: HDI_DetachBufferQueue's average time consuming: ";
955     g_writeIntoFile << avrg_time << "us. " << std::endl;
956     g_writeIntoFile.close();
957 }
958 
959 /**
960   * @tc.name: ChangeToOfflineStream
961   * @tc.desc: the average time for 1000 times.
962   * @tc.size: MediumTest
963   * @tc.type: Function
964   */
965 HWTEST_F(PerformanceHdiTest, Camera_Performance_Hdi_0230, TestSize.Level0)
966 {
967     std::cout << "==========[test log] Performance: HDI_ChangeToOfflineStream's average time consuming." << std::endl;
968     struct timeval start;
969     struct timeval end;
970     float time_use;
971     float totle_time_use = 0;
972     Test_->Open();
973     g_writeIntoFile.open("TimeConsuming.txt", ios::app);
974     for (int i = 0; i < CYCLE_TIMES; i++) {
975         std::cout << "Running " << i << " time" << std::endl;
976         // 1、Configure two stream information
977         Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
978         Test_->StartStream(Test_->intents);
979         // 2、Capture preview stream
980         Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
981         // 3、Capture camera stream, continuous shooting
982         Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
983         sleep(1);
984         // 4、Convert to offline stream
985         Test_->CreateOfflineStreamOperatorCallback();
986         gettimeofday(&start, NULL);
987         std::vector<int> offlineIds;
988         offlineIds.push_back(Test_->streamId_capture);
989         Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
990             offlineIds, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
991         gettimeofday(&end, NULL);
992         ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
993         time_use = calTime(start, end);
994         totle_time_use = totle_time_use + time_use;
995         std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
996         EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
997         if (Test_->rc == Camera::NO_ERROR) {
998             std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
999         } else {
1000             std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
1001         }
1002         // 5、Post-processing of the original stream
1003         Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
1004         Test_->streamIds.push_back(Test_->streamId_preview);
1005         Test_->streamIds.push_back(Test_->streamId_capture);
1006         Test_->StopStream(Test_->captureIds, Test_->streamIds);
1007         // 6、Post-processing of offline streams
1008         Test_->cameraDevice->Close();
1009         std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
1010         sleep(1);
1011         Test_->StopOfflineStream(Test_->captureId_capture);
1012     }
1013     float avrg_time = totle_time_use / CYCLE_TIMES;
1014     std::cout << "==========[test log] Performance: HDI_ChangeToOfflineStream's average time consuming: ";
1015     std::cout << avrg_time << "us. " << std::endl;
1016     g_writeIntoFile << "==========[test log] Performance: HDI_ChangeToOfflineStream's average time consuming: ";
1017     g_writeIntoFile << avrg_time << "us. " << std::endl;
1018     g_writeIntoFile.close();
1019 }