1 | /* |
2 | * QEMU Audio subsystem header |
3 | * |
4 | * Copyright (c) 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 | #ifdef DAC |
26 | #define NAME "playback" |
27 | #define HWBUF hw->mix_buf |
28 | #define TYPE out |
29 | #define HW HWVoiceOut |
30 | #define SW SWVoiceOut |
31 | #else |
32 | #define NAME "capture" |
33 | #define TYPE in |
34 | #define HW HWVoiceIn |
35 | #define SW SWVoiceIn |
36 | #define HWBUF hw->conv_buf |
37 | #endif |
38 | |
39 | static void glue(audio_init_nb_voices_, TYPE)(AudioState *s, |
40 | struct audio_driver *drv) |
41 | { |
42 | int max_voices = glue (drv->max_voices_, TYPE); |
43 | int voice_size = glue (drv->voice_size_, TYPE); |
44 | |
45 | if (glue (s->nb_hw_voices_, TYPE) > max_voices) { |
46 | if (!max_voices) { |
47 | #ifdef DAC |
48 | dolog ("Driver `%s' does not support " NAME "\n" , drv->name); |
49 | #endif |
50 | } |
51 | else { |
52 | dolog ("Driver `%s' does not support %d " NAME " voices, max %d\n" , |
53 | drv->name, |
54 | glue (s->nb_hw_voices_, TYPE), |
55 | max_voices); |
56 | } |
57 | glue (s->nb_hw_voices_, TYPE) = max_voices; |
58 | } |
59 | |
60 | if (audio_bug(__func__, !voice_size && max_voices)) { |
61 | dolog ("drv=`%s' voice_size=0 max_voices=%d\n" , |
62 | drv->name, max_voices); |
63 | glue (s->nb_hw_voices_, TYPE) = 0; |
64 | } |
65 | |
66 | if (audio_bug(__func__, voice_size && !max_voices)) { |
67 | dolog ("drv=`%s' voice_size=%d max_voices=0\n" , |
68 | drv->name, voice_size); |
69 | } |
70 | } |
71 | |
72 | static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw) |
73 | { |
74 | g_free (HWBUF); |
75 | HWBUF = NULL; |
76 | } |
77 | |
78 | static bool glue(audio_pcm_hw_alloc_resources_, TYPE)(HW *hw) |
79 | { |
80 | HWBUF = audio_calloc(__func__, hw->samples, sizeof(struct st_sample)); |
81 | if (!HWBUF) { |
82 | dolog("Could not allocate " NAME " buffer (%zu samples)\n" , |
83 | hw->samples); |
84 | return false; |
85 | } |
86 | |
87 | return true; |
88 | } |
89 | |
90 | static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw) |
91 | { |
92 | g_free (sw->buf); |
93 | |
94 | if (sw->rate) { |
95 | st_rate_stop (sw->rate); |
96 | } |
97 | |
98 | sw->buf = NULL; |
99 | sw->rate = NULL; |
100 | } |
101 | |
102 | static int glue (audio_pcm_sw_alloc_resources_, TYPE) (SW *sw) |
103 | { |
104 | int samples; |
105 | |
106 | samples = ((int64_t) sw->hw->samples << 32) / sw->ratio; |
107 | |
108 | sw->buf = audio_calloc(__func__, samples, sizeof(struct st_sample)); |
109 | if (!sw->buf) { |
110 | dolog ("Could not allocate buffer for `%s' (%d samples)\n" , |
111 | SW_NAME (sw), samples); |
112 | return -1; |
113 | } |
114 | |
115 | #ifdef DAC |
116 | sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq); |
117 | #else |
118 | sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq); |
119 | #endif |
120 | if (!sw->rate) { |
121 | g_free (sw->buf); |
122 | sw->buf = NULL; |
123 | return -1; |
124 | } |
125 | return 0; |
126 | } |
127 | |
128 | static int glue (audio_pcm_sw_init_, TYPE) ( |
129 | SW *sw, |
130 | HW *hw, |
131 | const char *name, |
132 | struct audsettings *as |
133 | ) |
134 | { |
135 | int err; |
136 | |
137 | audio_pcm_init_info (&sw->info, as); |
138 | sw->hw = hw; |
139 | sw->active = 0; |
140 | #ifdef DAC |
141 | sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq; |
142 | sw->total_hw_samples_mixed = 0; |
143 | sw->empty = 1; |
144 | #else |
145 | sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq; |
146 | #endif |
147 | |
148 | #ifdef DAC |
149 | sw->conv = mixeng_conv |
150 | #else |
151 | sw->clip = mixeng_clip |
152 | #endif |
153 | [sw->info.nchannels == 2] |
154 | [sw->info.sign] |
155 | [sw->info.swap_endianness] |
156 | [audio_bits_to_index (sw->info.bits)]; |
157 | |
158 | sw->name = g_strdup (name); |
159 | err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw); |
160 | if (err) { |
161 | g_free (sw->name); |
162 | sw->name = NULL; |
163 | } |
164 | return err; |
165 | } |
166 | |
167 | static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw) |
168 | { |
169 | glue (audio_pcm_sw_free_resources_, TYPE) (sw); |
170 | g_free (sw->name); |
171 | sw->name = NULL; |
172 | } |
173 | |
174 | static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw) |
175 | { |
176 | QLIST_INSERT_HEAD (&hw->sw_head, sw, entries); |
177 | } |
178 | |
179 | static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw) |
180 | { |
181 | QLIST_REMOVE (sw, entries); |
182 | } |
183 | |
184 | static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp) |
185 | { |
186 | HW *hw = *hwp; |
187 | AudioState *s = hw->s; |
188 | |
189 | if (!hw->sw_head.lh_first) { |
190 | #ifdef DAC |
191 | audio_detach_capture (hw); |
192 | #endif |
193 | QLIST_REMOVE (hw, entries); |
194 | glue (hw->pcm_ops->fini_, TYPE) (hw); |
195 | glue (s->nb_hw_voices_, TYPE) += 1; |
196 | glue (audio_pcm_hw_free_resources_ ,TYPE) (hw); |
197 | g_free (hw); |
198 | *hwp = NULL; |
199 | } |
200 | } |
201 | |
202 | static HW *glue(audio_pcm_hw_find_any_, TYPE)(AudioState *s, HW *hw) |
203 | { |
204 | return hw ? hw->entries.le_next : glue (s->hw_head_, TYPE).lh_first; |
205 | } |
206 | |
207 | static HW *glue(audio_pcm_hw_find_any_enabled_, TYPE)(AudioState *s, HW *hw) |
208 | { |
209 | while ((hw = glue(audio_pcm_hw_find_any_, TYPE)(s, hw))) { |
210 | if (hw->enabled) { |
211 | return hw; |
212 | } |
213 | } |
214 | return NULL; |
215 | } |
216 | |
217 | static HW *glue(audio_pcm_hw_find_specific_, TYPE)(AudioState *s, HW *hw, |
218 | struct audsettings *as) |
219 | { |
220 | while ((hw = glue(audio_pcm_hw_find_any_, TYPE)(s, hw))) { |
221 | if (audio_pcm_info_eq (&hw->info, as)) { |
222 | return hw; |
223 | } |
224 | } |
225 | return NULL; |
226 | } |
227 | |
228 | static HW *glue(audio_pcm_hw_add_new_, TYPE)(AudioState *s, |
229 | struct audsettings *as) |
230 | { |
231 | HW *hw; |
232 | struct audio_driver *drv = s->drv; |
233 | |
234 | if (!glue (s->nb_hw_voices_, TYPE)) { |
235 | return NULL; |
236 | } |
237 | |
238 | if (audio_bug(__func__, !drv)) { |
239 | dolog ("No host audio driver\n" ); |
240 | return NULL; |
241 | } |
242 | |
243 | if (audio_bug(__func__, !drv->pcm_ops)) { |
244 | dolog ("Host audio driver without pcm_ops\n" ); |
245 | return NULL; |
246 | } |
247 | |
248 | hw = audio_calloc(__func__, 1, glue(drv->voice_size_, TYPE)); |
249 | if (!hw) { |
250 | dolog ("Can not allocate voice `%s' size %d\n" , |
251 | drv->name, glue (drv->voice_size_, TYPE)); |
252 | return NULL; |
253 | } |
254 | |
255 | hw->s = s; |
256 | hw->pcm_ops = drv->pcm_ops; |
257 | hw->ctl_caps = drv->ctl_caps; |
258 | |
259 | QLIST_INIT (&hw->sw_head); |
260 | #ifdef DAC |
261 | QLIST_INIT (&hw->cap_head); |
262 | #endif |
263 | if (glue (hw->pcm_ops->init_, TYPE) (hw, as, s->drv_opaque)) { |
264 | goto err0; |
265 | } |
266 | |
267 | if (audio_bug(__func__, hw->samples <= 0)) { |
268 | dolog("hw->samples=%zd\n" , hw->samples); |
269 | goto err1; |
270 | } |
271 | |
272 | #ifdef DAC |
273 | hw->clip = mixeng_clip |
274 | #else |
275 | hw->conv = mixeng_conv |
276 | #endif |
277 | [hw->info.nchannels == 2] |
278 | [hw->info.sign] |
279 | [hw->info.swap_endianness] |
280 | [audio_bits_to_index (hw->info.bits)]; |
281 | |
282 | if (!glue(audio_pcm_hw_alloc_resources_, TYPE)(hw)) { |
283 | goto err1; |
284 | } |
285 | |
286 | QLIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries); |
287 | glue (s->nb_hw_voices_, TYPE) -= 1; |
288 | #ifdef DAC |
289 | audio_attach_capture (hw); |
290 | #endif |
291 | return hw; |
292 | |
293 | err1: |
294 | glue (hw->pcm_ops->fini_, TYPE) (hw); |
295 | err0: |
296 | g_free (hw); |
297 | return NULL; |
298 | } |
299 | |
300 | AudiodevPerDirectionOptions *glue(audio_get_pdo_, TYPE)(Audiodev *dev) |
301 | { |
302 | switch (dev->driver) { |
303 | case AUDIODEV_DRIVER_NONE: |
304 | return dev->u.none.TYPE; |
305 | case AUDIODEV_DRIVER_ALSA: |
306 | return qapi_AudiodevAlsaPerDirectionOptions_base(dev->u.alsa.TYPE); |
307 | case AUDIODEV_DRIVER_COREAUDIO: |
308 | return qapi_AudiodevCoreaudioPerDirectionOptions_base( |
309 | dev->u.coreaudio.TYPE); |
310 | case AUDIODEV_DRIVER_DSOUND: |
311 | return dev->u.dsound.TYPE; |
312 | case AUDIODEV_DRIVER_OSS: |
313 | return qapi_AudiodevOssPerDirectionOptions_base(dev->u.oss.TYPE); |
314 | case AUDIODEV_DRIVER_PA: |
315 | return qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.TYPE); |
316 | case AUDIODEV_DRIVER_SDL: |
317 | return dev->u.sdl.TYPE; |
318 | case AUDIODEV_DRIVER_SPICE: |
319 | return dev->u.spice.TYPE; |
320 | case AUDIODEV_DRIVER_WAV: |
321 | return dev->u.wav.TYPE; |
322 | |
323 | case AUDIODEV_DRIVER__MAX: |
324 | break; |
325 | } |
326 | abort(); |
327 | } |
328 | |
329 | static HW *glue(audio_pcm_hw_add_, TYPE)(AudioState *s, struct audsettings *as) |
330 | { |
331 | HW *hw; |
332 | AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev); |
333 | |
334 | if (pdo->fixed_settings) { |
335 | hw = glue(audio_pcm_hw_add_new_, TYPE)(s, as); |
336 | if (hw) { |
337 | return hw; |
338 | } |
339 | } |
340 | |
341 | hw = glue(audio_pcm_hw_find_specific_, TYPE)(s, NULL, as); |
342 | if (hw) { |
343 | return hw; |
344 | } |
345 | |
346 | hw = glue(audio_pcm_hw_add_new_, TYPE)(s, as); |
347 | if (hw) { |
348 | return hw; |
349 | } |
350 | |
351 | return glue(audio_pcm_hw_find_any_, TYPE)(s, NULL); |
352 | } |
353 | |
354 | static SW *glue(audio_pcm_create_voice_pair_, TYPE)( |
355 | AudioState *s, |
356 | const char *sw_name, |
357 | struct audsettings *as |
358 | ) |
359 | { |
360 | SW *sw; |
361 | HW *hw; |
362 | struct audsettings hw_as; |
363 | AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev); |
364 | |
365 | if (pdo->fixed_settings) { |
366 | hw_as = audiodev_to_audsettings(pdo); |
367 | } |
368 | else { |
369 | hw_as = *as; |
370 | } |
371 | |
372 | sw = audio_calloc(__func__, 1, sizeof(*sw)); |
373 | if (!sw) { |
374 | dolog ("Could not allocate soft voice `%s' (%zu bytes)\n" , |
375 | sw_name ? sw_name : "unknown" , sizeof (*sw)); |
376 | goto err1; |
377 | } |
378 | sw->s = s; |
379 | |
380 | hw = glue(audio_pcm_hw_add_, TYPE)(s, &hw_as); |
381 | if (!hw) { |
382 | goto err2; |
383 | } |
384 | |
385 | glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw); |
386 | |
387 | if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) { |
388 | goto err3; |
389 | } |
390 | |
391 | return sw; |
392 | |
393 | err3: |
394 | glue (audio_pcm_hw_del_sw_, TYPE) (sw); |
395 | glue (audio_pcm_hw_gc_, TYPE) (&hw); |
396 | err2: |
397 | g_free (sw); |
398 | err1: |
399 | return NULL; |
400 | } |
401 | |
402 | static void glue (audio_close_, TYPE) (SW *sw) |
403 | { |
404 | glue (audio_pcm_sw_fini_, TYPE) (sw); |
405 | glue (audio_pcm_hw_del_sw_, TYPE) (sw); |
406 | glue (audio_pcm_hw_gc_, TYPE) (&sw->hw); |
407 | g_free (sw); |
408 | } |
409 | |
410 | void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw) |
411 | { |
412 | if (sw) { |
413 | if (audio_bug(__func__, !card)) { |
414 | dolog ("card=%p\n" , card); |
415 | return; |
416 | } |
417 | |
418 | glue (audio_close_, TYPE) (sw); |
419 | } |
420 | } |
421 | |
422 | SW *glue (AUD_open_, TYPE) ( |
423 | QEMUSoundCard *card, |
424 | SW *sw, |
425 | const char *name, |
426 | void *callback_opaque , |
427 | audio_callback_fn callback_fn, |
428 | struct audsettings *as |
429 | ) |
430 | { |
431 | AudioState *s = card->state; |
432 | AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev); |
433 | |
434 | if (audio_bug(__func__, !card || !name || !callback_fn || !as)) { |
435 | dolog ("card=%p name=%p callback_fn=%p as=%p\n" , |
436 | card, name, callback_fn, as); |
437 | goto fail; |
438 | } |
439 | |
440 | ldebug ("open %s, freq %d, nchannels %d, fmt %d\n" , |
441 | name, as->freq, as->nchannels, as->fmt); |
442 | |
443 | if (audio_bug(__func__, audio_validate_settings(as))) { |
444 | audio_print_settings (as); |
445 | goto fail; |
446 | } |
447 | |
448 | if (audio_bug(__func__, !s->drv)) { |
449 | dolog ("Can not open `%s' (no host audio driver)\n" , name); |
450 | goto fail; |
451 | } |
452 | |
453 | if (sw && audio_pcm_info_eq (&sw->info, as)) { |
454 | return sw; |
455 | } |
456 | |
457 | if (!pdo->fixed_settings && sw) { |
458 | glue (AUD_close_, TYPE) (card, sw); |
459 | sw = NULL; |
460 | } |
461 | |
462 | if (sw) { |
463 | HW *hw = sw->hw; |
464 | |
465 | if (!hw) { |
466 | dolog ("Internal logic error voice `%s' has no hardware store\n" , |
467 | SW_NAME (sw)); |
468 | goto fail; |
469 | } |
470 | |
471 | glue (audio_pcm_sw_fini_, TYPE) (sw); |
472 | if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) { |
473 | goto fail; |
474 | } |
475 | } |
476 | else { |
477 | sw = glue(audio_pcm_create_voice_pair_, TYPE)(s, name, as); |
478 | if (!sw) { |
479 | dolog ("Failed to create voice `%s'\n" , name); |
480 | return NULL; |
481 | } |
482 | } |
483 | |
484 | sw->card = card; |
485 | sw->vol = nominal_volume; |
486 | sw->callback.fn = callback_fn; |
487 | sw->callback.opaque = callback_opaque; |
488 | |
489 | #ifdef DEBUG_AUDIO |
490 | dolog ("%s\n" , name); |
491 | audio_pcm_print_info ("hw" , &sw->hw->info); |
492 | audio_pcm_print_info ("sw" , &sw->info); |
493 | #endif |
494 | |
495 | return sw; |
496 | |
497 | fail: |
498 | glue (AUD_close_, TYPE) (card, sw); |
499 | return NULL; |
500 | } |
501 | |
502 | int glue (AUD_is_active_, TYPE) (SW *sw) |
503 | { |
504 | return sw ? sw->active : 0; |
505 | } |
506 | |
507 | void glue (AUD_init_time_stamp_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) |
508 | { |
509 | if (!sw) { |
510 | return; |
511 | } |
512 | |
513 | ts->old_ts = sw->hw->ts_helper; |
514 | } |
515 | |
516 | uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts) |
517 | { |
518 | uint64_t delta, cur_ts, old_ts; |
519 | |
520 | if (!sw) { |
521 | return 0; |
522 | } |
523 | |
524 | cur_ts = sw->hw->ts_helper; |
525 | old_ts = ts->old_ts; |
526 | /* dolog ("cur %" PRId64 " old %" PRId64 "\n", cur_ts, old_ts); */ |
527 | |
528 | if (cur_ts >= old_ts) { |
529 | delta = cur_ts - old_ts; |
530 | } |
531 | else { |
532 | delta = UINT64_MAX - old_ts + cur_ts; |
533 | } |
534 | |
535 | if (!delta) { |
536 | return 0; |
537 | } |
538 | |
539 | return muldiv64 (delta, sw->hw->info.freq, 1000000); |
540 | } |
541 | |
542 | #undef TYPE |
543 | #undef HW |
544 | #undef SW |
545 | #undef HWBUF |
546 | #undef NAME |
547 | |