slesTestEqOutputPath.cpp revision 01e9f5fa4698856f92bcfd88188ee4c8397b22db
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifdef ANDROID 18#define LOG_NDEBUG 0 19#define LOG_TAG "slesTest_seekFdPath" 20 21#include <utils/Log.h> 22#else 23#define LOGV printf 24#endif 25#include <getopt.h> 26#include <stdlib.h> 27#include <stdio.h> 28#include <string.h> 29#include <unistd.h> 30#include <sys/time.h> 31#include <fcntl.h> 32 33#include "SLES/OpenSLES.h" 34#ifdef ANDROID 35#include "SLES/OpenSLES_Android.h" 36#endif 37 38 39#define MAX_NUMBER_INTERFACES 3 40 41#define TIME_S_BETWEEN_EQ_ON_OFF 3 42 43//----------------------------------------------------------------- 44/* Exits the application if an error is encountered */ 45#define ExitOnError(x) ExitOnErrorFunc(x,__LINE__) 46 47void ExitOnErrorFunc( SLresult result , int line) 48{ 49 if (SL_RESULT_SUCCESS != result) { 50 fprintf(stderr, "%lu error code encountered at line %d, exiting\n", result, line); 51 exit(1); 52 } 53} 54 55 56//----------------------------------------------------------------- 57 58/* Play an audio path by opening a file descriptor on that path */ 59void TestEQPathFromFD( SLObjectItf sl, const char* path 60#ifdef ANDROID 61 , SLAint64 offset, SLAint64 size 62#endif 63 ) 64{ 65 SLresult result; 66 SLEngineItf EngineItf; 67 68 /* Objects this application uses: one player and an ouput mix */ 69 SLObjectItf player, outputMix; 70 71 /* Source of audio data to play */ 72 SLDataSource audioSource; 73#ifdef ANDROID 74 SLDataLocator_AndroidFD locatorFd; 75#else 76 SLDataLocator_URI locatorUri; 77#endif 78 SLDataFormat_MIME mime; 79 80 /* Data sinks for the audio player */ 81 SLDataSink audioSink; 82 SLDataLocator_OutputMix locator_outputmix; 83 84 /* Play and PrefetchStatus interfaces for the audio player */ 85 SLPlayItf playItf; 86 SLPrefetchStatusItf prefetchItf; 87 88 /* Effect interface for the output mix */ 89 SLEqualizerItf eqOutputItf; 90 91 SLboolean required[MAX_NUMBER_INTERFACES]; 92 SLInterfaceID iidArray[MAX_NUMBER_INTERFACES]; 93 94 /* Get the SL Engine Interface which is implicit */ 95 result = (*sl)->GetInterface(sl, SL_IID_ENGINE, (void*)&EngineItf); 96 ExitOnError(result); 97 98 /* Initialize arrays required[] and iidArray[] */ 99 for (int i=0 ; i < MAX_NUMBER_INTERFACES ; i++) { 100 required[i] = SL_BOOLEAN_FALSE; 101 iidArray[i] = SL_IID_NULL; 102 } 103 104 /* ------------------------------------------------------ */ 105 /* Configuration of the output mix */ 106 107 /* Set arrays required[] and iidArray[] for SLEqualizerItf interface */ 108 required[0] = SL_BOOLEAN_TRUE; 109 iidArray[0] = SL_IID_EQUALIZER; 110 111 /* Create Output Mix object to be used by the player */ 112 result = (*EngineItf)->CreateOutputMix(EngineItf, &outputMix, 1, iidArray, required); 113 ExitOnError(result); 114 115 /* Realize the Output Mix object in synchronous mode */ 116 result = (*outputMix)->Realize(outputMix, SL_BOOLEAN_FALSE); 117 ExitOnError(result); 118 119 /* Get the SLEqualizerItf interface */ 120 result = (*outputMix)->GetInterface(outputMix, SL_IID_EQUALIZER, (void*)&eqOutputItf); 121 122 /* Setup the data sink structure */ 123 locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX; 124 locator_outputmix.outputMix = outputMix; 125 audioSink.pLocator = (void*)&locator_outputmix; 126 audioSink.pFormat = NULL; 127 128 /* ------------------------------------------------------ */ 129 /* Configuration of the player */ 130 131 /* Set arrays required[] and iidArray[] for SLPrefetchStatusItf interfaces */ 132 /* (SLPlayItf is implicit) */ 133 required[0] = SL_BOOLEAN_TRUE; 134 iidArray[0] = SL_IID_PREFETCHSTATUS; 135 136 /* Setup the data source structure for the URI */ 137#ifdef ANDROID 138 locatorFd.locatorType = SL_DATALOCATOR_ANDROIDFD; 139 int fd = open(path, O_RDONLY); 140 if (fd == -1) { 141 ExitOnError(SL_RESULT_RESOURCE_ERROR); 142 } 143 locatorFd.fd = (SLint32) fd; 144 locatorFd.length = size; 145 locatorFd.offset = offset; 146#else 147 locatorUri.locatorType = SL_DATALOCATOR_URI; 148 locatorUri.URI = (SLchar *) path; 149#endif 150 151 mime.formatType = SL_DATAFORMAT_MIME; 152 /* this is how ignored mime information is specified, according to OpenSL ES spec 153 * in 9.1.6 SLDataFormat_MIME and 8.23 SLMetadataTraversalItf GetChildInfo */ 154 mime.mimeType = (SLchar*)NULL; 155 mime.containerType = SL_CONTAINERTYPE_UNSPECIFIED; 156 157 audioSource.pFormat = (void*)&mime; 158#ifdef ANDROID 159 audioSource.pLocator = (void*)&locatorFd; 160#else 161 audioSource.pLocator = (void*)&locatorUri; 162#endif 163 164 /* Create the audio player */ 165 result = (*EngineItf)->CreateAudioPlayer(EngineItf, &player, &audioSource, &audioSink, 1, 166 iidArray, required); 167 ExitOnError(result); 168 169 /* Realize the player in synchronous mode. */ 170 result = (*player)->Realize(player, SL_BOOLEAN_FALSE); ExitOnError(result); 171 fprintf(stdout, "URI example: after Realize\n"); 172 173 /* Get the SLPlayItf, SLPrefetchStatusItf and SLAndroidStreamTypeItf interfaces for the player*/ 174 result = (*player)->GetInterface(player, SL_IID_PLAY, (void*)&playItf); 175 ExitOnError(result); 176 177 result = (*player)->GetInterface(player, SL_IID_PREFETCHSTATUS, (void*)&prefetchItf); 178 ExitOnError(result); 179 180 fprintf(stdout, "Player configured\n"); 181 182 /* ------------------------------------------------------ */ 183 /* Playback and test */ 184 185 /* Start the data prefetching by setting the player to the paused state */ 186 result = (*playItf)->SetPlayState( playItf, SL_PLAYSTATE_PAUSED ); 187 ExitOnError(result); 188 189 /* Wait until there's data to play */ 190 SLuint32 prefetchStatus = SL_PREFETCHSTATUS_UNDERFLOW; 191 while (prefetchStatus != SL_PREFETCHSTATUS_SUFFICIENTDATA) { 192 usleep(100 * 1000); 193 (*prefetchItf)->GetPrefetchStatus(prefetchItf, &prefetchStatus); 194 ExitOnError(result); 195 } 196 197 /* Get duration */ 198 SLmillisecond durationInMsec = SL_TIME_UNKNOWN; 199 result = (*playItf)->GetDuration(playItf, &durationInMsec); 200 ExitOnError(result); 201 if (durationInMsec == SL_TIME_UNKNOWN) { 202 durationInMsec = 5000; 203 } 204 205 /* Start playback */ 206 fprintf(stdout, "Starting to play\n"); 207 result = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING ); 208 ExitOnError(result); 209 210 /* Configure EQ */ 211 SLuint16 nbPresets, preset, nbBands = 0; 212 result = (*eqOutputItf)->GetNumberOfBands(eqOutputItf, &nbBands); 213 ExitOnError(result); 214 result = (*eqOutputItf)->GetNumberOfPresets(eqOutputItf, &nbPresets); 215 ExitOnError(result); 216 /* Start from a preset */ 217 preset = nbPresets > 2 ? 2 : 0; 218 result = (*eqOutputItf)->UsePreset(eqOutputItf, preset); 219 220 preset = 1977; 221 result = (*eqOutputItf)->GetCurrentPreset(eqOutputItf, &preset); 222 ExitOnError(result); 223 if (SL_EQUALIZER_UNDEFINED == preset) { 224 fprintf(stderr, "Using SL_EQUALIZER_UNDEFINED preset, unexpected here!\n"); 225 } else { 226 fprintf(stdout, "Using preset %d\n", preset); 227 } 228 229 /* Tweak it so it's obvious it gets turned on/off later */ 230 SLmillibel minLevel, maxLevel = 0; 231 result = (*eqOutputItf)->GetBandLevelRange(eqOutputItf, &minLevel, &maxLevel); 232 ExitOnError(result); 233 fprintf(stdout, "Band level range = %dmB to %dmB\n", minLevel, maxLevel); 234 235 SLuint16 b = 0; 236 for(b = 0 ; b < nbBands/2 ; b++) { 237 result = (*eqOutputItf)->SetBandLevel(eqOutputItf, b, minLevel); 238 ExitOnError(result); 239 } 240 for(b = nbBands/2 ; b < nbBands ; b++) { 241 result = (*eqOutputItf)->SetBandLevel(eqOutputItf, b, maxLevel); 242 ExitOnError(result); 243 } 244 245 SLmillibel level = 0; 246 for(b = 0 ; b < nbBands ; b++) { 247 result = (*eqOutputItf)->GetBandLevel(eqOutputItf, b, &level); 248 ExitOnError(result); 249 fprintf(stdout, "Band %d level = %dmB\n", b, level); 250 } 251 252 /* Switch EQ on/off every TIME_S_BETWEEN_EQ_ON_OFF seconds */ 253 SLboolean enabled = SL_BOOLEAN_TRUE; 254 result = (*eqOutputItf)->SetEnabled(eqOutputItf, enabled); 255 ExitOnError(result); 256 for(unsigned int j=0 ; j<(durationInMsec/(1000*TIME_S_BETWEEN_EQ_ON_OFF)) ; j++) { 257 usleep(TIME_S_BETWEEN_EQ_ON_OFF * 1000 * 1000); 258 result = (*eqOutputItf)->IsEnabled(eqOutputItf, &enabled); 259 ExitOnError(result); 260 enabled = enabled == SL_BOOLEAN_TRUE ? SL_BOOLEAN_FALSE : SL_BOOLEAN_TRUE; 261 result = (*eqOutputItf)->SetEnabled(eqOutputItf, enabled); 262 if (SL_BOOLEAN_TRUE == enabled) { 263 fprintf(stdout, "EQ on\n"); 264 } else { 265 fprintf(stdout, "EQ off\n"); 266 } 267 ExitOnError(result); 268 } 269 270 /* Make sure player is stopped */ 271 fprintf(stdout, "Stopping playback\n"); 272 result = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_STOPPED); 273 ExitOnError(result); 274 275 /* Destroy the player */ 276 (*player)->Destroy(player); 277 278 /* Destroy Output Mix object */ 279 (*outputMix)->Destroy(outputMix); 280 281#ifdef ANDROID 282 close(fd); 283#endif 284} 285 286//----------------------------------------------------------------- 287int main(int argc, char* const argv[]) 288{ 289 LOGV("Starting %s\n", argv[0]); 290 291 SLresult result; 292 SLObjectItf sl; 293 294 fprintf(stdout, "OpenSL ES test %s: exercises SLEqualizerItf ", argv[0]); 295 fprintf(stdout, "on an OutputMix object\n"); 296 fprintf(stdout, "Plays the sound file designated by the given path, "); 297 fprintf(stdout, "starting at the specified offset, and using the specified length.\n"); 298 fprintf(stdout, "Omit the length of the file for it to be computed by the system.\n"); 299 fprintf(stdout, "Every %d seconds, the EQ will be turned on and off.\n", 300 TIME_S_BETWEEN_EQ_ON_OFF); 301 302#ifdef ANDROID 303 if (argc < 3) { 304 fprintf(stdout, "Usage: \t%s path offsetInBytes [sizeInBytes]\n", argv[0]); 305 fprintf(stdout, "Example: \"%s /sdcard/my.mp3 0 344460\" \n", argv[0]); 306 exit(1); 307 } 308#endif 309 310 SLEngineOption EngineOption[] = { 311 {(SLuint32) SL_ENGINEOPTION_THREADSAFE, (SLuint32) SL_BOOLEAN_TRUE} 312 }; 313 314 result = slCreateEngine( &sl, 1, EngineOption, 0, NULL, NULL); 315 ExitOnError(result); 316 317 /* Realizing the SL Engine in synchronous mode. */ 318 result = (*sl)->Realize(sl, SL_BOOLEAN_FALSE); 319 ExitOnError(result); 320 321#ifdef ANDROID 322 if (argc == 3) { 323 fprintf(stdout, "\nno file size given, using SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE\n\n"); 324 TestEQPathFromFD(sl, argv[1], (SLAint64)atoi(argv[2]), 325 SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE); 326 } else { 327 TestEQPathFromFD(sl, argv[1], (SLAint64)atoi(argv[2]), (SLAint64)atoi(argv[3])); 328 } 329#else 330 TestEQPathFromFD(sl, argv[1]); 331#endif 332 333 /* Shutdown OpenSL ES */ 334 (*sl)->Destroy(sl); 335 exit(0); 336 337 return 0; 338} 339