encounter
/
SDL
mirror of https://github.com/encounter/SDL.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Android/openslES: some space and indentation to match SDL conventions

This commit is contained in:
Sylvain Becker 2019-01-14 10:04:54 +01:00
parent 7dc92a7669
commit 365fd9c602
1 changed files with 361 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

717
src/audio/openslES/SDL_openslES.c
View File

@ -50,453 +50,452 @@ static SLObjectItf outputMixObject = NULL;
//static SLEnvironmentalReverbItf outputMixEnvironmentalReverb = NULL; //static SLEnvironmentalReverbItf outputMixEnvironmentalReverb = NULL;
// aux effect on the output mix, used by the buffer queue player // aux effect on the output mix, used by the buffer queue player
static const SLEnvironmentalReverbSettings reverbSettings = // static const SLEnvironmentalReverbSettings reverbSettings = SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR;
SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR;
// buffer queue player interfaces // buffer queue player interfaces
static SLObjectItf bqPlayerObject = NULL; static SLObjectItf bqPlayerObject = NULL;
static SLPlayItf bqPlayerPlay; static SLPlayItf bqPlayerPlay;
static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue; static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue;
//static SLEffectSendItf bqPlayerEffectSend; //static SLEffectSendItf bqPlayerEffectSend;
static SLMuteSoloItf bqPlayerMuteSolo; static SLMuteSoloItf bqPlayerMuteSolo;
static SLVolumeItf bqPlayerVolume; static SLVolumeItf bqPlayerVolume;
#if 0
// recorder interfaces TODO // recorder interfaces TODO
static SLObjectItf recorderObject = NULL; static SLObjectItf recorderObject = NULL;
static SLRecordItf recorderRecord; static SLRecordItf recorderRecord;
static SLAndroidSimpleBufferQueueItf recorderBufferQueue; static SLAndroidSimpleBufferQueueItf recorderBufferQueue;
#endif
// pointer and size of the next player buffer to enqueue, and number of remaining buffers // pointer and size of the next player buffer to enqueue, and number of remaining buffers
static short *nextBuffer; #if 0
static unsigned nextSize; static short *nextBuffer;
static int nextCount; static unsigned nextSize;
static int nextCount;
static const char *sldevaudiorecorderstr = "SLES Audio Recorder"; #endif
static const char *sldevaudioplayerstr = "SLES Audio Player";
#define SLES_DEV_AUDIO_RECORDER sldevaudiorecorderstr
#define SLES_DEV_AUDIO_PLAYER sldevaudioplayerstr
#define NUM_BUFFERS 2 /* -- Don't lower this! */ #define NUM_BUFFERS 2 /* -- Don't lower this! */
static Uint8 *mixbuff = NULL; static Uint8 *mixbuff = NULL;
static int next_buffer = 0; static int next_buffer = 0;
static Uint8 *pmixbuff[NUM_BUFFERS]; static Uint8 *pmixbuff[NUM_BUFFERS];
static SDL_sem *playsem = NULL, *recsem = NULL; static SDL_sem *playsem = NULL;
#if 0
static SDL_sem *recsem = NULL;
#endif
//static SDL_AudioDevice* audioDevice = NULL; //static SDL_AudioDevice* audioDevice = NULL;
#if 0 #if 0
static const char *sldevaudiorecorderstr = "SLES Audio Recorder";
static const char *sldevaudioplayerstr = "SLES Audio Player";
#define SLES_DEV_AUDIO_RECORDER sldevaudiorecorderstr
#define SLES_DEV_AUDIO_PLAYER sldevaudioplayerstr
static void openslES_DetectDevices( int iscapture ) static void openslES_DetectDevices( int iscapture )
{ {
LOGI( "openSLES_DetectDevices()" ); LOGI( "openSLES_DetectDevices()" );
if ( iscapture ) if ( iscapture )
addfn( SLES_DEV_AUDIO_RECORDER ); addfn( SLES_DEV_AUDIO_RECORDER );
else else
addfn( SLES_DEV_AUDIO_PLAYER ); addfn( SLES_DEV_AUDIO_PLAYER );
return; return;
} }
#endif #endif
static void openslES_DestroyEngine( void ); static void openslES_DestroyEngine(void);
static int openslES_CreateEngine( void ) static int
openslES_CreateEngine(void)
{ {
SLresult result; SLresult result;
LOGI( "openSLES_CreateEngine()" ); LOGI("openSLES_CreateEngine()");
// create engine // create engine
result = slCreateEngine( &engineObject, 0, NULL, 0, NULL, NULL ); result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
LOGE("slCreateEngine failed");
goto error;
}
LOGE( "slCreateEngine failed" ); LOGI("slCreateEngine OK");
goto error;
}
LOGI( "slCreateEngine OK" );
// realize the engine // realize the engine
result = (*engineObject)->Realize( engineObject, SL_BOOLEAN_FALSE ); result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
LOGE("RealizeEngine failed");
goto error;
}
LOGE( "RealizeEngine failed" ); LOGI("RealizeEngine OK");
goto error;
}
LOGI( "RealizeEngine OK" );
// get the engine interface, which is needed in order to create other objects // get the engine interface, which is needed in order to create other objects
result = (*engineObject)->GetInterface( engineObject, SL_IID_ENGINE, &engineEngine ); result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
LOGE("EngineGetInterface failed");
goto error;
}
LOGE( "EngineGetInterface failed" ); LOGI("EngineGetInterface OK");
goto error;
}
LOGI( "EngineGetInterface OK" );
// create output mix, with environmental reverb specified as a non-required interface // create output mix, with environmental reverb specified as a non-required interface
// const SLInterfaceID ids[1] = { SL_IID_ENVIRONMENTALREVERB }; // const SLInterfaceID ids[1] = { SL_IID_ENVIRONMENTALREVERB };
// const SLboolean req[1] = { SL_BOOLEAN_FALSE }; // const SLboolean req[1] = { SL_BOOLEAN_FALSE };
const SLInterfaceID ids[1] = { SL_IID_VOLUME }; const SLInterfaceID ids[1] = { SL_IID_VOLUME };
const SLboolean req[1] = { SL_BOOLEAN_FALSE }; const SLboolean req[1] = { SL_BOOLEAN_FALSE };
result = (*engineEngine)->CreateOutputMix( engineEngine, &outputMixObject, 1, ids, req ); result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 1, ids, req);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
LOGE("CreateOutputMix failed");
goto error;
}
LOGI("CreateOutputMix OK");
LOGE( "CreateOutputMix failed" ); // realize the output mix
goto error; result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
} if (SL_RESULT_SUCCESS != result) {
LOGI( "CreateOutputMix OK" ); LOGE("RealizeOutputMix failed");
goto error;
}
return 1;
// realize the output mix error:
result = (*outputMixObject)->Realize( outputMixObject, SL_BOOLEAN_FALSE ); openslES_DestroyEngine();
if ( SL_RESULT_SUCCESS != result ) { return 0;
LOGE( "RealizeOutputMix failed" );
goto error;
}
return 1;
error:;
openslES_DestroyEngine( );
return 0;
} }
static void openslES_DestroyPCMPlayer( void ); static void openslES_DestroyPCMPlayer(void);
static void openslES_DestroyPCMRecorder( void ); static void openslES_DestroyPCMRecorder(void);
static void openslES_DestroyEngine( void ) static void openslES_DestroyEngine(void)
{ {
LOGI( "openslES_DestroyEngine()" ); LOGI("openslES_DestroyEngine()");
openslES_DestroyPCMPlayer();
openslES_DestroyPCMRecorder();
openslES_DestroyPCMPlayer( ); // destroy output mix object, and invalidate all associated interfaces
openslES_DestroyPCMRecorder( ); if (outputMixObject != NULL) {
(*outputMixObject)->Destroy(outputMixObject);
outputMixObject = NULL;
// outputMixEnvironmentalReverb = NULL;
}
// destroy output mix object, and invalidate all associated interfaces // destroy engine object, and invalidate all associated interfaces
if ( outputMixObject != NULL ) { if (engineObject != NULL) {
(*engineObject)->Destroy(engineObject);
engineObject = NULL;
engineEngine = NULL;
}
(*outputMixObject)->Destroy( outputMixObject ); return;
outputMixObject = NULL;
// outputMixEnvironmentalReverb = NULL;
}
// destroy engine object, and invalidate all associated interfaces
if (engineObject != NULL) {
(*engineObject)->Destroy( engineObject );
engineObject = NULL;
engineEngine = NULL;
}
return;
} }
// this callback handler is called every time a buffer finishes playing // this callback handler is called every time a buffer finishes playing
static void bqPlayerCallback( SLAndroidSimpleBufferQueueItf bq, void *context ) static void
bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{ {
static int t = 0; static int t = 0;
// assert(bq == bqPlayerBufferQueue);
// assert(NULL == context); // assert(bq == bqPlayerBufferQueue);
// assert(NULL == context);
// for streaming playback, replace this test by logic to find and fill the next buffer // for streaming playback, replace this test by logic to find and fill the next buffer
#if 0 #if 0
if (--nextCount > 0 && NULL != nextBuffer && 0 != nextSize) { if (--nextCount > 0 && NULL != nextBuffer && 0 != nextSize)
SLresult result; {
// enqueue another buffer SLresult result;
result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, nextBuffer, nextSize);
// the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT, // enqueue another buffer
// which for this code example would indicate a programming error result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, nextBuffer, nextSize);
assert(SL_RESULT_SUCCESS == result); // the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT,
(void)result; // which for this code example would indicate a programming error
} assert(SL_RESULT_SUCCESS == result);
(void) result;
}
#endif #endif
LOGI("SLES: Playback Callmeback %u", t++);
LOGI( "SLES: Playback Callmeback %u", t++ ); SDL_SemPost(playsem);
return;
SDL_SemPost( playsem );
return;
} }
static int openslES_CreatePCMRecorder( _THIS ) static int
openslES_CreatePCMRecorder(_THIS)
{ {
LOGE( "openslES_CreatePCMRecorder not implimented yet!" ); LOGE("openslES_CreatePCMRecorder not implimented yet!");
return SDL_SetError( "openslES_CreatePCMRecorder not implimented yet!" ); return SDL_SetError("openslES_CreatePCMRecorder not implimented yet!");
} }
static void openslES_DestroyPCMRecorder( void ) static void
openslES_DestroyPCMRecorder(void)
{ {
return; return;
} }
static int openslES_CreatePCMPlayer( _THIS ) static int
openslES_CreatePCMPlayer(
_THIS)
{ {
SLDataFormat_PCM format_pcm; SLDataFormat_PCM format_pcm;
SDL_AudioFormat test_format;
SLresult result; SLresult result;
int i; int i;
/*
SDL_AudioFormat test_format;
test_format = SDL_FirstAudioFormat( this->spec.format );
while (test_format != 0) {
if (SDL_AUDIO_ISSIGNED(test_format) && SDL_AUDIO_ISINT(test_format)) {
break;
}
test_format = SDL_NextAudioFormat();
}
if ( test_format == 0 ) {
// Didn't find a compatible format :
LOGI( "No compatible audio format!" );
return SDL_SetError("No compatible audio format!");
}
this->spec.format = test_format;
*/
// Update the fragment size as size in bytes
SDL_CalculateAudioSpec(&this->spec);
LOGI("Try to open %u hz %u bit chan %u %s samples %u",
this->spec.freq, SDL_AUDIO_BITSIZE(this->spec.format),
this->spec.channels, (test_format & 0x1000) ? "BE" : "LE", this->spec.samples);
// configure audio source
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2 };
// SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, OPENSLES_BUFFERS };
format_pcm.formatType = SL_DATAFORMAT_PCM;
format_pcm.numChannels = this->spec.channels;
format_pcm.samplesPerSec = this->spec.freq * 1000; // / kilo Hz to milli Hz
format_pcm.bitsPerSample = SDL_AUDIO_BITSIZE(this->spec.format);
format_pcm.containerSize = SDL_AUDIO_BITSIZE(this->spec.format);
if (SDL_AUDIO_ISBIGENDIAN(this->spec.format)) {
format_pcm.endianness = SL_BYTEORDER_BIGENDIAN;
} else {
format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
}
/* /*
test_format = SDL_FirstAudioFormat( this->spec.format ); #define SL_SPEAKER_FRONT_LEFT ((SLuint32) 0x00000001)
#define SL_SPEAKER_FRONT_RIGHT ((SLuint32) 0x00000002)
while ( test_format != 0 ) { #define SL_SPEAKER_FRONT_CENTER ((SLuint32) 0x00000004)
#define SL_SPEAKER_LOW_FREQUENCY ((SLuint32) 0x00000008)
if ( SDL_AUDIO_ISSIGNED(test_format) && SDL_AUDIO_ISINT(test_format ) ) break; #define SL_SPEAKER_BACK_LEFT ((SLuint32) 0x00000010)
test_format = SDL_NextAudioFormat( ); #define SL_SPEAKER_BACK_RIGHT ((SLuint32) 0x00000020)
} #define SL_SPEAKER_FRONT_LEFT_OF_CENTER ((SLuint32) 0x00000040)
#define SL_SPEAKER_FRONT_RIGHT_OF_CENTER ((SLuint32) 0x00000080)
if ( test_format == 0 ) { #define SL_SPEAKER_BACK_CENTER ((SLuint32) 0x00000100)
#define SL_SPEAKER_SIDE_LEFT ((SLuint32) 0x00000200)
// Didn't find a compatible format :( #define SL_SPEAKER_SIDE_RIGHT ((SLuint32) 0x00000400)
LOGI( "No compatible audio format!" ); #define SL_SPEAKER_TOP_CENTER ((SLuint32) 0x00000800)
return SDL_SetError("No compatible audio format!"); #define SL_SPEAKER_TOP_FRONT_LEFT ((SLuint32) 0x00001000)
} #define SL_SPEAKER_TOP_FRONT_CENTER ((SLuint32) 0x00002000)
#define SL_SPEAKER_TOP_FRONT_RIGHT ((SLuint32) 0x00004000)
this->spec.format = test_format; #define SL_SPEAKER_TOP_BACK_LEFT ((SLuint32) 0x00008000)
#define SL_SPEAKER_TOP_BACK_CENTER ((SLuint32) 0x00010000)
#define SL_SPEAKER_TOP_BACK_RIGHT ((SLuint32) 0x00020000)
*/ */
// Update the fragment size as size in bytes if (this->spec.channels == 1) {
SDL_CalculateAudioSpec( &this->spec ); format_pcm.channelMask = SL_SPEAKER_FRONT_CENTER;
} else if (this->spec.channels == 2) {
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
} else if (this->spec.channels == 3) {
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT | SL_SPEAKER_FRONT_CENTER;
} else if (this->spec.channels == 4) {
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
SL_SPEAKER_BACK_LEFT | SL_SPEAKER_BACK_RIGHT;
} else {
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
SL_SPEAKER_BACK_LEFT | SL_SPEAKER_BACK_RIGHT | SL_SPEAKER_FRONT_CENTER;
}
LOGI( "Try to open %u hz %u bit chan %u %s samples %u", SLDataSource audioSrc = { &loc_bufq, &format_pcm };
this->spec.freq, SDL_AUDIO_BITSIZE( this->spec.format ),
this->spec.channels, (test_format&0x1000) ? "BE" : "LE", this->spec.samples
);
// configure audio source // configure audio sink
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2 }; SLDataLocator_OutputMix loc_outmix = { SL_DATALOCATOR_OUTPUTMIX, outputMixObject };
// SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, OPENSLES_BUFFERS }; SLDataSink audioSnk = { &loc_outmix, NULL };
format_pcm.formatType = SL_DATAFORMAT_PCM;
format_pcm.numChannels = this->spec.channels;
format_pcm.samplesPerSec = this->spec.freq * 1000; /// kilo Hz to milli Hz
format_pcm.bitsPerSample = SDL_AUDIO_BITSIZE( this->spec.format );
format_pcm.containerSize = SDL_AUDIO_BITSIZE( this->spec.format );
if ( SDL_AUDIO_ISBIGENDIAN( this->spec.format ) )
format_pcm.endianness = SL_BYTEORDER_BIGENDIAN;
else
format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
/*
#define SL_SPEAKER_FRONT_LEFT ((SLuint32) 0x00000001)
#define SL_SPEAKER_FRONT_RIGHT ((SLuint32) 0x00000002)
#define SL_SPEAKER_FRONT_CENTER ((SLuint32) 0x00000004)
#define SL_SPEAKER_LOW_FREQUENCY ((SLuint32) 0x00000008)
#define SL_SPEAKER_BACK_LEFT ((SLuint32) 0x00000010)
#define SL_SPEAKER_BACK_RIGHT ((SLuint32) 0x00000020)
#define SL_SPEAKER_FRONT_LEFT_OF_CENTER ((SLuint32) 0x00000040)
#define SL_SPEAKER_FRONT_RIGHT_OF_CENTER ((SLuint32) 0x00000080)
#define SL_SPEAKER_BACK_CENTER ((SLuint32) 0x00000100)
#define SL_SPEAKER_SIDE_LEFT ((SLuint32) 0x00000200)
#define SL_SPEAKER_SIDE_RIGHT ((SLuint32) 0x00000400)
#define SL_SPEAKER_TOP_CENTER ((SLuint32) 0x00000800)
#define SL_SPEAKER_TOP_FRONT_LEFT ((SLuint32) 0x00001000)
#define SL_SPEAKER_TOP_FRONT_CENTER ((SLuint32) 0x00002000)
#define SL_SPEAKER_TOP_FRONT_RIGHT ((SLuint32) 0x00004000)
#define SL_SPEAKER_TOP_BACK_LEFT ((SLuint32) 0x00008000)
#define SL_SPEAKER_TOP_BACK_CENTER ((SLuint32) 0x00010000)
#define SL_SPEAKER_TOP_BACK_RIGHT ((SLuint32) 0x00020000)
*/
if ( this->spec.channels == 1 )
format_pcm.channelMask = SL_SPEAKER_FRONT_CENTER;
else if ( this->spec.channels == 2 )
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
else if ( this->spec.channels == 3 )
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT | SL_SPEAKER_FRONT_CENTER;
else if ( this->spec.channels == 4 )
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
SL_SPEAKER_BACK_LEFT | SL_SPEAKER_BACK_RIGHT;
else
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
SL_SPEAKER_BACK_LEFT | SL_SPEAKER_BACK_RIGHT |
SL_SPEAKER_FRONT_CENTER;
SLDataSource audioSrc = { &loc_bufq, &format_pcm };
// configure audio sink
SLDataLocator_OutputMix loc_outmix = { SL_DATALOCATOR_OUTPUTMIX, outputMixObject };
SLDataSink audioSnk = { &loc_outmix, NULL };
// create audio player // create audio player
const SLInterfaceID ids[2] = { const SLInterfaceID ids[2] = {
SL_IID_ANDROIDSIMPLEBUFFERQUEUE, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
SL_IID_VOLUME SL_IID_VOLUME
}; };
const SLboolean req[2] = { const SLboolean req[2] = {
SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE,
SL_BOOLEAN_FALSE, SL_BOOLEAN_FALSE,
}; };
result = (*engineEngine)->CreateAudioPlayer( engineEngine, &bqPlayerObject, &audioSrc, &audioSnk, result = (*engineEngine)->CreateAudioPlayer(engineEngine, &bqPlayerObject, &audioSrc, &audioSnk, 2, ids, req);
2, ids, req ); if (SL_RESULT_SUCCESS != result) {
if ( SL_RESULT_SUCCESS != result ) { LOGE("CreateAudioPlayer failed");
goto failed;
LOGE( "CreateAudioPlayer failed" ); }
goto failed;
}
// realize the player // realize the player
result = (*bqPlayerObject)->Realize( bqPlayerObject, SL_BOOLEAN_FALSE ); result = (*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
LOGE("RealizeAudioPlayer failed");
goto failed;
}
LOGE( "RealizeAudioPlayer failed" ); // get the play interface
goto failed; result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY, &bqPlayerPlay);
} if (SL_RESULT_SUCCESS != result) {
LOGE("SL_IID_PLAY interface get failed");
// get the play interface goto failed;
result = (*bqPlayerObject)->GetInterface( bqPlayerObject, SL_IID_PLAY, &bqPlayerPlay ); }
if ( SL_RESULT_SUCCESS != result ) {
LOGE( "SL_IID_PLAY interface get failed" );
goto failed;
}
// get the buffer queue interface // get the buffer queue interface
result = (*bqPlayerObject)->GetInterface( bqPlayerObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &bqPlayerBufferQueue ); result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &bqPlayerBufferQueue);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
LOGE("SL_IID_BUFFERQUEUE interface get failed");
goto failed;
}
LOGE( "SL_IID_BUFFERQUEUE interface get failed" ); // register callback on the buffer queue
goto failed; result = (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, NULL);
} if (SL_RESULT_SUCCESS != result) {
LOGE("RegisterCallback failed");
// register callback on the buffer queue goto failed;
result = (*bqPlayerBufferQueue)->RegisterCallback( bqPlayerBufferQueue, bqPlayerCallback, NULL ); }
if ( SL_RESULT_SUCCESS != result ) {
LOGE( "RegisterCallback failed" );
goto failed;
}
#if 0 #if 0
// get the effect send interface // get the effect send interface
result = (*bqPlayerObject)->GetInterface( bqPlayerObject, SL_IID_EFFECTSEND, &bqPlayerEffectSend ); result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_EFFECTSEND, &bqPlayerEffectSend);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result)
{
LOGE( "SL_IID_EFFECTSEND interface get failed" ); LOGE("SL_IID_EFFECTSEND interface get failed");
goto failed; goto failed;
} }
#endif #endif
#if 0 // mute/solo is not supported for sources that are known to be mono, as this is #if 0 // mute/solo is not supported for sources that are known to be mono, as this is
// get the mute/solo interface // get the mute/solo interface
result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_MUTESOLO, &bqPlayerMuteSolo); result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_MUTESOLO, &bqPlayerMuteSolo);
assert(SL_RESULT_SUCCESS == result); assert(SL_RESULT_SUCCESS == result);
(void)result; (void) result;
#endif #endif
// get the volume interface // get the volume interface
result = (*bqPlayerObject)->GetInterface( bqPlayerObject, SL_IID_VOLUME, &bqPlayerVolume ); result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_VOLUME, &bqPlayerVolume);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
LOGE("SL_IID_VOLUME interface get failed");
// goto failed;
}
LOGE( "SL_IID_VOLUME interface get failed" ); // set the player's state to playing
// goto failed; result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);
} if (SL_RESULT_SUCCESS != result) {
LOGE("Play set state failed");
// set the player's state to playing goto failed;
result = (*bqPlayerPlay)->SetPlayState( bqPlayerPlay, SL_PLAYSTATE_PLAYING ); }
if ( SL_RESULT_SUCCESS != result ) {
LOGE( "Play set state failed" );
goto failed;
}
/* Create the audio buffer semaphore */ /* Create the audio buffer semaphore */
playsem = SDL_CreateSemaphore( NUM_BUFFERS - 1 ); playsem = SDL_CreateSemaphore(NUM_BUFFERS - 1);
if ( !playsem ) { if (!playsem) {
LOGE("cannot create Semaphore!");
goto failed;
}
LOGE( "cannot create Semaphore!" ); /* Create the sound buffers */
goto failed; mixbuff = (Uint8 *) SDL_malloc(NUM_BUFFERS * this->spec.size);
} if (mixbuff == NULL) {
LOGE("mixbuffer allocate - out of memory");
goto failed;
}
/* Create the sound buffers */ for (i = 0; i < NUM_BUFFERS; i++) {
mixbuff = (Uint8 *) SDL_malloc( NUM_BUFFERS * this->spec.size ); pmixbuff[i] = mixbuff + i * this->spec.size;
if ( mixbuff == NULL) { }
LOGE( "mixbuffer allocate - out of memory" );
goto failed;
}
for ( i = 0; i < NUM_BUFFERS; i ++ )
pmixbuff[i] = mixbuff + i * this->spec.size;
return 0; return 0;
failed:; failed:
openslES_DestroyPCMPlayer( ); openslES_DestroyPCMPlayer();
return SDL_SetError( "Open device failed!" ); return SDL_SetError("Open device failed!");
} }
static void openslES_DestroyPCMPlayer( void ) static void
openslES_DestroyPCMPlayer(void)
{ {
// destroy buffer queue audio player object, and invalidate all associated interfaces // destroy buffer queue audio player object, and invalidate all associated interfaces
if ( bqPlayerObject != NULL ) { if (bqPlayerObject != NULL) {
(*bqPlayerObject)->Destroy( bqPlayerObject ); (*bqPlayerObject)->Destroy(bqPlayerObject);
bqPlayerObject = NULL; bqPlayerObject = NULL;
bqPlayerPlay = NULL; bqPlayerPlay = NULL;
bqPlayerBufferQueue = NULL; bqPlayerBufferQueue = NULL;
// bqPlayerEffectSend = NULL; // bqPlayerEffectSend = NULL;
bqPlayerMuteSolo = NULL; bqPlayerMuteSolo = NULL;
bqPlayerVolume = NULL; bqPlayerVolume = NULL;
} }
if ( playsem ) { if (playsem) {
SDL_DestroySemaphore(playsem);
playsem = NULL;
}
SDL_DestroySemaphore( playsem ); if (mixbuff) {
playsem = NULL; SDL_free(mixbuff);
} }
if ( mixbuff ) return;
SDL_free( mixbuff );
return;
} }
static int openslES_OpenDevice( _THIS, void *handle, const char *devname, int iscapture ) static int
openslES_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
{ {
if ( iscapture ) { if (iscapture) {
LOGI( "openslES_OpenDevice( ) %s for capture", devname ); LOGI("openslES_OpenDevice( ) %s for capture", devname);
return openslES_CreatePCMRecorder( this ); return openslES_CreatePCMRecorder(this);
} } else {
LOGI("openslES_OpenDevice( ) %s for playing", devname);
LOGI( "openslES_OpenDevice( ) %s for playing", devname ); return openslES_CreatePCMPlayer(this);
}
return openslES_CreatePCMPlayer( this );
} }
static void openslES_CloseDevice( _THIS ) static void
openslES_CloseDevice(_THIS)
{ {
if ( this->iscapture ) { if (this->iscapture) {
LOGI( "openslES_CloseDevice( ) for capture" ); LOGI("openslES_CloseDevice( ) for capture");
return openslES_DestroyPCMRecorder( ); openslES_DestroyPCMRecorder();
} } else {
LOGI("openslES_CloseDevice( ) for playing");
openslES_DestroyPCMPlayer();
}
LOGI( "openslES_CloseDevice( ) for playing" ); return;
openslES_DestroyPCMPlayer( );
return;
} }
static void openslES_WaitDevice( _THIS ) static void
openslES_WaitDevice(_THIS)
{ {
LOGI( "openslES_WaitDevice( )" ); LOGI("openslES_WaitDevice( )");
/* Wait for an audio chunk to finish */ /* Wait for an audio chunk to finish */
// WaitForSingleObject(this->hidden->audio_sem, INFINITE); // WaitForSingleObject(this->hidden->audio_sem, INFINITE);
SDL_SemWait( playsem ); SDL_SemWait(playsem);
return; return;
} }
/// n playn sem /// n playn sem
@ -507,65 +506,71 @@ static void openslES_WaitDevice( _THIS )
// getbuf 1 0 0 // getbuf 1 0 0
// fill buff 1 0 0 // fill buff 1 0 0
// play 0 0 0 // play 0 0 0
// wait // wait
// //
// okay.. // okay..
static Uint8 *
static Uint8 *openslES_GetDeviceBuf( _THIS ) openslES_GetDeviceBuf(_THIS)
{ {
LOGI( "openslES_GetDeviceBuf( )" ); LOGI("openslES_GetDeviceBuf( )");
return pmixbuff[next_buffer]; return pmixbuff[next_buffer];
} }
static void openslES_PlayDevice( _THIS ) static void
openslES_PlayDevice(_THIS)
{ {
SLresult result; SLresult result;
LOGI( "======openslES_PlayDevice( )======" ); LOGI("======openslES_PlayDevice( )======");
/* Queue it up */ /* Queue it up */
result = (*bqPlayerBufferQueue)->Enqueue( bqPlayerBufferQueue, pmixbuff[next_buffer], this->spec.size ); result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, pmixbuff[next_buffer], this->spec.size);
if ( SL_RESULT_SUCCESS != result ) { if (SL_RESULT_SUCCESS != result) {
// just puk here // just puk here
// next ! // next !
} }
next_buffer ++; next_buffer++;
if ( next_buffer >= NUM_BUFFERS ) next_buffer = 0; if (next_buffer >= NUM_BUFFERS) {
next_buffer = 0;
}
return; return;
} }
static int openslES_Init( SDL_AudioDriverImpl * impl ) static int
openslES_Init(SDL_AudioDriverImpl * impl)
{ {
LOGI( "openslES_Init() called" ); LOGI("openslES_Init() called");
if ( !openslES_CreateEngine() ) return 0; if (!openslES_CreateEngine()) {
return 0;
}
LOGI( "openslES_Init() - set pointers" ); LOGI("openslES_Init() - set pointers");
/* Set the function pointers */ /* Set the function pointers */
// impl->DetectDevices = openslES_DetectDevices; // impl->DetectDevices = openslES_DetectDevices;
impl->OpenDevice = openslES_OpenDevice; impl->OpenDevice = openslES_OpenDevice;
impl->PlayDevice = openslES_PlayDevice; impl->PlayDevice = openslES_PlayDevice;
impl->GetDeviceBuf = openslES_GetDeviceBuf; impl->GetDeviceBuf = openslES_GetDeviceBuf;
impl->Deinitialize = openslES_DestroyEngine; impl->Deinitialize = openslES_DestroyEngine;
impl->WaitDevice = openslES_WaitDevice; impl->WaitDevice = openslES_WaitDevice;
/* and the capabilities */ /* and the capabilities */
impl->HasCaptureSupport = 0; /* TODO */ impl->HasCaptureSupport = 0; /* TODO */
impl->OnlyHasDefaultOutputDevice = 1; impl->OnlyHasDefaultOutputDevice = 1;
// impl->OnlyHasDefaultInputDevice = 1; // impl->OnlyHasDefaultInputDevice = 1;
LOGI( "openslES_Init() - succes" ); LOGI("openslES_Init() - succes");
return 1; /* this audio target is available. */ /* this audio target is available. */
return 1;
} }
AudioBootStrap openslES_bootstrap = { AudioBootStrap openslES_bootstrap = {
"openslES", "opensl ES audio driver", openslES_Init, 0 "openslES", "opensl ES audio driver", openslES_Init, 0
}; };
#endif /* SDL_AUDIO_DRIVER_OPENSLES */ #endif /* SDL_AUDIO_DRIVER_OPENSLES */