This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_bsdaudio.c
453 lines (392 loc) · 12.8 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2004 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
126
127
128
129
130
131
132
133
134
return 0; /* shouldn't ever hit this. */
}
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
146
147
148
149
150
151
SDL_SetError("No such device");
return NULL;
}
static void
BSDAUDIO_Status(_THIS)
{
#ifdef DEBUG_AUDIO
audio_info_t info;
if (ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info) < 0) {
fprintf(stderr, "AUDIO_GETINFO failed.\n");
return;
}
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
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
195
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" : "?"));
#endif /* DEBUG_AUDIO */
196
197
198
199
200
}
/* This function waits until it is possible to write a full sound buffer */
static void
201
BSDAUDIO_WaitDevice(_THIS)
202
{
203
204
#ifndef USE_BLOCKING_WRITES /* Not necessary when using blocking writes */
/* See if we need to use timed audio synchronization */
205
if (this->hidden->frame_ticks) {
206
207
208
/* Use timer for general audio synchronization */
Sint32 ticks;
209
ticks = ((Sint32)(this->hidden->next_frame-SDL_GetTicks()))-FUDGE_TICKS;
210
211
212
213
214
215
216
217
218
if (ticks > 0) {
SDL_Delay(ticks);
}
} else {
/* Use select() for audio synchronization */
fd_set fdset;
struct timeval timeout;
FD_ZERO(&fdset);
219
FD_SET(this->hidden->audio_fd, &fdset);
220
221
timeout.tv_sec = 10;
timeout.tv_usec = 0;
222
#ifdef DEBUG_AUDIO
223
fprintf(stderr, "Waiting for audio to get ready\n");
224
#endif
225
if (select(this->hidden->audio_fd+1,NULL,&fdset,NULL,&timeout) <= 0) {
226
227
228
229
230
231
232
233
234
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 */
235
this->hidden->audio_fd = -1;
236
#ifdef DEBUG_AUDIO
237
fprintf(stderr, "Done disabling audio\n");
238
#endif
239
}
240
#ifdef DEBUG_AUDIO
241
fprintf(stderr, "Ready!\n");
242
#endif
243
}
244
245
246
247
#endif /* !USE_BLOCKING_WRITES */
}
static void
248
BSDAUDIO_PlayDevice(_THIS)
249
{
250
251
252
253
int written, p = 0;
/* Write the audio data, checking for EAGAIN on broken audio drivers */
do {
254
255
256
257
written = write(this->hidden->audio_fd,
&this->hidden->mixbuf[p],
this->hidden->mixlen - p);
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
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 */
}
}
while (p < written);
/* If timer synchronization is enabled, set the next write frame */
274
275
if (this->hidden->frame_ticks) {
this->hidden->next_frame += this->hidden->frame_ticks;
276
277
278
279
280
281
}
/* If we couldn't write, assume fatal error for now */
if (written < 0) {
this->enabled = 0;
}
282
#ifdef DEBUG_AUDIO
283
fprintf(stderr, "Wrote %d bytes of audio data\n", written);
284
285
286
#endif
}
287
static Uint8 *
288
BSDAUDIO_GetDeviceBuf(_THIS)
289
{
290
return (this->hidden->mixbuf);
291
292
293
}
static void
294
BSDAUDIO_CloseDevice(_THIS)
295
{
296
297
298
299
300
301
302
303
304
305
306
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;
307
308
309
}
}
310
311
static int
BSDAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
312
{
313
314
const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
SDL_AudioFormat format = 0;
315
316
audio_info_t info;
317
318
319
320
321
322
323
324
325
/* 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) {
if ( ((iscapture) && (inputDeviceCount == 0)) ||
((!iscapture) && (outputDeviceCount == 0)) ) {
SDL_SetError("No such audio device");
return 0;
}
devname = ((iscapture) ? inputDevices[0] : outputDevices[0]);
326
327
}
328
329
330
331
332
333
334
335
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc((sizeof *this->hidden));
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
336
337
338
339
340
341
342
/* 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;
}
343
344
AUDIO_INITINFO(&info);
345
346
/* Calculate the final parameters for this audio specification */
347
SDL_CalculateAudioSpec(&this->spec);
348
349
350
/* Set to play mode */
info.mode = AUMODE_PLAY;
351
352
if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) < 0) {
BSDAUDIO_CloseDevice(this);
353
SDL_SetError("Couldn't put device into play mode");
354
return 0;
355
}
356
357
AUDIO_INITINFO(&info);
358
for (format = SDL_FirstAudioFormat(this->spec.format);
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
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;
}
388
389
if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) == 0) {
390
break;
391
}
392
393
}
394
if (!format) {
395
396
397
BSDAUDIO_CloseDevice(this);
SDL_SetError("No supported encoding for 0x%x", this->spec.format);
return 0;
398
399
}
400
this->spec.format = format;
401
402
AUDIO_INITINFO(&info);
403
404
405
406
info.play.channels = this->spec.channels;
if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) == -1) {
this->spec.channels = 1;
}
407
AUDIO_INITINFO(&info);
408
409
info.play.sample_rate = this->spec.freq;
info.blocksize = this->spec.size;
410
411
info.hiwat = 5;
info.lowat = 3;
412
413
414
(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;
415
/* Allocate mixing buffer */
416
417
418
419
420
421
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;
422
}
423
SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
424
425
BSDAUDIO_Status(this);
426
427
/* We're ready to rock and roll. :-) */
428
return (0);
429
}
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
static int
BSDAUDIO_Init(SDL_AudioDriverImpl *impl)
{
/* 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();
return 1;
}
AudioBootStrap BSD_AUDIO_bootstrap = {
BSD_AUDIO_DRIVER_NAME, BSD_AUDIO_DRIVER_DESC, BSDAUDIO_Init, 0
};
453
/* vi: set ts=4 sw=4 expandtab: */