/
SDL_artsaudio.c
362 lines (308 loc) · 9.05 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2012 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
30
#ifdef HAVE_SIGNAL_H
#include <signal.h>
#endif
#include <unistd.h>
31
#include "SDL_timer.h"
32
#include "SDL_audio.h"
33
34
35
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "../SDL_audiodev_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
/* Audio driver functions */
49
50
51
52
53
static int ARTS_OpenAudio(_THIS, SDL_AudioSpec *spec);
static void ARTS_WaitAudio(_THIS);
static void ARTS_PlayAudio(_THIS);
static Uint8 *ARTS_GetAudioBuf(_THIS);
static void ARTS_CloseAudio(_THIS);
54
55
#ifdef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
56
57
static const char *arts_library = SDL_AUDIO_DRIVER_ARTS_DYNAMIC;
58
59
60
static void *arts_handle = NULL;
static int arts_loaded = 0;
61
62
63
64
65
66
67
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);
68
static int (*SDL_NAME(arts_suspend))(void);
69
70
static int (*SDL_NAME(arts_suspended))(void);
static const char *(*SDL_NAME(arts_error_text))(int errorcode);
71
72
73
74
75
76
77
78
79
80
81
82
static struct {
const char *name;
void **func;
} arts_functions[] = {
{ "arts_init", (void **)&SDL_NAME(arts_init) },
{ "arts_free", (void **)&SDL_NAME(arts_free) },
{ "arts_play_stream", (void **)&SDL_NAME(arts_play_stream) },
{ "arts_stream_set", (void **)&SDL_NAME(arts_stream_set) },
{ "arts_stream_get", (void **)&SDL_NAME(arts_stream_get) },
{ "arts_write", (void **)&SDL_NAME(arts_write) },
{ "arts_close_stream", (void **)&SDL_NAME(arts_close_stream) },
83
{ "arts_suspend", (void **)&SDL_NAME(arts_suspend) },
84
85
{ "arts_suspended", (void **)&SDL_NAME(arts_suspended) },
{ "arts_error_text", (void **)&SDL_NAME(arts_error_text) },
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
};
static void UnloadARTSLibrary()
{
if ( arts_loaded ) {
SDL_UnloadObject(arts_handle);
arts_handle = NULL;
arts_loaded = 0;
}
}
static int LoadARTSLibrary(void)
{
int i, retval = -1;
arts_handle = SDL_LoadObject(arts_library);
if ( arts_handle ) {
arts_loaded = 1;
retval = 0;
105
for ( i=0; i<SDL_arraysize(arts_functions); ++i ) {
106
*arts_functions[i].func = SDL_LoadFunction(arts_handle, arts_functions[i].name);
107
if ( !*arts_functions[i].func ) {
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
retval = -1;
UnloadARTSLibrary();
break;
}
}
}
return retval;
}
#else
static void UnloadARTSLibrary()
{
return;
}
static int LoadARTSLibrary(void)
{
return 0;
}
129
#endif /* SDL_AUDIO_DRIVER_ARTS_DYNAMIC */
130
131
132
/* Audio driver bootstrap functions */
133
134
135
136
137
138
139
140
141
142
143
144
static int ARTS_Suspend(void)
{
const Uint32 abortms = SDL_GetTicks() + 3000; /* give up after 3 secs */
while ( (!SDL_NAME(arts_suspended)()) && (SDL_GetTicks() < abortms) ) {
if ( SDL_NAME(arts_suspend)() ) {
break;
}
}
return SDL_NAME(arts_suspended)();
}
145
146
static int Audio_Available(void)
{
147
148
149
150
151
152
int available = 0;
if ( LoadARTSLibrary() < 0 ) {
return available;
}
if ( SDL_NAME(arts_init)() == 0 ) {
153
if ( ARTS_Suspend() ) {
154
155
156
157
158
159
160
/* Play a stream so aRts doesn't crash */
arts_stream_t stream2;
stream2=SDL_NAME(arts_play_stream)(44100, 16, 2, "SDL");
SDL_NAME(arts_write)(stream2, "", 0);
SDL_NAME(arts_close_stream)(stream2);
available = 1;
}
161
162
163
SDL_NAME(arts_free)();
}
UnloadARTSLibrary();
164
165
return available;
166
167
168
169
}
static void Audio_DeleteDevice(SDL_AudioDevice *device)
{
170
171
SDL_free(device->hidden);
SDL_free(device);
172
UnloadARTSLibrary();
173
174
175
176
177
178
179
}
static SDL_AudioDevice *Audio_CreateDevice(int devindex)
{
SDL_AudioDevice *this;
/* Initialize all variables that we clean on shutdown */
180
LoadARTSLibrary();
181
this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
182
if ( this ) {
183
SDL_memset(this, 0, (sizeof *this));
184
this->hidden = (struct SDL_PrivateAudioData *)
185
SDL_malloc((sizeof *this->hidden));
186
187
188
189
}
if ( (this == NULL) || (this->hidden == NULL) ) {
SDL_OutOfMemory();
if ( this ) {
190
SDL_free(this);
191
192
193
}
return(0);
}
194
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
195
196
197
stream = 0;
/* Set the function pointers */
198
199
200
201
202
this->OpenAudio = ARTS_OpenAudio;
this->WaitAudio = ARTS_WaitAudio;
this->PlayAudio = ARTS_PlayAudio;
this->GetAudioBuf = ARTS_GetAudioBuf;
this->CloseAudio = ARTS_CloseAudio;
203
204
205
206
207
208
this->free = Audio_DeleteDevice;
return this;
}
209
210
AudioBootStrap ARTS_bootstrap = {
ARTS_DRIVER_NAME, "Analog Realtime Synthesizer",
211
212
213
214
Audio_Available, Audio_CreateDevice
};
/* This function waits until it is possible to write a full sound buffer */
215
static void ARTS_WaitAudio(_THIS)
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
{
Sint32 ticks;
/* Check to see if the thread-parent process is still alive */
{ static int cnt = 0;
/* Note that this only works with thread implementations
that use a different process id for each thread.
*/
if (parent && (((++cnt)%10) == 0)) { /* Check every 10 loops */
if ( kill(parent, 0) < 0 ) {
this->enabled = 0;
}
}
}
/* Use timer for general audio synchronization */
ticks = ((Sint32)(next_frame - SDL_GetTicks()))-FUDGE_TICKS;
if ( ticks > 0 ) {
SDL_Delay(ticks);
}
}
238
static void ARTS_PlayAudio(_THIS)
239
240
241
242
{
int written;
/* Write the audio data */
243
written = SDL_NAME(arts_write)(stream, mixbuf, mixlen);
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
/* If timer synchronization is enabled, set the next write frame */
if ( frame_ticks ) {
next_frame += frame_ticks;
}
/* If we couldn't write, assume fatal error for now */
if ( written < 0 ) {
this->enabled = 0;
}
#ifdef DEBUG_AUDIO
fprintf(stderr, "Wrote %d bytes of audio data\n", written);
#endif
}
259
static Uint8 *ARTS_GetAudioBuf(_THIS)
260
261
262
263
{
return(mixbuf);
}
264
static void ARTS_CloseAudio(_THIS)
265
266
267
268
269
270
{
if ( mixbuf != NULL ) {
SDL_FreeAudioMem(mixbuf);
mixbuf = NULL;
}
if ( stream ) {
271
SDL_NAME(arts_close_stream)(stream);
272
273
stream = 0;
}
274
SDL_NAME(arts_free)();
275
276
}
277
static int ARTS_OpenAudio(_THIS, SDL_AudioSpec *spec)
278
279
280
{
int bits, frag_spec;
Uint16 test_format, format;
281
int error_code;
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
/* Reset the timer synchronization flag */
frame_ticks = 0.0;
mixbuf = NULL;
/* Try for a closest match on audio format */
format = 0;
bits = 0;
for ( test_format = SDL_FirstAudioFormat(spec->format);
! format && test_format; ) {
#ifdef DEBUG_AUDIO
fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
#endif
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 ) {
SDL_SetError("Couldn't find any hardware audio formats");
return(-1);
}
spec->format = test_format;
319
320
321
322
323
error_code = SDL_NAME(arts_init)();
if ( error_code != 0 ) {
SDL_SetError("Unable to initialize ARTS: %s", SDL_NAME(arts_error_text)(error_code));
return(-1);
}
324
if ( ! ARTS_Suspend() ) {
325
SDL_SetError("ARTS can not open audio device");
326
327
328
return(-1);
}
stream = SDL_NAME(arts_play_stream)(spec->freq, bits, spec->channels, "SDL");
329
330
331
332
333
334
335
336
337
338
339
340
341
/* Calculate the final parameters for this audio specification */
SDL_CalculateAudioSpec(spec);
/* Determine the power of two of the fragment size */
for ( frag_spec = 0; (0x01<<frag_spec) < spec->size; ++frag_spec );
if ( (0x01<<frag_spec) != spec->size ) {
SDL_SetError("Fragment size must be a power of two");
return(-1);
}
frag_spec |= 0x00020000; /* two fragments, for low latency */
#ifdef ARTS_P_PACKET_SETTINGS
342
SDL_NAME(arts_stream_set)(stream, ARTS_P_PACKET_SETTINGS, frag_spec);
343
#else
344
345
SDL_NAME(arts_stream_set)(stream, ARTS_P_PACKET_SIZE, frag_spec&0xffff);
SDL_NAME(arts_stream_set)(stream, ARTS_P_PACKET_COUNT, frag_spec>>16);
346
#endif
347
spec->size = SDL_NAME(arts_stream_get)(stream, ARTS_P_PACKET_SIZE);
348
349
350
351
352
353
354
/* Allocate mixing buffer */
mixlen = spec->size;
mixbuf = (Uint8 *)SDL_AllocAudioMem(mixlen);
if ( mixbuf == NULL ) {
return(-1);
}
355
SDL_memset(mixbuf, spec->silence, spec->size);
356
357
358
359
360
361
362
/* Get the parent process id (we're the parent of the audio thread) */
parent = getpid();
/* We're ready to rock and roll. :-) */
return(0);
}