xref: /openbmc/qemu/audio/sdlaudio.c (revision d044b7c3)
1 /*
2  * QEMU SDL audio driver
3  *
4  * Copyright (c) 2004-2005 Vassili Karpov (malc)
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
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 
42 typedef struct SDLVoiceOut {
43     HWVoiceOut hw;
44     int exit;
45     int initialized;
46     Audiodev *dev;
47     SDL_AudioDeviceID devid;
48 } SDLVoiceOut;
49 
50 typedef struct SDLVoiceIn {
51     HWVoiceIn hw;
52     int exit;
53     int initialized;
54     Audiodev *dev;
55     SDL_AudioDeviceID devid;
56 } SDLVoiceIn;
57 
58 static void G_GNUC_PRINTF (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 
69 static 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     /* no unsigned 32-bit support in SDL */
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 
101 static 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 
162 static 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     /* Make sure potential threads created by SDL don't hog signals.  */
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         /* We have failed to restore original signal mask, all bets are off,
195            so exit the process */
196         exit (EXIT_FAILURE);
197     }
198 #endif
199     return devid;
200 }
201 
202 static 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 
217 static 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         /* dolog("callback_out: len=%d avail=%zu\n", len, hw->pending_emul); */
225 
226         while (hw->pending_emul && len) {
227             size_t write_len, start;
228 
229             start = audio_ring_posb(hw->pos_emul, hw->pending_emul,
230                                     hw->size_emul);
231             assert(start < hw->size_emul);
232 
233             write_len = MIN(MIN(hw->pending_emul, len),
234                             hw->size_emul - start);
235 
236             memcpy(buf, hw->buf_emul + start, write_len);
237             hw->pending_emul -= write_len;
238             len -= write_len;
239             buf += write_len;
240         }
241     }
242 
243     /* clear remaining buffer that we couldn't fill with data */
244     if (len) {
245         audio_pcm_info_clear_buf(&hw->info, buf,
246                                  len / hw->info.bytes_per_frame);
247     }
248 }
249 
250 static void sdl_close_in(SDLVoiceIn *sdl)
251 {
252     if (sdl->initialized) {
253         SDL_LockAudioDevice(sdl->devid);
254         sdl->exit = 1;
255         SDL_UnlockAudioDevice(sdl->devid);
256         SDL_PauseAudioDevice(sdl->devid, 1);
257         sdl->initialized = 0;
258     }
259     if (sdl->devid) {
260         SDL_CloseAudioDevice(sdl->devid);
261         sdl->devid = 0;
262     }
263 }
264 
265 static void sdl_callback_in(void *opaque, Uint8 *buf, int len)
266 {
267     SDLVoiceIn *sdl = opaque;
268     HWVoiceIn *hw = &sdl->hw;
269 
270     if (sdl->exit) {
271         return;
272     }
273 
274     /* dolog("callback_in: len=%d pending=%zu\n", len, hw->pending_emul); */
275 
276     while (hw->pending_emul < hw->size_emul && len) {
277         size_t read_len = MIN(len, MIN(hw->size_emul - hw->pos_emul,
278                                        hw->size_emul - hw->pending_emul));
279 
280         memcpy(hw->buf_emul + hw->pos_emul, buf, read_len);
281 
282         hw->pending_emul += read_len;
283         hw->pos_emul = (hw->pos_emul + read_len) % hw->size_emul;
284         len -= read_len;
285         buf += read_len;
286     }
287 }
288 
289 #define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, dir) \
290     static ret_type glue(sdl_, name)args_decl                  \
291     {                                                          \
292         ret_type ret;                                          \
293         glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw;  \
294                                                                \
295         SDL_LockAudioDevice(sdl->devid);                       \
296         ret = glue(audio_generic_, name)args;                  \
297         SDL_UnlockAudioDevice(sdl->devid);                     \
298                                                                \
299         return ret;                                            \
300     }
301 
302 #define SDL_WRAPPER_VOID_FUNC(name, args_decl, args, dir)      \
303     static void glue(sdl_, name)args_decl                      \
304     {                                                          \
305         glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw;  \
306                                                                \
307         SDL_LockAudioDevice(sdl->devid);                       \
308         glue(audio_generic_, name)args;                        \
309         SDL_UnlockAudioDevice(sdl->devid);                     \
310     }
311 
312 SDL_WRAPPER_FUNC(buffer_get_free, size_t, (HWVoiceOut *hw), (hw), Out)
313 SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
314                  (hw, size), Out)
315 SDL_WRAPPER_FUNC(put_buffer_out, size_t,
316                  (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
317 SDL_WRAPPER_FUNC(write, size_t,
318                  (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
319 SDL_WRAPPER_FUNC(read, size_t, (HWVoiceIn *hw, void *buf, size_t size),
320                  (hw, buf, size), In)
321 SDL_WRAPPER_FUNC(get_buffer_in, void *, (HWVoiceIn *hw, size_t *size),
322                  (hw, size), In)
323 SDL_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 
328 static void sdl_fini_out(HWVoiceOut *hw)
329 {
330     SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
331 
332     sdl_close_out(sdl);
333 }
334 
335 static 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     /* SDL samples are QEMU frames */
351     req.samples = audio_buffer_frames(
352         qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
353     req.callback = sdl_callback_out;
354     req.userdata = sdl;
355 
356     sdl->dev = dev;
357     sdl->devid = sdl_open(&req, &obt, 0);
358     if (!sdl->devid) {
359         return -1;
360     }
361 
362     err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
363     if (err) {
364         sdl_close_out(sdl);
365         return -1;
366     }
367 
368     obt_as.freq = obt.freq;
369     obt_as.nchannels = obt.channels;
370     obt_as.fmt = effective_fmt;
371     obt_as.endianness = endianness;
372 
373     audio_pcm_init_info (&hw->info, &obt_as);
374     hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
375         obt.samples;
376 
377     sdl->initialized = 1;
378     sdl->exit = 0;
379     return 0;
380 }
381 
382 static void sdl_enable_out(HWVoiceOut *hw, bool enable)
383 {
384     SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
385 
386     SDL_PauseAudioDevice(sdl->devid, !enable);
387 }
388 
389 static void sdl_fini_in(HWVoiceIn *hw)
390 {
391     SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
392 
393     sdl_close_in(sdl);
394 }
395 
396 static int sdl_init_in(HWVoiceIn *hw, audsettings *as, void *drv_opaque)
397 {
398     SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
399     SDL_AudioSpec req, obt;
400     int endianness;
401     int err;
402     AudioFormat effective_fmt;
403     Audiodev *dev = drv_opaque;
404     AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.in;
405     struct audsettings obt_as;
406 
407     req.freq = as->freq;
408     req.format = aud_to_sdlfmt(as->fmt);
409     req.channels = as->nchannels;
410     /* SDL samples are QEMU frames */
411     req.samples = audio_buffer_frames(
412         qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
413     req.callback = sdl_callback_in;
414     req.userdata = sdl;
415 
416     sdl->dev = dev;
417     sdl->devid = sdl_open(&req, &obt, 1);
418     if (!sdl->devid) {
419         return -1;
420     }
421 
422     err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
423     if (err) {
424         sdl_close_in(sdl);
425         return -1;
426     }
427 
428     obt_as.freq = obt.freq;
429     obt_as.nchannels = obt.channels;
430     obt_as.fmt = effective_fmt;
431     obt_as.endianness = endianness;
432 
433     audio_pcm_init_info(&hw->info, &obt_as);
434     hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
435         obt.samples;
436     hw->size_emul = hw->samples * hw->info.bytes_per_frame;
437     hw->buf_emul = g_malloc(hw->size_emul);
438     hw->pos_emul = hw->pending_emul = 0;
439 
440     sdl->initialized = 1;
441     sdl->exit = 0;
442     return 0;
443 }
444 
445 static void sdl_enable_in(HWVoiceIn *hw, bool enable)
446 {
447     SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
448 
449     SDL_PauseAudioDevice(sdl->devid, !enable);
450 }
451 
452 static void *sdl_audio_init(Audiodev *dev)
453 {
454     if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
455         sdl_logerr ("SDL failed to initialize audio subsystem\n");
456         return NULL;
457     }
458 
459     return dev;
460 }
461 
462 static void sdl_audio_fini (void *opaque)
463 {
464     SDL_QuitSubSystem (SDL_INIT_AUDIO);
465 }
466 
467 static struct audio_pcm_ops sdl_pcm_ops = {
468     .init_out = sdl_init_out,
469     .fini_out = sdl_fini_out,
470   /* wrapper for audio_generic_write */
471     .write    = sdl_write,
472   /* wrapper for audio_generic_buffer_get_free */
473     .buffer_get_free = sdl_buffer_get_free,
474   /* wrapper for audio_generic_get_buffer_out */
475     .get_buffer_out = sdl_get_buffer_out,
476   /* wrapper for audio_generic_put_buffer_out */
477     .put_buffer_out = sdl_put_buffer_out,
478     .enable_out = sdl_enable_out,
479     .init_in = sdl_init_in,
480     .fini_in = sdl_fini_in,
481   /* wrapper for audio_generic_read */
482     .read = sdl_read,
483   /* wrapper for audio_generic_get_buffer_in */
484     .get_buffer_in = sdl_get_buffer_in,
485   /* wrapper for audio_generic_put_buffer_in */
486     .put_buffer_in = sdl_put_buffer_in,
487     .enable_in = sdl_enable_in,
488 };
489 
490 static struct audio_driver sdl_audio_driver = {
491     .name           = "sdl",
492     .descr          = "SDL http://www.libsdl.org",
493     .init           = sdl_audio_init,
494     .fini           = sdl_audio_fini,
495     .pcm_ops        = &sdl_pcm_ops,
496     .can_be_default = 1,
497     .max_voices_out = INT_MAX,
498     .max_voices_in  = INT_MAX,
499     .voice_size_out = sizeof(SDLVoiceOut),
500     .voice_size_in  = sizeof(SDLVoiceIn),
501 };
502 
503 static void register_audio_sdl(void)
504 {
505     audio_driver_register(&sdl_audio_driver);
506 }
507 type_init(register_audio_sdl);
508