/
SDL_openslES.c
643 lines (529 loc) · 19.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
Simple DirectMedia Layer
Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "../../SDL_internal.h"
#if SDL_AUDIO_DRIVER_OPENSLES
25
26
27
28
/* For more discussion of low latency audio on Android, see this:
https://googlesamples.github.io/android-audio-high-performance/guides/opensl_es.html
*/
29
30
31
32
#include "SDL_audio.h"
#include "../SDL_audio_c.h"
#include "SDL_openslES.h"
33
/* for native audio */
34
35
36
37
38
39
40
#include <SLES/OpenSLES.h>
#include <SLES/OpenSLES_Android.h>
#include <android/log.h>
#define LOG_TAG "SDL_openslES"
41
42
#if 0
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
43
44
45
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
//#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE,LOG_TAG,__VA_ARGS__)
#define LOGV(...)
47
#define LOGE(...)
48
49
#define LOGI(...)
#define LOGV(...)
52
/* engine interfaces */
53
static SLObjectItf engineObject = NULL;
54
static SLEngineItf engineEngine = NULL;
56
/* output mix interfaces */
57
static SLObjectItf outputMixObject = NULL;
58
// static SLEnvironmentalReverbItf outputMixEnvironmentalReverb = NULL;
60
61
/* aux effect on the output mix, used by the buffer queue player */
/* static const SLEnvironmentalReverbSettings reverbSettings = SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR; */
63
/* buffer queue player interfaces */
64
65
66
static SLObjectItf bqPlayerObject = NULL;
static SLPlayItf bqPlayerPlay = NULL;
static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue = NULL;
67
68
#if 0
static SLEffectSendItf bqPlayerEffectSend = NULL;
69
70
static SLMuteSoloItf bqPlayerMuteSolo = NULL;
static SLVolumeItf bqPlayerVolume = NULL;
74
/* recorder interfaces TODO */
75
76
77
78
static SLObjectItf recorderObject = NULL;
static SLRecordItf recorderRecord;
static SLAndroidSimpleBufferQueueItf recorderBufferQueue;
#endif
80
/* pointer and size of the next player buffer to enqueue, and number of remaining buffers */
81
82
83
84
85
#if 0
static short *nextBuffer;
static unsigned nextSize;
static int nextCount;
#endif
87
// static SDL_AudioDevice* audioDevice = NULL;
90
91
92
93
94
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
95
96
static void openslES_DetectDevices( int iscapture )
{
97
LOGI( "openSLES_DetectDevices()" );
98
99
if ( iscapture )
addfn( SLES_DEV_AUDIO_RECORDER );
101
addfn( SLES_DEV_AUDIO_PLAYER );
103
104
105
}
#endif
106
static void openslES_DestroyEngine();
109
openslES_CreateEngine()
111
SLresult result;
113
LOGI("openSLES_CreateEngine()");
115
/* create engine */
116
117
118
119
120
result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
if (SL_RESULT_SUCCESS != result) {
LOGE("slCreateEngine failed");
goto error;
}
122
LOGI("slCreateEngine OK");
124
/* realize the engine */
125
126
127
128
129
result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
if (SL_RESULT_SUCCESS != result) {
LOGE("RealizeEngine failed");
goto error;
}
131
LOGI("RealizeEngine OK");
133
/* get the engine interface, which is needed in order to create other objects */
134
135
136
137
138
result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
if (SL_RESULT_SUCCESS != result) {
LOGE("EngineGetInterface failed");
goto error;
}
140
LOGI("EngineGetInterface OK");
142
143
144
/* create output mix, with environmental reverb specified as a non-required interface */
/* const SLInterfaceID ids[1] = { SL_IID_ENVIRONMENTALREVERB }; */
/* const SLboolean req[1] = { SL_BOOLEAN_FALSE }; */
146
147
148
const SLInterfaceID ids[1] = { SL_IID_VOLUME };
const SLboolean req[1] = { SL_BOOLEAN_FALSE };
result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 1, ids, req);
150
151
152
153
154
if (SL_RESULT_SUCCESS != result) {
LOGE("CreateOutputMix failed");
goto error;
}
LOGI("CreateOutputMix OK");
156
/* realize the output mix */
157
158
159
160
161
162
result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
if (SL_RESULT_SUCCESS != result) {
LOGE("RealizeOutputMix failed");
goto error;
}
return 1;
164
165
166
error:
openslES_DestroyEngine();
return 0;
169
170
static void openslES_DestroyPCMPlayer(_THIS);
static void openslES_DestroyPCMRecorder(_THIS);
172
static void openslES_DestroyEngine()
174
LOGI("openslES_DestroyEngine()");
176
177
// openslES_DestroyPCMPlayer(this);
// openslES_DestroyPCMRecorder(this);
179
/* destroy output mix object, and invalidate all associated interfaces */
180
181
182
if (outputMixObject != NULL) {
(*outputMixObject)->Destroy(outputMixObject);
outputMixObject = NULL;
183
/* outputMixEnvironmentalReverb = NULL; */
186
/* destroy engine object, and invalidate all associated interfaces */
187
188
189
190
191
if (engineObject != NULL) {
(*engineObject)->Destroy(engineObject);
engineObject = NULL;
engineEngine = NULL;
}
196
/* this callback handler is called every time a buffer finishes playing */
197
198
static void
bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
200
struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) context;
201
LOGV("SLES: Playback Callmeback");
202
SDL_SemPost(audiodata->playsem);
206
207
static int
openslES_CreatePCMRecorder(_THIS)
209
210
/* struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden; */
211
212
LOGE("openslES_CreatePCMRecorder not implimented yet!");
return SDL_SetError("openslES_CreatePCMRecorder not implimented yet!");
216
openslES_DestroyPCMRecorder(_THIS)
218
219
/* struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden; */
224
openslES_CreatePCMPlayer(_THIS)
226
struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
227
228
229
SLDataFormat_PCM format_pcm;
SLresult result;
int i;
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
/* If we want to add floating point audio support (requires API level 21)
it can be done as described here:
https://developer.android.com/ndk/guides/audio/opensl/android-extensions.html#floating-point
*/
#if 1
/* Just go with signed 16-bit audio as it's the most compatible */
this->spec.format = AUDIO_S16SYS;
#else
SDL_AudioFormat 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();
}
247
248
249
250
251
252
if (test_format == 0) {
/* Didn't find a compatible format : */
LOGI( "No compatible audio format, using signed 16-bit audio" );
test_format = AUDIO_S16SYS;
}
this->spec.format = test_format;
255
/* Update the fragment size as size in bytes */
256
SDL_CalculateAudioSpec(&this->spec);
258
259
LOGI("Try to open %u hz %u bit chan %u %s samples %u",
this->spec.freq, SDL_AUDIO_BITSIZE(this->spec.format),
260
this->spec.channels, (this->spec.format & 0x1000) ? "BE" : "LE", this->spec.samples);
262
/* configure audio source */
263
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, NUM_BUFFERS };
265
266
format_pcm.formatType = SL_DATAFORMAT_PCM;
format_pcm.numChannels = this->spec.channels;
267
format_pcm.samplesPerSec = this->spec.freq * 1000; /* / kilo Hz to milli Hz */
268
269
format_pcm.bitsPerSample = SDL_AUDIO_BITSIZE(this->spec.format);
format_pcm.containerSize = SDL_AUDIO_BITSIZE(this->spec.format);
271
272
273
274
275
if (SDL_AUDIO_ISBIGENDIAN(this->spec.format)) {
format_pcm.endianness = SL_BYTEORDER_BIGENDIAN;
} else {
format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
}
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
#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)
297
298
299
#define SL_ANDROID_SPEAKER_STEREO (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT)
#define SL_ANDROID_SPEAKER_QUAD (SL_ANDROID_SPEAKER_STEREO | SL_SPEAKER_BACK_LEFT | SL_SPEAKER_BACK_RIGHT)
#define SL_ANDROID_SPEAKER_5DOT1 (SL_ANDROID_SPEAKER_QUAD | SL_SPEAKER_FRONT_CENTER | SL_SPEAKER_LOW_FREQUENCY)
300
301
302
303
304
305
306
307
#define SL_ANDROID_SPEAKER_7DOT1 (SL_ANDROID_SPEAKER_5DOT1 | SL_SPEAKER_SIDE_LEFT | SL_SPEAKER_SIDE_RIGHT)
switch (this->spec.channels)
{
case 1:
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT;
break;
case 2:
308
format_pcm.channelMask = SL_ANDROID_SPEAKER_STEREO;
309
310
break;
case 3:
311
format_pcm.channelMask = SL_ANDROID_SPEAKER_STEREO | SL_SPEAKER_FRONT_CENTER;
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
break;
case 4:
format_pcm.channelMask = SL_ANDROID_SPEAKER_QUAD;
break;
case 5:
format_pcm.channelMask = SL_ANDROID_SPEAKER_QUAD | SL_SPEAKER_FRONT_CENTER;
break;
case 6:
format_pcm.channelMask = SL_ANDROID_SPEAKER_5DOT1;
break;
case 7:
format_pcm.channelMask = SL_ANDROID_SPEAKER_5DOT1 | SL_SPEAKER_BACK_CENTER;
break;
case 8:
format_pcm.channelMask = SL_ANDROID_SPEAKER_7DOT1;
break;
default:
/* Unknown number of channels, fall back to stereo */
this->spec.channels = 2;
format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
break;
335
SLDataSource audioSrc = { &loc_bufq, &format_pcm };
337
/* configure audio sink */
338
339
SLDataLocator_OutputMix loc_outmix = { SL_DATALOCATOR_OUTPUTMIX, outputMixObject };
SLDataSink audioSnk = { &loc_outmix, NULL };
341
/* create audio player */
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
const SLInterfaceID ids[2] = {
SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
SL_IID_VOLUME
};
const SLboolean req[2] = {
SL_BOOLEAN_TRUE,
SL_BOOLEAN_FALSE,
};
result = (*engineEngine)->CreateAudioPlayer(engineEngine, &bqPlayerObject, &audioSrc, &audioSnk, 2, ids, req);
if (SL_RESULT_SUCCESS != result) {
LOGE("CreateAudioPlayer failed");
goto failed;
}
358
/* realize the player */
359
360
361
362
363
result = (*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE);
if (SL_RESULT_SUCCESS != result) {
LOGE("RealizeAudioPlayer failed");
goto failed;
}
365
/* get the play interface */
366
result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY, &bqPlayerPlay);
367
368
369
370
if (SL_RESULT_SUCCESS != result) {
LOGE("SL_IID_PLAY interface get failed");
goto failed;
}
372
/* get the buffer queue interface */
373
374
375
376
377
result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &bqPlayerBufferQueue);
if (SL_RESULT_SUCCESS != result) {
LOGE("SL_IID_BUFFERQUEUE interface get failed");
goto failed;
}
379
380
381
/* register callback on the buffer queue */
/* context is '(SDL_PrivateAudioData *)this->hidden' */
result = (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, this->hidden);
382
383
384
385
if (SL_RESULT_SUCCESS != result) {
LOGE("RegisterCallback failed");
goto failed;
}
388
/* get the effect send interface */
389
390
391
result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_EFFECTSEND, &bqPlayerEffectSend);
if (SL_RESULT_SUCCESS != result)
{
393
394
395
LOGE("SL_IID_EFFECTSEND interface get failed");
goto failed;
}
398
399
#if 0 /* mute/solo is not supported for sources that are known to be mono, as this is */
/* get the mute/solo interface */
400
401
result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_MUTESOLO, &bqPlayerMuteSolo);
assert(SL_RESULT_SUCCESS == result);
402
(void) result;
406
/* get the volume interface */
407
408
409
result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_VOLUME, &bqPlayerVolume);
if (SL_RESULT_SUCCESS != result) {
LOGE("SL_IID_VOLUME interface get failed");
410
/* goto failed; */
413
414
/* Create the audio buffer semaphore */
415
416
audiodata->playsem = SDL_CreateSemaphore(NUM_BUFFERS - 1);
if (!audiodata->playsem) {
417
418
419
LOGE("cannot create Semaphore!");
goto failed;
}
421
/* Create the sound buffers */
422
423
audiodata->mixbuff = (Uint8 *) SDL_malloc(NUM_BUFFERS * this->spec.size);
if (audiodata->mixbuff == NULL) {
424
425
426
LOGE("mixbuffer allocate - out of memory");
goto failed;
}
428
for (i = 0; i < NUM_BUFFERS; i++) {
429
audiodata->pmixbuff[i] = audiodata->mixbuff + i * this->spec.size;
432
/* set the player's state to playing */
433
result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);
434
435
436
437
438
if (SL_RESULT_SUCCESS != result) {
LOGE("Play set state failed");
goto failed;
}
439
440
return 0;
443
openslES_DestroyPCMPlayer(this);
445
return SDL_SetError("Open device failed!");
449
openslES_DestroyPCMPlayer(_THIS)
451
struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
452
453
454
SLresult result;
/* set the player's state to 'stopped' */
455
456
457
458
459
if (bqPlayerPlay != NULL) {
result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_STOPPED);
if (SL_RESULT_SUCCESS != result) {
SDL_SetError("Stopped set state failed");
}
461
462
/* destroy buffer queue audio player object, and invalidate all associated interfaces */
463
if (bqPlayerObject != NULL) {
465
(*bqPlayerObject)->Destroy(bqPlayerObject);
467
bqPlayerObject = NULL;
468
bqPlayerPlay = NULL;
469
bqPlayerBufferQueue = NULL;
470
471
#if 0
bqPlayerEffectSend = NULL;
472
473
bqPlayerMuteSolo = NULL;
bqPlayerVolume = NULL;
477
478
479
if (audiodata->playsem) {
SDL_DestroySemaphore(audiodata->playsem);
audiodata->playsem = NULL;
482
483
if (audiodata->mixbuff) {
SDL_free(audiodata->mixbuff);
489
490
static int
openslES_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
492
493
494
495
496
this->hidden = (struct SDL_PrivateAudioData *) SDL_calloc(1, (sizeof *this->hidden));
if (this->hidden == NULL) {
return SDL_OutOfMemory();
}
497
498
499
500
501
502
503
if (iscapture) {
LOGI("openslES_OpenDevice( ) %s for capture", devname);
return openslES_CreatePCMRecorder(this);
} else {
LOGI("openslES_OpenDevice( ) %s for playing", devname);
return openslES_CreatePCMPlayer(this);
}
506
507
static void
openslES_CloseDevice(_THIS)
509
510
/* struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden; */
511
512
if (this->iscapture) {
LOGI("openslES_CloseDevice( ) for capture");
513
openslES_DestroyPCMRecorder(this);
514
515
} else {
LOGI("openslES_CloseDevice( ) for playing");
516
openslES_DestroyPCMPlayer(this);
519
520
SDL_free(this->hidden);
524
525
static void
openslES_WaitDevice(_THIS)
527
528
struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
529
LOGV("openslES_WaitDevice( )");
530
531
/* Wait for an audio chunk to finish */
532
533
/* WaitForSingleObject(this->hidden->audio_sem, INFINITE); */
SDL_SemWait(audiodata->playsem);
538
539
540
541
542
543
544
545
546
547
548
/*/ n playn sem */
/* getbuf 0 - 1 */
/* fill buff 0 - 1 */
/* play 0 - 0 1 */
/* wait 1 0 0 */
/* getbuf 1 0 0 */
/* fill buff 1 0 0 */
/* play 0 0 0 */
/* wait */
/* */
/* okay.. */
550
551
static Uint8 *
openslES_GetDeviceBuf(_THIS)
553
554
struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
555
LOGV("openslES_GetDeviceBuf( )");
556
return audiodata->pmixbuff[audiodata->next_buffer];
559
560
static void
openslES_PlayDevice(_THIS)
562
struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
563
SLresult result;
565
LOGV("======openslES_PlayDevice( )======");
567
/* Queue it up */
568
result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, audiodata->pmixbuff[audiodata->next_buffer], this->spec.size);
570
571
572
audiodata->next_buffer++;
if (audiodata->next_buffer >= NUM_BUFFERS) {
audiodata->next_buffer = 0;
575
576
577
578
579
580
/* If Enqueue fails, callback won't be called.
* Post the semphore, not to run out of buffer */
if (SL_RESULT_SUCCESS != result) {
SDL_SemPost(audiodata->playsem);
}
584
585
static int
openslES_Init(SDL_AudioDriverImpl * impl)
587
LOGI("openslES_Init() called");
589
590
591
if (!openslES_CreateEngine()) {
return 0;
}
593
LOGI("openslES_Init() - set pointers");
595
/* Set the function pointers */
596
/* impl->DetectDevices = openslES_DetectDevices; */
597
impl->OpenDevice = openslES_OpenDevice;
598
impl->CloseDevice = openslES_CloseDevice;
599
600
601
602
impl->PlayDevice = openslES_PlayDevice;
impl->GetDeviceBuf = openslES_GetDeviceBuf;
impl->Deinitialize = openslES_DestroyEngine;
impl->WaitDevice = openslES_WaitDevice;
604
605
606
/* and the capabilities */
impl->HasCaptureSupport = 0; /* TODO */
impl->OnlyHasDefaultOutputDevice = 1;
607
/* impl->OnlyHasDefaultInputDevice = 1; */
609
LOGI("openslES_Init() - succes");
611
612
/* this audio target is available. */
return 1;
613
614
615
}
AudioBootStrap openslES_bootstrap = {
616
"openslES", "opensl ES audio driver", openslES_Init, 0
619
620
void openslES_ResumeDevices()
{
621
622
623
624
625
626
if (bqPlayerPlay != NULL) {
/* set the player's state to 'playing' */
SLresult result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);
if (SL_RESULT_SUCCESS != result) {
SDL_SetError("openslES_ResumeDevices failed");
}
627
628
629
630
631
}
}
void openslES_PauseDevices()
{
632
633
634
635
636
637
if (bqPlayerPlay != NULL) {
/* set the player's state to 'paused' */
SLresult result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PAUSED);
if (SL_RESULT_SUCCESS != result) {
SDL_SetError("openslES_PauseDevices failed");
}
641
642
643
#endif /* SDL_AUDIO_DRIVER_OPENSLES */
/* vi: set ts=4 sw=4 expandtab: */