1 /*
2  * Copyright (c) 2023 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_log.h"
17 #include "audio_info.h"
18 #include <OpenSLES.h>
19 #include <OpenSLES_OpenHarmony.h>
20 #include <string>
21 #include "gtest/gtest.h"
22 
23 using namespace std;
24 using namespace testing::ext;
25 namespace {
26 class ActsOpenslesPlayerNdkTest : public testing::Test {
27 public:
28     static void SetUpTestCase();
29     static void TearDownTestCase();
30     void SetUp() override;
31     void TearDown() override;
32 };
33 
34 struct WAV_HEADER {
35     /* RIFF Chunk Descriptor */
36     uint8_t RIFF[4] = {'R', 'I', 'F', 'F'}; // RIFF Header Magic header
37     uint32_t ChunkSize = 0; // RIFF Chunk Size
38     uint8_t WAVE[4] = {'W', 'A', 'V', 'E'}; // WAVE Header
39     /* "fmt" sub-chunk */
40     uint8_t fmt[4] = {'f', 'm', 't', ' '}; // FMT header
41     uint32_t Subchunk1Size = 16; // Size of the fmt chunk
42     uint16_t AudioFormat = 1; // Audio format 1=PCM
43     uint16_t NumOfChan = 2; // Number of channels 1=Mono 2=Stereo
44     uint32_t SamplesPerSec = 44100; // Sampling Frequency in Hz
45     uint32_t bytesPerSec = 176400; // bytes per second
46     uint16_t blockAlign = 2; // 2=16-bit mono, 4=16-bit stereo
47     uint16_t bitsPerSample = 16; // Number of bits per sample
48     /* "data" sub-chunk */
49     uint8_t Subchunk2ID[4] = {'d', 'a', 't', 'a'}; // "data"  string
50     uint32_t Subchunk2Size = 0; // Sampled data length
51 };
52 
53 using wav_hdr = struct WAV_HEADER;
54 
SetUpTestCase()55 void ActsOpenslesPlayerNdkTest::SetUpTestCase() {}
TearDownTestCase()56 void ActsOpenslesPlayerNdkTest::TearDownTestCase() {}
SetUp()57 void ActsOpenslesPlayerNdkTest::SetUp() {}
TearDown()58 void ActsOpenslesPlayerNdkTest::TearDown() {}
59 
60 static void BuqqerQueueCallback(SLOHBufferQueueItf sBufferQueueItf, void *pContext, SLuint32 size);
61 
62 static SLuint32 PlayerStart(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf, FILE *wavFile);
63 
64 static SLuint32 PlayerStop(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf);
65 
66 static SLresult OpenSlTest();
67 
68 static SLresult OpenSlTestConcurrent();
69 
70 const SLuint32 number = 3;
71 const char* READPATH1 = "/data/audio/S16LE_2_44100.pcm";
72 const char* READPATH2 = "/data/audio/S16LE_2_64000.pcm";
73 FILE *wavFile_ = nullptr;
74 FILE *wavFile1_ = nullptr;
75 FILE *wavFile2_ = nullptr;
76 wav_hdr wavHeader_;
77 wav_hdr wavHeader1_;
78 wav_hdr wavHeader2_;
79 SLObjectItf engineObject = nullptr;
80 SLObjectItf outputMixObject = nullptr;
81 SLPlayItf playItf;
82 SLPlayItf playItf1;
83 SLPlayItf playItf2;
84 SLVolumeItf volumeItf1;
85 SLVolumeItf volumeItf2;
86 SLOHBufferQueueItf bufferQueueItf;
87 SLOHBufferQueueItf bufferQueueItf1;
88 SLOHBufferQueueItf bufferQueueItf2;
89 SLObjectItf pcmPlayerObject = nullptr;
90 SLObjectItf pcmPlayerObject1 = nullptr;
91 SLObjectItf pcmPlayerObject2 = nullptr;
92 
OpenSlTest()93 static SLresult OpenSlTest()
94 {
95     AUDIO_INFO_LOG("OpenSlTest enter");
96     engineObject = nullptr;
97     SLEngineItf engineEngine = nullptr;
98     SLresult result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr);
99     // get engine object
100     if (SL_RESULT_SUCCESS != result) {
101         AUDIO_INFO_LOG("OpenSlTest slCreateEngine result: %{public}lu", result);
102         return result;
103     }
104     result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
105     if (SL_RESULT_SUCCESS != result) {
106         AUDIO_INFO_LOG("OpenSlTest Realize result: %{public}lu", result);
107         return result;
108     }
109     // get engineEngine object
110     result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
111     if (SL_RESULT_SUCCESS != result) {
112         AUDIO_INFO_LOG("OpenSlTest get engineEngine result: %{public}lu", result);
113         return result;
114     }
115     outputMixObject = nullptr;
116     result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, nullptr, nullptr);
117     if (SL_RESULT_SUCCESS != result) {
118         AUDIO_INFO_LOG("OpenSlTest CreateOutputMix result: %{public}lu", result);
119         return result;
120     }
121     result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
122     if (SL_RESULT_SUCCESS != result) {
123         AUDIO_INFO_LOG("OpenSlTest outPut Realize result: %{public}lu", result);
124         return result;
125     }
126 
127     SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
128     SLDataSink slSink = {&slOutputMix, nullptr};
129     SLDataLocator_BufferQueue slBufferQueue = {
130         SL_DATALOCATOR_BUFFERQUEUE,
131         0
132     };
133     SLDataFormat_PCM pcmFormat = {
134         SL_DATAFORMAT_PCM,
135         wavHeader_.NumOfChan,
136         wavHeader_.SamplesPerSec * 1000,
137         wavHeader_.bitsPerSample,
138         0,
139         0,
140         0
141     };
142     SLDataSource slSource = {&slBufferQueue, &pcmFormat};
143 
144     result = (*engineEngine)->CreateAudioPlayer(engineEngine, &pcmPlayerObject,
145         &slSource, &slSink, number, nullptr, nullptr);
146     if (SL_RESULT_SUCCESS != result) {
147         AUDIO_INFO_LOG("OpenSlTest CreateAudioPlayer result: %{public}lu", result);
148         return result;
149     }
150     result = (*pcmPlayerObject)->Realize(pcmPlayerObject, SL_BOOLEAN_FALSE);
151     if (SL_RESULT_SUCCESS != result) {
152         AUDIO_INFO_LOG("OpenSlTest CreateAudioPlayer Realize result: %{public}lu", result);
153         return result;
154     }
155     // get bufferQueueItf object
156     result = (*pcmPlayerObject)->GetInterface(pcmPlayerObject, SL_IID_PLAY, &playItf);
157     if (SL_RESULT_SUCCESS != result) {
158         AUDIO_INFO_LOG("OpenSlTest get playItf result: %{public}lu", result);
159         return result;
160     }
161     SLVolumeItf volumeItf;
162     result = (*pcmPlayerObject)->GetInterface(pcmPlayerObject, SL_IID_VOLUME, &volumeItf);
163     if (SL_RESULT_SUCCESS != result) {
164         AUDIO_INFO_LOG("OpenSlTest get volumeItf result: %{public}lu", result);
165         return result;
166     }
167     SLmillibel pLevel = 0;
168     result = (*volumeItf)->GetVolumeLevel(volumeItf, &pLevel);
169     if (SL_RESULT_SUCCESS != result) {
170         AUDIO_INFO_LOG("OpenSlTest GetVolumeLevel result: %{public}lu", result);
171         return result;
172     }
173     result = (*pcmPlayerObject)->GetInterface(pcmPlayerObject, SL_IID_OH_BUFFERQUEUE, &bufferQueueItf);
174     if (SL_RESULT_SUCCESS != result) {
175         AUDIO_INFO_LOG("OpenSlTest get bufferQueueItf result: %{public}lu", result);
176         return result;
177     }
178     result = (*bufferQueueItf)->RegisterCallback(bufferQueueItf, BuqqerQueueCallback, wavFile_);
179     if (SL_RESULT_SUCCESS != result) {
180         AUDIO_INFO_LOG("OpenSlTest RegisterCallback result: %{public}lu", result);
181         return result;
182     }
183     result = PlayerStart(playItf, bufferQueueItf, wavFile_);
184     if (SL_RESULT_SUCCESS != result) {
185         AUDIO_INFO_LOG("OpenSlTest PlayerStart result: %{public}lu", result);
186         return result;
187     }
188     AUDIO_INFO_LOG("OpenSlTest return  result: %{public}lu", result);
189     return result;
190 }
191 
OpenSlTestConcurrent()192 static SLresult OpenSlTestConcurrent()
193 {
194     AUDIO_INFO_LOG("OpenSlTestConcurrent start");
195     engineObject = nullptr;
196     SLEngineItf engineEngine = nullptr;
197     SLresult result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr);
198     if (SL_RESULT_SUCCESS != result) {
199         AUDIO_INFO_LOG("OpenSlTestConcurrent slCreateEngine result: %{public}lu", result);
200         return result;
201     }
202     result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
203     if (SL_RESULT_SUCCESS != result) {
204         AUDIO_INFO_LOG("OpenSlTestConcurrent Realize result: %{public}lu", result);
205         return result;
206     }
207 
208     result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
209     if (SL_RESULT_SUCCESS != result) {
210         AUDIO_INFO_LOG("OpenSlTestConcurrent get engineEngine result: %{public}lu", result);
211         return result;
212     }
213 
214     outputMixObject = nullptr;
215     result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, nullptr, nullptr);
216     if (SL_RESULT_SUCCESS != result) {
217         AUDIO_INFO_LOG("OpenSlTestConcurrent CreateOutputMix result: %{public}lu", result);
218         return result;
219     }
220     result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
221     if (SL_RESULT_SUCCESS != result) {
222         AUDIO_INFO_LOG("OpenSlTestConcurrent outPut Realize result: %{public}lu", result);
223         return result;
224     }
225     SLuint32 state;
226     result = (*outputMixObject)->GetState(outputMixObject, &state);
227     if (SL_RESULT_SUCCESS != result) {
228         AUDIO_INFO_LOG("OpenSlTestConcurrent outPut GetState result: %{public}lu", result);
229         return result;
230     }
231 
232     SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
233     SLDataSink slSink = {&slOutputMix, nullptr};
234     SLDataLocator_BufferQueue slBufferQueue = {
235         SL_DATALOCATOR_BUFFERQUEUE,
236         0
237     };
238     SLDataFormat_PCM pcmFormat1 = {
239         SL_DATAFORMAT_PCM,
240         wavHeader1_.NumOfChan,
241         wavHeader1_.SamplesPerSec * 1000,
242         wavHeader1_.bitsPerSample,
243         0,
244         0,
245         0
246     };
247     SLDataFormat_PCM pcmFormat2 = {
248         SL_DATAFORMAT_PCM,
249         wavHeader2_.NumOfChan,
250         wavHeader2_.SamplesPerSec * 1000,
251         wavHeader2_.bitsPerSample,
252         0,
253         0,
254         0
255     };
256     SLDataSource slSource1 = {&slBufferQueue, &pcmFormat1};
257     SLDataSource slSource2 = {&slBufferQueue, &pcmFormat2};
258 
259     result = (*engineEngine)->CreateAudioPlayer(engineEngine, &pcmPlayerObject1, &slSource1,
260         &slSink, number, nullptr, nullptr);
261     if (SL_RESULT_SUCCESS != result) {
262         AUDIO_INFO_LOG("OpenSlTestConcurrent CreateAudioPlayer pcmPlayerObject1 Realize result: %{public}lu", result);
263         return result;
264     }
265     result = (*pcmPlayerObject1)->Realize(pcmPlayerObject1, SL_BOOLEAN_FALSE);
266     if (SL_RESULT_SUCCESS != result) {
267         AUDIO_INFO_LOG("OpenSlTestConcurrent outPut Realize pcmPlayerObject1 result: %{public}lu", result);
268         return result;
269     }
270 
271     result = (*engineEngine)->CreateAudioPlayer(engineEngine, &pcmPlayerObject2, &slSource2, &slSink,
272         number, nullptr, nullptr);
273     if (SL_RESULT_SUCCESS != result) {
274         AUDIO_INFO_LOG("OpenSlTestConcurrent CreateAudioPlayer pcmPlayerObject2 result: %{public}lu", result);
275         return result;
276     }
277     result = (*pcmPlayerObject2)->Realize(pcmPlayerObject2, SL_BOOLEAN_FALSE);
278     if (SL_RESULT_SUCCESS != result) {
279         AUDIO_INFO_LOG("OpenSlTestConcurrent Realize pcmPlayerObject2 result: %{public}lu", result);
280         return result;
281     }
282 
283     result = (*pcmPlayerObject1)->GetInterface(pcmPlayerObject1, SL_IID_PLAY, &playItf1);
284     if (SL_RESULT_SUCCESS != result) {
285         AUDIO_INFO_LOG("OpenSlTestConcurrent playItf1 result: %{public}lu", result);
286         return result;
287     }
288     result = (*pcmPlayerObject2)->GetInterface(pcmPlayerObject2, SL_IID_PLAY, &playItf2);
289     if (SL_RESULT_SUCCESS != result) {
290         AUDIO_INFO_LOG("OpenSlTestConcurrent playItf2 result: %{public}lu", result);
291         return result;
292     }
293     result = (*pcmPlayerObject1)->GetInterface(pcmPlayerObject1, SL_IID_VOLUME, &volumeItf1);
294     if (SL_RESULT_SUCCESS != result) {
295         AUDIO_INFO_LOG("OpenSlTestConcurrent volumeItf1 result: %{public}lu", result);
296         return result;
297     }
298 
299     SLmillibel level1 = 0;
300     (*volumeItf1)->GetMaxVolumeLevel(volumeItf1, &level1);
301     SLmillibel temp = 2; // SetVolumeLevel level1
302     level1 = (SLmillibel) (level1 / temp);
303     (*volumeItf1)->SetVolumeLevel(volumeItf1, level1);
304     (*pcmPlayerObject2)->GetInterface(pcmPlayerObject2, SL_IID_VOLUME, &volumeItf2);
305     SLmillibel level2 = 0;
306     (*volumeItf2)->GetMaxVolumeLevel(volumeItf2, &level2);
307     temp = 15; // SetVolumeLevel level2
308     level2 = (SLmillibel) (level2 / temp);
309     (*volumeItf2)->SetVolumeLevel(volumeItf2, level2);
310 
311     result = (*pcmPlayerObject1)->GetInterface(pcmPlayerObject1, SL_IID_OH_BUFFERQUEUE, &bufferQueueItf1);
312     if (SL_RESULT_SUCCESS != result) {
313         AUDIO_INFO_LOG("OpenSlTestConcurrent bufferQueueItf1 result: %{public}lu", result);
314         return result;
315     }
316     result = (*pcmPlayerObject2)->GetInterface(pcmPlayerObject2, SL_IID_OH_BUFFERQUEUE, &bufferQueueItf2);
317     if (SL_RESULT_SUCCESS != result) {
318         AUDIO_INFO_LOG("OpenSlTestConcurrent bufferQueueItf2 result: %{public}lu", result);
319         return result;
320     }
321     result = (*bufferQueueItf1)->RegisterCallback(bufferQueueItf1, BuqqerQueueCallback, wavFile1_);
322     if (SL_RESULT_SUCCESS != result) {
323         AUDIO_INFO_LOG("OpenSlTestConcurrent RegisterCallback1 result: %{public}lu", result);
324         return result;
325     }
326     result = (*bufferQueueItf2)->RegisterCallback(bufferQueueItf2, BuqqerQueueCallback, wavFile2_);
327     if (SL_RESULT_SUCCESS != result) {
328         AUDIO_INFO_LOG("OpenSlTestConcurrent RegisterCallback2 result: %{public}lu", result);
329         return result;
330     }
331     result = PlayerStart(playItf1, bufferQueueItf1, wavFile1_);
332     if (SL_RESULT_SUCCESS != result) {
333         AUDIO_INFO_LOG("OpenSlTestConcurrent playItf1 PlayerStart result: %{public}lu", result);
334         return result;
335     }
336     result = PlayerStart(playItf2, bufferQueueItf2, wavFile2_);
337     if (SL_RESULT_SUCCESS != result) {
338         AUDIO_INFO_LOG("OpenSlTestConcurrent playItf2 PlayerStart result: %{public}lu", result);
339         return result;
340     }
341     AUDIO_INFO_LOG("OpenSlTestConcurrent return  result: %{public}lu", result);
342     return result;
343 }
344 
BuqqerQueueCallback(SLOHBufferQueueItf sBufferQueueItf, void *pContext, SLuint32 size)345 static void BuqqerQueueCallback(SLOHBufferQueueItf sBufferQueueItf, void *pContext, SLuint32 size)
346 {
347     FILE *wavFile = (FILE *)pContext;
348     if (!feof(wavFile)) {
349         SLuint8 *buffer = nullptr;
350         SLuint32 pSize = 0;
351         SLresult result = (*bufferQueueItf)->GetBuffer(sBufferQueueItf, &buffer, &pSize);
352         if (SL_RESULT_SUCCESS != result) {
353             AUDIO_INFO_LOG("BuqqerQueueCallback GetBuffer result: %{public}lu", result);
354             return ;
355         }
356         fread(buffer, 1, size, wavFile);
357         result = (*bufferQueueItf)->Enqueue(sBufferQueueItf, buffer, size);
358         if (SL_RESULT_SUCCESS != result) {
359             AUDIO_INFO_LOG("BuqqerQueueCallback Enqueue result: %{public}lu", result);
360             return ;
361         }
362     }
363     return ;
364 }
365 
PlayerStart(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf, FILE *wavFile)366 static SLresult PlayerStart(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf, FILE *wavFile)
367 {
368     AUDIO_INFO_LOG("PlayerStart enter");
369     SLresult result = (*playItf)->SetPlayState(sPlayItf, SL_PLAYSTATE_PLAYING);
370     if (SL_RESULT_SUCCESS != result) {
371         AUDIO_INFO_LOG("PlayerStart SetPlayState result: %{public}lu", result);
372         return result;
373     }
374     SLuint32 state = SL_PLAYSTATE_PLAYING;
375     result = (*playItf)->GetPlayState(sPlayItf, &state);
376     if (SL_RESULT_SUCCESS != result) {
377         AUDIO_INFO_LOG("PlayerStart GetPlayState result: %{public}lu", result);
378         return result;
379     }
380     if (!feof(wavFile)) {
381         SLuint8* buffer = nullptr;
382         SLuint32 pSize = 0;
383         result = (*bufferQueueItf)->GetBuffer(sBufferQueueItf, &buffer, &pSize);
384         if (SL_RESULT_SUCCESS != result) {
385             AUDIO_INFO_LOG("PlayerStart GetBuffer result: %{public}lu", result);
386             return result;
387         }
388         fread(buffer, 1, pSize, wavFile);
389         result = (*bufferQueueItf)->Enqueue(sBufferQueueItf, buffer, pSize);
390         if (SL_RESULT_SUCCESS != result) {
391             AUDIO_INFO_LOG("PlayerStart Enqueue result: %{public}lu", result);
392             return result;
393         }
394     }
395     AUDIO_INFO_LOG("PlayerStart return  result: %{public}lu", result);
396     return result;
397 }
398 
PlayerStop(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf)399 static SLresult PlayerStop(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf)
400 {
401     AUDIO_INFO_LOG("PlayerStop enetr");
402 
403     SLresult result = (*playItf)->SetPlayState(sPlayItf, SL_PLAYSTATE_STOPPED);
404     if (SL_RESULT_SUCCESS != result) {
405         AUDIO_INFO_LOG("PlayerStop SetPlayState result: %{public}lu", result);
406         return result;
407     }
408     AUDIO_INFO_LOG("PlayerStop return  result: %{public}lu", result);
409     return result;
410 }
411 }
412 
413 /**
414  * @tc.number    : SUB_MULTIMEDIA_AUDIO_OPENSELES_PALYER_FUNCTION_0100
415  * @tc.name      : Pcm gemischte Wiedergabe
416  * @tc.desc      : Basic function test
417  */
HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_PALYER_FUNCTION_0100, TestSize.Level1)418 HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_PALYER_FUNCTION_0100, TestSize.Level1)
419 {
420     size_t headerSize = sizeof(wav_hdr);
421     char path[PATH_MAX + 1] = {0x00};
422     if ((strlen(READPATH1) > PATH_MAX) || (realpath(READPATH1, path) == nullptr)) {
423         AUDIO_ERR_LOG("Invalid path");
424         return ;
425     }
426     wavFile1_ = fopen(path, "rb");
427     if (wavFile1_ == nullptr) {
428         AUDIO_INFO_LOG("AudioRendererTest: Unable to open wave file");
429         return ;
430     }
431     fread(&wavHeader1_, 1, headerSize, wavFile1_);
432 
433     headerSize = sizeof(wav_hdr);
434     if ((strlen(READPATH2) > PATH_MAX) || (realpath(READPATH2, path) == nullptr)) {
435         AUDIO_ERR_LOG("Invalid path");
436         return ;
437     }
438     wavFile2_ = fopen(path, "rb");
439     if (wavFile2_ == nullptr) {
440         AUDIO_INFO_LOG("AudioRendererTest: Unable to open wave file");
441         return ;
442     }
443     fread(&wavHeader2_, 1, headerSize, wavFile2_);
444     SLresult result = OpenSlTestConcurrent();
445     ASSERT_EQ(SL_RESULT_SUCCESS, result);
446     while (!feof(wavFile1_) || !feof(wavFile2_)) {
447         sleep(1);
448     }
449     result = PlayerStop(playItf1, bufferQueueItf1);
450     ASSERT_EQ(SL_RESULT_SUCCESS, result);
451 
452     result = PlayerStop(playItf2, bufferQueueItf2);
453     ASSERT_EQ(SL_RESULT_SUCCESS, result);
454     (*pcmPlayerObject1)->Destroy(pcmPlayerObject1);
455     (*pcmPlayerObject2)->Destroy(pcmPlayerObject2);
456     (*engineObject)->Destroy(engineObject);
457     (*outputMixObject)->Destroy(outputMixObject);
458 }
459 
460 /**
461  * @tc.number    : SUB_MULTIMEDIA_AUDIO_OPENSELES_PALYER_FUNCTION_0200
462  * @tc.name      : Pcm spielt weiter
463  * @tc.desc      : Basic function test
464  */
HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_PALYER_FUNCTION_0200, TestSize.Level1)465 HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_PALYER_FUNCTION_0200, TestSize.Level1)
466 {
467     size_t headerSize = sizeof(wav_hdr);
468         char path[PATH_MAX + 1] = {0x00};
469         if ((strlen(READPATH1) > PATH_MAX) || (realpath(READPATH1, path) == nullptr)) {
470             AUDIO_ERR_LOG("Invalid path");
471             return ;
472         }
473         wavFile_ = fopen(path, "rb");
474         if (wavFile_ == nullptr) {
475             AUDIO_INFO_LOG("AudioRendererTest: Unable to open wave file");
476             return ;
477         }
478         fread(&wavHeader_, 1, headerSize, wavFile_);
479 
480         SLresult result = OpenSlTest();
481         ASSERT_EQ(SL_RESULT_SUCCESS, result);
482 
483         while (!feof(wavFile_)) {
484             sleep(1);
485         }
486         result = PlayerStop(playItf, bufferQueueItf);
487         ASSERT_EQ(SL_RESULT_SUCCESS, result);
488         (*pcmPlayerObject)->Destroy(pcmPlayerObject);
489 
490         char path2[PATH_MAX + 1] = {0x00};
491         if ((strlen(READPATH2) > PATH_MAX) || (realpath(READPATH2, path2) == nullptr)) {
492             AUDIO_ERR_LOG("Invalid path");
493             return ;
494         }
495         wavFile_ = fopen(path2, "rb");
496         if (wavFile_ == nullptr) {
497             AUDIO_INFO_LOG("AudioRendererTest: Unable to open wave file");
498             return ;
499         }
500         fread(&wavHeader_, 1, headerSize, wavFile_);
501 
502         result = OpenSlTest();
503         ASSERT_EQ(SL_RESULT_SUCCESS, result);
504 
505         while (!feof(wavFile_)) {
506             sleep(1);
507         }
508         result = PlayerStop(playItf, bufferQueueItf);
509         ASSERT_EQ(SL_RESULT_SUCCESS, result);
510         (*pcmPlayerObject)->Destroy(pcmPlayerObject);
511 }
512 
513 /**
514  * @tc.number    : SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0100
515  * @tc.name      : engine itf invalid
516  * @tc.desc      : Basic function test
517  */
HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0100, TestSize.Level1)518 HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0100, TestSize.Level1)
519 {
520     SLEngineItf engineEngine = nullptr;
521     engineObject = nullptr;
522     SLresult result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr);
523     ASSERT_EQ(SL_RESULT_SUCCESS, result);
524 
525     result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
526     ASSERT_EQ(SL_RESULT_SUCCESS, result);
527 
528     SLresult result1 = (*engineEngine)->CreateLEDDevice(engineEngine, nullptr, 0, 0, nullptr, nullptr);
529     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result1);
530 
531     SLresult result2 = (*engineEngine)->CreateVibraDevice(engineEngine, nullptr, 0, 0, nullptr, nullptr);
532     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result2);
533 
534     SLresult result4 = (*engineEngine)->CreateListener(engineEngine, nullptr, 0, nullptr, nullptr);
535     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result4);
536 
537     SLresult result5 = (*engineEngine)->Create3DGroup(engineEngine, nullptr, 0, nullptr, nullptr);
538     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result5);
539 
540     SLresult result6 = (*engineEngine)->CreateMetadataExtractor(engineEngine, nullptr, nullptr, 0, nullptr, nullptr);
541     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result6);
542 
543     SLresult result7 = (*engineEngine)->CreateExtensionObject(engineEngine, nullptr, nullptr, 0,
544         0, nullptr, nullptr);
545     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result7);
546 
547     SLresult result8 = (*engineEngine)->QueryNumSupportedInterfaces(engineEngine, 0, nullptr);
548     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result8);
549 
550     SLresult result9 = (*engineEngine)->QuerySupportedInterfaces(engineEngine, 0, 0, nullptr);
551     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result9);
552 
553     SLresult result10 = (*engineEngine)->QueryNumSupportedExtensions(engineEngine, nullptr);
554     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result10);
555 
556     SLresult result11 = (*engineEngine)->QuerySupportedExtension(engineEngine, 0, nullptr, nullptr);
557     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result11);
558 
559     SLresult result12 = (*engineEngine)->IsExtensionSupported(engineEngine, nullptr, nullptr);
560     ASSERT_EQ(SL_RESULT_FEATURE_UNSUPPORTED, result12);
561 }
562 
563 /**
564  * @tc.number    : SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0200
565  * @tc.name      : engine itf invalid
566  * @tc.desc      : Basic function test
567  */
HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0200, TestSize.Level1)568 HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0200, TestSize.Level1)
569 {
570     SLObjectItf engineObject_;
571     SLresult result = slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
572     EXPECT_TRUE(result == SL_RESULT_SUCCESS);
573 
574     SLresult result1 = (*engineObject_)->RegisterCallback(engineObject_, nullptr, nullptr);
575     EXPECT_TRUE(result1 == SL_RESULT_FEATURE_UNSUPPORTED);
576 
577     (*engineObject_)->AbortAsyncOperation(engineObject_);
578 
579     SLresult result2 = (*engineObject_)->SetPriority(engineObject_, 0, SL_BOOLEAN_FALSE);
580     EXPECT_TRUE(result2 == SL_RESULT_FEATURE_UNSUPPORTED);
581 
582     SLresult result3 = (*engineObject_)->GetPriority(engineObject_, nullptr, nullptr);
583     EXPECT_TRUE(result3 == SL_RESULT_FEATURE_UNSUPPORTED);
584 
585     SLresult result4 = (*engineObject_)->SetLossOfControlInterfaces(engineObject_, 0, nullptr, false);
586     EXPECT_TRUE(result4 == SL_RESULT_FEATURE_UNSUPPORTED);
587 }
588 
589 /**
590  * @tc.number    : SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0300
591  * @tc.name      : engine itf invalid
592  * @tc.desc      : Basic function test
593  */
HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0300, TestSize.Level1)594 HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0300, TestSize.Level1)
595 {
596     // get engineObject
597     engineObject = nullptr;
598     SLresult result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr);
599     ASSERT_EQ(SL_RESULT_SUCCESS, result);
600 
601     // get engineEngine
602     SLEngineItf engineEngine = nullptr;
603     result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
604     ASSERT_EQ(SL_RESULT_SUCCESS, result);
605 
606     // get pcmPlayerObject
607     pcmPlayerObject = nullptr;
608     SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
609     SLDataSink slSink = {&slOutputMix, nullptr};
610     SLDataLocator_BufferQueue slBufferQueue = {
611         SL_DATALOCATOR_BUFFERQUEUE,
612         0};
613     SLDataFormat_PCM pcmFormat = {
614         SL_DATAFORMAT_PCM,
615         wavHeader_.NumOfChan,
616         wavHeader_.SamplesPerSec * 1000,
617         wavHeader_.bitsPerSample,
618         0,
619         0,
620         0};
621     SLDataSource slSource = {&slBufferQueue, &pcmFormat};
622     result = (*engineEngine)->CreateAudioPlayer(engineEngine, &pcmPlayerObject, &slSource, &slSink,
623         number, nullptr, nullptr);
624     EXPECT_TRUE(result == SL_RESULT_SUCCESS);
625 
626     // get playItf
627     playItf = nullptr;
628     result = (*pcmPlayerObject)->GetInterface(pcmPlayerObject, SL_IID_PLAY, &playItf);
629     EXPECT_TRUE(result == SL_RESULT_SUCCESS);
630 
631     SLresult result1 = (*playItf)->GetDuration(playItf, nullptr);
632     EXPECT_TRUE(result1 == SL_RESULT_FEATURE_UNSUPPORTED);
633 
634     SLresult result2 = (*playItf)->GetPositionUpdatePeriod(playItf, nullptr);
635     EXPECT_TRUE(result2 == SL_RESULT_FEATURE_UNSUPPORTED);
636 
637     SLresult result3 = (*playItf)->RegisterCallback(playItf, nullptr, nullptr);
638     EXPECT_TRUE(result3 == SL_RESULT_FEATURE_UNSUPPORTED);
639 
640     SLresult result4 = (*playItf)->SetCallbackEventsMask(playItf, 0);
641     EXPECT_TRUE(result4 == SL_RESULT_FEATURE_UNSUPPORTED);
642 
643     SLresult result5 = (*playItf)->GetCallbackEventsMask(playItf, 0);
644     EXPECT_TRUE(result5 == SL_RESULT_FEATURE_UNSUPPORTED);
645 
646     SLresult result6 = (*playItf)->SetMarkerPosition(playItf, 0);
647     EXPECT_TRUE(result6 == SL_RESULT_FEATURE_UNSUPPORTED);
648 
649     SLresult result7 = (*playItf)->GetMarkerPosition(playItf, nullptr);
650     EXPECT_TRUE(result7 == SL_RESULT_FEATURE_UNSUPPORTED);
651 
652     SLresult result8 = (*playItf)->SetPositionUpdatePeriod(playItf, 0);
653     EXPECT_TRUE(result8 == SL_RESULT_FEATURE_UNSUPPORTED);
654 
655     SLresult result9 = (*playItf)->ClearMarkerPosition(playItf);
656     EXPECT_TRUE(result9 == SL_RESULT_FEATURE_UNSUPPORTED);
657 
658     SLresult result10 = (*playItf)->GetPosition(playItf, nullptr);
659     EXPECT_TRUE(result10 == SL_RESULT_FEATURE_UNSUPPORTED);
660 }
661 
662 /**
663  * @tc.number    : SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0400
664  * @tc.name      : engine itf invalid
665  * @tc.desc      : Basic function test
666  */
HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0400, TestSize.Level1)667 HWTEST_F(ActsOpenslesPlayerNdkTest, SUB_MULTIMEDIA_AUDIO_OPENSELES_ENGINEITF_INVALID_0400, TestSize.Level1)
668 {
669     // get engineObject
670     engineObject = nullptr;
671     SLresult result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr);
672     ASSERT_EQ(SL_RESULT_SUCCESS, result);
673 
674     // get engineEngine
675     SLEngineItf engineEngine = nullptr;
676     result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
677     ASSERT_EQ(SL_RESULT_SUCCESS, result);
678 
679     // get pcmPlayerObject
680     pcmPlayerObject = nullptr;
681     SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
682     SLDataSink slSink = {&slOutputMix, nullptr};
683     SLDataLocator_BufferQueue slBufferQueue = {
684         SL_DATALOCATOR_BUFFERQUEUE,
685         0};
686     SLDataFormat_PCM pcmFormat = {
687         SL_DATAFORMAT_PCM,
688         wavHeader_.NumOfChan,
689         wavHeader_.SamplesPerSec * 1000,
690         wavHeader_.bitsPerSample,
691         0,
692         0,
693         0};
694     SLDataSource slSource = {&slBufferQueue, &pcmFormat};
695     result = (*engineEngine)->CreateAudioPlayer(engineEngine, &pcmPlayerObject, &slSource,
696         &slSink, number, nullptr, nullptr);
697     EXPECT_TRUE(result == SL_RESULT_SUCCESS);
698 
699     // get volumeItf
700     SLVolumeItf volumeItf = nullptr;
701     result = (*pcmPlayerObject)->GetInterface(pcmPlayerObject, SL_IID_VOLUME, &volumeItf);
702     EXPECT_TRUE(result == SL_RESULT_SUCCESS);
703 
704     SLresult result1 = (*volumeItf)->SetMute(volumeItf, SL_BOOLEAN_FALSE);
705     EXPECT_TRUE(result1 == SL_RESULT_FEATURE_UNSUPPORTED);
706 
707     SLresult result2 = (*volumeItf)->GetMute(volumeItf, nullptr);
708     EXPECT_TRUE(result2 == SL_RESULT_FEATURE_UNSUPPORTED);
709 
710     SLresult result3 = (*volumeItf)->EnableStereoPosition(volumeItf, SL_BOOLEAN_FALSE);
711     EXPECT_TRUE(result3 == SL_RESULT_FEATURE_UNSUPPORTED);
712 
713     SLresult result4 = (*volumeItf)->IsEnabledStereoPosition(volumeItf, nullptr);
714     EXPECT_TRUE(result4 == SL_RESULT_FEATURE_UNSUPPORTED);
715 
716     SLresult result5 = (*volumeItf)->SetStereoPosition(volumeItf, 0);
717     EXPECT_TRUE(result5 == SL_RESULT_FEATURE_UNSUPPORTED);
718 
719     SLresult result6 = (*volumeItf)->GetStereoPosition(volumeItf, nullptr);
720     EXPECT_TRUE(result6 == SL_RESULT_FEATURE_UNSUPPORTED);
721 }