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
39static 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
72static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw)
73{
74 g_free (HWBUF);
75 HWBUF = NULL;
76}
77
78static 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
90static 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
102static 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
128static 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
167static 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
174static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw)
175{
176 QLIST_INSERT_HEAD (&hw->sw_head, sw, entries);
177}
178
179static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw)
180{
181 QLIST_REMOVE (sw, entries);
182}
183
184static 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
202static 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
207static 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
217static 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
228static 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
300AudiodevPerDirectionOptions *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
329static 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
354static 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
393err3:
394 glue (audio_pcm_hw_del_sw_, TYPE) (sw);
395 glue (audio_pcm_hw_gc_, TYPE) (&hw);
396err2:
397 g_free (sw);
398err1:
399 return NULL;
400}
401
402static 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
410void 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
422SW *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
502int glue (AUD_is_active_, TYPE) (SW *sw)
503{
504 return sw ? sw->active : 0;
505}
506
507void 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
516uint64_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