Commit 59c8c7b684467a8180bff4a1ec21ba51a5986145

Sylvain Becker 2019-01-14T10:58:57

Android/openslES: move a few static variables to SDL_PrivateAudioData structure

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
diff --git a/src/audio/openslES/SDL_openslES.c b/src/audio/openslES/SDL_openslES.c
index d3b0e39..02efe1a 100644
--- a/src/audio/openslES/SDL_openslES.c
+++ b/src/audio/openslES/SDL_openslES.c
@@ -26,7 +26,7 @@
 #include "../SDL_audio_c.h"
 #include "SDL_openslES.h"
 
-// for native audio
+/* for native audio */
 #include <SLES/OpenSLES.h>
 #include <SLES/OpenSLES_Android.h>
 
@@ -34,58 +34,47 @@
 
 #define LOG_TAG "SDL_openslES"
 
-//#define LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
-//#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
-//#define LOGI(...) do {} while (0)
-//#define LOGE(...) do {} while (0)
+/*#define LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) */
+/*#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) */
+/*#define LOGI(...) do {} while (0) */
+/*#define LOGE(...) do {} while (0) */
 #define LOGI(...)
 #define LOGE(...)
 
-// engine interfaces
+/* engine interfaces */
 static SLObjectItf engineObject = NULL;
 static SLEngineItf engineEngine;
 
-// output mix interfaces
+/* output mix interfaces */
 static SLObjectItf outputMixObject = NULL;
-//static SLEnvironmentalReverbItf outputMixEnvironmentalReverb = NULL;
+// static SLEnvironmentalReverbItf outputMixEnvironmentalReverb = NULL;
 
-// aux effect on the output mix, used by the buffer queue player
-// static const SLEnvironmentalReverbSettings reverbSettings = SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR;
+/* aux effect on the output mix, used by the buffer queue player */
+/* static const SLEnvironmentalReverbSettings reverbSettings = SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR; */
 
-// buffer queue player interfaces
+/* buffer queue player interfaces */
 static SLObjectItf                   bqPlayerObject = NULL;
 static SLPlayItf                     bqPlayerPlay;
 static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue;
-//static SLEffectSendItf          bqPlayerEffectSend;
+/*static SLEffectSendItf          bqPlayerEffectSend; */
 static SLMuteSoloItf                 bqPlayerMuteSolo;
 static SLVolumeItf                   bqPlayerVolume;
 
 #if 0
-// recorder interfaces TODO
+/* recorder interfaces TODO */
 static SLObjectItf                   recorderObject = NULL;
 static SLRecordItf                   recorderRecord;
 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 */
 #if 0
 static short      *nextBuffer;
 static unsigned    nextSize;
 static int         nextCount;
 #endif
 
-#define NUM_BUFFERS 2           /* -- Don't lower this! */
-
-static Uint8   *mixbuff               = NULL;
-static int      next_buffer           = 0;
-static Uint8   *pmixbuff[NUM_BUFFERS];
-
-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
 static const char *sldevaudiorecorderstr = "SLES Audio Recorder";
@@ -104,16 +93,16 @@ static void openslES_DetectDevices( int iscapture )
 }
 #endif
 
-static void openslES_DestroyEngine(void);
+static void openslES_DestroyEngine();
 
 static int
-openslES_CreateEngine(void)
+openslES_CreateEngine()
 {
     SLresult result;
 
     LOGI("openSLES_CreateEngine()");
 
-    // create engine
+    /* create engine */
     result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("slCreateEngine failed");
@@ -122,7 +111,7 @@ openslES_CreateEngine(void)
 
     LOGI("slCreateEngine OK");
 
-    // realize the engine
+    /* realize the engine */
     result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("RealizeEngine failed");
@@ -131,7 +120,7 @@ openslES_CreateEngine(void)
 
     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);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("EngineGetInterface failed");
@@ -140,9 +129,9 @@ openslES_CreateEngine(void)
 
     LOGI("EngineGetInterface OK");
 
-    // 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 };
+    /* 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 }; */
 
     const SLInterfaceID ids[1] = { SL_IID_VOLUME };
     const SLboolean req[1] = { SL_BOOLEAN_FALSE };
