This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_audio.c
1001 lines (875 loc) · 28.3 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
26
27
28
29
30
/* Allow access to a raw mixing buffer */
#include "SDL.h"
#include "SDL_audio_c.h"
#include "SDL_audiomem.h"
#include "SDL_sysaudio.h"
31
32
#define _THIS SDL_AudioDevice *this
33
34
35
36
37
static SDL_AudioDriver current_audio;
/* !!! FIXME: don't use a static array, but it's Good Enough For Now... */
static SDL_AudioDevice *open_devices[16];
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
/* !!! FIXME: These are wordy and unlocalized... */
#define DEFAULT_OUTPUT_DEVNAME "System audio output device"
#define DEFAULT_INPUT_DEVNAME "System audio capture device"
/*
* Not all of these will be compiled and linked in, but it's convenient
* to have a complete list here and saves yet-another block of #ifdefs...
* Please see bootstrap[], below, for the actual #ifdef mess.
*/
extern AudioBootStrap BSD_AUDIO_bootstrap;
extern AudioBootStrap DSP_bootstrap;
extern AudioBootStrap DMA_bootstrap;
extern AudioBootStrap ALSA_bootstrap;
extern AudioBootStrap QNXNTOAUDIO_bootstrap;
extern AudioBootStrap SUNAUDIO_bootstrap;
extern AudioBootStrap DMEDIA_bootstrap;
extern AudioBootStrap ARTS_bootstrap;
extern AudioBootStrap ESD_bootstrap;
extern AudioBootStrap NAS_bootstrap;
extern AudioBootStrap DSOUND_bootstrap;
extern AudioBootStrap WAVEOUT_bootstrap;
extern AudioBootStrap Paud_bootstrap;
extern AudioBootStrap BAUDIO_bootstrap;
extern AudioBootStrap COREAUDIO_bootstrap;
extern AudioBootStrap SNDMGR_bootstrap;
extern AudioBootStrap MINTAUDIO_GSXB_bootstrap;
extern AudioBootStrap MINTAUDIO_MCSN_bootstrap;
extern AudioBootStrap MINTAUDIO_STFA_bootstrap;
extern AudioBootStrap MINTAUDIO_XBIOS_bootstrap;
extern AudioBootStrap MINTAUDIO_DMA8_bootstrap;
extern AudioBootStrap DISKAUD_bootstrap;
extern AudioBootStrap DUMMYAUD_bootstrap;
extern AudioBootStrap DCAUD_bootstrap;
extern AudioBootStrap MMEAUDIO_bootstrap;
extern AudioBootStrap DART_bootstrap;
75
76
77
/* Available audio drivers */
static AudioBootStrap *bootstrap[] = {
78
#if SDL_AUDIO_DRIVER_BSD
79
&BSD_AUDIO_bootstrap,
80
#endif
81
#if SDL_AUDIO_DRIVER_OSS
82
83
&DSP_bootstrap,
&DMA_bootstrap,
84
#endif
85
#if SDL_AUDIO_DRIVER_ALSA
86
&ALSA_bootstrap,
87
#endif
88
#if SDL_AUDIO_DRIVER_QNXNTO
89
&QNXNTOAUDIO_bootstrap,
90
#endif
91
#if SDL_AUDIO_DRIVER_SUNAUDIO
92
&SUNAUDIO_bootstrap,
93
#endif
94
#if SDL_AUDIO_DRIVER_DMEDIA
95
&DMEDIA_bootstrap,
96
#endif
97
#if SDL_AUDIO_DRIVER_ARTS
98
&ARTS_bootstrap,
99
#endif
100
#if SDL_AUDIO_DRIVER_ESD
101
&ESD_bootstrap,
102
#endif
103
#if SDL_AUDIO_DRIVER_NAS
104
&NAS_bootstrap,
105
#endif
106
#if SDL_AUDIO_DRIVER_DSOUND
107
&DSOUND_bootstrap,
108
#endif
109
#if SDL_AUDIO_DRIVER_WAVEOUT
110
&WAVEOUT_bootstrap,
111
#endif
112
#if SDL_AUDIO_DRIVER_PAUD
113
&Paud_bootstrap,
114
115
#endif
#if SDL_AUDIO_DRIVER_BAUDIO
116
&BAUDIO_bootstrap,
117
#endif
118
#if SDL_AUDIO_DRIVER_COREAUDIO
119
&COREAUDIO_bootstrap,
120
#endif
121
#if SDL_AUDIO_DRIVER_SNDMGR
122
&SNDMGR_bootstrap,
123
#endif
124
#if SDL_AUDIO_DRIVER_MINT
125
126
127
128
129
&MINTAUDIO_GSXB_bootstrap,
&MINTAUDIO_MCSN_bootstrap,
&MINTAUDIO_STFA_bootstrap,
&MINTAUDIO_XBIOS_bootstrap,
&MINTAUDIO_DMA8_bootstrap,
130
#endif
131
#if SDL_AUDIO_DRIVER_DISK
132
&DISKAUD_bootstrap,
133
#endif
134
#if SDL_AUDIO_DRIVER_DUMMY
135
&DUMMYAUD_bootstrap,
136
#endif
137
#if SDL_AUDIO_DRIVER_DC
138
&DCAUD_bootstrap,
139
#endif
140
#if SDL_AUDIO_DRIVER_MMEAUDIO
141
&MMEAUDIO_bootstrap,
142
143
#endif
#if SDL_AUDIO_DRIVER_DART
144
&DART_bootstrap,
145
#endif
146
NULL
147
148
};
149
150
151
152
153
154
155
156
157
158
159
160
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];
}
161
/* stubs for audio drivers that don't need a specific entry point... */
162
163
164
165
166
167
168
169
static int SDL_AudioDetectDevices_Default(int iscapture) { return -1; }
static void SDL_AudioThreadInit_Default(_THIS) { /* no-op. */ }
static void SDL_AudioWaitDevice_Default(_THIS) { /* no-op. */ }
static void SDL_AudioPlayDevice_Default(_THIS) { /* no-op. */ }
static Uint8 *SDL_AudioGetDeviceBuf_Default(_THIS) { return NULL; }
static void SDL_AudioWaitDone_Default(_THIS) { /* no-op. */ }
static void SDL_AudioCloseDevice_Default(_THIS) { /* no-op. */ }
static void SDL_AudioDeinitialize_Default(void) { /* no-op. */ }
170
171
172
static int
SDL_AudioOpenDevice_Default(_THIS, const char *devname, int iscapture)
173
{
174
return 0;
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
static const char *SDL_AudioGetDeviceName_Default(int index, int iscapture)
{
SDL_SetError("No such device");
return NULL;
}
static void
SDL_AudioLockDevice_Default(SDL_AudioDevice * device)
{
if (device->thread && (SDL_ThreadID() == device->threadid)) {
return;
}
SDL_mutexP(device->mixer_lock);
}
static void
SDL_AudioUnlockDevice_Default(SDL_AudioDevice * device)
{
if (device->thread && (SDL_ThreadID() == device->threadid)) {
return;
}
SDL_mutexV(device->mixer_lock);
}
static void finalize_audio_entry_points(void)
{
/*
* Fill in stub functions for unused driver entry points. This lets us
* blindly call them without having to check for validity first.
*/
#define FILL_STUB(x) \
if (current_audio.impl.x == NULL) { \
current_audio.impl.x = SDL_Audio##x##_Default; \
}
FILL_STUB(DetectDevices);
FILL_STUB(GetDeviceName);
FILL_STUB(OpenDevice);
FILL_STUB(ThreadInit);
FILL_STUB(WaitDevice);
FILL_STUB(PlayDevice);
FILL_STUB(GetDeviceBuf);
FILL_STUB(WaitDone);
FILL_STUB(CloseDevice);
FILL_STUB(LockDevice);
FILL_STUB(UnlockDevice);
FILL_STUB(Deinitialize);
#undef FILL_STUB
}
227
228
229
/* The general mixing thread function */
230
int SDLCALL
231
SDL_RunAudio(void *devicep)
232
{
233
234
SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
const int legacy_device = (device == open_devices[0]);
235
236
237
238
239
Uint8 *stream;
int stream_len;
void *udata;
void (SDLCALL * fill) (void *userdata, Uint8 * stream, int len);
int silence;
240
241
/* Perform any thread setup */
242
device->threadid = SDL_ThreadID();
243
current_audio.impl.ThreadInit(device);
244
245
/* Set up the mixing function */
246
247
fill = device->spec.callback;
udata = device->spec.userdata;
248
249
250
if (device->convert.needed) {
if (device->convert.src_format == AUDIO_U8) {
251
252
253
254
silence = 0x80;
} else {
silence = 0;
}
255
stream_len = device->convert.len;
256
} else {
257
258
silence = device->spec.silence;
stream_len = device->spec.size;
259
}
260
261
/* Loop, filling the audio buffers */
262
while (device->enabled) {
263
264
/* Fill the current buffer with sound */
265
266
267
if (device->convert.needed) {
if (device->convert.buf) {
stream = device->convert.buf;
268
269
270
271
} else {
continue;
}
} else {
272
stream = current_audio.impl.GetDeviceBuf(device);
273
if (stream == NULL) {
274
stream = device->fake_stream;
275
}
276
}
277
278
279
280
281
282
283
284
/* New code should fill buffer or set it to silence themselves. */
if (legacy_device) {
SDL_memset(stream, silence, stream_len);
}
if (!device->paused) {
SDL_mutexP(device->mixer_lock);
285
(*fill) (udata, stream, stream_len);
286
SDL_mutexV(device->mixer_lock);
287
}
288
289
/* Convert the audio if necessary */
290
291
if (device->convert.needed) {
SDL_ConvertAudio(&device->convert);
292
stream = current_audio.impl.GetDeviceBuf(device);
293
if (stream == NULL) {
294
stream = device->fake_stream;
295
}
296
SDL_memcpy(stream, device->convert.buf, device->convert.len_cvt);
297
298
299
}
/* Ready current buffer for play and change current buffer */
300
if (stream != device->fake_stream) {
301
current_audio.impl.PlayDevice(device);
302
303
304
}
/* Wait for an audio buffer to become available */
305
306
if (stream == device->fake_stream) {
SDL_Delay((device->spec.samples * 1000) / device->spec.freq);
307
} else {
308
current_audio.impl.WaitDevice(device);
309
310
311
312
}
}
/* Wait for the audio to drain.. */
313
314
315
current_audio.impl.WaitDone(device);
return (0);
316
317
318
}
319
static SDL_AudioFormat
320
SDL_ParseAudioFormat(const char *string)
321
{
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
#define CHECK_FMT_STRING(x) if (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;
343
344
}
345
346
int
SDL_GetNumAudioDrivers(void)
347
{
348
349
return (SDL_arraysize(bootstrap) - 1);
}
350
351
352
353
354
355
356
357
358
359
360
361
362
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)
{
363
364
int i = 0;
int initialized = 0;
365
366
367
if (SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_AudioQuit(); /* shutdown driver if already running. */
368
369
}
370
371
372
373
374
SDL_memset(¤t_audio, '\0', sizeof (current_audio));
SDL_memset(open_devices, '\0', sizeof (open_devices));
/* !!! FIXME: build a priority list of available drivers... */
375
/* Select the proper audio driver */
376
377
378
if (driver_name == NULL) {
driver_name = SDL_getenv("SDL_AUDIODRIVER");
}
379
380
/* !!! FIXME: move this esound shite into the esound driver... */
381
#if SDL_AUDIO_DRIVER_ESD
382
383
384
385
386
387
if ((driver_name == NULL) && (SDL_getenv("ESPEAKER") != NULL)) {
/* Ahem, we know that if ESPEAKER is set, user probably wants
to use ESD, but don't start it if it's not already running.
This probably isn't the place to do this, but... Shh! :)
*/
for (i = 0; bootstrap[i]; ++i) {
388
if (SDL_strcasecmp(bootstrap[i]->name, "esd") == 0) {
389
#ifdef HAVE_PUTENV
390
391
392
393
394
395
396
397
398
const char *esd_no_spawn;
/* Don't start ESD if it's not running */
esd_no_spawn = getenv("ESD_NO_SPAWN");
if (esd_no_spawn == NULL) {
putenv("ESD_NO_SPAWN=1");
}
#endif
if (bootstrap[i]->available()) {
399
400
401
402
SDL_memset(¤t_audio, 0, sizeof (current_audio));
current_audio.name = bootstrap[i]->name;
current_audio.desc = bootstrap[i]->desc;
initialized = bootstrap[i]->init(¤t_audio.impl);
403
404
break;
}
405
#ifdef HAVE_UNSETENV
406
407
408
if (esd_no_spawn == NULL) {
unsetenv("ESD_NO_SPAWN");
}
409
#endif
410
411
412
}
}
}
413
#endif /* SDL_AUDIO_DRIVER_ESD */
414
415
if (!initialized) {
416
417
if (driver_name != NULL) {
for (i = 0; bootstrap[i]; ++i) {
418
if (SDL_strcasecmp(bootstrap[i]->name, driver_name) == 0) {
419
if (bootstrap[i]->available()) {
420
421
422
423
SDL_memset(¤t_audio, 0, sizeof (current_audio));
current_audio.name = bootstrap[i]->name;
current_audio.desc = bootstrap[i]->desc;
initialized = bootstrap[i]->init(¤t_audio.impl);
424
425
426
427
428
}
break;
}
}
} else {
429
for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
430
if ((!bootstrap[i]->demand) && (bootstrap[i]->available())) {
431
432
433
434
SDL_memset(¤t_audio, 0, sizeof (current_audio));
current_audio.name = bootstrap[i]->name;
current_audio.desc = bootstrap[i]->desc;
initialized = bootstrap[i]->init(¤t_audio.impl);
435
436
437
}
}
}
438
if (!initialized) {
439
440
441
442
443
if (driver_name) {
SDL_SetError("%s not available", driver_name);
} else {
SDL_SetError("No available audio device");
}
444
445
SDL_memset(¤t_audio, 0, sizeof (current_audio));
return (-1); /* No driver was available, so fail. */
446
447
}
}
448
449
finalize_audio_entry_points();
450
451
return (0);
452
453
}
454
455
456
457
458
/*
* Get the current audio driver name
*/
const char *
SDL_GetCurrentAudioDriver()
459
{
460
return current_audio.name;
461
462
}
463
464
465
466
int
SDL_GetNumAudioDevices(int iscapture)
{
467
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
468
469
return -1;
}
470
471
472
473
474
475
476
477
478
479
480
481
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
return 0;
}
if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
return 1;
}
if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
return 1;
}
482
483
484
485
486
return current_audio.impl.DetectDevices(iscapture);
}
const char *
487
SDL_GetAudioDeviceName(int index, int iscapture)
488
489
490
491
492
493
{
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_SetError("Audio subsystem is not initialized");
return NULL;
}
494
495
496
497
498
499
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
SDL_SetError("No capture support");
return NULL;
}
if (index < 0) {
500
501
502
503
SDL_SetError("No such device");
return NULL;
}
504
505
506
507
508
509
510
511
if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
return DEFAULT_INPUT_DEVNAME;
}
if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
return DEFAULT_OUTPUT_DEVNAME;
}
512
return current_audio.impl.GetDeviceName(index, iscapture);
513
514
515
}
516
517
static void
close_audio_device(SDL_AudioDevice *device)
518
{
519
520
521
device->enabled = 0;
if (device->thread != NULL) {
SDL_WaitThread(device->thread, NULL);
522
}
523
524
525
526
527
528
529
530
531
532
if (device->mixer_lock != NULL) {
SDL_DestroyMutex(device->mixer_lock);
}
if (device->fake_stream != NULL) {
SDL_FreeAudioMem(device->fake_stream);
}
if (device->convert.needed) {
SDL_FreeAudioMem(device->convert.buf);
}
if (device->opened) {
533
current_audio.impl.CloseDevice(device);
534
535
536
537
device->opened = 0;
}
SDL_FreeAudioMem(device);
}
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
/*
* Sanity check desired AudioSpec for SDL_OpenAudio() in (orig).
* Fills in a sanitized copy in (prepared).
* Returns non-zero if okay, zero on fatal parameters in (orig).
*/
static int
prepare_audiospec(const SDL_AudioSpec *orig, SDL_AudioSpec *prepared)
{
SDL_memcpy(prepared, orig, sizeof (SDL_AudioSpec));
if (orig->callback == NULL) {
SDL_SetError("SDL_OpenAudio() passed a NULL callback");
return 0;
553
554
}
555
556
557
558
if (orig->freq == 0) {
const char *env = SDL_getenv("SDL_AUDIO_FREQUENCY");
if ( (!env) || ((prepared->freq = SDL_atoi(env)) == 0) ) {
prepared->freq = 22050; /* a reasonable default */
559
560
}
}
561
562
563
564
565
if (orig->format == 0) {
const char *env = SDL_getenv("SDL_AUDIO_FORMAT");
if ((!env) || ((prepared->format = SDL_ParseAudioFormat(env)) == 0)) {
prepared->format = AUDIO_S16; /* a reasonable default */
566
567
}
}
568
569
570
571
572
573
switch (orig->channels) {
case 0: {
const char *env = SDL_getenv("SDL_AUDIO_CHANNELS");
if ( (!env) || ((prepared->channels = SDL_atoi(env)) == 0) ) {
prepared->channels = 2; /* a reasonable default */
574
}
575
break;
576
577
578
579
580
581
582
}
case 1: /* Mono */
case 2: /* Stereo */
case 4: /* surround */
case 6: /* surround with center and lfe */
break;
default:
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
SDL_SetError("Unsupported number of audio channels.");
return 0;
}
if (orig->samples == 0) {
const char *env = SDL_getenv("SDL_AUDIO_SAMPLES");
if ( (!env) || ((prepared->samples = (Uint16) SDL_atoi(env)) == 0) ) {
/* Pick a default of ~46 ms at desired frequency */
/* !!! FIXME: remove this when the non-Po2 resampling is in. */
const int samples = (prepared->freq / 1000) * 46;
int power2 = 1;
while (power2 < samples) {
power2 *= 2;
}
prepared->samples = power2;
598
599
}
}
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
/* Calculate the silence and size of the audio specification */
SDL_CalculateAudioSpec(prepared);
return 1;
}
static SDL_AudioDeviceID
open_audio_device(const char *devname, int iscapture,
const SDL_AudioSpec *_desired, SDL_AudioSpec *obtained,
int min_id)
{
SDL_AudioDeviceID id = 0;
SDL_AudioSpec desired;
SDL_AudioDevice *device;
616
int i = 0;
617
618
619
620
621
622
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_SetError("Audio subsystem is not initialized");
return 0;
}
623
624
625
626
627
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
SDL_SetError("No capture support");
return 0;
}
628
629
630
631
if (!prepare_audiospec(_desired, &desired)) {
return 0;
}
632
633
634
635
636
/* If app doesn't care about a specific device, let the user override. */
if (devname == NULL) {
devname = SDL_getenv("SDL_AUDIO_DEVICE_NAME");
}
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
/*
* Catch device names at the high level for the simple case...
* This lets us have a basic "device enumeration" for systems that
* don't have multiple devices, but makes sure the device name is
* always NULL when it hits the low level.
*
* Also make sure that the simple case prevents multiple simultaneous
* opens of the default system device.
*/
if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
if ((devname) && (SDL_strcmp(devname, DEFAULT_INPUT_DEVNAME) != 0)) {
SDL_SetError("No such device");
return 0;
}
devname = NULL;
for (i = 0; i < SDL_arraysize(open_devices); i++) {
if ((open_devices[i]) && (open_devices[i]->iscapture)) {
SDL_SetError("Audio device already open");
return;
}
}
}
if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
if ((devname) && (SDL_strcmp(devname, DEFAULT_OUTPUT_DEVNAME) != 0)) {
SDL_SetError("No such device");
return 0;
}
devname = NULL;
for (i = 0; i < SDL_arraysize(open_devices); i++) {
if ((open_devices[i]) && (!open_devices[i]->iscapture)) {
SDL_SetError("Audio device already open");
return;
}
}
}
677
678
679
680
device = (SDL_AudioDevice *) SDL_AllocAudioMem(sizeof (SDL_AudioDevice));
if (device == NULL) {
SDL_OutOfMemory();
return 0;
681
}
682
683
684
685
SDL_memset(device, '\0', sizeof (SDL_AudioDevice));
SDL_memcpy(&device->spec, &desired, sizeof (SDL_AudioSpec));
device->enabled = 1;
device->paused = 1;
686
device->iscapture = iscapture;
687
688
/* Create a semaphore for locking the sound buffers */
689
690
691
692
693
694
695
if (!current_audio.impl.SkipMixerLock) {
device->mixer_lock = SDL_CreateMutex();
if (device->mixer_lock == NULL) {
close_audio_device(device);
SDL_SetError("Couldn't create mixer lock");
return 0;
}
696
}
697
698
if (!current_audio.impl.OpenDevice(device, devname, iscapture)) {
699
700
close_audio_device(device);
return 0;
701
}
702
device->opened = 1;
703
704
/* If the audio driver changes the buffer size, accept it */
705
706
707
if (device->spec.samples != desired.samples) {
desired.samples = device->spec.samples;
SDL_CalculateAudioSpec(&device->spec);
708
709
710
}
/* Allocate a fake audio memory buffer */
711
712
713
device->fake_stream = SDL_AllocAudioMem(device->spec.size);
if (device->fake_stream == NULL) {
close_audio_device(device);
714
SDL_OutOfMemory();
715
return 0;
716
717
718
719
}
/* See if we need to do any conversion */
if (obtained != NULL) {
720
721
722
723
SDL_memcpy(obtained, &device->spec, sizeof(SDL_AudioSpec));
} else if (desired.freq != device->spec.freq ||
desired.format != device->spec.format ||
desired.channels != device->spec.channels) {
724
/* Build an audio conversion block */
725
726
727
728
729
730
731
if (SDL_BuildAudioCVT(&device->convert,
desired.format, desired.channels,
desired.freq,
device->spec.format, device->spec.channels,
device->spec.freq) < 0) {
close_audio_device(device);
return 0;
732
}
733
734
735
736
737
738
739
if (device->convert.needed) {
device->convert.len = desired.size;
device->convert.buf =
(Uint8 *) SDL_AllocAudioMem(device->convert.len *
device->convert.len_mult);
if (device->convert.buf == NULL) {
close_audio_device(device);
740
SDL_OutOfMemory();
741
return 0;
742
743
744
}
}
}
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
/* Find an available device ID and store the structure... */
for (id = min_id-1; id < SDL_arraysize(open_devices); id++) {
if (open_devices[id] == NULL) {
open_devices[id] = device;
break;
}
}
/* !!! FIXME: remove static array... */
if (id == SDL_arraysize(open_devices)) {
SDL_SetError("Too many open audio devices");
close_audio_device(device);
return 0;
}
761
/* Start the audio thread if necessary */
762
if (!current_audio.impl.ProvidesOwnCallbackThread) {
763
/* Start the audio thread */
764
/* !!! FIXME: this is nasty. */
765
#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
766
#undef SDL_CreateThread
767
device->thread = SDL_CreateThread(SDL_RunAudio, device, NULL, NULL);
768
#else
769
device->thread = SDL_CreateThread(SDL_RunAudio, device);
770
#endif
771
772
if (device->thread == NULL) {
SDL_CloseAudioDevice(id+1);
773
SDL_SetError("Couldn't create audio thread");
774
return 0;
775
776
}
}
777
778
return id+1;
779
780
}
781
782
783
int
SDL_OpenAudio(const SDL_AudioSpec * desired, SDL_AudioSpec * obtained)
784
{
785
SDL_AudioDeviceID id = 0;
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
/* Start up the audio driver, if necessary. This is legacy behaviour! */
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
return (-1);
}
}
/* SDL_OpenAudio() is legacy and can only act on Device ID #1. */
if (open_devices[0] != NULL) {
SDL_SetError("Audio device is already opened");
return (-1);
}
id = open_audio_device(NULL, 0, desired, obtained, 1);
if (id > 1) { /* this should never happen in theory... */
SDL_CloseAudioDevice(id);
SDL_SetError("Internal error"); /* MUST be Device ID #1! */
return (-1);
}
return ((id == 0) ? -1 : 0);
}
SDL_AudioDeviceID
SDL_OpenAudioDevice(const char *device, int iscapture,
const SDL_AudioSpec *desired, SDL_AudioSpec *obtained)
{
return open_audio_device(device, iscapture, desired, obtained, 2);
}
SDL_audiostatus
SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
{
SDL_AudioDevice *device = get_audio_device(devid);
SDL_audiostatus status = SDL_AUDIO_STOPPED;
if (device && device->enabled) {
if (device->paused) {
824
825
826
827
828
829
status = SDL_AUDIO_PAUSED;
} else {
status = SDL_AUDIO_PLAYING;
}
}
return (status);
830
831
}
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
SDL_audiostatus
SDL_GetAudioStatus(void)
{
return SDL_GetAudioDeviceStatus(1);
}
void
SDL_PauseAudioDevice(SDL_AudioDeviceID devid, int pause_on)
{
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
device->paused = pause_on;
}
}
848
849
void
SDL_PauseAudio(int pause_on)
850
{
851
852
853
SDL_PauseAudioDevice(1, pause_on);
}
854
855
856
857
void
SDL_LockAudioDevice(SDL_AudioDeviceID devid)
{
858
859
860
861
/* Obtain a lock on the mixing buffers */
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
current_audio.impl.LockDevice(device);
862
}
863
864
}
865
866
void
SDL_LockAudio(void)
867
{
868
869
SDL_LockAudioDevice(1);
}
870
871
872
873
void
SDL_UnlockAudioDevice(SDL_AudioDeviceID devid)
{
874
875
876
877
/* Obtain a lock on the mixing buffers */
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
current_audio.impl.UnlockDevice(device);
878
}
879
880
}
881
882
void
SDL_UnlockAudio(void)
883
{
884
885
SDL_UnlockAudioDevice(1);
}
886
887
888
889
890
891
892
893
void
SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
{
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
close_audio_device(device);
open_devices[devid-1] = NULL;
894
}
895
896
}
897
898
void
SDL_CloseAudio(void)
899
{
900
SDL_CloseAudioDevice(1);
901
902
}
903
904
void
SDL_AudioQuit(void)
905
{
906
907
908
SDL_AudioDeviceID i;
for (i = 0; i < SDL_arraysize(open_devices); i++) {
SDL_CloseAudioDevice(i);
909
}
910
911
/* Free the driver data */
912
current_audio.impl.Deinitialize();
913
914
SDL_memset(¤t_audio, '\0', sizeof (current_audio));
SDL_memset(open_devices, '\0', sizeof (open_devices));
915
916
}
917
#define NUM_FORMATS 10
918
919
static int format_idx;
static int format_idx_sub;
920
static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS] = {
921
{AUDIO_U8, AUDIO_S8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
922
AUDIO_U16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB},
923
{AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
924
925
926
927
928
929
930
931
932
AUDIO_U16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB},
{AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S32LSB,
AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S32MSB,
AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_U8, AUDIO_S8},
{AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S32LSB,
AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_S32MSB,
AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_U8, AUDIO_S8},
933
934
935
936
937
938
939
940
{AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_S16LSB,
AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_S16MSB,
AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8},
{AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_S16LSB,
AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, AUDIO_S8},
{AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_S16MSB,
AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8},
941
942
};
943
944
SDL_AudioFormat
SDL_FirstAudioFormat(SDL_AudioFormat format)
945
{
946
947
948
949
950
951
952
for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
if (format_list[format_idx][0] == format) {
break;
}
}
format_idx_sub = 0;
return (SDL_NextAudioFormat());
953
954
}
955
SDL_AudioFormat
956
SDL_NextAudioFormat(void)
957
{
958
959
960
961
if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
return (0);
}
return (format_list[format_idx][format_idx_sub++]);
962
963
}
964
965
void
SDL_CalculateAudioSpec(SDL_AudioSpec * spec)
966
{
967
968
969
970
971
972
973
974
switch (spec->format) {
case AUDIO_U8:
spec->silence = 0x80;
break;
default:
spec->silence = 0x00;
break;
}
975
spec->size = SDL_AUDIO_BITSIZE(spec->format) / 8;
976
977
spec->size *= spec->channels;
spec->size *= spec->samples;
978
}
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Moved here from SDL_mixer.c, since it relies on internals of an opened
* audio device (and is deprecated, by the way!).
*/
void
SDL_MixAudio(Uint8 * dst, const Uint8 * src, Uint32 len, int volume)
{
/* Mix the user-level audio format */
SDL_AudioDevice *device = get_audio_device(1);
if (device != NULL) {
SDL_AudioFormat format;
if (device->convert.needed) {
format = device->convert.src_format;
} else {
format = device->spec.format;
}
SDL_MixAudioFormat(dst, src, format, len, volume);
}
}