xref: /qemu/audio/sdlaudio.c (revision 4b627a236ada4c097cf8cb682a7ae393fb4a4e10) 
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 #include <signal.h>
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 rpos;
45     int decr;
46 } SDLVoiceOut;
47 
48 static struct {
49     int nb_samples;
50 } conf = {
51     1024
52 };
53 
54 static struct SDLAudioState {
55     int exit;
56     SDL_mutex *mutex;
57     SDL_sem *sem;
58     int initialized;
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, int *shift)
119 {
120     switch (fmt) {
121     case AUD_FMT_S8:
122         *shift = 0;
123         return AUDIO_S8;
124 
125     case AUD_FMT_U8:
126         *shift = 0;
127         return AUDIO_U8;
128 
129     case AUD_FMT_S16:
130         *shift = 1;
131         return AUDIO_S16LSB;
132 
133     case AUD_FMT_U16:
134         *shift = 1;
135         return AUDIO_U16LSB;
136 
137     default:
138         dolog ("Internal logic error: Bad audio format %d\n", fmt);
139 #ifdef DEBUG_AUDIO
140         abort ();
141 #endif
142         return AUDIO_U8;
143     }
144 }
145 
146 static int sdl_to_audfmt (int sdlfmt, audfmt_e *fmt, int *endianess)
147 {
148     switch (sdlfmt) {
149     case AUDIO_S8:
150         *endianess = 0;
151         *fmt = AUD_FMT_S8;
152         break;
153 
154     case AUDIO_U8:
155         *endianess = 0;
156         *fmt = AUD_FMT_U8;
157         break;
158 
159     case AUDIO_S16LSB:
160         *endianess = 0;
161         *fmt = AUD_FMT_S16;
162         break;
163 
164     case AUDIO_U16LSB:
165         *endianess = 0;
166         *fmt = AUD_FMT_U16;
167         break;
168 
169     case AUDIO_S16MSB:
170         *endianess = 1;
171         *fmt = AUD_FMT_S16;
172         break;
173 
174     case AUDIO_U16MSB:
175         *endianess = 1;
176         *fmt = AUD_FMT_U16;
177         break;
178 
179     default:
180         dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
181         return -1;
182     }
183 
184     return 0;
185 }
186 
187 static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
188 {
189     int status;
190 #ifndef _WIN32
191     sigset_t new, old;
192 
193     /* Make sure potential threads created by SDL don't hog signals.  */
194     sigfillset (&new);
195     pthread_sigmask (SIG_BLOCK, &new, &old);
196 #endif
197 
198     status = SDL_OpenAudio (req, obt);
199     if (status) {
200         sdl_logerr ("SDL_OpenAudio failed\n");
201     }
202 
203 #ifndef _WIN32
204     pthread_sigmask (SIG_SETMASK, &old, 0);
205 #endif
206     return status;
207 }
208 
209 static void sdl_close (SDLAudioState *s)
210 {
211     if (s->initialized) {
212         sdl_lock (s, "sdl_close");
213         s->exit = 1;
214         sdl_unlock_and_post (s, "sdl_close");
215         SDL_PauseAudio (1);
216         SDL_CloseAudio ();
217         s->initialized = 0;
218     }
219 }
220 
221 static void sdl_callback (void *opaque, Uint8 *buf, int len)
222 {
223     SDLVoiceOut *sdl = opaque;
224     SDLAudioState *s = &glob_sdl;
225     HWVoiceOut *hw = &sdl->hw;
226     int samples = len >> hw->info.shift;
227 
228     if (s->exit) {
229         return;
230     }
231 
232     while (samples) {
233         int to_mix, decr;
234 
235         /* dolog ("in callback samples=%d\n", samples); */
236         sdl_wait (s, "sdl_callback");
237         if (s->exit) {
238             return;
239         }
240 
241         if (sdl_lock (s, "sdl_callback")) {
242             return;
243         }
244 
245         if (audio_bug (AUDIO_FUNC, sdl->live < 0 || sdl->live > hw->samples)) {
246             dolog ("sdl->live=%d hw->samples=%d\n",
247                    sdl->live, hw->samples);
248             return;
249         }
250 
251         if (!sdl->live) {
252             goto again;
253         }
254 
255         /* dolog ("in callback live=%d\n", live); */
256         to_mix = audio_MIN (samples, sdl->live);
257         decr = to_mix;
258         while (to_mix) {
259             int chunk = audio_MIN (to_mix, hw->samples - hw->rpos);
260             struct st_sample *src = hw->mix_buf + hw->rpos;
261 
262             /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
263             hw->clip (buf, src, chunk);
264             sdl->rpos = (sdl->rpos + chunk) % hw->samples;
265             to_mix -= chunk;
266             buf += chunk << hw->info.shift;
267         }
268         samples -= decr;
269         sdl->live -= decr;
270         sdl->decr += decr;
271 
272     again:
273         if (sdl_unlock (s, "sdl_callback")) {
274             return;
275         }
276     }
277     /* dolog ("done len=%d\n", len); */
278 }
279 
280 static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
281 {
282     return audio_pcm_sw_write (sw, buf, len);
283 }
284 
285 static int sdl_run_out (HWVoiceOut *hw)
286 {
287     int decr, live;
288     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
289     SDLAudioState *s = &glob_sdl;
290 
291     if (sdl_lock (s, "sdl_callback")) {
292         return 0;
293     }
294 
295     live = audio_pcm_hw_get_live_out (hw);
296 
297     if (sdl->decr > live) {
298         ldebug ("sdl->decr %d live %d sdl->live %d\n",
299                 sdl->decr,
300                 live,
301                 sdl->live);
302     }
303 
304     decr = audio_MIN (sdl->decr, live);
305     sdl->decr -= decr;
306 
307     sdl->live = live - decr;
308     hw->rpos = sdl->rpos;
309 
310     if (sdl->live > 0) {
311         sdl_unlock_and_post (s, "sdl_callback");
312     }
313     else {
314         sdl_unlock (s, "sdl_callback");
315     }
316     return decr;
317 }
318 
319 static void sdl_fini_out (HWVoiceOut *hw)
320 {
321     (void) hw;
322 
323     sdl_close (&glob_sdl);
324 }
325 
326 static int sdl_init_out (HWVoiceOut *hw, struct audsettings *as)
327 {
328     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
329     SDLAudioState *s = &glob_sdl;
330     SDL_AudioSpec req, obt;
331     int shift;
332     int endianess;
333     int err;
334     audfmt_e effective_fmt;
335     struct audsettings obt_as;
336 
337     shift <<= as->nchannels == 2;
338 
339     req.freq = as->freq;
340     req.format = aud_to_sdlfmt (as->fmt, &shift);
341     req.channels = as->nchannels;
342     req.samples = conf.nb_samples;
343     req.callback = sdl_callback;
344     req.userdata = sdl;
345 
346     if (sdl_open (&req, &obt)) {
347         return -1;
348     }
349 
350     err = sdl_to_audfmt (obt.format, &effective_fmt, &endianess);
351     if (err) {
352         sdl_close (s);
353         return -1;
354     }
355 
356     obt_as.freq = obt.freq;
357     obt_as.nchannels = obt.channels;
358     obt_as.fmt = effective_fmt;
359     obt_as.endianness = endianess;
360 
361     audio_pcm_init_info (&hw->info, &obt_as);
362     hw->samples = obt.samples;
363 
364     s->initialized = 1;
365     s->exit = 0;
366     SDL_PauseAudio (0);
367     return 0;
368 }
369 
370 static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
371 {
372     (void) hw;
373 
374     switch (cmd) {
375     case VOICE_ENABLE:
376         SDL_PauseAudio (0);
377         break;
378 
379     case VOICE_DISABLE:
380         SDL_PauseAudio (1);
381         break;
382     }
383     return 0;
384 }
385 
386 static void *sdl_audio_init (void)
387 {
388     SDLAudioState *s = &glob_sdl;
389 
390     if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
391         sdl_logerr ("SDL failed to initialize audio subsystem\n");
392         return NULL;
393     }
394 
395     s->mutex = SDL_CreateMutex ();
396     if (!s->mutex) {
397         sdl_logerr ("Failed to create SDL mutex\n");
398         SDL_QuitSubSystem (SDL_INIT_AUDIO);
399         return NULL;
400     }
401 
402     s->sem = SDL_CreateSemaphore (0);
403     if (!s->sem) {
404         sdl_logerr ("Failed to create SDL semaphore\n");
405         SDL_DestroyMutex (s->mutex);
406         SDL_QuitSubSystem (SDL_INIT_AUDIO);
407         return NULL;
408     }
409 
410     return s;
411 }
412 
413 static void sdl_audio_fini (void *opaque)
414 {
415     SDLAudioState *s = opaque;
416     sdl_close (s);
417     SDL_DestroySemaphore (s->sem);
418     SDL_DestroyMutex (s->mutex);
419     SDL_QuitSubSystem (SDL_INIT_AUDIO);
420 }
421 
422 static struct audio_option sdl_options[] = {
423     {"SAMPLES", AUD_OPT_INT, &conf.nb_samples,
424      "Size of SDL buffer in samples", NULL, 0},
425     {NULL, 0, NULL, NULL, NULL, 0}
426 };
427 
428 static struct audio_pcm_ops sdl_pcm_ops = {
429     sdl_init_out,
430     sdl_fini_out,
431     sdl_run_out,
432     sdl_write_out,
433     sdl_ctl_out,
434 
435     NULL,
436     NULL,
437     NULL,
438     NULL,
439     NULL
440 };
441 
442 struct audio_driver sdl_audio_driver = {
443     INIT_FIELD (name           = ) "sdl",
444     INIT_FIELD (descr          = ) "SDL http://www.libsdl.org",
445     INIT_FIELD (options        = ) sdl_options,
446     INIT_FIELD (init           = ) sdl_audio_init,
447     INIT_FIELD (fini           = ) sdl_audio_fini,
448     INIT_FIELD (pcm_ops        = ) &sdl_pcm_ops,
449     INIT_FIELD (can_be_default = ) 1,
450     INIT_FIELD (max_voices_out = ) 1,
451     INIT_FIELD (max_voices_in  = ) 0,
452     INIT_FIELD (voice_size_out = ) sizeof (SDLVoiceOut),
453     INIT_FIELD (voice_size_in  = ) 0
454 };
455