xref: /openbmc/qemu/audio/audio_template.h (revision 52f2b896)
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) (struct audio_driver *drv)
40 {
41     AudioState *s = &glob_audio_state;
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 int 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 (%d samples)\n",
83                hw->samples);
84         return -1;
85     }
86 
87     return 0;
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     AudioState *s = &glob_audio_state;
187     HW *hw = *hwp;
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) (HW *hw)
203 {
204     AudioState *s = &glob_audio_state;
205     return hw ? hw->entries.le_next : glue (s->hw_head_, TYPE).lh_first;
206 }
207 
208 static HW *glue (audio_pcm_hw_find_any_enabled_, TYPE) (HW *hw)
209 {
210     while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) {
211         if (hw->enabled) {
212             return hw;
213         }
214     }
215     return NULL;
216 }
217 
218 static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
219     HW *hw,
220     struct audsettings *as
221     )
222 {
223     while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) {
224         if (audio_pcm_info_eq (&hw->info, as)) {
225             return hw;
226         }
227     }
228     return NULL;
229 }
230 
231 static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as)
232 {
233     HW *hw;
234     AudioState *s = &glob_audio_state;
235     struct audio_driver *drv = s->drv;
236 
237     if (!glue (s->nb_hw_voices_, TYPE)) {
238         return NULL;
239     }
240 
241     if (audio_bug(__func__, !drv)) {
242         dolog ("No host audio driver\n");
243         return NULL;
244     }
245 
246     if (audio_bug(__func__, !drv->pcm_ops)) {
247         dolog ("Host audio driver without pcm_ops\n");
248         return NULL;
249     }
250 
251     hw = audio_calloc(__func__, 1, glue(drv->voice_size_, TYPE));
252     if (!hw) {
253         dolog ("Can not allocate voice `%s' size %d\n",
254                drv->name, glue (drv->voice_size_, TYPE));
255         return NULL;
256     }
257 
258     hw->pcm_ops = drv->pcm_ops;
259     hw->ctl_caps = drv->ctl_caps;
260 
261     QLIST_INIT (&hw->sw_head);
262 #ifdef DAC
263     QLIST_INIT (&hw->cap_head);
264 #endif
265     if (glue (hw->pcm_ops->init_, TYPE) (hw, as, s->drv_opaque)) {
266         goto err0;
267     }
268 
269     if (audio_bug(__func__, hw->samples <= 0)) {
270         dolog ("hw->samples=%d\n", hw->samples);
271         goto err1;
272     }
273 
274 #ifdef DAC
275     hw->clip = mixeng_clip
276 #else
277     hw->conv = mixeng_conv
278 #endif
279         [hw->info.nchannels == 2]
280         [hw->info.sign]
281         [hw->info.swap_endianness]
282         [audio_bits_to_index (hw->info.bits)];
283 
284     if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
285         goto err1;
286     }
287 
288     QLIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
289     glue (s->nb_hw_voices_, TYPE) -= 1;
290 #ifdef DAC
291     audio_attach_capture (hw);
292 #endif
293     return hw;
294 
295  err1:
296     glue (hw->pcm_ops->fini_, TYPE) (hw);
297  err0:
298     g_free (hw);
299     return NULL;
300 }
301 
302 AudiodevPerDirectionOptions *glue(audio_get_pdo_, TYPE)(Audiodev *dev)
303 {
304     switch (dev->driver) {
305     case AUDIODEV_DRIVER_NONE:
306         return dev->u.none.TYPE;
307     case AUDIODEV_DRIVER_ALSA:
308         return qapi_AudiodevAlsaPerDirectionOptions_base(dev->u.alsa.TYPE);
309     case AUDIODEV_DRIVER_COREAUDIO:
310         return qapi_AudiodevCoreaudioPerDirectionOptions_base(
311             dev->u.coreaudio.TYPE);
312     case AUDIODEV_DRIVER_DSOUND:
313         return dev->u.dsound.TYPE;
314     case AUDIODEV_DRIVER_OSS:
315         return qapi_AudiodevOssPerDirectionOptions_base(dev->u.oss.TYPE);
316     case AUDIODEV_DRIVER_PA:
317         return qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.TYPE);
318     case AUDIODEV_DRIVER_SDL:
319         return dev->u.sdl.TYPE;
320     case AUDIODEV_DRIVER_SPICE:
321         return dev->u.spice.TYPE;
322     case AUDIODEV_DRIVER_WAV:
323         return dev->u.wav.TYPE;
324 
325     case AUDIODEV_DRIVER__MAX:
326         break;
327     }
328     abort();
329 }
330 
331 static HW *glue (audio_pcm_hw_add_, TYPE) (struct audsettings *as)
332 {
333     HW *hw;
334     AudioState *s = &glob_audio_state;
335     AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev);
336 
337     if (pdo->fixed_settings) {
338         hw = glue (audio_pcm_hw_add_new_, TYPE) (as);
339         if (hw) {
340             return hw;
341         }
342     }
343 
344     hw = glue (audio_pcm_hw_find_specific_, TYPE) (NULL, as);
345     if (hw) {
346         return hw;
347     }
348 
349     hw = glue (audio_pcm_hw_add_new_, TYPE) (as);
350     if (hw) {
351         return hw;
352     }
353 
354     return glue (audio_pcm_hw_find_any_, TYPE) (NULL);
355 }
356 
357 static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
358     const char *sw_name,
359     struct audsettings *as
360     )
361 {
362     SW *sw;
363     HW *hw;
364     struct audsettings hw_as;
365     AudioState *s = &glob_audio_state;
366     AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev);
367 
368     if (pdo->fixed_settings) {
369         hw_as = audiodev_to_audsettings(pdo);
370     }
371     else {
372         hw_as = *as;
373     }
374 
375     sw = audio_calloc(__func__, 1, sizeof(*sw));
376     if (!sw) {
377         dolog ("Could not allocate soft voice `%s' (%zu bytes)\n",
378                sw_name ? sw_name : "unknown", sizeof (*sw));
379         goto err1;
380     }
381 
382     hw = glue (audio_pcm_hw_add_, TYPE) (&hw_as);
383     if (!hw) {
384         goto err2;
385     }
386 
387     glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw);
388 
389     if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) {
390         goto err3;
391     }
392 
393     return sw;
394 
395 err3:
396     glue (audio_pcm_hw_del_sw_, TYPE) (sw);
397     glue (audio_pcm_hw_gc_, TYPE) (&hw);
398 err2:
399     g_free (sw);
400 err1:
401     return NULL;
402 }
403 
404 static void glue (audio_close_, TYPE) (SW *sw)
405 {
406     glue (audio_pcm_sw_fini_, TYPE) (sw);
407     glue (audio_pcm_hw_del_sw_, TYPE) (sw);
408     glue (audio_pcm_hw_gc_, TYPE) (&sw->hw);
409     g_free (sw);
410 }
411 
412 void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw)
413 {
414     if (sw) {
415         if (audio_bug(__func__, !card)) {
416             dolog ("card=%p\n", card);
417             return;
418         }
419 
420         glue (audio_close_, TYPE) (sw);
421     }
422 }
423 
424 SW *glue (AUD_open_, TYPE) (
425     QEMUSoundCard *card,
426     SW *sw,
427     const char *name,
428     void *callback_opaque ,
429     audio_callback_fn callback_fn,
430     struct audsettings *as
431     )
432 {
433     AudioState *s = &glob_audio_state;
434     AudiodevPerDirectionOptions *pdo = glue(audio_get_pdo_, TYPE)(s->dev);
435 
436     if (audio_bug(__func__, !card || !name || !callback_fn || !as)) {
437         dolog ("card=%p name=%p callback_fn=%p as=%p\n",
438                card, name, callback_fn, as);
439         goto fail;
440     }
441 
442     ldebug ("open %s, freq %d, nchannels %d, fmt %d\n",
443             name, as->freq, as->nchannels, as->fmt);
444 
445     if (audio_bug(__func__, audio_validate_settings(as))) {
446         audio_print_settings (as);
447         goto fail;
448     }
449 
450     if (audio_bug(__func__, !s->drv)) {
451         dolog ("Can not open `%s' (no host audio driver)\n", name);
452         goto fail;
453     }
454 
455     if (sw && audio_pcm_info_eq (&sw->info, as)) {
456         return sw;
457     }
458 
459     if (!pdo->fixed_settings && sw) {
460         glue (AUD_close_, TYPE) (card, sw);
461         sw = NULL;
462     }
463 
464     if (sw) {
465         HW *hw = sw->hw;
466 
467         if (!hw) {
468             dolog ("Internal logic error voice `%s' has no hardware store\n",
469                    SW_NAME (sw));
470             goto fail;
471         }
472 
473         glue (audio_pcm_sw_fini_, TYPE) (sw);
474         if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) {
475             goto fail;
476         }
477     }
478     else {
479         sw = glue (audio_pcm_create_voice_pair_, TYPE) (name, as);
480         if (!sw) {
481             dolog ("Failed to create voice `%s'\n", name);
482             return NULL;
483         }
484     }
485 
486     sw->card = card;
487     sw->vol = nominal_volume;
488     sw->callback.fn = callback_fn;
489     sw->callback.opaque = callback_opaque;
490 
491 #ifdef DEBUG_AUDIO
492     dolog ("%s\n", name);
493     audio_pcm_print_info ("hw", &sw->hw->info);
494     audio_pcm_print_info ("sw", &sw->info);
495 #endif
496 
497     return sw;
498 
499  fail:
500     glue (AUD_close_, TYPE) (card, sw);
501     return NULL;
502 }
503 
504 int glue (AUD_is_active_, TYPE) (SW *sw)
505 {
506     return sw ? sw->active : 0;
507 }
508 
509 void glue (AUD_init_time_stamp_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts)
510 {
511     if (!sw) {
512         return;
513     }
514 
515     ts->old_ts = sw->hw->ts_helper;
516 }
517 
518 uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts)
519 {
520     uint64_t delta, cur_ts, old_ts;
521 
522     if (!sw) {
523         return 0;
524     }
525 
526     cur_ts = sw->hw->ts_helper;
527     old_ts = ts->old_ts;
528     /* dolog ("cur %" PRId64 " old %" PRId64 "\n", cur_ts, old_ts); */
529 
530     if (cur_ts >= old_ts) {
531         delta = cur_ts - old_ts;
532     }
533     else {
534         delta = UINT64_MAX - old_ts + cur_ts;
535     }
536 
537     if (!delta) {
538         return 0;
539     }
540 
541     return muldiv64 (delta, sw->hw->info.freq, 1000000);
542 }
543 
544 #undef TYPE
545 #undef HW
546 #undef SW
547 #undef HWBUF
548 #undef NAME
549