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 <climits>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include "hdf_dlist.h"
20 #include "osal_mem.h"
21 #include "v5_0/audio_types.h"
22 #include "v5_0/iaudio_adapter.h"
23 #include "v5_0/iaudio_manager.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 #define AUDIO_CHANNELCOUNT 2
29 #define AUDIO_SAMPLE_RATE_192K 192000
30 #define AUDIO_SAMPLE_RATE_48K 48000
31 #define AUDIO_SAMPLE_RATE_44_1K 44100
32 #define DEEP_BUFFER_RENDER_PERIOD_SIZE 4096
33 #define AUDIO_CHANNELLAYOUT 3
34 namespace {
35 static const uint32_t g_audioAdapterNumMax = 5;
36
37 class HdfAudioAdapterDirectTest : public testing::Test {
38 public:
39 struct IAudioManager *manager_ = nullptr;
40 struct IAudioAdapter *adapter_ = nullptr;
41 struct AudioAdapterDescriptor *adapterDescs_ = nullptr;
42 uint32_t renderId_ = 0;
43 uint32_t captureId_ = 0;
44 virtual void SetUp();
45 virtual void TearDown();
46 void InitDirectAttrs(struct AudioSampleAttributes &attrs);
47 void InitDevDesc(struct AudioDeviceDescriptor &devDesc);
48 void AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
49 void ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen);
50 };
51
AudioAdapterDescriptorFree(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)52 void HdfAudioAdapterDirectTest::AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
53 {
54 if (dataBlock == nullptr) {
55 return;
56 }
57
58 if (dataBlock->adapterName != nullptr) {
59 OsalMemFree(dataBlock->adapterName);
60 dataBlock->adapterName = nullptr;
61 }
62
63 if (dataBlock->ports != nullptr) {
64 OsalMemFree(dataBlock->ports);
65 }
66
67 if (freeSelf) {
68 OsalMemFree(dataBlock);
69 }
70 }
71
ReleaseAdapterDescs(struct AudioAdapterDescriptor ** descs,uint32_t descsLen)72 void HdfAudioAdapterDirectTest::ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
73 {
74 if ((descsLen > 0) && (descs != nullptr) && ((*descs) != nullptr)) {
75 for (uint32_t i = 0; i < descsLen; i++) {
76 AudioAdapterDescriptorFree(&(*descs)[i], false);
77 }
78 OsalMemFree(*descs);
79 *descs = nullptr;
80 }
81 }
82
InitDirectAttrs(struct AudioSampleAttributes & attrs)83 void HdfAudioAdapterDirectTest::InitDirectAttrs(struct AudioSampleAttributes &attrs)
84 {
85 attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
86 attrs.channelCount = AUDIO_CHANNELCOUNT;
87 attrs.channelLayout = AUDIO_CHANNELLAYOUT;
88 attrs.sampleRate = AUDIO_SAMPLE_RATE_192K;
89 attrs.interleaved = 1;
90 attrs.type = AUDIO_DIRECT;
91 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
92 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_32_BIT * AUDIO_CHANNELCOUNT;
93 attrs.isBigEndian = false;
94 attrs.isSignedData = true;
95 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.frameSize);
96 attrs.stopThreshold = INT_MAX;
97 attrs.silenceThreshold = 0;
98 }
99
InitDevDesc(struct AudioDeviceDescriptor & devDesc)100 void HdfAudioAdapterDirectTest::InitDevDesc(struct AudioDeviceDescriptor &devDesc)
101 {
102 ASSERT_NE(adapterDescs_, nullptr);
103 ASSERT_NE(adapterDescs_->ports, nullptr);
104 for (uint32_t index = 0; index < adapterDescs_->portsLen; index++) {
105 if (adapterDescs_->ports[index].dir == PORT_OUT) {
106 devDesc.portId = adapterDescs_->ports[index].portId;
107 return;
108 }
109 }
110 }
111
SetUp()112 void HdfAudioAdapterDirectTest::SetUp()
113 {
114 uint32_t size = g_audioAdapterNumMax;
115 manager_ = IAudioManagerGet(false);
116 ASSERT_NE(manager_, nullptr);
117
118 adapterDescs_ = (struct AudioAdapterDescriptor *)OsalMemCalloc(
119 sizeof(struct AudioAdapterDescriptor) * (g_audioAdapterNumMax));
120 ASSERT_NE(adapterDescs_, nullptr);
121
122 ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, adapterDescs_, &size));
123 if (size > g_audioAdapterNumMax) {
124 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
125 ASSERT_LT(size, g_audioAdapterNumMax);
126 }
127
128 if (manager_->LoadAdapter(manager_, &adapterDescs_[0], &adapter_) != HDF_SUCCESS) {
129 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
130 ASSERT_TRUE(false);
131 }
132 if (adapter_ == nullptr) {
133 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
134 ASSERT_TRUE(false);
135 }
136 }
137
TearDown()138 void HdfAudioAdapterDirectTest::TearDown()
139 {
140 ASSERT_NE(manager_, nullptr);
141 ASSERT_NE(adapter_, nullptr);
142
143 manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName);
144 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
145 adapter_ = nullptr;
146 IAudioManagerRelease(manager_, false);
147 manager_ = nullptr;
148 }
149
150 /**
151 * @tc.number : SUB_Driver_Audio_Direct_0100
152 * @tc.name : HdfAudioAdapterDirectCreateRenderInvalid001
153 * @tc.desc : Verify function when the input parameter is invalid.
154 @tc.type: FUNC
155 */
156 HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderInvalid001, TestSize.Level1)
157 {
158 struct IAudioRender *render = nullptr;
159 struct AudioDeviceDescriptor devicedesc = {};
160 struct AudioSampleAttributes attrs = {};
161 uint32_t renderId_ = 10;
162
163 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, adapter_->CreateRender(nullptr, &devicedesc, &attrs, &render, &renderId_));
164 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, nullptr, &attrs, &render, &renderId_));
165 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, &devicedesc, nullptr, &render, &renderId_));
166 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, &devicedesc, &attrs, nullptr, &renderId_));
167 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, nullptr));
168 EXPECT_NE(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
169 }
170
171 /**
172 * @tc.number : SUB_Driver_Audio_Direct_0200
173 * @tc.name : HdfAudioAdapterDirectCreateRenderIsvalid001
174 * @tc.desc : Verify supported the direct when sampleRate is 192K.
175 @tc.type: FUNC
176 */
177 HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid001, TestSize.Level1)
178 {
179 struct IAudioRender *render = nullptr;
180 struct AudioDeviceDescriptor devicedesc = {};
181 struct AudioSampleAttributes attrs = {};
182 InitDevDesc(devicedesc);
183 devicedesc.desc = strdup("");
184 devicedesc.pins = PIN_OUT_HEADSET;
185 InitDirectAttrs(attrs);
186 attrs.streamId = 0;
187 int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
188 if (ret == HDF_ERR_NOT_SUPPORT)
189 {
190 GTEST_SKIP() << "direct is not supported!" << std::endl;
191 return;
192 }
193 EXPECT_TRUE(ret == HDF_SUCCESS);
194 ret = adapter_->DestroyRender(adapter_, renderId_);
195 EXPECT_TRUE(ret == HDF_SUCCESS);
196 }
197
198 /**
199 * @tc.number : SUB_Driver_Audio_Direct_0300
200 * @tc.name : HdfAudioAdapterDirectCreateRenderIsvalid002
201 * @tc.desc : Verify supported the direct when sampleRate is 48K.
202 @tc.type: FUNC
203 */
204 HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid002, TestSize.Level1)
205 {
206 struct IAudioRender *render = nullptr;
207 struct AudioDeviceDescriptor devicedesc = {};
208 struct AudioSampleAttributes attrs = {};
209 InitDevDesc(devicedesc);
210 devicedesc.desc = strdup("");
211 devicedesc.pins = PIN_OUT_HEADSET;
212 InitDirectAttrs(attrs);
213 attrs.streamId = 0;
214 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
215 int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
216 if (ret == HDF_ERR_NOT_SUPPORT)
217 {
218 GTEST_SKIP() << "direct is not supported!" << std::endl;
219 return;
220 }
221 EXPECT_TRUE(ret == HDF_SUCCESS);
222 ret = adapter_->DestroyRender(adapter_, renderId_);
223 EXPECT_TRUE(ret == HDF_SUCCESS);
224 }
225
226 /**
227 * @tc.number : SUB_Driver_Audio_Direct_0400
228 * @tc.name : HdfAudioAdapterDirectCreateRenderIsvalid003
229 * @tc.desc : Verify supported the direct when sampleRate is 44.1K.
230 @tc.type: FUNC
231 */
232 HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid003, TestSize.Level1)
233 {
234 struct IAudioRender *render = nullptr;
235 struct AudioDeviceDescriptor devicedesc = {};
236 struct AudioSampleAttributes attrs = {};
237 InitDevDesc(devicedesc);
238 devicedesc.desc = strdup("");
239 devicedesc.pins = PIN_OUT_HEADSET;
240 InitDirectAttrs(attrs);
241 attrs.streamId = 0;
242 attrs.sampleRate = AUDIO_SAMPLE_RATE_44_1K;
243 int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
244 if (ret == HDF_ERR_NOT_SUPPORT)
245 {
246 GTEST_SKIP() << "direct is not supported!" << std::endl;
247 return;
248 }
249 EXPECT_TRUE(ret == HDF_SUCCESS);
250 ret = adapter_->DestroyRender(adapter_, renderId_);
251 EXPECT_TRUE(ret == HDF_SUCCESS);
252 }
253 }