@@ -154,7 +143,7 @@ openslES_CreateEngine(void)
     }
     LOGI("CreateOutputMix OK");
 
-    // realize the output mix
+    /* realize the output mix */
     result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("RealizeOutputMix failed");
@@ -167,23 +156,24 @@ error:
     return 0;
 }
 
-static void openslES_DestroyPCMPlayer(void);
-static void openslES_DestroyPCMRecorder(void);
+static void openslES_DestroyPCMPlayer(_THIS);
+static void openslES_DestroyPCMRecorder(_THIS);
 
-static void openslES_DestroyEngine(void)
+static void openslES_DestroyEngine()
 {
     LOGI("openslES_DestroyEngine()");
-    openslES_DestroyPCMPlayer();
-    openslES_DestroyPCMRecorder();
+   
+//        openslES_DestroyPCMPlayer(this);
+//    openslES_DestroyPCMRecorder(this);
 
-    // destroy output mix object, and invalidate all associated interfaces
+    /* destroy output mix object, and invalidate all associated interfaces */
     if (outputMixObject != NULL) {
         (*outputMixObject)->Destroy(outputMixObject);
         outputMixObject = NULL;
-        // outputMixEnvironmentalReverb = NULL;
+        /* outputMixEnvironmentalReverb = NULL; */
     }
 
-    // destroy engine object, and invalidate all associated interfaces
+    /* destroy engine object, and invalidate all associated interfaces */
     if (engineObject != NULL) {
         (*engineObject)->Destroy(engineObject);
         engineObject = NULL;
@@ -193,56 +183,63 @@ static void openslES_DestroyEngine(void)
     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)
 {
+    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) context;
     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 (--nextCount > 0 && NULL != nextBuffer && 0 != nextSize)
     {
         SLresult result;
 
-        // enqueue another buffer
+        /* enqueue another buffer */
         result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, nextBuffer, nextSize);
-        // the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT,
-        // which for this code example would indicate a programming error
+        /* the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT, */
+        /* which for this code example would indicate a programming error */
         assert(SL_RESULT_SUCCESS == result);
         (void) result;
     }
 #endif
     LOGI("SLES: Playback Callmeback %u", t++);
-    SDL_SemPost(playsem);
+    SDL_SemPost(audiodata->playsem);
     return;
 }
 
 static int
 openslES_CreatePCMRecorder(_THIS)
 {
+/*    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden; */
+
     LOGE("openslES_CreatePCMRecorder not implimented yet!");
     return SDL_SetError("openslES_CreatePCMRecorder not implimented yet!");
 }
 
 static void
-openslES_DestroyPCMRecorder(void)
+openslES_DestroyPCMRecorder(_THIS)
 {
+/*    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden; */
+
     return;
 }
 
 static int
 openslES_CreatePCMPlayer(_THIS)
 {
+    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
+
     SLDataFormat_PCM format_pcm;
 
     SLresult result;
     int i;
 
-    /*
+#if 0
       SDL_AudioFormat test_format;
       test_format = SDL_FirstAudioFormat( this->spec.format );
 
@@ -255,28 +252,28 @@ openslES_CreatePCMPlayer(_THIS)
       }
 
       if ( test_format == 0 ) {
-          // Didn't find a compatible format :
+          /* Didn't find a compatible format : */
           LOGI( "No compatible audio format!" );
           return SDL_SetError("No compatible audio format!");
       }
 
       this->spec.format = test_format;
-    */
+#endif
 
-    // Update the fragment size as size in bytes
+    /* 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
+    /* configure audio source */
     SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2 };
-    // SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, OPENSLES_BUFFERS };
+    /* 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.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);
 
@@ -323,11 +320,11 @@ openslES_CreatePCMPlayer(_THIS)
 
     SLDataSource audioSrc = { &loc_bufq, &format_pcm };
 
-    // configure audio sink
+    /* 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] = {
         SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
         SL_IID_VOLUME
@@ -344,36 +341,37 @@ openslES_CreatePCMPlayer(_THIS)
         goto failed;
     }
 
-    // realize the player
+    /* realize the player */
     result = (*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("RealizeAudioPlayer failed");
         goto failed;
     }
 
-    // get the play interface
+    /* get the play interface */
     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);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("SL_IID_BUFFERQUEUE interface get failed");
         goto failed;
     }
 
