1 /*
2 * Copyright (c) 2022 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 #include <gtest/gtest.h>
17 #include "hdi_service_common.h"
18 #include "osal_mem.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS::Audio;
23
24 namespace {
25 const float COUNT = 1000; // number of interface calls
26 const int32_t LOWLATENCY = 10000; // low interface delay:10ms
27 const int32_t NORMALLATENCY = 30000; // normal interface delay:30ms
28
29 class AudioIdlHdiRenderPerformaceTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 static TestAudioManager *manager;
36 struct IAudioAdapter *adapter = nullptr;
37 struct IAudioRender *render = nullptr;
38 };
39 using THREAD_FUNC = void *(*)(void *);
40 TestAudioManager *AudioIdlHdiRenderPerformaceTest::manager = nullptr;
41
SetUpTestCase(void)42 void AudioIdlHdiRenderPerformaceTest::SetUpTestCase(void)
43 {
44 manager = IAudioManagerGet(IS_STUB);
45 ASSERT_NE(nullptr, manager);
46 }
47
TearDownTestCase(void)48 void AudioIdlHdiRenderPerformaceTest::TearDownTestCase(void)
49 {
50 if (manager != nullptr) {
51 (void)IAudioManagerRelease(manager, IS_STUB);
52 }
53 }
54
SetUp(void)55 void AudioIdlHdiRenderPerformaceTest::SetUp(void)
56 {
57 ASSERT_NE(nullptr, manager);
58 int32_t ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
59 ASSERT_EQ(HDF_SUCCESS, ret);
60 }
61
TearDown(void)62 void AudioIdlHdiRenderPerformaceTest::TearDown(void)
63 {
64 int32_t ret = ReleaseRenderSource(manager, adapter, render);
65 ASSERT_EQ(HDF_SUCCESS, ret);
66 }
67 /**
68 * @tc.name AudioRenderGetLatencyPerformance_001
69 * @tc.desc tests the performace of RenderGetLatency interface by executing 1000 times,
70 * and calculates the delay time and average of Delay Time.
71 * @tc.type: PERF
72 */
73 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetLatencyPerformance_001, TestSize.Level1)
74 {
75 int32_t ret;
76 uint32_t latencyTime = 0;
77 uint32_t expectLatency = 0;
78 struct PrepareAudioPara audiopara = {
79 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
80 };
81 ASSERT_NE(nullptr, audiopara.render);
82 ret = AudioRenderStartAndOneFrame(audiopara.render);
83 EXPECT_EQ(HDF_SUCCESS, ret);
84
85 for (int i = 0; i < COUNT; ++i) {
86 if (audiopara.render != nullptr) {
87 gettimeofday(&audiopara.start, NULL);
88 ret = audiopara.render->GetLatency(audiopara.render, &latencyTime);
89 gettimeofday(&audiopara.end, NULL);
90 EXPECT_EQ(HDF_SUCCESS, ret);
91 EXPECT_LT(expectLatency, latencyTime);
92 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
93 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
94 audiopara.totalTime += audiopara.delayTime;
95 }
96 }
97 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
98 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
99 ret = audiopara.render->Stop(audiopara.render);
100 EXPECT_EQ(HDF_SUCCESS, ret);
101 }
102 /**
103 * @tc.name AudioRenderGetRenderPositionPerformance_001
104 * @tc.desc tests the performace of RenderGetRenderPosition interface by executing 1000 times,
105 * and calculates the delay time and average of Delay Time.
106 * @tc.type: PERF
107 */
108 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetRenderPositionPerformance_001, TestSize.Level1)
109 {
110 int32_t ret;
111 uint64_t frames = 0;
112 int64_t timeExp = 0;
113 struct PrepareAudioPara audiopara = {
114 .render = render, .path = AUDIO_FILE.c_str(), .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
115 };
116 ASSERT_NE(nullptr, audiopara.render);
117 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
118 EXPECT_EQ(HDF_SUCCESS, ret);
119 sleep(1);
120 for (int i = 0; i < COUNT; ++i) {
121 gettimeofday(&audiopara.start, NULL);
122 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &audiopara.time);
123 gettimeofday(&audiopara.end, NULL);
124 EXPECT_EQ(HDF_SUCCESS, ret);
125 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
126 EXPECT_GT(frames, INITIAL_VALUE);
127 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
128 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
129 audiopara.totalTime += audiopara.delayTime;
130 }
131 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
132 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
133 ret = ThreadRelease(audiopara);
134 EXPECT_EQ(HDF_SUCCESS, ret);
135 }
136 /**
137 * @tc.name AudioRenderSetRenderSpeedPerformance_001
138 * @tc.desc tests the performace of RenderSetRenderSpeed interface by executing 1000 times,
139 * and calculates the delay time and average of Delay Time.
140 * @tc.type: PERF
141 */
142 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetRenderSpeedPerformance_001, TestSize.Level1)
143 {
144 struct PrepareAudioPara audiopara = {
145 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
146 };
147 ASSERT_NE(nullptr, audiopara.render);
148 int32_t ret = AudioRenderStartAndOneFrame(audiopara.render);
149 EXPECT_EQ(HDF_SUCCESS, ret);
150
151 for (int i = 0; i < COUNT; ++i) {
152 float speed = 0;
153 gettimeofday(&audiopara.start, NULL);
154 ret = audiopara.render->SetRenderSpeed(audiopara.render, speed);
155 gettimeofday(&audiopara.end, NULL);
156 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
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 ret = audiopara.render->GetRenderSpeed(audiopara.render, &speed);
161 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
162 }
163 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
164 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
165 ret = audiopara.render->Stop(audiopara.render);
166 EXPECT_EQ(HDF_SUCCESS, ret);
167 }
168 /**
169 * @tc.name AudioRenderGetRenderSpeedPerformance_001
170 * @tc.desc tests the performace of RenderGetRenderSpeed interface by executing 1000 times,
171 * and calculates the delay time and average of Delay Time.
172 * @tc.type: PERF
173 */
174 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioAudioRenderGetRenderSpeedPerformance_001, TestSize.Level1)
175 {
176 int32_t ret;
177 struct PrepareAudioPara audiopara = {
178 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
179 };
180 ASSERT_NE(nullptr, audiopara.render);
181 ret = AudioRenderStartAndOneFrame(audiopara.render);
182 EXPECT_EQ(HDF_SUCCESS, ret);
183 for (int i = 0; i < COUNT; ++i) {
184 float speed = 0;
185 gettimeofday(&audiopara.start, NULL);
186 ret = audiopara.render->GetRenderSpeed(audiopara.render, &speed);
187 gettimeofday(&audiopara.end, NULL);
188 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, 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 }
193 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
194 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
195 ret = audiopara.render->Stop(audiopara.render);
196 EXPECT_EQ(HDF_SUCCESS, ret);
197 }
198 /**
199 * @tc.name AudioRenderSetChannelModePerformance_001
200 * @tc.desc tests the performace of RenderSetChannelMode interface by executing 1000 times,
201 * and calculates the delay time and average of Delay Time.
202 * @tc.type: PERF
203 */
204 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetChannelModePerformance_001, TestSize.Level1)
205 {
206 int32_t ret;
207 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
208 struct PrepareAudioPara audiopara = {
209 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
210 };
211 ASSERT_NE(nullptr, audiopara.render);
212
213 for (int i = 0; i < COUNT; ++i) {
214 gettimeofday(&audiopara.start, NULL);
215 ret = audiopara.render->SetChannelMode(audiopara.render, mode);
216 gettimeofday(&audiopara.end, NULL);
217 EXPECT_EQ(HDF_SUCCESS, ret);
218 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
219 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
220 audiopara.totalTime += audiopara.delayTime;
221 ret = audiopara.render->GetChannelMode(audiopara.render, &mode);
222 EXPECT_EQ(HDF_SUCCESS, ret);
223 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
224 }
225 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
226 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
227 }
228 /**
229 * @tc.name AudioRenderGetChannelModePerformance_001
230 * @tc.desc tests the performace of RenderGetChannelMode interface by executing 1000 times,
231 * and calculates the delay time and average of Delay Time.
232 * @tc.type: PERF
233 */
234 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetChannelModePerformance_001, TestSize.Level1)
235 {
236 int32_t ret;
237 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
238 struct PrepareAudioPara audiopara = {
239 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
240 };
241 ASSERT_NE(nullptr, audiopara.render);
242 ret = audiopara.render->SetChannelMode(audiopara.render, mode);
243 EXPECT_EQ(HDF_SUCCESS, ret);
244
245 for (int i = 0; i < COUNT; ++i) {
246 gettimeofday(&audiopara.start, NULL);
247 ret = audiopara.render->GetChannelMode(audiopara.render, &mode);
248 gettimeofday(&audiopara.end, NULL);
249 EXPECT_EQ(HDF_SUCCESS, ret);
250 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
251 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
252 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
253 audiopara.totalTime += audiopara.delayTime;
254 }
255 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
256 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
257 }
258 /**
259 * @tc.name AudioRenderGetFrameCountPerformance_001
260 * @tc.desc tests the performace of RenderGetFrameCount interface by executing 1000 times,
261 * and calculates the delay time and average of Delay Time.
262 * @tc.type: PERF
263 */
264 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetFrameCountPerformance_001, TestSize.Level1)
265 {
266 int32_t ret;
267 uint64_t count = 0;
268 uint64_t zero = 0;
269 struct PrepareAudioPara audiopara = {
270 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
271 };
272 ASSERT_NE(nullptr, audiopara.render);
273 ret = AudioRenderStartAndOneFrame(audiopara.render);
274 EXPECT_EQ(HDF_SUCCESS, ret);
275
276 for (int i = 0; i < COUNT; ++i) {
277 gettimeofday(&audiopara.start, NULL);
278 ret = audiopara.render->GetFrameCount(audiopara.render, &count);
279 gettimeofday(&audiopara.end, NULL);
280 EXPECT_EQ(HDF_SUCCESS, ret);
281 EXPECT_GT(count, zero);
282 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
283 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
284 audiopara.totalTime += audiopara.delayTime;
285 }
286 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
287 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
288 ret = audiopara.render->Stop(audiopara.render);
289 EXPECT_EQ(HDF_SUCCESS, ret);
290 }
291 /**
292 * @tc.name AudioRenderGetCurrentChannelIdPerformance_001
293 * @tc.desc tests the performace of RenderGetCurrentChannelId interface by executing 1000 times,
294 * and calculates the delay time and average of Delay Time.
295 * @tc.type: PERF
296 */
297 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetCurrentChannelIdPerformance_001, TestSize.Level1)
298 {
299 int32_t ret;
300 uint32_t channelId = 0;
301 uint32_t channelIdValue = CHANNELCOUNT;
302 struct PrepareAudioPara audiopara = {
303 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
304 };
305 ASSERT_NE(nullptr, audiopara.render);
306 for (int i = 0; i < COUNT; ++i) {
307 gettimeofday(&audiopara.start, NULL);
308 ret = audiopara.render->GetCurrentChannelId(audiopara.render, &channelId);
309 gettimeofday(&audiopara.end, NULL);
310 EXPECT_EQ(HDF_SUCCESS, ret);
311 EXPECT_EQ(channelIdValue, channelId);
312 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
313 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
314 audiopara.totalTime += audiopara.delayTime;
315 }
316 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
317 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
318 }
319 /**
320 * @tc.name AudioRenderFlushPerformance_001
321 * @tc.desc tests the performace of RenderFlush interface by executing 1000 times,
322 * and calculates the delay time and average of Delay Time.
323 * @tc.type: PERF
324 */
325 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderFlushPerformance_001, TestSize.Level1)
326 {
327 int32_t ret;
328 struct PrepareAudioPara audiopara = {
329 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
330 };
331 ASSERT_NE(nullptr, audiopara.render);
332
333 for (int i = 0; i < COUNT; ++i) {
334 ret = AudioRenderStartAndOneFrame(audiopara.render);
335 EXPECT_EQ(HDF_SUCCESS, ret);
336 gettimeofday(&audiopara.start, NULL);
337 ret = audiopara.render->Flush(audiopara.render);
338 gettimeofday(&audiopara.end, NULL);
339 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
340 ret = audiopara.render->Stop(audiopara.render);
341 EXPECT_EQ(HDF_SUCCESS, ret);
342 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
343 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
344 audiopara.totalTime += audiopara.delayTime;
345 }
346 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
347 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
348 }
349 /**
350 * @tc.name AudioRenderGetFrameSizePerformance_001
351 * @tc.desc tests the performace of RenderGetFrameSize interface by executing 1000 times,
352 * and calculates the delay time and average of Delay Time.
353 * @tc.type: PERF
354 */
355 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetFrameSizePerformance_001, TestSize.Level1)
356 {
357 int32_t ret;
358 uint64_t size = 0;
359 uint64_t zero = 0;
360 struct PrepareAudioPara audiopara = {
361 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
362 };
363 ASSERT_NE(nullptr, audiopara.render);
364
365 for (int i = 0; i < COUNT; ++i) {
366 ret = AudioRenderStartAndOneFrame(audiopara.render);
367 EXPECT_EQ(HDF_SUCCESS, ret);
368 gettimeofday(&audiopara.start, NULL);
369 ret = audiopara.render->GetFrameSize(audiopara.render, &size);
370 gettimeofday(&audiopara.end, NULL);
371 EXPECT_EQ(HDF_SUCCESS, ret);
372 EXPECT_GT(size, zero);
373 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
374 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
375 audiopara.totalTime += audiopara.delayTime;
376 ret = audiopara.render->Stop(audiopara.render);
377 EXPECT_EQ(HDF_SUCCESS, ret);
378 }
379 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
380 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
381 }
382
383 /**
384 * @tc.name AudioRenderCheckSceneCapabilityPerformance_001
385 * @tc.desc tests the performace of RenderCheckSceneCapability interface by executing 1000 times,
386 * and calculates the delay time and average of Delay Time.
387 * @tc.type: PERF
388 */
389 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderCheckSceneCapabilityPerformance_001, TestSize.Level1)
390 {
391 int32_t ret;
392 bool supported = false;
393 struct PrepareAudioPara audiopara = {
394 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
395 };
396 ASSERT_NE(nullptr, audiopara.render);
397 struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER, .desc.desc = strdup("mic") };
398 for (int i = 0; i < COUNT; ++i) {
399 gettimeofday(&audiopara.start, NULL);
400 ret = audiopara.render->CheckSceneCapability(audiopara.render, &scenes, &supported);
401 gettimeofday(&audiopara.end, NULL);
402 EXPECT_EQ(HDF_SUCCESS, ret);
403 EXPECT_TRUE(supported);
404 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
405 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
406 audiopara.totalTime += audiopara.delayTime;
407 }
408 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
409 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
410 }
411 /**
412 * @tc.name AudioRenderSelectScenePerformance_001
413 * @tc.desc tests the performace of RenderSelectScene interface by executing 1000 times,
414 * and calculates the delay time and average of Delay Time.
415 * @tc.type: PERF
416 */
417 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSelectScenePerformance_001, TestSize.Level1)
418 {
419 int32_t ret;
420 struct PrepareAudioPara audiopara = {
421 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
422 };
423 ASSERT_NE(nullptr, audiopara.render);
424 struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER, .desc.desc = strdup("mic") };
425
426 for (int i = 0; i < COUNT; ++i) {
427 gettimeofday(&audiopara.start, NULL);
428 ret = audiopara.render->SelectScene(audiopara.render, &scenes);
429 gettimeofday(&audiopara.end, NULL);
430 EXPECT_EQ(HDF_SUCCESS, ret);
431 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
432 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
433 audiopara.totalTime += audiopara.delayTime;
434 ret = AudioRenderStartAndOneFrame(audiopara.render);
435 EXPECT_EQ(HDF_SUCCESS, ret);
436 ret = audiopara.render->Stop(audiopara.render);
437 EXPECT_EQ(HDF_SUCCESS, ret);
438 }
439 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
440 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
441 }
442 /**
443 * @tc.name AudiorenderSetMutePerformance_001
444 * @tc.desc tests the performace of renderSetMute interface by executing 1000 times,
445 * and calculates the delay time and average of Delay Time.
446 * @tc.type: PERF
447 */
448 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderSetMutePerformance_001, TestSize.Level1)
449 {
450 int32_t ret;
451 bool muteFalse = false;
452 struct PrepareAudioPara audiopara = {
453 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
454 };
455 ASSERT_NE(nullptr, audiopara.render);
456
457 for (int i = 0; i < COUNT; ++i) {
458 gettimeofday(&audiopara.start, NULL);
459 ret = audiopara.render->SetMute(audiopara.render, muteFalse);
460 gettimeofday(&audiopara.end, NULL);
461 EXPECT_EQ(HDF_SUCCESS, ret);
462 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
463 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
464 audiopara.totalTime += audiopara.delayTime;
465 ret = audiopara.render->GetMute(audiopara.render, &muteFalse);
466 EXPECT_EQ(HDF_SUCCESS, ret);
467 EXPECT_EQ(false, muteFalse);
468 }
469 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
470 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
471 }
472 /**
473 * @tc.name AudioenderGetMutePerformance_001
474 * @tc.desc tests the performace of renderGetMute interface by executing 1000 times,
475 * and calculates the delay time and average of Delay Time.
476 * @tc.type: PERF
477 */
478 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetMutePerformance_001, TestSize.Level1)
479 {
480 int32_t ret;
481 bool muteFalse = false;
482 struct PrepareAudioPara audiopara = {
483 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
484 };
485 ASSERT_NE(nullptr, audiopara.render);
486 ret = audiopara.render->SetMute(audiopara.render, muteFalse);
487 EXPECT_EQ(HDF_SUCCESS, ret);
488
489 for (int i = 0; i < COUNT; ++i) {
490 gettimeofday(&audiopara.start, NULL);
491 ret = audiopara.render->GetMute(audiopara.render, &muteFalse);
492 gettimeofday(&audiopara.end, NULL);
493 EXPECT_EQ(HDF_SUCCESS, ret);
494 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
495 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
496 audiopara.totalTime += audiopara.delayTime;
497 }
498 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
499 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
500 }
501 /**
502 * @tc.name AudiorenderSetVolumePerformance_001
503 * @tc.desc tests the performace of renderSetVolume interface by executing 1000 times,
504 * and calculates the delay time and average of Delay Time.
505 * @tc.type: PERF
506 */
507 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderSetVolumePerformance_001, TestSize.Level1)
508 {
509 int32_t ret;
510 float volume = 0.80;
511 float volumeExpc = 0.80;
512 struct PrepareAudioPara audiopara = {
513 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
514 };
515 ASSERT_NE(nullptr, audiopara.render);
516
517 for (int i = 0; i < COUNT; ++i) {
518 gettimeofday(&audiopara.start, NULL);
519 ret = audiopara.render->SetVolume(audiopara.render, volume);
520 gettimeofday(&audiopara.end, NULL);
521 EXPECT_EQ(HDF_SUCCESS, ret);
522 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
523 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
524 audiopara.totalTime += audiopara.delayTime;
525 ret = audiopara.render->GetVolume(audiopara.render, &volume);
526 EXPECT_EQ(HDF_SUCCESS, ret);
527 EXPECT_EQ(volumeExpc, volume);
528 }
529 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
530 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
531 }
532 /**
533 * @tc.name AudiorenderGetVolumePerformance_001
534 * @tc.desc tests the performace of renderGetVolume interface by executing 1000 times,
535 * and calculates the delay time and average of Delay Time.
536 * @tc.type: PERF
537 */
538 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetVolumePerformance_001, TestSize.Level1)
539 {
540 int32_t ret;
541 float volume = 0.30;
542 float volumeDefault = 0.30;
543 struct PrepareAudioPara audiopara = {
544 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
545 };
546 ASSERT_NE(nullptr, audiopara.render);
547 ret = audiopara.render->SetVolume(audiopara.render, volume);
548 EXPECT_EQ(HDF_SUCCESS, ret);
549
550 for (int i = 0; i < COUNT; ++i) {
551 gettimeofday(&audiopara.start, NULL);
552 ret = audiopara.render->GetVolume(audiopara.render, &volume);
553 gettimeofday(&audiopara.end, NULL);
554 EXPECT_EQ(HDF_SUCCESS, ret);
555 EXPECT_EQ(volumeDefault, volume);
556 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
557 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
558 audiopara.totalTime += audiopara.delayTime;
559 }
560 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
561 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
562 }
563 /**
564 * @tc.name AudiorenderGetGainThresholdPerformance_001
565 * @tc.desc tests the performace of renderGetGainThreshold interface by executing 1000 times,
566 * and calculates the delay time and average of Delay Time.
567 * @tc.type: PERF
568 */
569 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetGainThresholdPerformance_001, TestSize.Level1)
570 {
571 int32_t ret;
572 float min = 0;
573 float max = 0;
574 struct PrepareAudioPara audiopara = {
575 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
576 };
577 ASSERT_NE(nullptr, audiopara.render);
578
579 for (int i = 0; i < COUNT; ++i) {
580 gettimeofday(&audiopara.start, NULL);
581 ret = audiopara.render->GetGainThreshold(audiopara.render, &min, &max);
582 gettimeofday(&audiopara.end, NULL);
583 EXPECT_EQ(HDF_SUCCESS, ret);
584 EXPECT_EQ(min, GAIN_MIN);
585 EXPECT_EQ(max, GAIN_MAX);
586 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
587 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
588 audiopara.totalTime += audiopara.delayTime;
589 }
590 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
591 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
592 }
593 /**
594 * @tc.name AudiorenderSetGainPerformance_001
595 * @tc.desc tests the performace of renderSetGain interface by executing 1000 times,
596 * and calculates the delay time and average of Delay Time.
597 * @tc.type: PERF
598 */
599 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderSetGainPerformance_001, TestSize.Level1)
600 {
601 int32_t ret;
602 float gain = 10;
603 float gainExpc = 10;
604 struct PrepareAudioPara audiopara = {
605 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
606 };
607 ASSERT_NE(nullptr, audiopara.render);
608
609 for (int i = 0; i < COUNT; ++i) {
610 gettimeofday(&audiopara.start, NULL);
611 ret = audiopara.render->SetGain(audiopara.render, gain);
612 gettimeofday(&audiopara.end, NULL);
613 EXPECT_EQ(HDF_SUCCESS, ret);
614 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
615 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
616 audiopara.totalTime += audiopara.delayTime;
617 ret = audiopara.render->GetGain(audiopara.render, &gain);
618 EXPECT_EQ(HDF_SUCCESS, ret);
619 EXPECT_EQ(gainExpc, gain);
620 }
621 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
622 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
623 }
624 /**
625 * @tc.name AudiorenderGetGainPerformance_001
626 * @tc.desc tests the performace of renderGetGain interface by executing 1000 times,
627 * and calculates the delay time and average of Delay Time.
628 * @tc.type: PERF
629 */
630 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetGainPerformance_001, TestSize.Level1)
631 {
632 int32_t ret;
633 float min = 0;
634 float max = 0;
635 struct PrepareAudioPara audiopara = {
636 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
637 };
638 ASSERT_NE(nullptr, audiopara.render);
639 ret = audiopara.render->GetGainThreshold(audiopara.render, &min, &max);
640 EXPECT_EQ(HDF_SUCCESS, ret);
641 float gain = min + 1;
642 float gainValue = min + 1;
643
644 for (int i = 0; i < COUNT; ++i) {
645 ret = audiopara.render->SetGain(audiopara.render, gain);
646 EXPECT_EQ(HDF_SUCCESS, ret);
647 gettimeofday(&audiopara.start, NULL);
648 ret = audiopara.render->GetGain(audiopara.render, &gain);
649 gettimeofday(&audiopara.end, NULL);
650 EXPECT_EQ(HDF_SUCCESS, ret);
651 EXPECT_EQ(gainValue, gain);
652 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
653 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
654 audiopara.totalTime += audiopara.delayTime;
655 }
656 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
657 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
658 }
659 /**
660 * @tc.name AudioRenderFramePerformance_001
661 * @tc.desc tests the performace of RenderFrame interface by executing 1000 times,
662 * and calculates the delay time and average of Delay Time.
663 * @tc.type: PERF
664 */
665 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderFramePerformance_001, TestSize.Level1)
666 {
667 int32_t ret;
668 uint64_t requestBytes = 0;
669 uint64_t replyBytes = 0;
670 struct PrepareAudioPara audiopara = {
671 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
672 };
673 ASSERT_NE(nullptr, audiopara.render);
674 ret = audiopara.render->Start(audiopara.render);
675 EXPECT_EQ(HDF_SUCCESS, ret);
676 ret = RenderFramePrepare(AUDIO_FILE, audiopara.frame, requestBytes);
677 EXPECT_EQ(HDF_SUCCESS, ret);
678
679 for (int i = 0; i < COUNT; ++i) {
680 gettimeofday(&audiopara.start, NULL);
681 ret = audiopara.render->RenderFrame(audiopara.render, (int8_t *)audiopara.frame, requestBytes,
682 &replyBytes);
683 gettimeofday(&audiopara.end, NULL);
684 EXPECT_EQ(HDF_SUCCESS, ret);
685 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
686 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
687 audiopara.totalTime += audiopara.delayTime;
688 }
689 audiopara.render->Stop(audiopara.render);
690 EXPECT_EQ(HDF_SUCCESS, ret);
691 if (audiopara.frame != nullptr) {
692 free(audiopara.frame);
693 audiopara.frame = nullptr;
694 }
695 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
696 EXPECT_GT(NORMALLATENCY, audiopara.averageDelayTime);
697 }
698 /**
699 * @tc.name AudioRenderStartPerformance_001
700 * @tc.desc tests the performace of RenderStart interface by executing 1000 times,
701 * and calculates the delay time and average of Delay Time.
702 * @tc.type: PERF
703 */
704 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderStartPerformance_001, TestSize.Level1)
705 {
706 int32_t ret;
707 struct PrepareAudioPara audiopara = {
708 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
709 };
710 ASSERT_NE(nullptr, audiopara.render);
711
712 for (int i = 0; i < COUNT; ++i) {
713 gettimeofday(&audiopara.start, NULL);
714 ret = audiopara.render->Start(audiopara.render);
715 gettimeofday(&audiopara.end, NULL);
716 EXPECT_EQ(HDF_SUCCESS, ret);
717 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
718 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
719 audiopara.totalTime += audiopara.delayTime;
720 ret = audiopara.render->Stop(audiopara.render);
721 EXPECT_EQ(HDF_SUCCESS, ret);
722 }
723 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
724 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
725 }
726 /**
727 * @tc.name AudioRenderStopPerformance_001
728 * @tc.desc tests the performace of RenderStop interface by executing 1000 times,
729 * and calculates the delay time and average of Delay Time.
730 * @tc.type: PERF
731 */
732 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderStopPerformance_001, TestSize.Level1)
733 {
734 int32_t ret;
735 struct PrepareAudioPara audiopara = {
736 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
737 };
738 ASSERT_NE(nullptr, audiopara.render);
739
740 for (int i = 0; i < COUNT; ++i) {
741 ret = audiopara.render->Start(audiopara.render);
742 EXPECT_EQ(HDF_SUCCESS, ret);
743 gettimeofday(&audiopara.start, NULL);
744 ret = audiopara.render->Stop(audiopara.render);
745 gettimeofday(&audiopara.end, NULL);
746 EXPECT_EQ(HDF_SUCCESS, ret);
747 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
748 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
749 audiopara.totalTime += audiopara.delayTime;
750 }
751 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
752 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
753 }
754 /**
755 * @tc.name AudioRenderPausePerformance_001
756 * @tc.desc tests the performace of RenderPause interface by executing 1000 times,
757 * and calculates the delay time and average of Delay Time.
758 * @tc.type: PERF
759 */
760 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderPausePerformance_001, TestSize.Level1)
761 {
762 int32_t ret;
763 struct PrepareAudioPara audiopara = {
764 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
765 };
766 ASSERT_NE(nullptr, audiopara.render);
767 ret = AudioRenderStartAndOneFrame(audiopara.render);
768 EXPECT_EQ(HDF_SUCCESS, ret);
769
770 for (int i = 0; i < COUNT; ++i) {
771 gettimeofday(&audiopara.start, NULL);
772 ret = audiopara.render->Pause(audiopara.render);
773 gettimeofday(&audiopara.end, NULL);
774 EXPECT_EQ(HDF_SUCCESS, ret);
775 ret = audiopara.render->Resume(audiopara.render);
776 EXPECT_EQ(HDF_SUCCESS, ret);
777 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
778 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
779 audiopara.totalTime += audiopara.delayTime;
780 }
781 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
782 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
783 ret = audiopara.render->Stop(audiopara.render);
784 EXPECT_EQ(HDF_SUCCESS, ret);
785 }
786 /**
787 * @tc.name AudioAudioRenderResumePerformance_001
788 * @tc.desc tests the performace of AudioRenderResume interface by executing 1000 times,
789 * and calculates the delay time and average of Delay Time.
790 * @tc.type: PERF
791 */
792 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioAudioRenderResumePerformance_001, TestSize.Level1)
793 {
794 int32_t ret;
795 struct PrepareAudioPara audiopara = {
796 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
797 };
798 ASSERT_NE(nullptr, audiopara.render);
799 ret = AudioRenderStartAndOneFrame(audiopara.render);
800 EXPECT_EQ(HDF_SUCCESS, ret);
801
802 for (int i = 0; i < COUNT; ++i) {
803 ret = audiopara.render->Pause(audiopara.render);
804 EXPECT_EQ(HDF_SUCCESS, ret);
805 gettimeofday(&audiopara.start, NULL);
806 ret = audiopara.render->Resume(audiopara.render);
807 gettimeofday(&audiopara.end, NULL);
808 EXPECT_EQ(HDF_SUCCESS, ret);
809 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
810 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
811 audiopara.totalTime += audiopara.delayTime;
812 }
813 ret = audiopara.render->Stop(audiopara.render);
814 EXPECT_EQ(HDF_SUCCESS, ret);
815 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
816 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
817 }
818 /**
819 * @tc.name AudioRenderSetSampleAttributesPerformance_001
820 * @tc.desc tests the performace of RenderSetSampleAttributes interface by executing 1000 times,
821 * and calculates the delay time and average of Delay Time.
822 * @tc.type: PERF
823 */
824 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetSampleAttributesPerformance_001, TestSize.Level1)
825 {
826 int32_t ret;
827 uint32_t expChannelCount = 2;
828 uint32_t expSampleRate = 8000;
829 struct PrepareAudioPara audiopara = {
830 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
831 };
832 ASSERT_NE(nullptr, audiopara.render);
833 InitAttrsUpdate(audiopara.attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 8000);
834
835 for (int i = 0; i < COUNT; ++i) {
836 gettimeofday(&audiopara.start, NULL);
837 ret = audiopara.render->SetSampleAttributes(audiopara.render, &audiopara.attrs);
838 gettimeofday(&audiopara.end, NULL);
839 EXPECT_EQ(HDF_SUCCESS, ret);
840 ret = audiopara.render->GetSampleAttributes(audiopara.render, &audiopara.attrsValue);
841 EXPECT_EQ(HDF_SUCCESS, ret);
842 EXPECT_EQ(AUDIO_IN_MEDIA, audiopara.attrsValue.type);
843 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, audiopara.attrsValue.format);
844 EXPECT_EQ(expSampleRate, audiopara.attrsValue.sampleRate);
845 EXPECT_EQ(expChannelCount, audiopara.attrsValue.channelCount);
846 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
847 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
848 audiopara.totalTime += audiopara.delayTime;
849 }
850 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
851 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
852 }
853 /**
854 * @tc.name AudioRenderGetSampleAttributesPerformance_001
855 * @tc.desc tests the performace of RenderGetSampleAttributes interface by executing 1000 times,
856 * and calculates the delay time and average of Delay Time.
857 * @tc.type: PERF
858 */
859 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetSampleAttributesPerformance_001, TestSize.Level1)
860 {
861 int32_t ret;
862 uint32_t expChannelCount = 2;
863 uint32_t expSampleRate = 8000;
864 struct PrepareAudioPara audiopara = {
865 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
866 };
867 ASSERT_NE(nullptr, audiopara.render);
868 InitAttrsUpdate(audiopara.attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000);
869
870 for (int i = 0; i < COUNT; ++i) {
871 ret = audiopara.render->SetSampleAttributes(audiopara.render, &audiopara.attrs);
872 EXPECT_EQ(HDF_SUCCESS, ret);
873 gettimeofday(&audiopara.start, NULL);
874 ret = audiopara.render->GetSampleAttributes(audiopara.render, &audiopara.attrsValue);
875 gettimeofday(&audiopara.end, NULL);
876 EXPECT_EQ(HDF_SUCCESS, ret);
877 EXPECT_EQ(AUDIO_IN_MEDIA, audiopara.attrsValue.type);
878 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, audiopara.attrsValue.format);
879 EXPECT_EQ(expSampleRate, audiopara.attrsValue.sampleRate);
880 EXPECT_EQ(expChannelCount, audiopara.attrsValue.channelCount);
881 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
882 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
883 audiopara.totalTime += audiopara.delayTime;
884 }
885 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
886 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
887 }
888 /**
889 * @tc.name AudioRenderReqMmapBufferPerformance_001
890 * @tc.desc tests the performace of RenderReqMmapBuffer interface by executing 1000 times,
891 * and calculates the delay time and average of Delay Time.
892 * @tc.type: PERF
893 */
894 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderReqMmapBufferPerformance_001, TestSize.Level1)
895 {
896 int32_t ret;
897 bool isRender = true;
898 int32_t reqSize = 0;
899 struct AudioMmapBufferDescripter desc = {};
900 struct PrepareAudioPara audiopara = {
901 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
902 };
903 ASSERT_NE(nullptr, audiopara.render);
904
905 for (int i = 0; i < COUNT; ++i) {
906 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
907 EXPECT_EQ(HDF_SUCCESS, ret);
908 ret = audiopara.render->Start(audiopara.render);
909 EXPECT_EQ(HDF_SUCCESS, ret);
910 gettimeofday(&audiopara.start, NULL);
911 ret = audiopara.render->ReqMmapBuffer(audiopara.render, reqSize, &desc);
912 gettimeofday(&audiopara.end, NULL);
913 EXPECT_EQ(HDF_SUCCESS, ret);
914 if (ret == 0) {
915 munmap(desc.memoryAddress, reqSize);
916 }
917 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
918 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
919 audiopara.totalTime += audiopara.delayTime;
920 ret = audiopara.render->Stop(audiopara.render);
921 EXPECT_EQ(HDF_SUCCESS, ret);
922 free(desc.filePath);
923 usleep(500);
924 }
925 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
926 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
927 }
928 /**
929 * @tc.name AudioRenderGetMmapPositionPerformance_001
930 * @tc.desc tests the performace of RenderRenderGetMmapPosition interface by executing 1000 times,
931 * and calculates the delay time and average of Delay Time.
932 * @tc.type: PERF
933 */
934 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetMmapPositionPerformance_001, TestSize.Level1)
935 {
936 int32_t ret;
937 uint64_t framesRendering = 0;
938 int64_t timeExp = 0;
939 struct PrepareAudioPara audiopara = {
940 .render = render, .path = LOW_LATENCY_AUDIO_FILE.c_str(), .delayTime = 0,
941 .totalTime = 0, .averageDelayTime =0,
942 };
943 ASSERT_NE(nullptr, audiopara.render);
944
945 ret = PlayMapAudioFile(audiopara);
946 ASSERT_EQ(HDF_SUCCESS, ret);
947 for (int i = 0; i < COUNT; ++i) {
948 gettimeofday(&audiopara.start, NULL);
949 ret = audiopara.render->GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time));
950 gettimeofday(&audiopara.end, NULL);
951 EXPECT_EQ(HDF_SUCCESS, ret);
952 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
953 EXPECT_GT(framesRendering, INITIAL_VALUE);
954 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
955 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
956 audiopara.totalTime += audiopara.delayTime;
957 }
958 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
959 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
960 ret = audiopara.render->Stop(audiopara.render);
961 EXPECT_EQ(HDF_SUCCESS, ret);
962 }
963 /**
964 * @tc.name AudioRenderSetExtraParamsPerformance_001
965 * @tc.desc tests the performace of RenderSetExtraParams interface by executing 1000 times,
966 * and calculates the delay time and average of Delay Time.
967 * @tc.type: PERF
968 */
969 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetExtraParamsPerformance_001, TestSize.Level1)
970 {
971 int32_t ret;
972 const char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;\
973 attr-sampling-rate=48000";
974 const char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
975 size_t index = 1;
976 int32_t listLenth = 256;
977 struct PrepareAudioPara audiopara = {
978 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
979 };
980 ASSERT_NE(nullptr, audiopara.render);
981 for (int i = 0; i < COUNT; ++i) {
982 gettimeofday(&audiopara.start, NULL);
983 ret = audiopara.render->SetExtraParams(audiopara.render, keyValueList);
984 gettimeofday(&audiopara.end, NULL);
985 EXPECT_EQ(HDF_SUCCESS, ret);
986 usleep(10000);
987 char keyValueListValue[256] = {0};
988 ret = audiopara.render->GetExtraParams(audiopara.render, keyValueListValue, listLenth);
989 EXPECT_EQ(HDF_SUCCESS, ret);
990 string strGetValue = keyValueListValue;
991 size_t indexAttr = strGetValue.find("attr-frame-count");
992 size_t indexFlag = strGetValue.rfind(";");
993 if (indexAttr != string::npos && indexFlag != string::npos) {
994 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
995 }
996 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
997 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
998 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
999 audiopara.totalTime += audiopara.delayTime;
1000 }
1001 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1002 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1003 }
1004 /**
1005 * @tc.name AudioRenderGetExtraParamsPerformance_001
1006 * @tc.desc tests the performace of RenderGetExtraParams interface by executing 1000 times,
1007 * and calculates the delay time and average of Delay Time.
1008 * @tc.type: PERF
1009 */
1010 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetExtraParamsPerformance_001, TestSize.Level1)
1011 {
1012 int32_t ret;
1013 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1014 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1015 attr-sampling-rate=48000";
1016 int32_t listLenth = 256;
1017 struct PrepareAudioPara audiopara = {
1018 .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
1019 };
1020 ASSERT_NE(nullptr, audiopara.render);
1021 ret = audiopara.render->SetExtraParams(audiopara.render, keyValueList);
1022 EXPECT_EQ(HDF_SUCCESS, ret);
1023
1024 for (int i = 0; i < COUNT; ++i) {
1025 char keyValueListValue[256] = {};
1026 gettimeofday(&audiopara.start, NULL);
1027 ret = audiopara.render->GetExtraParams(audiopara.render, keyValueListValue, listLenth);
1028 gettimeofday(&audiopara.end, NULL);
1029 ASSERT_EQ(HDF_SUCCESS, ret);
1030 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1031 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1032 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1033 audiopara.totalTime += audiopara.delayTime;
1034 }
1035 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1036 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1037 }
1038 }
1039