1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /**
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 OHOS::Audio;
42
43 namespace {
44 const int BUFFER_SIZE = 16384;
45 const int BUFFER_SIZE_LITTLE = 0;
46 const uint64_t FILESIZE = 1024;
47
48 class AudioHdiCaptureTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 static TestAudioManager *manager;
55 };
56
57 using THREAD_FUNC = void *(*)(void *);
58 TestAudioManager *AudioHdiCaptureTest::manager = nullptr;
59
SetUpTestCase(void)60 void AudioHdiCaptureTest::SetUpTestCase(void)
61 {
62 manager = GetAudioManagerFuncs();
63 ASSERT_NE(nullptr, manager);
64 }
65
TearDownTestCase(void)66 void AudioHdiCaptureTest::TearDownTestCase(void) {}
67
68
SetUp(void)69 void AudioHdiCaptureTest::SetUp(void) {}
70
TearDown(void)71 void AudioHdiCaptureTest::TearDown(void) {}
72
73 /**
74 * @tc.name AudioCaptureFrame_001
75 * @tc.desc test AudioCaptureCaptureFrame interface,Returns 0 if the input data is read successfully
76 * @tc.type: FUNC
77 */
78 HWTEST_F(AudioHdiCaptureTest, AudioCaptureFrame_001, TestSize.Level1)
79 {
80 uint64_t replyBytes = 0;
81 uint64_t requestBytes = BUFFER_SIZE;
82 struct AudioAdapter *adapter = nullptr;
83 struct AudioCapture *capture = nullptr;
84
85 ASSERT_NE(nullptr, manager);
86 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
87 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
88 ret = capture->control.Start((AudioHandle)capture);
89 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
90 char *frame = static_cast<char *>(calloc(1, BUFFER_SIZE));
91 EXPECT_NE(nullptr, frame);
92 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
93 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
94
95 capture->control.Stop((AudioHandle)capture);
96 adapter->DestroyCapture(adapter, capture);
97 manager->UnloadAdapter(manager, adapter);
98 if (frame != nullptr) {
99 free(frame);
100 frame = nullptr;
101 }
102 }
103 /**
104 * @tc.name AudioCaptureFrame_002
105 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter frame is nullptr
106 * @tc.type: FUNC
107 */
108 HWTEST_F(AudioHdiCaptureTest, AudioCaptureFrame_002, TestSize.Level1)
109 {
110 uint64_t replyBytes = 0;
111 uint64_t requestBytes = BUFFER_SIZE;
112 struct AudioAdapter *adapter = nullptr;
113 struct AudioCapture *capture = nullptr;
114 char *frame = nullptr;
115
116 ASSERT_NE(nullptr, manager);
117 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
118 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
119 ret = capture->control.Start((AudioHandle)capture);
120 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
121 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
122 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
123
124 capture->control.Stop((AudioHandle)capture);
125 adapter->DestroyCapture(adapter, capture);
126 manager->UnloadAdapter(manager, adapter);
127 }
128 /**
129 * @tc.name AudioCaptureFrame_003
130 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr
131 * @tc.type: FUNC
132 */
133 HWTEST_F(AudioHdiCaptureTest, AudioCaptureFrame_003, TestSize.Level1)
134 {
135 uint64_t requestBytes = BUFFER_SIZE;
136 struct AudioAdapter *adapter = nullptr;
137 struct AudioCapture *capture = nullptr;
138 uint64_t *replyBytes = nullptr;
139
140 ASSERT_NE(nullptr, manager);
141 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
142 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
143 ret = capture->control.Start((AudioHandle)capture);
144 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
145 char *frame = static_cast<char *>(calloc(1, BUFFER_SIZE));
146 EXPECT_NE(nullptr, frame);
147 ret = capture->CaptureFrame(capture, frame, requestBytes, replyBytes);
148 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
149
150 capture->control.Stop((AudioHandle)capture);
151 adapter->DestroyCapture(adapter, capture);
152 manager->UnloadAdapter(manager, adapter);
153 if (frame != nullptr) {
154 free(frame);
155 frame = nullptr;
156 }
157 }
158 /**
159 * @tc.name AudioCaptureFrame_004
160 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter capture is nullptr
161 * @tc.type: FUNC
162 */
163 HWTEST_F(AudioHdiCaptureTest, AudioCaptureFrame_004, TestSize.Level1)
164 {
165 uint64_t requestBytes = BUFFER_SIZE;
166 uint64_t replyBytes = 0;
167 struct AudioAdapter *adapter = nullptr;
168 struct AudioCapture *capture = nullptr;
169 struct AudioCapture *captureNull = nullptr;
170
171 ASSERT_NE(nullptr, manager);
172 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
173 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
174 ret = capture->control.Start((AudioHandle)capture);
175 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
176 char *frame = static_cast<char *>(calloc(1, BUFFER_SIZE));
177 EXPECT_NE(nullptr, frame);
178 ret = capture->CaptureFrame(captureNull, frame, requestBytes, &replyBytes);
179 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
180
181 capture->control.Stop((AudioHandle)capture);
182 adapter->DestroyCapture(adapter, capture);
183 manager->UnloadAdapter(manager, adapter);
184 if (frame != nullptr) {
185 free(frame);
186 frame = nullptr;
187 }
188 }
189 /**
190 * @tc.name AudioCaptureFrame_005
191 * @tc.desc Test AudioCaptureFrame interface,Returns -1 if without calling interface capturestart
192 * @tc.type: FUNC
193 */
194 HWTEST_F(AudioHdiCaptureTest, AudioCaptureFrame_005, TestSize.Level1)
195 {
196 uint64_t requestBytes = BUFFER_SIZE;
197 struct AudioAdapter *adapter = nullptr;
198 struct AudioCapture *capture = nullptr;
199 uint64_t replyBytes = 0;
200
201 ASSERT_NE(nullptr, manager);
202 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
203 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
204 char *frame = static_cast<char *>(calloc(1, BUFFER_SIZE));
205 EXPECT_NE(nullptr, frame);
206 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
207 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
208
209 adapter->DestroyCapture(adapter, capture);
210 manager->UnloadAdapter(manager, adapter);
211 if (frame != nullptr) {
212 free(frame);
213 frame = nullptr;
214 }
215 }
216 /**
217 less than interface requirements
218 * @tc.name AudioCaptureFrame_006
219 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter
220 requestBytes less than interface requirements
221 * @tc.type: FUNC
222 */
223 HWTEST_F(AudioHdiCaptureTest, AudioCaptureFrame_006, TestSize.Level1)
224 {
225 uint64_t requestBytes = BUFFER_SIZE_LITTLE;
226 uint64_t replyBytes = 0;
227 struct AudioAdapter *adapter = nullptr;
228 struct AudioCapture *capture = nullptr;
229
230 ASSERT_NE(nullptr, manager);
231 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
232 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
233 ret = capture->control.Start((AudioHandle)capture);
234 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
235 char *frame = static_cast<char *>(calloc(1, BUFFER_SIZE));
236 EXPECT_NE(nullptr, frame);
237 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
238 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
239
240 capture->control.Stop((AudioHandle)capture);
241 adapter->DestroyCapture(adapter, capture);
242 manager->UnloadAdapter(manager, adapter);
243 if (frame != nullptr) {
244 free(frame);
245 frame = nullptr;
246 }
247 }
248 /**
249 * @tc.name AudioCaptureGetCapturePosition_001
250 * @tc.desc Test AudioCaptureGetCapturePosition interface,Returns 0 if get CapturePosition during playing.
251 * @tc.type: FUNC
252 */
253 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_001, TestSize.Level1)
254 {
255 uint64_t frames = 0;
256 int64_t timeExp = 0;
257 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
258 struct PrepareAudioPara audiopara = {
259 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
260 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
261 };
262 audiopara.manager = manager;
263 ASSERT_NE(nullptr, audiopara.manager);
264
265 int32_t ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
266 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
267 sleep(1);
268 if (audiopara.capture != nullptr) {
269 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
270 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
271 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
272 EXPECT_GT(frames, INITIAL_VALUE);
273 }
274
275 ret = ThreadRelease(audiopara);
276 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
277 }
278 /**
279 * @tc.name AudioCaptureGetCapturePosition_002
280 * @tc.desc Test GetCapturePosition interface,Returns 0 if get Position after Pause and resume during playing
281 * @tc.type: FUNC
282 */
283 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_002, TestSize.Level1)
284 {
285 int64_t timeExp = 0;
286 uint64_t frames = 0;
287 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
288 struct PrepareAudioPara audiopara = {
289 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
290 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
291 };
292 audiopara.manager = manager;
293 ASSERT_NE(nullptr, audiopara.manager);
294
295 int32_t ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
296 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
297 sleep(1);
298 if (audiopara.capture != nullptr) {
299 ret = audiopara.capture->control.Pause((AudioHandle)(audiopara.capture));
300 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
301 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
302 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
303 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
304 EXPECT_GT(frames, INITIAL_VALUE);
305 ret = audiopara.capture->control.Resume((AudioHandle)(audiopara.capture));
306 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
307 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
308 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
309 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
310 EXPECT_GT(frames, INITIAL_VALUE);
311 }
312
313 ret = ThreadRelease(audiopara);
314 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
315 }
316 /**
317 * @tc.name AudioCaptureGetCapturePosition_003
318 * @tc.desc Test GetCapturePosition interface,Returns 0 if get CapturePosition after stop during playing
319 * @tc.type: FUNC
320 */
321 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_003, TestSize.Level1)
322 {
323 struct AudioAdapter *adapter = {};
324 struct AudioCapture *capture = nullptr;
325 uint64_t frames = 0;
326 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
327 int64_t timeExp = 0;
328
329 ASSERT_NE(nullptr, manager);
330 int32_t ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
331 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
332 ret = capture->control.Stop((AudioHandle)capture);
333 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
334 ret = capture->GetCapturePosition(capture, &frames, &time);
335 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
336 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
337 EXPECT_GT(frames, INITIAL_VALUE);
338
339 adapter->DestroyCapture(adapter, capture);
340 manager->UnloadAdapter(manager, adapter);
341 }
342 /**
343 * @tc.name AudioCaptureGetCapturePosition_004
344 * @tc.desc Test GetCapturePosition interface, return 0 if get CapturePosition after the object is created
345 * @tc.type: FUNC
346 */
347 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_004, TestSize.Level1)
348 {
349 struct AudioAdapter *adapter = {};
350 struct AudioCapture *capture = nullptr;
351 uint64_t frames = 0;
352 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
353 int64_t timeExp = 0;
354
355 ASSERT_NE(nullptr, manager);
356 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
357 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
358 ret = capture->GetCapturePosition(capture, &frames, &time);
359 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
360 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
361
362 adapter->DestroyCapture(adapter, capture);
363 manager->UnloadAdapter(manager, adapter);
364 }
365 /**
366 * @tc.name AudioCaptureGetCapturePosition_005
367 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter Capture is nullptr
368 * @tc.type: FUNC
369 */
370 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_005, TestSize.Level1)
371 {
372 struct AudioAdapter *adapter = {};
373 struct AudioCapture *capture = nullptr;
374 struct AudioCapture *captureNull = nullptr;
375 uint64_t frames = 0;
376 struct AudioTimeStamp time = {};
377
378 ASSERT_NE(nullptr, manager);
379 int32_t ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
380 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
381 ret = capture->GetCapturePosition(captureNull, &frames, &time);
382 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
383
384 capture->control.Stop((AudioHandle)capture);
385 adapter->DestroyCapture(adapter, capture);
386 manager->UnloadAdapter(manager, adapter);
387 }
388 /**
389 * @tc.name AudioCaptureGetCapturePosition_006
390 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter frames is nullptr
391 * @tc.type: FUNC
392 */
393 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_006, TestSize.Level1)
394 {
395 struct AudioAdapter *adapter = {};
396 struct AudioCapture *capture = nullptr;
397 uint64_t *framesNull = nullptr;
398 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
399
400 ASSERT_NE(nullptr, manager);
401 int32_t ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
402 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
403 ret = capture->GetCapturePosition(capture, framesNull, &time);
404 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
405
406 capture->control.Stop((AudioHandle)capture);
407 adapter->DestroyCapture(adapter, capture);
408 manager->UnloadAdapter(manager, adapter);
409 }
410 /**
411 * @tc.name AudioCaptureGetCapturePosition_007
412 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter time is nullptr
413 * @tc.type: FUNC
414 */
415 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_007, TestSize.Level1)
416 {
417 struct AudioAdapter *adapter = {};
418 struct AudioCapture *capture = nullptr;
419 uint64_t frames = 0;
420 struct AudioTimeStamp *timeNull = nullptr;
421
422 ASSERT_NE(nullptr, manager);
423 int32_t ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
424 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
425 ret = capture->GetCapturePosition(capture, &frames, timeNull);
426 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
427
428 capture->control.Stop((AudioHandle)capture);
429 adapter->DestroyCapture(adapter, capture);
430 manager->UnloadAdapter(manager, adapter);
431 }
432 /**
433 * @tc.name AudioCaptureGetCapturePosition_008
434 * @tc.desc Test GetCapturePosition interface, return 0 if the GetCapturePosition was called twice
435 * @tc.type: FUNC
436 */
437 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetCapturePosition_008, TestSize.Level1)
438 {
439 struct AudioAdapter *adapter = {};
440 struct AudioCapture *capture = nullptr;
441 uint64_t frames = 0;
442 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
443 struct AudioTimeStamp timeSec = {.tvSec = 0, .tvNSec = 0};
444 int64_t timeExp = 0;
445
446 ASSERT_NE(nullptr, manager);
447 int32_t ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
448 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
449 ret = capture->GetCapturePosition(capture, &frames, &time);
450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
451 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
452 EXPECT_GT(frames, INITIAL_VALUE);
453 ret = capture->GetCapturePosition(capture, &frames, &timeSec);
454 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
455 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
456 EXPECT_GT(frames, INITIAL_VALUE);
457
458 capture->control.Stop((AudioHandle)capture);
459 adapter->DestroyCapture(adapter, capture);
460 manager->UnloadAdapter(manager, adapter);
461 }
462 /**
463 * @tc.name AudioCaptureReqMmapBuffer_001
464 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
465 * @tc.type: FUNC
466 */
467 HWTEST_F(AudioHdiCaptureTest, AudioCaptureReqMmapBuffer_001, TestSize.Level1)
468 {
469 bool isRender = false;
470 int32_t reqSize = 0;
471 struct AudioMmapBufferDescripter desc = {};
472 struct AudioCapture *capture = nullptr;
473 struct AudioAdapter *adapter = nullptr;
474 ASSERT_NE(nullptr, manager);
475 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
476 ASSERT_NE(nullptr, fp);
477 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
478 if (ret < 0 || capture == nullptr) {
479 fclose(fp);
480 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
481 ASSERT_EQ(nullptr, capture);
482 }
483 ret = InitMmapDesc(fp, desc, reqSize, isRender);
484 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
485 ret = capture->control.Start((AudioHandle)capture);
486 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
487 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
488 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
489 fclose(fp);
490 if (ret == 0) {
491 munmap(desc.memoryAddress, reqSize);
492 }
493 capture->control.Stop((AudioHandle)capture);
494 adapter->DestroyCapture(adapter, capture);
495 manager->UnloadAdapter(manager, adapter);
496 }
497 /**
498 * @tc.name AudioRenderReqMmapBuffer_002
499 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
500 incoming parameter reqSize is bigger than the size of actual audio file
501 * @tc.type: FUNC
502 */
503 HWTEST_F(AudioHdiCaptureTest, AudioCaptureReqMmapBuffer_002, TestSize.Level1)
504 {
505 bool isRender = false;
506 int32_t reqSize = 0;
507 struct AudioMmapBufferDescripter desc = {};
508 struct AudioCapture *capture = nullptr;
509 struct AudioAdapter *adapter = nullptr;
510 ASSERT_NE(nullptr, manager);
511 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
512 ASSERT_NE(nullptr, fp);
513 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
514 if (ret < 0 || capture == nullptr) {
515 fclose(fp);
516 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
517 ASSERT_EQ(nullptr, capture);
518 }
519 ret = InitMmapDesc(fp, desc, reqSize, isRender);
520 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
521 reqSize = reqSize + BUFFER_LENTH;
522 ret = capture->control.Start((AudioHandle)capture);
523 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
524 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
525 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
526 fclose(fp);
527 capture->control.Stop((AudioHandle)capture);
528 adapter->DestroyCapture(adapter, capture);
529 manager->UnloadAdapter(manager, adapter);
530 }
531 /**
532 * @tc.name AudioCaptureReqMmapBuffer_003
533 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the
534 incoming parameter reqSize is smaller than the size of actual audio file
535 * @tc.type: FUNC
536 */
537 HWTEST_F(AudioHdiCaptureTest, AudioCaptureReqMmapBuffer_003, TestSize.Level1)
538 {
539 bool isRender = false;
540 int32_t reqSize = 0;
541 struct AudioMmapBufferDescripter desc = {};
542 struct AudioCapture *capture = nullptr;
543 struct AudioAdapter *adapter = nullptr;
544 ASSERT_NE(nullptr, manager);
545 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
546 ASSERT_NE(nullptr, fp);
547 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
548 if (ret < 0 || capture == nullptr) {
549 fclose(fp);
550 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
551 ASSERT_EQ(nullptr, capture);
552 }
553 ret = InitMmapDesc(fp, desc, reqSize, isRender);
554 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
555 reqSize = reqSize / 2;
556 ret = capture->control.Start((AudioHandle)capture);
557 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
558 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
559 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
560 fclose(fp);
561 if (ret == 0) {
562 munmap(desc.memoryAddress, reqSize);
563 }
564 capture->control.Stop((AudioHandle)capture);
565 adapter->DestroyCapture(adapter, capture);
566 manager->UnloadAdapter(manager, adapter);
567 }
568 /**
569 * @tc.name AudioCaptureReqMmapBuffer_004
570 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessful when setting the
571 incoming parameter reqSize is zero
572 * @tc.type: FUNC
573 */
574 HWTEST_F(AudioHdiCaptureTest, AudioCaptureReqMmapBuffer_004, TestSize.Level1)
575 {
576 bool isRender = false;
577 int32_t reqSize = 0;
578 struct AudioMmapBufferDescripter desc = {};
579 struct AudioCapture *capture = nullptr;
580 struct AudioAdapter *adapter = nullptr;
581 ASSERT_NE(nullptr, manager);
582 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
583 ASSERT_NE(nullptr, fp);
584 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
585 if (ret < 0 || capture == nullptr) {
586 fclose(fp);
587 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
588 ASSERT_EQ(nullptr, capture);
589 }
590 ret = InitMmapDesc(fp, desc, reqSize, isRender);
591 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
592 reqSize = 0;
593 ret = capture->control.Start((AudioHandle)capture);
594 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
595 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
596 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
597 fclose(fp);
598 capture->control.Stop((AudioHandle)capture);
599 adapter->DestroyCapture(adapter, capture);
600 manager->UnloadAdapter(manager, adapter);
601 }
602 /**
603 * @tc.name AudioCaptureReqMmapBuffer_005
604 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
605 incoming parameter memoryFd of desc is illegal
606 * @tc.type: FUNC
607 */
608 HWTEST_F(AudioHdiCaptureTest, AudioCaptureReqMmapBuffer_005, TestSize.Level1)
609 {
610 bool isRender = false;
611 int32_t reqSize = 0;
612 struct AudioMmapBufferDescripter desc = {};
613 struct AudioCapture *capture = nullptr;
614 struct AudioAdapter *adapter = nullptr;
615 ASSERT_NE(nullptr, manager);
616 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
617 ASSERT_NE(nullptr, fp);
618 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
619 if (ret < 0 || capture == nullptr) {
620 fclose(fp);
621 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
622 ASSERT_EQ(nullptr, capture);
623 }
624 ret = InitMmapDesc(fp, desc, reqSize, isRender);
625 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
626 desc.memoryFd = -1; // -1 is invalid fd
627 ret = capture->control.Start((AudioHandle)capture);
628 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
629 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
630 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
631 fclose(fp);
632 capture->control.Stop((AudioHandle)capture);
633 adapter->DestroyCapture(adapter, capture);
634 manager->UnloadAdapter(manager, adapter);
635 }
636 /**
637 * @tc.name AudioCaptureReqMmapBuffer_006
638 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
639 incoming parameter handle is nullptr
640 * @tc.type: FUNC
641 */
642 HWTEST_F(AudioHdiCaptureTest, AudioCaptureReqMmapBuffer_006, TestSize.Level1)
643 {
644 bool isRender = false;
645 int32_t reqSize = 0;
646 struct AudioMmapBufferDescripter desc = {};
647 struct AudioCapture *capture = nullptr;
648 struct AudioCapture *captureNull = nullptr;
649 struct AudioAdapter *adapter = nullptr;
650 ASSERT_NE(nullptr, manager);
651 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
652 ASSERT_NE(nullptr, fp);
653 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
654 if (ret < 0 || capture == nullptr) {
655 fclose(fp);
656 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
657 ASSERT_EQ(nullptr, capture);
658 }
659 ret = InitMmapDesc(fp, desc, reqSize, isRender);
660 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
661 ret = capture->control.Start((AudioHandle)capture);
662 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
663 ret = capture->attr.ReqMmapBuffer((AudioHandle)captureNull, reqSize, &desc);
664 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
665 fclose(fp);
666 capture->control.Stop((AudioHandle)capture);
667 adapter->DestroyCapture(adapter, capture);
668 manager->UnloadAdapter(manager, adapter);
669 }
670 /**
671 * @tc.name AudioCaptureReqMmapBuffer_007
672 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
673 incoming parameter desc is nullptr
674 * @tc.type: FUNC
675 */
676 HWTEST_F(AudioHdiCaptureTest, AudioCaptureReqMmapBuffer_007, TestSize.Level1)
677 {
678 uint32_t reqSize = 0;
679 struct AudioMmapBufferDescripter *descNull = nullptr;
680 struct AudioCapture *capture = nullptr;
681 struct AudioAdapter *adapter = nullptr;
682 ASSERT_NE(nullptr, manager);
683 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
684 if (ret < 0 || capture == nullptr) {
685 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
686 ASSERT_EQ(nullptr, capture);
687 }
688 reqSize = FILE_CAPTURE_SIZE;
689 ret = capture->control.Start((AudioHandle)capture);
690 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
691 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, descNull);
692 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
693 capture->control.Stop((AudioHandle)capture);
694 adapter->DestroyCapture(adapter, capture);
695 manager->UnloadAdapter(manager, adapter);
696 }
697
698 /**
699 * @tc.name AudioCaptureGetMmapPosition_001
700 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
701 * @tc.type: FUNC
702 */
703 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetMmapPosition_001, TestSize.Level1)
704 {
705 uint64_t frames = 0;
706 uint64_t framesCapturing = 0;
707 uint64_t framesExpCapture = 0;
708 int64_t timeExp = 0;
709 int64_t timeExpCaptureing = 0;
710 struct PrepareAudioPara audiopara = {
711 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
712 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
713 };
714 audiopara.manager = manager;
715 ASSERT_NE(nullptr, audiopara.manager);
716 int32_t ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
717 &audiopara.capture);
718 if (ret < 0 || audiopara.capture == nullptr) {
719 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
720 ASSERT_EQ(nullptr, audiopara.capture);
721 }
722 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
723 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
724 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
725 EXPECT_EQ(frames, INITIAL_VALUE);
726 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
727 if (ret != 0) {
728 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
729 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
730 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
731 }
732 sleep(1);
733 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesCapturing, &(audiopara.time));
734 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
735 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
736 EXPECT_GT(framesCapturing, INITIAL_VALUE);
737 timeExpCaptureing = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
738 void *result = nullptr;
739 pthread_join(audiopara.tids, &result);
740 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
741 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesExpCapture, &(audiopara.time));
742 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
743 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExpCaptureing);
744 EXPECT_GT(framesExpCapture, framesCapturing);
745
746 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
747 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
748 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
749 }
750 /**
751 * @tc.name AudioCaptureGetMmapPosition_003
752 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
753 * @tc.type: FUNC
754 */
755 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetMmapPosition_003, TestSize.Level1)
756 {
757 uint64_t *frames = nullptr;
758 struct PrepareAudioPara audiopara = {
759 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
760 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
761 };
762 audiopara.manager = manager;
763 ASSERT_NE(nullptr, audiopara.manager);
764 int32_t ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
765 &audiopara.capture);
766 if (ret < 0 || audiopara.capture == nullptr) {
767 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
768 ASSERT_EQ(nullptr, audiopara.capture);
769 }
770
771 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, frames, &(audiopara.time));
772 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
773
774 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
775 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
776 }
777 /**
778 * @tc.name AudioCaptureGetMmapPosition_004
779 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
780 * @tc.type: FUNC
781 */
782 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetMmapPosition_004, TestSize.Level1)
783 {
784 uint64_t frames = 0;
785 struct AudioTimeStamp *time = nullptr;
786 struct PrepareAudioPara audiopara = {
787 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
788 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
789 };
790 audiopara.manager = manager;
791 ASSERT_NE(nullptr, audiopara.manager);
792 int32_t ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
793 &audiopara.capture);
794 if (ret < 0 || audiopara.capture == nullptr) {
795 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
796 ASSERT_EQ(nullptr, audiopara.capture);
797 }
798
799 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, time);
800 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
801
802 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
803 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
804 }
805 /**
806 * @tc.name AudioRenderReqMmapBuffer_005
807 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
808 * @tc.type: FUNC
809 */
810 HWTEST_F(AudioHdiCaptureTest, AudioCaptureGetMmapPosition_005, TestSize.Level1)
811 {
812 uint64_t frames = 0;
813 struct AudioCapture *captureNull = nullptr;
814 struct PrepareAudioPara audiopara = {
815 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
816 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
817 };
818 audiopara.manager = manager;
819 ASSERT_NE(nullptr, audiopara.manager);
820 int32_t ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
821 &audiopara.capture);
822 if (ret < 0 || audiopara.capture == nullptr) {
823 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
824 ASSERT_EQ(nullptr, audiopara.capture);
825 }
826
827 ret = audiopara.capture->attr.GetMmapPosition(captureNull, &frames, &(audiopara.time));
828 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
829
830 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
831 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
832 }
833 }
834