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