This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_audio.c
1085 lines (942 loc) · 30.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
#ifdef __OS2__
32
/* We'll need the DosSetPriority() API! */
33
34
35
36
#define INCL_DOSPROCESS
#include <os2.h>
#endif
37
38
#define _THIS SDL_AudioDevice *this
39
40
41
42
43
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];
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
/* !!! 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 AHI_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;
82
83
84
/* Available audio drivers */
static AudioBootStrap *bootstrap[] = {
85
#if SDL_AUDIO_DRIVER_BSD
86
&BSD_AUDIO_bootstrap,
87
#endif
88
#if SDL_AUDIO_DRIVER_OSS
89
90
&DSP_bootstrap,
&DMA_bootstrap,
91
#endif
92
#if SDL_AUDIO_DRIVER_ALSA
93
&ALSA_bootstrap,
94
#endif
95
#if SDL_AUDIO_DRIVER_QNXNTO
96
&QNXNTOAUDIO_bootstrap,
97
#endif
98
#if SDL_AUDIO_DRIVER_SUNAUDIO
99
&SUNAUDIO_bootstrap,
100
#endif
101
#if SDL_AUDIO_DRIVER_DMEDIA
102
&DMEDIA_bootstrap,
103
#endif
104
#if SDL_AUDIO_DRIVER_ARTS
105
&ARTS_bootstrap,
106
#endif
107
#if SDL_AUDIO_DRIVER_ESD
108
&ESD_bootstrap,
109
#endif
110
#if SDL_AUDIO_DRIVER_NAS
111
&NAS_bootstrap,
112
#endif
113
#if SDL_AUDIO_DRIVER_DSOUND
114
&DSOUND_bootstrap,
115
#endif
116
#if SDL_AUDIO_DRIVER_WAVEOUT
117
&WAVEOUT_bootstrap,
118
#endif
119
#if SDL_AUDIO_DRIVER_PAUD
120
&Paud_bootstrap,
121
122
#endif
#if SDL_AUDIO_DRIVER_BAUDIO
123
&BAUDIO_bootstrap,
124
#endif
125
#if SDL_AUDIO_DRIVER_COREAUDIO
126
&COREAUDIO_bootstrap,
127
#endif
128
#if SDL_AUDIO_DRIVER_SNDMGR
129
&SNDMGR_bootstrap,
130
#endif
131
#if SDL_AUDIO_DRIVER_AHI
132
&AHI_bootstrap,
133
#endif
134
#if SDL_AUDIO_DRIVER_MINT
135
136
137
138
139
&MINTAUDIO_GSXB_bootstrap,
&MINTAUDIO_MCSN_bootstrap,
&MINTAUDIO_STFA_bootstrap,
&MINTAUDIO_XBIOS_bootstrap,
&MINTAUDIO_DMA8_bootstrap,
140
#endif
141
#if SDL_AUDIO_DRIVER_DISK
142
&DISKAUD_bootstrap,
143
#endif
144
#if SDL_AUDIO_DRIVER_DUMMY
145
&DUMMYAUD_bootstrap,
146
#endif
147
#if SDL_AUDIO_DRIVER_DC
148
&DCAUD_bootstrap,
149
#endif
150
#if SDL_AUDIO_DRIVER_MMEAUDIO
151
&MMEAUDIO_bootstrap,
152
153
#endif
#if SDL_AUDIO_DRIVER_DART
154
&DART_bootstrap,
155
#endif
156
NULL
157
158
};
159
#if SDL_AUDIO_DRIVER_AHI
160
161
static int audio_configured = 0;
#endif
162
163
164
165
166
167
168
169
170
171
172
173
174
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];
}
175
/* stubs for audio drivers that don't need a specific entry point... */
176
177
178
179
180
181
182
183
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. */ }
184
185
186
static int
SDL_AudioOpenDevice_Default(_THIS, const char *devname, int iscapture)
187
{
188
return 0;
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
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
}
241
242
243
/* The general mixing thread function */
244
int SDLCALL
245
SDL_RunAudio(void *devicep)
246
{
247
248
SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
const int legacy_device = (device == open_devices[0]);
249
250
251
252
253
Uint8 *stream;
int stream_len;
void *udata;
void (SDLCALL * fill) (void *userdata, Uint8 * stream, int len);
int silence;
254
255
/* !!! FIXME: can we push this into the Amiga driver? */
256
#if SDL_AUDIO_DRIVER_AHI
257
#error this is probably broken.
258
int started = 0;
259
260
261
/* AmigaOS NEEDS that the audio driver is opened in the thread that uses it! */
262
D(bug("Task audio started audio struct:<%lx>...\n", audiop));
263
264
265
266
267
268
269
D(bug("Before Openaudio..."));
if (audio->OpenAudio(audio, &audio->spec) == -1) {
D(bug("Open audio failed...\n"));
return (-1);
}
D(bug("OpenAudio...OK\n"));
270
#endif
271
272
/* Perform any thread setup */
273
device->threadid = SDL_ThreadID();
274
current_audio.impl.ThreadInit(device);
275
276
/* Set up the mixing function */
277
278
fill = device->spec.callback;
udata = device->spec.userdata;
279
280
#if SDL_AUDIO_DRIVER_AHI
281
audio_configured = 1;
282
283
284
285
D(bug("Audio configured... Checking for conversion\n"));
SDL_mutexP(audio->mixer_lock);
D(bug("Semaphore obtained...\n"));
286
287
#endif
288
289
if (device->convert.needed) {
if (device->convert.src_format == AUDIO_U8) {
290
291
292
293
silence = 0x80;
} else {
silence = 0;
}
294
stream_len = device->convert.len;
295
} else {
296
297
silence = device->spec.silence;
stream_len = device->spec.size;
298
}
299
300
#if SDL_AUDIO_DRIVER_AHI
301
SDL_mutexV(device->mixer_lock);
302
D(bug("Entering audio loop...\n"));
303
304
#endif
305
/* Loop, filling the audio buffers */
306
while (device->enabled) {
307
308
/* Fill the current buffer with sound */
309
310
311
if (device->convert.needed) {
if (device->convert.buf) {
stream = device->convert.buf;
312
313
314
315
} else {
continue;
}
} else {
316
stream = current_audio.impl.GetDeviceBuf(device);
317
if (stream == NULL) {
318
stream = device->fake_stream;
319
}
320
}
321
322
323
324
325
326
327
328
/* 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);
329
(*fill) (udata, stream, stream_len);
330
SDL_mutexV(device->mixer_lock);
331
}
332
333
/* Convert the audio if necessary */
334
335
if (device->convert.needed) {
SDL_ConvertAudio(&device->convert);
336
stream = current_audio.impl.GetDeviceBuf(device);
337
if (stream == NULL) {
338
stream = device->fake_stream;
339
}
340
SDL_memcpy(stream, device->convert.buf, device->convert.len_cvt);
341
342
343
}
/* Ready current buffer for play and change current buffer */
344
if (stream != device->fake_stream) {
345
current_audio.impl.PlayDevice(device);
346
347
348
}
/* Wait for an audio buffer to become available */
349
350
if (stream == device->fake_stream) {
SDL_Delay((device->spec.samples * 1000) / device->spec.freq);
351
} else {
352
current_audio.impl.WaitDevice(device);
353
354
355
356
}
}
/* Wait for the audio to drain.. */
357
358
359
current_audio.impl.WaitDone(device);
/* !!! FIXME: get this out of core. */
360
#if SDL_AUDIO_DRIVER_AHI
361
D(bug("WaitDevice...Done\n"));
362
363
current_audio.impl.CloseDevice(device);
device->opened = 0;
364
D(bug("CloseDevice..Done, subtask exiting...\n"));
365
audio_configured = 0;
366
#endif
367
368
return (0);
369
370
371
}
372
static SDL_AudioFormat
373
SDL_ParseAudioFormat(const char *string)
374
{
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
#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;
396
397
}
398
399
int
SDL_GetNumAudioDrivers(void)
400
{
401
402
return (SDL_arraysize(bootstrap) - 1);
}
403
404
405
406
407
408
409
410
411
412
413
414
415
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)
{
416
417
int i = 0;
int initialized = 0;
418
419
420
if (SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_AudioQuit(); /* shutdown driver if already running. */
421
422
}
423
424
425
426
427
SDL_memset(¤t_audio, '\0', sizeof (current_audio));
SDL_memset(open_devices, '\0', sizeof (open_devices));
/* !!! FIXME: build a priority list of available drivers... */
428
/* Select the proper audio driver */
429
430
431
if (driver_name == NULL) {
driver_name = SDL_getenv("SDL_AUDIODRIVER");
}
432
433
/* !!! FIXME: move this esound shite into the esound driver... */
434
#if SDL_AUDIO_DRIVER_ESD
435
436
437
438
439
440
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) {
441
if (SDL_strcasecmp(bootstrap[i]->name, "esd") == 0) {
442
#ifdef HAVE_PUTENV
443
444
445
446
447
448
449
450
451
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()) {
452
453
454
455
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);
456
457
break;
}
458
#ifdef HAVE_UNSETENV
459
460
461
if (esd_no_spawn == NULL) {
unsetenv("ESD_NO_SPAWN");
}
462
#endif
463
464
465
}
}
}
466
#endif /* SDL_AUDIO_DRIVER_ESD */
467
468
if (!initialized) {
469
470
if (driver_name != NULL) {
for (i = 0; bootstrap[i]; ++i) {
471
if (SDL_strcasecmp(bootstrap[i]->name, driver_name) == 0) {
472
if (bootstrap[i]->available()) {
473
474
475
476
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);
477
478
479
480
481
}
break;
}
}
} else {
482
for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
483
if ((!bootstrap[i]->demand) && (bootstrap[i]->available())) {
484
485
486
487
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);
488
489
490
}
}
}
491
if (!initialized) {
492
493
494
495
496
if (driver_name) {
SDL_SetError("%s not available", driver_name);
} else {
SDL_SetError("No available audio device");
}
497
498
SDL_memset(¤t_audio, 0, sizeof (current_audio));
return (-1); /* No driver was available, so fail. */
499
500
}
}
501
502
finalize_audio_entry_points();
503
504
return (0);
505
506
}
507
508
509
510
511
/*
* Get the current audio driver name
*/
const char *
SDL_GetCurrentAudioDriver()
512
{
513
return current_audio.name;
514
515
}
516
517
518
519
int
SDL_GetNumAudioDevices(int iscapture)
{
520
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
521
522
return -1;
}
523
524
525
526
527
528
529
530
531
532
533
534
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
return 0;
}
if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
return 1;
}
if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
return 1;
}
535
536
537
538
539
return current_audio.impl.DetectDevices(iscapture);
}
const char *
540
SDL_GetAudioDeviceName(int index, int iscapture)
541
542
543
544
545
546
{
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_SetError("Audio subsystem is not initialized");
return NULL;
}
547
548
549
550
551
552
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
SDL_SetError("No capture support");
return NULL;
}
if (index < 0) {
553
554
555
556
SDL_SetError("No such device");
return NULL;
}
557
558
559
560
561
562
563
564
if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
return DEFAULT_INPUT_DEVNAME;
}
if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
return DEFAULT_OUTPUT_DEVNAME;
}
565
return current_audio.impl.GetDeviceName(index, iscapture);
566
567
568
}
569
570
static void
close_audio_device(SDL_AudioDevice *device)
571
{
572
573
574
device->enabled = 0;
if (device->thread != NULL) {
SDL_WaitThread(device->thread, NULL);
575
}
576
577
578
579
580
581
582
583
584
585
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) {
586
current_audio.impl.CloseDevice(device);
587
588
589
590
device->opened = 0;
}
SDL_FreeAudioMem(device);
}
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
/*
* 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;
606
607
}
608
609
610
611
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 */
612
613
}
}
614
615
616
617
618
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 */
619
620
}
}
621
622
623
624
625
626
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 */
627
}
628
break;
629
630
631
632
633
634
635
}
case 1: /* Mono */
case 2: /* Stereo */
case 4: /* surround */
case 6: /* surround with center and lfe */
break;
default:
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
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;
651
652
}
}
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
/* 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;
669
int i = 0;
670
671
672
673
674
675
if (!SDL_WasInit(SDL_INIT_AUDIO)) {
SDL_SetError("Audio subsystem is not initialized");
return 0;
}
676
677
678
679
680
if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
SDL_SetError("No capture support");
return 0;
}
681
682
683
684
if (!prepare_audiospec(_desired, &desired)) {
return 0;
}
685
686
687
688
689
/* If app doesn't care about a specific device, let the user override. */
if (devname == NULL) {
devname = SDL_getenv("SDL_AUDIO_DEVICE_NAME");
}
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
/*
* 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;
}
}
}
730
731
732
733
device = (SDL_AudioDevice *) SDL_AllocAudioMem(sizeof (SDL_AudioDevice));
if (device == NULL) {
SDL_OutOfMemory();
return 0;
734
}
735
736
737
738
SDL_memset(device, '\0', sizeof (SDL_AudioDevice));
SDL_memcpy(&device->spec, &desired, sizeof (SDL_AudioSpec));
device->enabled = 1;
device->paused = 1;
739
device->iscapture = iscapture;
740
741
/* Create a semaphore for locking the sound buffers */
742
743
744
745
746
747
748
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;
}
749
}
750
751
/* !!! FIXME: Get this #if out of the core. */
752
/* AmigaOS opens audio inside the main loop */
753
#if !SDL_AUDIO_DRIVER_AHI
754
if (!current_audio.impl.OpenDevice(device, devname, iscapture)) {
755
756
close_audio_device(device);
return 0;
757
}
758
device->opened = 1;
759
#else
760
761
# error needs to be fixed for new internal API. Email Ryan for details.
762
763
764
765
766
767
768
769
770
771
772
D(bug("Locking semaphore..."));
SDL_mutexP(audio->mixer_lock);
audio->thread = SDL_CreateThread(SDL_RunAudio, audio);
D(bug("Created thread...\n"));
if (audio->thread == NULL) {
SDL_mutexV(audio->mixer_lock);
SDL_CloseAudio();
SDL_SetError("Couldn't create audio thread");
773
return 0;
774
775
776
777
778
779
780
}
while (!audio_configured)
SDL_Delay(100);
#endif
/* If the audio driver changes the buffer size, accept it */
781
782
783
if (device->spec.samples != desired.samples) {
desired.samples = device->spec.samples;
SDL_CalculateAudioSpec(&device->spec);
784
785
786
}
/* Allocate a fake audio memory buffer */
787
788
789
device->fake_stream = SDL_AllocAudioMem(device->spec.size);
if (device->fake_stream == NULL) {
close_audio_device(device);
790
SDL_OutOfMemory();
791
return 0;
792
793
794
795
}
/* See if we need to do any conversion */
if (obtained != NULL) {
796
797
798
799
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) {
800
/* Build an audio conversion block */
801
802
803
804
805
806
807
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;
808
}
809
810
811
812
813
814
815
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);
816
SDL_OutOfMemory();
817
return 0;
818
819
820
}
}
}
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
/* 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;
}
837
/* !!! FIXME: get this out of core. */
838
#if !SDL_AUDIO_DRIVER_AHI
839
/* Start the audio thread if necessary */
840
if (!current_audio.impl.ProvidesOwnCallbackThread) {
841
/* Start the audio thread */
842
/* !!! FIXME: this is nasty. */
843
#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
844
#undef SDL_CreateThread
845
device->thread = SDL_CreateThread(SDL_RunAudio, device, NULL, NULL);
846
#else
847
device->thread = SDL_CreateThread(SDL_RunAudio, device);
848
#endif
849
850
if (device->thread == NULL) {
SDL_CloseAudioDevice(id+1);
851
SDL_SetError("Couldn't create audio thread");
852
return 0;
853
854
}
}
855
856
#else
857
858
SDL_mutexV(audio->mixer_lock);
D(bug("SDL_OpenAudio USCITA...\n"));
859
860
861
#endif
862
return id+1;
863
864
}
865
866
867
int
SDL_OpenAudio(const SDL_AudioSpec * desired, SDL_AudioSpec * obtained)
868
{
869
SDL_AudioDeviceID id = 0;
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
/* 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) {
908
909
910
911
912
913
status = SDL_AUDIO_PAUSED;
} else {
status = SDL_AUDIO_PLAYING;
}
}
return (status);
914
915
}
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
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;
}
}
932
933
void
SDL_PauseAudio(int pause_on)
934
{
935
936
937
SDL_PauseAudioDevice(1, pause_on);
}
938
939
940
941
void
SDL_LockAudioDevice(SDL_AudioDeviceID devid)
{
942
943
944
945
/* Obtain a lock on the mixing buffers */
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
current_audio.impl.LockDevice(device);
946
}
947
948
}
949
950
void
SDL_LockAudio(void)
951
{
952
953
SDL_LockAudioDevice(1);
}
954
955
956
957
void
SDL_UnlockAudioDevice(SDL_AudioDeviceID devid)
{
958
959
960
961
/* Obtain a lock on the mixing buffers */
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
current_audio.impl.UnlockDevice(device);
962
}
963
964
}
965
966
void
SDL_UnlockAudio(void)
967
{
968
969
SDL_UnlockAudioDevice(1);
}
970
971
972
973
974
975
976
977
void
SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
{
SDL_AudioDevice *device = get_audio_device(devid);
if (device) {
close_audio_device(device);
open_devices[devid-1] = NULL;
978
}
979
980
}
981
982
void
SDL_CloseAudio(void)
983
{
984
SDL_CloseAudioDevice(1);
985
986
}
987
988
void
SDL_AudioQuit(void)
989
{
990
991
992
SDL_AudioDeviceID i;
for (i = 0; i < SDL_arraysize(open_devices); i++) {
SDL_CloseAudioDevice(i);
993
}
994
995
/* Free the driver data */
996
current_audio.impl.Deinitialize();
997
998
SDL_memset(¤t_audio, '\0', sizeof (current_audio));
SDL_memset(open_devices, '\0', sizeof (open_devices));
999
1000
}