1 /*
2 * Copyright (c) 2023-2025 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 <benchmark/benchmark.h>
17 #include <climits>
18 #include <gtest/gtest.h>
19 #include "hdf_base.h"
20 #include "osal_mem.h"
21 #include "v5_0/audio_types.h"
22 #include "v5_0/iaudio_manager.h"
23 #include "v5_0/iaudio_render.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 namespace {
29 const float MAX_GAINTHRESHOLD = 15.0;
30 const float MIN_GAINTHRESHOLD = 0.0;
31 const int BUFFER_LENTH = 1024 * 16;
32 const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4 * 1024;
33 const int MOVE_LEFT_NUM = 8;
34 const int32_t AUDIO_RENDER_BUF_TEST = 1024;
35 const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
36 const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
37 const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
38 const uint64_t DEFAULT_BUFFER_SIZE = 16384;
39 const int32_t ITERATION_FREQUENCY = 100;
40 const int32_t REPETITION_FREQUENCY = 3;
41 const int32_t RANGE_VALUE = 4;
42 const float GAIN_VALUE = 1.0;
43 const float VOLUNE_VALUE = 0.2;
44
45 class AudioRenderBenchmarkTest : public benchmark::Fixture {
46 public:
47 struct IAudioManager *manager_ = nullptr;
48 struct AudioAdapterDescriptor descs_[MAX_AUDIO_ADAPTER_DESC];
49 struct AudioAdapterDescriptor *desc_;
50 struct IAudioAdapter *adapter_ = nullptr;
51 struct IAudioRender *render_ = nullptr;
52 struct AudioDeviceDescriptor devDescRender_ = {};
53 struct AudioSampleAttributes attrsRender_ = {};
54 uint32_t renderId_ = 0;
55 char *devDescriptorName_ = nullptr;
56 uint32_t size_ = MAX_AUDIO_ADAPTER_DESC;
57 virtual void SetUp(const ::benchmark::State &state);
58 virtual void TearDown(const ::benchmark::State &state);
59 uint64_t GetRenderBufferSize();
60 void InitRenderAttrs(struct AudioSampleAttributes &attrs);
61 void InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc);
62 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
63 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen);
64 };
65
GetRenderBufferSize()66 uint64_t AudioRenderBenchmarkTest::GetRenderBufferSize()
67 {
68 int32_t ret = HDF_SUCCESS;
69 uint64_t frameSize = 0;
70 uint64_t frameCount = 0;
71 uint64_t bufferSize = 0;
72
73 if (render_ == nullptr) {
74 return DEFAULT_BUFFER_SIZE;
75 }
76
77 ret = render_->GetFrameSize(render_, &frameSize);
78 if (ret != HDF_SUCCESS) {
79 return DEFAULT_BUFFER_SIZE;
80 }
81
82 ret = render_->GetFrameCount(render_, &frameCount);
83 if (ret != HDF_SUCCESS) {
84 return DEFAULT_BUFFER_SIZE;
85 }
86
87 bufferSize = frameCount * frameSize;
88 if (bufferSize == 0) {
89 bufferSize = DEFAULT_BUFFER_SIZE;
90 }
91
92 return bufferSize;
93 }
94
InitRenderAttrs(struct AudioSampleAttributes & attrs)95 void AudioRenderBenchmarkTest::InitRenderAttrs(struct AudioSampleAttributes &attrs)
96 {
97 attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
98 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
99 attrs.interleaved = 0;
100 attrs.type = AUDIO_IN_MEDIA;
101 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
102 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT / MOVE_LEFT_NUM;
103 attrs.isBigEndian = false;
104 attrs.isSignedData = true;
105 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
106 attrs.stopThreshold = INT_MAX;
107 attrs.silenceThreshold = BUFFER_LENTH;
108 }
109
InitRenderDevDesc(struct AudioDeviceDescriptor & devDesc)110 void AudioRenderBenchmarkTest::InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc)
111 {
112 devDesc.pins = PIN_OUT_SPEAKER;
113 devDescriptorName_ = strdup("cardname");
114 devDesc.desc = devDescriptorName_;
115
116 ASSERT_NE(desc_, nullptr);
117 ASSERT_NE(desc_->ports, nullptr);
118 for (uint32_t index = 0; index < desc_->portsLen; index++) {
119 if (desc_->ports[index].dir == PORT_OUT) {
120 devDesc.portId = desc_->ports[index].portId;
121 return;
122 }
123 }
124 }
125
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)126 void AudioRenderBenchmarkTest::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
127 {
128 if (dataBlock == nullptr) {
129 return;
130 }
131
132 OsalMemFree(dataBlock->adapterName);
133
134 OsalMemFree(dataBlock->ports);
135
136 if (freeSelf) {
137 OsalMemFree(dataBlock);
138 }
139 }
140
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor * descs,uint32_t descsLen)141 void AudioRenderBenchmarkTest::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen)
142 {
143 if (descs == nullptr || descsLen == 0) {
144 return;
145 }
146
147 for (uint32_t i = 0; i < descsLen; i++) {
148 FreeAdapterElements(&descs[i], false);
149 }
150 }
151
SetUp(const::benchmark::State & state)152 void AudioRenderBenchmarkTest::SetUp(const ::benchmark::State &state)
153 {
154 manager_ = IAudioManagerGet(false);
155 ASSERT_NE(manager_, nullptr);
156
157 ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, descs_, &size_));
158 ASSERT_NE(descs_, nullptr);
159 EXPECT_GE(MAX_AUDIO_ADAPTER_DESC, size_);
160 desc_ = &descs_[0];
161 ASSERT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, desc_, &adapter_));
162 ASSERT_NE(adapter_, nullptr);
163 InitRenderDevDesc(devDescRender_);
164 InitRenderAttrs(attrsRender_);
165
166 attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
167 int32_t ret = adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
168 if (ret != HDF_SUCCESS) {
169 attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
170 ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_));
171 }
172 ASSERT_NE(render_, nullptr);
173 }
174
TearDown(const::benchmark::State & state)175 void AudioRenderBenchmarkTest::TearDown(const ::benchmark::State &state)
176 {
177 ASSERT_NE(devDescriptorName_, nullptr);
178 free(devDescriptorName_);
179 devDescriptorName_ = NULL;
180
181 if (adapter_ != nullptr) {
182 adapter_->DestroyRender(adapter_, renderId_);
183 render_ = nullptr;
184 }
185 if (manager_ != nullptr) {
186 manager_->UnloadAdapter(manager_, desc_->adapterName);
187 adapter_ = nullptr;
188 ReleaseAllAdapterDescs(descs_, size_);
189
190 IAudioManagerRelease(manager_, false);
191 }
192 }
193
BENCHMARK_F(AudioRenderBenchmarkTest,StartAndStop)194 BENCHMARK_F(AudioRenderBenchmarkTest, StartAndStop)(benchmark::State &state)
195 {
196 ASSERT_NE(render_, nullptr);
197 int32_t ret;
198 for (auto _ : state) {
199 ret = render_->Start(render_);
200 EXPECT_EQ(ret, HDF_SUCCESS);
201 ret = render_->Stop(render_);
202 EXPECT_EQ(ret, HDF_SUCCESS);
203 }
204 }
205
206 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, StartAndStop)->
207 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
208
BENCHMARK_F(AudioRenderBenchmarkTest,Pause)209 BENCHMARK_F(AudioRenderBenchmarkTest, Pause)(benchmark::State &state)
210 {
211 ASSERT_NE(render_, nullptr);
212 int32_t ret = render_->Start(render_);
213 EXPECT_EQ(ret, HDF_SUCCESS);
214
215 for (auto _ : state) {
216 ret = render_->Pause(render_);
217 #ifdef DISPLAY_COMMUNITY
218 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_SUCCESS);
219 #else
220 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
221 #endif
222 }
223 ret = render_->Stop(render_);
224 ASSERT_EQ(ret, HDF_SUCCESS);
225 }
226
227 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, Pause)->
228 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
229
BENCHMARK_F(AudioRenderBenchmarkTest,Resume)230 BENCHMARK_F(AudioRenderBenchmarkTest, Resume)(benchmark::State &state)
231 {
232 ASSERT_NE(render_, nullptr);
233 int32_t ret = render_->Start(render_);
234 EXPECT_EQ(ret, HDF_SUCCESS);
235
236 ret = render_->Pause(render_);
237 #ifdef DISPLAY_COMMUNITY
238 ASSERT_TRUE(ret == HDF_SUCCESS);
239 #else
240 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
241 #endif
242
243 for (auto _ : state) {
244 ret = render_->Resume(render_);
245 #ifdef DISPLAY_COMMUNITY
246 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_SUCCESS);
247 #else
248 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
249 #endif
250 }
251
252 ret = render_->Stop(render_);
253 ASSERT_EQ(ret, HDF_SUCCESS);
254 }
255
256 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, Resume)->
257 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
258
BENCHMARK_F(AudioRenderBenchmarkTest,Flush)259 BENCHMARK_F(AudioRenderBenchmarkTest, Flush)(benchmark::State &state)
260 {
261 ASSERT_NE(render_, nullptr);
262 int32_t ret;
263 for (auto _ : state) {
264 ret = render_->Flush(render_);
265 EXPECT_NE(ret, HDF_SUCCESS);
266 }
267 }
268
269 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, Flush)->
270 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
271
BENCHMARK_F(AudioRenderBenchmarkTest,TurnStandbyMode)272 BENCHMARK_F(AudioRenderBenchmarkTest, TurnStandbyMode)(benchmark::State &state)
273 {
274 ASSERT_NE(render_, nullptr);
275 int32_t ret;
276 for (auto _ : state) {
277 ret = render_->Start(render_);
278 EXPECT_EQ(ret, HDF_SUCCESS);
279 ret = render_->TurnStandbyMode(render_);
280 EXPECT_EQ(ret, HDF_SUCCESS);
281 render_->Stop(render_);
282 }
283 }
284
285 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, TurnStandbyMode)->
286 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
287
BENCHMARK_F(AudioRenderBenchmarkTest,AudioDevDump)288 BENCHMARK_F(AudioRenderBenchmarkTest, AudioDevDump)(benchmark::State &state)
289 {
290 ASSERT_NE(render_, nullptr);
291 int32_t ret;
292 int32_t range = RANGE_VALUE;
293 char pathBuf[] = "/data/RenderDump.log";
294
295 FILE *file = fopen(pathBuf, "wb+");
296 ASSERT_NE(nullptr, file);
297 int fd = fileno(file);
298 if (fd == -1) {
299 fclose(file);
300 ASSERT_NE(fd, -1);
301 }
302
303 for (auto _ : state) {
304 ret = render_->AudioDevDump(render_, range, fd);
305 #ifdef DISPLAY_COMMUNITY
306 ASSERT_TRUE(ret == HDF_SUCCESS);
307 #else
308 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
309 #endif
310 }
311 fclose(file);
312 }
313
314 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, AudioDevDump)->
315 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
316
BENCHMARK_F(AudioRenderBenchmarkTest,GetFrameSize)317 BENCHMARK_F(AudioRenderBenchmarkTest, GetFrameSize)(benchmark::State &state)
318 {
319 ASSERT_NE(render_, nullptr);
320 int32_t ret;
321 uint64_t frameSize = 0;
322
323 for (auto _ : state) {
324 ret = render_->GetFrameSize(render_, &frameSize);
325 EXPECT_EQ(ret, HDF_SUCCESS);
326 }
327 }
328
329 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetFrameSize)->
330 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
331
BENCHMARK_F(AudioRenderBenchmarkTest,GetFrameCount)332 BENCHMARK_F(AudioRenderBenchmarkTest, GetFrameCount)(benchmark::State &state)
333 {
334 ASSERT_NE(render_, nullptr);
335 int32_t ret;
336 uint64_t frameCount = 0;
337
338 for (auto _ : state) {
339 ret = render_->GetFrameCount(render_, &frameCount);
340 EXPECT_EQ(ret, HDF_SUCCESS);
341 }
342 }
343
344 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetFrameCount)->
345 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
346
BENCHMARK_F(AudioRenderBenchmarkTest,SetSampleAttributes)347 BENCHMARK_F(AudioRenderBenchmarkTest, SetSampleAttributes)(benchmark::State &state)
348 {
349 ASSERT_NE(render_, nullptr);
350 int32_t ret;
351 struct AudioSampleAttributes attrs = attrsRender_;
352 for (auto _ : state) {
353 ret = render_->SetSampleAttributes(render_, &attrs);
354 EXPECT_EQ(ret, HDF_SUCCESS);
355 }
356 }
357
358 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SetSampleAttributes)->
359 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
360
BENCHMARK_F(AudioRenderBenchmarkTest,GetSampleAttributes)361 BENCHMARK_F(AudioRenderBenchmarkTest, GetSampleAttributes)(benchmark::State &state)
362 {
363 ASSERT_NE(render_, nullptr);
364 int32_t ret;
365 struct AudioSampleAttributes attrs = {};
366
367 for (auto _ : state) {
368 ret = render_->GetSampleAttributes(render_, &attrs);
369 EXPECT_EQ(ret, HDF_SUCCESS);
370 }
371 }
372
373 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetSampleAttributes)->
374 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
375
BENCHMARK_F(AudioRenderBenchmarkTest,GetCurrentChannelId)376 BENCHMARK_F(AudioRenderBenchmarkTest, GetCurrentChannelId)(benchmark::State &state)
377 {
378 ASSERT_NE(render_, nullptr);
379 int32_t ret;
380 uint32_t channelId = 0;
381
382 for (auto _ : state) {
383 ret = render_->GetCurrentChannelId(render_, &channelId);
384 EXPECT_EQ(ret, HDF_SUCCESS);
385 }
386 }
387
388 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetCurrentChannelId)->
389 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
390
BENCHMARK_F(AudioRenderBenchmarkTest,SelectScene)391 BENCHMARK_F(AudioRenderBenchmarkTest, SelectScene)(benchmark::State &state)
392 {
393 ASSERT_NE(render_, nullptr);
394 int32_t ret;
395 struct AudioSceneDescriptor scene;
396 scene.scene.id = AUDIO_IN_MEDIA;
397 scene.desc.pins = PIN_OUT_SPEAKER;
398 scene.desc.desc = const_cast<char*>("primary");
399
400 for (auto _ : state) {
401 ret = render_->SelectScene(render_, &scene);
402 EXPECT_EQ(ret, HDF_SUCCESS);
403 }
404 }
405
406 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SelectScene)->
407 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
408
BENCHMARK_F(AudioRenderBenchmarkTest,GetLatency)409 BENCHMARK_F(AudioRenderBenchmarkTest, GetLatency)(benchmark::State &state)
410 {
411 ASSERT_NE(render_, nullptr);
412 int32_t ret;
413 uint32_t ms = 0;
414
415 for (auto _ : state) {
416 ret = render_->GetLatency(render_, &ms);
417 EXPECT_EQ(ret, HDF_SUCCESS);
418 }
419 }
420
421 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetLatency)->
422 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
423
BENCHMARK_F(AudioRenderBenchmarkTest,GetRenderPosition)424 BENCHMARK_F(AudioRenderBenchmarkTest, GetRenderPosition)(benchmark::State &state)
425 {
426 ASSERT_NE(render_, nullptr);
427 int32_t ret;
428 uint64_t frames = 0;
429 struct AudioTimeStamp time;
430
431 for (auto _ : state) {
432 ret = render_->GetRenderPosition(render_, &frames, &time);
433 #ifdef DISPLAY_COMMUNITY
434 ASSERT_TRUE(ret == HDF_SUCCESS);
435 #else
436 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
437 #endif
438 }
439 }
440
441 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetRenderPosition)->
442 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
443
BENCHMARK_F(AudioRenderBenchmarkTest,SetExtraParams)444 BENCHMARK_F(AudioRenderBenchmarkTest, SetExtraParams)(benchmark::State &state)
445 {
446 ASSERT_NE(render_, nullptr);
447 int32_t ret;
448 char keyValueList[AUDIO_RENDER_BUF_TEST] =
449 "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
450
451 for (auto _ : state) {
452 ret = render_->SetExtraParams(render_, keyValueList);
453 EXPECT_EQ(ret, HDF_SUCCESS);
454 }
455 }
456
457 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SetExtraParams)->
458 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
459
BENCHMARK_F(AudioRenderBenchmarkTest,GetExtraParams)460 BENCHMARK_F(AudioRenderBenchmarkTest, GetExtraParams)(benchmark::State &state)
461 {
462 ASSERT_NE(render_, nullptr);
463 int32_t ret;
464 char keyValueList[AUDIO_RENDER_BUF_TEST] = {};
465 uint32_t keyValueListLen = 0;
466
467 for (auto _ : state) {
468 ret = render_->GetExtraParams(render_, keyValueList, keyValueListLen);
469 EXPECT_NE(ret, HDF_SUCCESS);
470 }
471 }
472
473 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetExtraParams)->
474 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
475
BENCHMARK_F(AudioRenderBenchmarkTest,SetGain)476 BENCHMARK_F(AudioRenderBenchmarkTest, SetGain)(benchmark::State &state)
477 {
478 ASSERT_NE(render_, nullptr);
479 int32_t ret;
480 float gain = GAIN_VALUE;
481
482 for (auto _ : state) {
483 ret = render_->SetGain(render_, gain);
484 #ifdef DISPLAY_COMMUNITY
485 ASSERT_TRUE(ret == HDF_SUCCESS);
486 #else
487 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
488 #endif
489 }
490 }
491
492 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SetGain)->
493 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
494
BENCHMARK_F(AudioRenderBenchmarkTest,GetGain)495 BENCHMARK_F(AudioRenderBenchmarkTest, GetGain)(benchmark::State &state)
496 {
497 ASSERT_NE(render_, nullptr);
498 int32_t ret;
499 float gain;
500
501 for (auto _ : state) {
502 ret = render_->GetGain(render_, &gain);
503 #ifdef DISPLAY_COMMUNITY
504 ASSERT_TRUE(ret == HDF_SUCCESS);
505 #else
506 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
507 #endif
508 }
509 }
510
511 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetGain)->
512 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
513
BENCHMARK_F(AudioRenderBenchmarkTest,GetGainThreshold)514 BENCHMARK_F(AudioRenderBenchmarkTest, GetGainThreshold)(benchmark::State &state)
515 {
516 ASSERT_NE(render_, nullptr);
517 int32_t ret;
518 float min = 0.0;
519 float max = GAIN_VALUE;
520
521 for (auto _ : state) {
522 ret = render_->GetGainThreshold(render_, &min, &max);
523 #ifdef DISPLAY_COMMUNITY
524 ASSERT_TRUE(ret == HDF_SUCCESS);
525 #else
526 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
527 #endif
528 }
529 EXPECT_GE(min, MIN_GAINTHRESHOLD);
530 EXPECT_LE(max, MAX_GAINTHRESHOLD);
531 }
532
533 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetGainThreshold)->
534 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
535
BENCHMARK_F(AudioRenderBenchmarkTest,GetMmapPosition)536 BENCHMARK_F(AudioRenderBenchmarkTest, GetMmapPosition)(benchmark::State &state)
537 {
538 ASSERT_NE(render_, nullptr);
539 int32_t ret;
540 uint64_t frames = 0;
541 struct AudioTimeStamp time;
542 time.tvNSec = 0;
543 time.tvSec = 0;
544
545 for (auto _ : state) {
546 ret = render_->GetMmapPosition(render_, &frames, &time);
547 #ifdef DISPLAY_COMMUNITY
548 ASSERT_TRUE(ret == HDF_SUCCESS);
549 #else
550 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
551 #endif
552 }
553 }
554
555 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetMmapPosition)->
556 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
557
BENCHMARK_F(AudioRenderBenchmarkTest,SetMute)558 BENCHMARK_F(AudioRenderBenchmarkTest, SetMute)(benchmark::State &state)
559 {
560 ASSERT_NE(render_, nullptr);
561 int32_t ret;
562 bool mute = false;
563
564 for (auto _ : state) {
565 ret = render_->SetMute(render_, mute);
566 #ifdef DISPLAY_COMMUNITY
567 ASSERT_TRUE(ret == HDF_SUCCESS);
568 #else
569 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
570 #endif
571 }
572 }
573
574 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SetMute)->
575 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
576
BENCHMARK_F(AudioRenderBenchmarkTest,GetMute)577 BENCHMARK_F(AudioRenderBenchmarkTest, GetMute)(benchmark::State &state)
578 {
579 ASSERT_NE(render_, nullptr);
580 int32_t ret;
581 bool isMute = false;
582
583 for (auto _ : state) {
584 ret = render_->GetMute(render_, &isMute);
585 #ifdef DISPLAY_COMMUNITY
586 ASSERT_TRUE(ret == HDF_SUCCESS);
587 #else
588 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
589 #endif
590 }
591 }
592
593 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetMute)->
594 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
595
BENCHMARK_F(AudioRenderBenchmarkTest,SetVolume)596 BENCHMARK_F(AudioRenderBenchmarkTest, SetVolume)(benchmark::State &state)
597 {
598 ASSERT_NE(render_, nullptr);
599 int32_t ret;
600 float volume = VOLUNE_VALUE;
601
602 for (auto _ : state) {
603 ret = render_->SetVolume(render_, volume);
604 #ifdef DISPLAY_COMMUNITY
605 ASSERT_TRUE(ret == HDF_SUCCESS);
606 #else
607 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
608 #endif
609 }
610 }
611
612 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SetVolume)->
613 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
614
BENCHMARK_F(AudioRenderBenchmarkTest,GetVolume)615 BENCHMARK_F(AudioRenderBenchmarkTest, GetVolume)(benchmark::State &state)
616 {
617 ASSERT_NE(render_, nullptr);
618 int32_t ret;
619 float val = 0.0;
620
621 for (auto _ : state) {
622 ret = render_->GetVolume(render_, &val);
623 #ifdef DISPLAY_COMMUNITY
624 ASSERT_TRUE(ret == HDF_SUCCESS);
625 #else
626 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
627 #endif
628 }
629 }
630
631 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetVolume)->
632 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
633
BENCHMARK_F(AudioRenderBenchmarkTest,RenderFrame)634 BENCHMARK_F(AudioRenderBenchmarkTest, RenderFrame)(benchmark::State &state)
635 {
636 ASSERT_NE(render_, nullptr);
637 int32_t ret;
638 uint32_t frameLen = (uint64_t)GetRenderBufferSize();
639 uint64_t requestBytes = frameLen;
640 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
641
642 int8_t *frame = (int8_t *)calloc(1, frameLen);
643 ASSERT_NE(nullptr, frame);
644
645 for (auto _ : state) {
646 ret = render_->RenderFrame(render_, frame, frameLen, &requestBytes);
647 EXPECT_EQ(ret, HDF_SUCCESS);
648 }
649 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
650
651 if (frame != nullptr) {
652 free(frame);
653 frame = nullptr;
654 }
655 }
656
657 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, RenderFrame)->
658 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
659
BENCHMARK_F(AudioRenderBenchmarkTest,SetChannelMode)660 BENCHMARK_F(AudioRenderBenchmarkTest, SetChannelMode)(benchmark::State &state)
661 {
662 ASSERT_NE(render_, nullptr);
663 int32_t ret;
664 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
665
666 for (auto _ : state) {
667 ret = render_->SetChannelMode(render_, mode);
668 #ifdef DISPLAY_COMMUNITY
669 ASSERT_TRUE(ret == HDF_SUCCESS);
670 #else
671 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
672 #endif
673 }
674 }
675
676 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SetChannelMode)->
677 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
678
BENCHMARK_F(AudioRenderBenchmarkTest,GetChannelMode)679 BENCHMARK_F(AudioRenderBenchmarkTest, GetChannelMode)(benchmark::State &state)
680 {
681 ASSERT_NE(render_, nullptr);
682 int32_t ret;
683 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
684
685 for (auto _ : state) {
686 ret = render_->GetChannelMode(render_, &mode);
687 #ifdef DISPLAY_COMMUNITY
688 ASSERT_TRUE(ret == HDF_SUCCESS);
689 #else
690 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
691 #endif
692 }
693 }
694
695 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetChannelMode)->
696 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
697
BENCHMARK_F(AudioRenderBenchmarkTest,SetRenderSpeed)698 BENCHMARK_F(AudioRenderBenchmarkTest, SetRenderSpeed)(benchmark::State &state)
699 {
700 ASSERT_NE(render_, nullptr);
701 int32_t ret;
702 float speed = 2.0;
703
704 for (auto _ : state) {
705 ret = render_->SetRenderSpeed(render_, speed);
706 EXPECT_NE(ret, HDF_SUCCESS);
707 }
708 }
709
710 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, SetRenderSpeed)->
711 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
712
BENCHMARK_F(AudioRenderBenchmarkTest,GetRenderSpeed)713 BENCHMARK_F(AudioRenderBenchmarkTest, GetRenderSpeed)(benchmark::State &state)
714 {
715 ASSERT_NE(render_, nullptr);
716 int32_t ret;
717 float speed = 0;
718
719 for (auto _ : state) {
720 ret = render_->GetRenderSpeed(render_, &speed);
721 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
722 }
723 }
724 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetRenderSpeed)->
725 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
726
BENCHMARK_F(AudioRenderBenchmarkTest,RegCallback)727 BENCHMARK_F(AudioRenderBenchmarkTest, RegCallback)(benchmark::State &state)
728 {
729 ASSERT_NE(render_, nullptr);
730 int32_t ret;
731 int8_t cookie = 0;
732 struct IAudioCallback *audioCallback = nullptr;
733
734 for (auto _ : state) {
735 ret = render_->RegCallback(render_, audioCallback, cookie);
736 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
737 }
738 }
739
740 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, RegCallback)->
741 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
742
BENCHMARK_F(AudioRenderBenchmarkTest,DrainBuffer)743 BENCHMARK_F(AudioRenderBenchmarkTest, DrainBuffer)(benchmark::State &state)
744 {
745 ASSERT_NE(render_, nullptr);
746 int32_t ret;
747 enum AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
748
749 for (auto _ : state) {
750 ret = render_->DrainBuffer(render_, &type);
751 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
752 }
753 }
754
755 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, DrainBuffer)->
756 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
757
BENCHMARK_F(AudioRenderBenchmarkTest,IsSupportsDrain)758 BENCHMARK_F(AudioRenderBenchmarkTest, IsSupportsDrain)(benchmark::State &state)
759 {
760 ASSERT_NE(render_, nullptr);
761 int32_t ret;
762 bool support = false;
763
764 for (auto _ : state) {
765 ret = render_->IsSupportsDrain(render_, &support);
766 #ifdef DISPLAY_COMMUNITY
767 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
768 #else
769 ASSERT_TRUE(ret == HDF_SUCCESS);
770 #endif
771 }
772 }
773
774 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, IsSupportsDrain)->
775 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
776
BENCHMARK_F(AudioRenderBenchmarkTest,CheckSceneCapability)777 BENCHMARK_F(AudioRenderBenchmarkTest, CheckSceneCapability)(benchmark::State &state)
778 {
779 ASSERT_NE(render_, nullptr);
780 int32_t ret = -1;
781 bool supported = false;
782 struct AudioSceneDescriptor scenes = {};
783 scenes.scene.id = 0;
784 scenes.desc.pins = PIN_OUT_SPEAKER;
785 scenes.desc.desc = strdup("mic");
786 for (auto _ : state) {
787 ret = render_->CheckSceneCapability(render_, &scenes, &supported);
788 EXPECT_EQ(HDF_SUCCESS, ret);
789 }
790 free(scenes.desc.desc);
791 }
792 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, CheckSceneCapability)->
793 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
794
BENCHMARK_F(AudioRenderBenchmarkTest,AddAndRemoveAudioEffect)795 BENCHMARK_F(AudioRenderBenchmarkTest, AddAndRemoveAudioEffect)(benchmark::State &state)
796 {
797 ASSERT_NE(render_, nullptr);
798 int32_t ret;
799 uint64_t effectId = 0;
800
801 for (auto _ : state) {
802 ret = render_->AddAudioEffect(render_, effectId);
803 #ifdef DISPLAY_COMMUNITY
804 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
805 #else
806 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
807 #endif
808
809 ret = render_->RemoveAudioEffect(render_, effectId);
810 #ifdef DISPLAY_COMMUNITY
811 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
812 #else
813 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
814 #endif
815 }
816 }
817
818 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, AddAndRemoveAudioEffect)->
819 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
820
BENCHMARK_F(AudioRenderBenchmarkTest,GetFrameBufferSize)821 BENCHMARK_F(AudioRenderBenchmarkTest, GetFrameBufferSize)(benchmark::State &state)
822 {
823 ASSERT_NE(render_, nullptr);
824 int32_t ret;
825 uint64_t bufferSize = BUFFER_LENTH;
826
827 for (auto _ : state) {
828 ret = render_->GetFrameBufferSize(render_, &bufferSize);
829 #ifdef DISPLAY_COMMUNITY
830 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
831 #else
832 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
833 #endif
834 }
835 }
836
837 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, GetFrameBufferSize)->
838 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
839
BENCHMARK_F(AudioRenderBenchmarkTest,IsSupportsPauseAndResume)840 BENCHMARK_F(AudioRenderBenchmarkTest, IsSupportsPauseAndResume)(benchmark::State &state)
841 {
842 ASSERT_NE(render_, nullptr);
843 int32_t ret;
844 bool supportPause = false;
845 bool supportResume = false;
846
847 for (auto _ : state) {
848 ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
849 #ifdef DISPLAY_COMMUNITY
850 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT);
851 #else
852 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
853 #endif
854 }
855 }
856
857 BENCHMARK_REGISTER_F(AudioRenderBenchmarkTest, IsSupportsPauseAndResume)->
858 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
859 }
860