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