1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include <SDL.h>
27#include <SDL_thread.h>
28#include "qemu/module.h"
29#include "audio.h"
30
31#ifndef _WIN32
32#ifdef __sun__
33#define _POSIX_PTHREAD_SEMANTICS 1
34#elif defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
35#include <pthread.h>
36#endif
37#endif
38
39#define AUDIO_CAP "sdl"
40#include "audio_int.h"
41
42typedef struct SDLVoiceOut {
43 HWVoiceOut hw;
44 int exit;
45 int initialized;
46 Audiodev *dev;
47 SDL_AudioDeviceID devid;
48} SDLVoiceOut;
49
50typedef struct SDLVoiceIn {
51 HWVoiceIn hw;
52 int exit;
53 int initialized;
54 Audiodev *dev;
55 SDL_AudioDeviceID devid;
56} SDLVoiceIn;
57
58static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
59{
60 va_list ap;
61
62 va_start (ap, fmt);
63 AUD_vlog (AUDIO_CAP, fmt, ap);
64 va_end (ap);
65
66 AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
67}
68
69static int aud_to_sdlfmt (AudioFormat fmt)
70{
71 switch (fmt) {
72 case AUDIO_FORMAT_S8:
73 return AUDIO_S8;
74
75 case AUDIO_FORMAT_U8:
76 return AUDIO_U8;
77
78 case AUDIO_FORMAT_S16:
79 return AUDIO_S16LSB;
80
81 case AUDIO_FORMAT_U16:
82 return AUDIO_U16LSB;
83
84 case AUDIO_FORMAT_S32:
85 return AUDIO_S32LSB;
86
87
88
89 case AUDIO_FORMAT_F32:
90 return AUDIO_F32LSB;
91
92 default:
93 dolog ("Internal logic error: Bad audio format %d\n", fmt);
94#ifdef DEBUG_AUDIO
95 abort ();
96#endif
97 return AUDIO_U8;
98 }
99}
100
101static int sdl_to_audfmt(int sdlfmt, AudioFormat *fmt, int *endianness)
102{
103 switch (sdlfmt) {
104 case AUDIO_S8:
105 *endianness = 0;
106 *fmt = AUDIO_FORMAT_S8;
107 break;
108
109 case AUDIO_U8:
110 *endianness = 0;
111 *fmt = AUDIO_FORMAT_U8;
112 break;
113
114 case AUDIO_S16LSB:
115 *endianness = 0;
116 *fmt = AUDIO_FORMAT_S16;
117 break;
118
119 case AUDIO_U16LSB:
120 *endianness = 0;
121 *fmt = AUDIO_FORMAT_U16;
122 break;
123
124 case AUDIO_S16MSB:
125 *endianness = 1;
126 *fmt = AUDIO_FORMAT_S16;
127 break;
128
129 case AUDIO_U16MSB:
130 *endianness = 1;
131 *fmt = AUDIO_FORMAT_U16;
132 break;
133
134 case AUDIO_S32LSB:
135 *endianness = 0;
136 *fmt = AUDIO_FORMAT_S32;
137 break;
138
139 case AUDIO_S32MSB:
140 *endianness = 1;
141 *fmt = AUDIO_FORMAT_S32;
142 break;
143
144 case AUDIO_F32LSB:
145 *endianness = 0;
146 *fmt = AUDIO_FORMAT_F32;
147 break;
148
149 case AUDIO_F32MSB:
150 *endianness = 1;
151 *fmt = AUDIO_FORMAT_F32;
152 break;
153
154 default:
155 dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
156 return -1;
157 }
158
159 return 0;
160}
161
162static SDL_AudioDeviceID sdl_open(SDL_AudioSpec *req, SDL_AudioSpec *obt,
163 int rec)
164{
165 SDL_AudioDeviceID devid;
166#ifndef _WIN32
167 int err;
168 sigset_t new, old;
169
170
171 err = sigfillset (&new);
172 if (err) {
173 dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
174 return 0;
175 }
176 err = pthread_sigmask (SIG_BLOCK, &new, &old);
177 if (err) {
178 dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
179 return 0;
180 }
181#endif
182
183 devid = SDL_OpenAudioDevice(NULL, rec, req, obt, 0);
184 if (!devid) {
185 sdl_logerr("SDL_OpenAudioDevice for %s failed\n",
186 rec ? "recording" : "playback");
187 }
188
189#ifndef _WIN32
190 err = pthread_sigmask (SIG_SETMASK, &old, NULL);
191 if (err) {
192 dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
193 strerror (errno));
194
195
196 exit (EXIT_FAILURE);
197 }
198#endif
199 return devid;
200}
201
202static void sdl_close_out(SDLVoiceOut *sdl)
203{
204 if (sdl->initialized) {
205 SDL_LockAudioDevice(sdl->devid);
206 sdl->exit = 1;
207 SDL_UnlockAudioDevice(sdl->devid);
208 SDL_PauseAudioDevice(sdl->devid, 1);
209 sdl->initialized = 0;
210 }
211 if (sdl->devid) {
212 SDL_CloseAudioDevice(sdl->devid);
213 sdl->devid = 0;
214 }
215}
216
217static void sdl_callback_out(void *opaque, Uint8 *buf, int len)
218{
219 SDLVoiceOut *sdl = opaque;
220 HWVoiceOut *hw = &sdl->hw;
221
222 if (!sdl->exit) {
223
224
225
226 while (hw->pending_emul && len) {
227 size_t write_len;
228 ssize_t start = (ssize_t)hw->pos_emul - hw->pending_emul;
229 if (start < 0) {
230 start += hw->size_emul;
231 }
232 assert(start >= 0 && start < hw->size_emul);
233
234 write_len = MIN(MIN(hw->pending_emul, len),
235 hw->size_emul - start);
236
237 memcpy(buf, hw->buf_emul + start, write_len);
238 hw->pending_emul -= write_len;
239 len -= write_len;
240 buf += write_len;
241 }
242 }
243
244
245 if (len) {
246 audio_pcm_info_clear_buf(&hw->info, buf,
247 len / hw->info.bytes_per_frame);
248 }
249}
250
251static void sdl_close_in(SDLVoiceIn *sdl)
252{
253 if (sdl->initialized) {
254 SDL_LockAudioDevice(sdl->devid);
255 sdl->exit = 1;
256 SDL_UnlockAudioDevice(sdl->devid);
257 SDL_PauseAudioDevice(sdl->devid, 1);
258 sdl->initialized = 0;
259 }
260 if (sdl->devid) {
261 SDL_CloseAudioDevice(sdl->devid);
262 sdl->devid = 0;
263 }
264}
265
266static void sdl_callback_in(void *opaque, Uint8 *buf, int len)
267{
268 SDLVoiceIn *sdl = opaque;
269 HWVoiceIn *hw = &sdl->hw;
270
271 if (sdl->exit) {
272 return;
273 }
274
275
276
277 while (hw->pending_emul < hw->size_emul && len) {
278 size_t read_len = MIN(len, MIN(hw->size_emul - hw->pos_emul,
279 hw->size_emul - hw->pending_emul));
280
281 memcpy(hw->buf_emul + hw->pos_emul, buf, read_len);
282
283 hw->pending_emul += read_len;
284 hw->pos_emul = (hw->pos_emul + read_len) % hw->size_emul;
285 len -= read_len;
286 buf += read_len;
287 }
288}
289
290#define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, dir) \
291 static ret_type glue(sdl_, name)args_decl \
292 { \
293 ret_type ret; \
294 glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
295 \
296 SDL_LockAudioDevice(sdl->devid); \
297 ret = glue(audio_generic_, name)args; \
298 SDL_UnlockAudioDevice(sdl->devid); \
299 \
300 return ret; \
301 }
302
303#define SDL_WRAPPER_VOID_FUNC(name, args_decl, args, dir) \
304 static void glue(sdl_, name)args_decl \
305 { \
306 glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
307 \
308 SDL_LockAudioDevice(sdl->devid); \
309 glue(audio_generic_, name)args; \
310 SDL_UnlockAudioDevice(sdl->devid); \
311 }
312
313SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
314 (hw, size), Out)
315SDL_WRAPPER_FUNC(put_buffer_out, size_t,
316 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
317SDL_WRAPPER_FUNC(write, size_t,
318 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
319SDL_WRAPPER_FUNC(read, size_t, (HWVoiceIn *hw, void *buf, size_t size),
320 (hw, buf, size), In)
321SDL_WRAPPER_FUNC(get_buffer_in, void *, (HWVoiceIn *hw, size_t *size),
322 (hw, size), In)
323SDL_WRAPPER_VOID_FUNC(put_buffer_in, (HWVoiceIn *hw, void *buf, size_t size),
324 (hw, buf, size), In)
325#undef SDL_WRAPPER_FUNC
326#undef SDL_WRAPPER_VOID_FUNC
327
328static void sdl_fini_out(HWVoiceOut *hw)
329{
330 SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
331
332 sdl_close_out(sdl);
333}
334
335static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
336 void *drv_opaque)
337{
338 SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
339 SDL_AudioSpec req, obt;
340 int endianness;
341 int err;
342 AudioFormat effective_fmt;
343 Audiodev *dev = drv_opaque;
344 AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.out;
345 struct audsettings obt_as;
346
347 req.freq = as->freq;
348 req.format = aud_to_sdlfmt (as->fmt);
349 req.channels = as->nchannels;
350
351
352
353
354 req.samples = audio_buffer_samples(
355 qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
356 req.callback = sdl_callback_out;
357 req.userdata = sdl;
358
359 sdl->dev = dev;
360 sdl->devid = sdl_open(&req, &obt, 0);
361 if (!sdl->devid) {
362 return -1;
363 }
364
365 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
366 if (err) {
367 sdl_close_out(sdl);
368 return -1;
369 }
370
371 obt_as.freq = obt.freq;
372 obt_as.nchannels = obt.channels;
373 obt_as.fmt = effective_fmt;
374 obt_as.endianness = endianness;
375
376 audio_pcm_init_info (&hw->info, &obt_as);
377 hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
378 obt.samples;
379
380 sdl->initialized = 1;
381 sdl->exit = 0;
382 return 0;
383}
384
385static void sdl_enable_out(HWVoiceOut *hw, bool enable)
386{
387 SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
388
389 SDL_PauseAudioDevice(sdl->devid, !enable);
390}
391
392static void sdl_fini_in(HWVoiceIn *hw)
393{
394 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
395
396 sdl_close_in(sdl);
397}
398
399static int sdl_init_in(HWVoiceIn *hw, audsettings *as, void *drv_opaque)
400{
401 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
402 SDL_AudioSpec req, obt;
403 int endianness;
404 int err;
405 AudioFormat effective_fmt;
406 Audiodev *dev = drv_opaque;
407 AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.in;
408 struct audsettings obt_as;
409
410 req.freq = as->freq;
411 req.format = aud_to_sdlfmt(as->fmt);
412 req.channels = as->nchannels;
413
414 req.samples = audio_buffer_frames(
415 qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
416 req.callback = sdl_callback_in;
417 req.userdata = sdl;
418
419 sdl->dev = dev;
420 sdl->devid = sdl_open(&req, &obt, 1);
421 if (!sdl->devid) {
422 return -1;
423 }
424
425 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
426 if (err) {
427 sdl_close_in(sdl);
428 return -1;
429 }
430
431 obt_as.freq = obt.freq;
432 obt_as.nchannels = obt.channels;
433 obt_as.fmt = effective_fmt;
434 obt_as.endianness = endianness;
435
436 audio_pcm_init_info(&hw->info, &obt_as);
437 hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
438 obt.samples;
439 hw->size_emul = hw->samples * hw->info.bytes_per_frame;
440 hw->buf_emul = g_malloc(hw->size_emul);
441 hw->pos_emul = hw->pending_emul = 0;
442
443 sdl->initialized = 1;
444 sdl->exit = 0;
445 return 0;
446}
447
448static void sdl_enable_in(HWVoiceIn *hw, bool enable)
449{
450 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
451
452 SDL_PauseAudioDevice(sdl->devid, !enable);
453}
454
455static void *sdl_audio_init(Audiodev *dev)
456{
457 if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
458 sdl_logerr ("SDL failed to initialize audio subsystem\n");
459 return NULL;
460 }
461
462 return dev;
463}
464
465static void sdl_audio_fini (void *opaque)
466{
467 SDL_QuitSubSystem (SDL_INIT_AUDIO);
468}
469
470static struct audio_pcm_ops sdl_pcm_ops = {
471 .init_out = sdl_init_out,
472 .fini_out = sdl_fini_out,
473
474 .write = sdl_write,
475
476 .get_buffer_out = sdl_get_buffer_out,
477
478 .put_buffer_out = sdl_put_buffer_out,
479 .enable_out = sdl_enable_out,
480 .init_in = sdl_init_in,
481 .fini_in = sdl_fini_in,
482
483 .read = sdl_read,
484
485 .get_buffer_in = sdl_get_buffer_in,
486
487 .put_buffer_in = sdl_put_buffer_in,
488 .enable_in = sdl_enable_in,
489};
490
491static struct audio_driver sdl_audio_driver = {
492 .name = "sdl",
493 .descr = "SDL http://www.libsdl.org",
494 .init = sdl_audio_init,
495 .fini = sdl_audio_fini,
496 .pcm_ops = &sdl_pcm_ops,
497 .can_be_default = 1,
498 .max_voices_out = INT_MAX,
499 .max_voices_in = INT_MAX,
500 .voice_size_out = sizeof(SDLVoiceOut),
501 .voice_size_in = sizeof(SDLVoiceIn),
502};
503
504static void register_audio_sdl(void)
505{
506 audio_driver_register(&sdl_audio_driver);
507}
508type_init(register_audio_sdl);
509