ui/cocoa.m: Fix macOS 10.12 deprecation warnings
[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 #include "qemu/osdep.h"
25 #include <SDL.h>
26 #include <SDL_thread.h>
27 #include "qemu-common.h"
28 #include "audio.h"
29
30 #ifndef _WIN32
31 #ifdef __sun__
32 #define _POSIX_PTHREAD_SEMANTICS 1
33 #elif defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
34 #include <pthread.h>
35 #endif
36 #endif
37
38 #define AUDIO_CAP "sdl"
39 #include "audio_int.h"
40
41 #define USE_SEMAPHORE (SDL_MAJOR_VERSION < 2)
42
43 typedef struct SDLVoiceOut {
44 HWVoiceOut hw;
45 int live;
46 #if USE_SEMAPHORE
47 int rpos;
48 #endif
49 int decr;
50 } SDLVoiceOut;
51
52 static struct {
53 int nb_samples;
54 } conf = {
55 .nb_samples = 1024
56 };
57
58 static struct SDLAudioState {
59 int exit;
60 #if USE_SEMAPHORE
61 SDL_mutex *mutex;
62 SDL_sem *sem;
63 #endif
64 int initialized;
65 bool driver_created;
66 } glob_sdl;
67 typedef struct SDLAudioState SDLAudioState;
68
69 static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
70 {
71 va_list ap;
72
73 va_start (ap, fmt);
74 AUD_vlog (AUDIO_CAP, fmt, ap);
75 va_end (ap);
76
77 AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
78 }
79
80 static int sdl_lock (SDLAudioState *s, const char *forfn)
81 {
82 #if USE_SEMAPHORE
83 if (SDL_LockMutex (s->mutex)) {
84 sdl_logerr ("SDL_LockMutex for %s failed\n", forfn);
85 return -1;
86 }
87 #else
88 SDL_LockAudio();
89 #endif
90
91 return 0;
92 }
93
94 static int sdl_unlock (SDLAudioState *s, const char *forfn)
95 {
96 #if USE_SEMAPHORE
97 if (SDL_UnlockMutex (s->mutex)) {
98 sdl_logerr ("SDL_UnlockMutex for %s failed\n", forfn);
99 return -1;
100 }
101 #else
102 SDL_UnlockAudio();
103 #endif
104
105 return 0;
106 }
107
108 static int sdl_post (SDLAudioState *s, const char *forfn)
109 {
110 #if USE_SEMAPHORE
111 if (SDL_SemPost (s->sem)) {
112 sdl_logerr ("SDL_SemPost for %s failed\n", forfn);
113 return -1;
114 }
115 #endif
116
117 return 0;
118 }
119
120 #if USE_SEMAPHORE
121 static int sdl_wait (SDLAudioState *s, const char *forfn)
122 {
123 if (SDL_SemWait (s->sem)) {
124 sdl_logerr ("SDL_SemWait for %s failed\n", forfn);
125 return -1;
126 }
127 return 0;
128 }
129 #endif
130
131 static int sdl_unlock_and_post (SDLAudioState *s, const char *forfn)
132 {
133 if (sdl_unlock (s, forfn)) {
134 return -1;
135 }
136
137 return sdl_post (s, forfn);
138 }
139
140 static int aud_to_sdlfmt (audfmt_e fmt)
141 {
142 switch (fmt) {
143 case AUD_FMT_S8:
144 return AUDIO_S8;
145
146 case AUD_FMT_U8:
147 return AUDIO_U8;
148
149 case AUD_FMT_S16:
150 return AUDIO_S16LSB;
151
152 case AUD_FMT_U16:
153 return AUDIO_U16LSB;
154
155 default:
156 dolog ("Internal logic error: Bad audio format %d\n", fmt);
157 #ifdef DEBUG_AUDIO
158 abort ();
159 #endif
160 return AUDIO_U8;
161 }
162 }
163
164 static int sdl_to_audfmt(int sdlfmt, audfmt_e *fmt, int *endianness)
165 {
166 switch (sdlfmt) {
167 case AUDIO_S8:
168 *endianness = 0;
169 *fmt = AUD_FMT_S8;
170 break;
171
172 case AUDIO_U8:
173 *endianness = 0;
174 *fmt = AUD_FMT_U8;
175 break;
176
177 case AUDIO_S16LSB:
178 *endianness = 0;
179 *fmt = AUD_FMT_S16;
180 break;
181
182 case AUDIO_U16LSB:
183 *endianness = 0;
184 *fmt = AUD_FMT_U16;
185 break;
186
187 case AUDIO_S16MSB:
188 *endianness = 1;
189 *fmt = AUD_FMT_S16;
190 break;
191
192 case AUDIO_U16MSB:
193 *endianness = 1;
194 *fmt = AUD_FMT_U16;
195 break;
196
197 default:
198 dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
199 return -1;
200 }
201
202 return 0;
203 }
204
205 static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
206 {
207 int status;
208 #ifndef _WIN32
209 int err;
210 sigset_t new, old;
211
212 /* Make sure potential threads created by SDL don't hog signals. */
213 err = sigfillset (&new);
214 if (err) {
215 dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
216 return -1;
217 }
218 err = pthread_sigmask (SIG_BLOCK, &new, &old);
219 if (err) {
220 dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
221 return -1;
222 }
223 #endif
224
225 status = SDL_OpenAudio (req, obt);
226 if (status) {
227 sdl_logerr ("SDL_OpenAudio failed\n");
228 }
229
230 #ifndef _WIN32
231 err = pthread_sigmask (SIG_SETMASK, &old, NULL);
232 if (err) {
233 dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
234 strerror (errno));
235 /* We have failed to restore original signal mask, all bets are off,
236 so exit the process */
237 exit (EXIT_FAILURE);
238 }
239 #endif
240 return status;
241 }
242
243 static void sdl_close (SDLAudioState *s)
244 {
245 if (s->initialized) {
246 sdl_lock (s, "sdl_close");
247 s->exit = 1;
248 sdl_unlock_and_post (s, "sdl_close");
249 SDL_PauseAudio (1);
250 SDL_CloseAudio ();
251 s->initialized = 0;
252 }
253 }
254
255 static void sdl_callback (void *opaque, Uint8 *buf, int len)
256 {
257 SDLVoiceOut *sdl = opaque;
258 SDLAudioState *s = &glob_sdl;
259 HWVoiceOut *hw = &sdl->hw;
260 int samples = len >> hw->info.shift;
261
262 if (s->exit) {
263 return;
264 }
265
266 while (samples) {
267 int to_mix, decr;
268
269 /* dolog ("in callback samples=%d\n", samples); */
270 #if USE_SEMAPHORE
271 sdl_wait (s, "sdl_callback");
272 if (s->exit) {
273 return;
274 }
275
276 if (sdl_lock (s, "sdl_callback")) {
277 return;
278 }
279
280 if (audio_bug (AUDIO_FUNC, sdl->live < 0 || sdl->live > hw->samples)) {
281 dolog ("sdl->live=%d hw->samples=%d\n",
282 sdl->live, hw->samples);
283 return;
284 }
285
286 if (!sdl->live) {
287 goto again;
288 }
289 #else
290 if (s->exit || !sdl->live) {
291 break;
292 }
293 #endif
294
295 /* dolog ("in callback live=%d\n", live); */
296 to_mix = audio_MIN (samples, sdl->live);
297 decr = to_mix;
298 while (to_mix) {
299 int chunk = audio_MIN (to_mix, hw->samples - hw->rpos);
300 struct st_sample *src = hw->mix_buf + hw->rpos;
301
302 /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
303 hw->clip (buf, src, chunk);
304 #if USE_SEMAPHORE
305 sdl->rpos = (sdl->rpos + chunk) % hw->samples;
306 #else
307 hw->rpos = (hw->rpos + chunk) % hw->samples;
308 #endif
309 to_mix -= chunk;
310 buf += chunk << hw->info.shift;
311 }
312 samples -= decr;
313 sdl->live -= decr;
314 sdl->decr += decr;
315
316 #if USE_SEMAPHORE
317 again:
318 if (sdl_unlock (s, "sdl_callback")) {
319 return;
320 }
321 #endif
322 }
323 /* dolog ("done len=%d\n", len); */
324
325 #if (SDL_MAJOR_VERSION >= 2)
326 /* SDL2 does not clear the remaining buffer for us, so do it on our own */
327 if (samples) {
328 memset(buf, 0, samples << hw->info.shift);
329 }
330 #endif
331 }
332
333 static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
334 {
335 return audio_pcm_sw_write (sw, buf, len);
336 }
337
338 static int sdl_run_out (HWVoiceOut *hw, int live)
339 {
340 int decr;
341 SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
342 SDLAudioState *s = &glob_sdl;
343
344 if (sdl_lock (s, "sdl_run_out")) {
345 return 0;
346 }
347
348 if (sdl->decr > live) {
349 ldebug ("sdl->decr %d live %d sdl->live %d\n",
350 sdl->decr,
351 live,
352 sdl->live);
353 }
354
355 decr = audio_MIN (sdl->decr, live);
356 sdl->decr -= decr;
357
358 #if USE_SEMAPHORE
359 sdl->live = live - decr;
360 hw->rpos = sdl->rpos;
361 #else
362 sdl->live = live;
363 #endif
364
365 if (sdl->live > 0) {
366 sdl_unlock_and_post (s, "sdl_run_out");
367 }
368 else {
369 sdl_unlock (s, "sdl_run_out");
370 }
371 return decr;
372 }
373
374 static void sdl_fini_out (HWVoiceOut *hw)
375 {
376 (void) hw;
377
378 sdl_close (&glob_sdl);
379 }
380
381 static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
382 void *drv_opaque)
383 {
384 SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
385 SDLAudioState *s = &glob_sdl;
386 SDL_AudioSpec req, obt;
387 int endianness;
388 int err;
389 audfmt_e effective_fmt;
390 struct audsettings obt_as;
391
392 req.freq = as->freq;
393 req.format = aud_to_sdlfmt (as->fmt);
394 req.channels = as->nchannels;
395 req.samples = conf.nb_samples;
396 req.callback = sdl_callback;
397 req.userdata = sdl;
398
399 if (sdl_open (&req, &obt)) {
400 return -1;
401 }
402
403 err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
404 if (err) {
405 sdl_close (s);
406 return -1;
407 }
408
409 obt_as.freq = obt.freq;
410 obt_as.nchannels = obt.channels;
411 obt_as.fmt = effective_fmt;
412 obt_as.endianness = endianness;
413
414 audio_pcm_init_info (&hw->info, &obt_as);
415 hw->samples = obt.samples;
416
417 s->initialized = 1;
418 s->exit = 0;
419 SDL_PauseAudio (0);
420 return 0;
421 }
422
423 static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
424 {
425 (void) hw;
426
427 switch (cmd) {
428 case VOICE_ENABLE:
429 SDL_PauseAudio (0);
430 break;
431
432 case VOICE_DISABLE:
433 SDL_PauseAudio (1);
434 break;
435 }
436 return 0;
437 }
438
439 static void *sdl_audio_init (void)
440 {
441 SDLAudioState *s = &glob_sdl;
442 if (s->driver_created) {
443 sdl_logerr("Can't create multiple sdl backends\n");
444 return NULL;
445 }
446
447 if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
448 sdl_logerr ("SDL failed to initialize audio subsystem\n");
449 return NULL;
450 }
451
452 #if USE_SEMAPHORE
453 s->mutex = SDL_CreateMutex ();
454 if (!s->mutex) {
455 sdl_logerr ("Failed to create SDL mutex\n");
456 SDL_QuitSubSystem (SDL_INIT_AUDIO);
457 return NULL;
458 }
459
460 s->sem = SDL_CreateSemaphore (0);
461 if (!s->sem) {
462 sdl_logerr ("Failed to create SDL semaphore\n");
463 SDL_DestroyMutex (s->mutex);
464 SDL_QuitSubSystem (SDL_INIT_AUDIO);
465 return NULL;
466 }
467 #endif
468
469 s->driver_created = true;
470 return s;
471 }
472
473 static void sdl_audio_fini (void *opaque)
474 {
475 SDLAudioState *s = opaque;
476 sdl_close (s);
477 #if USE_SEMAPHORE
478 SDL_DestroySemaphore (s->sem);
479 SDL_DestroyMutex (s->mutex);
480 #endif
481 SDL_QuitSubSystem (SDL_INIT_AUDIO);
482 s->driver_created = false;
483 }
484
485 static struct audio_option sdl_options[] = {
486 {
487 .name = "SAMPLES",
488 .tag = AUD_OPT_INT,
489 .valp = &conf.nb_samples,
490 .descr = "Size of SDL buffer in samples"
491 },
492 { /* End of list */ }
493 };
494
495 static struct audio_pcm_ops sdl_pcm_ops = {
496 .init_out = sdl_init_out,
497 .fini_out = sdl_fini_out,
498 .run_out = sdl_run_out,
499 .write = sdl_write_out,
500 .ctl_out = sdl_ctl_out,
501 };
502
503 struct audio_driver sdl_audio_driver = {
504 .name = "sdl",
505 .descr = "SDL http://www.libsdl.org",
506 .options = sdl_options,
507 .init = sdl_audio_init,
508 .fini = sdl_audio_fini,
509 .pcm_ops = &sdl_pcm_ops,
510 .can_be_default = 1,
511 .max_voices_out = 1,
512 .max_voices_in = 0,
513 .voice_size_out = sizeof (SDLVoiceOut),
514 .voice_size_in = 0
515 };