/
SDL_audio.c
1712 lines (1456 loc) · 51.2 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
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
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"
/* Allow access to a raw mixing buffer */
#include "SDL.h"
#include "SDL_audio.h"
#include "SDL_audio_c.h"
#include "SDL_sysaudio.h"
29
#include "../thread/SDL_systhread.h"
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#define _THIS SDL_AudioDevice *_this
static SDL_AudioDriver current_audio;
static SDL_AudioDevice *open_devices[16];
/* Available audio drivers */
static const AudioBootStrap *const bootstrap[] = {
#if SDL_AUDIO_DRIVER_PULSEAUDIO
&PULSEAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_ALSA
&ALSA_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_SNDIO
&SNDIO_bootstrap,
#endif
47
48
#if SDL_AUDIO_DRIVER_NETBSD
&NETBSDAUDIO_bootstrap,
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#endif
#if SDL_AUDIO_DRIVER_OSS
&DSP_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_QSA
&QSAAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_SUNAUDIO
&SUNAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_ARTS
&ARTS_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_ESD
&ESD_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_NACL
66
&NACLAUDIO_bootstrap,
67
68
69
70
#endif
#if SDL_AUDIO_DRIVER_NAS
&NAS_bootstrap,
#endif
71
72
73
#if SDL_AUDIO_DRIVER_WASAPI
&WASAPI_bootstrap,
#endif
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#if SDL_AUDIO_DRIVER_DSOUND
&DSOUND_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_WINMM
&WINMM_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_PAUDIO
&PAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_HAIKU
&HAIKUAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_COREAUDIO
&COREAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_FUSIONSOUND
&FUSIONSOUND_bootstrap,
#endif
92
93
94
#if SDL_AUDIO_DRIVER_OPENSLES
&openslES_bootstrap,
#endif
95
96
97
#if SDL_AUDIO_DRIVER_ANDROID
&ANDROIDAUDIO_bootstrap,
#endif
98
#if SDL_AUDIO_DRIVER_PSP
99
&PSPAUDIO_bootstrap,
100
101
#endif
#if SDL_AUDIO_DRIVER_EMSCRIPTEN
102
&EMSCRIPTENAUDIO_bootstrap,
103
#endif
104
105
106
#if SDL_AUDIO_DRIVER_JACK
&JACK_bootstrap,
#endif
107
108
109
#if SDL_AUDIO_DRIVER_OS2
&OS2AUDIO_bootstrap,
#endif
110
111
112
113
114
#if SDL_AUDIO_DRIVER_DISK
&DISKAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_DUMMY
&DUMMYAUDIO_bootstrap,
115
116
117
118
#endif
NULL
};
119
120
121
122
123
124
#ifdef HAVE_LIBSAMPLERATE_H
#ifdef SDL_LIBSAMPLERATE_DYNAMIC
static void *SRC_lib = NULL;
#endif
SDL_bool SRC_available = SDL_FALSE;
125
int SRC_converter = 0;
126
127
128
129
130
131
132
133
134
SRC_STATE* (*SRC_src_new)(int converter_type, int channels, int *error) = NULL;
int (*SRC_src_process)(SRC_STATE *state, SRC_DATA *data) = NULL;
int (*SRC_src_reset)(SRC_STATE *state) = NULL;
SRC_STATE* (*SRC_src_delete)(SRC_STATE *state) = NULL;
const char* (*SRC_src_strerror)(int error) = NULL;
static SDL_bool
LoadLibSampleRate(void)
{
135
const char *hint = SDL_GetHint(SDL_HINT_AUDIO_RESAMPLING_MODE);
136
137
SRC_available = SDL_FALSE;
138
SRC_converter = 0;
139
140
if (!hint || *hint == '0' || SDL_strcasecmp(hint, "default") == 0) {
141
return SDL_FALSE; /* don't load anything. */
142
} else if (*hint == '1' || SDL_strcasecmp(hint, "fast") == 0) {
143
SRC_converter = SRC_SINC_FASTEST;
144
} else if (*hint == '2' || SDL_strcasecmp(hint, "medium") == 0) {
145
SRC_converter = SRC_SINC_MEDIUM_QUALITY;
146
} else if (*hint == '3' || SDL_strcasecmp(hint, "best") == 0) {
147
148
149
SRC_converter = SRC_SINC_BEST_QUALITY;
} else {
return SDL_FALSE; /* treat it like "default", don't load anything. */
150
151
152
153
154
155
}
#ifdef SDL_LIBSAMPLERATE_DYNAMIC
SDL_assert(SRC_lib == NULL);
SRC_lib = SDL_LoadObject(SDL_LIBSAMPLERATE_DYNAMIC);
if (!SRC_lib) {
156
SDL_ClearError();
157
158
159
return SDL_FALSE;
}
160
161
162
163
164
SRC_src_new = (SRC_STATE* (*)(int converter_type, int channels, int *error))SDL_LoadFunction(SRC_lib, "src_new");
SRC_src_process = (int (*)(SRC_STATE *state, SRC_DATA *data))SDL_LoadFunction(SRC_lib, "src_process");
SRC_src_reset = (int(*)(SRC_STATE *state))SDL_LoadFunction(SRC_lib, "src_reset");
SRC_src_delete = (SRC_STATE* (*)(SRC_STATE *state))SDL_LoadFunction(SRC_lib, "src_delete");
SRC_src_strerror = (const char* (*)(int error))SDL_LoadFunction(SRC_lib, "src_strerror");
165
166
167
168
169
170
if (!SRC_src_new || !SRC_src_process || !SRC_src_reset || !SRC_src_delete || !SRC_src_strerror) {
SDL_UnloadObject(SRC_lib);
SRC_lib = NULL;
return SDL_FALSE;
}
171
172
173
174
175
176
177
#else
SRC_src_new = src_new;
SRC_src_process = src_process;
SRC_src_reset = src_reset;
SRC_src_delete = src_delete;
SRC_src_strerror = src_strerror;
#endif
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
SRC_available = SDL_TRUE;
return SDL_TRUE;
}
static void
UnloadLibSampleRate(void)
{
#ifdef SDL_LIBSAMPLERATE_DYNAMIC
if (SRC_lib != NULL) {
SDL_UnloadObject(SRC_lib);
}
SRC_lib = NULL;
#endif
SRC_available = SDL_FALSE;
SRC_src_new = NULL;
SRC_src_process = NULL;
SRC_src_reset = NULL;
SRC_src_delete = NULL;
SRC_src_strerror = NULL;
}
#endif
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
static SDL_AudioDevice *
get_audio_device(SDL_AudioDeviceID id)
{
id--;
if ((id >= SDL_arraysize(open_devices)) || (open_devices[id] == NULL)) {
SDL_SetError("Invalid audio device ID");
return NULL;
}
return open_devices[id];
}
/* stubs for audio drivers that don't need a specific entry point... */
static void
SDL_AudioDetectDevices_Default(void)
{
/* you have to write your own implementation if these assertions fail. */
SDL_assert(current_audio.impl.OnlyHasDefaultOutputDevice);
221
SDL_assert(current_audio.impl.OnlyHasDefaultCaptureDevice || !current_audio.impl.HasCaptureSupport);
222
223
224
225
226
227
228
229
230
231
232
233
SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, (void *) ((size_t) 0x1));
if (current_audio.impl.HasCaptureSupport) {
SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, (void *) ((size_t) 0x2));
}
}
static void
SDL_AudioThreadInit_Default(_THIS)
{ /* no-op. */
}
234
235
236
237
238
static void
SDL_AudioThreadDeinit_Default(_THIS)
{ /* no-op. */
}
239
240
241
242
243
static void
SDL_AudioBeginLoopIteration_Default(_THIS)
{ /* no-op. */
}
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
static void
SDL_AudioWaitDevice_Default(_THIS)
{ /* no-op. */
}
static void
SDL_AudioPlayDevice_Default(_THIS)
{ /* no-op. */
}
static Uint8 *
SDL_AudioGetDeviceBuf_Default(_THIS)
{
return NULL;
}
260
261
262
263
264
265
266
267
268
269
270
static int
SDL_AudioCaptureFromDevice_Default(_THIS, void *buffer, int buflen)
{
return -1; /* just fail immediately. */
}
static void
SDL_AudioFlushCapture_Default(_THIS)
{ /* no-op. */
}
271
272
273
274
275
static void
SDL_AudioPrepareToClose_Default(_THIS)
{ /* no-op. */
}
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
static void
SDL_AudioCloseDevice_Default(_THIS)
{ /* no-op. */
}
static void
SDL_AudioDeinitialize_Default(void)
{ /* no-op. */
}
static void
SDL_AudioFreeDeviceHandle_Default(void *handle)
{ /* no-op. */
}
static int
SDL_AudioOpenDevice_Default(_THIS, void *handle, const char *devname, int iscapture)
{
return SDL_Unsupported();
}
static SDL_INLINE SDL_bool
is_in_audio_device_thread(SDL_AudioDevice * device)
{
/* The device thread locks the same mutex, but not through the public API.
This check is in case the application, in the audio callback,
tries to lock the thread that we've already locked from the
device thread...just in case we only have non-recursive mutexes. */
if (device->thread && (SDL_ThreadID() == device->threadid)) {
return SDL_TRUE;
}
return SDL_FALSE;
}
static void
SDL_AudioLockDevice_Default(SDL_AudioDevice * device)
{
if (!is_in_audio_device_thread(device)) {
SDL_LockMutex(device->mixer_lock);
}
}
static void
SDL_AudioUnlockDevice_Default(SDL_AudioDevice * device)
{
if (!is_in_audio_device_thread(device)) {
SDL_UnlockMutex(device->mixer_lock);
}
}
328
329
330
331
static void
SDL_AudioLockOrUnlockDeviceWithNoMixerLock(SDL_AudioDevice * device)
{
}
332
333
static void
334
finish_audio_entry_points_init(void)
335
336
337
338
339
340
{
/*
* Fill in stub functions for unused driver entry points. This lets us
* blindly call them without having to check for validity first.
*/
341
342
343
344
345
346
347
348
349
if (current_audio.impl.SkipMixerLock) {
if (current_audio.impl.LockDevice == NULL) {
current_audio.impl.LockDevice = SDL_AudioLockOrUnlockDeviceWithNoMixerLock;
}
if (current_audio.impl.UnlockDevice == NULL) {
current_audio.impl.UnlockDevice = SDL_AudioLockOrUnlockDeviceWithNoMixerLock;
}
}
350
351
352
353
354
355
356
#define FILL_STUB(x) \
if (current_audio.impl.x == NULL) { \
current_audio.impl.x = SDL_Audio##x##_Default; \
}
FILL_STUB(DetectDevices);
FILL_STUB(OpenDevice);
FILL_STUB(ThreadInit);
357
FILL_STUB(ThreadDeinit);
358
FILL_STUB(BeginLoopIteration);
359
360
361
FILL_STUB(WaitDevice);
FILL_STUB(PlayDevice);
FILL_STUB(GetDeviceBuf);
362
363
FILL_STUB(CaptureFromDevice);
FILL_STUB(FlushCapture);
364
FILL_STUB(PrepareToClose);
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
FILL_STUB(CloseDevice);
FILL_STUB(LockDevice);
FILL_STUB(UnlockDevice);
FILL_STUB(FreeDeviceHandle);
FILL_STUB(Deinitialize);
#undef FILL_STUB
}
/* device hotplug support... */
static int
add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
{
int retval = -1;
380
381
382
SDL_AudioDeviceItem *item;
const SDL_AudioDeviceItem *i;
int dupenum = 0;
383
384
SDL_assert(handle != NULL); /* we reserve NULL, audio backends can't use it. */
385
386
387
388
389
390
391
392
393
394
395
396
SDL_assert(name != NULL);
item = (SDL_AudioDeviceItem *) SDL_malloc(sizeof (SDL_AudioDeviceItem));
if (!item) {
return SDL_OutOfMemory();
}
item->original_name = SDL_strdup(name);
if (!item->original_name) {
SDL_free(item);
return SDL_OutOfMemory();
}
397
398
399
item->dupenum = 0;
item->name = item->original_name;
400
401
402
item->handle = handle;
SDL_LockMutex(current_audio.detectionLock);
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
for (i = *devices; i != NULL; i = i->next) {
if (SDL_strcmp(name, i->original_name) == 0) {
dupenum = i->dupenum + 1;
break; /* stop at the highest-numbered dupe. */
}
}
if (dupenum) {
const size_t len = SDL_strlen(name) + 16;
char *replacement = (char *) SDL_malloc(len);
if (!replacement) {
SDL_UnlockMutex(current_audio.detectionLock);
SDL_free(item->original_name);
SDL_free(item);
SDL_OutOfMemory();
return -1;
}
SDL_snprintf(replacement, len, "%s (%d)", name, dupenum + 1);
item->dupenum = dupenum;
item->name = replacement;
}
427
428
item->next = *devices;
*devices = item;
429
430
retval = (*devCount)++; /* !!! FIXME: this should be an atomic increment */
431
432
433
434
435
436
437
438
SDL_UnlockMutex(current_audio.detectionLock);
return retval;
}
static SDL_INLINE int
add_capture_device(const char *name, void *handle)
{
439
SDL_assert(current_audio.impl.HasCaptureSupport);
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
return add_audio_device(name, handle, ¤t_audio.inputDevices, ¤t_audio.inputDeviceCount);
}
static SDL_INLINE int
add_output_device(const char *name, void *handle)
{
return add_audio_device(name, handle, ¤t_audio.outputDevices, ¤t_audio.outputDeviceCount);
}
static void
free_device_list(SDL_AudioDeviceItem **devices, int *devCount)
{
SDL_AudioDeviceItem *item, *next;
for (item = *devices; item != NULL; item = next) {
next = item->next;
if (item->handle != NULL) {
current_audio.impl.FreeDeviceHandle(item->handle);
}
458
459
460
461
462
/* these two pointers are the same if not a duplicate devname */
if (item->name != item->original_name) {
SDL_free(item->name);
}
SDL_free(item->original_name);
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
SDL_free(item);
}
*devices = NULL;
*devCount = 0;
}
/* The audio backends call this when a new device is plugged in. */
void
SDL_AddAudioDevice(const int iscapture, const char *name, void *handle)
{
const int device_index = iscapture ? add_capture_device(name, handle) : add_output_device(name, handle);
if (device_index != -1) {
/* Post the event, if desired */
if (SDL_GetEventState(SDL_AUDIODEVICEADDED) == SDL_ENABLE) {
SDL_Event event;
SDL_zero(event);
event.adevice.type = SDL_AUDIODEVICEADDED;
event.adevice.which = device_index;
event.adevice.iscapture = iscapture;
SDL_PushEvent(&event);
}
}
}
/* The audio backends call this when a currently-opened device is lost. */
void SDL_OpenedAudioDeviceDisconnected(SDL_AudioDevice *device)
{
SDL_assert(get_audio_device(device->id) == device);
493
if (!SDL_AtomicGet(&device->enabled)) {
494
495
496
497
498
return; /* don't report disconnects more than once. */
}
if (SDL_AtomicGet(&device->shutdown)) {
return; /* don't report disconnect if we're trying to close device. */
499
500
501
502
503
}
/* Ends the audio callback and mark the device as STOPPED, but the
app still needs to close the device to free resources. */
current_audio.impl.LockDevice(device);
504
SDL_AtomicSet(&device->enabled, 0);
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
current_audio.impl.UnlockDevice(device);
/* Post the event, if desired */
if (SDL_GetEventState(SDL_AUDIODEVICEREMOVED) == SDL_ENABLE) {
SDL_Event event;
SDL_zero(event);
event.adevice.type = SDL_AUDIODEVICEREMOVED;
event.adevice.which = device->id;
event.adevice.iscapture = device->iscapture ? 1 : 0;
SDL_PushEvent(&event);
}
}
static void
mark_device_removed(void *handle, SDL_AudioDeviceItem *devices, SDL_bool *removedFlag)
{
SDL_AudioDeviceItem *item;
SDL_assert(handle != NULL);
for (item = devices; item != NULL; item = item->next) {
if (item->handle == handle) {
item->handle = NULL;
*removedFlag = SDL_TRUE;
return;
}
}
}
/* The audio backends call this when a device is removed from the system. */
void
SDL_RemoveAudioDevice(const int iscapture, void *handle)
{
536
537
538
int device_index;
SDL_AudioDevice *device = NULL;
539
540
541
542
543
544
SDL_LockMutex(current_audio.detectionLock);
if (iscapture) {
mark_device_removed(handle, current_audio.inputDevices, ¤t_audio.captureDevicesRemoved);
} else {
mark_device_removed(handle, current_audio.outputDevices, ¤t_audio.outputDevicesRemoved);
}
545
546
547
548
549
550
551
552
553
for (device_index = 0; device_index < SDL_arraysize(open_devices); device_index++)
{
device = open_devices[device_index];
if (device != NULL && device->handle == handle)
{
SDL_OpenedAudioDeviceDisconnected(device);
break;
}
}
554
SDL_UnlockMutex(current_audio.detectionLock);
555
556
557
558
559
560
561
562
current_audio.impl.FreeDeviceHandle(handle);
}
/* buffer queueing support... */
563
564
565
566
567
static void SDLCALL
SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int len)
{
/* this function always holds the mixer lock before being called. */
SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;
568
size_t dequeued;
569
570
571
572
573
SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */
SDL_assert(!device->iscapture); /* this shouldn't ever happen, right?! */
SDL_assert(len >= 0); /* this shouldn't ever happen, right?! */
574
575
576
dequeued = SDL_ReadFromDataQueue(device->buffer_queue, stream, len);
stream += dequeued;
len -= (int) dequeued;
577
578
if (len > 0) { /* fill any remaining space in the stream with silence. */
579
SDL_assert(SDL_CountDataQueue(device->buffer_queue) == 0);
580
SDL_memset(stream, device->callbackspec.silence, len);
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
}
}
static void SDLCALL
SDL_BufferQueueFillCallback(void *userdata, Uint8 *stream, int len)
{
/* this function always holds the mixer lock before being called. */
SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;
SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */
SDL_assert(device->iscapture); /* this shouldn't ever happen, right?! */
SDL_assert(len >= 0); /* this shouldn't ever happen, right?! */
/* note that if this needs to allocate more space and run out of memory,
we have no choice but to quietly drop the data and hope it works out
later, but you probably have bigger problems in this case anyhow. */
597
SDL_WriteToDataQueue(device->buffer_queue, stream, len);
598
599
600
601
602
603
604
605
606
607
608
609
}
int
SDL_QueueAudio(SDL_AudioDeviceID devid, const void *data, Uint32 len)
{
SDL_AudioDevice *device = get_audio_device(devid);
int rc = 0;
if (!device) {
return -1; /* get_audio_device() will have set the error state */
} else if (device->iscapture) {
return SDL_SetError("This is a capture device, queueing not allowed");
610
} else if (device->callbackspec.callback != SDL_BufferQueueDrainCallback) {
611
612
613
614
615
return SDL_SetError("Audio device has a callback, queueing not allowed");
}
if (len > 0) {
current_audio.impl.LockDevice(device);
616
rc = SDL_WriteToDataQueue(device->buffer_queue, data, len);
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
current_audio.impl.UnlockDevice(device);
}
return rc;
}
Uint32
SDL_DequeueAudio(SDL_AudioDeviceID devid, void *data, Uint32 len)
{
SDL_AudioDevice *device = get_audio_device(devid);
Uint32 rc;
if ( (len == 0) || /* nothing to do? */
(!device) || /* called with bogus device id */
(!device->iscapture) || /* playback devices can't dequeue */
632
(device->callbackspec.callback != SDL_BufferQueueFillCallback) ) { /* not set for queueing */
633
634
635
636
return 0; /* just report zero bytes dequeued. */
}
current_audio.impl.LockDevice(device);
637
rc = (Uint32) SDL_ReadFromDataQueue(device->buffer_queue, data, len);
638
639
640
641
current_audio.impl.UnlockDevice(device);
return rc;
}
642
643
644
645
646
647
Uint32
SDL_GetQueuedAudioSize(SDL_AudioDeviceID devid)
{
Uint32 retval = 0;
SDL_AudioDevice *device = get_audio_device(devid);
648
649
650
651
if (!device) {
return 0;
}
652
/* Nothing to do unless we're set up for queueing. */
653
654
655
if (device->callbackspec.callback == SDL_BufferQueueDrainCallback ||
device->callbackspec.callback == SDL_BufferQueueFillCallback)
{
656
current_audio.impl.LockDevice(device);
657
retval = (Uint32) SDL_CountDataQueue(device->buffer_queue);
658
current_audio.impl.UnlockDevice(device);
659
660
661
662
663
664
665
666
667
}
return retval;
}
void
SDL_ClearQueuedAudio(SDL_AudioDeviceID devid)
{
SDL_AudioDevice *device = get_audio_device(devid);
668
669
670
671
672
673
674
if (!device) {
return; /* nothing to do. */
}
/* Blank out the device and release the mutex. Free it afterwards. */
current_audio.impl.LockDevice(device);
675
676
/* Keep up to two packets in the pool to reduce future malloc pressure. */
677
SDL_ClearDataQueue(device->buffer_queue, SDL_AUDIOBUFFERQUEUE_PACKETLEN * 2);
678
679
680
681
682
683
current_audio.impl.UnlockDevice(device);
}
/* The general mixing thread function */
684
static int SDLCALL
685
686
687
SDL_RunAudio(void *devicep)
{
SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
688
689
void *udata = device->callbackspec.userdata;
SDL_AudioCallback callback = device->callbackspec.callback;
690
int data_len = 0;
691
Uint8 *data;
692
693
SDL_assert(!device->iscapture);
694
695
696
697
698
699
700
701
#if SDL_AUDIO_DRIVER_ANDROID
{
/* Set thread priority to THREAD_PRIORITY_AUDIO */
extern void Android_JNI_AudioSetThreadPriority(int, int);
Android_JNI_AudioSetThreadPriority(device->iscapture, device->id);
}
#else
702
/* The audio mixing is always a high priority thread */
703
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_TIME_CRITICAL);
704
#endif
705
706
707
708
709
710
/* Perform any thread setup */
device->threadid = SDL_ThreadID();
current_audio.impl.ThreadInit(device);
/* Loop, filling the audio buffers */
711
while (!SDL_AtomicGet(&device->shutdown)) {
712
713
current_audio.impl.BeginLoopIteration(device);
data_len = device->callbackspec.size;
714
715
/* Fill the current buffer with sound */
716
if (!device->stream && SDL_AtomicGet(&device->enabled)) {
717
718
SDL_assert(data_len == device->spec.size);
data = current_audio.impl.GetDeviceBuf(device);
719
720
} else {
/* if the device isn't enabled, we still write to the
721
work_buffer, so the app's callback will fire with
722
723
a regular frequency, in case they depend on that
for timing or progress. They can use hotplug
724
now to know if the device failed.
725
Streaming playback uses work_buffer, too. */
726
data = NULL;
727
728
}
729
730
if (data == NULL) {
data = device->work_buffer;
731
732
}
733
734
735
/* !!! FIXME: this should be LockDevice. */
SDL_LockMutex(device->mixer_lock);
if (SDL_AtomicGet(&device->paused)) {
736
SDL_memset(data, device->callbackspec.silence, data_len);
737
738
} else {
callback(udata, data, data_len);
739
}
740
SDL_UnlockMutex(device->mixer_lock);
741
742
743
744
if (device->stream) {
/* Stream available audio to device, converting/resampling. */
/* if this fails...oh well. We'll play silence here. */
745
SDL_AudioStreamPut(device->stream, data, data_len);
746
747
while (SDL_AudioStreamAvailable(device->stream) >= ((int) device->spec.size)) {
748
int got;
749
data = SDL_AtomicGet(&device->enabled) ? current_audio.impl.GetDeviceBuf(device) : NULL;
750
got = SDL_AudioStreamGet(device->stream, data ? data : device->work_buffer, device->spec.size);
751
752
753
SDL_assert((got < 0) || (got == device->spec.size));
if (data == NULL) { /* device is having issues... */
754
const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
755
SDL_Delay(delay); /* wait for as long as this buffer would have played. Maybe device recovers later? */
756
757
} else {
if (got != device->spec.size) {
758
SDL_memset(data, device->spec.silence, device->spec.size);
759
760
761
762
}
current_audio.impl.PlayDevice(device);
current_audio.impl.WaitDevice(device);
}
763
}
764
} else if (data == device->work_buffer) {
765
/* nothing to do; pause like we queued a buffer to play. */
766
const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
767
SDL_Delay(delay);
768
769
} else { /* writing directly to the device. */
/* queue this buffer and wait for it to finish playing. */
770
771
772
773
774
current_audio.impl.PlayDevice(device);
current_audio.impl.WaitDevice(device);
}
}
775
776
current_audio.impl.PrepareToClose(device);
777
/* Wait for the audio to drain. */
778
SDL_Delay(((device->spec.samples * 1000) / device->spec.freq) * 2);
779
780
781
current_audio.impl.ThreadDeinit(device);
782
783
784
return 0;
}
785
/* !!! FIXME: this needs to deal with device spec changes. */
786
787
788
789
790
791
792
/* The general capture thread function */
static int SDLCALL
SDL_CaptureAudio(void *devicep)
{
SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
const int silence = (int) device->spec.silence;
const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
793
794
const int data_len = device->spec.size;
Uint8 *data;
795
void *udata = device->callbackspec.userdata;
796
SDL_AudioCallback callback = device->callbackspec.callback;
797
798
799
SDL_assert(device->iscapture);
800
801
802
803
804
805
806
#if SDL_AUDIO_DRIVER_ANDROID
{
/* Set thread priority to THREAD_PRIORITY_AUDIO */
extern void Android_JNI_AudioSetThreadPriority(int, int);
Android_JNI_AudioSetThreadPriority(device->iscapture, device->id);
}
#else
807
808
/* The audio mixing is always a high priority thread */
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
809
#endif
810
811
812
813
814
815
816
817
818
819
/* Perform any thread setup */
device->threadid = SDL_ThreadID();
current_audio.impl.ThreadInit(device);
/* Loop, filling the audio buffers */
while (!SDL_AtomicGet(&device->shutdown)) {
int still_need;
Uint8 *ptr;
820
821
current_audio.impl.BeginLoopIteration(device);
822
if (SDL_AtomicGet(&device->paused)) {
823
SDL_Delay(delay); /* just so we don't cook the CPU. */
824
825
826
if (device->stream) {
SDL_AudioStreamClear(device->stream);
}
827
828
829
830
831
current_audio.impl.FlushCapture(device); /* dump anything pending. */
continue;
}
/* Fill the current buffer with sound */
832
still_need = data_len;
833
834
/* Use the work_buffer to hold data read from the device. */
835
836
data = device->work_buffer;
SDL_assert(data != NULL);
837
838
ptr = data;
839
840
841
842
843
/* We still read from the device when "paused" to keep the state sane,
and block when there isn't data so this thread isn't eating CPU.
But we don't process it further or call the app's callback. */
844
845
846
847
848
849
850
851
852
853
854
855
856
if (!SDL_AtomicGet(&device->enabled)) {
SDL_Delay(delay); /* try to keep callback firing at normal pace. */
} else {
while (still_need > 0) {
const int rc = current_audio.impl.CaptureFromDevice(device, ptr, still_need);
SDL_assert(rc <= still_need); /* device should not overflow buffer. :) */
if (rc > 0) {
still_need -= rc;
ptr += rc;
} else { /* uhoh, device failed for some reason! */
SDL_OpenedAudioDeviceDisconnected(device);
break;
}
857
858
859
860
861
862
863
864
}
}
if (still_need > 0) {
/* Keep any data we already read, silence the rest. */
SDL_memset(ptr, silence, still_need);
}
865
866
if (device->stream) {
/* if this fails...oh well. */
867
SDL_AudioStreamPut(device->stream, data, data_len);
868
869
while (SDL_AudioStreamAvailable(device->stream) >= ((int) device->callbackspec.size)) {
870
const int got = SDL_AudioStreamGet(device->stream, device->work_buffer, device->callbackspec.size);
871
872
SDL_assert((got < 0) || (got == device->callbackspec.size));
if (got != device->callbackspec.size) {
873
SDL_memset(device->work_buffer, device->spec.silence, device->callbackspec.size);
874
875
876
877
878
}
/* !!! FIXME: this should be LockDevice. */
SDL_LockMutex(device->mixer_lock);
if (!SDL_AtomicGet(&device->paused)) {
879
callback(udata, device->work_buffer, device->callbackspec.size);
880
881
882
883
884
885
886
}
SDL_UnlockMutex(device->mixer_lock);
}
} else { /* feeding user callback directly without streaming. */
/* !!! FIXME: this should be LockDevice. */
SDL_LockMutex(device->mixer_lock);
if (!SDL_AtomicGet(&device->paused)) {
887
callback(udata, data, device->callbackspec.size);
888
889
}
SDL_UnlockMutex(device->mixer_lock);
890
891
892
893
894
}
}
current_audio.impl.FlushCapture(device);
895
896
current_audio.impl.ThreadDeinit(device);
897
898
899
return 0;
}
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
static SDL_AudioFormat
SDL_ParseAudioFormat(const char *string)
{
#define CHECK_FMT_STRING(x) if (SDL_strcmp(string, #x) == 0) return AUDIO_##x
CHECK_FMT_STRING(U8);
CHECK_FMT_STRING(S8);
CHECK_FMT_STRING(U16LSB);
CHECK_FMT_STRING(S16LSB);
CHECK_FMT_STRING(U16MSB);
CHECK_FMT_STRING(S16MSB);
CHECK_FMT_STRING(U16SYS);
CHECK_FMT_STRING(S16SYS);
CHECK_FMT_STRING(U16);
CHECK_FMT_STRING(S16);
CHECK_FMT_STRING(S32LSB);
CHECK_FMT_STRING(S32MSB);
CHECK_FMT_STRING(S32SYS);
CHECK_FMT_STRING(S32);
CHECK_FMT_STRING(F32LSB);
CHECK_FMT_STRING(F32MSB);
CHECK_FMT_STRING(F32SYS);
CHECK_FMT_STRING(F32);
#undef CHECK_FMT_STRING
return 0;
}
int
SDL_GetNumAudioDrivers(void)
{
return SDL_arraysize(bootstrap) - 1;
}
const char *
SDL_GetAudioDriver(int index)
{
if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
return bootstrap[index]->name;
}
return NULL;
}
int
SDL_AudioInit(const char *driver_name)
{
int i = 0;
int initialized = 0;
int tried_to_init = 0;
if (SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_AudioQuit(); /* shutdown driver if already running. */
}
SDL_zero(current_audio);
954
SDL_zeroa(open_devices);
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
/* Select the proper audio driver */
if (driver_name == NULL) {
driver_name = SDL_getenv("SDL_AUDIODRIVER");
}
for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
/* make sure we should even try this driver before doing so... */
const AudioBootStrap *backend = bootstrap[i];
if ((driver_name && (SDL_strncasecmp(backend->name, driver_name, SDL_strlen(driver_name)) != 0)) ||
(!driver_name && backend->demand_only)) {
continue;
}
tried_to_init = 1;
SDL_zero(current_audio);
current_audio.name = backend->name;
current_audio.desc = backend->desc;
initialized = backend->init(¤t_audio.impl);
}
if (!initialized) {
/* specific drivers will set the error message if they fail... */
if (!tried_to_init) {
if (driver_name) {
SDL_SetError("Audio target '%s' not available", driver_name);
} else {
SDL_SetError("No available audio device");
}
}
SDL_zero(current_audio);
return -1; /* No driver was available, so fail. */
}
current_audio.detectionLock = SDL_CreateMutex();
992
finish_audio_entry_points_init();
993
994
995
996
/* Make sure we have a list of devices available at startup. */
current_audio.impl.DetectDevices();
997
998
999
1000
#ifdef HAVE_LIBSAMPLERATE_H
LoadLibSampleRate();
#endif