1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
42typedef struct SDLVoiceOut {
43 HWVoiceOut hw;
44} SDLVoiceOut;
45
46static struct SDLAudioState {
47 int exit;
48 int initialized;
49 bool driver_created;
50 Audiodev *dev;
51} glob_sdl;
52typedef struct SDLAudioState SDLAudioState;
53
54static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
55{
56 va_list ap;
57
58 va_start (ap, fmt);
59 AUD_vlog (AUDIO_CAP, fmt, ap);
60 va_end (ap);
61
62 AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
63}
64
65static int aud_to_sdlfmt (AudioFormat fmt)
66{
67 switch (fmt) {
68 case AUDIO_FORMAT_S8:
69 return AUDIO_S8;
70
71 case AUDIO_FORMAT_U8:
72 return AUDIO_U8;
73
74 case AUDIO_FORMAT_S16:
75 return AUDIO_S16LSB;
76
77 case AUDIO_FORMAT_U16:
78 return AUDIO_U16LSB;
79
80 case AUDIO_FORMAT_S32:
81 return AUDIO_S32LSB;
82
83
84
85 case AUDIO_FORMAT_F32:
86 return AUDIO_F32LSB;
87
88 default:
89 dolog ("Internal logic error: Bad audio format %d\n", fmt);
90#ifdef DEBUG_AUDIO
91 abort ();
92#endif
93 return AUDIO_U8;
94 }
95}
96
97static int sdl_to_audfmt(int sdlfmt, AudioFormat *fmt, int *endianness)
98{
99 switch (sdlfmt) {
100 case AUDIO_S8:
101 *endianness = 0;
102 *fmt = AUDIO_FORMAT_S8;
103 break;
104
105 case AUDIO_U8:
106 *endianness = 0;
107 *fmt = AUDIO_FORMAT_U8;
108 break;
109
110 case AUDIO_S16LSB:
111 *endianness = 0;
112 *fmt = AUDIO_FORMAT_S16;
113 break;
114
115 case AUDIO_U16LSB:
116 *endianness = 0;
117 *fmt = AUDIO_FORMAT_U16;
118 break;
119
120 case AUDIO_S16MSB:
121 *endianness = 1;
122 *fmt = AUDIO_FORMAT_S16;
123 break;
124
125 case AUDIO_U16MSB:
126 *endianness = 1;
127 *fmt = AUDIO_FORMAT_U16;
128 break;
129
130 case AUDIO_S32LSB:
131 *endianness = 0;
132 *fmt = AUDIO_FORMAT_S32;
133 break;
134
135 case AUDIO_S32MSB:
136 *endianness = 1;
137 *fmt = AUDIO_FORMAT_S32;
138 break;
139
140 case AUDIO_F32LSB:
141 *endianness = 0;
142 *fmt = AUDIO_FORMAT_F32;
143 break;
144
145 case AUDIO_F32MSB:
146 *endianness = 1;
147 *fmt = AUDIO_FORMAT_F32;
148 break;
149
150 default:
151 dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
152 return -1;
153 }
154
155 return 0;
156}
157
158static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
159{
160 int status;
161#ifndef _WIN32
162 int err;
163 sigset_t new, old;
164
165
166 err = sigfillset (&new);
167 if (err) {
168 dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
169 return -1;
170 }
171 err = pthread_sigmask (SIG_BLOCK, &new, &old);
172 if (err) {
173 dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
174 return -1;
175 }
176#endif
177
178 status = SDL_OpenAudio (req, obt);
179 if (status) {
180 sdl_logerr ("SDL_OpenAudio failed\n");
181 }
182
183#ifndef _WIN32
184 err = pthread_sigmask (SIG_SETMASK, &old, NULL);
185 if (err) {
186 dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
187 strerror (errno));
188
189
190 exit (EXIT_FAILURE);
191 }
192#endif
193 return status;
194}
195
196static void sdl_close (SDLAudioState *s)
197{
198 if (s->initialized) {
199 SDL_LockAudio();
200 s->exit = 1;
201 SDL_UnlockAudio();
202 SDL_PauseAudio (1);
203 SDL_CloseAudio ();
204 s->initialized = 0;
205 }
206}
207
208static void sdl_callback (void *opaque, Uint8 *buf, int len)
209{
210 SDLVoiceOut *sdl = opaque;
211 SDLAudioState *s = &glob_sdl;
212 HWVoiceOut *hw = &sdl->hw;
213
214 if (s->exit) {
215 return;
216 }
217
218
219
220 while (hw->pending_emul && len) {
221 size_t write_len;
222 ssize_t start = ((ssize_t) hw->pos_emul) - hw->pending_emul;
223 if (start < 0) {
224 start += hw->size_emul;
225 }
226 assert(start >= 0 && start < hw->size_emul);
227
228 write_len = MIN(MIN(hw->pending_emul, len),
229 hw->size_emul - start);
230
231 memcpy(buf, hw->buf_emul + start, write_len);
232 hw->pending_emul -= write_len;
233 len -= write_len;
234 buf += write_len;
235 }
236
237
238 if (len) {
239 memset(buf, 0, len);
240 }
241}
242
243#define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, fail, unlock) \
244 static ret_type glue(sdl_, name)args_decl \
245 { \
246 ret_type ret; \
247 \
248 SDL_LockAudio(); \
249 \
250 ret = glue(audio_generic_, name)args; \
251 \
252 SDL_UnlockAudio(); \
253 return ret; \
254 }
255
256SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
257 (hw, size), *size = 0, sdl_unlock)
258SDL_WRAPPER_FUNC(put_buffer_out, size_t,
259 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size),
260 , sdl_unlock_and_post)
261SDL_WRAPPER_FUNC(write, size_t,
262 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size),
263 , sdl_unlock_and_post)
264
265#undef SDL_WRAPPER_FUNC
266
267static void sdl_fini_out (HWVoiceOut *hw)
268{
269 (void) hw;
270
271 sdl_close (&glob_sdl);
272}
273
274static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
275 void *drv_opaque)
276{
277 SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
278 SDLAudioState *s = &glob_sdl;
279 SDL_AudioSpec req, obt;
280 int endianness;
281 int err;
282 AudioFormat effective_fmt;
283 struct audsettings obt_as;
284
285 req.freq = as->freq;
286 req.format = aud_to_sdlfmt (as->fmt);
287 req.channels = as->nchannels;
288 req.samples = audio_buffer_samples(s->dev->u.sdl.out, as, 11610);
289 req.callback = sdl_callback;
290 req.userdata = sdl;
291
292 if (sdl_open (&req, &obt)) {
293 return -1;
294 }
295
296 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
297 if (err) {
298 sdl_close (s);
299 return -1;
300 }
301
302 obt_as.freq = obt.freq;
303 obt_as.nchannels = obt.channels;
304 obt_as.fmt = effective_fmt;
305 obt_as.endianness = endianness;
306
307 audio_pcm_init_info (&hw->info, &obt_as);
308 hw->samples = obt.samples;
309
310 s->initialized = 1;
311 s->exit = 0;
312 SDL_PauseAudio (0);
313 return 0;
314}
315
316static void sdl_enable_out(HWVoiceOut *hw, bool enable)
317{
318 SDL_PauseAudio(!enable);
319}
320
321static void *sdl_audio_init(Audiodev *dev)
322{
323 SDLAudioState *s = &glob_sdl;
324 if (s->driver_created) {
325 sdl_logerr("Can't create multiple sdl backends\n");
326 return NULL;
327 }
328
329 if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
330 sdl_logerr ("SDL failed to initialize audio subsystem\n");
331 return NULL;
332 }
333
334 s->driver_created = true;
335 s->dev = dev;
336 return s;
337}
338
339static void sdl_audio_fini (void *opaque)
340{
341 SDLAudioState *s = opaque;
342 sdl_close (s);
343 SDL_QuitSubSystem (SDL_INIT_AUDIO);
344 s->driver_created = false;
345 s->dev = NULL;
346}
347
348static struct audio_pcm_ops sdl_pcm_ops = {
349 .init_out = sdl_init_out,
350 .fini_out = sdl_fini_out,
351
352 .write = sdl_write,
353
354 .get_buffer_out = sdl_get_buffer_out,
355
356 .put_buffer_out = sdl_put_buffer_out,
357 .enable_out = sdl_enable_out,
358};
359
360static struct audio_driver sdl_audio_driver = {
361 .name = "sdl",
362 .descr = "SDL http://www.libsdl.org",
363 .init = sdl_audio_init,
364 .fini = sdl_audio_fini,
365 .pcm_ops = &sdl_pcm_ops,
366 .can_be_default = 1,
367 .max_voices_out = 1,
368 .max_voices_in = 0,
369 .voice_size_out = sizeof (SDLVoiceOut),
370 .voice_size_in = 0
371};
372
373static void register_audio_sdl(void)
374{
375 audio_driver_register(&sdl_audio_driver);
376}
377type_init(register_audio_sdl);
378
