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