1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <SDL.h>
25#include <SDL_thread.h>
26#include "qemu-common.h"
27#include "audio.h"
28
29#ifndef _WIN32
30#ifdef __sun__
31#define _POSIX_PTHREAD_SEMANTICS 1
32#elif defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
33#include <pthread.h>
34#endif
35#endif
36
37#define AUDIO_CAP "sdl"
38#include "audio_int.h"
39
40typedef struct SDLVoiceOut {
41 HWVoiceOut hw;
42 int live;
43 int rpos;
44 int decr;
45} SDLVoiceOut;
46
47static struct {
48 int nb_samples;
49} conf = {
50 .nb_samples = 1024
51};
52
53static struct SDLAudioState {
54 int exit;
55 SDL_mutex *mutex;
56 SDL_sem *sem;
57 int initialized;
58} glob_sdl;
59typedef struct SDLAudioState SDLAudioState;
60
61static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
62{
63 va_list ap;
64
65 va_start (ap, fmt);
66 AUD_vlog (AUDIO_CAP, fmt, ap);
67 va_end (ap);
68
69 AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
70}
71
72static int sdl_lock (SDLAudioState *s, const char *forfn)
73{
74 if (SDL_LockMutex (s->mutex)) {
75 sdl_logerr ("SDL_LockMutex for %s failed\n", forfn);
76 return -1;
77 }
78 return 0;
79}
80
81static int sdl_unlock (SDLAudioState *s, const char *forfn)
82{
83 if (SDL_UnlockMutex (s->mutex)) {
84 sdl_logerr ("SDL_UnlockMutex for %s failed\n", forfn);
85 return -1;
86 }
87 return 0;
88}
89
90static int sdl_post (SDLAudioState *s, const char *forfn)
91{
92 if (SDL_SemPost (s->sem)) {
93 sdl_logerr ("SDL_SemPost for %s failed\n", forfn);
94 return -1;
95 }
96 return 0;
97}
98
99static int sdl_wait (SDLAudioState *s, const char *forfn)
100{
101 if (SDL_SemWait (s->sem)) {
102 sdl_logerr ("SDL_SemWait for %s failed\n", forfn);
103 return -1;
104 }
105 return 0;
106}
107
108static int sdl_unlock_and_post (SDLAudioState *s, const char *forfn)
109{
110 if (sdl_unlock (s, forfn)) {
111 return -1;
112 }
113
114 return sdl_post (s, forfn);
115}
116
117static int aud_to_sdlfmt (audfmt_e fmt)
118{
119 switch (fmt) {
120 case AUD_FMT_S8:
121 return AUDIO_S8;
122
123 case AUD_FMT_U8:
124 return AUDIO_U8;
125
126 case AUD_FMT_S16:
127 return AUDIO_S16LSB;
128
129 case AUD_FMT_U16:
130 return AUDIO_U16LSB;
131
132 default:
133 dolog ("Internal logic error: Bad audio format %d\n", fmt);
134#ifdef DEBUG_AUDIO
135 abort ();
136#endif
137 return AUDIO_U8;
138 }
139}
140
141static int sdl_to_audfmt(int sdlfmt, audfmt_e *fmt, int *endianness)
142{
143 switch (sdlfmt) {
144 case AUDIO_S8:
145 *endianness = 0;
146 *fmt = AUD_FMT_S8;
147 break;
148
149 case AUDIO_U8:
150 *endianness = 0;
151 *fmt = AUD_FMT_U8;
152 break;
153
154 case AUDIO_S16LSB:
155 *endianness = 0;
156 *fmt = AUD_FMT_S16;
157 break;
158
159 case AUDIO_U16LSB:
160 *endianness = 0;
161 *fmt = AUD_FMT_U16;
162 break;
163
164 case AUDIO_S16MSB:
165 *endianness = 1;
166 *fmt = AUD_FMT_S16;
167 break;
168
169 case AUDIO_U16MSB:
170 *endianness = 1;
171 *fmt = AUD_FMT_U16;
172 break;
173
174 default:
175 dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
176 return -1;
177 }
178
179 return 0;
180}
181
182static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
183{
184 int status;
185#ifndef _WIN32
186 int err;
187 sigset_t new, old;
188
189
190 err = sigfillset (&new);
191 if (err) {
192 dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
193 return -1;
194 }
195 err = pthread_sigmask (SIG_BLOCK, &new, &old);
196 if (err) {
197 dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
198 return -1;
199 }
200#endif
201
202 status = SDL_OpenAudio (req, obt);
203 if (status) {
204 sdl_logerr ("SDL_OpenAudio failed\n");
205 }
206
207#ifndef _WIN32
208 err = pthread_sigmask (SIG_SETMASK, &old, NULL);
209 if (err) {
210 dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
211 strerror (errno));
212
213
214 exit (EXIT_FAILURE);
215 }
216#endif
217 return status;
218}
219
220static void sdl_close (SDLAudioState *s)
221{
222 if (s->initialized) {
223 sdl_lock (s, "sdl_close");
224 s->exit = 1;
225 sdl_unlock_and_post (s, "sdl_close");
226 SDL_PauseAudio (1);
227 SDL_CloseAudio ();
228 s->initialized = 0;
229 }
230}
231
232static void sdl_callback (void *opaque, Uint8 *buf, int len)
233{
234 SDLVoiceOut *sdl = opaque;
235 SDLAudioState *s = &glob_sdl;
236 HWVoiceOut *hw = &sdl->hw;
237 int samples = len >> hw->info.shift;
238
239 if (s->exit) {
240 return;
241 }
242
243 while (samples) {
244 int to_mix, decr;
245
246
247 sdl_wait (s, "sdl_callback");
248 if (s->exit) {
249 return;
250 }
251
252 if (sdl_lock (s, "sdl_callback")) {
253 return;
254 }
255
256 if (audio_bug (AUDIO_FUNC, sdl->live < 0 || sdl->live > hw->samples)) {
257 dolog ("sdl->live=%d hw->samples=%d\n",
258 sdl->live, hw->samples);
259 return;
260 }
261
262 if (!sdl->live) {
263 goto again;
264 }
265
266
267 to_mix = audio_MIN (samples, sdl->live);
268 decr = to_mix;
269 while (to_mix) {
270 int chunk = audio_MIN (to_mix, hw->samples - hw->rpos);
271 struct st_sample *src = hw->mix_buf + hw->rpos;
272
273
274 hw->clip (buf, src, chunk);
275 sdl->rpos = (sdl->rpos + chunk) % hw->samples;
276 to_mix -= chunk;
277 buf += chunk << hw->info.shift;
278 }
279 samples -= decr;
280 sdl->live -= decr;
281 sdl->decr += decr;
282
283 again:
284 if (sdl_unlock (s, "sdl_callback")) {
285 return;
286 }
287 }
288
289}
290
291static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
292{
293 return audio_pcm_sw_write (sw, buf, len);
294}
295
296static int sdl_run_out (HWVoiceOut *hw, int live)
297{
298 int decr;
299 SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
300 SDLAudioState *s = &glob_sdl;
301
302 if (sdl_lock (s, "sdl_run_out")) {
303 return 0;
304 }
305
306 if (sdl->decr > live) {
307 ldebug ("sdl->decr %d live %d sdl->live %d\n",
308 sdl->decr,
309 live,
310 sdl->live);
311 }
312
313 decr = audio_MIN (sdl->decr, live);
314 sdl->decr -= decr;
315
316 sdl->live = live - decr;
317 hw->rpos = sdl->rpos;
318
319 if (sdl->live > 0) {
320 sdl_unlock_and_post (s, "sdl_run_out");
321 }
322 else {
323 sdl_unlock (s, "sdl_run_out");
324 }
325 return decr;
326}
327
328static void sdl_fini_out (HWVoiceOut *hw)
329{
330 (void) hw;
331
332 sdl_close (&glob_sdl);
333}
334
335static int sdl_init_out (HWVoiceOut *hw, struct audsettings *as)
336{
337 SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
338 SDLAudioState *s = &glob_sdl;
339 SDL_AudioSpec req, obt;
340 int endianness;
341 int err;
342 audfmt_e effective_fmt;
343 struct audsettings obt_as;
344
345 req.freq = as->freq;
346 req.format = aud_to_sdlfmt (as->fmt);
347 req.channels = as->nchannels;
348 req.samples = conf.nb_samples;
349 req.callback = sdl_callback;
350 req.userdata = sdl;
351
352 if (sdl_open (&req, &obt)) {
353 return -1;
354 }
355
356 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
357 if (err) {
358 sdl_close (s);
359 return -1;
360 }
361
362 obt_as.freq = obt.freq;
363 obt_as.nchannels = obt.channels;
364 obt_as.fmt = effective_fmt;
365 obt_as.endianness = endianness;
366
367 audio_pcm_init_info (&hw->info, &obt_as);
368 hw->samples = obt.samples;
369
370 s->initialized = 1;
371 s->exit = 0;
372 SDL_PauseAudio (0);
373 return 0;
374}
375
376static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
377{
378 (void) hw;
379
380 switch (cmd) {
381 case VOICE_ENABLE:
382 SDL_PauseAudio (0);
383 break;
384
385 case VOICE_DISABLE:
386 SDL_PauseAudio (1);
387 break;
388 }
389 return 0;
390}
391
392static void *sdl_audio_init (void)
393{
394 SDLAudioState *s = &glob_sdl;
395
396 if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
397 sdl_logerr ("SDL failed to initialize audio subsystem\n");
398 return NULL;
399 }
400
401 s->mutex = SDL_CreateMutex ();
402 if (!s->mutex) {
403 sdl_logerr ("Failed to create SDL mutex\n");
404 SDL_QuitSubSystem (SDL_INIT_AUDIO);
405 return NULL;
406 }
407
408 s->sem = SDL_CreateSemaphore (0);
409 if (!s->sem) {
410 sdl_logerr ("Failed to create SDL semaphore\n");
411 SDL_DestroyMutex (s->mutex);
412 SDL_QuitSubSystem (SDL_INIT_AUDIO);
413 return NULL;
414 }
415
416 return s;
417}
418
419static void sdl_audio_fini (void *opaque)
420{
421 SDLAudioState *s = opaque;
422 sdl_close (s);
423 SDL_DestroySemaphore (s->sem);
424 SDL_DestroyMutex (s->mutex);
425 SDL_QuitSubSystem (SDL_INIT_AUDIO);
426}
427
428static struct audio_option sdl_options[] = {
429 {
430 .name = "SAMPLES",
431 .tag = AUD_OPT_INT,
432 .valp = &conf.nb_samples,
433 .descr = "Size of SDL buffer in samples"
434 },
435 { }
436};
437
438static struct audio_pcm_ops sdl_pcm_ops = {
439 .init_out = sdl_init_out,
440 .fini_out = sdl_fini_out,
441 .run_out = sdl_run_out,
442 .write = sdl_write_out,
443 .ctl_out = sdl_ctl_out,
444};
445
446struct audio_driver sdl_audio_driver = {
447 .name = "sdl",
448 .descr = "SDL http://www.libsdl.org",
449 .options = sdl_options,
450 .init = sdl_audio_init,
451 .fini = sdl_audio_fini,
452 .pcm_ops = &sdl_pcm_ops,
453 .can_be_default = 1,
454 .max_voices_out = 1,
455 .max_voices_in = 0,
456 .voice_size_out = sizeof (SDLVoiceOut),
457 .voice_size_in = 0
458};
459
