x86: acpi: introduce AcpiPmInfo::smi_on_cpuhp
[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 } SDLVoiceOut;
45
46 static struct SDLAudioState {
47 int exit;
48 int initialized;
49 bool driver_created;
50 Audiodev *dev;
51 } glob_sdl;
52 typedef struct SDLAudioState SDLAudioState;
53
54 static 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
65 static 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 /* no unsigned 32-bit support in SDL */
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
97 static 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
158 static 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 /* Make sure potential threads created by SDL don't hog signals. */
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 /* We have failed to restore original signal mask, all bets are off,
189 so exit the process */
190 exit (EXIT_FAILURE);
191 }
192 #endif
193 return status;
194 }
195
196 static 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
208 static 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 /* dolog ("in callback samples=%zu live=%zu\n", samples, sdl->live); */
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 /* clear remaining buffer that we couldn't fill with data */
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
256 SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
257 (hw, size), *size = 0, sdl_unlock)
258 SDL_WRAPPER_FUNC(put_buffer_out, size_t,
259 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size),
260 /*nothing*/, sdl_unlock_and_post)
261 SDL_WRAPPER_FUNC(write, size_t,
262 (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size),
263 /*nothing*/, sdl_unlock_and_post)
264
265 #undef SDL_WRAPPER_FUNC
266
267 static void sdl_fini_out (HWVoiceOut *hw)
268 {
269 (void) hw;
270
271 sdl_close (&glob_sdl);
272 }
273
274 static 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
316 static void sdl_enable_out(HWVoiceOut *hw, bool enable)
317 {
318 SDL_PauseAudio(!enable);
319 }
320
321 static 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
339 static 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
348 static struct audio_pcm_ops sdl_pcm_ops = {
349 .init_out = sdl_init_out,
350 .fini_out = sdl_fini_out,
351 /* wrapper for audio_generic_write */
352 .write = sdl_write,
353 /* wrapper for audio_generic_get_buffer_out */
354 .get_buffer_out = sdl_get_buffer_out,
355 /* wrapper for audio_generic_put_buffer_out */
356 .put_buffer_out = sdl_put_buffer_out,
357 .enable_out = sdl_enable_out,
358 };
359
360 static 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
373 static void register_audio_sdl(void)
374 {
375 audio_driver_register(&sdl_audio_driver);
376 }
377 type_init(register_audio_sdl);