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