ia64/xen-unstable

view tools/ioemu/audio/sdlaudio.c @ 15841:c5f735271e22

[IA64] Foreign p2m: Fix vti domain builder.

It should set arch_domain::convmem_end.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Alex Williamson <alex.williamson@hp.com>
date Thu Sep 06 13:48:43 2007 -0600 (2007-09-06)
parents 08a11694b109
children
line source
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 <SDL.h>
25 #include <SDL_thread.h>
26 #include "vl.h"
28 #define AUDIO_CAP "sdl"
29 #include "audio_int.h"
31 typedef struct SDLVoiceOut {
32 HWVoiceOut hw;
33 int live;
34 int rpos;
35 int decr;
36 } SDLVoiceOut;
38 static struct {
39 int nb_samples;
40 } conf = {
41 1024
42 };
44 struct SDLAudioState {
45 int exit;
46 SDL_mutex *mutex;
47 SDL_sem *sem;
48 int initialized;
49 } glob_sdl;
50 typedef struct SDLAudioState SDLAudioState;
52 static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
53 {
54 va_list ap;
56 va_start (ap, fmt);
57 AUD_vlog (AUDIO_CAP, fmt, ap);
58 va_end (ap);
60 AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
61 }
63 static int sdl_lock (SDLAudioState *s, const char *forfn)
64 {
65 if (SDL_LockMutex (s->mutex)) {
66 sdl_logerr ("SDL_LockMutex for %s failed\n", forfn);
67 return -1;
68 }
69 return 0;
70 }
72 static int sdl_unlock (SDLAudioState *s, const char *forfn)
73 {
74 if (SDL_UnlockMutex (s->mutex)) {
75 sdl_logerr ("SDL_UnlockMutex for %s failed\n", forfn);
76 return -1;
77 }
78 return 0;
79 }
81 static int sdl_post (SDLAudioState *s, const char *forfn)
82 {
83 if (SDL_SemPost (s->sem)) {
84 sdl_logerr ("SDL_SemPost for %s failed\n", forfn);
85 return -1;
86 }
87 return 0;
88 }
90 static int sdl_wait (SDLAudioState *s, const char *forfn)
91 {
92 if (SDL_SemWait (s->sem)) {
93 sdl_logerr ("SDL_SemWait for %s failed\n", forfn);
94 return -1;
95 }
96 return 0;
97 }
99 static int sdl_unlock_and_post (SDLAudioState *s, const char *forfn)
100 {
101 if (sdl_unlock (s, forfn)) {
102 return -1;
103 }
105 return sdl_post (s, forfn);
106 }
108 static int aud_to_sdlfmt (audfmt_e fmt, int *shift)
109 {
110 switch (fmt) {
111 case AUD_FMT_S8:
112 *shift = 0;
113 return AUDIO_S8;
115 case AUD_FMT_U8:
116 *shift = 0;
117 return AUDIO_U8;
119 case AUD_FMT_S16:
120 *shift = 1;
121 return AUDIO_S16LSB;
123 case AUD_FMT_U16:
124 *shift = 1;
125 return AUDIO_U16LSB;
127 default:
128 dolog ("Internal logic error: Bad audio format %d\n", fmt);
129 #ifdef DEBUG_AUDIO
130 abort ();
131 #endif
132 return AUDIO_U8;
133 }
134 }
136 static int sdl_to_audfmt (int sdlfmt, audfmt_e *fmt, int *endianess)
137 {
138 switch (sdlfmt) {
139 case AUDIO_S8:
140 *endianess = 0;
141 *fmt = AUD_FMT_S8;
142 break;
144 case AUDIO_U8:
145 *endianess = 0;
146 *fmt = AUD_FMT_U8;
147 break;
149 case AUDIO_S16LSB:
150 *endianess = 0;
151 *fmt = AUD_FMT_S16;
152 break;
154 case AUDIO_U16LSB:
155 *endianess = 0;
156 *fmt = AUD_FMT_U16;
157 break;
159 case AUDIO_S16MSB:
160 *endianess = 1;
161 *fmt = AUD_FMT_S16;
162 break;
164 case AUDIO_U16MSB:
165 *endianess = 1;
166 *fmt = AUD_FMT_U16;
167 break;
169 default:
170 dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
171 return -1;
172 }
174 return 0;
175 }
177 static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
178 {
179 int status;
181 status = SDL_OpenAudio (req, obt);
182 if (status) {
183 sdl_logerr ("SDL_OpenAudio failed\n");
184 }
185 return status;
186 }
188 static void sdl_close (SDLAudioState *s)
189 {
190 if (s->initialized) {
191 sdl_lock (s, "sdl_close");
192 s->exit = 1;
193 sdl_unlock_and_post (s, "sdl_close");
194 SDL_PauseAudio (1);
195 SDL_CloseAudio ();
196 s->initialized = 0;
197 }
198 }
200 static void sdl_callback (void *opaque, Uint8 *buf, int len)
201 {
202 SDLVoiceOut *sdl = opaque;
203 SDLAudioState *s = &glob_sdl;
204 HWVoiceOut *hw = &sdl->hw;
205 int samples = len >> hw->info.shift;
207 if (s->exit) {
208 return;
209 }
211 while (samples) {
212 int to_mix, decr;
214 /* dolog ("in callback samples=%d\n", samples); */
215 sdl_wait (s, "sdl_callback");
216 if (s->exit) {
217 return;
218 }
220 if (sdl_lock (s, "sdl_callback")) {
221 return;
222 }
224 if (audio_bug (AUDIO_FUNC, sdl->live < 0 || sdl->live > hw->samples)) {
225 dolog ("sdl->live=%d hw->samples=%d\n",
226 sdl->live, hw->samples);
227 return;
228 }
230 if (!sdl->live) {
231 goto again;
232 }
234 /* dolog ("in callback live=%d\n", live); */
235 to_mix = audio_MIN (samples, sdl->live);
236 decr = to_mix;
237 while (to_mix) {
238 int chunk = audio_MIN (to_mix, hw->samples - hw->rpos);
239 st_sample_t *src = hw->mix_buf + hw->rpos;
241 /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
242 hw->clip (buf, src, chunk);
243 sdl->rpos = (sdl->rpos + chunk) % hw->samples;
244 to_mix -= chunk;
245 buf += chunk << hw->info.shift;
246 }
247 samples -= decr;
248 sdl->live -= decr;
249 sdl->decr += decr;
251 again:
252 if (sdl_unlock (s, "sdl_callback")) {
253 return;
254 }
255 }
256 /* dolog ("done len=%d\n", len); */
257 }
259 static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
260 {
261 return audio_pcm_sw_write (sw, buf, len);
262 }
264 static int sdl_run_out (HWVoiceOut *hw)
265 {
266 int decr, live;
267 SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
268 SDLAudioState *s = &glob_sdl;
270 if (sdl_lock (s, "sdl_callback")) {
271 return 0;
272 }
274 live = audio_pcm_hw_get_live_out (hw);
276 if (sdl->decr > live) {
277 ldebug ("sdl->decr %d live %d sdl->live %d\n",
278 sdl->decr,
279 live,
280 sdl->live);
281 }
283 decr = audio_MIN (sdl->decr, live);
284 sdl->decr -= decr;
286 sdl->live = live - decr;
287 hw->rpos = sdl->rpos;
289 if (sdl->live > 0) {
290 sdl_unlock_and_post (s, "sdl_callback");
291 }
292 else {
293 sdl_unlock (s, "sdl_callback");
294 }
295 return decr;
296 }
298 static void sdl_fini_out (HWVoiceOut *hw)
299 {
300 (void) hw;
302 sdl_close (&glob_sdl);
303 }
305 static int sdl_init_out (HWVoiceOut *hw, audsettings_t *as)
306 {
307 SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
308 SDLAudioState *s = &glob_sdl;
309 SDL_AudioSpec req, obt;
310 int shift;
311 int endianess;
312 int err;
313 audfmt_e effective_fmt;
314 audsettings_t obt_as;
316 shift <<= as->nchannels == 2;
318 req.freq = as->freq;
319 req.format = aud_to_sdlfmt (as->fmt, &shift);
320 req.channels = as->nchannels;
321 req.samples = conf.nb_samples;
322 req.callback = sdl_callback;
323 req.userdata = sdl;
325 if (sdl_open (&req, &obt)) {
326 return -1;
327 }
329 err = sdl_to_audfmt (obt.format, &effective_fmt, &endianess);
330 if (err) {
331 sdl_close (s);
332 return -1;
333 }
335 obt_as.freq = obt.freq;
336 obt_as.nchannels = obt.channels;
337 obt_as.fmt = effective_fmt;
338 obt_as.endianness = endianess;
340 audio_pcm_init_info (&hw->info, &obt_as);
341 hw->samples = obt.samples;
343 s->initialized = 1;
344 s->exit = 0;
345 SDL_PauseAudio (0);
346 return 0;
347 }
349 static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
350 {
351 (void) hw;
353 switch (cmd) {
354 case VOICE_ENABLE:
355 SDL_PauseAudio (0);
356 break;
358 case VOICE_DISABLE:
359 SDL_PauseAudio (1);
360 break;
361 }
362 return 0;
363 }
365 static void *sdl_audio_init (void)
366 {
367 SDLAudioState *s = &glob_sdl;
369 if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
370 sdl_logerr ("SDL failed to initialize audio subsystem\n");
371 return NULL;
372 }
374 s->mutex = SDL_CreateMutex ();
375 if (!s->mutex) {
376 sdl_logerr ("Failed to create SDL mutex\n");
377 SDL_QuitSubSystem (SDL_INIT_AUDIO);
378 return NULL;
379 }
381 s->sem = SDL_CreateSemaphore (0);
382 if (!s->sem) {
383 sdl_logerr ("Failed to create SDL semaphore\n");
384 SDL_DestroyMutex (s->mutex);
385 SDL_QuitSubSystem (SDL_INIT_AUDIO);
386 return NULL;
387 }
389 return s;
390 }
392 static void sdl_audio_fini (void *opaque)
393 {
394 SDLAudioState *s = opaque;
395 sdl_close (s);
396 SDL_DestroySemaphore (s->sem);
397 SDL_DestroyMutex (s->mutex);
398 SDL_QuitSubSystem (SDL_INIT_AUDIO);
399 }
401 static struct audio_option sdl_options[] = {
402 {"SAMPLES", AUD_OPT_INT, &conf.nb_samples,
403 "Size of SDL buffer in samples", NULL, 0},
404 {NULL, 0, NULL, NULL, NULL, 0}
405 };
407 static struct audio_pcm_ops sdl_pcm_ops = {
408 sdl_init_out,
409 sdl_fini_out,
410 sdl_run_out,
411 sdl_write_out,
412 sdl_ctl_out,
414 NULL,
415 NULL,
416 NULL,
417 NULL,
418 NULL
419 };
421 struct audio_driver sdl_audio_driver = {
422 INIT_FIELD (name = ) "sdl",
423 INIT_FIELD (descr = ) "SDL http://www.libsdl.org",
424 INIT_FIELD (options = ) sdl_options,
425 INIT_FIELD (init = ) sdl_audio_init,
426 INIT_FIELD (fini = ) sdl_audio_fini,
427 INIT_FIELD (pcm_ops = ) &sdl_pcm_ops,
428 INIT_FIELD (can_be_default = ) 1,
429 INIT_FIELD (max_voices_out = ) 1,
430 INIT_FIELD (max_voices_in = ) 0,
431 INIT_FIELD (voice_size_out = ) sizeof (SDLVoiceOut),
432 INIT_FIELD (voice_size_in = ) 0
433 };