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