-    // register callback on the buffer queue
-    result = (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, NULL);
+    /* register callback on the buffer queue */
+    /* context is '(SDL_PrivateAudioData *)this->hidden' */
+    result = (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, this->hidden);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("RegisterCallback failed");
         goto failed;
     }
 
 #if 0
-    // get the effect send interface
+    /* get the effect send interface */
     result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_EFFECTSEND, &bqPlayerEffectSend);
     if (SL_RESULT_SUCCESS != result)
     {
@@ -383,21 +381,21 @@ openslES_CreatePCMPlayer(_THIS)
     }
 #endif
 
-#if 0   // mute/solo is not supported for sources that are known to be mono, as this is
-    // get the mute/solo interface
+#if 0   /* mute/solo is not supported for sources that are known to be mono, as this is */
+    /* get the mute/solo interface */
     result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_MUTESOLO, &bqPlayerMuteSolo);
     assert(SL_RESULT_SUCCESS == result);
     (void) result;
 #endif
 
-    // get the volume interface
+    /* get the volume interface */
     result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_VOLUME, &bqPlayerVolume);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("SL_IID_VOLUME interface get failed");
-        // goto failed;
+        /* goto failed; */
     }
 
-    // set the player's state to playing
+    /* set the player's state to playing */
     result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);
     if (SL_RESULT_SUCCESS != result) {
         LOGE("Play set state failed");
@@ -405,36 +403,38 @@ openslES_CreatePCMPlayer(_THIS)
     }
 
     /* Create the audio buffer semaphore */
