This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_sunaudio.c
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2013 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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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_config.h"
#if SDL_AUDIO_DRIVER_SUNAUDIO
/* Allow access to a raw mixing buffer */
#include <fcntl.h>
#include <errno.h>
#ifdef __NETBSD__
#include <sys/ioctl.h>
#include <sys/audioio.h>
#endif
#ifdef __SVR4
#include <sys/audioio.h>
#else
#include <sys/time.h>
#include <sys/types.h>
#endif
#include <unistd.h>
#include "SDL_timer.h"
#include "SDL_audio.h"
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "../SDL_audiodev_c.h"
#include "SDL_sunaudio.h"
/* Open the audio device for playback, and don't block if busy */
#if defined(AUDIO_GETINFO) && !defined(AUDIO_GETBUFINFO)
#define AUDIO_GETBUFINFO AUDIO_GETINFO
#endif
/* Audio driver functions */
static Uint8 snd2au(int sample);
/* Audio driver bootstrap functions */
static void
59
SUNAUDIO_DetectDevices(int iscapture, SDL_AddAudioDevice addfn)
61
SDL_EnumUnixAudioDevices(iscapture, 1, (int (*)(int fd)) NULL, addfn);
62
63
64
65
66
67
68
69
70
71
}
#ifdef DEBUG_AUDIO
void
CheckUnderflow(_THIS)
{
#ifdef AUDIO_GETBUFINFO
audio_info_t info;
int left;
72
73
74
ioctl(this->hidden->audio_fd, AUDIO_GETBUFINFO, &info);
left = (this->hidden->written - info.play.samples);
if (this->hidden->written && (left == 0)) {
75
76
77
78
79
80
fprintf(stderr, "audio underflow!\n");
}
#endif
}
#endif
81
82
static void
SUNAUDIO_WaitDevice(_THIS)
83
84
85
86
87
88
{
#ifdef AUDIO_GETBUFINFO
#define SLEEP_FUDGE 10 /* 10 ms scheduling fudge factor */
audio_info_t info;
Sint32 left;
89
90
91
ioctl(this->hidden->audio_fd, AUDIO_GETBUFINFO, &info);
left = (this->hidden->written - info.play.samples);
if (left > this->hidden->fragsize) {
92
93
Sint32 sleepy;
94
sleepy = ((left - this->hidden->fragsize) / this->hidden->frequency);
95
96
97
98
99
100
101
102
103
sleepy -= SLEEP_FUDGE;
if (sleepy > 0) {
SDL_Delay(sleepy);
}
}
#else
fd_set fdset;
FD_ZERO(&fdset);
104
105
FD_SET(this->hidden->audio_fd, &fdset);
select(this->hidden->audio_fd + 1, NULL, &fdset, NULL, NULL);
109
110
static void
SUNAUDIO_PlayDevice(_THIS)
111
112
{
/* Write the audio data */
113
if (this->hidden->ulaw_only) {
114
115
116
117
118
119
/* Assuming that this->spec.freq >= 8000 Hz */
int accum, incr, pos;
Uint8 *aubuf;
accum = 0;
incr = this->spec.freq / 8;
120
121
aubuf = this->hidden->ulaw_buf;
switch (this->hidden->audio_fmt & 0xFF) {
122
123
124
125
case 8:
{
Uint8 *sndbuf;
126
127
sndbuf = this->hidden->mixbuf;
for (pos = 0; pos < this->hidden->fragsize; ++pos) {
128
129
130
131
132
133
134
135
136
137
138
139
140
141
*aubuf = snd2au((0x80 - *sndbuf) * 64);
accum += incr;
while (accum > 0) {
accum -= 1000;
sndbuf += 1;
}
aubuf += 1;
}
}
break;
case 16:
{
Sint16 *sndbuf;
142
143
sndbuf = (Sint16 *) this->hidden->mixbuf;
for (pos = 0; pos < this->hidden->fragsize; ++pos) {
144
145
146
147
148
149
150
151
152
153
154
155
156
157
*aubuf = snd2au(*sndbuf / 4);
accum += incr;
while (accum > 0) {
accum -= 1000;
sndbuf += 1;
}
aubuf += 1;
}
}
break;
}
#ifdef DEBUG_AUDIO
CheckUnderflow(this);
#endif
158
159
if (write(this->hidden->audio_fd, this->hidden->ulaw_buf,
this->hidden->fragsize) < 0) {
160
161
162
/* Assume fatal error, for now */
this->enabled = 0;
}
163
this->hidden->written += this->hidden->fragsize;
164
165
166
167
} else {
#ifdef DEBUG_AUDIO
CheckUnderflow(this);
#endif
168
169
if (write(this->hidden->audio_fd, this->hidden->mixbuf,
this->spec.size) < 0) {
170
171
172
/* Assume fatal error, for now */
this->enabled = 0;
}
173
this->hidden->written += this->hidden->fragsize;
177
178
static Uint8 *
SUNAUDIO_GetDeviceBuf(_THIS)
180
return (this->hidden->mixbuf);
183
184
static void
SUNAUDIO_CloseDevice(_THIS)
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
if (this->hidden != NULL) {
if (this->hidden->mixbuf != NULL) {
SDL_FreeAudioMem(this->hidden->mixbuf);
this->hidden->mixbuf = NULL;
}
if (this->hidden->ulaw_buf != NULL) {
SDL_free(this->hidden->ulaw_buf);
this->hidden->ulaw_buf = NULL;
}
if (this->hidden->audio_fd >= 0) {
close(this->hidden->audio_fd);
this->hidden->audio_fd = -1;
}
SDL_free(this->hidden);
this->hidden = NULL;
204
205
static int
SUNAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
207
208
209
210
211
212
213
214
215
const int flags = ((iscapture) ? OPEN_FLAGS_INPUT : OPEN_FLAGS_OUTPUT);
SDL_AudioFormat format = 0;
audio_info_t info;
/* 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) {
devname = SDL_GetAudioDeviceName(0, iscapture);
if (devname == NULL) {
216
return SDL_SetError("No such audio device");
217
218
219
220
221
222
223
}
}
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc((sizeof *this->hidden));
if (this->hidden == NULL) {
224
return SDL_OutOfMemory();
225
226
227
228
229
230
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
/* Open the audio device */
this->hidden->audio_fd = open(devname, flags, 0);
if (this->hidden->audio_fd < 0) {
231
return SDL_SetError("Couldn't open %s: %s", devname, strerror(errno));
234
235
236
#ifdef AUDIO_SETINFO
int enc;
#endif
237
int desired_freq = this->spec.freq;
238
239
/* Determine the audio parameters from the AudioSpec */
240
switch (SDL_AUDIO_BITSIZE(this->spec.format)) {
241
242
243
case 8:
{ /* Unsigned 8 bit audio data */
244
this->spec.format = AUDIO_U8;
245
246
247
248
249
250
251
252
#ifdef AUDIO_SETINFO
enc = AUDIO_ENCODING_LINEAR8;
#endif
}
break;
case 16:
{ /* Signed 16 bit audio data */
253
this->spec.format = AUDIO_S16SYS;
254
255
256
257
258
259
260
261
262
#ifdef AUDIO_SETINFO
enc = AUDIO_ENCODING_LINEAR;
#endif
}
break;
default:
{
/* !!! FIXME: fallback to conversion on unsupported types! */
263
return SDL_SetError("Unsupported audio format");
266
this->hidden->audio_fmt = this->spec.format;
268
this->hidden->ulaw_only = 0; /* modern Suns do support linear audio */
269
270
271
272
273
274
#ifdef AUDIO_SETINFO
for (;;) {
audio_info_t info;
AUDIO_INITINFO(&info); /* init all fields to "no change" */
/* Try to set the requested settings */
275
276
info.play.sample_rate = this->spec.freq;
info.play.channels = this->spec.channels;
277
info.play.precision = (enc == AUDIO_ENCODING_ULAW)
278
? 8 : this->spec.format & 0xff;
279
info.play.encoding = enc;
280
if (ioctl(this->hidden->audio_fd, AUDIO_SETINFO, &info) == 0) {
281
282
/* Check to be sure we got what we wanted */
283
if (ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info) < 0) {
284
285
return SDL_SetError("Error getting audio parameters: %s",
strerror(errno));
286
287
}
if (info.play.encoding == enc
288
289
&& info.play.precision == (this->spec.format & 0xff)
&& info.play.channels == this->spec.channels) {
290
/* Yow! All seems to be well! */
291
this->spec.freq = info.play.sample_rate;
292
293
294
295
296
297
298
299
break;
}
}
switch (enc) {
case AUDIO_ENCODING_LINEAR8:
/* unsigned 8bit apparently not supported here */
enc = AUDIO_ENCODING_LINEAR;
300
this->spec.format = AUDIO_S16SYS;
301
302
303
304
305
break; /* try again */
case AUDIO_ENCODING_LINEAR:
/* linear 16bit didn't work either, resort to µ-law */
enc = AUDIO_ENCODING_ULAW;
306
307
308
309
this->spec.channels = 1;
this->spec.freq = 8000;
this->spec.format = AUDIO_U8;
this->hidden->ulaw_only = 1;
310
311
312
313
break;
default:
/* oh well... */
314
315
return SDL_SetError("Error setting audio parameters: %s",
strerror(errno));
316
317
318
}
}
#endif /* AUDIO_SETINFO */
319
this->hidden->written = 0;
320
321
/* We can actually convert on-the-fly to U-Law */
322
323
324
325
326
327
328
if (this->hidden->ulaw_only) {
this->spec.freq = desired_freq;
this->hidden->fragsize = (this->spec.samples * 1000) /
(this->spec.freq / 8);
this->hidden->frequency = 8;
this->hidden->ulaw_buf = (Uint8 *) SDL_malloc(this->hidden->fragsize);
if (this->hidden->ulaw_buf == NULL) {
329
return SDL_OutOfMemory();
331
this->spec.channels = 1;
333
334
this->hidden->fragsize = this->spec.samples;
this->hidden->frequency = this->spec.freq / 1000;
335
336
337
}
#ifdef DEBUG_AUDIO
fprintf(stderr, "Audio device %s U-Law only\n",
338
this->hidden->ulaw_only ? "is" : "is not");
339
fprintf(stderr, "format=0x%x chan=%d freq=%d\n",
340
this->spec.format, this->spec.channels, this->spec.freq);
341
342
343
#endif
/* Update the fragment size as size in bytes */
344
SDL_CalculateAudioSpec(&this->spec);
345
346
/* Allocate mixing buffer */
347
348
this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->spec.size);
if (this->hidden->mixbuf == NULL) {
349
return SDL_OutOfMemory();
351
SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
352
353
/* We're ready to rock and roll. :-) */
355
356
357
358
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
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
}
/************************************************************************/
/* This function (snd2au()) copyrighted: */
/************************************************************************/
/* Copyright 1989 by Rich Gopstein and Harris Corporation */
/* */
/* Permission to use, copy, modify, and distribute this software */
/* and its documentation for any purpose and without fee is */
/* hereby granted, provided that the above copyright notice */
/* appears in all copies and that both that copyright notice and */
/* this permission notice appear in supporting documentation, and */
/* that the name of Rich Gopstein and Harris Corporation not be */
/* used in advertising or publicity pertaining to distribution */
/* of the software without specific, written prior permission. */
/* Rich Gopstein and Harris Corporation make no representations */
/* about the suitability of this software for any purpose. It */
/* provided "as is" without express or implied warranty. */
/************************************************************************/
static Uint8
snd2au(int sample)
{
int mask;
if (sample < 0) {
sample = -sample;
mask = 0x7f;
} else {
mask = 0xff;
}
if (sample < 32) {
sample = 0xF0 | (15 - sample / 2);
} else if (sample < 96) {
sample = 0xE0 | (15 - (sample - 32) / 4);
} else if (sample < 224) {
sample = 0xD0 | (15 - (sample - 96) / 8);
} else if (sample < 480) {
sample = 0xC0 | (15 - (sample - 224) / 16);
} else if (sample < 992) {
sample = 0xB0 | (15 - (sample - 480) / 32);
} else if (sample < 2016) {
sample = 0xA0 | (15 - (sample - 992) / 64);
} else if (sample < 4064) {
sample = 0x90 | (15 - (sample - 2016) / 128);
} else if (sample < 8160) {
sample = 0x80 | (15 - (sample - 4064) / 256);
} else {
sample = 0x80;
}
return (mask & sample);
}
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
static int
SUNAUDIO_Init(SDL_AudioDriverImpl * impl)
{
/* Set the function pointers */
impl->DetectDevices = SUNAUDIO_DetectDevices;
impl->OpenDevice = SUNAUDIO_OpenDevice;
impl->PlayDevice = SUNAUDIO_PlayDevice;
impl->WaitDevice = SUNAUDIO_WaitDevice;
impl->GetDeviceBuf = SUNAUDIO_GetDeviceBuf;
impl->CloseDevice = SUNAUDIO_CloseDevice;
return 1; /* this audio target is available. */
}
AudioBootStrap SUNAUDIO_bootstrap = {
"audio", "UNIX /dev/audio interface", SUNAUDIO_Init, 0
};
428
429
430
#endif /* SDL_AUDIO_DRIVER_SUNAUDIO */
/* vi: set ts=4 sw=4 expandtab: */