This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_artsaudio.c
379 lines (321 loc) · 10.5 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2009 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
/* Allow access to a raw mixing buffer */
26
27
28
29
#ifdef HAVE_SIGNAL_H
#include <signal.h>
#endif
#include <unistd.h>
30
#include <errno.h>
31
32
#include "SDL_timer.h"
33
#include "SDL_audio.h"
34
35
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
36
37
#include "SDL_artsaudio.h"
38
#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
39
40
41
42
43
44
#include "SDL_name.h"
#include "SDL_loadso.h"
#else
#define SDL_NAME(X) X
#endif
45
/* The tag name used by artsc audio */
46
#define ARTS_DRIVER_NAME "arts"
47
48
#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
49
50
static const char *arts_library = SDL_AUDIO_DRIVER_ARTS_DYNAMIC;
51
52
static void *arts_handle = NULL;
53
/* !!! FIXME: I hate this SDL_NAME clutter...it makes everything so messy! */
54
55
56
57
58
59
60
61
62
63
64
65
static int (*SDL_NAME(arts_init)) (void);
static void (*SDL_NAME(arts_free)) (void);
static arts_stream_t(*SDL_NAME(arts_play_stream)) (int rate, int bits,
int channels,
const char *name);
static int (*SDL_NAME(arts_stream_set)) (arts_stream_t s,
arts_parameter_t param, int value);
static int (*SDL_NAME(arts_stream_get)) (arts_stream_t s,
arts_parameter_t param);
static int (*SDL_NAME(arts_write)) (arts_stream_t s, const void *buffer,
int count);
static void (*SDL_NAME(arts_close_stream)) (arts_stream_t s);
66
static int (*SDL_NAME(arts_suspended)) (void);
67
static const char *(*SDL_NAME(arts_error_text)) (int errorcode);
68
69
#define SDL_ARTS_SYM(x) { #x, (void **) (char *) &SDL_NAME(x) }
70
71
72
73
static struct
{
const char *name;
void **func;
74
} arts_functions[] = {
75
76
77
78
79
80
81
82
83
84
85
/* *INDENT-OFF* */
SDL_ARTS_SYM(arts_init),
SDL_ARTS_SYM(arts_free),
SDL_ARTS_SYM(arts_play_stream),
SDL_ARTS_SYM(arts_stream_set),
SDL_ARTS_SYM(arts_stream_get),
SDL_ARTS_SYM(arts_write),
SDL_ARTS_SYM(arts_close_stream),
SDL_ARTS_SYM(arts_suspended),
SDL_ARTS_SYM(arts_error_text),
/* *INDENT-ON* */
86
};
87
88
#undef SDL_ARTS_SYM
89
90
91
static void
UnloadARTSLibrary()
92
{
93
if (arts_handle != NULL) {
94
95
96
SDL_UnloadObject(arts_handle);
arts_handle = NULL;
}
97
98
}
99
100
static int
LoadARTSLibrary(void)
101
{
102
103
int i, retval = -1;
104
105
106
107
108
109
110
111
112
113
114
115
if (arts_handle == NULL) {
arts_handle = SDL_LoadObject(arts_library);
if (arts_handle != NULL) {
retval = 0;
for (i = 0; i < SDL_arraysize(arts_functions); ++i) {
*arts_functions[i].func =
SDL_LoadFunction(arts_handle, arts_functions[i].name);
if (!*arts_functions[i].func) {
retval = -1;
UnloadARTSLibrary();
break;
}
116
117
118
}
}
}
119
120
return retval;
121
122
123
124
}
#else
125
126
static void
UnloadARTSLibrary()
127
{
128
return;
129
130
}
131
132
static int
LoadARTSLibrary(void)
133
{
134
return 0;
135
136
}
137
#endif /* SDL_AUDIO_DRIVER_ARTS_DYNAMIC */
138
139
/* This function waits until it is possible to write a full sound buffer */
140
static void
141
ARTS_WaitDevice(_THIS)
142
{
143
144
145
146
147
Sint32 ticks;
/* Check to see if the thread-parent process is still alive */
{
static int cnt = 0;
148
/* Note that this only works with thread implementations
149
150
that use a different process id for each thread.
*/
151
152
/* Check every 10 loops */
if (this->hidden->parent && (((++cnt) % 10) == 0)) {
153
if (kill(this->hidden->parent, 0) < 0 && errno == ESRCH) {
154
155
156
157
158
159
this->enabled = 0;
}
}
}
/* Use timer for general audio synchronization */
160
161
ticks =
((Sint32) (this->hidden->next_frame - SDL_GetTicks())) - FUDGE_TICKS;
162
163
164
if (ticks > 0) {
SDL_Delay(ticks);
}
165
166
}
167
static void
168
ARTS_PlayDevice(_THIS)
169
{
170
/* Write the audio data */
171
172
173
int written = SDL_NAME(arts_write) (this->hidden->stream,
this->hidden->mixbuf,
this->hidden->mixlen);
174
175
/* If timer synchronization is enabled, set the next write frame */
176
177
if (this->hidden->frame_ticks) {
this->hidden->next_frame += this->hidden->frame_ticks;
178
179
180
181
182
183
}
/* If we couldn't write, assume fatal error for now */
if (written < 0) {
this->enabled = 0;
}
184
#ifdef DEBUG_AUDIO
185
fprintf(stderr, "Wrote %d bytes of audio data\n", written);
186
187
188
#endif
}
189
190
191
192
193
194
195
static void
ARTS_WaitDone(_THIS)
{
/* !!! FIXME: camp here until buffer drains... SDL_Delay(???); */
}
196
static Uint8 *
197
ARTS_GetDeviceBuf(_THIS)
198
{
199
return (this->hidden->mixbuf);
200
201
}
202
203
static void
204
ARTS_CloseDevice(_THIS)
205
{
206
207
208
209
210
211
212
213
214
215
216
217
if (this->hidden != NULL) {
if (this->hidden->mixbuf != NULL) {
SDL_FreeAudioMem(this->hidden->mixbuf);
this->hidden->mixbuf = NULL;
}
if (this->hidden->stream) {
SDL_NAME(arts_close_stream) (this->hidden->stream);
this->hidden->stream = 0;
}
SDL_NAME(arts_free) ();
SDL_free(this->hidden);
this->hidden = NULL;
218
}
219
220
}
221
222
static int
223
ARTS_OpenDevice(_THIS, const char *devname, int iscapture)
224
{
225
226
227
int rc = 0;
int bits = 0, frag_spec = 0;
SDL_AudioFormat test_format = 0, format = 0;
228
229
230
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
231
SDL_malloc((sizeof *this->hidden));
232
233
234
235
236
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
237
238
/* Try for a closest match on audio format */
239
for (test_format = SDL_FirstAudioFormat(this->spec.format);
240
!format && test_format;) {
241
#ifdef DEBUG_AUDIO
242
fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
243
#endif
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
switch (test_format) {
case AUDIO_U8:
bits = 8;
format = 1;
break;
case AUDIO_S16LSB:
bits = 16;
format = 1;
break;
default:
format = 0;
break;
}
if (!format) {
test_format = SDL_NextAudioFormat();
}
}
if (format == 0) {
262
ARTS_CloseDevice(this);
263
SDL_SetError("Couldn't find any hardware audio formats");
264
return 0;
265
}
266
this->spec.format = test_format;
267
268
269
if ((rc = SDL_NAME(arts_init) ()) != 0) {
ARTS_CloseDevice(this);
270
271
SDL_SetError("Unable to initialize ARTS: %s",
SDL_NAME(arts_error_text) (rc));
272
return 0;
273
}
274
275
if (!SDL_NAME(arts_suspended) ()) {
276
277
278
279
280
ARTS_CloseDevice(this);
SDL_SetError("ARTS can not open audio device");
return 0;
}
281
282
283
284
this->hidden->stream = SDL_NAME(arts_play_stream) (this->spec.freq,
bits,
this->spec.channels,
"SDL");
285
286
287
288
/* Play nothing so we have at least one write (server bug workaround). */
SDL_NAME(arts_write) (this->hidden->stream, "", 0);
289
/* Calculate the final parameters for this audio specification */
290
SDL_CalculateAudioSpec(&this->spec);
291
292
/* Determine the power of two of the fragment size */
293
294
295
for (frag_spec = 0; (0x01 << frag_spec) < this->spec.size; ++frag_spec);
if ((0x01 << frag_spec) != this->spec.size) {
ARTS_CloseDevice(this);
296
SDL_SetError("Fragment size must be a power of two");
297
return 0;
298
299
}
frag_spec |= 0x00020000; /* two fragments, for low latency */
300
301
#ifdef ARTS_P_PACKET_SETTINGS
302
SDL_NAME(arts_stream_set) (this->hidden->stream,
303
ARTS_P_PACKET_SETTINGS, frag_spec);
304
#else
305
SDL_NAME(arts_stream_set) (this->hidden->stream, ARTS_P_PACKET_SIZE,
306
frag_spec & 0xffff);
307
308
SDL_NAME(arts_stream_set) (this->hidden->stream, ARTS_P_PACKET_COUNT,
frag_spec >> 16);
309
#endif
310
311
this->spec.size = SDL_NAME(arts_stream_get) (this->hidden->stream,
ARTS_P_PACKET_SIZE);
312
313
/* Allocate mixing buffer */
314
315
316
317
318
319
this->hidden->mixlen = this->spec.size;
this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen);
if (this->hidden->mixbuf == NULL) {
ARTS_CloseDevice(this);
SDL_OutOfMemory();
return 0;
320
}
321
SDL_memset(this->hidden->mixbuf, this->spec.silence, this->spec.size);
322
323
/* Get the parent process id (we're the parent of the audio thread) */
324
this->hidden->parent = getpid();
325
326
/* We're ready to rock and roll. :-) */
327
return 1;
328
}
329
330
331
332
333
334
335
336
337
338
static void
ARTS_Deinitialize(void)
{
UnloadARTSLibrary();
}
static int
339
ARTS_Init(SDL_AudioDriverImpl * impl)
340
341
342
343
344
345
346
347
348
349
350
{
if (LoadARTSLibrary() < 0) {
return 0;
} else {
if (SDL_NAME(arts_init) () != 0) {
UnloadARTSLibrary();
SDL_SetError("ARTS: arts_init failed (no audio server?)");
return 0;
}
/* Play a stream so aRts doesn't crash */
351
if (SDL_NAME(arts_suspended) ()) {
352
353
354
355
356
357
arts_stream_t stream;
stream = SDL_NAME(arts_play_stream) (44100, 16, 2, "SDL");
SDL_NAME(arts_write) (stream, "", 0);
SDL_NAME(arts_close_stream) (stream);
}
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
SDL_NAME(arts_free) ();
}
/* Set the function pointers */
impl->OpenDevice = ARTS_OpenDevice;
impl->PlayDevice = ARTS_PlayDevice;
impl->WaitDevice = ARTS_WaitDevice;
impl->GetDeviceBuf = ARTS_GetDeviceBuf;
impl->CloseDevice = ARTS_CloseDevice;
impl->WaitDone = ARTS_WaitDone;
impl->Deinitialize = ARTS_Deinitialize;
impl->OnlyHasDefaultOutputDevice = 1;
return 1;
}
AudioBootStrap ARTS_bootstrap = {
ARTS_DRIVER_NAME, "Analog RealTime Synthesizer", ARTS_Init, 0
};
379
/* vi: set ts=4 sw=4 expandtab: */