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