1 /*
2 * Copyright (c) 2024-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
22 #include "v5_0/audio_types.h"
23 #include "v5_0/iaudio_manager.h"
24 #include "v5_0/iaudio_render.h"
25
26 using namespace std;
27 using namespace testing::ext;
28
29 namespace {
30 const int BUFFER_LENTH = 1024 * 16;
31 const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4 * 1024;
32 const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
33 const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
34 const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
35 const int32_t AUDIO_OFFLOAD_BUFFER_SIZE = 100;
36 const int32_t AUDIO_BIT_RATE = AUDIO_SAMPLE_RATE_48K * 8;
37 const int32_t AUDIO_BIT_WIDTH = 32;
38
39 class AudioRenderOffloadBenchmarkTest : public benchmark::Fixture {
40 public:
41 struct IAudioManager *manager_ = nullptr;
42 struct AudioAdapterDescriptor descs_[MAX_AUDIO_ADAPTER_DESC];
43 struct AudioAdapterDescriptor *desc_;
44 struct IAudioAdapter *adapter_ = nullptr;
45 struct IAudioRender *render_ = nullptr;
46 struct AudioDeviceDescriptor devDescRender_ = {};
47 struct AudioSampleAttributes attrsRender_ = {};
48 uint32_t renderId_ = 0;
49 char *devDescriptorName_ = nullptr;
50 uint32_t size_ = MAX_AUDIO_ADAPTER_DESC;
51 virtual void SetUp(const ::benchmark::State &state);
52 virtual void TearDown(const ::benchmark::State &state);
53 void InitRenderAttrs(struct AudioSampleAttributes &attrs);
54 void InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc);
55 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
56 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen);
57 };
58
InitRenderAttrs(struct AudioSampleAttributes & attrs)59 void AudioRenderOffloadBenchmarkTest::InitRenderAttrs(struct AudioSampleAttributes &attrs)
60 {
61 attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
62 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
63 attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
64 attrs.interleaved = 0;
65 attrs.type = AUDIO_OFFLOAD;
66 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
67 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT;
68 attrs.isBigEndian = false;
69 attrs.isSignedData = true;
70 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount);
71 attrs.stopThreshold = INT_MAX;
72 attrs.silenceThreshold = BUFFER_LENTH;
73 attrs.offloadInfo.bitRate = AUDIO_BIT_RATE;
74 attrs.offloadInfo.bitWidth = AUDIO_BIT_WIDTH;
75 attrs.offloadInfo.sampleRate = AUDIO_SAMPLE_RATE_48K;
76 attrs.offloadInfo.channelCount = AUDIO_RENDER_CHANNELCOUNT;
77 attrs.offloadInfo.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
78 }
79
InitRenderDevDesc(struct AudioDeviceDescriptor & devDesc)80 void AudioRenderOffloadBenchmarkTest::InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc)
81 {
82 devDesc.pins = PIN_OUT_SPEAKER;
83 devDescriptorName_ = strdup("cardname");
84 devDesc.desc = devDescriptorName_;
85
86 ASSERT_NE(desc_, nullptr);
87 ASSERT_NE(desc_->ports, nullptr);
88 for (uint32_t index = 0; index < desc_->portsLen; index++) {
89 if (desc_->ports[index].dir == PORT_OUT) {
90 devDesc.portId = desc_->ports[index].portId;
91 return;
92 }
93 }
94 free(devDesc.desc);
95 }
96
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)97 void AudioRenderOffloadBenchmarkTest::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
98 {
99 if (dataBlock == nullptr) {
100 return;
101 }
102
103 OsalMemFree(dataBlock->adapterName);
104
105 OsalMemFree(dataBlock->ports);
106
107 if (freeSelf) {
108 OsalMemFree(dataBlock);
109 }
110 }
111
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor * descs,uint32_t descsLen)112 void AudioRenderOffloadBenchmarkTest::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen)
113 {
114 if (descs == nullptr || descsLen == 0) {
115 return;
116 }
117
118 for (uint32_t i = 0; i < descsLen; i++) {
119 FreeAdapterElements(&descs[i], false);
120 }
121 }
122
SetUp(const::benchmark::State & state)123 void AudioRenderOffloadBenchmarkTest::SetUp(const ::benchmark::State &state)
124 {
125 manager_ = IAudioManagerGet(false);
126 ASSERT_NE(manager_, nullptr);
127
128 ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, descs_, &size_));
129 ASSERT_NE(descs_, nullptr);
130 EXPECT_GE(MAX_AUDIO_ADAPTER_DESC, size_);
131 desc_ = &descs_[0];
132 ASSERT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, desc_, &adapter_));
133 ASSERT_NE(adapter_, nullptr);
134 InitRenderDevDesc(devDescRender_);
135 InitRenderAttrs(attrsRender_);
136 (void)adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
137 ASSERT_NE(render_, nullptr);
138 }
139
TearDown(const::benchmark::State & state)140 void AudioRenderOffloadBenchmarkTest::TearDown(const ::benchmark::State &state)
141 {
142 ASSERT_NE(devDescriptorName_, nullptr);
143 free(devDescriptorName_);
144 devDescriptorName_ = NULL;
145
146 if (adapter_ != nullptr) {
147 adapter_->DestroyRender(adapter_, renderId_);
148 render_ = nullptr;
149 }
150 if (manager_ != nullptr) {
151 manager_->UnloadAdapter(manager_, desc_->adapterName);
152 adapter_ = nullptr;
153 ReleaseAllAdapterDescs(descs_, size_);
154
155 IAudioManagerRelease(manager_, false);
156 }
157 }
158
BENCHMARK_F(AudioRenderOffloadBenchmarkTest,SetBufferSize)159 BENCHMARK_F(AudioRenderOffloadBenchmarkTest, SetBufferSize)(benchmark::State &state)
160 {
161 uint32_t size = AUDIO_OFFLOAD_BUFFER_SIZE;
162 int32_t ret;
163 for (auto _ : state) {
164 ret = render_->SetBufferSize(render_, size);
165 ASSERT_TRUE(ret == HDF_SUCCESS);
166 }
167 }
168
169 BENCHMARK_REGISTER_F(AudioRenderOffloadBenchmarkTest, SetBufferSize)->
170 Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
171
172 } // end of namespace