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
23using namespace std;
24using namespace testing::ext;
25namespace {
26class ActsOpenslesPlayerNdkTest : public testing::Test {
27public:
28    static void SetUpTestCase();
29    static void TearDownTestCase();
30    void SetUp() override;
31    void TearDown() override;
32};
33
34struct 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
53using wav_hdr = struct WAV_HEADER;
54
55void ActsOpenslesPlayerNdkTest::SetUpTestCase() {}
56void ActsOpenslesPlayerNdkTest::TearDownTestCase() {}
57void ActsOpenslesPlayerNdkTest::SetUp() {}
58void ActsOpenslesPlayerNdkTest::TearDown() {}
59
60static void BuqqerQueueCallback(SLOHBufferQueueItf sBufferQueueItf, void *pContext, SLuint32 size);
61
62static SLuint32 PlayerStart(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf, FILE *wavFile);
63
64static SLuint32 PlayerStop(SLPlayItf sPlayItf, SLOHBufferQueueItf sBufferQueueItf);
65
66static SLresult OpenSlTest();
67
68static SLresult OpenSlTestConcurrent();
69
70const SLuint32 number = 3;
71const char* READPATH1 = "/data/audio/S16LE_2_44100.pcm";
72const char* READPATH2 = "/data/audio/S16LE_2_64000.pcm";
73FILE *wavFile_ = nullptr;
74FILE *wavFile1_ = nullptr;
75FILE *wavFile2_ = nullptr;
76wav_hdr wavHeader_;
77wav_hdr wavHeader1_;
78wav_hdr wavHeader2_;
79SLObjectItf engineObject = nullptr;
80SLObjectItf outputMixObject = nullptr;
81SLPlayItf playItf;
82SLPlayItf playItf1;
83SLPlayItf playItf2;
84SLVolumeItf volumeItf1;
85SLVolumeItf volumeItf2;
86SLOHBufferQueueItf bufferQueueItf;
87SLOHBufferQueueItf bufferQueueItf1;
88SLOHBufferQueueItf bufferQueueItf2;
89SLObjectItf pcmPlayerObject = nullptr;
90SLObjectItf pcmPlayerObject1 = nullptr;
91SLObjectItf pcmPlayerObject2 = nullptr;
92
93static 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
192static 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
345static 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
366static 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
399static 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 */
418HWTEST_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 */
465HWTEST_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 */
518HWTEST_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 */
568HWTEST_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 */
594HWTEST_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 */
667HWTEST_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}