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 "audio_lib_common.h"
17 #include "audio_librender_hardwaredependence_test.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 const string BIND_CONTROL = "control";
25 const string BIND_RENDER = "render";
26 #ifdef PRODUCT_RK3568
27 const string PATH_SWITCH_ORDER = "Headphone1 Switch";
28 constexpr int MAX_VOLUME = 255;
29 constexpr int MIN_VOLUME = 0;
30 constexpr int BELOW_MAX_VOLUME = 254;
31 constexpr int OVER_MIN_VOLUME = 1;
32 #else
33 const string PATH_SWITCH_ORDER = "Dacl enable";
34 constexpr int MAX_VOLUME = 127;
35 constexpr int MIN_VOLUME = 40;
36 constexpr int BELOW_MAX_VOLUME = 126;
37 constexpr int OVER_MIN_VOLUME = 41;
38 #endif
39 constexpr float MAX_GAIN = 15;
40 constexpr float MIN_GAIN = 0;
41 class AudioLibRenderHardwareDependenceTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 static struct DevHandle *(*BindServiceRenderSo)(const char *serverName);
48 static int32_t (*InterfaceLibOutputRender)(struct DevHandle *handle,
49 int cmdId, struct AudioHwRenderParam *handleData);
50 static int32_t (*InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
51 static void (*CloseServiceRenderSo)(struct DevHandle *handle);
52 static void *ptrHandle;
53 int32_t LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const;
54 int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender,
55 const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const;
56 };
57
58 struct DevHandle *(*AudioLibRenderHardwareDependenceTest::BindServiceRenderSo)(const char *serverName) = nullptr;
59 int32_t (*AudioLibRenderHardwareDependenceTest::InterfaceLibOutputRender)(struct DevHandle *handle, int cmdId,
60 struct AudioHwRenderParam *handleData) = nullptr;
61 int32_t (*AudioLibRenderHardwareDependenceTest::InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId,
62 struct AudioHwRenderParam *handleData) = nullptr;
63 void (*AudioLibRenderHardwareDependenceTest::CloseServiceRenderSo)(struct DevHandle *handle) = nullptr;
64 void *AudioLibRenderHardwareDependenceTest::ptrHandle = nullptr;
65
SetUpTestCase(void)66 void AudioLibRenderHardwareDependenceTest::SetUpTestCase(void)
67 {
68 char resolvedPath[] = HDF_LIBRARY_FULL_PATH("libaudio_render_adapter");
69 ptrHandle = dlopen(resolvedPath, RTLD_LAZY);
70 if (ptrHandle == nullptr) {
71 return;
72 }
73 BindServiceRenderSo = reinterpret_cast<struct DevHandle* (*)(const char *serverName)>(
74 dlsym(ptrHandle, "AudioBindServiceRender"));
75 InterfaceLibOutputRender = reinterpret_cast<int32_t (*)(struct DevHandle *handle, int cmdId,
76 struct AudioHwRenderParam *handleData)>(dlsym(ptrHandle, "AudioInterfaceLibOutputRender"));
77 InterfaceLibCtlRender = reinterpret_cast<int32_t (*)(struct DevHandle *handle, int cmdId,
78 struct AudioHwRenderParam *handleData)>(dlsym(ptrHandle, "AudioInterfaceLibCtlRender"));
79 CloseServiceRenderSo = reinterpret_cast<void (*)(struct DevHandle *handle)>(
80 dlsym(ptrHandle, "AudioCloseServiceRender"));
81 if (BindServiceRenderSo == nullptr || CloseServiceRenderSo == nullptr ||
82 InterfaceLibCtlRender == nullptr || InterfaceLibOutputRender == nullptr) {
83 dlclose(ptrHandle);
84 return;
85 }
86 }
87
TearDownTestCase(void)88 void AudioLibRenderHardwareDependenceTest::TearDownTestCase(void)
89 {
90 if (BindServiceRenderSo != nullptr) {
91 BindServiceRenderSo = nullptr;
92 }
93 if (CloseServiceRenderSo != nullptr) {
94 CloseServiceRenderSo = nullptr;
95 }
96 if (InterfaceLibOutputRender != nullptr) {
97 InterfaceLibOutputRender = nullptr;
98 }
99 if (InterfaceLibCtlRender != nullptr) {
100 InterfaceLibCtlRender = nullptr;
101 }
102 if (ptrHandle != nullptr) {
103 dlclose(ptrHandle);
104 ptrHandle = nullptr;
105 }
106 }
107
SetUp(void)108 void AudioLibRenderHardwareDependenceTest::SetUp(void) {}
109
TearDown(void)110 void AudioLibRenderHardwareDependenceTest::TearDown(void) {}
111
LibHwOutputRender(struct AudioHwRender * hwRender,struct DevHandle * handlerender) const112 int32_t AudioLibRenderHardwareDependenceTest::LibHwOutputRender(struct AudioHwRender *hwRender,
113 struct DevHandle *handlerender) const
114 {
115 if (hwRender == nullptr || handlerender == nullptr) {
116 return HDF_FAILURE;
117 }
118 if (InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam) ||
119 InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) ||
120 InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) ||
121 InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) {
122 return HDF_FAILURE;
123 }
124 return HDF_SUCCESS;
125 }
126
BindServiceAndHwRender(struct AudioHwRender * & hwRender,const std::string BindName,const std::string adapterNameCase,struct DevHandle * & handle) const127 int32_t AudioLibRenderHardwareDependenceTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender,
128 const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const
129 {
130 int32_t ret = HDF_FAILURE;
131 handle = BindServiceRenderSo(BindName.c_str());
132 if (handle == nullptr) {
133 return HDF_FAILURE;
134 }
135 hwRender = static_cast<struct AudioHwRender *>(calloc(1, sizeof(*hwRender)));
136 if (hwRender == nullptr) {
137 CloseServiceRenderSo(handle);
138 return HDF_FAILURE;
139 }
140 ret = InitHwRender(hwRender, adapterNameCase);
141 if (ret != HDF_SUCCESS) {
142 CloseServiceRenderSo(handle);
143 free(hwRender);
144 hwRender = nullptr;
145 return HDF_FAILURE;
146 }
147 return HDF_SUCCESS;
148 }
149 /**
150 * @tc.name AudioInterfaceLibCtlRenderVolumeWriteRead_001
151 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
152 * @tc.type: FUNC
153 */
154 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderVolumeWriteRead_001, TestSize.Level1)
155 {
156 int32_t ret = HDF_FAILURE;
157 float volumeValue = 0;
158 float volumeThresholdValueMaxIn = 0;
159 float volumeThresholdValueMinIn = 0;
160 float volumeBoundaryValueIn = 127.9;
161 struct DevHandle *handle = nullptr;
162 struct AudioHwRender *hwRender = nullptr;
163 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
164 ASSERT_EQ(HDF_SUCCESS, ret);
165
166 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
167 EXPECT_EQ(HDF_SUCCESS, ret);
168 volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
169 volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
170
171 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn - 1;
172 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
173 EXPECT_EQ(HDF_SUCCESS, ret);
174 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
175 EXPECT_EQ(HDF_SUCCESS, ret);
176 volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
177 EXPECT_EQ(BELOW_MAX_VOLUME, volumeValue);
178
179 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn + 1;
180 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
181 EXPECT_EQ(HDF_SUCCESS, ret);
182 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
183 EXPECT_EQ(HDF_SUCCESS, ret);
184 volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
185 EXPECT_EQ(OVER_MIN_VOLUME, volumeValue);
186 hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValueIn;
187 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
188 EXPECT_EQ(HDF_SUCCESS, ret);
189 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
190 EXPECT_EQ(HDF_SUCCESS, ret);
191 volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
192 EXPECT_EQ(static_cast<int>(volumeBoundaryValueIn), volumeValue);
193 CloseServiceRenderSo(handle);
194 free(hwRender);
195 hwRender = nullptr;
196 }
197 /**
198 * @tc.name AudioInterfaceLibCtlRenderVolumeWriteRead_002
199 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
200 * @tc.type: FUNC
201 */
202 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderVolumeWriteRead_002, TestSize.Level1)
203 {
204 int32_t ret = HDF_FAILURE;
205 struct AudioHwRender *hwRender = nullptr;
206 struct DevHandle *handle = nullptr;
207 float volumeThresholdValueMaxIn = 0;
208 float volumeThresholdValueMinIn = 0;
209 float volumeValue = 0;
210 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
211 ASSERT_EQ(HDF_SUCCESS, ret);
212
213 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
214 EXPECT_EQ(HDF_SUCCESS, ret);
215 volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
216 volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
217
218 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn;
219 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
220 EXPECT_EQ(HDF_SUCCESS, ret);
221 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
222 EXPECT_EQ(HDF_SUCCESS, ret);
223 volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
224 EXPECT_EQ(MIN_VOLUME, volumeValue);
225
226 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn;
227 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
228 EXPECT_EQ(HDF_SUCCESS, ret);
229 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
230 EXPECT_EQ(HDF_SUCCESS, ret);
231 volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
232 EXPECT_EQ(MAX_VOLUME, volumeValue);
233
234 CloseServiceRenderSo(handle);
235 free(hwRender);
236 hwRender = nullptr;
237 }
238 /**
239 * @tc.name AudioInterfaceLibCtlRenderVolumeWriteRead_003
240 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
241 * @tc.type: FUNC
242 */
243 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderVolumeWriteRead_003, TestSize.Level1)
244 {
245 int32_t ret = HDF_FAILURE;
246 struct DevHandle *handle = nullptr;
247 struct AudioHwRender *hwRender = nullptr;
248 float volumeThresholdValueMaxIn = 0;
249 float volumeThresholdValueMinIn = 0;
250
251 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
252 ASSERT_EQ(HDF_SUCCESS, ret);
253
254 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
255 EXPECT_EQ(HDF_SUCCESS, ret);
256 volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
257 volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
258
259 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn + 1;
260 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
261 EXPECT_EQ(HDF_FAILURE, ret);
262
263 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn - 1;
264 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
265 EXPECT_EQ(HDF_FAILURE, ret);
266
267 CloseServiceRenderSo(handle);
268 free(hwRender);
269 hwRender = nullptr;
270 }
271
272 /**
273 * @tc.name AudioInterfaceLibCtlRenderGetVolthresholdRead_002
274 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ.
275 * @tc.type: FUNC
276 */
277 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGetVolthresholdRead_002, TestSize.Level1)
278 {
279 int32_t ret = HDF_FAILURE;
280 float volumeThresholdValueMaxIn = 0;
281 float volumeThresholdValueMinIn = 0;
282 struct AudioHwRender *hwRender = nullptr;
283 struct DevHandle *handle = nullptr;
284 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
285 ASSERT_EQ(HDF_SUCCESS, ret);
286
287 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
288 EXPECT_EQ(HDF_SUCCESS, ret);
289 volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
290 volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
291 EXPECT_EQ(MAX_VOLUME, volumeThresholdValueMaxIn);
292 EXPECT_EQ(MIN_VOLUME, volumeThresholdValueMinIn);
293 CloseServiceRenderSo(handle);
294 free(hwRender);
295 hwRender = nullptr;
296 }
297 /**
298 * @tc.name AudioInterfaceLibCtlRenderChannelModeWriteRead_001
299 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE
300 * and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderChannelModeWriteRead_001,
304 TestSize.Level1)
305 {
306 int32_t ret = HDF_FAILURE;
307 float channelModeExc = 1;
308 struct DevHandle *handle = nullptr;
309 struct DevHandle *handleRender = nullptr;
310 struct AudioHwRender *impl = nullptr;
311 ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
312 ASSERT_EQ(HDF_SUCCESS, ret);
313 handleRender = BindServiceRenderSo(BIND_RENDER.c_str());
314 if (handleRender == nullptr) {
315 CloseServiceRenderSo(handle);
316 free(impl);
317 impl = nullptr;
318 ASSERT_NE(nullptr, handleRender);
319 }
320 ret = LibHwOutputRender(impl, handleRender);
321 EXPECT_EQ(HDF_SUCCESS, ret);
322 if (impl != nullptr) {
323 impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_RIGHT;
324 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
325 EXPECT_EQ(HDF_SUCCESS, ret);
326 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
327 EXPECT_EQ(HDF_SUCCESS, ret);
328 channelModeExc = impl->renderParam.frameRenderMode.mode;
329 EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, channelModeExc);
330
331 impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_RIGHT_MUTE;
332 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
333 #ifdef PRODUCT_RK3568
334 EXPECT_EQ(HDF_FAILURE, ret);
335 #else
336 EXPECT_EQ(HDF_SUCCESS, ret);
337 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
338 EXPECT_EQ(HDF_SUCCESS, ret);
339 channelModeExc = impl->renderParam.frameRenderMode.mode;
340 EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, channelModeExc);
341 #endif
342 }
343 CloseServiceRenderSo(handleRender);
344 CloseServiceRenderSo(handle);
345 free(impl);
346 impl = nullptr;
347 }
348 /**
349 * @tc.name AudioInterfaceLibCtlRenderChannelModeWriteRead_002
350 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE
351 * and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ.
352 * @tc.type: FUNC
353 */
354 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderChannelModeWriteRead_002,
355 TestSize.Level1)
356 {
357 int32_t ret = HDF_FAILURE;
358 float channelModeExc = 1;
359 struct DevHandle *handleRender = nullptr;
360 struct DevHandle *handle = nullptr;
361 struct AudioHwRender *impl = nullptr;
362 ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
363 ASSERT_EQ(HDF_SUCCESS, ret);
364 handleRender = BindServiceRenderSo(BIND_RENDER.c_str());
365 if (handleRender == nullptr) {
366 free(impl);
367 impl = nullptr;
368 CloseServiceRenderSo(handle);
369 ASSERT_NE(nullptr, handleRender);
370 }
371 ret = LibHwOutputRender(impl, handleRender);
372 EXPECT_EQ(HDF_SUCCESS, ret);
373 if (impl != nullptr) {
374 impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_MUTE;
375 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
376 #ifdef PRODUCT_RK3568
377 EXPECT_EQ(HDF_FAILURE, ret);
378 #else
379 EXPECT_EQ(HDF_SUCCESS, ret);
380 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
381 EXPECT_EQ(HDF_SUCCESS, ret);
382 channelModeExc = impl->renderParam.frameRenderMode.mode;
383 EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, channelModeExc);
384 #endif
385 impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_NORMAL;
386 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
387 EXPECT_EQ(HDF_SUCCESS, ret);
388 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
389 EXPECT_EQ(HDF_SUCCESS, ret);
390 channelModeExc = impl->renderParam.frameRenderMode.mode;
391 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, channelModeExc);
392 }
393 CloseServiceRenderSo(handleRender);
394 CloseServiceRenderSo(handle);
395 free(impl);
396 impl = nullptr;
397 }
398 /**
399 * @tc.name AudioInterfaceLibCtlRenderSelectScene_001
400 * @tc.desc test InterfaceLibCtlRender,cmdId is AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE.
401 * @tc.type: FUNC
402 */
403 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderSelectScene_001, TestSize.Level1)
404 {
405 int32_t ret = HDF_FAILURE;
406 struct DevHandle *handle = nullptr;
407 struct AudioHwRender *hwRender = nullptr;
408 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
409 ASSERT_EQ(HDF_SUCCESS, ret);
410
411 struct AudioSceneDescriptor scene = {
412 .scene.id = 0,
413 .desc.pins = PIN_OUT_HEADSET,
414 };
415 hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = 1;
416 ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].deviceSwitch,
417 PATHPLAN_COUNT, PATH_SWITCH_ORDER.c_str());
418 hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].value = 0;
419 hwRender->renderParam.frameRenderMode.attrs.type = (enum AudioCategory)(scene.scene.id);
420 hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = scene.desc.pins;
421
422 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, &hwRender->renderParam);
423 EXPECT_EQ(HDF_SUCCESS, ret);
424
425 CloseServiceRenderSo(handle);
426 free(hwRender);
427 hwRender = nullptr;
428 }
429 /**
430 * @tc.name AudioInterfaceLibCtlRenderGainWriteRead_001
431 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
432 * @tc.type: FUNC
433 */
434 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGainWriteRead_001, TestSize.Level1)
435 {
436 int32_t ret = HDF_FAILURE;
437 struct AudioHwRender *hwRender = nullptr;
438 struct DevHandle *handle = nullptr;
439 float gainValue = 0;
440 float gainThresholdValueMax, gainThresholdValueMin;
441 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
442 ASSERT_EQ(HDF_SUCCESS, ret);
443
444 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
445 EXPECT_EQ(HDF_SUCCESS, ret);
446 gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
447 gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
448 ret = InitHwRenderMode(hwRender->renderParam.renderMode);
449 EXPECT_EQ(HDF_SUCCESS, ret);
450
451 hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax - 1;
452 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
453 EXPECT_EQ(HDF_SUCCESS, ret);
454 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
455 EXPECT_EQ(HDF_SUCCESS, ret);
456 gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
457 EXPECT_EQ(gainThresholdValueMax - 1, gainValue);
458 hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin + 1;
459 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
460 EXPECT_EQ(HDF_SUCCESS, ret);
461 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
462 EXPECT_EQ(HDF_SUCCESS, ret);
463 gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
464 EXPECT_EQ(gainThresholdValueMin + 1, gainValue);
465 hwRender->renderParam.renderMode.ctlParam.audioGain.gain = 2.3;
466 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
467 EXPECT_EQ(HDF_SUCCESS, ret);
468 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
469 EXPECT_EQ(HDF_SUCCESS, ret);
470 gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
471 EXPECT_EQ(2, gainValue);
472 CloseServiceRenderSo(handle);
473 free(hwRender);
474 hwRender = nullptr;
475 }
476 /**
477 * @tc.name AudioInterfaceLibCtlRenderGainWriteRead_002
478 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
479 * @tc.type: FUNC
480 */
481 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGainWriteRead_002, TestSize.Level1)
482 {
483 int32_t ret = HDF_FAILURE;
484 float gainValue = 0;
485 float gainThresholdValueMax, gainThresholdValueMin;
486 struct DevHandle *handle = nullptr;
487 struct AudioHwRender *hwRender = nullptr;
488 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
489 ASSERT_EQ(HDF_SUCCESS, ret);
490
491 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
492 EXPECT_EQ(HDF_SUCCESS, ret);
493 gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
494 gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
495 ret = InitHwRenderMode(hwRender->renderParam.renderMode);
496 EXPECT_EQ(HDF_SUCCESS, ret);
497 hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin;
498 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
499 EXPECT_EQ(HDF_SUCCESS, ret);
500 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
501 EXPECT_EQ(HDF_SUCCESS, ret);
502 gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
503 EXPECT_EQ(gainThresholdValueMin, gainValue);
504 hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax;
505 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
506 EXPECT_EQ(HDF_SUCCESS, ret);
507 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
508 EXPECT_EQ(HDF_SUCCESS, ret);
509 gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
510 EXPECT_EQ(gainThresholdValueMax, gainValue);
511 CloseServiceRenderSo(handle);
512 free(hwRender);
513 hwRender = nullptr;
514 }
515 /**
516 * @tc.name AudioInterfaceLibCtlRenderGainWriteRead_003
517 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
518 * @tc.type: FUNC
519 */
520 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGainWriteRead_003, TestSize.Level1)
521 {
522 int32_t ret = HDF_FAILURE;
523 float gainThresholdValueMax, gainThresholdValueMin;
524 struct AudioHwRender *hwRender = nullptr;
525 struct DevHandle *handle = nullptr;
526 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
527 ASSERT_EQ(HDF_SUCCESS, ret);
528
529 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
530 EXPECT_EQ(HDF_SUCCESS, ret);
531 gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
532 gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
533 ret = InitHwRenderMode(hwRender->renderParam.renderMode);
534 EXPECT_EQ(HDF_SUCCESS, ret);
535 hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax + 1;
536 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
537 EXPECT_EQ(HDF_FAILURE, ret);
538 hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin - 1;
539 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
540 EXPECT_EQ(HDF_FAILURE, ret);
541 CloseServiceRenderSo(handle);
542 free(hwRender);
543 hwRender = nullptr;
544 }
545 /**
546 * @tc.name AudioInterfaceLibCtlRenderGetGainthresholdRead_001
547 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ.
548 * @tc.type: FUNC
549 */
550 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGetGainthresholdRead_001,
551 TestSize.Level1)
552 {
553 int32_t ret = HDF_FAILURE;
554 float gainThresholdValueMaxGet, gainThresholdValueMinGet;
555 struct DevHandle *handle = nullptr;
556 struct AudioHwRender *hwRender = nullptr;
557 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
558 ASSERT_EQ(HDF_SUCCESS, ret);
559
560 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
561 EXPECT_EQ(HDF_SUCCESS, ret);
562 gainThresholdValueMaxGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
563 gainThresholdValueMinGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
564 EXPECT_EQ(MAX_GAIN, gainThresholdValueMaxGet);
565 EXPECT_EQ(MIN_GAIN, gainThresholdValueMinGet);
566 CloseServiceRenderSo(handle);
567 free(hwRender);
568 hwRender = nullptr;
569 }
570 }
571