1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Test audio recording interface delayTime.
21 *
22 * @since 1.0
23 * @version 1.0
24 */
25
26 /**
27 * @file audio_hdi_common.h
28 *
29 * @brief Declares APIs for operations related to the audio delayTime.
30 *
31 * @since 1.0
32 * @version 1.0
33 */
34 #include <benchmark/benchmark.h>
35 #include <string>
36 #include <vector>
37
38 #include "audio_hdi_common.h"
39 #include "audio_hdicapture_performace_test.h"
40
41 using namespace std;
42 using namespace testing::ext;
43 using namespace OHOS::Audio;
44
45 namespace {
46 const int BUFFER = 1024 * 4;
47 class AudioCaptureBenchmarkTest : public benchmark::Fixture {
48 public:
49 void SetUp(const ::benchmark::State &state);
50 void TearDown(const ::benchmark::State &state);
51 static TestAudioManager *(*GetAudioManager)();
52 static void *handleSo;
53 };
54
55 TestAudioManager *(*AudioCaptureBenchmarkTest::GetAudioManager)() = nullptr;
56 void *AudioCaptureBenchmarkTest::handleSo = nullptr;
57
SetUp(const::benchmark::State & state)58 void AudioCaptureBenchmarkTest::SetUp(const ::benchmark::State &state) {
59 char absPath[PATH_MAX] = {0};
60 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
61 return;
62 }
63 handleSo = dlopen(absPath, RTLD_LAZY);
64 if (handleSo == nullptr) {
65 return;
66 }
67 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
68 if (GetAudioManager == nullptr) {
69 return;
70 }
71 };
72
TearDown(const::benchmark::State & state)73 void AudioCaptureBenchmarkTest::TearDown(const ::benchmark::State &state) {
74 if (handleSo != nullptr) {
75 dlclose(handleSo);
76 handleSo = nullptr;
77 }
78 if (GetAudioManager != nullptr) {
79 GetAudioManager = nullptr;
80 }
81 };
82
83 /**
84 * @tc.name the performace of AudioCreateCapture
85 * @tc.number SUB_DriverSystem_Benchmark_AudioCreateCapture_0001
86 * @tc.devDesc tests the performace of AudioCreateCapture interface by executing 100 times,
87 * and calculates the delay time and average of Delay Time.
88 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCreateCapture_0001)89 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCreateCapture_0001)
90 (benchmark::State &st)
91 {
92 int32_t ret = -1;
93 struct PrepareAudioPara audiopara = {
94 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
95 };
96 ASSERT_NE(nullptr, GetAudioManager);
97 audiopara.manager = GetAudioManager();
98 ASSERT_NE(nullptr, audiopara.manager);
99 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
100 &audiopara.adapter, audiopara.audioPort);
101 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
102 InitAttrs(audiopara.attrs);
103 InitDevDesc(audiopara.devDesc, audiopara.audioPort->portId, audiopara.pins);
104 for (auto _ : st) {
105 ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
106 &audiopara.capture);
107 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
108 audiopara.capture = nullptr;
109 }
110 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
111 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
112 audiopara.adapter = nullptr;
113 }
114 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCreateCapture_0001)->
115 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
116
117 /**
118 * @tc.name the performace of AudioDestroyCapture
119 * @tc.number SUB_DriverSystem_Benchmark_AudioDestroyCapture_0001
120 * @tc.devDesc tests the performace of AudioDestroyCapture interface by executing 100 times,
121 * and calculates the delay time and average of Delay Time.
122 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioDestroyCapture_0001)123 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioDestroyCapture_0001)
124 (benchmark::State &st)
125 {
126 int32_t ret = -1;
127 struct PrepareAudioPara audiopara = {
128 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
129 };
130 ASSERT_NE(nullptr, GetAudioManager);
131 audiopara.manager = GetAudioManager();
132 ASSERT_NE(nullptr, audiopara.manager);
133 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
134 &audiopara.adapter, audiopara.audioPort);
135 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
136 InitAttrs(audiopara.attrs);
137 InitDevDesc(audiopara.devDesc, audiopara.audioPort->portId, audiopara.pins);
138 for (auto _ : st) {
139 ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
140 &audiopara.capture);
141 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
142 audiopara.capture = nullptr;
143 }
144
145 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
146 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
147 audiopara.adapter = nullptr;
148 }
149 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioDestroyCapture_0001)->
150 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
151 /**
152 * @tc.name the performace of AudioCaptureStart
153 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureStart_0001
154 * @tc.devDesc tests the performace of AudioCaptureStart interface by executing 100 times,
155 * and calculates the delay time and average of Delay Time.
156 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureStart_0001)157 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureStart_0001)
158 (benchmark::State &st)
159 {
160 int32_t ret = -1;
161 struct PrepareAudioPara audiopara = {
162 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
163 };
164 ASSERT_NE(nullptr, GetAudioManager);
165 audiopara.manager = GetAudioManager();
166 ASSERT_NE(nullptr, audiopara.manager);
167 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
168 &audiopara.capture);
169 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
170 for (auto _ : st) {
171 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
172 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
173 }
174 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
175 }
176 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureStart_0001)->
177 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
178 /**
179 * @tc.name the performace of AudioCapturePause
180 * @tc.number SUB_DriverSystem_Benchmark_AudioCapturePause_0001
181 * @tc.devDesc tests the performace of AudioCapturePause interface by executing 100 times,
182 * and calculates the delay time and average of Delay Time.
183 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCapturePause_0001)184 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCapturePause_0001)
185 (benchmark::State &st)
186 {
187 int32_t ret = -1;
188 struct PrepareAudioPara audiopara = {
189 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
190 };
191 ASSERT_NE(nullptr, GetAudioManager);
192 audiopara.manager = GetAudioManager();
193 ASSERT_NE(nullptr, audiopara.manager);
194 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
195 &audiopara.capture);
196 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
197 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
198 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
199 for (auto _ : st) {
200 ret = audiopara.capture->control.Pause((AudioHandle)audiopara.capture);
201 audiopara.capture->control.Resume((AudioHandle)audiopara.capture);
202 }
203 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
204 ret = StopAudio(audiopara);
205 }
206 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCapturePause_0001)->
207 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
208
209 /**
210 * @tc.name the performace of AudioCaptureResume
211 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureResume_0001
212 * @tc.devDesc tests the performace of AudioCaptureResume interface by executing 100 times,
213 * and calculates the delay time and average of Delay Time.
214 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureResume_0001)215 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureResume_0001)
216 (benchmark::State &st)
217 {
218 int32_t ret = -1;
219 struct PrepareAudioPara audiopara = {
220 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
221 };
222 ASSERT_NE(nullptr, GetAudioManager);
223 audiopara.manager = GetAudioManager();
224 ASSERT_NE(nullptr, audiopara.manager);
225 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
226 &audiopara.capture);
227 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
228 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
229 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
230 for (auto _ : st) {
231 ret = audiopara.capture->control.Pause((AudioHandle)audiopara.capture);
232 ret = audiopara.capture->control.Resume((AudioHandle)audiopara.capture);
233 }
234 ret = StopAudio(audiopara);
235 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
236 }
237 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureResume_0001)->
238 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
239
240 /**
241 * @tc.name the performace of AudioCaptureStop
242 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureStop_0001
243 * @tc.devDesc tests the performace of AudioCaptureStop interface by executing 100 times,
244 * and calculates the delay time and average of Delay Time.
245 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureStop_0001)246 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureStop_0001)
247 (benchmark::State &st)
248 {
249 int32_t ret = -1;
250 struct PrepareAudioPara audiopara = {
251 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
252 };
253 ASSERT_NE(nullptr, GetAudioManager);
254 audiopara.manager = GetAudioManager();
255 ASSERT_NE(nullptr, audiopara.manager);
256 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
257 &audiopara.capture);
258 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
259 for (auto _ : st) {
260 audiopara.capture->control.Start((AudioHandle)audiopara.capture);
261 ret = audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
262 }
263 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
264 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
265 audiopara.capture = nullptr;
266 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
267 audiopara.adapter = nullptr;
268 }
269 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureStop_0001)->
270 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
271 /**
272 * @tc.name the performace of AudioCaptureSetSampleAttributes
273 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureSetSampleAttributes_0001
274 * @tc.devDesc tests the performace of AudioCaptureSetSampleAttributes interface by executing 100 times,
275 * and calculates the delay time and average of Delay Time.
276 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureSetSampleAttributes_0001)277 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetSampleAttributes_0001)
278 (benchmark::State &st)
279 {
280 int32_t ret = -1;
281 struct PrepareAudioPara audiopara = {
282 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
283 };
284 ASSERT_NE(nullptr, GetAudioManager);
285 audiopara.manager = GetAudioManager();
286 ASSERT_NE(nullptr, audiopara.manager);
287 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
288 &audiopara.capture);
289 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
290 InitAttrs(audiopara.attrs);
291 for (auto _ : st) {
292 ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &audiopara.attrs);
293 }
294 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
295 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
296 audiopara.capture = nullptr;
297 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
298 audiopara.adapter = nullptr;
299 }
300 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetSampleAttributes_0001)->
301 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
302 /**
303 * @tc.name the performace of AudioCaptureCaptureFrame
304 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureCaptureFrame_0001
305 * @tc.devDesc tests the performace of AudioCaptureCaptureFrame interface by executing 100 times,
306 * and calculates the delay time and average of Delay Time.
307 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureCaptureFrame_0001)308 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureCaptureFrame_0001)
309 (benchmark::State &st)
310 {
311 int32_t ret = -1;
312 struct PrepareAudioPara audiopara = {
313 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
314 .requestBytes = BUFFER_LENTH
315 };
316 ASSERT_NE(nullptr, GetAudioManager);
317 audiopara.manager = GetAudioManager();
318 ASSERT_NE(nullptr, audiopara.manager);
319 audiopara.frame = (char *)calloc(1, BUFFER_LENTH);
320 ASSERT_NE(nullptr, audiopara.frame);
321 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName, &(audiopara.adapter),
322 audiopara.audioPort);
323 if (ret < 0 || audiopara.adapter == nullptr) {
324 free(audiopara.frame);
325 audiopara.frame = nullptr;
326 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
327 }
328 InitAttrs(audiopara.attrs);
329 audiopara.attrs.silenceThreshold = BUFFER;
330 InitDevDesc(audiopara.devDesc, audiopara.audioPort->portId, audiopara.pins);
331 ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
332 &audiopara.capture);
333 if (ret < 0) {
334 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
335 free(audiopara.frame);
336 audiopara.frame = nullptr;
337 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
338 }
339 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
340 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
341 for (auto _ : st) {
342 ret = audiopara.capture->CaptureFrame(audiopara.capture, audiopara.frame, audiopara.requestBytes,
343 &audiopara.replyBytes);
344 }
345 ret = audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
346 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
347 free(audiopara.frame);
348 audiopara.frame = nullptr;
349 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
350 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
351 audiopara.capture = nullptr;
352 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
353 audiopara.adapter = nullptr;
354 }
355 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureCaptureFrame_0001)->
356 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
357 /**
358 * @tc.name the performace of AudioCaptureGetSampleAttributes
359 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetSampleAttributes_0001
360 * @tc.devDesc tests the performace of AudioCaptureGetSampleAttributes interface by executing 100 times,
361 * and calculates the delay time and average of Delay Time.
362 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetSampleAttributes_0001)363 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetSampleAttributes_0001)
364 (benchmark::State &st)
365 {
366 int32_t ret = -1;
367 struct PrepareAudioPara audiopara = {
368 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
369 };
370 ASSERT_NE(nullptr, GetAudioManager);
371 audiopara.manager = GetAudioManager();
372 ASSERT_NE(nullptr, audiopara.manager);
373 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
374 &audiopara.capture);
375 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
376 InitAttrs(audiopara.attrs);
377 ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &audiopara.attrs);
378 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
379 for (auto _ : st) {
380 ret = audiopara.capture->attr.GetSampleAttributes(audiopara.capture, &audiopara.attrsValue);
381 }
382 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
383 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
384 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
385 audiopara.capture = nullptr;
386 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
387 audiopara.adapter = nullptr;
388 }
389 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetSampleAttributes_0001)->
390 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
391 /**
392 * @tc.name the performace of AudioCaptureSetMute
393 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureSetMute_0001
394 * @tc.devDesc tests the performace of AudioCaptureSetMute interface by executing 100 times,
395 * and calculates the delay time and average of Delay Time.
396 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureSetMute_0001)397 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetMute_0001)
398 (benchmark::State &st)
399 {
400 int32_t ret = -1;
401 struct PrepareAudioPara audiopara = {
402 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
403 };
404 ASSERT_NE(nullptr, GetAudioManager);
405 audiopara.manager = GetAudioManager();
406 ASSERT_NE(nullptr, audiopara.manager);
407 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
408 &audiopara.capture);
409 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
410 for (auto _ : st) {
411 ret = audiopara.capture->volume.SetMute(audiopara.capture, false);
412 }
413 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
414 ret = audiopara.capture->volume.GetMute(audiopara.capture, &audiopara.character.getmute);
415 EXPECT_FALSE(audiopara.character.getmute);
416
417 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
418 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
419 audiopara.capture = nullptr;
420 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
421 audiopara.adapter = nullptr;
422 }
423 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetMute_0001)->
424 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
425 /**
426 * @tc.name the performace of AudioCaptureGetMute
427 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetMute_0001
428 * @tc.devDesc tests the performace of AudioCaptureGetMute interface by executing 100 times,
429 * and calculates the delay time and average of Delay Time.
430 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetMute_0001)431 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetMute_0001)
432 (benchmark::State &st)
433 {
434 int32_t ret = -1;
435 struct PrepareAudioPara audiopara = {
436 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
437 };
438 ASSERT_NE(nullptr, GetAudioManager);
439 audiopara.manager = GetAudioManager();
440 ASSERT_NE(nullptr, audiopara.manager);
441 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
442 &audiopara.capture);
443 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
444 ret = audiopara.capture->volume.SetMute(audiopara.capture, false);
445 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
446 for (auto _ : st) {
447 ret = audiopara.capture->volume.GetMute(audiopara.capture, &audiopara.character.getmute);
448 }
449 EXPECT_FALSE(audiopara.character.getmute);
450
451 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
452 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
453 audiopara.capture = nullptr;
454 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
455 audiopara.adapter = nullptr;
456 }
457 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetMute_0001)->
458 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
459 /**
460 * @tc.name the performace of AudioCaptureSetVolume
461 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureSetVolume_0001
462 * @tc.devDesc tests the performace of AudioCaptureSetVolume interface by executing 100 times,
463 * and calculates the delay time and average of Delay Time.
464 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureSetVolume_0001)465 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetVolume_0001)
466 (benchmark::State &st)
467 {
468 int32_t ret = -1;
469 struct PrepareAudioPara audiopara = {
470 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
471 .character.setvolume = 0.7
472 };
473 ASSERT_NE(nullptr, GetAudioManager);
474 audiopara.manager = GetAudioManager();
475 ASSERT_NE(nullptr, audiopara.manager);
476 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
477 &audiopara.capture);
478 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
479 for (auto _ : st) {
480 ret = audiopara.capture->volume.SetVolume(audiopara.capture, audiopara.character.setvolume);
481 }
482 ret = audiopara.capture->volume.GetVolume(audiopara.capture, &audiopara.character.getvolume);
483 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
484 EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume);
485 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
486 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
487 audiopara.capture = nullptr;
488 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
489 audiopara.adapter = nullptr;
490 }
491 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetVolume_0001)->
492 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
493
494 /**
495 * @tc.name the performace of AudioCaptureGetVolume
496 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetVolume_0001
497 * @tc.devDesc tests the performace of AudioCaptureGetVolume interface by executing 100 times,
498 * and calculates the delay time and average of Delay Time.
499 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetVolume_0001)500 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetVolume_0001)
501 (benchmark::State &st)
502 {
503 int32_t ret = -1;
504 struct PrepareAudioPara audiopara = {
505 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
506 .character.setvolume = 0.8
507 };
508 ASSERT_NE(nullptr, GetAudioManager);
509 audiopara.manager = GetAudioManager();
510 ASSERT_NE(nullptr, audiopara.manager);
511 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
512 &audiopara.capture);
513 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
514 ret = audiopara.capture->volume.SetVolume(audiopara.capture, audiopara.character.setvolume);
515 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
516 for (auto _ : st) {
517 ret = audiopara.capture->volume.GetVolume(audiopara.capture, &audiopara.character.getvolume);
518 }
519 EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume);
520 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
521 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
522 audiopara.capture = nullptr;
523 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
524 audiopara.adapter = nullptr;
525 }
526 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetVolume_0001)->
527 Iterations(100)-> Repetitions(3)->ReportAggregatesOnly();
528
529 /**
530 * @tc.name the performace of AudioCaptureGetGain
531 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetGain_0001
532 * @tc.devDesc tests the performace of AudioCaptureGetGain interface by executing 100 times,
533 * and calculates the delay time and average of Delay Time.
534 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetGain_0001)535 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetGain_0001)
536 (benchmark::State &st)
537 {
538 int32_t ret = -1;
539 struct PrepareAudioPara audiopara = {
540 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
541 .character.setgain = 7
542 };
543 ASSERT_NE(nullptr, GetAudioManager);
544 audiopara.manager = GetAudioManager();
545 ASSERT_NE(nullptr, audiopara.manager);
546 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
547 &audiopara.capture);
548 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
549 ret = audiopara.capture->volume.SetGain(audiopara.capture, audiopara.character.setgain);
550 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
551 for (auto _ : st) {
552 ret = audiopara.capture->volume.GetGain(audiopara.capture, &audiopara.character.getgain);
553 }
554 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
555 EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain);
556 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
557 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
558 audiopara.capture = nullptr;
559 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
560 audiopara.adapter = nullptr;
561 }
562 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetGain_0001)->
563 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
564 /**
565 * @tc.name the performace of AudioCaptureSetGain
566 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureSetGain_0001
567 * @tc.devDesc tests the performace of AudioCaptureSetGain interface by executing 100 times,
568 * and calculates the delay time and average of Delay Time.
569 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureSetGain_0001)570 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetGain_0001)
571 (benchmark::State &st)
572 {
573 int32_t ret = -1;
574 struct PrepareAudioPara audiopara = {
575 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
576 .character.setgain = 8
577 };
578 ASSERT_NE(nullptr, GetAudioManager);
579 audiopara.manager = GetAudioManager();
580 ASSERT_NE(nullptr, audiopara.manager);
581 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
582 &audiopara.capture);
583 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
584 for (auto _ : st) {
585 ret = audiopara.capture->volume.SetGain(audiopara.capture, audiopara.character.setgain);
586 }
587 ret = audiopara.capture->volume.GetGain(audiopara.capture, &audiopara.character.getgain);
588 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
589 EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain);
590 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
591 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
592 audiopara.capture = nullptr;
593 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
594 audiopara.adapter = nullptr;
595 }
596 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetGain_0001)->
597 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
598 /**
599 * @tc.name the performace of AudioCaptureGetCurrentChannelId
600 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetCurrentChannelId_0001
601 * @tc.devDesc tests the performace of AudioCaptureGetCurrentChannelId interface by executing 100 times,
602 * and calculates the delay time and average of Delay Time.
603 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetCurrentChannelId_0001)604 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetCurrentChannelId_0001)
605 (benchmark::State &st)
606 {
607 int32_t ret = -1;
608 struct PrepareAudioPara audiopara = {
609 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
610 };
611 ASSERT_NE(nullptr, GetAudioManager);
612 audiopara.manager = GetAudioManager();
613 ASSERT_NE(nullptr, audiopara.manager);
614 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
615 &audiopara.capture);
616 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
617 for (auto _ : st) {
618
619 ret = audiopara.capture->attr.GetCurrentChannelId(audiopara.capture, &audiopara.character.getcurrentchannelId);
620 }
621 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);;
622 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
623 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
624 audiopara.capture = nullptr;
625 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
626 audiopara.adapter = nullptr;
627 }
628 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetCurrentChannelId_0001)->
629 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
630 /**
631 * @tc.name the performace of AudioCaptureGetFrameCount
632 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetFrameCount_0001
633 * @tc.devDesc tests the performace of AudioCaptureGetFrameCount interface by executing 100 times,
634 * and calculates the delay time and average of Delay Time.
635 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetFrameCount_0001)636 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetFrameCount_0001)
637 (benchmark::State &st)
638 {
639 int32_t ret = -1;
640 struct PrepareAudioPara audiopara = {
641 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
642 };
643 ASSERT_NE(nullptr, GetAudioManager);
644 audiopara.manager = GetAudioManager();
645 ASSERT_NE(nullptr, audiopara.manager);
646 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
647 &audiopara.capture);
648 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
649 for (auto _ : st) {
650 ret = audiopara.capture->attr.GetFrameCount(audiopara.capture, &audiopara.character.getframecount);
651 }
652 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
653 EXPECT_EQ(INITIAL_VALUE, audiopara.character.getframecount);
654 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
655 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
656 audiopara.capture = nullptr;
657 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
658 audiopara.adapter = nullptr;
659 }
660 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetFrameCount_0001)->
661 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
662 /**
663 * @tc.name the performace of AudioCaptureGetFrameSize
664 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetFrameSize_0001
665 * @tc.devDesc tests the performace of AudioCaptureGetFrameSize interface by executing 100 times,
666 * and calculates the delay time and average of Delay Time.
667 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetFrameSize_0001)668 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetFrameSize_0001)
669 (benchmark::State &st)
670 {
671 int32_t ret = -1;
672 struct PrepareAudioPara audiopara = {
673 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
674 };
675 ASSERT_NE(nullptr, GetAudioManager);
676 audiopara.manager = GetAudioManager();
677 ASSERT_NE(nullptr, audiopara.manager);
678 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
679 &audiopara.capture);
680 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
681 for (auto _ : st) {
682 ret = audiopara.capture->attr.GetFrameSize(audiopara.capture, &audiopara.character.getframesize);
683 }
684 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
685 EXPECT_GT(audiopara.character.getframesize, INITIAL_VALUE);
686 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
687 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
688 audiopara.capture = nullptr;
689 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
690 audiopara.adapter = nullptr;
691 }
692 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetFrameSize_0001)->
693 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
694 /**
695 * @tc.name the performace of AudioCaptureFlush
696 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureFlush_0001
697 * @tc.devDesc tests the performace of AudioCaptureFlush interface by executing 100 times,
698 * and calculates the delay time and average of Delay Time.
699 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureFlush_0001)700 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureFlush_0001)
701 (benchmark::State &st)
702 {
703 int32_t ret = -1;
704 struct PrepareAudioPara audiopara = {
705 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
706 };
707 ASSERT_NE(nullptr, GetAudioManager);
708 audiopara.manager = GetAudioManager();
709 ASSERT_NE(nullptr, audiopara.manager);
710 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
711 &audiopara.capture);
712 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
713 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
714 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
715 for (auto _ : st) {
716 ret = audiopara.capture->control.Flush((AudioHandle)audiopara.capture);
717 }
718 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
719 ret = StopAudio(audiopara);
720 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
721 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
722 audiopara.adapter = nullptr;
723 }
724 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureFlush_0001)->
725 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
726 /**
727 * @tc.name the performace of AudioCaptureGetGainThreshold
728 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetGainThreshold_0001
729 * @tc.devDesc tests the performace of AudioCaptureGetGainThreshold interface by executing 100 times,
730 * and calculates the delay time and average of Delay Time.
731 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetGainThreshold_0001)732 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetGainThreshold_0001)
733 (benchmark::State &st)
734 {
735 int32_t ret = -1;
736 struct PrepareAudioPara audiopara = {
737 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
738 };
739 ASSERT_NE(nullptr, GetAudioManager);
740 audiopara.manager = GetAudioManager();
741 ASSERT_NE(nullptr, audiopara.manager);
742 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
743 &audiopara.capture);
744 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
745 for (auto _ : st) {
746
747 ret = audiopara.capture->volume.GetGainThreshold(audiopara.capture, &audiopara.character.gainthresholdmin,
748 &audiopara.character.gainthresholdmax);
749 }
750 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
751 EXPECT_EQ(audiopara.character.gainthresholdmin, GAIN_MIN);
752 EXPECT_EQ(audiopara.character.gainthresholdmax, GAIN_MAX);
753 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
754 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
755 audiopara.capture = nullptr;
756 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
757 audiopara.adapter = nullptr;
758 }
759 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetGainThreshold_0001)->
760 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
761 /**
762 * @tc.name the performace of AudioCaptureCheckSceneCapability
763 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureCheckSceneCapability_0001
764 * @tc.devDesc tests the performace of AudioCaptureCheckSceneCapability interface by executing 100 times,
765 * and calculates the delay time and average of Delay Time.
766 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureCheckSceneCapability_0001)767 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureCheckSceneCapability_0001)
768 (benchmark::State &st)
769 {
770 int32_t ret = -1;
771 struct PrepareAudioPara audiopara = {
772 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
773 };
774 struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC };
775 bool supported = false;
776 ASSERT_NE(nullptr, GetAudioManager);
777 audiopara.manager = GetAudioManager();
778 ASSERT_NE(nullptr, audiopara.manager);
779 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
780 &audiopara.capture);
781 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
782 for (auto _ : st) {
783 ret = audiopara.capture->scene.CheckSceneCapability(audiopara.capture, &scenes, &supported);
784 }
785 #ifdef AUDIO_HAL_NOTSUPPORT_PATHSELECT
786 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
787 #else
788 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
789 #endif
790 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
791 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
792 audiopara.capture = nullptr;
793 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
794 audiopara.adapter = nullptr;
795 }
796 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureCheckSceneCapability_0001)->
797 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
798 /**
799 * @tc.name the performace of AudioCaptureSelectScene
800 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureSelectScene_0001
801 * @tc.devDesc tests the performace of AudioCaptureSelectScene interface by executing 100 times,
802 * and calculates the delay time and average of Delay Time.
803 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureSelectScene_0001)804 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSelectScene_0001)
805 (benchmark::State &st)
806 {
807 int32_t ret = -1;
808 struct PrepareAudioPara audiopara = {
809 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
810 };
811 struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC };
812 ASSERT_NE(nullptr, GetAudioManager);
813 audiopara.manager = GetAudioManager();
814 ASSERT_NE(nullptr, audiopara.manager);
815 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
816 &audiopara.capture);
817 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
818 for (auto _ : st) {
819 ret = audiopara.capture->scene.SelectScene(audiopara.capture, &scenes);
820 }
821 #ifdef AUDIO_HAL_NOTSUPPORT_PATHSELECT
822 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
823 #else
824 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
825 #endif
826 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
827 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
828 audiopara.capture = nullptr;
829 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
830 audiopara.adapter = nullptr;
831 }
832 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSelectScene_0001)->
833 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
834 /**
835 * @tc.name the performace of AudioGetCapturePosition
836 * @tc.number SUB_DriverSystem_Benchmark_AudioGetCapturePosition_0001
837 * @tc.devDesc tests the performace of AudioCaptureGetCapturePosition interface by executing 100 times,
838 * and calculates the delay time and average of Delay Time.
839 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioGetCapturePosition_0001)840 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioGetCapturePosition_0001)
841 (benchmark::State &st)
842 {
843 int32_t ret = -1;
844 struct PrepareAudioPara audiopara = {
845 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
846 };
847 ASSERT_NE(nullptr, GetAudioManager);
848 audiopara.manager = GetAudioManager();
849 ASSERT_NE(nullptr, audiopara.manager);
850 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
851 &audiopara.capture);
852 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
853 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
854 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
855 for (auto _ : st) {
856 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &audiopara.character.getframes, &audiopara.time);
857 }
858 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
859 ret = StopAudio(audiopara);
860 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
861 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
862 audiopara.adapter = nullptr;
863 }
864 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioGetCapturePosition_0001)->
865 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
866
867 /**
868 * @tc.name the performace of AudioCaptureSetExtraParams
869 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureSetExtraParams_0001
870 * @tc.desc tests the performace of AudioCaptureSetExtraParams interface by executing 100 times,
871 * and calculates the delay time and average of Delay Time.
872 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureSetExtraParams_0001)873 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetExtraParams_0001)
874 (benchmark::State &st)
875 {
876 int32_t ret = -1;
877 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
878 struct PrepareAudioPara audiopara = {
879 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
880 };
881 ASSERT_NE(nullptr, GetAudioManager);
882 audiopara.manager = GetAudioManager();
883 ASSERT_NE(nullptr, audiopara.manager);
884 ret = AudioCreateStartCapture(audiopara.manager, &audiopara.capture, &audiopara.adapter, ADAPTER_NAME);
885 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
886
887 for (auto _ : st) {
888 ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList);
889 }
890 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
891 ret = StopAudio(audiopara);
892 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
893 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
894 audiopara.adapter = nullptr;
895 }
896 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureSetExtraParams_0001)->
897 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
898 /**
899 * @tc.name the performace of AudioCaptureGetExtraParams
900 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetExtraParams_0001
901 * @tc.desc tests the performace of AudioCaptureGetExtraParams interface by executing 100 times,
902 * and calculates the delay time and average of Delay Time.
903 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetExtraParams_0001)904 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetExtraParams_0001)
905 (benchmark::State &st)
906 {
907 int32_t ret = -1;
908 struct PrepareAudioPara audiopara = {
909 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
910 };
911 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
912 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
913 char keyValueListValue[256] = {};
914 int32_t listLenth = 256;
915 ASSERT_NE(nullptr, GetAudioManager);
916 audiopara.manager = GetAudioManager();
917 ASSERT_NE(nullptr, audiopara.manager);
918
919 ret = AudioCreateStartCapture(audiopara.manager, &audiopara.capture, &audiopara.adapter, ADAPTER_NAME);
920 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
921 ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList);
922 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
923
924 for (auto _ : st) {
925 (void)memset_s(&keyValueListValue, sizeof(keyValueListValue), 0, sizeof(keyValueListValue));
926 ret = audiopara.capture->attr.GetExtraParams((AudioHandle)audiopara.capture, keyValueListValue, listLenth);
927 }
928 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
929 EXPECT_STREQ(keyValueListExp, keyValueListValue);
930 ret = StopAudio(audiopara);
931 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
932 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
933 audiopara.adapter = nullptr;
934 }
935 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetExtraParams_0001)->
936 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
937 /**
938 * @tc.name the performace of AudioCaptureGetMmapPosition
939 * @tc.number SUB_DriverSystem_Benchmark_AudioCaptureGetMmapPosition_0001
940 * @tc.desc tests the performace of AudioCaptureGetMmapPosition interface by executing 100 times,
941 * and calculates the delay time and average of Delay Time.
942 */
BENCHMARK_F(AudioCaptureBenchmarkTest,SUB_DriverSystem_Benchmark_AudioCaptureGetMmapPosition_0001)943 BENCHMARK_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetMmapPosition_0001)
944 (benchmark::State &st)
945 {
946 int32_t ret = -1;
947 uint64_t frames = 0;
948 int64_t timeExp = 0;
949 struct PrepareAudioPara audiopara = {
950 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
951 };
952 ASSERT_NE(nullptr, GetAudioManager);
953 audiopara.manager = GetAudioManager();
954 ASSERT_NE(nullptr, audiopara.manager);
955 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
956 &audiopara.capture);
957 if (ret < 0 || audiopara.capture == nullptr) {
958 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
959 ASSERT_EQ(nullptr, audiopara.capture);
960 }
961
962 for (auto _ : st) {
963 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
964 }
965 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
966 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
967 EXPECT_EQ(frames, INITIAL_VALUE);
968 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
969 audiopara.adapter = nullptr;
970 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
971 audiopara.adapter = nullptr;
972 }
973 BENCHMARK_REGISTER_F(AudioCaptureBenchmarkTest, SUB_DriverSystem_Benchmark_AudioCaptureGetMmapPosition_0001)->
974 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
975 }
976 BENCHMARK_MAIN();