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 #include "audio_lib_common.h"
17 #include "audio_smartpa_test.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace HMOS::Audio;
22
23 namespace {
24 const string ADAPTER_NAME_HDMI = "hdmi";
25 const string ADAPTER_NAME_USB = "usb";
26 const string ADAPTER_NAME_INTERNAL = "internal";
27 const string BIND_CONTROL = "control";
28 const string BIND_RENDER = "render";
29 const string BIND_NAME_ERROR = "rendeo";
30
31 class AudioSmartPaTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 static TestAudioManager *(*GetAudioManager)();
38 static void *handleSo;
39 static struct DevHandle *(*BindServiceRenderSo)(const char *);
40 static int32_t (*InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *);
41 static int32_t (*InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *);
42 static void (*CloseServiceRenderSo)(struct DevHandle *);
43 static void *PtrHandle;
44 static int32_t GetManager(struct PrepareAudioPara& audiopara);
45 int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender, const std::string BindName,
46 const std::string adapterNameCase, struct DevHandle *&handle) const;
47 };
48
49 TestAudioManager *(*AudioSmartPaTest::GetAudioManager)() = nullptr;
50 void *AudioSmartPaTest::handleSo = nullptr;
51 struct DevHandle *(*AudioSmartPaTest::BindServiceRenderSo)(const char *) = nullptr;
52 int32_t (*AudioSmartPaTest::InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr;
53 int32_t (*AudioSmartPaTest::InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr;
54 void (*AudioSmartPaTest::CloseServiceRenderSo)(struct DevHandle *) = nullptr;
55 void *AudioSmartPaTest::PtrHandle = nullptr;
56 using THREAD_FUNC = void *(*)(void *);
57
SetUpTestCase(void)58 void AudioSmartPaTest::SetUpTestCase(void)
59 {
60 char absPath[PATH_MAX] = {0};
61 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
62 return;
63 }
64 handleSo = dlopen(absPath, RTLD_LAZY);
65 if (handleSo == nullptr) {
66 return;
67 }
68 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
69 if (GetAudioManager == nullptr) {
70 return;
71 }
72 string resolvedPathOne = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
73 PtrHandle = dlopen(resolvedPathOne.c_str(), RTLD_LAZY);
74 if (PtrHandle == nullptr) {
75 return;
76 }
77 BindServiceRenderSo = (struct DevHandle* (*)(const char *))dlsym(PtrHandle, "AudioBindServiceRender");
78 InterfaceLibOutputRender = (int32_t (*)(struct DevHandle *, int,
79 struct AudioHwRenderParam *))dlsym(PtrHandle, "AudioInterfaceLibOutputRender");
80 InterfaceLibCtlRender = (int32_t (*)(struct DevHandle *, int,
81 struct AudioHwRenderParam *))dlsym(PtrHandle, "AudioInterfaceLibCtlRender");
82 CloseServiceRenderSo = (void (*)(struct DevHandle *))dlsym(PtrHandle, "AudioCloseServiceRender");
83 if (BindServiceRenderSo == nullptr || CloseServiceRenderSo == nullptr ||
84 InterfaceLibCtlRender == nullptr || InterfaceLibOutputRender == nullptr) {
85 dlclose(PtrHandle);
86 return;
87 }
88 }
89
TearDownTestCase(void)90 void AudioSmartPaTest::TearDownTestCase(void)
91 {
92 if (handleSo != nullptr) {
93 dlclose(handleSo);
94 handleSo = nullptr;
95 }
96 if (GetAudioManager != nullptr) {
97 GetAudioManager = nullptr;
98 }
99 if (PtrHandle != nullptr) {
100 dlclose(PtrHandle);
101 PtrHandle = nullptr;
102 }
103 if (BindServiceRenderSo != nullptr) {
104 BindServiceRenderSo = nullptr;
105 }
106 if (CloseServiceRenderSo != nullptr) {
107 CloseServiceRenderSo = nullptr;
108 }
109 if (InterfaceLibOutputRender != nullptr) {
110 InterfaceLibOutputRender = nullptr;
111 }
112 if (InterfaceLibCtlRender != nullptr) {
113 InterfaceLibCtlRender = nullptr;
114 }
115 }
116
SetUp(void)117 void AudioSmartPaTest::SetUp(void) {}
118
TearDown(void)119 void AudioSmartPaTest::TearDown(void) {}
120
GetManager(struct PrepareAudioPara & audiopara)121 int32_t AudioSmartPaTest::GetManager(struct PrepareAudioPara& audiopara)
122 {
123 auto *inst = (AudioSmartPaTest *)audiopara.self;
124 if (inst != nullptr && inst->GetAudioManager != nullptr) {
125 audiopara.manager = inst->GetAudioManager();
126 }
127 if (audiopara.manager == nullptr) {
128 return HDF_FAILURE;
129 }
130 return HDF_SUCCESS;
131 }
132
BindServiceAndHwRender(struct AudioHwRender * & hwRender,const std::string BindName,const std::string adapterNameCase,struct DevHandle * & handle) const133 int32_t AudioSmartPaTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender,
134 const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const
135 {
136 handle = BindServiceRenderSo(BindName.c_str());
137 if (handle == nullptr) {
138 return HDF_FAILURE;
139 }
140 hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender));
141 if (hwRender == nullptr) {
142 CloseServiceRenderSo(handle);
143 return HDF_FAILURE;
144 }
145 if (InitHwRender(hwRender, adapterNameCase)) {
146 CloseServiceRenderSo(handle);
147 free(hwRender);
148 hwRender = nullptr;
149 return HDF_FAILURE;
150 }
151 return HDF_SUCCESS;
152 }
153 /**
154 * @tc.name Pause,Flush,Resume and Stop when playing audio file based smartPA
155 * @tc.number SUB_Audio_Function_Smartpa_Test_0001
156 * @tc.desc test Render interface by playing an audio file based smartPA successfully.
157 * @tc.author: wangkang
158 */
159 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0001, TestSize.Level1)
160 {
161 int32_t ret = -1;
162 struct PrepareAudioPara audiopara = {
163 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
164 .path = AUDIO_FILE.c_str()
165 };
166 uint32_t latencyTime = 0;
167 uint32_t expectedValue = 0;
168
169 ret = GetManager(audiopara);
170 ASSERT_EQ(HDF_SUCCESS, ret);
171
172 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
173 ASSERT_EQ(HDF_SUCCESS, ret);
174 sleep(1);
175 if (audiopara.render != nullptr) {
176 ret = audiopara.render->GetLatency(audiopara.render, &latencyTime);
177 EXPECT_EQ(HDF_SUCCESS, ret);
178 EXPECT_LT(expectedValue, latencyTime);
179 FrameStatus(0);
180 usleep(1000);
181 ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render));
182 EXPECT_EQ(HDF_SUCCESS, ret);
183 ret = audiopara.render->control.Flush((AudioHandle)audiopara.render);
184 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
185 sleep(1);
186 ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render));
187 EXPECT_EQ(HDF_SUCCESS, ret);
188 FrameStatus(1);
189 }
190 ret = ThreadRelease(audiopara);
191 EXPECT_EQ(HDF_SUCCESS, ret);
192 }
193 /**
194 * @tc.name Setting audio file volume based smartPA
195 * @tc.number SUB_Audio_Function_Smartpa_Test_0002
196 * @tc.desc test Render function,set volume when playing audio file based smartPA.
197 * @tc.author: wangkang
198 */
199 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0002, TestSize.Level1)
200 {
201 int32_t ret = -1;
202 float volumeMax = 1.0;
203 struct PrepareAudioPara audiopara = {
204 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
205 .path = AUDIO_FILE.c_str()
206 };
207 float volumeValue[10] = {0};
208 float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
209
210 ret = GetManager(audiopara);
211 ASSERT_EQ(HDF_SUCCESS, ret);
212
213 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
214 ASSERT_EQ(HDF_SUCCESS, ret);
215 sleep(1);
216 if (audiopara.render != nullptr) {
217 ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax);
218 for (int i = 0; i < 10; i++) {
219 ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]);
220 EXPECT_EQ(HDF_SUCCESS, ret);
221 ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]);
222 EXPECT_EQ(HDF_SUCCESS, ret);
223 EXPECT_EQ(volumeArr[i], volumeValue[i]);
224 usleep(30000);
225 }
226 }
227 ret = ThreadRelease(audiopara);
228 EXPECT_EQ(HDF_SUCCESS, ret);
229 }
230 /**
231 * @tc.name SetMute audio files when playing audio file based smartPA
232 * @tc.number SUB_Audio_Function_Smartpa_Test_0003
233 * @tc.desc test render function by SetMute and GetMute when playing audio file based smartPA.
234 * @tc.author: wangkang
235 */
236 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0003, TestSize.Level1)
237 {
238 int32_t ret = -1;
239 struct PrepareAudioPara audiopara = {
240 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
241 .path = AUDIO_FILE.c_str()
242 };
243
244 ret = GetManager(audiopara);
245 ASSERT_EQ(HDF_SUCCESS, ret);
246
247 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
248 ASSERT_EQ(HDF_SUCCESS, ret);
249 sleep(1);
250 bool muteTrue = true;
251 bool muteFalse = false;
252 if (audiopara.render != nullptr) {
253 ret = audiopara.render->volume.SetMute(audiopara.render, muteTrue);
254 EXPECT_EQ(HDF_SUCCESS, ret);
255 ret = audiopara.render->volume.GetMute(audiopara.render, &muteTrue);
256 EXPECT_EQ(HDF_SUCCESS, ret);
257 EXPECT_EQ(true, muteTrue);
258 sleep(1);
259 ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse);
260 EXPECT_EQ(HDF_SUCCESS, ret);
261 ret = audiopara.render->volume.GetMute(audiopara.render, &muteFalse);
262 EXPECT_EQ(HDF_SUCCESS, ret);
263 EXPECT_EQ(false, muteFalse);
264 }
265 ret = ThreadRelease(audiopara);
266 EXPECT_EQ(HDF_SUCCESS, ret);
267 }
268 /**
269 * @tc.name Get render position when playing audio file based smartPA
270 * @tc.number SUB_Audio_Function_Smartpa_Test_0004
271 * @tc.desc test render function by Get render position when playing audio file based smartPA.
272 * @tc.author: wangkang
273 */
274 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0004, TestSize.Level1)
275 {
276 int32_t ret = -1;
277 struct PrepareAudioPara audiopara = {
278 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
279 .path = AUDIO_FILE.c_str()
280 };
281 uint64_t frames = 0;
282 int64_t timeExp = 0;
283 struct AudioTimeStamp time = {.tvSec = 0};
284
285 ret = GetManager(audiopara);
286 ASSERT_EQ(HDF_SUCCESS, ret);
287
288 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
289 ASSERT_EQ(HDF_SUCCESS, ret);
290 sleep(2);
291 if (audiopara.render != nullptr) {
292 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
293 EXPECT_EQ(HDF_SUCCESS, ret);
294 EXPECT_GT(time.tvSec, timeExp);
295 EXPECT_GT(frames, INITIAL_VALUE);
296 }
297 ret = ThreadRelease(audiopara);
298 EXPECT_EQ(HDF_SUCCESS, ret);
299 }
300 /**
301 * @tc.name Get frame count and size when playing audio file based smartPA
302 * @tc.number SUB_Audio_Function_Smartpa_Test_0005
303 * @tc.desc test render function by Get frame count and size when playing audio file based smartPA.
304 * @tc.author: wangkang
305 */
306 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0005, TestSize.Level1)
307 {
308 int32_t ret = -1;
309 struct PrepareAudioPara audiopara = {
310 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
311 .path = AUDIO_FILE.c_str()
312 };
313 uint64_t size = 0;
314 uint64_t count = 0;
315 uint64_t zero = 0;
316 uint64_t sizeExpect = 0;
317
318 ret = GetManager(audiopara);
319 ASSERT_EQ(HDF_SUCCESS, ret);
320
321 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
322 ASSERT_EQ(HDF_SUCCESS, ret);
323 sleep(1);
324 if (audiopara.render != nullptr) {
325 ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size);
326 EXPECT_EQ(HDF_SUCCESS, ret);
327 sizeExpect = PcmFramesToBytes(audiopara.attrs);
328 EXPECT_EQ(size, sizeExpect);
329
330 ret = audiopara.render->attr.GetFrameCount(audiopara.render, &count);
331 EXPECT_EQ(HDF_SUCCESS, ret);
332 EXPECT_GT(count, zero);
333 }
334 ret = ThreadRelease(audiopara);
335 EXPECT_EQ(HDF_SUCCESS, ret);
336 }
337 /**
338 * @tc.name SetSampleAttributes when playing audio file based smartPA
339 * @tc.number SUB_Audio_Function_Smartpa_Test_0006
340 * @tc.desc test render function by SetSampleAttributes when playing audio file based smartPA.
341 * @tc.author: wangkang
342 */
343 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0006, TestSize.Level1)
344 {
345 struct PrepareAudioPara audiopara = {
346 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
347 .path = AUDIO_FILE.c_str()
348 };
349 int32_t ret = -1;
350 uint32_t samplerateValue = 48000;
351 uint32_t channelcountValue = 1;
352 struct AudioSampleAttributes attrsValue = {};
353
354 ret = GetManager(audiopara);
355 ASSERT_EQ(HDF_SUCCESS, ret);
356
357 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
358 ASSERT_EQ(HDF_SUCCESS, ret);
359
360 sleep(1);
361 if (audiopara.render != nullptr) {
362 audiopara.attrs.type = AUDIO_IN_MEDIA;
363 audiopara.attrs.format = AUDIO_FORMAT_PCM_16_BIT;
364 audiopara.attrs.sampleRate = 48000;
365 audiopara.attrs.channelCount = 1;
366 audiopara.attrs.stopThreshold = INT_32_MAX;
367 audiopara.attrs.period = 4096;
368
369 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
370 EXPECT_EQ(HDF_SUCCESS, ret);
371 ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &attrsValue);
372 EXPECT_EQ(HDF_SUCCESS, ret);
373
374 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
375 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
376 EXPECT_EQ(samplerateValue, attrsValue.sampleRate);
377 EXPECT_EQ(channelcountValue, attrsValue.channelCount);
378 EXPECT_EQ(INT_32_MAX, attrsValue.stopThreshold);
379 }
380 ret = ThreadRelease(audiopara);
381 EXPECT_EQ(HDF_SUCCESS, ret);
382 }
383 /**
384 * @tc.name test InterfaceLibCtlRender API via writing GetVolthreshold value that
385 * Hardware equipment of Acodec_ChangeOut.
386 * @tc.number SUB_Audio_Function_Smartpa_Test_0007
387 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ.
388 * @tc.author: zhouyongxiao
389 */
390 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0007, TestSize.Level1)
391 {
392 int32_t ret = -1;
393 float thresholdValueMax = 0;
394 float thresholdValueMin = 0;
395 float expMax = 127;
396 float expMix = 40;
397 struct DevHandle *handle = nullptr;
398 struct AudioHwRender *hwRender = nullptr;
399
400 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle);
401 ASSERT_EQ(HDF_SUCCESS, ret);
402 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT, &hwRender->renderParam);
403 EXPECT_EQ(HDF_SUCCESS, ret);
404
405 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
406 EXPECT_EQ(HDF_SUCCESS, ret);
407 thresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
408 thresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
409 EXPECT_EQ(expMax, thresholdValueMax);
410 EXPECT_EQ(expMix, thresholdValueMin);
411 CloseServiceRenderSo(handle);
412 free(hwRender);
413 }
414 /**
415 * @tc.name test InterfaceLibCtlRender API via using smartpa.
416 * @tc.number SUB_Audio_Function_Smartpa_Test_0008
417 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT.
418 * @tc.author: zhouyongxiao
419 */
420 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0008, TestSize.Level1)
421 {
422 int32_t ret = -1;
423 struct DevHandle *handle = nullptr;
424 struct AudioHwRender *hwRender = nullptr;
425 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle);
426 ASSERT_EQ(HDF_SUCCESS, ret);
427 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT, &hwRender->renderParam);
428 EXPECT_EQ(HDF_SUCCESS, ret);
429 CloseServiceRenderSo(handle);
430 free(hwRender);
431 }
432 /**
433 * @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is normal value and reading
434 * this value.
435 * @tc.number SUB_Audio_Function_Smartpa_Test_0009
436 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
437 * @tc.author: zhouyongxiao
438 */
439 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0009, TestSize.Level1)
440 {
441 int32_t ret = -1;
442 float volumevalue = 0;
443 float thresholdValueMaxOut = 0;
444 float thresholdValueMinOut = 0;
445 float volumeBoundaryValueOut = 127.9;
446 struct DevHandle *handle = nullptr;
447 struct AudioHwRender *hwRender = nullptr;
448 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle);
449 ASSERT_EQ(HDF_SUCCESS, ret);
450 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
451 EXPECT_EQ(HDF_SUCCESS, ret);
452 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
453 EXPECT_EQ(HDF_SUCCESS, ret);
454 thresholdValueMaxOut = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
455 thresholdValueMinOut = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
456
457 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMinOut+1;
458 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
459 EXPECT_EQ(HDF_SUCCESS, ret);
460 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
461 EXPECT_EQ(HDF_SUCCESS, ret);
462 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
463 EXPECT_EQ(41, volumevalue);
464
465 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMaxOut-1;
466 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
467 EXPECT_EQ(HDF_SUCCESS, ret);
468 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
469 EXPECT_EQ(HDF_SUCCESS, ret);
470 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
471 EXPECT_EQ(126, volumevalue);
472
473 hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValueOut;
474 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
475 EXPECT_EQ(HDF_SUCCESS, ret);
476 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
477 EXPECT_EQ(HDF_SUCCESS, ret);
478 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
479 EXPECT_EQ(127, volumevalue);
480
481 CloseServiceRenderSo(handle);
482 free(hwRender);
483 }
484 /**
485 * @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is boundary value and reading
486 * this value.
487 * @tc.number SUB_Audio_Function_Smartpa_Test_0010
488 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
489 * @tc.author: zhouyongxiao
490 */
491 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0010, TestSize.Level1)
492 {
493 int32_t ret = -1;
494 float thresholdValueMin = 0;
495 float thresholdValueMax = 0;
496 float volumevalue = 0;
497 struct DevHandle *handle = nullptr;
498 struct AudioHwRender *hwRender = nullptr;
499 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle);
500 ASSERT_EQ(HDF_SUCCESS, ret);
501 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
502 EXPECT_EQ(HDF_SUCCESS, ret);
503 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
504 EXPECT_EQ(HDF_SUCCESS, ret);
505 thresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
506 thresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
507 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMin;
508 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
509 EXPECT_EQ(HDF_SUCCESS, ret);
510 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
511 EXPECT_EQ(HDF_SUCCESS, ret);
512 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
513 EXPECT_EQ(40, volumevalue);
514
515 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMax;
516 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
517 EXPECT_EQ(HDF_SUCCESS, ret);
518 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
519 EXPECT_EQ(HDF_SUCCESS, ret);
520 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
521 EXPECT_EQ(127, volumevalue);
522
523 CloseServiceRenderSo(handle);
524 free(hwRender);
525 }
526 /**
527 * @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is invalid value.
528 * @tc.number SUB_Audio_Function_Smartpa_Test_0011
529 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
530 * @tc.author: zhouyongxiao
531 */
532 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0011, TestSize.Level1)
533 {
534 int32_t ret = -1;
535 float volumeThresholdValueMax = 0;
536 float volumeThresholdValueMin = 0;
537 struct DevHandle *handle = nullptr;
538 struct AudioHwRender *hwRender = nullptr;
539 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle);
540 ASSERT_EQ(HDF_SUCCESS, ret);
541 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
542 EXPECT_EQ(HDF_SUCCESS, ret);
543
544 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
545 EXPECT_EQ(HDF_SUCCESS, ret);
546 volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
547 volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
548
549 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax + 1;
550 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
551 EXPECT_EQ(HDF_FAILURE, ret);
552
553 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin - 1;
554 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
555 EXPECT_EQ(HDF_FAILURE, ret);
556
557 CloseServiceRenderSo(handle);
558 free(hwRender);
559 }
560 /**
561 * @tc.name Test AudioAdapterInitAllPorts API when the adapter is smartpa.
562 * @tc.number SUB_Audio_Function_Smartpa_Test_0012
563 * @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports are initialized successfully.
564 * @tc.author: liutian
565 */
566 HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0012, TestSize.Level1)
567 {
568 int32_t ret = -1;
569 struct PrepareAudioPara audiopara = {
570 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str()
571 };
572 ASSERT_NE(nullptr, GetAudioManager);
573 audiopara.manager = GetAudioManager();
574 ASSERT_NE(nullptr, audiopara.manager);
575 ret = HMOS::Audio::GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
576 &audiopara.adapter, audiopara.audioPort);
577 ASSERT_EQ(HDF_SUCCESS, ret);
578 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
579 EXPECT_EQ(HDF_SUCCESS, ret);
580 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
581 }
582 }
583