xref: /openbmc/qemu/audio/sdlaudio.c (revision fa59483d) 
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 #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 typedef struct SDLVoiceOut {
42     HWVoiceOut hw;
43     int live;
44     int decr;
45 } SDLVoiceOut;
46 
47 static struct {
48     int nb_samples;
49 } conf = {
50     .nb_samples = 1024
51 };
52 
53 static struct SDLAudioState {
54     int exit;
55     int initialized;
56     bool driver_created;
57 } glob_sdl;
58 typedef struct SDLAudioState SDLAudioState;
59 
60 static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
61 {
62     va_list ap;
63 
64     va_start (ap, fmt);
65     AUD_vlog (AUDIO_CAP, fmt, ap);
66     va_end (ap);
67 
68     AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
69 }
70 
71 static int aud_to_sdlfmt (audfmt_e fmt)
72 {
73     switch (fmt) {
74     case AUD_FMT_S8:
75         return AUDIO_S8;
76 
77     case AUD_FMT_U8:
78         return AUDIO_U8;
79 
80     case AUD_FMT_S16:
81         return AUDIO_S16LSB;
82 
83     case AUD_FMT_U16:
84         return AUDIO_U16LSB;
85 
86     default:
87         dolog ("Internal logic error: Bad audio format %d\n", fmt);
88 #ifdef DEBUG_AUDIO
89         abort ();
90 #endif
91         return AUDIO_U8;
92     }
93 }
94 
95 static int sdl_to_audfmt(int sdlfmt, audfmt_e *fmt, int *endianness)
96 {
97     switch (sdlfmt) {
98     case AUDIO_S8:
99         *endianness = 0;
100         *fmt = AUD_FMT_S8;
101         break;
102 
103     case AUDIO_U8:
104         *endianness = 0;
105         *fmt = AUD_FMT_U8;
106         break;
107 
108     case AUDIO_S16LSB:
109         *endianness = 0;
110         *fmt = AUD_FMT_S16;
111         break;
112 
113     case AUDIO_U16LSB:
114         *endianness = 0;
115         *fmt = AUD_FMT_U16;
116         break;
117 
118     case AUDIO_S16MSB:
119         *endianness = 1;
120         *fmt = AUD_FMT_S16;
121         break;
122 
123     case AUDIO_U16MSB:
124         *endianness = 1;
125         *fmt = AUD_FMT_U16;
126         break;
127 
128     default:
129         dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
130         return -1;
131     }
132 
133     return 0;
134 }
135 
136 static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
137 {
138     int status;
139 #ifndef _WIN32
140     int err;
141     sigset_t new, old;
142 
143     /* Make sure potential threads created by SDL don't hog signals.  */
144     err = sigfillset (&new);
145     if (err) {
146         dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
147         return -1;
148     }
149     err = pthread_sigmask (SIG_BLOCK, &new, &old);
150     if (err) {
151         dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
152         return -1;
153     }
154 #endif
155 
156     status = SDL_OpenAudio (req, obt);
157     if (status) {
158         sdl_logerr ("SDL_OpenAudio failed\n");
159     }
160 
161 #ifndef _WIN32
162     err = pthread_sigmask (SIG_SETMASK, &old, NULL);
163     if (err) {
164         dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
165                strerror (errno));
166         /* We have failed to restore original signal mask, all bets are off,
167            so exit the process */
168         exit (EXIT_FAILURE);
169     }
170 #endif
171     return status;
172 }
173 
174 static void sdl_close (SDLAudioState *s)
175 {
176     if (s->initialized) {
177         SDL_LockAudio();
178         s->exit = 1;
179         SDL_UnlockAudio();
180         SDL_PauseAudio (1);
181         SDL_CloseAudio ();
182         s->initialized = 0;
183     }
184 }
185 
186 static void sdl_callback (void *opaque, Uint8 *buf, int len)
187 {
188     SDLVoiceOut *sdl = opaque;
189     SDLAudioState *s = &glob_sdl;
190     HWVoiceOut *hw = &sdl->hw;
191     int samples = len >> hw->info.shift;
192     int to_mix, decr;
193 
194     if (s->exit || !sdl->live) {
195         return;
196     }
197 
198     /* dolog ("in callback samples=%d live=%d\n", samples, sdl->live); */
199 
200     to_mix = audio_MIN(samples, sdl->live);
201     decr = to_mix;
202     while (to_mix) {
203         int chunk = audio_MIN(to_mix, hw->samples - hw->rpos);
204         struct st_sample *src = hw->mix_buf + hw->rpos;
205 
206         /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
207         hw->clip(buf, src, chunk);
208         hw->rpos = (hw->rpos + chunk) % hw->samples;
209         to_mix -= chunk;
210         buf += chunk << hw->info.shift;
211     }
212     samples -= decr;
213     sdl->live -= decr;
214     sdl->decr += decr;
215 
216     /* dolog ("done len=%d\n", len); */
217 
218     /* SDL2 does not clear the remaining buffer for us, so do it on our own */
219     if (samples) {
220         memset(buf, 0, samples << hw->info.shift);
221     }
222 }
223 
224 static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
225 {
226     return audio_pcm_sw_write (sw, buf, len);
227 }
228 
229 static int sdl_run_out (HWVoiceOut *hw, int live)
230 {
231     int decr;
232     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
233 
234     SDL_LockAudio();
235 
236     if (sdl->decr > live) {
237         ldebug ("sdl->decr %d live %d sdl->live %d\n",
238                 sdl->decr,
239                 live,
240                 sdl->live);
241     }
242 
243     decr = audio_MIN (sdl->decr, live);
244     sdl->decr -= decr;
245 
246     sdl->live = live;
247 
248     SDL_UnlockAudio();
249 
250     return decr;
251 }
252 
253 static void sdl_fini_out (HWVoiceOut *hw)
254 {
255     (void) hw;
256 
257     sdl_close (&glob_sdl);
258 }
259 
260 static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
261                         void *drv_opaque)
262 {
263     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
264     SDLAudioState *s = &glob_sdl;
265     SDL_AudioSpec req, obt;
266     int endianness;
267     int err;
268     audfmt_e effective_fmt;
269     struct audsettings obt_as;
270 
271     req.freq = as->freq;
272     req.format = aud_to_sdlfmt (as->fmt);
273     req.channels = as->nchannels;
274     req.samples = conf.nb_samples;
275     req.callback = sdl_callback;
276     req.userdata = sdl;
277 
278     if (sdl_open (&req, &obt)) {
279         return -1;
280     }
281 
282     err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
283     if (err) {
284         sdl_close (s);
285         return -1;
286     }
287 
288     obt_as.freq = obt.freq;
289     obt_as.nchannels = obt.channels;
290     obt_as.fmt = effective_fmt;
291     obt_as.endianness = endianness;
292 
293     audio_pcm_init_info (&hw->info, &obt_as);
294     hw->samples = obt.samples;
295 
296     s->initialized = 1;
297     s->exit = 0;
298     SDL_PauseAudio (0);
299     return 0;
300 }
301 
302 static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
303 {
304     (void) hw;
305 
306     switch (cmd) {
307     case VOICE_ENABLE:
308         SDL_PauseAudio (0);
309         break;
310 
311     case VOICE_DISABLE:
312         SDL_PauseAudio (1);
313         break;
314     }
315     return 0;
316 }
317 
318 static void *sdl_audio_init (void)
319 {
320     SDLAudioState *s = &glob_sdl;
321     if (s->driver_created) {
322         sdl_logerr("Can't create multiple sdl backends\n");
323         return NULL;
324     }
325 
326     if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
327         sdl_logerr ("SDL failed to initialize audio subsystem\n");
328         return NULL;
329     }
330 
331     s->driver_created = true;
332     return s;
333 }
334 
335 static void sdl_audio_fini (void *opaque)
336 {
337     SDLAudioState *s = opaque;
338     sdl_close (s);
339     SDL_QuitSubSystem (SDL_INIT_AUDIO);
340     s->driver_created = false;
341 }
342 
343 static struct audio_option sdl_options[] = {
344     {
345         .name  = "SAMPLES",
346         .tag   = AUD_OPT_INT,
347         .valp  = &conf.nb_samples,
348         .descr = "Size of SDL buffer in samples"
349     },
350     { /* End of list */ }
351 };
352 
353 static struct audio_pcm_ops sdl_pcm_ops = {
354     .init_out = sdl_init_out,
355     .fini_out = sdl_fini_out,
356     .run_out  = sdl_run_out,
357     .write    = sdl_write_out,
358     .ctl_out  = sdl_ctl_out,
359 };
360 
361 static struct audio_driver sdl_audio_driver = {
362     .name           = "sdl",
363     .descr          = "SDL http://www.libsdl.org",
364     .options        = sdl_options,
365     .init           = sdl_audio_init,
366     .fini           = sdl_audio_fini,
367     .pcm_ops        = &sdl_pcm_ops,
368     .can_be_default = 1,
369     .max_voices_out = 1,
370     .max_voices_in  = 0,
371     .voice_size_out = sizeof (SDLVoiceOut),
372     .voice_size_in  = 0
373 };
374 
375 static void register_audio_sdl(void)
376 {
377     audio_driver_register(&sdl_audio_driver);
378 }
379 type_init(register_audio_sdl);
380