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