GRLIB UART: Add RX channel
[qemu.git] / audio / audio_template.h
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 (AUDIO_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 (AUDIO_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 if (HWBUF) {
75 g_free (HWBUF);
76 }
77
78 HWBUF = NULL;
79 }
80
81 static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw)
82 {
83 HWBUF = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (struct st_sample));
84 if (!HWBUF) {
85 dolog ("Could not allocate " NAME " buffer (%d samples)\n",
86 hw->samples);
87 return -1;
88 }
89
90 return 0;
91 }
92
93 static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw)
94 {
95 if (sw->buf) {
96 g_free (sw->buf);
97 }
98
99 if (sw->rate) {
100 st_rate_stop (sw->rate);
101 }
102
103 sw->buf = NULL;
104 sw->rate = NULL;
105 }
106
107 static int glue (audio_pcm_sw_alloc_resources_, TYPE) (SW *sw)
108 {
109 int samples;
110
111 samples = ((int64_t) sw->hw->samples << 32) / sw->ratio;
112
113 sw->buf = audio_calloc (AUDIO_FUNC, samples, sizeof (struct st_sample));
114 if (!sw->buf) {
115 dolog ("Could not allocate buffer for `%s' (%d samples)\n",
116 SW_NAME (sw), samples);
117 return -1;
118 }
119
120 #ifdef DAC
121 sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq);
122 #else
123 sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq);
124 #endif
125 if (!sw->rate) {
126 g_free (sw->buf);
127 sw->buf = NULL;
128 return -1;
129 }
130 return 0;
131 }
132
133 static int glue (audio_pcm_sw_init_, TYPE) (
134 SW *sw,
135 HW *hw,
136 const char *name,
137 struct audsettings *as
138 )
139 {
140 int err;
141
142 audio_pcm_init_info (&sw->info, as);
143 sw->hw = hw;
144 sw->active = 0;
145 #ifdef DAC
146 sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq;
147 sw->total_hw_samples_mixed = 0;
148 sw->empty = 1;
149 #else
150 sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq;
151 #endif
152
153 #ifdef DAC
154 sw->conv = mixeng_conv
155 #else
156 sw->clip = mixeng_clip
157 #endif
158 [sw->info.nchannels == 2]
159 [sw->info.sign]
160 [sw->info.swap_endianness]
161 [audio_bits_to_index (sw->info.bits)];
162
163 sw->name = g_strdup (name);
164 err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw);
165 if (err) {
166 g_free (sw->name);
167 sw->name = NULL;
168 }
169 return err;
170 }
171
172 static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw)
173 {
174 glue (audio_pcm_sw_free_resources_, TYPE) (sw);
175 if (sw->name) {
176 g_free (sw->name);
177 sw->name = NULL;
178 }
179 }
180
181 static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw)
182 {
183 QLIST_INSERT_HEAD (&hw->sw_head, sw, entries);
184 }
185
186 static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw)
187 {
188 QLIST_REMOVE (sw, entries);
189 }
190
191 static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp)
192 {
193 AudioState *s = &glob_audio_state;
194 HW *hw = *hwp;
195
196 if (!hw->sw_head.lh_first) {
197 #ifdef DAC
198 audio_detach_capture (hw);
199 #endif
200 QLIST_REMOVE (hw, entries);
201 glue (s->nb_hw_voices_, TYPE) += 1;
202 glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);
203 glue (hw->pcm_ops->fini_, TYPE) (hw);
204 g_free (hw);
205 *hwp = NULL;
206 }
207 }
208
209 static HW *glue (audio_pcm_hw_find_any_, TYPE) (HW *hw)
210 {
211 AudioState *s = &glob_audio_state;
212 return hw ? hw->entries.le_next : glue (s->hw_head_, TYPE).lh_first;
213 }
214
215 static HW *glue (audio_pcm_hw_find_any_enabled_, TYPE) (HW *hw)
216 {
217 while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) {
218 if (hw->enabled) {
219 return hw;
220 }
221 }
222 return NULL;
223 }
224
225 static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
226 HW *hw,
227 struct audsettings *as
228 )
229 {
230 while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) {
231 if (audio_pcm_info_eq (&hw->info, as)) {
232 return hw;
233 }
234 }
235 return NULL;
236 }
237
238 static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as)
239 {
240 HW *hw;
241 AudioState *s = &glob_audio_state;
242 struct audio_driver *drv = s->drv;
243
244 if (!glue (s->nb_hw_voices_, TYPE)) {
245 return NULL;
246 }
247
248 if (audio_bug (AUDIO_FUNC, !drv)) {
249 dolog ("No host audio driver\n");
250 return NULL;
251 }
252
253 if (audio_bug (AUDIO_FUNC, !drv->pcm_ops)) {
254 dolog ("Host audio driver without pcm_ops\n");
255 return NULL;
256 }
257
258 hw = audio_calloc (AUDIO_FUNC, 1, glue (drv->voice_size_, TYPE));
259 if (!hw) {
260 dolog ("Can not allocate voice `%s' size %d\n",
261 drv->name, glue (drv->voice_size_, TYPE));
262 return NULL;
263 }
264
265 hw->pcm_ops = drv->pcm_ops;
266 QLIST_INIT (&hw->sw_head);
267 #ifdef DAC
268 QLIST_INIT (&hw->cap_head);
269 #endif
270 if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
271 goto err0;
272 }
273
274 if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) {
275 dolog ("hw->samples=%d\n", hw->samples);
276 goto err1;
277 }
278
279 #ifdef DAC
280 hw->clip = mixeng_clip
281 #else
282 hw->conv = mixeng_conv
283 #endif
284 [hw->info.nchannels == 2]
285 [hw->info.sign]
286 [hw->info.swap_endianness]
287 [audio_bits_to_index (hw->info.bits)];
288
289 if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
290 goto err1;
291 }
292
293 QLIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
294 glue (s->nb_hw_voices_, TYPE) -= 1;
295 #ifdef DAC
296 audio_attach_capture (hw);
297 #endif
298 return hw;
299
300 err1:
301 glue (hw->pcm_ops->fini_, TYPE) (hw);
302 err0:
303 g_free (hw);
304 return NULL;
305 }
306
307 static HW *glue (audio_pcm_hw_add_, TYPE) (struct audsettings *as)
308 {
309 HW *hw;
310
311 if (glue (conf.fixed_, TYPE).enabled && glue (conf.fixed_, TYPE).greedy) {
312 hw = glue (audio_pcm_hw_add_new_, TYPE) (as);
313 if (hw) {
314 return hw;
315 }
316 }
317
318 hw = glue (audio_pcm_hw_find_specific_, TYPE) (NULL, as);
319 if (hw) {
320 return hw;
321 }
322
323 hw = glue (audio_pcm_hw_add_new_, TYPE) (as);
324 if (hw) {
325 return hw;
326 }
327
328 return glue (audio_pcm_hw_find_any_, TYPE) (NULL);
329 }
330
331 static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
332 const char *sw_name,
333 struct audsettings *as
334 )
335 {
336 SW *sw;
337 HW *hw;
338 struct audsettings hw_as;
339
340 if (glue (conf.fixed_, TYPE).enabled) {
341 hw_as = glue (conf.fixed_, TYPE).settings;
342 }
343 else {
344 hw_as = *as;
345 }
346
347 sw = audio_calloc (AUDIO_FUNC, 1, sizeof (*sw));
348 if (!sw) {
349 dolog ("Could not allocate soft voice `%s' (%zu bytes)\n",
350 sw_name ? sw_name : "unknown", sizeof (*sw));
351 goto err1;
352 }
353
354 hw = glue (audio_pcm_hw_add_, TYPE) (&hw_as);
355 if (!hw) {
356 goto err2;
357 }
358
359 glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw);
360
361 if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) {
362 goto err3;
363 }
364
365 return sw;
366
367 err3:
368 glue (audio_pcm_hw_del_sw_, TYPE) (sw);
369 glue (audio_pcm_hw_gc_, TYPE) (&hw);
370 err2:
371 g_free (sw);
372 err1:
373 return NULL;
374 }
375
376 static void glue (audio_close_, TYPE) (SW *sw)
377 {
378 glue (audio_pcm_sw_fini_, TYPE) (sw);
379 glue (audio_pcm_hw_del_sw_, TYPE) (sw);
380 glue (audio_pcm_hw_gc_, TYPE) (&sw->hw);
381 g_free (sw);
382 }
383
384 void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw)
385 {
386 if (sw) {
387 if (audio_bug (AUDIO_FUNC, !card)) {
388 dolog ("card=%p\n", card);
389 return;
390 }
391
392 glue (audio_close_, TYPE) (sw);
393 }
394 }
395
396 SW *glue (AUD_open_, TYPE) (
397 QEMUSoundCard *card,
398 SW *sw,
399 const char *name,
400 void *callback_opaque ,
401 audio_callback_fn callback_fn,
402 struct audsettings *as
403 )
404 {
405 AudioState *s = &glob_audio_state;
406 #ifdef DAC
407 int live = 0;
408 SW *old_sw = NULL;
409 #endif
410
411 ldebug ("open %s, freq %d, nchannels %d, fmt %d\n",
412 name, as->freq, as->nchannels, as->fmt);
413
414 if (audio_bug (AUDIO_FUNC, !card || !name || !callback_fn || !as)) {
415 dolog ("card=%p name=%p callback_fn=%p as=%p\n",
416 card, name, callback_fn, as);
417 goto fail;
418 }
419
420 if (audio_bug (AUDIO_FUNC, audio_validate_settings (as))) {
421 audio_print_settings (as);
422 goto fail;
423 }
424
425 if (audio_bug (AUDIO_FUNC, !s->drv)) {
426 dolog ("Can not open `%s' (no host audio driver)\n", name);
427 goto fail;
428 }
429
430 if (sw && audio_pcm_info_eq (&sw->info, as)) {
431 return sw;
432 }
433
434 #ifdef DAC
435 if (conf.plive && sw && (!sw->active && !sw->empty)) {
436 live = sw->total_hw_samples_mixed;
437
438 #ifdef DEBUG_PLIVE
439 dolog ("Replacing voice %s with %d live samples\n", SW_NAME (sw), live);
440 dolog ("Old %s freq %d, bits %d, channels %d\n",
441 SW_NAME (sw), sw->info.freq, sw->info.bits, sw->info.nchannels);
442 dolog ("New %s freq %d, bits %d, channels %d\n",
443 name,
444 as->freq,
445 (as->fmt == AUD_FMT_S16 || as->fmt == AUD_FMT_U16) ? 16 : 8,
446 as->nchannels);
447 #endif
448
449 if (live) {
450 old_sw = sw;
451 old_sw->callback.fn = NULL;
452 sw = NULL;
453 }
454 }
455 #endif
456
457 if (!glue (conf.fixed_, TYPE).enabled && 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) (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 DAC
490 if (live) {
491 int mixed =
492 (live << old_sw->info.shift)
493 * old_sw->info.bytes_per_second
494 / sw->info.bytes_per_second;
495
496 #ifdef DEBUG_PLIVE
497 dolog ("Silence will be mixed %d\n", mixed);
498 #endif
499 sw->total_hw_samples_mixed += mixed;
500 }
501 #endif
502
503 #ifdef DEBUG_AUDIO
504 dolog ("%s\n", name);
505 audio_pcm_print_info ("hw", &sw->hw->info);
506 audio_pcm_print_info ("sw", &sw->info);
507 #endif
508
509 return sw;
510
511 fail:
512 glue (AUD_close_, TYPE) (card, sw);
513 return NULL;
514 }
515
516 int glue (AUD_is_active_, TYPE) (SW *sw)
517 {
518 return sw ? sw->active : 0;
519 }
520
521 void glue (AUD_init_time_stamp_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts)
522 {
523 if (!sw) {
524 return;
525 }
526
527 ts->old_ts = sw->hw->ts_helper;
528 }
529
530 uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts)
531 {
532 uint64_t delta, cur_ts, old_ts;
533
534 if (!sw) {
535 return 0;
536 }
537
538 cur_ts = sw->hw->ts_helper;
539 old_ts = ts->old_ts;
540 /* dolog ("cur %" PRId64 " old %" PRId64 "\n", cur_ts, old_ts); */
541
542 if (cur_ts >= old_ts) {
543 delta = cur_ts - old_ts;
544 }
545 else {
546 delta = UINT64_MAX - old_ts + cur_ts;
547 }
548
549 if (!delta) {
550 return 0;
551 }
552
553 return muldiv64 (delta, sw->hw->info.freq, 1000000);
554 }
555
556 #undef TYPE
557 #undef HW
558 #undef SW
559 #undef HWBUF
560 #undef NAME