Merge tag 'pull-request-2022-09-28' of https://gitlab.com/thuth/qemu into staging
[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 G_GNUC_PRINTF (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, start;
228
229 start = audio_ring_posb(hw->pos_emul, hw->pending_emul,
230 hw->size_emul);
231 assert(start < hw->size_emul);
232
233 write_len = MIN(MIN(hw->pending_emul, len),
234 hw->size_emul - start);
235
236 memcpy(buf, hw->buf_emul + start, write_len);
237 hw->pending_emul -= write_len;
238 len -= write_len;
239 buf += write_len;
240 }
241 }
242
243 /* clear remaining buffer that we couldn't fill with data */
244 if (len) {
245 audio_pcm_info_clear_buf(&hw->info, buf,
246 len / hw->info.bytes_per_frame);
247 }
248 }
249
250 static void sdl_close_in(SDLVoiceIn *sdl)
251 {
252 if (sdl->initialized) {
253 SDL_LockAudioDevice(sdl->devid);
254 sdl->exit = 1;
255 SDL_UnlockAudioDevice(sdl->devid);
256 SDL_PauseAudioDevice(sdl->devid, 1);
257 sdl->initialized = 0;
258 }
259 if (sdl->devid) {
260 SDL_CloseAudioDevice(sdl->devid);
261 sdl->devid = 0;
262 }
263 }
264
265 static void sdl_callback_in(void *opaque, Uint8 *buf, int len)
266 {
267 SDLVoiceIn *sdl = opaque;
268 HWVoiceIn *hw = &sdl->hw;
269
270 if (sdl->exit) {
271 return;
272 }
273
274 /* dolog("callback_in: len=%d pending=%zu\n", len, hw->pending_emul); */
275
276 while (hw->pending_emul < hw->size_emul && len) {
277 size_t read_len = MIN(len, MIN(hw->size_emul - hw->pos_emul,
278 hw->size_emul - hw->pending_emul));
279
280 memcpy(hw->buf_emul + hw->pos_emul, buf, read_len);
281
282 hw->pending_emul += read_len;
283 hw->pos_emul = (hw->pos_emul + read_len) % hw->size_emul;
284 len -= read_len;
285 buf += read_len;
286 }
287 }
288
289 #define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, dir) \
290 static ret_type glue(sdl_, name)args_decl \
291 { \
292 ret_type ret; \
293 glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
294 \
295 SDL_LockAudioDevice(sdl->devid); \
296 ret = glue(audio_generic_, name)args; \
297 SDL_UnlockAudioDevice(sdl->devid); \
298 \
299 return ret; \
300 }
301
302 #define SDL_WRAPPER_VOID_FUNC(name, args_decl, args, dir) \
303 static void glue(sdl_, name)args_decl \
304 { \
305 glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
306 \
307 SDL_LockAudioDevice(sdl->devid); \
308 glue(audio_generic_, name)args; \
309 SDL_UnlockAudioDevice(sdl->devid); \
310 }
311
312 SDL_WRAPPER_FUNC(buffer_get_free, size_t, (HWVoiceOut *hw), (hw), Out)
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 /* SDL samples are QEMU frames */
351 req.samples = audio_buffer_frames(
352 qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
353 req.callback = sdl_callback_out;
354 req.userdata = sdl;
355
356 sdl->dev = dev;
357 sdl->devid = sdl_open(&req, &obt, 0);
358 if (!sdl->devid) {
359 return -1;
360 }
361
362 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
363 if (err) {
364 sdl_close_out(sdl);
365 return -1;
366 }
367
368 obt_as.freq = obt.freq;
369 obt_as.nchannels = obt.channels;
370 obt_as.fmt = effective_fmt;
371 obt_as.endianness = endianness;
372
373 audio_pcm_init_info (&hw->info, &obt_as);
374 hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
375 obt.samples;
376
377 sdl->initialized = 1;
378 sdl->exit = 0;
379 return 0;
380 }
381
382 static void sdl_enable_out(HWVoiceOut *hw, bool enable)
383 {
384 SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
385
386 SDL_PauseAudioDevice(sdl->devid, !enable);
387 }
388
389 static void sdl_fini_in(HWVoiceIn *hw)
390 {
391 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
392
393 sdl_close_in(sdl);
394 }
395
396 static int sdl_init_in(HWVoiceIn *hw, audsettings *as, void *drv_opaque)
397 {
398 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
399 SDL_AudioSpec req, obt;
400 int endianness;
401 int err;
402 AudioFormat effective_fmt;
403 Audiodev *dev = drv_opaque;
404 AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.in;
405 struct audsettings obt_as;
406
407 req.freq = as->freq;
408 req.format = aud_to_sdlfmt(as->fmt);
409 req.channels = as->nchannels;
410 /* SDL samples are QEMU frames */
411 req.samples = audio_buffer_frames(
412 qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
413 req.callback = sdl_callback_in;
414 req.userdata = sdl;
415
416 sdl->dev = dev;
417 sdl->devid = sdl_open(&req, &obt, 1);
418 if (!sdl->devid) {
419 return -1;
420 }
421
422 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
423 if (err) {
424 sdl_close_in(sdl);
425 return -1;
426 }
427
428 obt_as.freq = obt.freq;
429 obt_as.nchannels = obt.channels;
430 obt_as.fmt = effective_fmt;
431 obt_as.endianness = endianness;
432
433 audio_pcm_init_info(&hw->info, &obt_as);
434 hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
435 obt.samples;
436 hw->size_emul = hw->samples * hw->info.bytes_per_frame;
437 hw->buf_emul = g_malloc(hw->size_emul);
438 hw->pos_emul = hw->pending_emul = 0;
439
440 sdl->initialized = 1;
441 sdl->exit = 0;
442 return 0;
443 }
444
445 static void sdl_enable_in(HWVoiceIn *hw, bool enable)
446 {
447 SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
448
449 SDL_PauseAudioDevice(sdl->devid, !enable);
450 }
451
452 static void *sdl_audio_init(Audiodev *dev)
453 {
454 if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
455 sdl_logerr ("SDL failed to initialize audio subsystem\n");
456 return NULL;
457 }
458
459 return dev;
460 }
461
462 static void sdl_audio_fini (void *opaque)
463 {
464 SDL_QuitSubSystem (SDL_INIT_AUDIO);
465 }
466
467 static struct audio_pcm_ops sdl_pcm_ops = {
468 .init_out = sdl_init_out,
469 .fini_out = sdl_fini_out,
470 /* wrapper for audio_generic_write */
471 .write = sdl_write,
472 /* wrapper for audio_generic_buffer_get_free */
473 .buffer_get_free = sdl_buffer_get_free,
474 /* wrapper for audio_generic_get_buffer_out */
475 .get_buffer_out = sdl_get_buffer_out,
476 /* wrapper for audio_generic_put_buffer_out */
477 .put_buffer_out = sdl_put_buffer_out,
478 .enable_out = sdl_enable_out,
479 .init_in = sdl_init_in,
480 .fini_in = sdl_fini_in,
481 /* wrapper for audio_generic_read */
482 .read = sdl_read,
483 /* wrapper for audio_generic_get_buffer_in */
484 .get_buffer_in = sdl_get_buffer_in,
485 /* wrapper for audio_generic_put_buffer_in */
486 .put_buffer_in = sdl_put_buffer_in,
487 .enable_in = sdl_enable_in,
488 };
489
490 static struct audio_driver sdl_audio_driver = {
491 .name = "sdl",
492 .descr = "SDL http://www.libsdl.org",
493 .init = sdl_audio_init,
494 .fini = sdl_audio_fini,
495 .pcm_ops = &sdl_pcm_ops,
496 .can_be_default = 1,
497 .max_voices_out = INT_MAX,
498 .max_voices_in = INT_MAX,
499 .voice_size_out = sizeof(SDLVoiceOut),
500 .voice_size_in = sizeof(SDLVoiceIn),
501 };
502
503 static void register_audio_sdl(void)
504 {
505 audio_driver_register(&sdl_audio_driver);
506 }
507 type_init(register_audio_sdl);