This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_bsdaudio.c
455 lines (395 loc) · 12.9 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2009 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
/*
25
* Driver for native OpenBSD/NetBSD audio(4).
26
27
28
29
30
31
32
33
34
35
36
37
* vedge@vedge.com.ar.
*/
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/audioio.h>
38
#include "SDL_timer.h"
39
#include "SDL_audio.h"
40
41
42
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "../SDL_audiodev_c.h"
43
#include "SDL_bsdaudio.h"
44
45
/* The tag name used by NetBSD/OpenBSD audio */
46
47
48
#ifdef __NetBSD__
#define BSD_AUDIO_DRIVER_NAME "netbsd"
#define BSD_AUDIO_DRIVER_DESC "Native NetBSD audio"
49
#else
50
51
#define BSD_AUDIO_DRIVER_NAME "openbsd"
#define BSD_AUDIO_DRIVER_DESC "Native OpenBSD audio"
52
#endif
53
54
55
56
57
58
59
60
61
62
63
/* Open the audio device for playback, and don't block if busy */
/* #define USE_BLOCKING_WRITES */
/* Use timer for synchronization */
/* #define USE_TIMER_SYNC */
/* #define DEBUG_AUDIO */
/* #define DEBUG_AUDIO_STREAM */
#ifdef USE_BLOCKING_WRITES
64
65
#define OPEN_FLAGS_OUTPUT O_WRONLY
#define OPEN_FLAGS_INPUT O_RDONLY
66
#else
67
68
#define OPEN_FLAGS_OUTPUT (O_WRONLY|O_NONBLOCK)
#define OPEN_FLAGS_INPUT (O_RDONLY|O_NONBLOCK)
69
70
#endif
71
72
73
74
75
/* !!! FIXME: so much cut and paste with dsp/dma drivers... */
static char **outputDevices = NULL;
static int outputDeviceCount = 0;
static char **inputDevices = NULL;
static int inputDeviceCount = 0;
76
77
78
79
80
81
static inline void
free_device_list(char ***devs, int *count)
{
SDL_FreeUnixAudioDevices(devs, count);
}
82
83
84
85
86
87
88
89
static inline void
build_device_list(int iscapture, char ***devs, int *count)
{
const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
free_device_list(devs, count);
SDL_EnumUnixAudioDevices(flags, 0, NULL, devs, count);
}
90
91
92
static inline void
build_device_lists(void)
93
{
94
95
build_device_list(0, &outputDevices, &outputDeviceCount);
build_device_list(1, &inputDevices, &inputDeviceCount);
96
97
}
98
99
100
static inline void
free_device_lists(void)
101
{
102
103
free_device_list(&outputDevices, &outputDeviceCount);
free_device_list(&inputDevices, &inputDeviceCount);
104
105
}
106
107
108
static void
BSDAUDIO_Deinitialize(void)
109
{
110
111
free_device_lists();
}
112
113
114
115
116
117
118
119
120
121
122
static int
BSDAUDIO_DetectDevices(int iscapture)
{
if (iscapture) {
build_device_list(1, &inputDevices, &inputDeviceCount);
return inputDeviceCount;
} else {
build_device_list(0, &outputDevices, &outputDeviceCount);
return outputDeviceCount;
123
}
124
125
return 0; /* shouldn't ever hit this. */
126
127
128
129
130
131
132
133
134
}
static const char *
BSDAUDIO_GetDeviceName(int index, int iscapture)
{
if ((iscapture) && (index < inputDeviceCount)) {
return inputDevices[index];
} else if ((!iscapture) && (index < outputDeviceCount)) {
return outputDevices[index];
135
136
}
137
138
139
140
141
142
143
144
145
SDL_SetError("No such device");
return NULL;
}
static void
BSDAUDIO_Status(_THIS)
{
#ifdef DEBUG_AUDIO
146
/* *INDENT-OFF* */
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
audio_info_t info;
if (ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info) < 0) {
fprintf(stderr, "AUDIO_GETINFO failed.\n");
return;
}
fprintf(stderr, "\n"
"[play/record info]\n"
"buffer size : %d bytes\n"
"sample rate : %i Hz\n"
"channels : %i\n"
"precision : %i-bit\n"
"encoding : 0x%x\n"
"seek : %i\n"
"sample count : %i\n"
"EOF count : %i\n"
"paused : %s\n"
"error occured : %s\n"
"waiting : %s\n"
"active : %s\n"
"",
info.play.buffer_size,
info.play.sample_rate,
info.play.channels,
info.play.precision,
info.play.encoding,
info.play.seek,
info.play.samples,
info.play.eof,
info.play.pause ? "yes" : "no",
info.play.error ? "yes" : "no",
info.play.waiting ? "yes" : "no",
info.play.active ? "yes" : "no");
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
fprintf(stderr, "\n"
"[audio info]\n"
"monitor_gain : %i\n"
"hw block size : %d bytes\n"
"hi watermark : %i\n"
"lo watermark : %i\n"
"audio mode : %s\n"
"",
info.monitor_gain,
info.blocksize,
info.hiwat, info.lowat,
(info.mode == AUMODE_PLAY) ? "PLAY"
: (info.mode = AUMODE_RECORD) ? "RECORD"
: (info.mode == AUMODE_PLAY_ALL ? "PLAY_ALL" : "?"));
195
/* *INDENT-ON* */
196
#endif /* DEBUG_AUDIO */
197
198
199
200
201
}
/* This function waits until it is possible to write a full sound buffer */
static void
202
BSDAUDIO_WaitDevice(_THIS)
203
{
204
205
#ifndef USE_BLOCKING_WRITES /* Not necessary when using blocking writes */
/* See if we need to use timed audio synchronization */
206
if (this->hidden->frame_ticks) {
207
208
209
/* Use timer for general audio synchronization */
Sint32 ticks;
210
211
212
ticks =
((Sint32) (this->hidden->next_frame - SDL_GetTicks())) -
FUDGE_TICKS;
213
214
215
216
217
218
219
220
221
if (ticks > 0) {
SDL_Delay(ticks);
}
} else {
/* Use select() for audio synchronization */
fd_set fdset;
struct timeval timeout;
FD_ZERO(&fdset);
222
FD_SET(this->hidden->audio_fd, &fdset);
223
224
timeout.tv_sec = 10;
timeout.tv_usec = 0;
225
#ifdef DEBUG_AUDIO
226
fprintf(stderr, "Waiting for audio to get ready\n");
227
#endif
228
229
if (select(this->hidden->audio_fd + 1, NULL, &fdset, NULL, &timeout)
<= 0) {
230
231
232
233
234
235
236
237
238
const char *message =
"Audio timeout - buggy audio driver? (disabled)";
/* In general we should never print to the screen,
but in this case we have no other way of letting
the user know what happened.
*/
fprintf(stderr, "SDL: %s\n", message);
this->enabled = 0;
/* Don't try to close - may hang */
239
this->hidden->audio_fd = -1;
240
#ifdef DEBUG_AUDIO
241
fprintf(stderr, "Done disabling audio\n");
242
#endif
243
}
244
#ifdef DEBUG_AUDIO
245
fprintf(stderr, "Ready!\n");
246
#endif
247
}
248
249
250
251
#endif /* !USE_BLOCKING_WRITES */
}
static void
252
BSDAUDIO_PlayDevice(_THIS)
253
{
254
255
256
257
int written, p = 0;
/* Write the audio data, checking for EAGAIN on broken audio drivers */
do {
258
written = write(this->hidden->audio_fd,
259
&this->hidden->mixbuf[p], this->hidden->mixlen - p);
260
261
262
263
264
265
266
267
268
269
270
271
272
if (written > 0)
p += written;
if (written == -1 && errno != 0 && errno != EAGAIN && errno != EINTR) {
/* Non recoverable error has occurred. It should be reported!!! */
perror("audio");
break;
}
if (p < written
|| ((written < 0) && ((errno == 0) || (errno == EAGAIN)))) {
SDL_Delay(1); /* Let a little CPU time go by */
}
273
} while (p < written);
274
275
/* If timer synchronization is enabled, set the next write frame */
276
277
if (this->hidden->frame_ticks) {
this->hidden->next_frame += this->hidden->frame_ticks;
278
279
280
281
282
283
}
/* If we couldn't write, assume fatal error for now */
if (written < 0) {
this->enabled = 0;
}
284
#ifdef DEBUG_AUDIO
285
fprintf(stderr, "Wrote %d bytes of audio data\n", written);
286
287
288
#endif
}
289
static Uint8 *
290
BSDAUDIO_GetDeviceBuf(_THIS)
291
{
292
return (this->hidden->mixbuf);
293
294
295
}
static void
296
BSDAUDIO_CloseDevice(_THIS)
297
{
298
299
300
301
302
303
304
305
306
307
308
if (this->hidden != NULL) {
if (this->hidden->mixbuf != NULL) {
SDL_FreeAudioMem(this->hidden->mixbuf);
this->hidden->mixbuf = NULL;
}
if (this->hidden->audio_fd >= 0) {
close(this->hidden->audio_fd);
this->hidden->audio_fd = -1;
}
SDL_free(this->hidden);
this->hidden = NULL;
309
310
311
}
}
312
313
static int
BSDAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
314
{
315
316
const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
SDL_AudioFormat format = 0;
317
318
audio_info_t info;
319
320
321
/* We don't care what the devname is...we'll try to open anything. */
/* ...but default to first name in the list... */
if (devname == NULL) {
322
323
if (((iscapture) && (inputDeviceCount == 0)) ||
((!iscapture) && (outputDeviceCount == 0))) {
324
325
326
327
SDL_SetError("No such audio device");
return 0;
}
devname = ((iscapture) ? inputDevices[0] : outputDevices[0]);
328
329
}
330
331
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
332
SDL_malloc((sizeof *this->hidden));
333
334
335
336
337
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
338
339
340
341
342
343
344
/* Open the audio device */
this->hidden->audio_fd = open(devname, flags, 0);
if (this->hidden->audio_fd < 0) {
SDL_SetError("Couldn't open %s: %s", devname, strerror(errno));
return 0;
}
345
346
AUDIO_INITINFO(&info);
347
348
/* Calculate the final parameters for this audio specification */
349
SDL_CalculateAudioSpec(&this->spec);
350
351
352
/* Set to play mode */
info.mode = AUMODE_PLAY;
353
354
if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) < 0) {
BSDAUDIO_CloseDevice(this);
355
SDL_SetError("Couldn't put device into play mode");
356
return 0;
357
}
358
359
AUDIO_INITINFO(&info);
360
for (format = SDL_FirstAudioFormat(this->spec.format);
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
format; format = SDL_NextAudioFormat()) {
switch (format) {
case AUDIO_U8:
info.play.encoding = AUDIO_ENCODING_ULINEAR;
info.play.precision = 8;
break;
case AUDIO_S8:
info.play.encoding = AUDIO_ENCODING_SLINEAR;
info.play.precision = 8;
break;
case AUDIO_S16LSB:
info.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
info.play.precision = 16;
break;
case AUDIO_S16MSB:
info.play.encoding = AUDIO_ENCODING_SLINEAR_BE;
info.play.precision = 16;
break;
case AUDIO_U16LSB:
info.play.encoding = AUDIO_ENCODING_ULINEAR_LE;
info.play.precision = 16;
break;
case AUDIO_U16MSB:
info.play.encoding = AUDIO_ENCODING_ULINEAR_BE;
info.play.precision = 16;
break;
default:
continue;
}
390
391
if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) == 0) {
392
break;
393
}
394
395
}
396
if (!format) {
397
398
399
BSDAUDIO_CloseDevice(this);
SDL_SetError("No supported encoding for 0x%x", this->spec.format);
return 0;
400
401
}
402
this->spec.format = format;
403
404
AUDIO_INITINFO(&info);
405
406
407
408
info.play.channels = this->spec.channels;
if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) == -1) {
this->spec.channels = 1;
}
409
AUDIO_INITINFO(&info);
410
411
info.play.sample_rate = this->spec.freq;
info.blocksize = this->spec.size;
412
413
info.hiwat = 5;
info.lowat = 3;
414
415
416
(void) ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info);
(void) ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info);
this->spec.freq = info.play.sample_rate;
417
/* Allocate mixing buffer */
418
419
420
421
422
423
this->hidden->mixlen = this->spec.size;
this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
if (this->hidden->mixbuf == NULL) {
BSDAUDIO_CloseDevice(this);
SDL_OutOfMemory();
return 0;
424
}
425
SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
426
427
BSDAUDIO_Status(this);
428
429
/* We're ready to rock and roll. :-) */
430
return (0);
431
}
432
433
static int
434
BSDAUDIO_Init(SDL_AudioDriverImpl * impl)
435
436
437
438
439
440
441
442
443
444
445
446
{
/* Set the function pointers */
impl->DetectDevices = BSDAUDIO_DetectDevices;
impl->GetDeviceName = BSDAUDIO_GetDeviceName;
impl->OpenDevice = BSDAUDIO_OpenDevice;
impl->PlayDevice = BSDAUDIO_PlayDevice;
impl->WaitDevice = BSDAUDIO_WaitDevice;
impl->GetDeviceBuf = BSDAUDIO_GetDeviceBuf;
impl->CloseDevice = BSDAUDIO_CloseDevice;
impl->Deinitialize = BSDAUDIO_Deinitialize;
build_device_lists();
447
return (outputDeviceCount > 0) ? 2 : 1;
448
449
450
451
452
453
454
}
AudioBootStrap BSD_AUDIO_bootstrap = {
BSD_AUDIO_DRIVER_NAME, BSD_AUDIO_DRIVER_DESC, BSDAUDIO_Init, 0
};
455
/* vi: set ts=4 sw=4 expandtab: */