Merge remote-tracking branch 'remotes/kraxel/tags/usb-20210122-pull-request' into...
[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 exit;
45 int initialized;
46 Audiodev *dev;
47 SDL_AudioDeviceID devid;
48 } SDLVoiceOut;
49
50 typedef struct SDLVoiceIn {
51 HWVoiceIn hw;
52 int exit;
53 int initialized;
54 Audiodev *dev;
55 SDL_AudioDeviceID devid;
56 } SDLVoiceIn;
57
58 static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
59 {
60 va_list ap;
61
62 va_start (ap, fmt);
63 AUD_vlog (AUDIO_CAP, fmt, ap);
64 va_end (ap);
65
66 AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
67 }
68
69 static int aud_to_sdlfmt (AudioFormat fmt)
70 {
71 switch (fmt) {
72 case AUDIO_FORMAT_S8:
73 return AUDIO_S8;
74
75 case AUDIO_FORMAT_U8:
76 return AUDIO_U8;
77
78 case AUDIO_FORMAT_S16:
79 return AUDIO_S16LSB;
80
81 case AUDIO_FORMAT_U16:
82 return AUDIO_U16LSB;
83
84 case AUDIO_FORMAT_S32:
85 return AUDIO_S32LSB;
86
87 /* no unsigned 32-bit support in SDL */
88
89 case AUDIO_FORMAT_F32:
90 return AUDIO_F32LSB;
91
92 default:
93 dolog ("Internal logic error: Bad audio format %d\n", fmt);
94 #ifdef DEBUG_AUDIO
95 abort ();
96 #endif
97 return AUDIO_U8;
98 }
99 }
100
101 static int sdl_to_audfmt(int sdlfmt, AudioFormat *fmt, int *endianness)
102 {
103 switch (sdlfmt) {
104 case AUDIO_S8:
105 *endianness = 0;
106 *fmt = AUDIO_FORMAT_S8;
107 break;
108
109 case AUDIO_U8:
110 *endianness = 0;
111 *fmt = AUDIO_FORMAT_U8;
112 break;
113
114 case AUDIO_S16LSB:
115 *endianness = 0;
116 *fmt = AUDIO_FORMAT_S16;
117 break;
118
119 case AUDIO_U16LSB:
120 *endianness = 0;
121 *fmt = AUDIO_FORMAT_U16;
122 break;
123
124 case AUDIO_S16MSB:
125 *endianness = 1;
126 *fmt = AUDIO_FORMAT_S16;
127 break;
128
129 case AUDIO_U16MSB:
130 *endianness = 1;
131 *fmt = AUDIO_FORMAT_U16;
132 break;
133
134 case AUDIO_S32LSB:
135 *endianness = 0;
136 *fmt = AUDIO_FORMAT_S32;
137 break;
138
139 case AUDIO_S32MSB:
140 *endianness = 1;
141 *fmt = AUDIO_FORMAT_S32;
142 break;
143
144 case AUDIO_F32LSB:
145 *endianness = 0;
146 *fmt = AUDIO_FORMAT_F32;
147 break;
148
149 case AUDIO_F32MSB:
150 *endianness = 1;
151 *fmt = AUDIO_FORMAT_F32;
152 break;
153
154 default:
155 dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
156 return -1;
157 }
158
159 return 0;
160 }
161
162 static SDL_AudioDeviceID sdl_open(SDL_AudioSpec *req, SDL_AudioSpec *obt,
163 int rec)
164 {
165 SDL_AudioDeviceID devid;
166 #ifndef _WIN32
167 int err;
168 sigset_t new, old;
169
170 /* Make sure potential threads created by SDL don't hog signals. */
171 err = sigfillset (&new);
172 if (err) {
173 dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
174 return 0;
175 }
176 err = pthread_sigmask (SIG_BLOCK, &new, &old);
177 if (err) {
178 dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
179 return 0;
180 }
181 #endif
182
183 devid = SDL_OpenAudioDevice(NULL, rec, req, obt, 0);
184 if (!devid) {
185 sdl_logerr("SDL_OpenAudioDevice for %s failed\n",
186 rec ? "recording" : "playback");
187 }
188
189 #ifndef _WIN32
190 err = pthread_sigmask (SIG_SETMASK, &old, NULL);
191 if (err) {
192 dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
193 strerror (errno));
194 /* We have failed to restore original signal mask, all bets are off,
195 so exit the process */
196 exit (EXIT_FAILURE);
197 }
198 #endif
199 return devid;
200 }
201
202 static void sdl_close_out(SDLVoiceOut *sdl)
203 {
204 if (sdl->initialized) {
205 SDL_LockAudioDevice(sdl->devid);
206 sdl->exit = 1;
207 SDL_UnlockAudioDevice(sdl->devid);
208 SDL_PauseAudioDevice(sdl->devid, 1);
209 sdl->initialized = 0;
210 }
211 if (sdl->devid) {
212 SDL_CloseAudioDevice(sdl->devid);
213 sdl->devid = 0;
214 }
215 }
216
217 static void sdl_callback_out(void *opaque, Uint8 *buf, int len)
218 {
219 SDLVoiceOut *sdl = opaque;
220 HWVoiceOut *hw = &sdl->hw;
221
222 if (!sdl->exit) {
223
224 /* dolog("callback_out: len=%d avail=%zu\n", len, hw->pending_emul); */
225
226 while (hw->pending_emul && len) {
227 size_t write_len;
228 ssize_t start = (ssize_t)hw->pos_emul - hw->pending_emul;
229 if (start < 0) {
230 start += hw->size_emul;
231 }
232 assert(start >= 0 && start < hw->size_emul);
233
234 write_len = MIN(MIN(hw->pending_emul, len),
235 hw->size_emul - start);
236
237 memcpy(buf, hw->buf_emul + start, write_len);
238 hw->pending_emul -= write_len;
239 len -= write_len;
240 buf += write_len;
241 }
242 }
243
244 /* clear remaining buffer that we couldn't fill with data */
245 if (len) {
246 audio_pcm_info_clear_buf(&hw->info, buf,
247 len / hw->info.bytes_per_frame);
248 }
249 }
250
251 static void sdl_close_in(SDLVoiceIn *sdl)
252 {
253 if (sdl->initialized) {
254 SDL_LockAudioDevice(sdl->devid);
255 sdl->exit = 1;
256 SDL_UnlockAudioDevice(sdl->devid);
257 SDL_PauseAudioDevice(sdl->devid, 1);
258 sdl->initialized = 0;
259 }
260 if (sdl->devid) {
261 SDL_CloseAudioDevice(sdl->devid);
262 sdl->devid = 0;
263 }
264 }
265
266 static void sdl_callback_in(void *opaque, Uint8 *buf, int len)
267 {
268 SDLVoiceIn *sdl = opaque;
269 HWVoiceIn *hw = &sdl->hw;
270
271 if (sdl->exit) {
272 return;
273 }
274
275 /* dolog("callback_in: len=%d pending=%zu\n", len, hw->pending_emul); */
276
277 while (hw->pending_emul < hw->size_emul && len) {
278 size_t read_len = MIN(len, MIN(hw->size_emul - hw->pos_emul,
279 hw->size_emul - hw->pending_emul));
280
281 memcpy(hw->buf_emul + hw->pos_emul, buf, read_len);
282
283 hw->pending_emul += read_len;
284 hw->pos_emul = (hw->pos_emul + read_len) % hw->size_emul;
285 len -= read_len;
286 buf += read_len;
287 }
288 }
289
290 #define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, dir) \
291 static ret_type glue(sdl_, name)args_decl \
292 { \
293 ret_type ret; \
294 glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
295 \
296 SDL_LockAudioDevice(sdl->devid); \
297 ret = glue(audio_generic_, name)args; \
298 SDL_UnlockAudioDevice(sdl->devid); \
299 \
300 return ret; \
301 }
302
303 #define SDL_WRAPPER_VOID_FUNC(name, args_decl, args, dir) \
304 static void glue(sdl_, name)args_decl \
305 { \
306 glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
307 \
308 SDL_LockAudioDevice(sdl->devid); \
309 glue(audio_generic_, name)args; \
310 SDL_UnlockAudioDevice(sdl->devid); \
311 }
312
313 SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
314 (hw, size), Out)
315 SDL_WRAPPER_FUNC(put_buffer_out, size_t,
316 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
317 SDL_WRAPPER_FUNC(write, size_t,
318 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
319 SDL_WRAPPER_FUNC(read, size_t, (HWVoiceIn *hw, void *buf, size_t size),
320 (hw, buf, size), In)
321 SDL_WRAPPER_FUNC(get_buffer_in, void *, (HWVoiceIn *hw, size_t *size),
322 (hw, size), In)
323 SDL_WRAPPER_VOID_FUNC(put_buffer_in, (HWVoiceIn *hw, void *buf, size_t size),
324 (hw, buf, size), In)
325 #undef SDL_WRAPPER_FUNC
326 #undef SDL_WRAPPER_VOID_FUNC
327
328 static void sdl_fini_out(HWVoiceOut *hw)
329 {
330 SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
331
332 sdl_close_out(sdl);
333 }
334
335 static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
336 void *drv_opaque)
337 {
338 SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
339 SDL_AudioSpec req, obt;
340 int endianness;
341 int err;
342 AudioFormat effective_fmt;
343 Audiodev *dev = drv_opaque;
344 AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.out;
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 /*
351 * This is wrong. SDL samples are QEMU frames. The buffer size will be
352 * the requested buffer size multiplied by the number of channels.
353 */
354 req.samples = audio_buffer_samples(
355 qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
356 req.callback = sdl_callback_out;
357 req.userdata = sdl;
358
359 sdl->dev = dev;
360 sdl->devid = sdl_open(&req, &obt, 0);
361 if (!sdl->devid) {
362 return -1;
363 }
364
365 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
366 if (err) {
367 sdl_close_out(sdl);
368 return -1;
369 }
370
371 obt_as.freq = obt.freq;
372 obt_as.nchannels = obt.channels;
373 obt_as.fmt = effective_fmt;
374 obt_as.endianness = endianness;
375
376 audio_pcm_init_info (&hw->info, &obt_as);
377 hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
378 obt.samples;
379
380 sdl->initialized = 1;
381 sdl->exit = 0;
382 return 0;
383 }
384
385 static void sdl_enable_out(HWVoiceOut *hw, bool enable)
386 {
387 SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
388
389 SDL_PauseAudioDevice(sdl->devid, !enable);
390 }
391
392 static void sdl_fini_in(HWVoiceIn *hw)
393 {
394 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
395
396 sdl_close_in(sdl);
397 }
398
399 static int sdl_init_in(HWVoiceIn *hw, audsettings *as, void *drv_opaque)
400 {
401 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
402 SDL_AudioSpec req, obt;
403 int endianness;
404 int err;
405 AudioFormat effective_fmt;
406 Audiodev *dev = drv_opaque;
407 AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.in;
408 struct audsettings obt_as;
409
410 req.freq = as->freq;
411 req.format = aud_to_sdlfmt(as->fmt);
412 req.channels = as->nchannels;
413 /* SDL samples are QEMU frames */
414 req.samples = audio_buffer_frames(
415 qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
416 req.callback = sdl_callback_in;
417 req.userdata = sdl;
418
419 sdl->dev = dev;
420 sdl->devid = sdl_open(&req, &obt, 1);
421 if (!sdl->devid) {
422 return -1;
423 }
424
425 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
426 if (err) {
427 sdl_close_in(sdl);
428 return -1;
429 }
430
431 obt_as.freq = obt.freq;
432 obt_as.nchannels = obt.channels;
433 obt_as.fmt = effective_fmt;
434 obt_as.endianness = endianness;
435
436 audio_pcm_init_info(&hw->info, &obt_as);
437 hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
438 obt.samples;
439 hw->size_emul = hw->samples * hw->info.bytes_per_frame;
440 hw->buf_emul = g_malloc(hw->size_emul);
441 hw->pos_emul = hw->pending_emul = 0;
442
443 sdl->initialized = 1;
444 sdl->exit = 0;
445 return 0;
446 }
447
448 static void sdl_enable_in(HWVoiceIn *hw, bool enable)
449 {
450 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
451
452 SDL_PauseAudioDevice(sdl->devid, !enable);
453 }
454
455 static void *sdl_audio_init(Audiodev *dev)
456 {
457 if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
458 sdl_logerr ("SDL failed to initialize audio subsystem\n");
459 return NULL;
460 }
461
462 return dev;
463 }
464
465 static void sdl_audio_fini (void *opaque)
466 {
467 SDL_QuitSubSystem (SDL_INIT_AUDIO);
468 }
469
470 static struct audio_pcm_ops sdl_pcm_ops = {
471 .init_out = sdl_init_out,
472 .fini_out = sdl_fini_out,
473 /* wrapper for audio_generic_write */
474 .write = sdl_write,
475 /* wrapper for audio_generic_get_buffer_out */
476 .get_buffer_out = sdl_get_buffer_out,
477 /* wrapper for audio_generic_put_buffer_out */
478 .put_buffer_out = sdl_put_buffer_out,
479 .enable_out = sdl_enable_out,
480 .init_in = sdl_init_in,
481 .fini_in = sdl_fini_in,
482 /* wrapper for audio_generic_read */
483 .read = sdl_read,
484 /* wrapper for audio_generic_get_buffer_in */
485 .get_buffer_in = sdl_get_buffer_in,
486 /* wrapper for audio_generic_put_buffer_in */
487 .put_buffer_in = sdl_put_buffer_in,
488 .enable_in = sdl_enable_in,
489 };
490
491 static struct audio_driver sdl_audio_driver = {
492 .name = "sdl",
493 .descr = "SDL http://www.libsdl.org",
494 .init = sdl_audio_init,
495 .fini = sdl_audio_fini,
496 .pcm_ops = &sdl_pcm_ops,
497 .can_be_default = 1,
498 .max_voices_out = INT_MAX,
499 .max_voices_in = INT_MAX,
500 .voice_size_out = sizeof(SDLVoiceOut),
501 .voice_size_in = sizeof(SDLVoiceIn),
502 };
503
504 static void register_audio_sdl(void)
505 {
506 audio_driver_register(&sdl_audio_driver);
507 }
508 type_init(register_audio_sdl);