| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <sys/time.h> |
| #include <fcntl.h> |
| |
| #include "SLES/OpenSLES.h" |
| #include "SLES/OpenSLES_Android.h" |
| |
| |
| #define MAX_NUMBER_INTERFACES 3 |
| |
| #define TEST_MUTE 0 |
| #define TEST_SOLO 1 |
| |
| static int testMode; |
| //----------------------------------------------------------------- |
| /* Exits the application if an error is encountered */ |
| #define ExitOnError(x) ExitOnErrorFunc(x,__LINE__) |
| |
| void ExitOnErrorFunc( SLresult result , int line) |
| { |
| if (SL_RESULT_SUCCESS != result) { |
| fprintf(stdout, "%lu error code encountered at line %d, exiting\n", result, line); |
| exit(EXIT_FAILURE); |
| } |
| } |
| |
| |
| //----------------------------------------------------------------- |
| |
| /* Play an audio path by opening a file descriptor on that path */ |
| void TestPlayPathFromFD( SLObjectItf sl, const char* path, SLAint64 offset, SLAint64 size) |
| { |
| SLresult result; |
| SLEngineItf EngineItf; |
| |
| /* Objects this application uses: one player and an ouput mix */ |
| SLObjectItf player, outputMix; |
| |
| /* Source of audio data to play */ |
| SLDataSource audioSource; |
| SLDataLocator_AndroidFD locatorFd; |
| SLDataFormat_MIME mime; |
| |
| /* Data sinks for the audio player */ |
| SLDataSink audioSink; |
| SLDataLocator_OutputMix locator_outputmix; |
| |
| /* Play and PrefetchStatus interfaces for the audio player */ |
| SLPlayItf playItf; |
| SLPrefetchStatusItf prefetchItf; |
| |
| SLboolean required[MAX_NUMBER_INTERFACES]; |
| SLInterfaceID iidArray[MAX_NUMBER_INTERFACES]; |
| |
| /* Get the SL Engine Interface which is implicit */ |
| result = (*sl)->GetInterface(sl, SL_IID_ENGINE, (void*)&EngineItf); |
| ExitOnError(result); |
| |
| /* Initialize arrays required[] and iidArray[] */ |
| for (int i=0 ; i < MAX_NUMBER_INTERFACES ; i++) { |
| required[i] = SL_BOOLEAN_FALSE; |
| iidArray[i] = SL_IID_NULL; |
| } |
| |
| /* ------------------------------------------------------ */ |
| /* Configuration of the output mix */ |
| |
| /* Create Output Mix object to be used by the player */ |
| result = (*EngineItf)->CreateOutputMix(EngineItf, &outputMix, 0, iidArray, required); |
| ExitOnError(result); |
| |
| /* Realize the Output Mix object in synchronous mode */ |
| result = (*outputMix)->Realize(outputMix, SL_BOOLEAN_FALSE); |
| ExitOnError(result); |
| |
| /* Setup the data sink structure */ |
| locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX; |
| locator_outputmix.outputMix = outputMix; |
| audioSink.pLocator = (void*)&locator_outputmix; |
| audioSink.pFormat = NULL; |
| |
| /* ------------------------------------------------------ */ |
| /* Configuration of the player */ |
| |
| /* Set arrays required[] and iidArray[] for SLPrefetchStatusItf interfaces */ |
| /* (SLPlayItf is implicit) */ |
| required[0] = SL_BOOLEAN_TRUE; |
| iidArray[0] = SL_IID_PREFETCHSTATUS; |
| |
| /* Setup the data source structure for the URI */ |
| locatorFd.locatorType = SL_DATALOCATOR_ANDROIDFD; |
| int fd = open(path, O_RDONLY); |
| if (fd == -1) { |
| perror(path); |
| exit(EXIT_FAILURE); |
| } |
| locatorFd.fd = (SLint32) fd; |
| locatorFd.length = size; |
| locatorFd.offset = offset; |
| |
| mime.formatType = SL_DATAFORMAT_MIME; |
| /* this is how ignored mime information is specified, according to OpenSL ES spec |
| * in 9.1.6 SLDataFormat_MIME and 8.23 SLMetadataTraversalItf GetChildInfo */ |
| mime.mimeType = (SLchar*)NULL; |
| mime.containerType = SL_CONTAINERTYPE_UNSPECIFIED; |
| |
| audioSource.pFormat = (void*)&mime; |
| audioSource.pLocator = (void*)&locatorFd; |
| |
| /* Create the audio player */ |
| result = (*EngineItf)->CreateAudioPlayer(EngineItf, &player, &audioSource, &audioSink, 1, |
| iidArray, required); |
| ExitOnError(result); |
| |
| /* Realize the player in synchronous mode. */ |
| result = (*player)->Realize(player, SL_BOOLEAN_FALSE); ExitOnError(result); |
| fprintf(stdout, "URI example: after Realize\n"); |
| |
| /* Get the SLPlayItf, SLPrefetchStatusItf and SLAndroidStreamTypeItf interfaces for the player*/ |
| result = (*player)->GetInterface(player, SL_IID_PLAY, (void*)&playItf); |
| ExitOnError(result); |
| |
| result = (*player)->GetInterface(player, SL_IID_PREFETCHSTATUS, (void*)&prefetchItf); |
| ExitOnError(result); |
| |
| fprintf(stdout, "Player configured\n"); |
| |
| /* ------------------------------------------------------ */ |
| /* Playback and test */ |
| |
| /* Start the data prefetching by setting the player to the paused state */ |
| result = (*playItf)->SetPlayState( playItf, SL_PLAYSTATE_PAUSED ); |
| ExitOnError(result); |
| |
| /* Wait until there's data to play */ |
| SLuint32 prefetchStatus = SL_PREFETCHSTATUS_UNDERFLOW; |
| while (prefetchStatus != SL_PREFETCHSTATUS_SUFFICIENTDATA) { |
| usleep(100 * 1000); |
| (*prefetchItf)->GetPrefetchStatus(prefetchItf, &prefetchStatus); |
| ExitOnError(result); |
| } |
| |
| /* Get duration */ |
| SLmillisecond durationInMsec = SL_TIME_UNKNOWN; |
| result = (*playItf)->GetDuration(playItf, &durationInMsec); |
| ExitOnError(result); |
| if (durationInMsec == SL_TIME_UNKNOWN) { |
| durationInMsec = 5000; |
| } |
| |
| /* Start playback */ |
| result = (*playItf)->SetPlayState( playItf, SL_PLAYSTATE_PLAYING ); |
| ExitOnError(result); |
| |
| usleep(durationInMsec * 1000); |
| |
| /* Make sure player is stopped */ |
| fprintf(stdout, "Stopping playback\n"); |
| result = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_STOPPED); |
| ExitOnError(result); |
| |
| /* Destroy the player */ |
| (*player)->Destroy(player); |
| |
| /* Destroy Output Mix object */ |
| (*outputMix)->Destroy(outputMix); |
| |
| close(fd); |
| } |
| |
| //----------------------------------------------------------------- |
| int main(int argc, char* const argv[]) |
| { |
| SLresult result; |
| SLObjectItf sl; |
| |
| fprintf(stdout, "OpenSL ES test %s: exercises SLPlayItf ", argv[0]); |
| fprintf(stdout, "and AudioPlayer with SLDataLocator_AndroidFD source / OutputMix sink\n"); |
| fprintf(stdout, "Plays the sound file designated by the given path, "); |
| fprintf(stdout, "starting at the specified offset, and using the specified length.\n"); |
| fprintf(stdout, "Omit the length of the file for it to be computed by the system.\n"); |
| |
| if (argc < 3) { |
| fprintf(stdout, "Usage: \t%s path offsetInBytes [sizeInBytes]\n", argv[0]); |
| fprintf(stdout, "Example: \"%s /sdcard/my.mp3 0 344460\" \n", argv[0]); |
| exit(EXIT_FAILURE); |
| } |
| |
| SLEngineOption EngineOption[] = { |
| {(SLuint32) SL_ENGINEOPTION_THREADSAFE, (SLuint32) SL_BOOLEAN_TRUE} |
| }; |
| |
| result = slCreateEngine( &sl, 1, EngineOption, 0, NULL, NULL); |
| ExitOnError(result); |
| |
| /* Realizing the SL Engine in synchronous mode. */ |
| result = (*sl)->Realize(sl, SL_BOOLEAN_FALSE); |
| ExitOnError(result); |
| |
| if (argc == 3) { |
| fprintf(stdout, "no file size given, using SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE\n"); |
| TestPlayPathFromFD(sl, argv[1], (SLAint64)atoi(argv[2]), |
| SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE); |
| } else { |
| TestPlayPathFromFD(sl, argv[1], (SLAint64)atoi(argv[2]), (SLAint64)atoi(argv[3])); |
| } |
| |
| /* Shutdown OpenSL ES */ |
| (*sl)->Destroy(sl); |
| |
| return EXIT_SUCCESS; |
| } |