This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_nasaudio.c
408 lines (352 loc) · 11.7 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 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
23
24
25
This driver was written by:
Erik Inge Bolsø
knan@mo.himolde.no
*/
26
#include "SDL_config.h"
27
28
29
30
31
32
/* Allow access to a raw mixing buffer */
#include <signal.h>
#include <unistd.h>
33
#include "SDL_timer.h"
34
#include "SDL_audio.h"
35
#include "SDL_loadso.h"
36
37
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
38
39
#include "SDL_nasaudio.h"
40
/* The tag name used by nas audio */
41
42
43
44
45
#define NAS_DRIVER_NAME "nas"
static struct SDL_PrivateAudioData *this2 = NULL;
46
47
48
49
50
static void (*NAS_AuCloseServer) (AuServer *);
static void (*NAS_AuNextEvent) (AuServer *, AuBool, AuEvent *);
static AuBool(*NAS_AuDispatchEvent) (AuServer *, AuEvent *);
static AuFlowID(*NAS_AuCreateFlow) (AuServer *, AuStatus *);
static void (*NAS_AuStartFlow) (AuServer *, AuFlowID, AuStatus *);
51
static void (*NAS_AuSetElements)
52
(AuServer *, AuFlowID, AuBool, int, AuElement *, AuStatus *);
53
static void (*NAS_AuWriteElement)
54
(AuServer *, AuFlowID, int, AuUint32, AuPointer, AuBool, AuStatus *);
55
static AuServer *(*NAS_AuOpenServer)
56
(_AuConst char *, int, _AuConst char *, int, _AuConst char *, char **);
57
static AuEventHandlerRec *(*NAS_AuRegisterEventHandler)
58
(AuServer *, AuMask, int, AuID, AuEventHandlerCallback, AuPointer);
59
60
61
62
63
64
#ifdef SDL_AUDIO_DRIVER_NAS_DYNAMIC
static const char *nas_library = SDL_AUDIO_DRIVER_NAS_DYNAMIC;
static void *nas_handle = NULL;
65
66
static int
67
load_nas_sym(const char *fn, void **addr)
68
{
69
70
*addr = SDL_LoadFunction(nas_handle, fn);
if (*addr == NULL) {
71
return 0;
72
}
73
return 1;
74
75
}
76
77
78
79
80
81
82
/* cast funcs to char* first, to please GCC's strict aliasing rules. */
#define SDL_NAS_SYM(x) \
if (!load_nas_sym(#x, (void **) (char *) &NAS_##x)) return -1
#else
#define SDL_NAS_SYM(x) NAS_##x = x
#endif
83
84
static int
load_nas_syms(void)
85
{
86
87
88
89
90
91
92
93
94
95
SDL_NAS_SYM(AuCloseServer);
SDL_NAS_SYM(AuNextEvent);
SDL_NAS_SYM(AuDispatchEvent);
SDL_NAS_SYM(AuCreateFlow);
SDL_NAS_SYM(AuStartFlow);
SDL_NAS_SYM(AuSetElements);
SDL_NAS_SYM(AuWriteElement);
SDL_NAS_SYM(AuOpenServer);
SDL_NAS_SYM(AuRegisterEventHandler);
return 0;
96
}
97
98
#undef SDL_NAS_SYM
99
100
#ifdef SDL_AUDIO_DRIVER_NAS_DYNAMIC
101
102
103
104
105
106
107
static void
UnloadNASLibrary(void)
{
if (nas_handle != NULL) {
SDL_UnloadObject(nas_handle);
nas_handle = NULL;
108
}
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
}
static int
LoadNASLibrary(void)
{
int retval = 0;
if (nas_handle == NULL) {
nas_handle = SDL_LoadObject(nas_library);
if (nas_handle == NULL) {
/* Copy error string so we can use it in a new SDL_SetError(). */
char *origerr = SDL_GetError();
size_t len = SDL_strlen(origerr) + 1;
char *err = (char *) alloca(len);
SDL_strlcpy(err, origerr, len);
retval = -1;
SDL_SetError("NAS: SDL_LoadObject('%s') failed: %s\n",
125
nas_library, err);
126
127
128
129
130
} else {
retval = load_nas_syms();
if (retval < 0) {
UnloadNASLibrary();
}
131
132
}
}
133
134
return retval;
}
135
136
#else
137
138
139
140
141
static void
UnloadNASLibrary(void)
{
}
142
143
144
145
146
147
static int
LoadNASLibrary(void)
{
load_nas_syms();
return 0;
148
149
}
150
#endif /* SDL_AUDIO_DRIVER_NAS_DYNAMIC */
151
152
/* This function waits until it is possible to write a full sound buffer */
153
static void
154
NAS_WaitDevice(_THIS)
155
{
156
157
while (this->hidden->buf_free < this->hidden->mixlen) {
AuEvent ev;
158
159
NAS_AuNextEvent(this->hidden->aud, AuTrue, &ev);
NAS_AuDispatchEvent(this->hidden->aud, &ev);
160
}
161
162
}
163
static void
164
NAS_PlayDevice(_THIS)
165
{
166
167
168
169
170
171
while (this->hidden->mixlen > this->hidden->buf_free) {
/*
* We think the buffer is full? Yikes! Ask the server for events,
* in the hope that some of them is LowWater events telling us more
* of the buffer is free now than what we think.
*/
172
AuEvent ev;
173
174
NAS_AuNextEvent(this->hidden->aud, AuTrue, &ev);
NAS_AuDispatchEvent(this->hidden->aud, &ev);
175
176
177
178
}
this->hidden->buf_free -= this->hidden->mixlen;
/* Write the audio data */
179
NAS_AuWriteElement(this->hidden->aud, this->hidden->flow, 0,
180
181
this->hidden->mixlen, this->hidden->mixbuf, AuFalse,
NULL);
182
183
184
this->hidden->written += this->hidden->mixlen;
185
#ifdef DEBUG_AUDIO
186
fprintf(stderr, "Wrote %d bytes of audio data\n", this->hidden->mixlen);
187
188
189
#endif
}
190
static Uint8 *
191
NAS_GetDeviceBuf(_THIS)
192
{
193
return (this->hidden->mixbuf);
194
195
}
196
static void
197
NAS_CloseDevice(_THIS)
198
{
199
200
201
202
203
204
205
206
207
208
209
if (this->hidden != NULL) {
if (this->hidden->mixbuf != NULL) {
SDL_FreeAudioMem(this->hidden->mixbuf);
this->hidden->mixbuf = NULL;
}
if (this->hidden->aud) {
NAS_AuCloseServer(this->hidden->aud);
this->hidden->aud = 0;
}
SDL_free(this->hidden);
this2 = this->hidden = NULL;
210
}
211
212
}
213
214
static unsigned char
sdlformat_to_auformat(unsigned int fmt)
215
{
216
switch (fmt) {
217
case AUDIO_U8:
218
return AuFormatLinearUnsigned8;
219
case AUDIO_S8:
220
return AuFormatLinearSigned8;
221
case AUDIO_U16LSB:
222
return AuFormatLinearUnsigned16LSB;
223
case AUDIO_U16MSB:
224
return AuFormatLinearUnsigned16MSB;
225
case AUDIO_S16LSB:
226
return AuFormatLinearSigned16LSB;
227
case AUDIO_S16MSB:
228
return AuFormatLinearSigned16MSB;
229
}
230
return AuNone;
231
232
233
}
static AuBool
234
event_handler(AuServer * aud, AuEvent * ev, AuEventHandlerRec * hnd)
235
{
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
switch (ev->type) {
case AuEventTypeElementNotify:
{
AuElementNotifyEvent *event = (AuElementNotifyEvent *) ev;
switch (event->kind) {
case AuElementNotifyKindLowWater:
if (this2->buf_free >= 0) {
this2->really += event->num_bytes;
gettimeofday(&this2->last_tv, 0);
this2->buf_free += event->num_bytes;
} else {
this2->buf_free = event->num_bytes;
}
break;
case AuElementNotifyKindState:
switch (event->cur_state) {
case AuStatePause:
if (event->reason != AuReasonUser) {
if (this2->buf_free >= 0) {
this2->really += event->num_bytes;
gettimeofday(&this2->last_tv, 0);
this2->buf_free += event->num_bytes;
} else {
this2->buf_free = event->num_bytes;
}
}
break;
}
}
}
}
return AuTrue;
269
270
271
272
273
}
static AuDeviceID
find_device(_THIS, int nch)
{
274
/* These "Au" things are all macros, not functions... */
275
276
277
278
279
280
281
282
283
int i;
for (i = 0; i < AuServerNumDevices(this->hidden->aud); i++) {
if ((AuDeviceKind(AuServerDevice(this->hidden->aud, i)) ==
AuComponentKindPhysicalOutput) &&
AuDeviceNumTracks(AuServerDevice(this->hidden->aud, i)) == nch) {
return AuDeviceIdentifier(AuServerDevice(this->hidden->aud, i));
}
}
return AuNone;
284
285
}
286
static int
287
NAS_OpenDevice(_THIS, const char *devname, int iscapture)
288
{
289
290
AuElement elms[3];
int buffer_size;
291
SDL_AudioFormat test_format, format;
292
293
294
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
295
SDL_malloc((sizeof *this->hidden));
296
297
298
299
300
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
301
302
303
/* Try for a closest match on audio format */
format = 0;
304
for (test_format = SDL_FirstAudioFormat(this->spec.format);
305
306
307
308
309
310
311
!format && test_format;) {
format = sdlformat_to_auformat(test_format);
if (format == AuNone) {
test_format = SDL_NextAudioFormat();
}
}
if (format == 0) {
312
313
314
NAS_CloseDevice(this);
SDL_SetError("NAS: Couldn't find any hardware audio formats");
return 0;
315
}
316
this->spec.format = test_format;
317
318
this->hidden->aud = NAS_AuOpenServer("", 0, NULL, 0, NULL, NULL);
319
if (this->hidden->aud == 0) {
320
321
322
NAS_CloseDevice(this);
SDL_SetError("NAS: Couldn't open connection to NAS server");
return 0;
323
324
}
325
this->hidden->dev = find_device(this, this->spec.channels);
326
if ((this->hidden->dev == AuNone)
327
328
329
330
|| (!(this->hidden->flow = NAS_AuCreateFlow(this->hidden->aud, 0)))) {
NAS_CloseDevice(this);
SDL_SetError("NAS: Couldn't find a fitting device on NAS server");
return 0;
331
332
}
333
buffer_size = this->spec.freq;
334
335
336
337
338
339
340
if (buffer_size < 4096)
buffer_size = 4096;
if (buffer_size > 32768)
buffer_size = 32768; /* So that the buffer won't get unmanageably big. */
/* Calculate the final parameters for this audio specification */
341
SDL_CalculateAudioSpec(&this->spec);
342
343
344
this2 = this->hidden;
345
346
347
AuMakeElementImportClient(elms, this->spec.freq, format,
this->spec.channels, AuTrue, buffer_size,
buffer_size / 4, 0, NULL);
348
AuMakeElementExportDevice(elms + 1, 0, this->hidden->dev, this->spec.freq,
349
AuUnlimitedSamples, 0, NULL);
350
351
NAS_AuSetElements(this->hidden->aud, this->hidden->flow, AuTrue, 2, elms,
NULL);
352
353
354
NAS_AuRegisterEventHandler(this->hidden->aud, AuEventHandlerIDMask, 0,
this->hidden->flow, event_handler,
(AuPointer) NULL);
355
356
NAS_AuStartFlow(this->hidden->aud, this->hidden->flow, NULL);
357
358
/* Allocate mixing buffer */
359
this->hidden->mixlen = this->spec.size;
360
361
this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
if (this->hidden->mixbuf == NULL) {
362
363
364
NAS_CloseDevice(this);
SDL_OutOfMemory();
return 0;
365
}
366
SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
367
368
/* We're ready to rock and roll. :-) */
369
return 1;
370
}
371
372
373
374
375
376
377
378
static void
NAS_Deinitialize(void)
{
UnloadNASLibrary();
}
static int
379
NAS_Init(SDL_AudioDriverImpl * impl)
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
{
if (LoadNASLibrary() < 0) {
return 0;
} else {
AuServer *aud = NAS_AuOpenServer("", 0, NULL, 0, NULL, NULL);
if (aud == NULL) {
SDL_SetError("NAS: AuOpenServer() failed (no audio server?)");
return 0;
}
NAS_AuCloseServer(aud);
}
/* Set the function pointers */
impl->OpenDevice = NAS_OpenDevice;
impl->PlayDevice = NAS_PlayDevice;
impl->WaitDevice = NAS_WaitDevice;
impl->GetDeviceBuf = NAS_GetDeviceBuf;
impl->CloseDevice = NAS_CloseDevice;
impl->Deinitialize = NAS_Deinitialize;
399
impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME: is this true? */
400
401
return 2; /* 2 == definitely has an audio device. */
402
403
404
405
406
407
}
AudioBootStrap NAS_bootstrap = {
NAS_DRIVER_NAME, "Network Audio System", NAS_Init, 0
};
408
/* vi: set ts=4 sw=4 expandtab: */