1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_opensles_capture_unit_test.h"
17
18 using namespace std;
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace AudioStandard {
23 namespace {
24 const char *AUDIORENDER_TEST_FILE_PATH = "/data/test_capture.pcm";
25 FILE *wavFile_;
26 SLObjectItf engineObject_;
27 SLRecordItf captureItf_;
28 SLOHBufferQueueItf bufferQueueItf_;
29 SLObjectItf pcmCapturerObject_;
30 SLEngineItf engineEngine_;
31 } // namespace
32
BuqqerQueueCallback(SLOHBufferQueueItf bufferQueueItf,void * pContext,SLuint32 size)33 static void BuqqerQueueCallback(SLOHBufferQueueItf bufferQueueItf, void *pContext, SLuint32 size)
34 {
35 FILE *wavFile = (FILE *)pContext;
36 if (wavFile != nullptr) {
37 SLuint8 *buffer = nullptr;
38 SLuint32 pSize = 0;
39 (*bufferQueueItf)->GetBuffer(bufferQueueItf, &buffer, pSize);
40 if (buffer != nullptr) {
41 fwrite(buffer, 1, pSize, wavFile);
42 (*bufferQueueItf)->Enqueue(bufferQueueItf, buffer, size);
43 }
44 }
45
46 return;
47 }
48
SetUpTestCase(void)49 void AudioOpenslesCaptureUnitTest::SetUpTestCase(void) { }
50
TearDownTestCase(void)51 void AudioOpenslesCaptureUnitTest::TearDownTestCase(void) { }
52
SetUp(void)53 void AudioOpenslesCaptureUnitTest::SetUp(void) { }
54
TearDown(void)55 void AudioOpenslesCaptureUnitTest::TearDown(void) { }
56
57 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_CreateEngine_001, TestSize.Level0)
58 {
59 SLresult result = slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
60 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
61 }
62
63 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_CreateEngine_002, TestSize.Level0)
64 {
65 SLresult result = (*engineObject_)->Realize(engineObject_, SL_BOOLEAN_FALSE);
66 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
67 }
68
69 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_CreateEngine_003, TestSize.Level0)
70 {
71 SLresult result = (*engineObject_)->GetInterface(engineObject_, SL_IID_ENGINE, &engineEngine_);
72 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
73 }
74
75 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_CreateAudioRecorder_001, TestSize.Level0)
76 {
77 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
78 if (wavFile_ == nullptr) {
79 AUDIO_INFO_LOG("AudioCaptureTest: Unable to open record file.");
80 }
81
82 SLDataLocator_IODevice io_device = {
83 SL_DATALOCATOR_IODEVICE,
84 SL_IODEVICE_AUDIOINPUT,
85 SL_DEFAULTDEVICEID_AUDIOINPUT,
86 NULL
87 };
88
89 SLDataSource audioSource = {
90 &io_device,
91 NULL
92 };
93
94 SLDataLocator_BufferQueue buffer_queue = {
95 SL_DATALOCATOR_BUFFERQUEUE,
96 3
97 };
98
99 SLDataFormat_PCM format_pcm = {
100 SL_DATAFORMAT_PCM,
101 OHOS::AudioStandard::AudioChannel::MONO,
102 OHOS::AudioStandard::AudioSamplingRate::SAMPLE_RATE_44100,
103 SL_PCMSAMPLEFORMAT_FIXED_16,
104 0,
105 0,
106 0
107 };
108
109 SLDataSink audioSink = {
110 &buffer_queue,
111 &format_pcm
112 };
113
114 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
115 &audioSink, 0, nullptr, nullptr);
116 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
117 }
118
119 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_CreateAudioRecorder_002, TestSize.Level0)
120 {
121 SLresult result = (*pcmCapturerObject_)->Realize(pcmCapturerObject_, SL_BOOLEAN_FALSE);
122 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
123 }
124
125 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_CreateAudioRecorder_003, TestSize.Level0)
126 {
127 SLresult result = (*pcmCapturerObject_)->GetInterface(pcmCapturerObject_, SL_IID_RECORD, &captureItf_);
128 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
129 }
130
131 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetBufferQueue_001, TestSize.Level0)
132 {
133 SLresult result = (*pcmCapturerObject_)->GetInterface(pcmCapturerObject_, SL_IID_OH_BUFFERQUEUE, &bufferQueueItf_);
134 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
135 }
136
137 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_RegisterCallback_001, TestSize.Level0)
138 {
139 SLresult result = (*bufferQueueItf_)->RegisterCallback(bufferQueueItf_, BuqqerQueueCallback, wavFile_);
140 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
141 }
142
143 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_RegisterCallback_002, TestSize.Level1)
144 {
145 SLresult result = (*bufferQueueItf_)->RegisterCallback(nullptr, BuqqerQueueCallback, wavFile_);
146 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
147 }
148
149 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetRecordState_001, TestSize.Level0)
150 {
151 SLresult result = (*captureItf_)->SetRecordState(captureItf_, SL_RECORDSTATE_RECORDING);
152 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
153 }
154
155 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_001, TestSize.Level0)
156 {
157 if (wavFile_ != nullptr) {
158 SLuint8* buffer = nullptr;
159 SLuint32 size = 0;
160 SLresult result = (*bufferQueueItf_)->GetBuffer(bufferQueueItf_, &buffer, size);
161 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
162 if (buffer != nullptr) {
163 fwrite(buffer, 1, size, wavFile_);
164 result = (*bufferQueueItf_)->Enqueue(bufferQueueItf_, buffer, size);
165 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
166 }
167 }
168 }
169
170 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetState_001, TestSize.Level0)
171 {
172 SLOHBufferQueueState state;
173 SLresult result = (*bufferQueueItf_)->GetState(bufferQueueItf_, &state);
174 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
175 }
176
177 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetState_002, TestSize.Level1)
178 {
179 SLOHBufferQueueState state;
180 SLresult result = (*bufferQueueItf_)->GetState(nullptr, &state);
181 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
182 }
183
184 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetBuffer_001, TestSize.Level1)
185 {
186 SLuint32 pSize = 0;
187 SLresult result = (*bufferQueueItf_)->GetBuffer(nullptr, nullptr, pSize);
188 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
189 }
190
191 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetRecordState_002, TestSize.Level0)
192 {
193 SLresult result = (*captureItf_)->SetRecordState(captureItf_, SL_RECORDSTATE_PAUSED);
194 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
195 }
196
197 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetRecordState_003, TestSize.Level0)
198 {
199 SLresult result = (*captureItf_)->SetRecordState(captureItf_, SL_RECORDSTATE_STOPPED);
200 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
201 }
202
203 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetRecordState_004, TestSize.Level1)
204 {
205 SLresult result = (*captureItf_)->SetRecordState(nullptr, SL_RECORDSTATE_STOPPED);
206 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
207 }
208
209 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetRecordState_001, TestSize.Level0)
210 {
211 SLuint32 state;
212 SLresult result = (*captureItf_)->GetRecordState(captureItf_, &state);
213 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
214 }
215
216 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetRecordState_002, TestSize.Level1)
217 {
218 SLuint32 state;
219 SLresult result = (*captureItf_)->GetRecordState(nullptr, &state);
220 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
221 }
222
223 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetDurationLimit_001, TestSize.Level1)
224 {
225 SLresult result = (*captureItf_)->SetDurationLimit(nullptr, 0);
226 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
227 }
228
229 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetPosition_001, TestSize.Level1)
230 {
231 SLresult result = (*captureItf_)->GetPosition(nullptr, 0);
232 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
233 }
234
235 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_RegisterCallback_003, TestSize.Level1)
236 {
237 SLresult result = (*captureItf_)->RegisterCallback(captureItf_, nullptr, wavFile_);
238 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
239 }
240
241 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetCallbackEventsMask_001, TestSize.Level1)
242 {
243 SLresult result = (*captureItf_)->SetCallbackEventsMask(nullptr, 0);
244 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
245 }
246
247 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetCallbackEventsMask_001, TestSize.Level1)
248 {
249 SLresult result = (*captureItf_)->GetCallbackEventsMask(nullptr, nullptr);
250 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
251 }
252
253 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetMarkerPosition_001, TestSize.Level1)
254 {
255 SLresult result = (*captureItf_)->SetMarkerPosition(nullptr, 0);
256 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
257 }
258
259 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_ClearMarkerPosition_001, TestSize.Level1)
260 {
261 SLresult result = (*captureItf_)->ClearMarkerPosition(nullptr);
262 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
263 }
264
265 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetMarkerPosition_001, TestSize.Level1)
266 {
267 SLresult result = (*captureItf_)->GetMarkerPosition(nullptr, nullptr);
268 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
269 }
270
271 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SetPositionUpdatePeriod_001, TestSize.Level1)
272 {
273 SLresult result = (*captureItf_)->SetPositionUpdatePeriod(nullptr, 0);
274 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
275 }
276
277 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_GetPositionUpdatePeriod_001, TestSize.Level1)
278 {
279 SLresult result = (*captureItf_)->GetPositionUpdatePeriod(nullptr, nullptr);
280 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
281 }
282
283 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_clear_001, TestSize.Level0)
284 {
285 SLresult result = (*bufferQueueItf_)->Clear(bufferQueueItf_);
286 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
287 }
288
289 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_clear_002, TestSize.Level1)
290 {
291 SLresult result = (*bufferQueueItf_)->Clear(nullptr);
292 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
293 }
294
295 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_Destroy_001, TestSize.Level0)
296 {
297 (*pcmCapturerObject_)->Destroy(pcmCapturerObject_);
298 EXPECT_TRUE(true);
299 }
300
301 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_Destroy_002, TestSize.Level0)
302 {
303 (*engineObject_)->Destroy(engineObject_);
304 EXPECT_TRUE(true);
305 }
306
307 HWTEST(AudioOpenslesCaptureUnitTest, Prf_Audio_Opensles_Capture_CreateEngine_001, TestSize.Level0)
308 {
309 struct timespec tv1 = {0};
310 struct timespec tv2 = {0};
311 int64_t performanceTestTimes = 10;
312 int64_t usecTimes = 1000000000;
313 int64_t totalTime = 0;
314 for (int32_t i = 0; i < performanceTestTimes; i++) {
315 clock_gettime(CLOCK_REALTIME, &tv1);
316 slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
317 clock_gettime(CLOCK_REALTIME, &tv2);
318 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
319 }
320 int64_t expectTime = 1000000000;
321 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
322 }
323
324 HWTEST(AudioOpenslesCaptureUnitTest, Prf_Audio_Opensles_Capture_DestoryEngine_001, TestSize.Level0)
325 {
326 struct timespec tv1 = {0};
327 struct timespec tv2 = {0};
328 int64_t performanceTestTimes = 10;
329 int64_t usecTimes = 1000000000;
330 int64_t totalTime = 0;
331 for (int32_t i = 0; i < performanceTestTimes; i++) {
332 engineObject_ = {};
333 slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
334 clock_gettime(CLOCK_REALTIME, &tv1);
335 (*engineObject_)->Destroy(engineObject_);
336 clock_gettime(CLOCK_REALTIME, &tv2);
337 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
338 }
339 int64_t expectTime = 1000000000;
340 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
341 }
342
343 HWTEST(AudioOpenslesCaptureUnitTest, Prf_Audio_Opensles_Capture_Realize_001, TestSize.Level0)
344 {
345 struct timespec tv1 = {0};
346 struct timespec tv2 = {0};
347 int64_t performanceTestTimes = 10;
348 int64_t usecTimes = 1000000000;
349 int64_t totalTime = 0;
350 engineObject_ = {};
351 slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
352 for (int32_t i = 0; i < performanceTestTimes; i++) {
353 clock_gettime(CLOCK_REALTIME, &tv1);
354 (*engineObject_)->Realize(engineObject_, SL_BOOLEAN_FALSE);
355 clock_gettime(CLOCK_REALTIME, &tv2);
356 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
357 }
358 int64_t expectTime = 1000000000;
359 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
360 }
361
362 HWTEST(AudioOpenslesCaptureUnitTest, Prf_Audio_Opensles_Capture_GetInterface_001, TestSize.Level0)
363 {
364 struct timespec tv1 = {0};
365 struct timespec tv2 = {0};
366 int64_t performanceTestTimes = 10;
367 int64_t usecTimes = 1000000000;
368 int64_t totalTime = 0;
369 for (int32_t i = 0; i < performanceTestTimes; i++) {
370 clock_gettime(CLOCK_REALTIME, &tv1);
371 (*engineObject_)->GetInterface(engineObject_, SL_IID_ENGINE, &engineEngine_);
372 clock_gettime(CLOCK_REALTIME, &tv2);
373 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
374 }
375 int64_t expectTime = 1000000000;
376 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
377 }
378
379 HWTEST(AudioOpenslesCaptureUnitTest, Prf_Audio_Opensles_CreateAudioRecorder_001, TestSize.Level0)
380 {
381 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
382 if (wavFile_ == nullptr) {
383 AUDIO_INFO_LOG("AudioCaptureTest: Unable to open record file.");
384 }
385
386 SLDataLocator_IODevice io_device = {
387 SL_DATALOCATOR_IODEVICE,
388 SL_IODEVICE_AUDIOINPUT,
389 SL_DEFAULTDEVICEID_AUDIOINPUT,
390 NULL
391 };
392
393 SLDataSource audioSource = {
394 &io_device,
395 NULL
396 };
397
398 SLDataLocator_BufferQueue buffer_queue = {
399 SL_DATALOCATOR_BUFFERQUEUE,
400 3
401 };
402
403 SLDataFormat_PCM format_pcm = {
404 SL_DATAFORMAT_PCM,
405 OHOS::AudioStandard::AudioChannel::MONO,
406 OHOS::AudioStandard::AudioSamplingRate::SAMPLE_RATE_44100,
407 SL_PCMSAMPLEFORMAT_FIXED_16,
408 0,
409 0,
410 0
411 };
412
413 SLDataSink audioSink = {
414 &buffer_queue,
415 &format_pcm
416 };
417
418 struct timespec tv1 = {0};
419 struct timespec tv2 = {0};
420 int64_t performanceTestTimes = 10;
421 int64_t usecTimes = 1000000000;
422 int64_t totalTime = 0;
423 for (int32_t i = 0; i < performanceTestTimes; i++) {
424 clock_gettime(CLOCK_REALTIME, &tv1);
425 (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
426 &audioSink, 0, nullptr, nullptr);
427 clock_gettime(CLOCK_REALTIME, &tv2);
428 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
429 }
430 int64_t expectTime = 1000000000;
431 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
432 }
433
434 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_001, TestSize.Level1)
435 {
436 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
437 if (wavFile_ == nullptr) {
438 AUDIO_INFO_LOG("SlToOhosChannel_001: Unable to open record file.");
439 }
440
441 SLDataLocator_IODevice io_device = {
442 SL_DATALOCATOR_IODEVICE,
443 SL_IODEVICE_AUDIOINPUT,
444 SL_DEFAULTDEVICEID_AUDIOINPUT,
445 NULL
446 };
447
448 SLDataSource audioSource = {
449 &io_device,
450 NULL
451 };
452
453 SLDataLocator_BufferQueue buffer_queue = {
454 SL_DATALOCATOR_BUFFERQUEUE,
455 3
456 };
457
458 SLDataFormat_PCM format_pcm = {
459 SL_DATAFORMAT_PCM,
460 OHOS::AudioStandard::AudioChannel::MONO,
461 OHOS::AudioStandard::AudioSamplingRate::SAMPLE_RATE_8000,
462 SL_PCMSAMPLEFORMAT_FIXED_8,
463 0,
464 0,
465 0
466 };
467
468 SLDataSink audioSink = {
469 &buffer_queue,
470 &format_pcm
471 };
472 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
473 &audioSink, 0, nullptr, nullptr);
474 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
475 }
476
477 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_002, TestSize.Level1)
478 {
479 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
480 if (wavFile_ == nullptr) {
481 AUDIO_INFO_LOG("SlToOhosChannel_002: Unable to open record file.");
482 }
483
484 SLDataLocator_IODevice io_device = {
485 SL_DATALOCATOR_IODEVICE,
486 SL_IODEVICE_AUDIOINPUT,
487 SL_DEFAULTDEVICEID_AUDIOINPUT,
488 NULL
489 };
490
491 SLDataSource audioSource = {
492 &io_device,
493 NULL
494 };
495
496 SLDataLocator_BufferQueue buffer_queue = {
497 SL_DATALOCATOR_BUFFERQUEUE,
498 3
499 };
500
501 SLDataFormat_PCM format_pcm = {
502 SL_DATAFORMAT_PCM,
503 OHOS::AudioStandard::AudioChannel::STEREO,
504 SL_SAMPLINGRATE_11_025,
505 SL_PCMSAMPLEFORMAT_FIXED_16,
506 0,
507 0,
508 0
509 };
510 SLDataSink audioSink = {
511 &buffer_queue,
512 &format_pcm
513 };
514 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
515 &audioSink, 0, nullptr, nullptr);
516 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
517 }
518
519 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_003, TestSize.Level1)
520 {
521 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
522 if (wavFile_ == nullptr) {
523 AUDIO_INFO_LOG("SlToOhosChannel_003: Unable to open record file.");
524 }
525
526 SLDataLocator_IODevice io_device = {
527 SL_DATALOCATOR_IODEVICE,
528 SL_IODEVICE_AUDIOINPUT,
529 SL_DEFAULTDEVICEID_AUDIOINPUT,
530 NULL
531 };
532
533 SLDataSource audioSource = {
534 &io_device,
535 NULL
536 };
537
538 SLDataLocator_BufferQueue buffer_queue = {
539 SL_DATALOCATOR_BUFFERQUEUE,
540 3
541 };
542
543 SLDataFormat_PCM format_pcm = {
544 SL_DATAFORMAT_PCM,
545 3,
546 SL_SAMPLINGRATE_12,
547 SL_PCMSAMPLEFORMAT_FIXED_16,
548 0,
549 0,
550 0
551 };
552 SLDataSink audioSink = {
553 &buffer_queue,
554 &format_pcm
555 };
556 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
557 &audioSink, 0, nullptr, nullptr);
558 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
559 }
560
561 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_004, TestSize.Level1)
562 {
563 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
564 if (wavFile_ == nullptr) {
565 AUDIO_INFO_LOG("SlToOhosChannel_004: Unable to open record file.");
566 }
567
568 SLDataLocator_IODevice io_device = {
569 SL_DATALOCATOR_IODEVICE,
570 SL_IODEVICE_AUDIOINPUT,
571 SL_DEFAULTDEVICEID_AUDIOINPUT,
572 NULL
573 };
574
575 SLDataSource audioSource = {
576 &io_device,
577 NULL
578 };
579
580 SLDataLocator_BufferQueue buffer_queue = {
581 SL_DATALOCATOR_BUFFERQUEUE,
582 3
583 };
584 SLDataFormat_PCM format_pcm = {
585 SL_DATAFORMAT_PCM,
586 OHOS::AudioStandard::AudioChannel::CHANNEL_3,
587 SL_SAMPLINGRATE_16,
588 SL_PCMSAMPLEFORMAT_FIXED_24,
589 0,
590 0,
591 0
592 };
593 SLDataSink audioSink = {
594 &buffer_queue,
595 &format_pcm
596 };
597 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
598 &audioSink, 0, nullptr, nullptr);
599 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
600 }
601
602 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_005, TestSize.Level1)
603 {
604 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
605 if (wavFile_ == nullptr) {
606 AUDIO_INFO_LOG("SlToOhosChannel_005: Unable to open record file.");
607 }
608
609 SLDataLocator_IODevice io_device = {
610 SL_DATALOCATOR_IODEVICE,
611 SL_IODEVICE_AUDIOINPUT,
612 SL_DEFAULTDEVICEID_AUDIOINPUT,
613 NULL
614 };
615
616 SLDataSource audioSource = {
617 &io_device,
618 NULL
619 };
620
621 SLDataLocator_BufferQueue buffer_queue = {
622 SL_DATALOCATOR_BUFFERQUEUE,
623 3
624 };
625
626 SLDataFormat_PCM format_pcm = {
627 SL_DATAFORMAT_PCM,
628 OHOS::AudioStandard::AudioChannel::STEREO,
629 SL_SAMPLINGRATE_22_05,
630 SL_PCMSAMPLEFORMAT_FIXED_8,
631 0,
632 0,
633 0
634 };
635 SLDataSink audioSink = {
636 &buffer_queue,
637 &format_pcm
638 };
639
640 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
641 &audioSink, 0, nullptr, nullptr);
642 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
643 }
644
645 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_006, TestSize.Level1)
646 {
647 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
648 if (wavFile_ == nullptr) {
649 AUDIO_INFO_LOG("SlToOhosChannel_006: Unable to open record file.");
650 }
651
652 SLDataLocator_IODevice io_device = {
653 SL_DATALOCATOR_IODEVICE,
654 SL_IODEVICE_AUDIOINPUT,
655 SL_DEFAULTDEVICEID_AUDIOINPUT,
656 NULL
657 };
658
659 SLDataSource audioSource = {
660 &io_device,
661 NULL
662 };
663
664 SLDataLocator_BufferQueue buffer_queue = {
665 SL_DATALOCATOR_BUFFERQUEUE,
666 3
667 };
668
669 SLDataFormat_PCM format_pcm = {
670 SL_DATAFORMAT_PCM,
671 OHOS::AudioStandard::AudioChannel::STEREO,
672 SL_SAMPLINGRATE_24,
673 SL_PCMSAMPLEFORMAT_FIXED_32,
674 0,
675 0,
676 0
677 };
678 SLDataSink audioSink = {
679 &buffer_queue,
680 &format_pcm
681 };
682 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
683 &audioSink, 0, nullptr, nullptr);
684 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
685 }
686
687 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_007, TestSize.Level1)
688 {
689 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
690 if (wavFile_ == nullptr) {
691 AUDIO_INFO_LOG("SlToOhosChannel_007: Unable to open record file.");
692 }
693
694 SLDataLocator_IODevice io_device = {
695 SL_DATALOCATOR_IODEVICE,
696 SL_IODEVICE_AUDIOINPUT,
697 SL_DEFAULTDEVICEID_AUDIOINPUT,
698 NULL
699 };
700
701 SLDataSource audioSource = {
702 &io_device,
703 NULL
704 };
705
706 SLDataLocator_BufferQueue buffer_queue = {
707 SL_DATALOCATOR_BUFFERQUEUE,
708 3
709 };
710
711 SLDataFormat_PCM format_pcm = {
712 SL_DATAFORMAT_PCM,
713 OHOS::AudioStandard::AudioChannel::MONO,
714 SL_SAMPLINGRATE_32,
715 SL_PCMSAMPLEFORMAT_FIXED_8,
716 0,
717 0,
718 0
719 };
720 SLDataSink audioSink = {
721 &buffer_queue,
722 &format_pcm
723 };
724 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
725 &audioSink, 0, nullptr, nullptr);
726 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
727 }
728
729 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_008, TestSize.Level1)
730 {
731 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
732 if (wavFile_ == nullptr) {
733 AUDIO_INFO_LOG("SlToOhosChannel_008: Unable to open record file.");
734 }
735
736 SLDataLocator_IODevice io_device = {
737 SL_DATALOCATOR_IODEVICE,
738 SL_IODEVICE_AUDIOINPUT,
739 SL_DEFAULTDEVICEID_AUDIOINPUT,
740 NULL
741 };
742
743 SLDataSource audioSource = {
744 &io_device,
745 NULL
746 };
747
748 SLDataLocator_BufferQueue buffer_queue = {
749 SL_DATALOCATOR_BUFFERQUEUE,
750 3
751 };
752 SLDataFormat_PCM format_pcm = {
753 SL_DATAFORMAT_PCM,
754 OHOS::AudioStandard::AudioChannel::STEREO,
755 SL_SAMPLINGRATE_44_1,
756 SL_PCMSAMPLEFORMAT_FIXED_16,
757 0,
758 0,
759 0
760 };
761 SLDataSink audioSink = {
762 &buffer_queue,
763 &format_pcm
764 };
765 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
766 &audioSink, 0, nullptr, nullptr);
767 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
768 }
769
770 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_009, TestSize.Level1)
771 {
772 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
773 if (wavFile_ == nullptr) {
774 AUDIO_INFO_LOG("SlToOhosChannel_009: Unable to open record file.");
775 }
776
777 SLDataLocator_IODevice io_device = {
778 SL_DATALOCATOR_IODEVICE,
779 SL_IODEVICE_AUDIOINPUT,
780 SL_DEFAULTDEVICEID_AUDIOINPUT,
781 NULL
782 };
783
784 SLDataSource audioSource = {
785 &io_device,
786 NULL
787 };
788
789 SLDataLocator_BufferQueue buffer_queue = {
790 SL_DATALOCATOR_BUFFERQUEUE,
791 3
792 };
793
794 SLDataFormat_PCM format_pcm = {
795 SL_DATAFORMAT_PCM,
796 OHOS::AudioStandard::AudioChannel::CHANNEL_3,
797 SL_SAMPLINGRATE_48,
798 SL_PCMSAMPLEFORMAT_FIXED_16,
799 0,
800 0,
801 0
802 };
803 SLDataSink audioSink = {
804 &buffer_queue,
805 &format_pcm
806 };
807 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
808 &audioSink, 0, nullptr, nullptr);
809 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
810 }
811
812 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_010, TestSize.Level1)
813 {
814 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
815 if (wavFile_ == nullptr) {
816 AUDIO_INFO_LOG("SlToOhosChannel_010: Unable to open record file.");
817 }
818
819 SLDataLocator_IODevice io_device = {
820 SL_DATALOCATOR_IODEVICE,
821 SL_IODEVICE_AUDIOINPUT,
822 SL_DEFAULTDEVICEID_AUDIOINPUT,
823 NULL
824 };
825
826 SLDataSource audioSource = {
827 &io_device,
828 NULL
829 };
830
831 SLDataLocator_BufferQueue buffer_queue = {
832 SL_DATALOCATOR_BUFFERQUEUE,
833 3
834 };
835
836 SLDataFormat_PCM format_pcm = {
837 SL_DATAFORMAT_PCM,
838 OHOS::AudioStandard::AudioChannel::CHANNEL_3,
839 SL_SAMPLINGRATE_64,
840 SL_PCMSAMPLEFORMAT_FIXED_8,
841 0,
842 0,
843 0
844 };
845 SLDataSink audioSink = {
846 &buffer_queue,
847 &format_pcm
848 };
849 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
850 &audioSink, 0, nullptr, nullptr);
851 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
852 }
853
854 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_011, TestSize.Level1)
855 {
856 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
857 if (wavFile_ == nullptr) {
858 AUDIO_INFO_LOG("SlToOhosChannel_011: Unable to open record file.");
859 }
860
861 SLDataLocator_IODevice io_device = {
862 SL_DATALOCATOR_IODEVICE,
863 SL_IODEVICE_AUDIOINPUT,
864 SL_DEFAULTDEVICEID_AUDIOINPUT,
865 NULL
866 };
867
868 SLDataSource audioSource = {
869 &io_device,
870 NULL
871 };
872
873 SLDataLocator_BufferQueue buffer_queue = {
874 SL_DATALOCATOR_BUFFERQUEUE,
875 3
876 };
877
878 SLDataFormat_PCM format_pcm = {
879 SL_DATAFORMAT_PCM,
880 OHOS::AudioStandard::AudioChannel::CHANNEL_3,
881 SL_SAMPLINGRATE_96,
882 SL_PCMSAMPLEFORMAT_FIXED_16,
883 0,
884 0,
885 0
886 };
887 SLDataSink audioSink = {
888 &buffer_queue,
889 &format_pcm
890 };
891 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
892 &audioSink, 0, nullptr, nullptr);
893 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
894 }
895
896 HWTEST(AudioOpenslesCaptureUnitTest, Audio_Opensles_Capture_SlToOhosChannel_012, TestSize.Level1)
897 {
898 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "wb");
899 if (wavFile_ == nullptr) {
900 AUDIO_INFO_LOG("SlToOhosChannel_012: Unable to open record file.");
901 }
902
903 SLDataLocator_IODevice io_device = {
904 SL_DATALOCATOR_IODEVICE,
905 SL_IODEVICE_AUDIOINPUT,
906 SL_DEFAULTDEVICEID_AUDIOINPUT,
907 NULL
908 };
909
910 SLDataSource audioSource = {
911 &io_device,
912 NULL
913 };
914
915 SLDataLocator_BufferQueue buffer_queue = {
916 SL_DATALOCATOR_BUFFERQUEUE,
917 3
918 };
919 SLDataFormat_PCM format_pcm = {
920 SL_DATAFORMAT_PCM,
921 OHOS::AudioStandard::AudioChannel::CHANNEL_3,
922 SL_SAMPLINGRATE_88_2,
923 SL_PCMSAMPLEFORMAT_FIXED_16,
924 0,
925 0,
926 0
927 };
928 SLDataSink audioSink = {
929 &buffer_queue,
930 &format_pcm
931 };
932 SLresult result = (*engineEngine_)->CreateAudioRecorder(engineEngine_, &pcmCapturerObject_, &audioSource,
933 &audioSink, 0, nullptr, nullptr);
934 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
935 }
936 } // namespace AudioStandard
937 } // namespace OHOS
938