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 capture drivers funtion.
21 * accessing a driver adapter, and capturing 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 capturing audio adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdicapture_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_HDMI = "hdmi";
45 const string ADAPTER_NAME_USB = "usb";
46 const string ADAPTER_NAME_INTERNAL = "internal";
47 const int BUFFER_SIZE = 16384;
48 const int BUFFER_SIZE_LITTLE = 0;
49 const uint64_t FILESIZE = 1024;
50
51 class AudioHdiCaptureTest : public testing::Test {
52 public:
53 static void SetUpTestCase(void);
54 static void TearDownTestCase(void);
55 void SetUp();
56 void TearDown();
57 static TestAudioManager *(*GetAudioManager)();
58 static void *handleSo;
59 #ifdef AUDIO_MPI_SO
60 static int32_t (*SdkInit)();
61 static void (*SdkExit)();
62 static void *sdkSo;
63 #endif
64
65 static int32_t GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara);
66 };
67
68 using THREAD_FUNC = void *(*)(void *);
69
70 TestAudioManager *(*AudioHdiCaptureTest::GetAudioManager)() = nullptr;
71 void *AudioHdiCaptureTest::handleSo = nullptr;
72 #ifdef AUDIO_MPI_SO
73 int32_t (*AudioHdiCaptureTest::SdkInit)() = nullptr;
74 void (*AudioHdiCaptureTest::SdkExit)() = nullptr;
75 void *AudioHdiCaptureTest::sdkSo = nullptr;
76 #endif
77
SetUpTestCase(void)78 void AudioHdiCaptureTest::SetUpTestCase(void)
79 {
80 #ifdef AUDIO_MPI_SO
81 char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so";
82 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
83 if (sdkSo == nullptr) {
84 return;
85 }
86 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
87 if (SdkInit == nullptr) {
88 return;
89 }
90 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
91 if (SdkExit == nullptr) {
92 return;
93 }
94 SdkInit();
95 #endif
96 handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY);
97 if (handleSo == nullptr) {
98 return;
99 }
100 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
101 if (GetAudioManager == nullptr) {
102 return;
103 }
104 }
105
TearDownTestCase(void)106 void AudioHdiCaptureTest::TearDownTestCase(void)
107 {
108 #ifdef AUDIO_MPI_SO
109 SdkExit();
110 if (sdkSo != nullptr) {
111 dlclose(sdkSo);
112 sdkSo = nullptr;
113 }
114 if (SdkInit != nullptr) {
115 SdkInit = nullptr;
116 }
117 if (SdkExit != nullptr) {
118 SdkExit = nullptr;
119 }
120 #endif
121 if (GetAudioManager != nullptr) {
122 GetAudioManager = nullptr;
123 }
124 }
125
126
SetUp(void)127 void AudioHdiCaptureTest::SetUp(void) {}
128
TearDown(void)129 void AudioHdiCaptureTest::TearDown(void) {}
130
131
GetLoadAdapterAudioPara(struct PrepareAudioPara & audiopara)132 int32_t AudioHdiCaptureTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara)
133 {
134 int32_t ret = -1;
135 int size = 0;
136 auto *inst = (AudioHdiCaptureTest *)audiopara.self;
137 if (inst != nullptr && inst->GetAudioManager != nullptr) {
138 audiopara.manager = inst->GetAudioManager();
139 }
140 if (audiopara.manager == nullptr) {
141 return HDF_FAILURE;
142 }
143 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
144 if (ret < 0 || audiopara.descs == nullptr || size == 0) {
145 return HDF_FAILURE;
146 } else {
147 int index = SwitchAdapter(audiopara.descs, audiopara.adapterName,
148 audiopara.portType, audiopara.audioPort, size);
149 if (index < 0) {
150 return HDF_FAILURE;
151 } else {
152 audiopara.desc = &audiopara.descs[index];
153 }
154 }
155 if (audiopara.desc == nullptr) {
156 return HDF_FAILURE;
157 } else {
158 ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
159 }
160 if (ret < 0 || audiopara.adapter == nullptr) {
161 return HDF_FAILURE;
162 }
163 return HDF_SUCCESS;
164 }
165
166 /**
167 * @tc.name Test AudioCaptureCaptureFrame API via legal input
168 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0001
169 * @tc.desc test AudioCaptureCaptureFrame interface,Returns 0 if the input data is read successfully
170 * @tc.author: liweiming
171 */
172 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0001, TestSize.Level1)
173 {
174 int32_t ret = -1;
175 uint64_t replyBytes = 0;
176 uint64_t requestBytes = BUFFER_SIZE;
177 struct AudioAdapter *adapter = nullptr;
178 struct AudioCapture *capture = nullptr;
179
180 TestAudioManager manager = *GetAudioManager();
181 ASSERT_NE(nullptr, GetAudioManager);
182 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
183 ASSERT_EQ(HDF_SUCCESS, ret);
184 ret = capture->control.Start((AudioHandle)capture);
185 EXPECT_EQ(HDF_SUCCESS, ret);
186 char *frame = (char *)calloc(1, BUFFER_SIZE);
187 EXPECT_NE(nullptr, frame);
188 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
189 EXPECT_EQ(HDF_SUCCESS, ret);
190
191 capture->control.Stop((AudioHandle)capture);
192 adapter->DestroyCapture(adapter, capture);
193 manager.UnloadAdapter(&manager, adapter);
194 if (frame != nullptr) {
195 free(frame);
196 frame = nullptr;
197 }
198 }
199 /**
200 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter frame is nullptr
201 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0002
202 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter frame is nullptr
203 * @tc.author: liweiming
204 */
205 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0002, TestSize.Level1)
206 {
207 int32_t ret = -1;
208 uint64_t replyBytes = 0;
209 uint64_t requestBytes = BUFFER_SIZE;
210 struct AudioAdapter *adapter = nullptr;
211 struct AudioCapture *capture = nullptr;
212 char *frame = nullptr;
213
214 TestAudioManager manager = *GetAudioManager();
215 ASSERT_NE(nullptr, GetAudioManager);
216 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
217 ASSERT_EQ(HDF_SUCCESS, ret);
218 ret = capture->control.Start((AudioHandle)capture);
219 EXPECT_EQ(HDF_SUCCESS, ret);
220 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
221 EXPECT_EQ(HDF_FAILURE, ret);
222
223 capture->control.Stop((AudioHandle)capture);
224 adapter->DestroyCapture(adapter, capture);
225 manager.UnloadAdapter(&manager, adapter);
226 }
227 /**
228 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter replyBytes is nullptr
229 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0003
230 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr
231 * @tc.author: liweiming
232 */
233 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0003, TestSize.Level1)
234 {
235 int32_t ret = -1;
236 uint64_t requestBytes = BUFFER_SIZE;
237 struct AudioAdapter *adapter = nullptr;
238 struct AudioCapture *capture = nullptr;
239 uint64_t *replyBytes = nullptr;
240
241 TestAudioManager manager = *GetAudioManager();
242 ASSERT_NE(nullptr, GetAudioManager);
243 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
244 ASSERT_EQ(HDF_SUCCESS, ret);
245 ret = capture->control.Start((AudioHandle)capture);
246 EXPECT_EQ(HDF_SUCCESS, ret);
247 char *frame = (char *)calloc(1, BUFFER_SIZE);
248 EXPECT_NE(nullptr, frame);
249 ret = capture->CaptureFrame(capture, frame, requestBytes, replyBytes);
250 EXPECT_EQ(HDF_FAILURE, ret);
251
252 capture->control.Stop((AudioHandle)capture);
253 adapter->DestroyCapture(adapter, capture);
254 manager.UnloadAdapter(&manager, adapter);
255 if (frame != nullptr) {
256 free(frame);
257 frame = nullptr;
258 }
259 }
260 /**
261 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter capture is nullptr
262 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0004
263 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter capture is nullptr
264 * @tc.author: liweiming
265 */
266 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0004, TestSize.Level1)
267 {
268 int32_t ret = -1;
269 uint64_t requestBytes = BUFFER_SIZE;
270 uint64_t replyBytes = 0;
271 struct AudioAdapter *adapter = nullptr;
272 struct AudioCapture *capture = nullptr;
273 struct AudioCapture *captureNull = nullptr;
274
275 TestAudioManager manager = *GetAudioManager();
276 ASSERT_NE(nullptr, GetAudioManager);
277 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
278 ASSERT_EQ(HDF_SUCCESS, ret);
279 ret = capture->control.Start((AudioHandle)capture);
280 EXPECT_EQ(HDF_SUCCESS, ret);
281 char *frame = (char *)calloc(1, BUFFER_SIZE);
282 EXPECT_NE(nullptr, frame);
283 ret = capture->CaptureFrame(captureNull, frame, requestBytes, &replyBytes);
284 EXPECT_EQ(HDF_FAILURE, ret);
285
286 capture->control.Stop((AudioHandle)capture);
287 adapter->DestroyCapture(adapter, capture);
288 manager.UnloadAdapter(&manager, adapter);
289 if (frame != nullptr) {
290 free(frame);
291 frame = nullptr;
292 }
293 }
294 /**
295 * @tc.name Test AudioCaptureFrame API without calling interface capturestart
296 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0005
297 * @tc.desc Test AudioCaptureFrame interface,Returns -1 if without calling interface capturestart
298 * @tc.author: liweiming
299 */
300 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0005, TestSize.Level1)
301 {
302 int32_t ret = -1;
303 uint64_t requestBytes = BUFFER_SIZE;
304 struct AudioAdapter *adapter = nullptr;
305 struct AudioCapture *capture = nullptr;
306 uint64_t replyBytes = 0;
307
308 TestAudioManager manager = *GetAudioManager();
309 ASSERT_NE(nullptr, GetAudioManager);
310 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
311 ASSERT_EQ(HDF_SUCCESS, ret);
312 char *frame = (char *)calloc(1, BUFFER_SIZE);
313 EXPECT_NE(nullptr, frame);
314 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
315 EXPECT_EQ(HDF_FAILURE, ret);
316
317 adapter->DestroyCapture(adapter, capture);
318 manager.UnloadAdapter(&manager, adapter);
319 if (frame != nullptr) {
320 free(frame);
321 frame = nullptr;
322 }
323 }
324 /**
325 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter requestBytes
326 less than interface requirements
327 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0006
328 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter
329 requestBytes less than interface requirements
330 * @tc.author: liweiming
331 */
332 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0006, TestSize.Level1)
333 {
334 int32_t ret = -1;
335 uint64_t requestBytes = BUFFER_SIZE_LITTLE;
336 uint64_t replyBytes = 0;
337 struct AudioAdapter *adapter = nullptr;
338 struct AudioCapture *capture = nullptr;
339
340 TestAudioManager manager = *GetAudioManager();
341 ASSERT_NE(nullptr, GetAudioManager);
342 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
343 ASSERT_EQ(HDF_SUCCESS, ret);
344 ret = capture->control.Start((AudioHandle)capture);
345 EXPECT_EQ(HDF_SUCCESS, ret);
346 char *frame = (char *)calloc(1, BUFFER_SIZE);
347 EXPECT_NE(nullptr, frame);
348 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
349 EXPECT_EQ(HDF_FAILURE, ret);
350
351 capture->control.Stop((AudioHandle)capture);
352 adapter->DestroyCapture(adapter, capture);
353 manager.UnloadAdapter(&manager, adapter);
354 if (frame != nullptr) {
355 free(frame);
356 frame = nullptr;
357 }
358 }
359 /**
360 * @tc.name Test AudioCaptureGetCapturePosition API via legal input
361 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001
362 * @tc.desc Test AudioCaptureGetCapturePosition interface,Returns 0 if get CapturePosition during playing.
363 * @tc.author: tiansuli
364 */
365 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001, TestSize.Level1)
366 {
367 int32_t ret = -1;
368 uint64_t frames = 0;
369 int64_t timeExp = 0;
370 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
371 struct PrepareAudioPara audiopara = {
372 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
373 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
374 };
375 ASSERT_NE(nullptr, GetAudioManager);
376 audiopara.manager = GetAudioManager();
377 ASSERT_NE(nullptr, audiopara.manager);
378
379 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
380 ASSERT_EQ(HDF_SUCCESS, ret);
381 sleep(1);
382 if (audiopara.capture != nullptr) {
383 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
384 EXPECT_EQ(HDF_SUCCESS, ret);
385 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
386 EXPECT_GT(frames, INITIAL_VALUE);
387 }
388
389 ret = ThreadRelease(audiopara);
390 EXPECT_EQ(HDF_SUCCESS, ret);
391 }
392 /**
393 * @tc.name Test GetCapturePosition API via get CapturePosition after the audiois Paused and resumed
394 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002
395 * @tc.desc Test GetCapturePosition interface,Returns 0 if get Position after Pause and resume during playing
396 * @tc.author: tiansuli
397 */
398 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002, TestSize.Level1)
399 {
400 int32_t ret = -1;
401 int64_t timeExp = 0;
402 uint64_t frames = 0;
403 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
404 struct PrepareAudioPara audiopara = {
405 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
406 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
407 };
408 ASSERT_NE(nullptr, GetAudioManager);
409 audiopara.manager = GetAudioManager();
410 ASSERT_NE(nullptr, audiopara.manager);
411
412 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
413 ASSERT_EQ(HDF_SUCCESS, ret);
414 sleep(1);
415 if (audiopara.capture != nullptr) {
416 ret = audiopara.capture->control.Pause((AudioHandle)(audiopara.capture));
417 EXPECT_EQ(HDF_SUCCESS, ret);
418 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
419 EXPECT_EQ(HDF_SUCCESS, ret);
420 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
421 EXPECT_GT(frames, INITIAL_VALUE);
422 ret = audiopara.capture->control.Resume((AudioHandle)(audiopara.capture));
423 EXPECT_EQ(HDF_SUCCESS, ret);
424 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
425 EXPECT_EQ(HDF_SUCCESS, ret);
426 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
427 EXPECT_GT(frames, INITIAL_VALUE);
428 }
429
430 ret = ThreadRelease(audiopara);
431 EXPECT_EQ(HDF_SUCCESS, ret);
432 }
433 /**
434 * @tc.name Test GetCapturePosition API via get CapturePosition after the audio file is stopped
435 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003
436 * @tc.desc Test GetCapturePosition interface,Returns 0 if get CapturePosition after stop during playing
437 * @tc.author: tiansuli
438 */
439 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003, TestSize.Level1)
440 {
441 int32_t ret = -1;
442 TestAudioManager manager = {};
443 struct AudioAdapter *adapter = {};
444 struct AudioCapture *capture = nullptr;
445 uint64_t frames = 0;
446 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
447 int64_t timeExp = 0;
448
449 manager = *GetAudioManager();
450 ASSERT_NE(nullptr, GetAudioManager);
451 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
452 ASSERT_EQ(HDF_SUCCESS, ret);
453 ret = capture->control.Stop((AudioHandle)capture);
454 EXPECT_EQ(HDF_SUCCESS, ret);
455 ret = capture->GetCapturePosition(capture, &frames, &time);
456 EXPECT_EQ(HDF_SUCCESS, ret);
457 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
458 EXPECT_GT(frames, INITIAL_VALUE);
459
460 adapter->DestroyCapture(adapter, capture);
461 manager.UnloadAdapter(&manager, adapter);
462 }
463 /**
464 * @tc.name Test GetCapturePosition API via get CapturePosition after the object is created
465 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004
466 * @tc.desc Test GetCapturePosition interface, return 0 if get CapturePosition after the object is created
467 * @tc.author: tiansuli
468 */
469 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004, TestSize.Level1)
470 {
471 int32_t ret = -1;
472 enum AudioPortPin pins = PIN_IN_MIC;
473 struct AudioAdapter *adapter = {};
474 struct AudioCapture *capture = nullptr;
475 uint64_t frames = 0;
476 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
477 int64_t timeExp = 0;
478
479 TestAudioManager manager = *GetAudioManager();
480 ASSERT_NE(nullptr, GetAudioManager);
481 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
482 ASSERT_EQ(HDF_SUCCESS, ret);
483 ret = capture->GetCapturePosition(capture, &frames, &time);
484 EXPECT_EQ(HDF_SUCCESS, ret);
485 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
486
487 adapter->DestroyCapture(adapter, capture);
488 manager.UnloadAdapter(&manager, adapter);
489 }
490 /**
491 * @tc.name Test GetCapturePosition API via setting the parameter Capture is nullptr
492 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005
493 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter Capture is nullptr
494 * @tc.author: tiansuli
495 */
496 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005, TestSize.Level1)
497 {
498 int32_t ret = -1;
499 TestAudioManager manager = {};
500 struct AudioAdapter *adapter = {};
501 struct AudioCapture *capture = nullptr;
502 struct AudioCapture *captureNull = nullptr;
503 uint64_t frames = 0;
504 struct AudioTimeStamp time = {};
505
506 manager = *GetAudioManager();
507 ASSERT_NE(nullptr, GetAudioManager);
508 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
509 ASSERT_EQ(HDF_SUCCESS, ret);
510 ret = capture->GetCapturePosition(captureNull, &frames, &time);
511 EXPECT_EQ(HDF_FAILURE, ret);
512
513 capture->control.Stop((AudioHandle)capture);
514 adapter->DestroyCapture(adapter, capture);
515 manager.UnloadAdapter(&manager, adapter);
516 }
517 /**
518 * @tc.name Test GetCapturePosition API via setting the parameter frames is nullptr
519 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006
520 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter frames is nullptr
521 * @tc.author: tiansuli
522 */
523 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006, TestSize.Level1)
524 {
525 int32_t ret = -1;
526 TestAudioManager manager = {};
527 struct AudioAdapter *adapter = {};
528 struct AudioCapture *capture = nullptr;
529 uint64_t *framesNull = nullptr;
530 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
531
532 manager = *GetAudioManager();
533 ASSERT_NE(nullptr, GetAudioManager);
534 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
535 ASSERT_EQ(HDF_SUCCESS, ret);
536 ret = capture->GetCapturePosition(capture, framesNull, &time);
537 EXPECT_EQ(HDF_FAILURE, ret);
538
539 capture->control.Stop((AudioHandle)capture);
540 adapter->DestroyCapture(adapter, capture);
541 manager.UnloadAdapter(&manager, adapter);
542 }
543 /**
544 * @tc.name Test GetCapturePosition API via setting the parameter time is nullptr
545 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007
546 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter time is nullptr
547 * @tc.author: tiansuli
548 */
549 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007, TestSize.Level1)
550 {
551 int32_t ret = -1;
552 TestAudioManager manager = {};
553 struct AudioAdapter *adapter = {};
554 struct AudioCapture *capture = nullptr;
555 uint64_t frames = 0;
556 struct AudioTimeStamp *timeNull = nullptr;
557
558 manager = *GetAudioManager();
559 ASSERT_NE(nullptr, GetAudioManager);
560 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
561 ASSERT_EQ(HDF_SUCCESS, ret);
562 ret = capture->GetCapturePosition(capture, &frames, timeNull);
563 EXPECT_EQ(HDF_FAILURE, ret);
564
565 capture->control.Stop((AudioHandle)capture);
566 adapter->DestroyCapture(adapter, capture);
567 manager.UnloadAdapter(&manager, adapter);
568 }
569 /**
570 * @tc.name Test GetCapturePosition API via get CapturePosition continuously
571 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008
572 * @tc.desc Test GetCapturePosition interface, return 0 if the GetCapturePosition was called twice
573 * @tc.author: tiansuli
574 */
575 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008, TestSize.Level1)
576 {
577 int32_t ret = -1;
578 TestAudioManager manager = {};
579 struct AudioAdapter *adapter = {};
580 struct AudioCapture *capture = nullptr;
581 uint64_t frames = 0;
582 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
583 struct AudioTimeStamp timeSec = {.tvSec = 0, .tvNSec = 0};
584 int64_t timeExp = 0;
585
586 manager = *GetAudioManager();
587 ASSERT_NE(nullptr, GetAudioManager);
588 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
589 ASSERT_EQ(HDF_SUCCESS, ret);
590 ret = capture->GetCapturePosition(capture, &frames, &time);
591 EXPECT_EQ(HDF_SUCCESS, ret);
592 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
593 EXPECT_GT(frames, INITIAL_VALUE);
594 ret = capture->GetCapturePosition(capture, &frames, &timeSec);
595 EXPECT_EQ(HDF_SUCCESS, ret);
596 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
597 EXPECT_GT(frames, INITIAL_VALUE);
598
599 capture->control.Stop((AudioHandle)capture);
600 adapter->DestroyCapture(adapter, capture);
601 manager.UnloadAdapter(&manager, adapter);
602 }
603 /**
604 * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_16_BIT
605 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009
606 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT
607 * @tc.author: tiansuli
608 */
609 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009, TestSize.Level1)
610 {
611 int32_t ret = -1;
612 uint64_t channelCountExp = 2;
613 uint32_t sampleRateExp = 48000;
614 uint64_t frames = 0;
615 int64_t timeExp = 0;
616 struct AudioAdapter *adapter = nullptr;
617 struct AudioCapture *capture = nullptr;
618 struct AudioSampleAttributes attrs = {};
619 struct AudioSampleAttributes attrsValue = {};
620 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
621 TestAudioManager manager = *GetAudioManager();
622 ASSERT_NE(nullptr, GetAudioManager);
623 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
624 ASSERT_EQ(HDF_SUCCESS, ret);
625 InitAttrs(attrs);
626 attrs.type = AUDIO_IN_MEDIA;
627 attrs.interleaved = false;
628 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
629 attrs.sampleRate = 48000;
630 attrs.channelCount = 2;
631 ret = capture->attr.SetSampleAttributes(capture, &attrs);
632 EXPECT_EQ(HDF_SUCCESS, ret);
633 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
634 EXPECT_EQ(HDF_SUCCESS, ret);
635 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
636 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
637 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
638
639 ret = AudioCaptureStartAndOneFrame(capture);
640 EXPECT_EQ(HDF_SUCCESS, ret);
641 ret = capture->GetCapturePosition(capture, &frames, &time);
642 EXPECT_EQ(HDF_SUCCESS, ret);
643 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
644 EXPECT_GT(frames, INITIAL_VALUE);
645
646 capture->control.Stop((AudioHandle)capture);
647 adapter->DestroyCapture(adapter, capture);
648 manager.UnloadAdapter(&manager, adapter);
649 }
650 /**
651 * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_24_BIT
652 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010
653 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT
654 * @tc.author: tiansuli
655 */
656 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010, TestSize.Level1)
657 {
658 int32_t ret = -1;
659 struct AudioSampleAttributes attrs = {};
660 struct AudioSampleAttributes attrsValue = {};
661 struct AudioAdapter *adapter = nullptr;
662 struct AudioCapture *capture = nullptr;
663 uint64_t channelCountExp = 2;
664 uint32_t sampleRateExp = 48000;
665 uint64_t frames = 0;
666 int64_t timeExp = 0;
667 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
668 TestAudioManager manager = *GetAudioManager();
669 ASSERT_NE(nullptr, GetAudioManager);
670 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
671 ASSERT_EQ(HDF_SUCCESS, ret);
672 InitAttrs(attrs);
673 attrs.type = AUDIO_IN_MEDIA;
674 attrs.interleaved = false;
675 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
676 attrs.sampleRate = 48000;
677 attrs.channelCount = 2;
678 ret = capture->attr.SetSampleAttributes(capture, &attrs);
679 EXPECT_EQ(HDF_SUCCESS, ret);
680 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
681 EXPECT_EQ(HDF_SUCCESS, ret);
682 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
683 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
684 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
685
686 ret = AudioCaptureStartAndOneFrame(capture);
687 EXPECT_EQ(HDF_SUCCESS, ret);
688 ret = capture->GetCapturePosition(capture, &frames, &time);
689 EXPECT_EQ(HDF_SUCCESS, ret);
690 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
691 EXPECT_GT(frames, INITIAL_VALUE);
692
693 capture->control.Stop((AudioHandle)capture);
694 adapter->DestroyCapture(adapter, capture);
695 manager.UnloadAdapter(&manager, adapter);
696 }
697 /**
698 * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to different value
699 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011
700 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount as different values
701 * @tc.author: tiansuli
702 */
703 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011, TestSize.Level1)
704 {
705 int32_t ret = -1;
706 struct AudioCapture *capture = nullptr;
707 struct AudioAdapter *adapter = nullptr;
708 struct AudioSampleAttributes attrs = {};
709 struct AudioSampleAttributes attrsValue = {};
710 uint64_t channelCountExp = 1;
711 uint32_t sampleRateExp = 48000;
712 uint64_t frames = 0;
713 int64_t timeExp = 0;
714 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
715 TestAudioManager manager = *GetAudioManager();
716 ASSERT_NE(nullptr, GetAudioManager);
717 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
718 ASSERT_EQ(HDF_SUCCESS, ret);
719 InitAttrs(attrs);
720 attrs.type = AUDIO_IN_MEDIA;
721 attrs.interleaved = false;
722 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
723 attrs.sampleRate = 48000;
724 attrs.channelCount = 1;
725 ret = capture->attr.SetSampleAttributes(capture, &attrs);
726 EXPECT_EQ(HDF_SUCCESS, ret);
727 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
728 EXPECT_EQ(HDF_SUCCESS, ret);
729 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
730 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
731 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
732
733 ret = AudioCaptureStartAndOneFrame(capture);
734 EXPECT_EQ(HDF_SUCCESS, ret);
735 ret = capture->GetCapturePosition(capture, &frames, &time);
736 EXPECT_EQ(HDF_SUCCESS, ret);
737 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
738 EXPECT_GT(frames, INITIAL_VALUE);
739
740 capture->control.Stop((AudioHandle)capture);
741 adapter->DestroyCapture(adapter, capture);
742 manager.UnloadAdapter(&manager, adapter);
743 }
744 /**
745 * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to 1
746 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012
747 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount to 1
748 * @tc.author: tiansuli
749 */
750 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012, TestSize.Level1)
751 {
752 int32_t ret = -1;
753 uint64_t channelCountExp = 1;
754 uint32_t sampleRateExp = 48000;
755 uint64_t frames = 0;
756 int64_t timeExp = 0;
757 struct AudioAdapter *adapter = nullptr;
758 struct AudioCapture *capture = nullptr;
759 struct AudioSampleAttributes attrs = {};
760 struct AudioSampleAttributes attrsValue = {};
761 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
762 TestAudioManager manager = *GetAudioManager();
763 ASSERT_NE(nullptr, GetAudioManager);
764 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
765 ASSERT_EQ(HDF_SUCCESS, ret);
766 InitAttrs(attrs);
767 attrs.type = AUDIO_IN_MEDIA;
768 attrs.interleaved = false;
769 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
770 attrs.sampleRate = 48000;
771 attrs.channelCount = 1;
772 ret = capture->attr.SetSampleAttributes(capture, &attrs);
773 EXPECT_EQ(HDF_SUCCESS, ret);
774 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
775 EXPECT_EQ(HDF_SUCCESS, ret);
776 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
777 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
778 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
779
780 ret = AudioCaptureStartAndOneFrame(capture);
781 EXPECT_EQ(HDF_SUCCESS, ret);
782 ret = capture->GetCapturePosition(capture, &frames, &time);
783 EXPECT_EQ(HDF_SUCCESS, ret);
784 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
785 EXPECT_GT(frames, INITIAL_VALUE);
786
787 capture->control.Stop((AudioHandle)capture);
788 adapter->DestroyCapture(adapter, capture);
789 manager.UnloadAdapter(&manager, adapter);
790 }
791 }