-    playsem = SDL_CreateSemaphore(NUM_BUFFERS - 1);
-    if (!playsem) {
+    audiodata->playsem = SDL_CreateSemaphore(NUM_BUFFERS - 1);
+    if (!audiodata->playsem) {
         LOGE("cannot create Semaphore!");
         goto failed;
     }
 
     /* Create the sound buffers */
-    mixbuff = (Uint8 *) SDL_malloc(NUM_BUFFERS * this->spec.size);
-    if (mixbuff == NULL) {
+    audiodata->mixbuff = (Uint8 *) SDL_malloc(NUM_BUFFERS * this->spec.size);
+    if (audiodata->mixbuff == NULL) {
         LOGE("mixbuffer allocate - out of memory");
         goto failed;
     }
 
     for (i = 0; i < NUM_BUFFERS; i++) {
-        pmixbuff[i] = mixbuff + i * this->spec.size;
+        audiodata->pmixbuff[i] = audiodata->mixbuff + i * this->spec.size;
     }
 
     return 0;
 
 failed:
 
-    openslES_DestroyPCMPlayer();
+    openslES_DestroyPCMPlayer(this);
 
     return SDL_SetError("Open device failed!");
 }
 
 static void
-openslES_DestroyPCMPlayer(void)
+openslES_DestroyPCMPlayer(_THIS)
 {
-    // destroy buffer queue audio player object, and invalidate all associated interfaces
+    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
+
+    /* destroy buffer queue audio player object, and invalidate all associated interfaces */
     if (bqPlayerObject != NULL) {
 
         (*bqPlayerObject)->Destroy(bqPlayerObject);
@@ -442,18 +442,18 @@ openslES_DestroyPCMPlayer(void)
         bqPlayerObject = NULL;
         bqPlayerPlay = NULL;
         bqPlayerBufferQueue = NULL;
-        // bqPlayerEffectSend = NULL;
+        /* bqPlayerEffectSend = NULL; */
         bqPlayerMuteSolo = NULL;
         bqPlayerVolume = NULL;
     }
 
-    if (playsem) {
-        SDL_DestroySemaphore(playsem);
-        playsem = NULL;
+    if (audiodata->playsem) {
+        SDL_DestroySemaphore(audiodata->playsem);
+        audiodata->playsem = NULL;
     }
 
-    if (mixbuff) {
-        SDL_free(mixbuff);
+    if (audiodata->mixbuff) {
+        SDL_free(audiodata->mixbuff);
     }
 
     return;
@@ -479,15 +479,16 @@ openslES_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
 static void
 openslES_CloseDevice(_THIS)
 {
+    /* struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden; */
+
     if (this->iscapture) {
         LOGI("openslES_CloseDevice( ) for capture");
-        openslES_DestroyPCMRecorder();
+        openslES_DestroyPCMRecorder(this);
     } else {
         LOGI("openslES_CloseDevice( ) for playing");
-        SDL_Log("openslES_CloseDevice( ) for playing");
-        openslES_DestroyPCMPlayer();
+        openslES_DestroyPCMPlayer(this);
     }
-
+    
     SDL_free(this->hidden);
 
     return;
@@ -496,51 +497,56 @@ openslES_CloseDevice(_THIS)
 static void
 openslES_WaitDevice(_THIS)
 {
+    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
+
     LOGI("openslES_WaitDevice( )");
 
     /* Wait for an audio chunk to finish */
-    // WaitForSingleObject(this->hidden->audio_sem, INFINITE);
-    SDL_SemWait(playsem);
+    /* WaitForSingleObject(this->hidden->audio_sem, INFINITE); */
+    SDL_SemWait(audiodata->playsem);
 
     return;
 }
 
-///           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..
+/*/           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.. */
 
 static Uint8 *
 openslES_GetDeviceBuf(_THIS)
 {
+    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
+
     LOGI("openslES_GetDeviceBuf( )");
-    return pmixbuff[next_buffer];
+    return audiodata->pmixbuff[audiodata->next_buffer];
 }
 
 static void
 openslES_PlayDevice(_THIS)
 {
+    struct SDL_PrivateAudioData *audiodata = (struct SDL_PrivateAudioData *) this->hidden;
     SLresult result;
 
     LOGI("======openslES_PlayDevice( )======");
     /* Queue it up */
 
-    result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, pmixbuff[next_buffer], this->spec.size);
+    result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, audiodata->pmixbuff[audiodata->next_buffer], this->spec.size);
     if (SL_RESULT_SUCCESS != result) {
-        // just puk here
-        // next !
+        /* just puk here */
+        /* next ! */
     }
 
-    next_buffer++;
-    if (next_buffer >= NUM_BUFFERS) {
-        next_buffer = 0;
+    audiodata->next_buffer++;
+    if (audiodata->next_buffer >= NUM_BUFFERS) {
+        audiodata->next_buffer = 0;
     }
 
     return;
@@ -558,7 +564,7 @@ openslES_Init(SDL_AudioDriverImpl * impl)
     LOGI("openslES_Init() - set pointers");
 
     /* Set the function pointers */
-    // impl->DetectDevices = openslES_DetectDevices;
+    /* impl->DetectDevices = openslES_DetectDevices; */
     impl->OpenDevice    = openslES_OpenDevice;
     impl->CloseDevice   = openslES_CloseDevice;
     impl->PlayDevice    = openslES_PlayDevice;
@@ -569,7 +575,7 @@ openslES_Init(SDL_AudioDriverImpl * impl)
     /* and the capabilities */
     impl->HasCaptureSupport             = 0;        /* TODO */
     impl->OnlyHasDefaultOutputDevice    = 1;
-    // impl->OnlyHasDefaultInputDevice  = 1;
+    /* impl->OnlyHasDefaultInputDevice  = 1; */
 
     LOGI("openslES_Init() - succes");
 
diff --git a/src/audio/openslES/SDL_openslES.h b/src/audio/openslES/SDL_openslES.h
index c8f2762..8ed2804 100644
--- a/src/audio/openslES/SDL_openslES.h
+++ b/src/audio/openslES/SDL_openslES.h
@@ -28,13 +28,18 @@
 /* Hidden "this" pointer for the audio functions */
 #define _THIS   SDL_AudioDevice *this
 
+#define NUM_BUFFERS 2           /* -- Don't lower this! */
+
 struct SDL_PrivateAudioData
 {
     /* The file descriptor for the audio device */
-    Uint8 *mixbuf;
-    Uint32 mixlen;
-    Uint32 write_delay;
-    Uint32 initial_calls;
+    Uint8   *mixbuff;
+    int      next_buffer;
+    Uint8   *pmixbuff[NUM_BUFFERS];
+    SDL_sem *playsem;
+#if 0
+    SDL_sem *recsem;
+#endif
 };
 
 #endif /* _SDL_openslesaudio_h */