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 }