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 function.
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[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
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 char absPath[PATH_MAX] = {0};
97 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
98 return;
99 }
100 handleSo = dlopen(absPath, RTLD_LAZY);
101 if (handleSo == nullptr) {
102 return;
103 }
104 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
105 if (GetAudioManager == nullptr) {
106 return;
107 }
108 }
109
TearDownTestCase(void)110 void AudioHdiCaptureTest::TearDownTestCase(void)
111 {
112 #ifdef AUDIO_MPI_SO
113 SdkExit();
114 if (sdkSo != nullptr) {
115 dlclose(sdkSo);
116 sdkSo = nullptr;
117 }
118 if (SdkInit != nullptr) {
119 SdkInit = nullptr;
120 }
121 if (SdkExit != nullptr) {
122 SdkExit = nullptr;
123 }
124 #endif
125 if (handleSo != nullptr) {
126 dlclose(handleSo);
127 handleSo = nullptr;
128 }
129 if (GetAudioManager != nullptr) {
130 GetAudioManager = nullptr;
131 }
132 }
133
134
SetUp(void)135 void AudioHdiCaptureTest::SetUp(void) {}
136
TearDown(void)137 void AudioHdiCaptureTest::TearDown(void) {}
138
139
GetLoadAdapterAudioPara(struct PrepareAudioPara & audiopara)140 int32_t AudioHdiCaptureTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara)
141 {
142 int32_t ret = -1;
143 int size = 0;
144 auto *inst = (AudioHdiCaptureTest *)audiopara.self;
145 if (inst != nullptr && inst->GetAudioManager != nullptr) {
146 audiopara.manager = inst->GetAudioManager();
147 }
148 if (audiopara.manager == nullptr) {
149 return AUDIO_HAL_ERR_INVALID_PARAM;
150 }
151 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
152 if (ret < 0) {
153 return ret;
154 }
155 if (audiopara.descs == nullptr || size == 0) {
156 return AUDIO_HAL_ERR_INTERNAL;
157 }
158 int index = SwitchAdapter(audiopara.descs, audiopara.adapterName,
159 audiopara.portType, audiopara.audioPort, size);
160 if (index < 0) {
161 return AUDIO_HAL_ERR_INTERNAL;
162 } else {
163 audiopara.desc = &audiopara.descs[index];
164 }
165 if (audiopara.desc == nullptr) {
166 return AUDIO_HAL_ERR_INVALID_PARAM;
167 } else {
168 ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
169 }
170 if (ret < 0) {
171 return ret;
172 }
173 if (audiopara.adapter == nullptr) {
174 return AUDIO_HAL_ERR_INVALID_PARAM;
175 }
176 return HDF_SUCCESS;
177 }
178
179
180 /**
181 * @tc.name Test AudioCaptureCaptureFrame API via legal input
182 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0001
183 * @tc.desc test AudioCaptureCaptureFrame interface,Returns 0 if the input data is read successfully
184 * @tc.author: liweiming
185 */
186 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0001, TestSize.Level1)
187 {
188 int32_t ret = -1;
189 uint64_t replyBytes = 0;
190 uint64_t requestBytes = BUFFER_SIZE;
191 struct AudioAdapter *adapter = nullptr;
192 struct AudioCapture *capture = nullptr;
193
194 TestAudioManager* manager = GetAudioManager();
195 ASSERT_NE(nullptr, GetAudioManager);
196 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
197 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
198 ret = capture->control.Start((AudioHandle)capture);
199 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
200 char *frame = (char *)calloc(1, BUFFER_SIZE);
201 EXPECT_NE(nullptr, frame);
202 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
203 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
204
205 capture->control.Stop((AudioHandle)capture);
206 adapter->DestroyCapture(adapter, capture);
207 manager->UnloadAdapter(manager, adapter);
208 if (frame != nullptr) {
209 free(frame);
210 frame = nullptr;
211 }
212 }
213 /**
214 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter frame is nullptr
215 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0002
216 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter frame is nullptr
217 * @tc.author: liweiming
218 */
219 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0002, TestSize.Level1)
220 {
221 int32_t ret = -1;
222 uint64_t replyBytes = 0;
223 uint64_t requestBytes = BUFFER_SIZE;
224 struct AudioAdapter *adapter = nullptr;
225 struct AudioCapture *capture = nullptr;
226 char *frame = nullptr;
227
228 TestAudioManager* manager = GetAudioManager();
229 ASSERT_NE(nullptr, GetAudioManager);
230 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
231 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
232 ret = capture->control.Start((AudioHandle)capture);
233 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
234 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
235 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
236
237 capture->control.Stop((AudioHandle)capture);
238 adapter->DestroyCapture(adapter, capture);
239 manager->UnloadAdapter(manager, adapter);
240 }
241 /**
242 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter replyBytes is nullptr
243 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0003
244 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr
245 * @tc.author: liweiming
246 */
247 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0003, TestSize.Level1)
248 {
249 int32_t ret = -1;
250 uint64_t requestBytes = BUFFER_SIZE;
251 struct AudioAdapter *adapter = nullptr;
252 struct AudioCapture *capture = nullptr;
253 uint64_t *replyBytes = nullptr;
254
255 TestAudioManager* manager = GetAudioManager();
256 ASSERT_NE(nullptr, GetAudioManager);
257 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
258 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
259 ret = capture->control.Start((AudioHandle)capture);
260 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
261 char *frame = (char *)calloc(1, BUFFER_SIZE);
262 EXPECT_NE(nullptr, frame);
263 ret = capture->CaptureFrame(capture, frame, requestBytes, replyBytes);
264 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
265
266 capture->control.Stop((AudioHandle)capture);
267 adapter->DestroyCapture(adapter, capture);
268 manager->UnloadAdapter(manager, adapter);
269 if (frame != nullptr) {
270 free(frame);
271 frame = nullptr;
272 }
273 }
274 /**
275 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter capture is nullptr
276 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0004
277 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter capture is nullptr
278 * @tc.author: liweiming
279 */
280 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0004, TestSize.Level1)
281 {
282 int32_t ret = -1;
283 uint64_t requestBytes = BUFFER_SIZE;
284 uint64_t replyBytes = 0;
285 struct AudioAdapter *adapter = nullptr;
286 struct AudioCapture *capture = nullptr;
287 struct AudioCapture *captureNull = nullptr;
288
289 TestAudioManager* manager = GetAudioManager();
290 ASSERT_NE(nullptr, GetAudioManager);
291 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
292 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
293 ret = capture->control.Start((AudioHandle)capture);
294 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
295 char *frame = (char *)calloc(1, BUFFER_SIZE);
296 EXPECT_NE(nullptr, frame);
297 ret = capture->CaptureFrame(captureNull, frame, requestBytes, &replyBytes);
298 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
299
300 capture->control.Stop((AudioHandle)capture);
301 adapter->DestroyCapture(adapter, capture);
302 manager->UnloadAdapter(manager, adapter);
303 if (frame != nullptr) {
304 free(frame);
305 frame = nullptr;
306 }
307 }
308 /**
309 * @tc.name Test AudioCaptureFrame API without calling interface capturestart
310 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0005
311 * @tc.desc Test AudioCaptureFrame interface,Returns -1 if without calling interface capturestart
312 * @tc.author: liweiming
313 */
314 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0005, TestSize.Level1)
315 {
316 int32_t ret = -1;
317 uint64_t requestBytes = BUFFER_SIZE;
318 struct AudioAdapter *adapter = nullptr;
319 struct AudioCapture *capture = nullptr;
320 uint64_t replyBytes = 0;
321
322 TestAudioManager* manager = GetAudioManager();
323 ASSERT_NE(nullptr, GetAudioManager);
324 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
325 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
326 char *frame = (char *)calloc(1, BUFFER_SIZE);
327 EXPECT_NE(nullptr, frame);
328 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
329 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
330
331 adapter->DestroyCapture(adapter, capture);
332 manager->UnloadAdapter(manager, adapter);
333 if (frame != nullptr) {
334 free(frame);
335 frame = nullptr;
336 }
337 }
338 /**
339 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter requestBytes
340 less than interface requirements
341 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0006
342 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter
343 requestBytes less than interface requirements
344 * @tc.author: liweiming
345 */
346 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0006, TestSize.Level1)
347 {
348 int32_t ret = -1;
349 uint64_t requestBytes = BUFFER_SIZE_LITTLE;
350 uint64_t replyBytes = 0;
351 struct AudioAdapter *adapter = nullptr;
352 struct AudioCapture *capture = nullptr;
353
354 TestAudioManager* manager = GetAudioManager();
355 ASSERT_NE(nullptr, GetAudioManager);
356 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
357 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
358 ret = capture->control.Start((AudioHandle)capture);
359 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
360 char *frame = (char *)calloc(1, BUFFER_SIZE);
361 EXPECT_NE(nullptr, frame);
362 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
363 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
364
365 capture->control.Stop((AudioHandle)capture);
366 adapter->DestroyCapture(adapter, capture);
367 manager->UnloadAdapter(manager, adapter);
368 if (frame != nullptr) {
369 free(frame);
370 frame = nullptr;
371 }
372 }
373 /**
374 * @tc.name Test AudioCaptureGetCapturePosition API via legal input
375 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001
376 * @tc.desc Test AudioCaptureGetCapturePosition interface,Returns 0 if get CapturePosition during playing.
377 * @tc.author: tiansuli
378 */
379 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001, TestSize.Level1)
380 {
381 int32_t ret = -1;
382 uint64_t frames = 0;
383 int64_t timeExp = 0;
384 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
385 struct PrepareAudioPara audiopara = {
386 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
387 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
388 };
389 ASSERT_NE(nullptr, GetAudioManager);
390 audiopara.manager = GetAudioManager();
391 ASSERT_NE(nullptr, audiopara.manager);
392
393 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
394 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
395 sleep(1);
396 if (audiopara.capture != nullptr) {
397 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
398 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
399 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
400 EXPECT_GT(frames, INITIAL_VALUE);
401 }
402
403 ret = ThreadRelease(audiopara);
404 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
405 }
406 /**
407 * @tc.name Test GetCapturePosition API via get CapturePosition after the audiois Paused and resumed
408 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002
409 * @tc.desc Test GetCapturePosition interface,Returns 0 if get Position after Pause and resume during playing
410 * @tc.author: tiansuli
411 */
412 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002, TestSize.Level1)
413 {
414 int32_t ret = -1;
415 int64_t timeExp = 0;
416 uint64_t frames = 0;
417 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
418 struct PrepareAudioPara audiopara = {
419 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
420 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
421 };
422 ASSERT_NE(nullptr, GetAudioManager);
423 audiopara.manager = GetAudioManager();
424 ASSERT_NE(nullptr, audiopara.manager);
425
426 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
427 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
428 sleep(1);
429 if (audiopara.capture != nullptr) {
430 ret = audiopara.capture->control.Pause((AudioHandle)(audiopara.capture));
431 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
432 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
433 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
434 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
435 EXPECT_GT(frames, INITIAL_VALUE);
436 ret = audiopara.capture->control.Resume((AudioHandle)(audiopara.capture));
437 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
438 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
439 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
440 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
441 EXPECT_GT(frames, INITIAL_VALUE);
442 }
443
444 ret = ThreadRelease(audiopara);
445 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
446 }
447 /**
448 * @tc.name Test GetCapturePosition API via get CapturePosition after the audio file is stopped
449 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003
450 * @tc.desc Test GetCapturePosition interface,Returns 0 if get CapturePosition after stop during playing
451 * @tc.author: tiansuli
452 */
453 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003, TestSize.Level1)
454 {
455 int32_t ret = -1;
456 TestAudioManager* manager = {};
457 struct AudioAdapter *adapter = {};
458 struct AudioCapture *capture = nullptr;
459 uint64_t frames = 0;
460 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
461 int64_t timeExp = 0;
462
463 manager = GetAudioManager();
464 ASSERT_NE(nullptr, GetAudioManager);
465 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
466 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
467 ret = capture->control.Stop((AudioHandle)capture);
468 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
469 ret = capture->GetCapturePosition(capture, &frames, &time);
470 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
471 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
472 EXPECT_GT(frames, INITIAL_VALUE);
473
474 adapter->DestroyCapture(adapter, capture);
475 manager->UnloadAdapter(manager, adapter);
476 }
477 /**
478 * @tc.name Test GetCapturePosition API via get CapturePosition after the object is created
479 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004
480 * @tc.desc Test GetCapturePosition interface, return 0 if get CapturePosition after the object is created
481 * @tc.author: tiansuli
482 */
483 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004, TestSize.Level1)
484 {
485 int32_t ret = -1;
486 enum AudioPortPin pins = PIN_IN_MIC;
487 struct AudioAdapter *adapter = {};
488 struct AudioCapture *capture = nullptr;
489 uint64_t frames = 0;
490 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
491 int64_t timeExp = 0;
492
493 TestAudioManager* manager = GetAudioManager();
494 ASSERT_NE(nullptr, GetAudioManager);
495 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
496 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
497 ret = capture->GetCapturePosition(capture, &frames, &time);
498 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
499 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
500
501 adapter->DestroyCapture(adapter, capture);
502 manager->UnloadAdapter(manager, adapter);
503 }
504 /**
505 * @tc.name Test GetCapturePosition API via setting the parameter Capture is nullptr
506 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005
507 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter Capture is nullptr
508 * @tc.author: tiansuli
509 */
510 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005, TestSize.Level1)
511 {
512 int32_t ret = -1;
513 TestAudioManager* manager = {};
514 struct AudioAdapter *adapter = {};
515 struct AudioCapture *capture = nullptr;
516 struct AudioCapture *captureNull = nullptr;
517 uint64_t frames = 0;
518 struct AudioTimeStamp time = {};
519
520 manager = GetAudioManager();
521 ASSERT_NE(nullptr, GetAudioManager);
522 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
523 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
524 ret = capture->GetCapturePosition(captureNull, &frames, &time);
525 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
526
527 capture->control.Stop((AudioHandle)capture);
528 adapter->DestroyCapture(adapter, capture);
529 manager->UnloadAdapter(manager, adapter);
530 }
531 /**
532 * @tc.name Test GetCapturePosition API via setting the parameter frames is nullptr
533 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006
534 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter frames is nullptr
535 * @tc.author: tiansuli
536 */
537 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006, TestSize.Level1)
538 {
539 int32_t ret = -1;
540 TestAudioManager* manager = {};
541 struct AudioAdapter *adapter = {};
542 struct AudioCapture *capture = nullptr;
543 uint64_t *framesNull = nullptr;
544 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
545
546 manager = GetAudioManager();
547 ASSERT_NE(nullptr, GetAudioManager);
548 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
549 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
550 ret = capture->GetCapturePosition(capture, framesNull, &time);
551 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
552
553 capture->control.Stop((AudioHandle)capture);
554 adapter->DestroyCapture(adapter, capture);
555 manager->UnloadAdapter(manager, adapter);
556 }
557 /**
558 * @tc.name Test GetCapturePosition API via setting the parameter time is nullptr
559 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007
560 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter time is nullptr
561 * @tc.author: tiansuli
562 */
563 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007, TestSize.Level1)
564 {
565 int32_t ret = -1;
566 TestAudioManager* manager = {};
567 struct AudioAdapter *adapter = {};
568 struct AudioCapture *capture = nullptr;
569 uint64_t frames = 0;
570 struct AudioTimeStamp *timeNull = nullptr;
571
572 manager = GetAudioManager();
573 ASSERT_NE(nullptr, GetAudioManager);
574 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
575 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
576 ret = capture->GetCapturePosition(capture, &frames, timeNull);
577 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
578
579 capture->control.Stop((AudioHandle)capture);
580 adapter->DestroyCapture(adapter, capture);
581 manager->UnloadAdapter(manager, adapter);
582 }
583 /**
584 * @tc.name Test GetCapturePosition API via get CapturePosition continuously
585 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008
586 * @tc.desc Test GetCapturePosition interface, return 0 if the GetCapturePosition was called twice
587 * @tc.author: tiansuli
588 */
589 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008, TestSize.Level1)
590 {
591 int32_t ret = -1;
592 TestAudioManager* manager = {};
593 struct AudioAdapter *adapter = {};
594 struct AudioCapture *capture = nullptr;
595 uint64_t frames = 0;
596 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
597 struct AudioTimeStamp timeSec = {.tvSec = 0, .tvNSec = 0};
598 int64_t timeExp = 0;
599
600 manager = GetAudioManager();
601 ASSERT_NE(nullptr, GetAudioManager);
602 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
603 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
604 ret = capture->GetCapturePosition(capture, &frames, &time);
605 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
606 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
607 EXPECT_GT(frames, INITIAL_VALUE);
608 ret = capture->GetCapturePosition(capture, &frames, &timeSec);
609 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
610 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
611 EXPECT_GT(frames, INITIAL_VALUE);
612
613 capture->control.Stop((AudioHandle)capture);
614 adapter->DestroyCapture(adapter, capture);
615 manager->UnloadAdapter(manager, adapter);
616 }
617 /**
618 * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_16_BIT
619 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009
620 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT
621 * @tc.author: tiansuli
622 */
623 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009, TestSize.Level1)
624 {
625 int32_t ret = -1;
626 uint64_t channelCountExp = 2;
627 uint32_t sampleRateExp = 48000;
628 uint64_t frames = 0;
629 int64_t timeExp = 0;
630 struct AudioAdapter *adapter = nullptr;
631 struct AudioCapture *capture = nullptr;
632 struct AudioSampleAttributes attrs = {};
633 struct AudioSampleAttributes attrsValue = {};
634 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
635 TestAudioManager* manager = GetAudioManager();
636 ASSERT_NE(nullptr, GetAudioManager);
637 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
638 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
639 InitAttrs(attrs);
640 attrs.type = AUDIO_IN_MEDIA;
641 attrs.interleaved = false;
642 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
643 attrs.sampleRate = 48000;
644 attrs.channelCount = 2;
645 ret = capture->attr.SetSampleAttributes(capture, &attrs);
646 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
647 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
648 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
649 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
650 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
651 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
652
653 ret = AudioCaptureStartAndOneFrame(capture);
654 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
655 ret = capture->GetCapturePosition(capture, &frames, &time);
656 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
657 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
658 EXPECT_GT(frames, INITIAL_VALUE);
659
660 capture->control.Stop((AudioHandle)capture);
661 adapter->DestroyCapture(adapter, capture);
662 manager->UnloadAdapter(manager, adapter);
663 }
664 /**
665 * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_24_BIT
666 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010
667 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT
668 * @tc.author: tiansuli
669 */
670 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010, TestSize.Level1)
671 {
672 int32_t ret = -1;
673 struct AudioSampleAttributes attrs = {};
674 struct AudioSampleAttributes attrsValue = {};
675 struct AudioAdapter *adapter = nullptr;
676 struct AudioCapture *capture = nullptr;
677 uint64_t channelCountExp = 2;
678 uint32_t sampleRateExp = 48000;
679 uint64_t frames = 0;
680 int64_t timeExp = 0;
681 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
682 TestAudioManager* manager = GetAudioManager();
683 ASSERT_NE(nullptr, GetAudioManager);
684 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
685 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
686 InitAttrs(attrs);
687 attrs.type = AUDIO_IN_MEDIA;
688 attrs.interleaved = false;
689 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
690 attrs.sampleRate = 48000;
691 attrs.channelCount = 2;
692 ret = capture->attr.SetSampleAttributes(capture, &attrs);
693 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
694 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
695 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
696 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
697 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
698 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
699
700 ret = AudioCaptureStartAndOneFrame(capture);
701 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
702 ret = capture->GetCapturePosition(capture, &frames, &time);
703 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
704 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
705 EXPECT_GT(frames, INITIAL_VALUE);
706
707 capture->control.Stop((AudioHandle)capture);
708 adapter->DestroyCapture(adapter, capture);
709 manager->UnloadAdapter(manager, adapter);
710 }
711 /**
712 * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to different value
713 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011
714 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount as different values
715 * @tc.author: tiansuli
716 */
717 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011, TestSize.Level1)
718 {
719 int32_t ret = -1;
720 struct AudioCapture *capture = nullptr;
721 struct AudioAdapter *adapter = nullptr;
722 struct AudioSampleAttributes attrs = {};
723 struct AudioSampleAttributes attrsValue = {};
724 uint64_t channelCountExp = 1;
725 uint32_t sampleRateExp = 48000;
726 uint64_t frames = 0;
727 int64_t timeExp = 0;
728 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
729 TestAudioManager* manager = GetAudioManager();
730 ASSERT_NE(nullptr, GetAudioManager);
731 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
732 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
733 InitAttrs(attrs);
734 attrs.type = AUDIO_IN_MEDIA;
735 attrs.interleaved = false;
736 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
737 attrs.sampleRate = 48000;
738 attrs.channelCount = 1;
739 ret = capture->attr.SetSampleAttributes(capture, &attrs);
740 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
741 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
742 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
743 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
744 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
745 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
746
747 ret = AudioCaptureStartAndOneFrame(capture);
748 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
749 ret = capture->GetCapturePosition(capture, &frames, &time);
750 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
751 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
752 EXPECT_GT(frames, INITIAL_VALUE);
753
754 capture->control.Stop((AudioHandle)capture);
755 adapter->DestroyCapture(adapter, capture);
756 manager->UnloadAdapter(manager, adapter);
757 }
758 /**
759 * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to 1
760 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012
761 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount to 1
762 * @tc.author: tiansuli
763 */
764 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012, TestSize.Level1)
765 {
766 int32_t ret = -1;
767 uint64_t channelCountExp = 1;
768 uint32_t sampleRateExp = 48000;
769 uint64_t frames = 0;
770 int64_t timeExp = 0;
771 struct AudioAdapter *adapter = nullptr;
772 struct AudioCapture *capture = nullptr;
773 struct AudioSampleAttributes attrs = {};
774 struct AudioSampleAttributes attrsValue = {};
775 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
776 TestAudioManager* manager = GetAudioManager();
777 ASSERT_NE(nullptr, GetAudioManager);
778 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
779 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
780 InitAttrs(attrs);
781 attrs.type = AUDIO_IN_MEDIA;
782 attrs.interleaved = false;
783 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
784 attrs.sampleRate = 48000;
785 attrs.channelCount = 1;
786 ret = capture->attr.SetSampleAttributes(capture, &attrs);
787 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
788 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
789 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
790 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
791 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
792 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
793
794 ret = AudioCaptureStartAndOneFrame(capture);
795 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
796 ret = capture->GetCapturePosition(capture, &frames, &time);
797 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
798 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
799 EXPECT_GT(frames, INITIAL_VALUE);
800
801 capture->control.Stop((AudioHandle)capture);
802 adapter->DestroyCapture(adapter, capture);
803 manager->UnloadAdapter(manager, adapter);
804 }
805 /**
806 * @tc.name Test ReqMmapBuffer API via legal input
807 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0001
808 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
809 * @tc.author: liweiming
810 */
811 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0001, TestSize.Level1)
812 {
813 int32_t ret = -1;
814 bool isRender = false;
815 int32_t reqSize = 0;
816 struct AudioMmapBufferDescripter desc = {};
817 struct AudioCapture *capture = nullptr;
818 struct AudioAdapter *adapter = nullptr;
819 ASSERT_NE(nullptr, GetAudioManager);
820 TestAudioManager* manager = GetAudioManager();
821 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
822 ASSERT_NE(nullptr, fp);
823 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
824 if (ret < 0 || capture == nullptr) {
825 fclose(fp);
826 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
827 ASSERT_EQ(nullptr, capture);
828 }
829 ret = InitMmapDesc(fp, desc, reqSize, isRender);
830 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
831 ret = capture->control.Start((AudioHandle)capture);
832 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
833 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
834 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
835 fclose(fp);
836 if (ret == 0) {
837 munmap(desc.memoryAddress, reqSize);
838 }
839 capture->control.Stop((AudioHandle)capture);
840 adapter->DestroyCapture(adapter, capture);
841 manager->UnloadAdapter(manager, adapter);
842 }
843 /**
844 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is bigger than
845 the size of actual audio file
846 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0002
847 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
848 incoming parameter reqSize is bigger than the size of actual audio file
849 * @tc.author: liweiming
850 */
851 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0002, TestSize.Level1)
852 {
853 int32_t ret = -1;
854 bool isRender = false;
855 int32_t reqSize = 0;
856 struct AudioMmapBufferDescripter desc = {};
857 struct AudioCapture *capture = nullptr;
858 struct AudioAdapter *adapter = nullptr;
859 ASSERT_NE(nullptr, GetAudioManager);
860 TestAudioManager *manager = GetAudioManager();
861 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
862 ASSERT_NE(nullptr, fp);
863 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
864 if (ret < 0 || capture == nullptr) {
865 fclose(fp);
866 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
867 ASSERT_EQ(nullptr, capture);
868 }
869 ret = InitMmapDesc(fp, desc, reqSize, isRender);
870 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
871 reqSize = reqSize + BUFFER_LENTH;
872 ret = capture->control.Start((AudioHandle)capture);
873 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
874 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
875 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
876 fclose(fp);
877 capture->control.Stop((AudioHandle)capture);
878 adapter->DestroyCapture(adapter, capture);
879 manager->UnloadAdapter(manager, adapter);
880 }
881 /**
882 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is smaller than
883 the size of actual audio file
884 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0003
885 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the
886 incoming parameter reqSize is smaller than the size of actual audio file
887 * @tc.author: liweiming
888 */
889 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0003, TestSize.Level1)
890 {
891 int32_t ret = -1;
892 bool isRender = false;
893 int32_t reqSize = 0;
894 struct AudioMmapBufferDescripter desc = {};
895 struct AudioCapture *capture = nullptr;
896 struct AudioAdapter *adapter = nullptr;
897 ASSERT_NE(nullptr, GetAudioManager);
898 TestAudioManager *manager = GetAudioManager();
899 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
900 ASSERT_NE(nullptr, fp);
901 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
902 if (ret < 0 || capture == nullptr) {
903 fclose(fp);
904 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
905 ASSERT_EQ(nullptr, capture);
906 }
907 ret = InitMmapDesc(fp, desc, reqSize, isRender);
908 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
909 reqSize = reqSize / 2;
910 ret = capture->control.Start((AudioHandle)capture);
911 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
912 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
913 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
914 fclose(fp);
915 if (ret == 0) {
916 munmap(desc.memoryAddress, reqSize);
917 }
918 capture->control.Stop((AudioHandle)capture);
919 adapter->DestroyCapture(adapter, capture);
920 manager->UnloadAdapter(manager, adapter);
921 }
922 /**
923 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is zero
924 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0004
925 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessful when setting the
926 incoming parameter reqSize is zero
927 * @tc.author: liweiming
928 */
929 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0004, TestSize.Level1)
930 {
931 int32_t ret = -1;
932 bool isRender = false;
933 int32_t reqSize = 0;
934 struct AudioMmapBufferDescripter desc = {};
935 struct AudioCapture *capture = nullptr;
936 struct AudioAdapter *adapter = nullptr;
937 ASSERT_NE(nullptr, GetAudioManager);
938 TestAudioManager *manager = GetAudioManager();
939 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
940 ASSERT_NE(nullptr, fp);
941 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
942 if (ret < 0 || capture == nullptr) {
943 fclose(fp);
944 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
945 ASSERT_EQ(nullptr, capture);
946 }
947 ret = InitMmapDesc(fp, desc, reqSize, isRender);
948 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
949 reqSize = 0;
950 ret = capture->control.Start((AudioHandle)capture);
951 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
952 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
953 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
954 fclose(fp);
955 capture->control.Stop((AudioHandle)capture);
956 adapter->DestroyCapture(adapter, capture);
957 manager->UnloadAdapter(manager, adapter);
958 }
959 /**
960 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter memoryFd of desc is illegal
961 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0005
962 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
963 incoming parameter memoryFd of desc is illegal
964 * @tc.author: liweiming
965 */
966 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0005, TestSize.Level1)
967 {
968 int32_t ret = -1;
969 bool isRender = false;
970 int32_t reqSize = 0;
971 struct AudioMmapBufferDescripter desc = {};
972 struct AudioCapture *capture = nullptr;
973 struct AudioAdapter *adapter = nullptr;
974 ASSERT_NE(nullptr, GetAudioManager);
975 TestAudioManager *manager = GetAudioManager();
976 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
977 ASSERT_NE(nullptr, fp);
978 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
979 if (ret < 0 || capture == nullptr) {
980 fclose(fp);
981 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
982 ASSERT_EQ(nullptr, capture);
983 }
984 ret = InitMmapDesc(fp, desc, reqSize, isRender);
985 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
986 desc.memoryFd = 1;
987 ret = capture->control.Start((AudioHandle)capture);
988 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
989 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
990 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
991 fclose(fp);
992 capture->control.Stop((AudioHandle)capture);
993 adapter->DestroyCapture(adapter, capture);
994 manager->UnloadAdapter(manager, adapter);
995 }
996 /**
997 * @tc.name Test ReqMmapBuffer API via the incoming parameter handle is nullptr
998 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0006
999 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
1000 incoming parameter handle is nullptr
1001 * @tc.author: liweiming
1002 */
1003 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0006, TestSize.Level1)
1004 {
1005 int32_t ret = -1;
1006 bool isRender = false;
1007 int32_t reqSize = 0;
1008 struct AudioMmapBufferDescripter desc = {};
1009 struct AudioCapture *capture = nullptr;
1010 struct AudioCapture *captureNull = nullptr;
1011 struct AudioAdapter *adapter = nullptr;
1012 ASSERT_NE(nullptr, GetAudioManager);
1013 TestAudioManager* manager = GetAudioManager();
1014 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
1015 ASSERT_NE(nullptr, fp);
1016 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1017 if (ret < 0 || capture == nullptr) {
1018 fclose(fp);
1019 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1020 ASSERT_EQ(nullptr, capture);
1021 }
1022 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1023 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1024 ret = capture->control.Start((AudioHandle)capture);
1025 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1026 ret = capture->attr.ReqMmapBuffer((AudioHandle)captureNull, reqSize, &desc);
1027 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1028 fclose(fp);
1029 capture->control.Stop((AudioHandle)capture);
1030 adapter->DestroyCapture(adapter, capture);
1031 manager->UnloadAdapter(manager, adapter);
1032 }
1033 /**
1034 * @tc.name Test ReqMmapBuffer API via the incoming parameter desc is nullptr
1035 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0007
1036 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
1037 incoming parameter desc is nullptr
1038 * @tc.author: liweiming
1039 */
1040 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0007, TestSize.Level1)
1041 {
1042 int32_t ret = -1;
1043 uint32_t reqSize = 0;
1044 struct AudioMmapBufferDescripter *descNull = nullptr;
1045 struct AudioCapture *capture = nullptr;
1046 struct AudioAdapter *adapter = nullptr;
1047 ASSERT_NE(nullptr, GetAudioManager);
1048 TestAudioManager* manager = GetAudioManager();
1049 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1050 if (ret < 0 || capture == nullptr) {
1051 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1052 ASSERT_EQ(nullptr, capture);
1053 }
1054 reqSize = FILE_CAPTURE_SIZE;
1055 ret = capture->control.Start((AudioHandle)capture);
1056 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1057 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, descNull);
1058 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1059 capture->control.Stop((AudioHandle)capture);
1060 adapter->DestroyCapture(adapter, capture);
1061 manager->UnloadAdapter(manager, adapter);
1062 }
1063
1064 /**
1065 * @tc.name Test GetMmapPosition API via Getting position is normal in Before recording , recording and after recording
1066 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0001
1067 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1068 * @tc.author: zhouyongxiao
1069 */
1070 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0001, TestSize.Level1)
1071 {
1072 int32_t ret = -1;
1073 uint64_t frames = 0;
1074 uint64_t framesCapturing = 0;
1075 uint64_t framesExpCapture = 0;
1076 int64_t timeExp = 0;
1077 int64_t timeExpCaptureing = 0;
1078 struct PrepareAudioPara audiopara = {
1079 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1080 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1081 };
1082 ASSERT_NE(nullptr, GetAudioManager);
1083 audiopara.manager = GetAudioManager();
1084 ASSERT_NE(nullptr, audiopara.manager);
1085 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1086 &audiopara.capture);
1087 if (ret < 0 || audiopara.capture == nullptr) {
1088 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1089 ASSERT_EQ(nullptr, audiopara.capture);
1090 }
1091 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
1092 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1093 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1094 EXPECT_EQ(frames, INITIAL_VALUE);
1095 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
1096 if (ret != 0) {
1097 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1098 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1099 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1100 }
1101 sleep(1);
1102 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesCapturing, &(audiopara.time));
1103 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1104 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1105 EXPECT_GT(framesCapturing, INITIAL_VALUE);
1106 timeExpCaptureing = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
1107 void *result = nullptr;
1108 pthread_join(audiopara.tids, &result);
1109 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1110 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesExpCapture, &(audiopara.time));
1111 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1112 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExpCaptureing);
1113 EXPECT_GT(framesExpCapture, framesCapturing);
1114
1115 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
1116 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1117 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1118 }
1119 /**
1120 * @tc.name Test GetMmapPosition API via SetSampleAttributes and Getting position is normal.
1121 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0002
1122 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1123 * @tc.author: zhouyongxiao
1124 */
1125 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0002, TestSize.Level1)
1126 {
1127 int32_t ret = -1;
1128 uint64_t frames = 0;
1129 int64_t timeExp = 0;
1130 struct PrepareAudioPara audiopara = {
1131 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1132 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1133 };
1134 ASSERT_NE(nullptr, GetAudioManager);
1135 audiopara.manager = GetAudioManager();
1136 ASSERT_NE(nullptr, audiopara.manager);
1137 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1138 &audiopara.capture);
1139 if (ret < 0 || audiopara.capture == nullptr) {
1140 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1141 ASSERT_EQ(nullptr, audiopara.capture);
1142 }
1143 InitAttrs(audiopara.attrs);
1144 audiopara.attrs.format = AUDIO_FORMAT_PCM_24_BIT;
1145 audiopara.attrs.channelCount = 1;
1146 ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &(audiopara.attrs));
1147 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1148
1149 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
1150 if (ret != 0) {
1151 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1152 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1153 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1154 }
1155
1156 void *result = nullptr;
1157 pthread_join(audiopara.tids, &result);
1158 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1159
1160 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
1161 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1162 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1163 EXPECT_GT(frames, INITIAL_VALUE);
1164
1165 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
1166 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1167 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1168 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1169 }
1170 /**
1171 * @tc.name Test ReqMmapBuffer API via inputtint frames is nullptr.
1172 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0003
1173 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1174 * @tc.author: zhouyongxiao
1175 */
1176 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0003, TestSize.Level1)
1177 {
1178 int32_t ret = -1;
1179 uint64_t *frames = nullptr;
1180 struct PrepareAudioPara audiopara = {
1181 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1182 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1183 };
1184 ASSERT_NE(nullptr, GetAudioManager);
1185 audiopara.manager = GetAudioManager();
1186 ASSERT_NE(nullptr, audiopara.manager);
1187 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1188 &audiopara.capture);
1189 if (ret < 0 || audiopara.capture == nullptr) {
1190 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1191 ASSERT_EQ(nullptr, audiopara.capture);
1192 }
1193
1194 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, frames, &(audiopara.time));
1195 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1196
1197 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1198 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1199 }
1200 /**
1201 * @tc.name Test ReqMmapBuffer API via inputtint time is nullptr.
1202 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0004
1203 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1204 * @tc.author: zhouyongxiao
1205 */
1206 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0004, TestSize.Level1)
1207 {
1208 int32_t ret = -1;
1209 uint64_t frames = 0;
1210 struct AudioTimeStamp *time = nullptr;
1211 struct PrepareAudioPara audiopara = {
1212 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1213 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1214 };
1215 ASSERT_NE(nullptr, GetAudioManager);
1216 audiopara.manager = GetAudioManager();
1217 ASSERT_NE(nullptr, audiopara.manager);
1218 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1219 &audiopara.capture);
1220 if (ret < 0 || audiopara.capture == nullptr) {
1221 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1222 ASSERT_EQ(nullptr, audiopara.capture);
1223 }
1224
1225 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, time);
1226 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1227
1228 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1229 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1230 }
1231 /**
1232 * @tc.name Test ReqMmapBuffer API via inputtint capture is nullptr.
1233 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0005
1234 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1235 * @tc.author: zhouyongxiao
1236 */
1237 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0005, TestSize.Level1)
1238 {
1239 int32_t ret = -1;
1240 uint64_t frames = 0;
1241 struct AudioCapture *captureNull = nullptr;
1242 struct PrepareAudioPara audiopara = {
1243 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
1244 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1245 };
1246 ASSERT_NE(nullptr, GetAudioManager);
1247 audiopara.manager = GetAudioManager();
1248 ASSERT_NE(nullptr, audiopara.manager);
1249 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1250 &audiopara.capture);
1251 if (ret < 0 || audiopara.capture == nullptr) {
1252 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1253 ASSERT_EQ(nullptr, audiopara.capture);
1254 }
1255
1256 ret = audiopara.capture->attr.GetMmapPosition(captureNull, &frames, &(audiopara.time));
1257 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1258
1259 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1260 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1261 }
1262 }