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 Defines audio-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter, and rendering audios.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the audio render adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdirender_scene_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45 const string ADAPTER_NAME_INTERNAL = "internal";
46
47 class AudioHdiRenderSceneTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 static TestAudioManager *(*GetAudioManager)();
54 static void *handleSo;
55 #ifdef AUDIO_MPI_SO
56 static int32_t (*SdkInit)();
57 static void (*SdkExit)();
58 static void *sdkSo;
59 #endif
60 };
61
62 using THREAD_FUNC = void *(*)(void *);
63
64 TestAudioManager *(*AudioHdiRenderSceneTest::GetAudioManager)() = nullptr;
65 void *AudioHdiRenderSceneTest::handleSo = nullptr;
66 #ifdef AUDIO_MPI_SO
67 int32_t (*AudioHdiRenderSceneTest::SdkInit)() = nullptr;
68 void (*AudioHdiRenderSceneTest::SdkExit)() = nullptr;
69 void *AudioHdiRenderSceneTest::sdkSo = nullptr;
70 #endif
71
SetUpTestCase(void)72 void AudioHdiRenderSceneTest::SetUpTestCase(void)
73 {
74 #ifdef AUDIO_MPI_SO
75 char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so";
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 handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY);
91 if (handleSo == nullptr) {
92 return;
93 }
94 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
95 if (GetAudioManager == nullptr) {
96 return;
97 }
98 }
99
TearDownTestCase(void)100 void AudioHdiRenderSceneTest::TearDownTestCase(void)
101 {
102 #ifdef AUDIO_MPI_SO
103 SdkExit();
104 if (sdkSo != nullptr) {
105 dlclose(sdkSo);
106 sdkSo = nullptr;
107 }
108 if (SdkInit != nullptr) {
109 SdkInit = nullptr;
110 }
111 if (SdkExit != nullptr) {
112 SdkExit = nullptr;
113 }
114 #endif
115 if (GetAudioManager != nullptr) {
116 GetAudioManager = nullptr;
117 }
118 }
119
SetUp(void)120 void AudioHdiRenderSceneTest::SetUp(void) {}
121
TearDown(void)122 void AudioHdiRenderSceneTest::TearDown(void) {}
123
124 /**
125 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
126 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0001
127 * @tc.desc Test AudioRenderCheckSceneCapability interface,return 0 if check scene's capability successful.
128 * @tc.author: ZHANGHAILIN
129 */
130 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0001, TestSize.Level1)
131 {
132 int32_t ret = -1;
133 bool supported = false;
134 struct AudioSceneDescriptor scenes = {};
135 struct AudioAdapter *adapter = nullptr;
136 struct AudioRender *render = nullptr;
137 ASSERT_NE(nullptr, GetAudioManager);
138 TestAudioManager manager = *GetAudioManager();
139 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
140 ASSERT_EQ(HDF_SUCCESS, ret);
141
142 scenes.scene.id = 0;
143 scenes.desc.pins = PIN_OUT_SPEAKER;
144 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
145 EXPECT_EQ(HDF_SUCCESS, ret);
146 EXPECT_TRUE(supported);
147
148 adapter->DestroyRender(adapter, render);
149 manager.UnloadAdapter(&manager, adapter);
150 }
151 /**
152 * @tc.name Test checking scene's capability where the scene is not configed in the josn.
153 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0002
154 * @tc.desc Test RenderCheckSceneCapability interface,return -1 if the scene is not configed in the josn.
155 * @tc.author: ZHANGHAILIN
156 */
157 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0002, TestSize.Level1)
158 {
159 int32_t ret = -1;
160 bool supported = true;
161 struct AudioSceneDescriptor scenes = {};
162 struct AudioAdapter *adapter = nullptr;
163 struct AudioRender *render = nullptr;
164 ASSERT_NE(nullptr, GetAudioManager);
165 TestAudioManager manager = *GetAudioManager();
166 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
167 ASSERT_EQ(HDF_SUCCESS, ret);
168
169 scenes.scene.id = 5;
170 scenes.desc.pins = PIN_OUT_SPEAKER;
171 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
172 EXPECT_EQ(HDF_FAILURE, ret);
173
174 adapter->DestroyRender(adapter, render);
175 manager.UnloadAdapter(&manager, adapter);
176 }
177 /**
178 * @tc.name Test checking scene's capability where the render is empty
179 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0003
180 * @tc.desc Test AudioRenderCheckSceneCapability,return -1 if the render is empty.
181 * @tc.author: ZHANGHAILIN
182 */
183 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0003, TestSize.Level1)
184 {
185 int32_t ret = -1;
186 bool supported = true;
187 struct AudioSceneDescriptor scenes = {};
188 struct AudioAdapter *adapter = nullptr;
189 struct AudioRender *render = nullptr;
190 struct AudioRender *renderNull = nullptr;
191 ASSERT_NE(nullptr, GetAudioManager);
192 TestAudioManager manager = *GetAudioManager();
193 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
194 ASSERT_EQ(HDF_SUCCESS, ret);
195
196 scenes.scene.id = 0;
197 scenes.desc.pins = PIN_OUT_SPEAKER;
198 ret = render->scene.CheckSceneCapability(renderNull, &scenes, &supported);
199 EXPECT_EQ(HDF_FAILURE, ret);
200
201 adapter->DestroyRender(adapter, render);
202 manager.UnloadAdapter(&manager, adapter);
203 }
204 /**
205 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
206 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0004
207 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the scene is empty.
208 * @tc.author: ZHANGHAILIN
209 */
210 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0004, TestSize.Level1)
211 {
212 int32_t ret = -1;
213 bool supported = true;
214 struct AudioSceneDescriptor *scenes = nullptr;
215 struct AudioAdapter *adapter = nullptr;
216 struct AudioRender *render = nullptr;
217 ASSERT_NE(nullptr, GetAudioManager);
218 TestAudioManager manager = *GetAudioManager();
219 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
220 ASSERT_EQ(HDF_SUCCESS, ret);
221
222 ret = render->scene.CheckSceneCapability(render, scenes, &supported);
223 EXPECT_EQ(HDF_FAILURE, ret);
224
225 adapter->DestroyRender(adapter, render);
226 manager.UnloadAdapter(&manager, adapter);
227 }
228 /**
229 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
230 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0005
231 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the supported is empty.
232 * @tc.author: ZHANGHAILIN
233 */
234 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0005, TestSize.Level1)
235 {
236 int32_t ret = -1;
237 struct AudioSceneDescriptor scenes = {};
238 struct AudioAdapter *adapter = nullptr;
239 struct AudioRender *render = nullptr;
240 ASSERT_NE(nullptr, GetAudioManager);
241 TestAudioManager manager = *GetAudioManager();
242 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
243 ASSERT_EQ(HDF_SUCCESS, ret);
244
245 scenes.scene.id = 0;
246 scenes.desc.pins = PIN_OUT_SPEAKER;
247 ret = render->scene.CheckSceneCapability(render, &scenes, nullptr);
248 EXPECT_EQ(HDF_FAILURE, ret);
249
250 adapter->DestroyRender(adapter, render);
251 manager.UnloadAdapter(&manager, adapter);
252 }
253 /**
254 * @tc.name Test AudioRenderSelectScene API via legal input
255 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0001
256 * @tc.desc Test AudioRenderSelectScene interface,return 0 if select Render's scene successful.
257 * @tc.author: ZHANGHAILIN
258 */
259 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0001, TestSize.Level1)
260 {
261 int32_t ret = -1;
262 struct AudioSceneDescriptor scenes = {};
263 struct AudioAdapter *adapter = nullptr;
264 struct AudioRender *render = nullptr;
265 ASSERT_NE(nullptr, GetAudioManager);
266 TestAudioManager manager = *GetAudioManager();
267 scenes.scene.id = 0;
268 scenes.desc.pins = PIN_OUT_SPEAKER;
269
270 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
271 ASSERT_EQ(HDF_SUCCESS, ret);
272
273 ret = render->scene.SelectScene(render, &scenes);
274 EXPECT_EQ(HDF_SUCCESS, ret);
275
276 ret = AudioRenderStartAndOneFrame(render);
277 EXPECT_EQ(HDF_SUCCESS, ret);
278
279 ret = render->control.Stop((AudioHandle)render);
280 adapter->DestroyRender(adapter, render);
281 manager.UnloadAdapter(&manager, adapter);
282 }
283 /**
284 * @tc.name Test AudioRenderSelectScene API after Render start.
285 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0002
286 * @tc.desc Test AudioRenderSelectScene, return 0 if select Render's scene successful after Render start.
287 * @tc.author: ZHANGHAILIN
288 */
289 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0002, TestSize.Level1)
290 {
291 int32_t ret = -1;
292 struct AudioSceneDescriptor scenes = {};
293 TestAudioManager manager = {};
294 struct AudioAdapter *adapter =nullptr;
295 struct AudioRender *render = nullptr;
296 ASSERT_NE(nullptr, GetAudioManager);
297 manager = *GetAudioManager();
298 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
299 ASSERT_EQ(HDF_SUCCESS, ret);
300
301 scenes.scene.id = 0;
302 scenes.desc.pins = PIN_OUT_SPEAKER;
303 ret = render->scene.SelectScene(render, &scenes);
304 EXPECT_EQ(HDF_SUCCESS, ret);
305
306 ret = render->control.Stop((AudioHandle)render);
307 adapter->DestroyRender(adapter, render);
308 manager.UnloadAdapter(&manager, adapter);
309 }
310 /**
311 * @tc.name Test AudioRenderSelectScene API where the parameter handle is empty.
312 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0003
313 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter handle is empty.
314 * @tc.author: ZHANGHAILIN
315 */
316 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0003, TestSize.Level1)
317 {
318 int32_t ret = -1;
319 struct AudioSceneDescriptor scenes = {};
320 struct AudioAdapter *adapter = nullptr;
321 struct AudioRender *render = nullptr;
322 struct AudioRender *renderNull = nullptr;
323 ASSERT_NE(nullptr, GetAudioManager);
324 TestAudioManager manager = *GetAudioManager();
325 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
326 ASSERT_EQ(HDF_SUCCESS, ret);
327
328 scenes.scene.id = 0;
329 scenes.desc.pins = PIN_IN_MIC;
330 ret = render->scene.SelectScene(renderNull, &scenes);
331 EXPECT_EQ(HDF_FAILURE, ret);
332
333 adapter->DestroyRender(adapter, render);
334 manager.UnloadAdapter(&manager, adapter);
335 }
336 /**
337 * @tc.name Test AudioRenderSelectScene API where the parameter scene is empty.
338 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0004
339 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter scene is empty.
340 * @tc.author: ZHANGHAILIN
341 */
342 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0004, TestSize.Level1)
343 {
344 int32_t ret = -1;
345 struct AudioSceneDescriptor *scenes = nullptr;
346 struct AudioAdapter *adapter = nullptr;
347 struct AudioRender *render = nullptr;
348 ASSERT_NE(nullptr, GetAudioManager);
349 TestAudioManager manager = *GetAudioManager();
350 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
351 ASSERT_EQ(HDF_SUCCESS, ret);
352
353 ret = render->scene.SelectScene(render, scenes);
354 EXPECT_EQ(HDF_FAILURE, ret);
355
356 adapter->DestroyRender(adapter, render);
357 manager.UnloadAdapter(&manager, adapter);
358 }
359 /**
360 * @tc.name Test AudioRenderSelectScene API where the scene is not configed in the josn.
361 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0005
362 * @tc.desc Test AudioRenderSelectScene, return -1 if the scene is not configed in the josn.
363 * @tc.author: ZHANGHAILIN
364 */
365 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0005, TestSize.Level1)
366 {
367 int32_t ret = -1;
368 struct AudioSceneDescriptor scenes = {};
369 struct AudioAdapter *adapter = nullptr;
370 struct AudioRender *render = nullptr;
371 ASSERT_NE(nullptr, GetAudioManager);
372 TestAudioManager manager = *GetAudioManager();
373 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
374 ASSERT_EQ(HDF_SUCCESS, ret);
375
376 scenes.scene.id = 5;
377 scenes.desc.pins = PIN_OUT_HDMI;
378 ret = render->scene.SelectScene(render, &scenes);
379 EXPECT_EQ(HDF_FAILURE, ret);
380
381 adapter->DestroyRender(adapter, render);
382 manager.UnloadAdapter(&manager, adapter);
383 }
384 }