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 the delayTime of audio playback interface.
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
35 #include "audio_hdi_common.h"
36 #include "audio_hdirender_performace_test.h"
37
38 using namespace std;
39 using namespace testing::ext;
40 using namespace OHOS::Audio;
41
42 namespace {
43 const float COUNT = 1000;
44 const int32_t LOWLATENCY = 10000;
45 const int32_t NORMALLATENCY = 30000;
46 const int32_t HIGHLATENCY = 60000;
47
48 class AudioHdiRenderPerformaceTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 static TestAudioManager *manager;
55 };
56
57 TestAudioManager *AudioHdiRenderPerformaceTest::manager = nullptr;
58
SetUpTestCase(void)59 void AudioHdiRenderPerformaceTest::SetUpTestCase(void)
60 {
61 manager = GetAudioManagerFuncs();
62 ASSERT_NE(nullptr, manager);
63 }
64
TearDownTestCase(void)65 void AudioHdiRenderPerformaceTest::TearDownTestCase(void) {}
66
SetUp(void)67 void AudioHdiRenderPerformaceTest::SetUp(void) {}
68
TearDown(void)69 void AudioHdiRenderPerformaceTest::TearDown(void) {}
70
71 /**
72 * @tc.name AudioManagerGetAllAdapterPerformance_001
73 * @tc.desc tests the performance of AudioManagerGetAllAdapters interface by executing 1000 times,
74 * and calculates the delay time and average of Delay Time.
75 * @tc.type: PERF
76 */
77 HWTEST_F(AudioHdiRenderPerformaceTest, AudioManagerGetAllAdaptersPerformance_001, TestSize.Level1)
78 {
79 int32_t ret = -1;
80 int size = 0;
81 struct PrepareAudioPara audiopara = { .totalTime = 0 };
82
83 audiopara.manager = manager;
84 ASSERT_NE(nullptr, audiopara.manager);
85
86 for (int i = 0; i < COUNT; ++i) {
87 gettimeofday(&audiopara.start, NULL);
88 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
89 gettimeofday(&audiopara.end, NULL);
90 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
91 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
92 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
93 audiopara.totalTime += audiopara.delayTime;
94 }
95 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
96 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
97 }
98
99 /**
100 * @tc.name AudioManagerLoadAdapterPerformance_001
101 * @tc.desc tests the performance of AudioManagerLoadAdapter interface by executing 1000 times,
102 * and calculates the delay time and average of Delay Time.
103 * @tc.type: PERF
104 */
105 HWTEST_F(AudioHdiRenderPerformaceTest, AudioManagerLoadAdapterPerformance_001, TestSize.Level1)
106 {
107 int32_t ret = -1;
108 int size = 0;
109 struct PrepareAudioPara audiopara = { .totalTime = 0 };
110 audiopara.manager = manager;
111 ASSERT_NE(nullptr, audiopara.manager);
112 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
113 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
114 audiopara.desc = &audiopara.descs[0];
115 ASSERT_NE(nullptr, audiopara.desc);
116
117 for (int i = 0; i < COUNT; ++i) {
118 gettimeofday(&audiopara.start, NULL);
119 ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
120 gettimeofday(&audiopara.end, NULL);
121 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
122 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
123 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
124 audiopara.totalTime += audiopara.delayTime;
125 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
126 audiopara.adapter = nullptr;
127 }
128 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
129 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
130 }
131
132 /**
133 * @tc.name AudioManagerUnLoadAdapterPerformance_001
134 * @tc.desc tests the performance of AudioManagerLoadAdapter interface by executing 1000 times,
135 * and calculates the delay time and average of Delay Time.
136 * @tc.type: PERF
137 */
138 HWTEST_F(AudioHdiRenderPerformaceTest, AudioManagerUnLoadAdapterPerformance_001, TestSize.Level1)
139 {
140 int32_t ret = -1;
141 int size = 0;
142 struct PrepareAudioPara audiopara = { .totalTime = 0 };
143 audiopara.manager = manager;
144 ASSERT_NE(nullptr, audiopara.manager);
145 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
146 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
147 audiopara.desc = &audiopara.descs[0];
148 ASSERT_NE(nullptr, audiopara.desc);
149
150 for (int i = 0; i < COUNT; ++i) {
151 ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
152 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
153 gettimeofday(&audiopara.start, NULL);
154 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
155 gettimeofday(&audiopara.end, NULL);
156 audiopara.adapter = nullptr;
157 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
158 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
159 audiopara.totalTime += audiopara.delayTime;
160 }
161 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
162 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
163 }
164
165 /**
166 * @tc.name AudioManagerInitAllPortsPerformance_001
167 * @tc.desc tests the performance of AudioInitAllPorts interface by executing 1000 times,
168 * and calculates the delay time and average of Delay Time.
169 * @tc.type: PERF
170 */
171 HWTEST_F(AudioHdiRenderPerformaceTest, AudioManagerInitAllPortsPerformance_001, TestSize.Level1)
172 {
173 int32_t ret = -1;
174 struct PrepareAudioPara audiopara = {
175 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .totalTime = 0
176 };
177 audiopara.manager = manager;
178 ASSERT_NE(nullptr, audiopara.manager);
179 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
180 &audiopara.adapter, audiopara.audioPort);
181 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
182 for (int i = 0; i < COUNT; ++i) {
183 gettimeofday(&audiopara.start, NULL);
184 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
185 gettimeofday(&audiopara.end, NULL);
186 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
187 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
188 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
189 audiopara.totalTime += audiopara.delayTime;
190 }
191 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
192 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
193 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
194 audiopara.adapter = nullptr;
195 }
196
197 /**
198 * @tc.name AudioGetPortCapabilityPerformance_001
199 * @tc.desc tests the performance of AudioGetPortCapability interface by executing 1000 times,
200 * and calculates the delay time and average of Delay Time.
201 * @tc.type: PERF
202 */
203 HWTEST_F(AudioHdiRenderPerformaceTest, AudioGetPortCapabilityPerformance_001, TestSize.Level1)
204 {
205 int32_t ret = -1;
206 struct PrepareAudioPara audiopara = {
207 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .totalTime = 0
208 };
209 audiopara.manager = manager;
210 ASSERT_NE(nullptr, audiopara.manager);
211 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
212 &audiopara.adapter, audiopara.audioPort);
213 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
214 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
215 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
216 for (int i = 0; i < COUNT; ++i) {
217 gettimeofday(&audiopara.start, NULL);
218 ret = audiopara.adapter->GetPortCapability(audiopara.adapter, audiopara.audioPort, &audiopara.capability);
219 gettimeofday(&audiopara.end, NULL);
220 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
221 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
222 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
223 audiopara.totalTime += audiopara.delayTime;
224 }
225 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
226 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
227 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
228 audiopara.adapter = nullptr;
229 }
230
231 /**
232 * @tc.name AudioSetPassthroughModePerformance_001
233 * @tc.desc tests the performance of AudioSetPassthroughMode interface by executing 1000 times,
234 * and calculates the delay time and average of Delay Time.
235 * @tc.type: PERF
236 */
237 HWTEST_F(AudioHdiRenderPerformaceTest, AudioSetPassthroughModePerformance_001, TestSize.Level1)
238 {
239 int32_t ret = -1;
240 struct PrepareAudioPara audiopara = {
241 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .mode = PORT_PASSTHROUGH_LPCM,
242 .totalTime = 0
243 };
244 audiopara.manager = manager;
245 ASSERT_NE(nullptr, audiopara.manager);
246 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
247 &audiopara.adapter, audiopara.audioPort);
248 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
249 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
250 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
251 for (int i = 0; i < COUNT; ++i) {
252 gettimeofday(&audiopara.start, NULL);
253 ret = audiopara.adapter->SetPassthroughMode(audiopara.adapter, audiopara.audioPort, audiopara.mode);
254 gettimeofday(&audiopara.end, NULL);
255 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
256 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
257 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
258 audiopara.totalTime += audiopara.delayTime;
259 ret = audiopara.adapter->GetPassthroughMode(audiopara.adapter, audiopara.audioPort, &audiopara.mode);
260 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
261 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, audiopara.mode);
262 }
263 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
264 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
265 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
266 audiopara.adapter = nullptr;
267 }
268
269 /**
270 * @tc.name AudioGetPassthroughModePerformance_001
271 * @tc.desc tests the performance of AudioGetPassthroughMode interface by executing 1000 times,
272 * and calculates the delay time and average of Delay Time.
273 * @tc.type: PERF
274 */
275 HWTEST_F(AudioHdiRenderPerformaceTest, AudioGetPassthroughModePerformance_001, TestSize.Level1)
276 {
277 int32_t ret = -1;
278 struct PrepareAudioPara audiopara = {
279 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .mode = PORT_PASSTHROUGH_LPCM,
280 .totalTime = 0
281 };
282 audiopara.manager = manager;
283 ASSERT_NE(nullptr, audiopara.manager);
284 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
285 &audiopara.adapter, audiopara.audioPort);
286 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
287 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
288 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
289 ret = audiopara.adapter->SetPassthroughMode(audiopara.adapter, audiopara.audioPort, audiopara.mode);
290 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
291 for (int i = 0; i < COUNT; ++i) {
292 gettimeofday(&audiopara.start, NULL);
293 ret = audiopara.adapter->GetPassthroughMode(audiopara.adapter, audiopara.audioPort, &audiopara.mode);
294 gettimeofday(&audiopara.end, NULL);
295 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
296 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, audiopara.mode);
297 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
298 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
299 audiopara.totalTime += audiopara.delayTime;
300 }
301 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
302 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
303 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
304 audiopara.adapter = nullptr;
305 }
306
307 /**
308 * @tc.name AudioRenderGetLatencyPerformance_001
309 * @tc.desc tests the performance of AudioRenderGetLatency interface by executing 1000 times,
310 * and calculates the delay time and average of Delay Time.
311 * @tc.type: PERF
312 */
313 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetLatencyPerformance_001, TestSize.Level1)
314 {
315 int32_t ret = -1;
316 struct PrepareAudioPara audiopara = {
317 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
318 .path = AUDIO_FILE.c_str(), .totalTime = 0
319 };
320 uint32_t latencyTimeExpc = 0;
321 uint32_t latencyTime = 0;
322 audiopara.manager = manager;
323 ASSERT_NE(nullptr, audiopara.manager);
324 ret = PlayAudioFile(audiopara);
325 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
326 for (int i = 0; i < COUNT; ++i) {
327 if (audiopara.render != nullptr) {
328 gettimeofday(&audiopara.start, NULL);
329 ret = audiopara.render->GetLatency(audiopara.render, &latencyTime);
330 gettimeofday(&audiopara.end, NULL);
331 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
332 EXPECT_LT(latencyTimeExpc, latencyTime);
333 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
334 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
335 audiopara.totalTime += audiopara.delayTime;
336 }
337 }
338 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
339 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
340 ret = StopAudio(audiopara);
341 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
342 }
343
344 /**
345 * @tc.name AudioCreateRenderPerformance_001
346 * @tc.desc tests the performance of AudioCreateRender interface by executing 1000 times,
347 * and calculates the delay time and average of Delay Time.
348 * @tc.type: PERF
349 */
350 HWTEST_F(AudioHdiRenderPerformaceTest, AudioCreateRenderPerformance_001, TestSize.Level1)
351 {
352 int32_t ret = -1;
353 struct PrepareAudioPara audiopara = {
354 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
355 .totalTime = 0
356 };
357 audiopara.manager = manager;
358 ASSERT_NE(nullptr, audiopara.manager);
359 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
360 &audiopara.adapter, audiopara.audioPort);
361 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
362 InitAttrs(audiopara.attrs);
363 InitDevDesc(audiopara.devDesc, audiopara.audioPort->portId, audiopara.pins);
364
365 for (int i = 0; i < COUNT; ++i) {
366 gettimeofday(&audiopara.start, NULL);
367 ret = audiopara.adapter->CreateRender(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
368 &audiopara.render);
369 gettimeofday(&audiopara.end, NULL);
370 if (ret < 0 || audiopara.render == nullptr) {
371 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
372 audiopara.adapter = nullptr;
373 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
374 }
375 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
376 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
377 audiopara.totalTime += audiopara.delayTime;
378 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
379 }
380 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
381 EXPECT_GT(HIGHLATENCY, audiopara.averageDelayTime);
382 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
383 audiopara.adapter = nullptr;
384 }
385
386 /**
387 * @tc.name AudioDestroyRenderPerformance_001
388 * @tc.desc tests the performance of AudioDestroyRender interface by executing 1000 times,
389 * and calculates the delay time and average of Delay Time.
390 * @tc.type: PERF
391 */
392 HWTEST_F(AudioHdiRenderPerformaceTest, AudioDestroyRenderPerformance_001, TestSize.Level1)
393 {
394 int32_t ret = -1;
395 struct PrepareAudioPara audiopara = {
396 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
397 .totalTime = 0
398 };
399 audiopara.manager = manager;
400 ASSERT_NE(nullptr, audiopara.manager);
401 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
402 &audiopara.adapter, audiopara.audioPort);
403 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
404 InitAttrs(audiopara.attrs);
405 InitDevDesc(audiopara.devDesc, audiopara.audioPort->portId, audiopara.pins);
406 for (int i = 0; i < COUNT; ++i) {
407 ret = audiopara.adapter->CreateRender(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
408 &audiopara.render);
409 if (ret < 0 || audiopara.render == nullptr) {
410 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
411 audiopara.adapter = nullptr;
412 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
413 }
414 gettimeofday(&audiopara.start, NULL);
415 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
416 gettimeofday(&audiopara.end, NULL);
417 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
418 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
419 audiopara.totalTime += audiopara.delayTime;
420 }
421 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
422 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
423 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
424 audiopara.adapter = nullptr;
425 }
426
427 /**
428 * @tc.name AudioRenderGetRenderPositionPerformance_001
429 * @tc.desc tests the performance of AudioRenderGetRenderPosition interface by executing 1000 times,
430 * and calculates the delay time and average of Delay Time.
431 * @tc.type: PERF
432 */
433 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetRenderPositionPerformance_001, TestSize.Level1)
434 {
435 int32_t ret = -1;
436 struct PrepareAudioPara audiopara = {
437 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
438 .path = AUDIO_FILE.c_str(), .totalTime = 0
439 };
440 audiopara.manager = manager;
441 ASSERT_NE(nullptr, audiopara.manager);
442 ret = PlayAudioFile(audiopara);
443 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
444 for (int i = 0; i < COUNT; ++i) {
445 if (audiopara.render != nullptr) {
446 gettimeofday(&audiopara.start, NULL);
447 ret = audiopara.render->GetRenderPosition(audiopara.render, &audiopara.character.getframes,
448 &audiopara.time);
449 gettimeofday(&audiopara.end, NULL);
450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
451 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
452 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
453 audiopara.totalTime += audiopara.delayTime;
454 }
455 }
456 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
457 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
458 ret = StopAudio(audiopara);
459 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
460 }
461
462 /**
463 * @tc.name AudioRenderSetRenderSpeedPerformance_001
464 * @tc.desc tests the performance of AudioRenderSetRenderSpeed interface by executing 1000 times,
465 * and calculates the delay time and average of Delay Time.
466 * @tc.type: PERF
467 */
468 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderSetRenderSpeedPerformance_001, TestSize.Level1)
469 {
470 int32_t ret = -1;
471 float speedNormal = 30;
472 struct PrepareAudioPara audiopara = {
473 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
474 .totalTime = 0
475 };
476 audiopara.manager = manager;
477 ASSERT_NE(nullptr, audiopara.manager);
478 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
479 &audiopara.render);
480 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
481 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
482 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
483
484 for (int i = 0; i < COUNT; ++i) {
485 gettimeofday(&audiopara.start, NULL);
486 ret = audiopara.render->SetRenderSpeed(audiopara.render, speedNormal);
487 gettimeofday(&audiopara.end, NULL);
488 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
489 ret = audiopara.render->GetRenderSpeed(audiopara.render, &speedNormal);
490 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
491 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
492 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
493 audiopara.totalTime += audiopara.delayTime;
494 }
495 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
496 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
497 ret = StopAudio(audiopara);
498 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
499 }
500
501 /**
502 * @tc.name AudioRenderGetRenderSpeedPerformance_001
503 * @tc.desc tests the performance of AudioRenderGetRenderSpeed interface by executing 1000 times,
504 * and calculates the delay time and average of Delay Time.
505 * @tc.type: PERF
506 */
507 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetRenderSpeedPerformance_001, TestSize.Level1)
508 {
509 int32_t ret = -1;
510 float speedValue = 30;
511 struct PrepareAudioPara audiopara = {
512 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
513 .totalTime = 0
514 };
515 audiopara.manager = manager;
516 ASSERT_NE(nullptr, audiopara.manager);
517 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
518 &audiopara.render);
519 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
520 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
521 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
522
523 for (int i = 0; i < COUNT; ++i) {
524 gettimeofday(&audiopara.start, NULL);
525 ret = audiopara.render->GetRenderSpeed(audiopara.render, &speedValue);
526 gettimeofday(&audiopara.end, NULL);
527 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
528 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
529 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
530 audiopara.totalTime += audiopara.delayTime;
531 }
532 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
533 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
534 ret = StopAudio(audiopara);
535 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
536 }
537
538 /**
539 * @tc.name AudioRenderSetChannelModePerformance_001
540 * @tc.desc tests the performance of AudioRenderSetChannelMode interface by executing 1000 times,
541 * and calculates the delay time and average of Delay Time.
542 * @tc.type: PERF
543 */
544 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderSetChannelModePerformance_001, TestSize.Level1)
545 {
546 int32_t ret = -1;
547 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
548 struct PrepareAudioPara audiopara = {
549 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
550 .totalTime = 0
551 };
552 audiopara.manager = manager;
553 ASSERT_NE(nullptr, audiopara.manager);
554 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
555 &audiopara.render);
556 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
557 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
558 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
559 for (int i = 0; i < COUNT; ++i) {
560 gettimeofday(&audiopara.start, NULL);
561 ret = audiopara.render->SetChannelMode(audiopara.render, mode);
562 gettimeofday(&audiopara.end, NULL);
563 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
564 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
565 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
566 audiopara.totalTime += audiopara.delayTime;
567 ret = audiopara.render->GetChannelMode(audiopara.render, &mode);
568 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
569 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
570 }
571 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
572 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
573 ret = StopAudio(audiopara);
574 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
575 }
576
577 /**
578 * @tc.name AudioRenderGetChannelModePerformance_001
579 * @tc.desc tests the performance of AudioRenderGetChannelMode interface by executing 1000 times,
580 * and calculates the delay time and average of Delay Time.
581 * @tc.type: PERF
582 */
583 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetChannelModePerformance_001, TestSize.Level1)
584 {
585 int32_t ret = -1;
586 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
587 struct PrepareAudioPara audiopara = {
588 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
589 .totalTime = 0
590 };
591 audiopara.manager = manager;
592 ASSERT_NE(nullptr, audiopara.manager);
593 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
594 &audiopara.render);
595 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
596 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
597 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
598 ret = audiopara.render->SetChannelMode(audiopara.render, mode);
599 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
600
601 for (int i = 0; i < COUNT; ++i) {
602 gettimeofday(&audiopara.start, NULL);
603 ret = audiopara.render->GetChannelMode(audiopara.render, &mode);
604 gettimeofday(&audiopara.end, NULL);
605 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
606 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
607 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
608 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
609 audiopara.totalTime += audiopara.delayTime;
610 }
611 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
612 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
613 ret = StopAudio(audiopara);
614 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
615 }
616
617 /**
618 * @tc.name AudioRenderGetFrameCountPerformance_001
619 * @tc.desc tests the performance of AudioRenderGetFrameCount interface by executing 1000 times,
620 * and calculates the delay time and average of Delay Time.
621 * @tc.type: PERF
622 */
623 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetFrameCountPerformance_001, TestSize.Level1)
624 {
625 int32_t ret = -1;
626 struct PrepareAudioPara audiopara = {
627 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
628 .totalTime = 0
629 };
630 audiopara.manager = manager;
631 ASSERT_NE(nullptr, audiopara.manager);
632 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
633 &audiopara.render);
634 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
635 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
636 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
637
638 for (int i = 0; i < COUNT; ++i) {
639 gettimeofday(&audiopara.start, NULL);
640 ret = audiopara.render->attr.GetFrameCount(audiopara.render, &audiopara.character.getframecount);
641 gettimeofday(&audiopara.end, NULL);
642 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
643 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
644 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
645 audiopara.totalTime += audiopara.delayTime;
646 }
647 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
648 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
649 ret = StopAudio(audiopara);
650 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
651 }
652
653 /**
654 * @tc.name AudioRenderGetCurrentChannelIdPerformance_001
655 * @tc.desc tests the performance of AudioRenderGetCurrentChannelId interface by executing 1000 times,
656 * and calculates the delay time and average of Delay Time.
657 * @tc.type: PERF
658 */
659 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetCurrentChannelIdPerformance_001, TestSize.Level1)
660 {
661 int32_t ret = -1;
662 struct PrepareAudioPara audiopara = {
663 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
664 .totalTime = 0
665 };
666 audiopara.manager = manager;
667 ASSERT_NE(nullptr, audiopara.manager);
668 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
669 &audiopara.render);
670 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
671
672 for (int i = 0; i < COUNT; ++i) {
673 gettimeofday(&audiopara.start, NULL);
674 ret = audiopara.render->attr.GetCurrentChannelId(audiopara.render, &audiopara.character.getcurrentchannelId);
675 gettimeofday(&audiopara.end, NULL);
676 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
677 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
678 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
679 audiopara.totalTime += audiopara.delayTime;
680 }
681 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
682 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
683 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
684 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
685 audiopara.render = nullptr;
686 audiopara.adapter = nullptr;
687 }
688
689 /**
690 * @tc.name AudioRenderFlushPerformance_001
691 * @tc.desc tests the performance of AudioRenderFlush interface by executing 1000 times,
692 * and calculates the delay time and average of Delay Time.
693 * @tc.type: PERF
694 */
695 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderFlushPerformance_001, TestSize.Level1)
696 {
697 int32_t ret = -1;
698 struct PrepareAudioPara audiopara = {
699 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
700 .totalTime = 0
701 };
702 audiopara.manager = manager;
703 ASSERT_NE(nullptr, audiopara.manager);
704
705 for (int i = 0; i < COUNT; ++i) {
706 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
707 &audiopara.render);
708 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
709 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
710 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
711 gettimeofday(&audiopara.start, NULL);
712 ret = audiopara.render->control.Flush((AudioHandle)audiopara.render);
713 gettimeofday(&audiopara.end, NULL);
714 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
715 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
716 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
717 audiopara.totalTime += audiopara.delayTime;
718 ret = StopAudio(audiopara);
719 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
720 }
721 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
722 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
723 }
724
725 /**
726 * @tc.name AudioRenderGetFrameSizePerformance_001
727 * @tc.desc tests the performance of AudioRenderGetFrameSize interface by executing 1000 times,
728 * and calculates the delay time and average of Delay Time.
729 * @tc.type: PERF
730 */
731 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetFrameSizePerformance_001, TestSize.Level1)
732 {
733 int32_t ret = -1;
734 uint64_t zero = 0;
735 struct PrepareAudioPara audiopara = {
736 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
737 .totalTime = 0
738 };
739 audiopara.manager = manager;
740 ASSERT_NE(nullptr, audiopara.manager);
741 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
742 &audiopara.render);
743 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
744
745 for (int i = 0; i < COUNT; ++i) {
746 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
747 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
748 gettimeofday(&audiopara.start, NULL);
749 ret = audiopara.render->attr.GetFrameSize(audiopara.render, &audiopara.character.getframesize);
750 gettimeofday(&audiopara.end, NULL);
751 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
752 EXPECT_GT(audiopara.character.getframesize, zero);
753 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
754 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
755 audiopara.totalTime += audiopara.delayTime;
756 ret = audiopara.render->control.Stop((AudioHandle)audiopara.render);
757 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
758 }
759 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
760 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
761 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
762 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
763 audiopara.render = nullptr;
764 audiopara.adapter = nullptr;
765 }
766
767
768 /**
769 * @tc.name AudioRenderCheckSceneCapabilityPerformance_001
770 * @tc.desc tests the performance of AudioRenderCheckSceneCapability interface by executing 1000 times,
771 * and calculates the delay time and average of Delay Time.
772 * @tc.type: PERF
773 */
774 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderCheckSceneCapabilityPerformance_001, TestSize.Level1)
775 {
776 int32_t ret = -1;
777 struct PrepareAudioPara audiopara = {
778 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
779 .totalTime = 0
780 };
781 struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER};
782 audiopara.manager = manager;
783 ASSERT_NE(nullptr, audiopara.manager);
784 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
785 &audiopara.render);
786 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
787
788 for (int i = 0; i < COUNT; ++i) {
789 gettimeofday(&audiopara.start, NULL);
790 ret = audiopara.render->scene.CheckSceneCapability(audiopara.render, &scenes, &audiopara.character.supported);
791 gettimeofday(&audiopara.end, NULL);
792 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
793 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
794 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
795 audiopara.totalTime += audiopara.delayTime;
796 }
797 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
798 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
799 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
800 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
801 audiopara.render = nullptr;
802 audiopara.adapter = nullptr;
803 }
804
805 /**
806 * @tc.name AudioRenderSelectScenePerformance_001
807 * @tc.desc tests the performance of AudioRenderSelectScene interface by executing 1000 times,
808 * and calculates the delay time and average of Delay Time.
809 * @tc.type: PERF
810 */
811 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderSelectScenePerformance_001, TestSize.Level1)
812 {
813 int32_t ret = -1;
814 struct PrepareAudioPara audiopara = {
815 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
816 .totalTime = 0
817 };
818 struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER};
819 audiopara.manager = manager;
820 ASSERT_NE(nullptr, audiopara.manager);
821 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
822 &audiopara.render);
823 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
824
825 for (int i = 0; i < COUNT; ++i) {
826 gettimeofday(&audiopara.start, NULL);
827 ret = audiopara.render->scene.SelectScene(audiopara.render, &scenes);
828 gettimeofday(&audiopara.end, NULL);
829 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
830 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
831 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
832 audiopara.totalTime += audiopara.delayTime;
833 }
834 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
835 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
836 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
837 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
838 audiopara.render = nullptr;
839 audiopara.adapter = nullptr;
840 }
841
842 /**
843 * @tc.name AudiorenderSetMutePerformance_001
844 * @tc.desc tests the performance of AudiorenderSetMute interface by executing 1000 times,
845 * and calculates the delay time and average of Delay Time.
846 * @tc.type: PERF
847 */
848 HWTEST_F(AudioHdiRenderPerformaceTest, AudiorenderSetMutePerformance_001, TestSize.Level1)
849 {
850 int32_t ret = -1;
851 struct PrepareAudioPara audiopara = {
852 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
853 .totalTime = 0
854 };
855 audiopara.manager = manager;
856 ASSERT_NE(nullptr, audiopara.manager);
857 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
858 &audiopara.render);
859 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
860 for (int i = 0; i < COUNT; ++i) {
861 gettimeofday(&audiopara.start, NULL);
862 ret = audiopara.render->volume.SetMute(audiopara.render, false);
863 gettimeofday(&audiopara.end, NULL);
864 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
865 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
866 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
867 audiopara.totalTime += audiopara.delayTime;
868 ret = audiopara.render->volume.GetMute(audiopara.render, &audiopara.character.getmute);
869 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
870 EXPECT_FALSE(audiopara.character.getmute);
871 }
872 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
873 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
874 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
875 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
876 audiopara.render = nullptr;
877 audiopara.adapter = nullptr;
878 }
879
880 /**
881 * @tc.name AudiorenderGetMutePerformance_001
882 * @tc.desc tests the performance of AudiorenderGetMute interface by executing 1000 times,
883 * and calculates the delay time and average of Delay Time.
884 * @tc.type: PERF
885 */
886 HWTEST_F(AudioHdiRenderPerformaceTest, AudiorenderGetMutePerformance_001, TestSize.Level1)
887 {
888 int32_t ret = -1;
889 struct PrepareAudioPara audiopara = {
890 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
891 .totalTime = 0
892 };
893 audiopara.manager = manager;
894 ASSERT_NE(nullptr, audiopara.manager);
895 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
896 &audiopara.render);
897 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
898 ret = audiopara.render->volume.SetMute(audiopara.render, false);
899 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
900 for (int i = 0; i < COUNT; ++i) {
901 gettimeofday(&audiopara.start, NULL);
902 ret = audiopara.render->volume.GetMute(audiopara.render, &audiopara.character.getmute);
903 gettimeofday(&audiopara.end, NULL);
904 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
905 EXPECT_FALSE(audiopara.character.getmute);
906 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
907 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
908 audiopara.totalTime += audiopara.delayTime;
909 }
910 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
911 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
912 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
913 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
914 audiopara.render = nullptr;
915 audiopara.adapter = nullptr;
916 }
917
918 /**
919 * @tc.name AudiorenderSetVolumePerformance_001
920 * @tc.desc tests the performance of AudiorenderSetVolume interface by executing 1000 times,
921 * and calculates the delay time and average of Delay Time.
922 * @tc.type: PERF
923 */
924 HWTEST_F(AudioHdiRenderPerformaceTest, AudiorenderSetVolumePerformance_001, TestSize.Level1)
925 {
926 int32_t ret = -1;
927 struct PrepareAudioPara audiopara = {
928 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
929 .character.setvolume = 0.8, .totalTime = 0
930 };
931 audiopara.manager = manager;
932 ASSERT_NE(nullptr, audiopara.manager);
933 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
934 &audiopara.render);
935 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
936
937 for (int i = 0; i < COUNT; ++i) {
938 gettimeofday(&audiopara.start, NULL);
939 ret = audiopara.render->volume.SetVolume(audiopara.render, audiopara.character.setvolume);
940 gettimeofday(&audiopara.end, NULL);
941 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
942 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
943 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
944 audiopara.totalTime += audiopara.delayTime;
945 ret = audiopara.render->volume.GetVolume(audiopara.render, &audiopara.character.getvolume);
946 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
947 EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume);
948 }
949 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
950 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
951 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
952 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
953 audiopara.render = nullptr;
954 audiopara.adapter = nullptr;
955 }
956
957 /**
958 * @tc.name AudiorenderGetVolumePerformance_001
959 * @tc.desc tests the performance of AudiorenderGetVolume interface by executing 1000 times,
960 * and calculates the delay time and average of Delay Time.
961 * @tc.type: PERF
962 */
963 HWTEST_F(AudioHdiRenderPerformaceTest, AudiorenderGetVolumePerformance_001, TestSize.Level1)
964 {
965 int32_t ret = -1;
966 struct PrepareAudioPara audiopara = {
967 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
968 .totalTime = 0
969 };
970 audiopara.manager = manager;
971 ASSERT_NE(nullptr, audiopara.manager);
972 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
973 &audiopara.render);
974 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
975
976 for (int i = 0; i < COUNT; ++i) {
977 gettimeofday(&audiopara.start, NULL);
978 ret = audiopara.render->volume.GetVolume(audiopara.render, &audiopara.character.getvolume);
979 gettimeofday(&audiopara.end, NULL);
980 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
981 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
982 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
983 audiopara.totalTime += audiopara.delayTime;
984 }
985 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
986 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
987 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
988 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
989 audiopara.render = nullptr;
990 audiopara.adapter = nullptr;
991 }
992
993 /**
994 * @tc.name AudiorenderGetGainThresholdPerformance_001
995 * @tc.desc tests the performance of AudiorenderGetGainThreshold interface by executing 1000 times,
996 * and calculates the delay time and average of Delay Time.
997 * @tc.type: PERF
998 */
999 HWTEST_F(AudioHdiRenderPerformaceTest, AudiorenderGetGainThresholdPerformance_001, TestSize.Level1)
1000 {
1001 int32_t ret = -1;
1002 struct PrepareAudioPara audiopara = {
1003 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1004 .totalTime = 0
1005 };
1006 audiopara.manager = manager;
1007 ASSERT_NE(nullptr, audiopara.manager);
1008 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1009 &audiopara.render);
1010 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1011
1012 for (int i = 0; i < COUNT; ++i) {
1013 gettimeofday(&audiopara.start, NULL);
1014 ret = audiopara.render->volume.GetGainThreshold(audiopara.render, &audiopara.character.gainthresholdmin,
1015 &audiopara.character.gainthresholdmax);
1016 gettimeofday(&audiopara.end, NULL);
1017 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1018 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1019 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1020 audiopara.totalTime += audiopara.delayTime;
1021 }
1022 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1023 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1024 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1025 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1026 audiopara.render = nullptr;
1027 audiopara.adapter = nullptr;
1028 }
1029
1030 /**
1031 * @tc.name AudiorenderGetGainPerformance_001
1032 * @tc.desc tests the performance of AudiorenderGetGain interface by executing 1000 times,
1033 * and calculates the delay time and average of Delay Time.
1034 * @tc.type: PERF
1035 */
1036 HWTEST_F(AudioHdiRenderPerformaceTest, AudiorenderGetGainPerformance_001, TestSize.Level1)
1037 {
1038 int32_t ret = -1;
1039 struct PrepareAudioPara audiopara = {
1040 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1041 .totalTime = 0
1042 };
1043 audiopara.manager = manager;
1044 ASSERT_NE(nullptr, audiopara.manager);
1045 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1046 &audiopara.render);
1047 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1048 for (int i = 0; i < COUNT; ++i) {
1049 gettimeofday(&audiopara.start, NULL);
1050 ret = audiopara.render->volume.GetGain(audiopara.render, &audiopara.character.getgain);
1051 gettimeofday(&audiopara.end, NULL);
1052 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1053 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1054 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1055 audiopara.totalTime += audiopara.delayTime;
1056 }
1057 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1058 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1059 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1060 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1061 audiopara.render = nullptr;
1062 audiopara.adapter = nullptr;
1063 }
1064
1065 /**
1066 * @tc.name AudiorenderSetGainPerformance_001
1067 * @tc.desc tests the performance of AudiorenderSetGain interface by executing 1000 times,
1068 * and calculates the delay time and average of Delay Time.
1069 * @tc.type: PERF
1070 */
1071 HWTEST_F(AudioHdiRenderPerformaceTest, AudiorenderSetGainPerformance_001, TestSize.Level1)
1072 {
1073 int32_t ret = -1;
1074 struct PrepareAudioPara audiopara = {
1075 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1076 .character.setgain = 7, .totalTime = 0
1077 };
1078 audiopara.manager = manager;
1079 ASSERT_NE(nullptr, audiopara.manager);
1080 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1081 &audiopara.render);
1082 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1083
1084 for (int i = 0; i < COUNT; ++i) {
1085 gettimeofday(&audiopara.start, NULL);
1086 ret = audiopara.render->volume.SetGain(audiopara.render, audiopara.character.setgain);
1087 gettimeofday(&audiopara.end, NULL);
1088 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1089 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1090 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1091 audiopara.totalTime += audiopara.delayTime;
1092 ret = audiopara.render->volume.GetGain(audiopara.render, &audiopara.character.getgain);
1093 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1094 EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain);
1095 }
1096 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1097 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1098 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1099 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1100 audiopara.render = nullptr;
1101 audiopara.adapter = nullptr;
1102 }
1103
1104 /**
1105 * @tc.name AudioRenderFramePerformance_001
1106 * @tc.desc tests the performance of AudioRenderFrame interface by executing 1000 times,
1107 * and calculates the delay time and average of Delay Time.
1108 * @tc.type: PERF
1109 */
1110 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderFramePerformance_001, TestSize.Level1)
1111 {
1112 int32_t ret = -1;
1113 struct PrepareAudioPara audiopara = {
1114 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1115 .path = AUDIO_FILE.c_str(), .totalTime = 0
1116 };
1117 audiopara.manager = manager;
1118 ASSERT_NE(nullptr, audiopara.manager);
1119 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1120 &audiopara.render);
1121 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1122 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
1123 if (ret < 0) {
1124 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1125 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1126 audiopara.render = nullptr;
1127 audiopara.adapter = nullptr;
1128 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1129 }
1130 ret = RenderFramePrepare(audiopara.path, audiopara.frame, audiopara.requestBytes);
1131 if (ret < 0) {
1132 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1133 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1134 audiopara.render = nullptr;
1135 audiopara.adapter = nullptr;
1136 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1137 }
1138 for (int i = 0; i < COUNT; ++i) {
1139 gettimeofday(&audiopara.start, NULL);
1140 ret = audiopara.render->RenderFrame(audiopara.render, audiopara.frame, audiopara.requestBytes,
1141 &audiopara.replyBytes);
1142 gettimeofday(&audiopara.end, NULL);
1143 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1144 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1145 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1146 audiopara.totalTime += audiopara.delayTime;
1147 }
1148 ret = StopAudio(audiopara);
1149 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1150 if (audiopara.frame != nullptr) {
1151 free(audiopara.frame);
1152 audiopara.frame = nullptr;
1153 }
1154 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1155 EXPECT_GT(NORMALLATENCY, audiopara.averageDelayTime);
1156 }
1157
1158 /**
1159 * @tc.name AudioRenderStartPerformance_001
1160 * @tc.desc tests the performance of AudioRenderStart interface by executing 1000 times,
1161 * and calculates the delay time and average of Delay Time.
1162 * @tc.type: PERF
1163 */
1164 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderStartPerformance_001, TestSize.Level1)
1165 {
1166 int32_t ret = -1;
1167 struct PrepareAudioPara audiopara = {
1168 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1169 .totalTime = 0
1170 };
1171 audiopara.manager = manager;
1172 ASSERT_NE(nullptr, audiopara.manager);
1173
1174 for (int i = 0; i < COUNT; ++i) {
1175 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1176 &audiopara.render);
1177 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1178 gettimeofday(&audiopara.start, NULL);
1179 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
1180 gettimeofday(&audiopara.end, NULL);
1181 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1182 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1183 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1184 audiopara.totalTime += audiopara.delayTime;
1185 ret = StopAudio(audiopara);
1186 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1187 }
1188 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1189 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1190 }
1191 /**
1192 * @tc.name AudioRenderStopPerformance_001
1193 * @tc.desc tests the performance of AudioRenderStop interface by executing 1000 times,
1194 * and calculates the delay time and average of Delay Time.
1195 * @tc.type: PERF
1196 */
1197 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderStopPerformance_001, TestSize.Level1)
1198 {
1199 int32_t ret = -1;
1200 struct PrepareAudioPara audiopara = {
1201 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER, .totalTime = 0
1202 };
1203 audiopara.manager = manager;
1204 ASSERT_NE(nullptr, audiopara.manager);
1205
1206 for (int i = 0; i < COUNT; ++i) {
1207 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1208 &audiopara.render);
1209 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1210 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
1211 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1212 gettimeofday(&audiopara.start, NULL);
1213 ret = audiopara.render->control.Stop((AudioHandle)audiopara.render);
1214 gettimeofday(&audiopara.end, NULL);
1215 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1216 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1217 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1218 audiopara.totalTime += audiopara.delayTime;
1219 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1220 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1221 audiopara.render = nullptr;
1222 audiopara.adapter = nullptr;
1223 }
1224 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1225 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1226 }
1227 /**
1228 * @tc.name AudioRenderSetSampleAttributesPerformance_001
1229 * @tc.desc tests the performance of AudioRenderSetSampleAttributes interface by executing 1000 times,
1230 * and calculates the delay time and average of Delay Time.
1231 * @tc.type: PERF
1232 */
1233 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderSetSampleAttributesPerformance_001, TestSize.Level1)
1234 {
1235 int32_t ret = -1;
1236 struct PrepareAudioPara audiopara = {
1237 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER, .totalTime = 0
1238 };
1239 audiopara.manager = manager;
1240 ASSERT_NE(nullptr, audiopara.manager);
1241 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1242 &audiopara.render);
1243 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1244 InitAttrs(audiopara.attrs);
1245 for (int i = 0; i < COUNT; ++i) {
1246 gettimeofday(&audiopara.start, NULL);
1247 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &audiopara.attrs);
1248 gettimeofday(&audiopara.end, NULL);
1249 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1250 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1251 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1252 audiopara.totalTime += audiopara.delayTime;
1253 }
1254 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1255 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1256 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1257 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1258 audiopara.render = nullptr;
1259 audiopara.adapter = nullptr;
1260 }
1261 /**
1262 * @tc.name AudioRenderPausePerformance_001
1263 * @tc.desc tests the performance of AudioRenderPause interface by executing 1000 times,
1264 * and calculates the delay time and average of Delay Time.
1265 * @tc.type: PERF
1266 */
1267 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderPausePerformance_001, TestSize.Level1)
1268 {
1269 int32_t ret = -1;
1270 struct PrepareAudioPara audiopara = {
1271 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1272 .totalTime = 0
1273 };
1274 audiopara.manager = manager;
1275 ASSERT_NE(nullptr, audiopara.manager);
1276 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1277 &audiopara.render);
1278 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1279 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
1280 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1281 for (int i = 0; i < COUNT; ++i) {
1282 gettimeofday(&audiopara.start, NULL);
1283 ret = audiopara.render->control.Pause((AudioHandle)audiopara.render);
1284 gettimeofday(&audiopara.end, NULL);
1285 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1286 ret = audiopara.render->control.Resume((AudioHandle)audiopara.render);
1287 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1288 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1289 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1290 audiopara.totalTime += audiopara.delayTime;
1291 }
1292 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1293 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1294 ret = StopAudio(audiopara);
1295 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1296 }
1297
1298 /**
1299 * @tc.name AudioRenderResumePerformance_001
1300 * @tc.desc tests the performance of AudioRenderResume interface by executing 1000 times,
1301 * and calculates the delay time and average of Delay Time.
1302 * @tc.type: PERF
1303 */
1304 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderResumePerformance_001, TestSize.Level1)
1305 {
1306 int32_t ret = -1;
1307 struct PrepareAudioPara audiopara = {
1308 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1309 .totalTime = 0
1310 };
1311 audiopara.manager = manager;
1312 ASSERT_NE(nullptr, audiopara.manager);
1313 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1314 &audiopara.render);
1315 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1316 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
1317 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1318 for (int i = 0; i < COUNT; ++i) {
1319 ret = audiopara.render->control.Pause((AudioHandle)audiopara.render);
1320 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1321 gettimeofday(&audiopara.start, NULL);
1322 ret = audiopara.render->control.Resume((AudioHandle)audiopara.render);
1323 gettimeofday(&audiopara.end, NULL);
1324 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1325 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1326 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1327 audiopara.totalTime += audiopara.delayTime;
1328 }
1329 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1330 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1331 ret = StopAudio(audiopara);
1332 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1333 }
1334 /**
1335 * @tc.name AudioRenderGetSampleAttributesPerformance_001
1336 * @tc.desc tests the performance of AudioRenderGetSampleAttributes interface by executing 1000 times,
1337 * and calculates the delay time and average of Delay Time.
1338 * @tc.type: PERF
1339 */
1340 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetSampleAttributesPerformance_001, TestSize.Level1)
1341 {
1342 int32_t ret = -1;
1343 struct PrepareAudioPara audiopara = {
1344 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1345 .totalTime = 0
1346 };
1347 audiopara.manager = manager;
1348 ASSERT_NE(nullptr, audiopara.manager);
1349 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1350 &audiopara.render);
1351 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1352 InitAttrs(audiopara.attrs);
1353
1354 for (int i = 0; i < COUNT; ++i) {
1355 gettimeofday(&audiopara.start, NULL);
1356 ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &audiopara.attrs);
1357 gettimeofday(&audiopara.end, NULL);
1358 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1359 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1360 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1361 audiopara.totalTime += audiopara.delayTime;
1362 }
1363 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1364 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1365 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1366 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1367 audiopara.render = nullptr;
1368 audiopara.adapter = nullptr;
1369 }
1370 /**
1371 * @tc.name AudioRenderReqMmapBufferPerformance_001
1372 * @tc.desc tests the performance of AudioRenderReqMmapBuffer interface by executing 1000 times,
1373 * and calculates the delay time and average of Delay Time.
1374 * @tc.type: PERF
1375 */
1376 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderReqMmapBufferPerformance_001, TestSize.Level1)
1377 {
1378 int32_t ret = -1;
1379 bool isRender = true;
1380 int32_t reqSize = 0;
1381 struct AudioMmapBufferDescripter desc = {};
1382 struct PrepareAudioPara audiopara = {
1383 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER, .totalTime = 0
1384 };
1385 audiopara.manager = manager;
1386 ASSERT_NE(nullptr, audiopara.manager);
1387 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1388 &audiopara.render);
1389 ASSERT_NE(nullptr, audiopara.render);
1390 for (int i = 0; i < COUNT; ++i) {
1391 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1392 if (fp == nullptr) {
1393 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1394 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1395 ASSERT_NE(nullptr, fp);
1396 }
1397 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1398 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1399 ret = audiopara.render->control.Start((AudioHandle)audiopara.render);
1400 gettimeofday(&audiopara.start, NULL);
1401 ret = audiopara.render->attr.ReqMmapBuffer((AudioHandle)audiopara.render, reqSize, &desc);
1402 gettimeofday(&audiopara.end, NULL);
1403 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1404 if (ret == 0) {
1405 munmap(desc.memoryAddress, reqSize);
1406 }
1407 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1408 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1409 audiopara.totalTime += audiopara.delayTime;
1410 audiopara.render->control.Stop((AudioHandle)audiopara.render);
1411 fclose(fp);
1412 usleep(500);
1413 }
1414
1415 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1416 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1417 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1418 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1419 }
1420
1421 /**
1422 * @tc.name AudioRenderGetMmapPositionPerformance_001
1423 * @tc.desc tests the performance of AudioRenderRenderGetMmapPosition interface by executing 1000 times,
1424 * and calculates the delay time and average of Delay Time.
1425 * @tc.type: PERF
1426 */
1427 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetMmapPositionPerformance_001, TestSize.Level1)
1428 {
1429 int32_t ret = -1;
1430 uint64_t framesRendering = 0;
1431 int64_t timeExp = 0;
1432 struct PrepareAudioPara audiopara = {
1433 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1434 .path = LOW_LATENCY_AUDIO_FILE.c_str(), .totalTime = 0
1435 };
1436 audiopara.manager = manager;
1437 ASSERT_NE(nullptr, audiopara.manager);
1438 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1439 &audiopara.render);
1440 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1441
1442 ret = PlayMapAudioFile(audiopara);
1443 if (ret != 0) {
1444 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1445 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1446 audiopara.render = nullptr;
1447 audiopara.adapter = nullptr;
1448 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1449 }
1450 for (int i = 0; i < COUNT; ++i) {
1451 gettimeofday(&audiopara.start, NULL);
1452 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time));
1453 gettimeofday(&audiopara.end, NULL);
1454 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1455 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1456 EXPECT_GT(framesRendering, INITIAL_VALUE);
1457 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1458 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1459 audiopara.totalTime += audiopara.delayTime;
1460 }
1461 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1462 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1463 audiopara.render = nullptr;
1464 audiopara.adapter = nullptr;
1465 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1466 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1467 }
1468
1469 /**
1470 * @tc.name AudioRenderSetExtraParamsPerformance_001
1471 * @tc.desc tests the performance of AudioRenderSetExtraParams interface by executing 1000 times,
1472 * and calculates the delay time and average of Delay Time.
1473 * @tc.type: PERF
1474 */
1475 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderSetExtraParamsPerformance_001, TestSize.Level1)
1476 {
1477 int32_t ret = -1;
1478 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
1479 struct PrepareAudioPara audiopara = {
1480 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1481 };
1482 audiopara.manager = manager;
1483 ASSERT_NE(nullptr, audiopara.manager);
1484 ret = AudioCreateStartRender(audiopara.manager, &audiopara.render, &audiopara.adapter, ADAPTER_NAME);
1485 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1486
1487 for (int i = 0; i < COUNT; ++i) {
1488 gettimeofday(&audiopara.start, NULL);
1489 ret = audiopara.render->attr.SetExtraParams((AudioHandle)audiopara.render, keyValueList);
1490 gettimeofday(&audiopara.end, NULL);
1491 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1492 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1493 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1494 audiopara.totalTime += audiopara.delayTime;
1495 }
1496 ret = StopAudio(audiopara);
1497 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1498 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1499 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1500 }
1501
1502 /**
1503 * @tc.name AudioRenderGetExtraParamsPerformance_001
1504 * @tc.desc tests the performance of AudioRenderGetExtraParams interface by executing 1000 times,
1505 * and calculates the delay time and average of Delay Time.
1506 * @tc.type: PERF
1507 */
1508 HWTEST_F(AudioHdiRenderPerformaceTest, AudioRenderGetExtraParamsPerformance_001, TestSize.Level1)
1509 {
1510 int32_t ret = -1;
1511 struct PrepareAudioPara audiopara = {
1512 .portType = PORT_OUT, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str()
1513 };
1514 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1515 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1516 attr-sampling-rate=48000";
1517 int32_t listLenth = 256;
1518 audiopara.manager = manager;
1519 ASSERT_NE(nullptr, audiopara.manager);
1520
1521 ret = AudioCreateStartRender(audiopara.manager, &audiopara.render, &audiopara.adapter, ADAPTER_NAME);
1522 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1523 ret = audiopara.render->attr.SetExtraParams((AudioHandle)audiopara.render, keyValueList);
1524 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1525
1526 for (int i = 0; i < COUNT; ++i) {
1527 char keyValueListValue[256] = {};
1528 gettimeofday(&audiopara.start, NULL);
1529 ret = audiopara.render->attr.GetExtraParams((AudioHandle)audiopara.render, keyValueListValue, listLenth);
1530 gettimeofday(&audiopara.end, NULL);
1531 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1532 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1533 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1534 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1535 audiopara.totalTime += audiopara.delayTime;
1536 }
1537 ret = StopAudio(audiopara);
1538 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1539 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1540 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1541 }
1542 }
1543