Statistics
| Branch: | Revision:

root / audio / audio.c @ 39deb1e4

History | View | Annotate | Download (50.7 kB)

1
/*
2
 * QEMU Audio subsystem
3
 *
4
 * Copyright (c) 2003-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 "hw/hw.h"
25
#include "audio.h"
26
#include "monitor.h"
27
#include "qemu-timer.h"
28
#include "sysemu.h"
29

    
30
#define AUDIO_CAP "audio"
31
#include "audio_int.h"
32

    
33
/* #define DEBUG_PLIVE */
34
/* #define DEBUG_LIVE */
35
/* #define DEBUG_OUT */
36
/* #define DEBUG_CAPTURE */
37
/* #define DEBUG_POLL */
38

    
39
#define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown"
40

    
41

    
42
/* Order of CONFIG_AUDIO_DRIVERS is import.
43
   The 1st one is the one used by default, that is the reason
44
    that we generate the list.
45
*/
46
static struct audio_driver *drvtab[] = {
47
#ifdef CONFIG_SPICE
48
    &spice_audio_driver,
49
#endif
50
    CONFIG_AUDIO_DRIVERS
51
    &no_audio_driver,
52
    &wav_audio_driver
53
};
54

    
55
struct fixed_settings {
56
    int enabled;
57
    int nb_voices;
58
    int greedy;
59
    struct audsettings settings;
60
};
61

    
62
static struct {
63
    struct fixed_settings fixed_out;
64
    struct fixed_settings fixed_in;
65
    union {
66
        int hertz;
67
        int64_t ticks;
68
    } period;
69
    int plive;
70
    int log_to_monitor;
71
    int try_poll_in;
72
    int try_poll_out;
73
} conf = {
74
    .fixed_out = { /* DAC fixed settings */
75
        .enabled = 1,
76
        .nb_voices = 1,
77
        .greedy = 1,
78
        .settings = {
79
            .freq = 44100,
80
            .nchannels = 2,
81
            .fmt = AUD_FMT_S16,
82
            .endianness =  AUDIO_HOST_ENDIANNESS,
83
        }
84
    },
85

    
86
    .fixed_in = { /* ADC fixed settings */
87
        .enabled = 1,
88
        .nb_voices = 1,
89
        .greedy = 1,
90
        .settings = {
91
            .freq = 44100,
92
            .nchannels = 2,
93
            .fmt = AUD_FMT_S16,
94
            .endianness = AUDIO_HOST_ENDIANNESS,
95
        }
96
    },
97

    
98
    .period = { .hertz = 250 },
99
    .plive = 0,
100
    .log_to_monitor = 0,
101
    .try_poll_in = 1,
102
    .try_poll_out = 1,
103
};
104

    
105
static AudioState glob_audio_state;
106

    
107
struct mixeng_volume nominal_volume = {
108
    .mute = 0,
109
#ifdef FLOAT_MIXENG
110
    .r = 1.0,
111
    .l = 1.0,
112
#else
113
    .r = 1ULL << 32,
114
    .l = 1ULL << 32,
115
#endif
116
};
117

    
118
#ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED
119
#error No its not
120
#else
121
static void audio_print_options (const char *prefix,
122
                                 struct audio_option *opt);
123

    
124
int audio_bug (const char *funcname, int cond)
125
{
126
    if (cond) {
127
        static int shown;
128

    
129
        AUD_log (NULL, "A bug was just triggered in %s\n", funcname);
130
        if (!shown) {
131
            struct audio_driver *d;
132

    
133
            shown = 1;
134
            AUD_log (NULL, "Save all your work and restart without audio\n");
135
            AUD_log (NULL, "Please send bug report to av1474@comtv.ru\n");
136
            AUD_log (NULL, "I am sorry\n");
137
            d = glob_audio_state.drv;
138
            if (d) {
139
                audio_print_options (d->name, d->options);
140
            }
141
        }
142
        AUD_log (NULL, "Context:\n");
143

    
144
#if defined AUDIO_BREAKPOINT_ON_BUG
145
#  if defined HOST_I386
146
#    if defined __GNUC__
147
        __asm__ ("int3");
148
#    elif defined _MSC_VER
149
        _asm _emit 0xcc;
150
#    else
151
        abort ();
152
#    endif
153
#  else
154
        abort ();
155
#  endif
156
#endif
157
    }
158

    
159
    return cond;
160
}
161
#endif
162

    
163
static inline int audio_bits_to_index (int bits)
164
{
165
    switch (bits) {
166
    case 8:
167
        return 0;
168

    
169
    case 16:
170
        return 1;
171

    
172
    case 32:
173
        return 2;
174

    
175
    default:
176
        audio_bug ("bits_to_index", 1);
177
        AUD_log (NULL, "invalid bits %d\n", bits);
178
        return 0;
179
    }
180
}
181

    
182
void *audio_calloc (const char *funcname, int nmemb, size_t size)
183
{
184
    int cond;
185
    size_t len;
186

    
187
    len = nmemb * size;
188
    cond = !nmemb || !size;
189
    cond |= nmemb < 0;
190
    cond |= len < size;
191

    
192
    if (audio_bug ("audio_calloc", cond)) {
193
        AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n",
194
                 funcname);
195
        AUD_log (NULL, "nmemb=%d size=%zu (len=%zu)\n", nmemb, size, len);
196
        return NULL;
197
    }
198

    
199
    return qemu_mallocz (len);
200
}
201

    
202
static char *audio_alloc_prefix (const char *s)
203
{
204
    const char qemu_prefix[] = "QEMU_";
205
    size_t len, i;
206
    char *r, *u;
207

    
208
    if (!s) {
209
        return NULL;
210
    }
211

    
212
    len = strlen (s);
213
    r = qemu_malloc (len + sizeof (qemu_prefix));
214

    
215
    u = r + sizeof (qemu_prefix) - 1;
216

    
217
    pstrcpy (r, len + sizeof (qemu_prefix), qemu_prefix);
218
    pstrcat (r, len + sizeof (qemu_prefix), s);
219

    
220
    for (i = 0; i < len; ++i) {
221
        u[i] = qemu_toupper(u[i]);
222
    }
223

    
224
    return r;
225
}
226

    
227
static const char *audio_audfmt_to_string (audfmt_e fmt)
228
{
229
    switch (fmt) {
230
    case AUD_FMT_U8:
231
        return "U8";
232

    
233
    case AUD_FMT_U16:
234
        return "U16";
235

    
236
    case AUD_FMT_S8:
237
        return "S8";
238

    
239
    case AUD_FMT_S16:
240
        return "S16";
241

    
242
    case AUD_FMT_U32:
243
        return "U32";
244

    
245
    case AUD_FMT_S32:
246
        return "S32";
247
    }
248

    
249
    dolog ("Bogus audfmt %d returning S16\n", fmt);
250
    return "S16";
251
}
252

    
253
static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval,
254
                                        int *defaultp)
255
{
256
    if (!strcasecmp (s, "u8")) {
257
        *defaultp = 0;
258
        return AUD_FMT_U8;
259
    }
260
    else if (!strcasecmp (s, "u16")) {
261
        *defaultp = 0;
262
        return AUD_FMT_U16;
263
    }
264
    else if (!strcasecmp (s, "u32")) {
265
        *defaultp = 0;
266
        return AUD_FMT_U32;
267
    }
268
    else if (!strcasecmp (s, "s8")) {
269
        *defaultp = 0;
270
        return AUD_FMT_S8;
271
    }
272
    else if (!strcasecmp (s, "s16")) {
273
        *defaultp = 0;
274
        return AUD_FMT_S16;
275
    }
276
    else if (!strcasecmp (s, "s32")) {
277
        *defaultp = 0;
278
        return AUD_FMT_S32;
279
    }
280
    else {
281
        dolog ("Bogus audio format `%s' using %s\n",
282
               s, audio_audfmt_to_string (defval));
283
        *defaultp = 1;
284
        return defval;
285
    }
286
}
287

    
288
static audfmt_e audio_get_conf_fmt (const char *envname,
289
                                    audfmt_e defval,
290
                                    int *defaultp)
291
{
292
    const char *var = getenv (envname);
293
    if (!var) {
294
        *defaultp = 1;
295
        return defval;
296
    }
297
    return audio_string_to_audfmt (var, defval, defaultp);
298
}
299

    
300
static int audio_get_conf_int (const char *key, int defval, int *defaultp)
301
{
302
    int val;
303
    char *strval;
304

    
305
    strval = getenv (key);
306
    if (strval) {
307
        *defaultp = 0;
308
        val = atoi (strval);
309
        return val;
310
    }
311
    else {
312
        *defaultp = 1;
313
        return defval;
314
    }
315
}
316

    
317
static const char *audio_get_conf_str (const char *key,
318
                                       const char *defval,
319
                                       int *defaultp)
320
{
321
    const char *val = getenv (key);
322
    if (!val) {
323
        *defaultp = 1;
324
        return defval;
325
    }
326
    else {
327
        *defaultp = 0;
328
        return val;
329
    }
330
}
331

    
332
void AUD_vlog (const char *cap, const char *fmt, va_list ap)
333
{
334
    if (conf.log_to_monitor) {
335
        if (cap) {
336
            monitor_printf(default_mon, "%s: ", cap);
337
        }
338

    
339
        monitor_vprintf(default_mon, fmt, ap);
340
    }
341
    else {
342
        if (cap) {
343
            fprintf (stderr, "%s: ", cap);
344
        }
345

    
346
        vfprintf (stderr, fmt, ap);
347
    }
348
}
349

    
350
void AUD_log (const char *cap, const char *fmt, ...)
351
{
352
    va_list ap;
353

    
354
    va_start (ap, fmt);
355
    AUD_vlog (cap, fmt, ap);
356
    va_end (ap);
357
}
358

    
359
static void audio_print_options (const char *prefix,
360
                                 struct audio_option *opt)
361
{
362
    char *uprefix;
363

    
364
    if (!prefix) {
365
        dolog ("No prefix specified\n");
366
        return;
367
    }
368

    
369
    if (!opt) {
370
        dolog ("No options\n");
371
        return;
372
    }
373

    
374
    uprefix = audio_alloc_prefix (prefix);
375

    
376
    for (; opt->name; opt++) {
377
        const char *state = "default";
378
        printf ("  %s_%s: ", uprefix, opt->name);
379

    
380
        if (opt->overriddenp && *opt->overriddenp) {
381
            state = "current";
382
        }
383

    
384
        switch (opt->tag) {
385
        case AUD_OPT_BOOL:
386
            {
387
                int *intp = opt->valp;
388
                printf ("boolean, %s = %d\n", state, *intp ? 1 : 0);
389
            }
390
            break;
391

    
392
        case AUD_OPT_INT:
393
            {
394
                int *intp = opt->valp;
395
                printf ("integer, %s = %d\n", state, *intp);
396
            }
397
            break;
398

    
399
        case AUD_OPT_FMT:
400
            {
401
                audfmt_e *fmtp = opt->valp;
402
                printf (
403
                    "format, %s = %s, (one of: U8 S8 U16 S16 U32 S32)\n",
404
                    state,
405
                    audio_audfmt_to_string (*fmtp)
406
                    );
407
            }
408
            break;
409

    
410
        case AUD_OPT_STR:
411
            {
412
                const char **strp = opt->valp;
413
                printf ("string, %s = %s\n",
414
                        state,
415
                        *strp ? *strp : "(not set)");
416
            }
417
            break;
418

    
419
        default:
420
            printf ("???\n");
421
            dolog ("Bad value tag for option %s_%s %d\n",
422
                   uprefix, opt->name, opt->tag);
423
            break;
424
        }
425
        printf ("    %s\n", opt->descr);
426
    }
427

    
428
    qemu_free (uprefix);
429
}
430

    
431
static void audio_process_options (const char *prefix,
432
                                   struct audio_option *opt)
433
{
434
    char *optname;
435
    const char qemu_prefix[] = "QEMU_";
436
    size_t preflen, optlen;
437

    
438
    if (audio_bug (AUDIO_FUNC, !prefix)) {
439
        dolog ("prefix = NULL\n");
440
        return;
441
    }
442

    
443
    if (audio_bug (AUDIO_FUNC, !opt)) {
444
        dolog ("opt = NULL\n");
445
        return;
446
    }
447

    
448
    preflen = strlen (prefix);
449

    
450
    for (; opt->name; opt++) {
451
        size_t len, i;
452
        int def;
453

    
454
        if (!opt->valp) {
455
            dolog ("Option value pointer for `%s' is not set\n",
456
                   opt->name);
457
            continue;
458
        }
459

    
460
        len = strlen (opt->name);
461
        /* len of opt->name + len of prefix + size of qemu_prefix
462
         * (includes trailing zero) + zero + underscore (on behalf of
463
         * sizeof) */
464
        optlen = len + preflen + sizeof (qemu_prefix) + 1;
465
        optname = qemu_malloc (optlen);
466

    
467
        pstrcpy (optname, optlen, qemu_prefix);
468

    
469
        /* copy while upper-casing, including trailing zero */
470
        for (i = 0; i <= preflen; ++i) {
471
            optname[i + sizeof (qemu_prefix) - 1] = qemu_toupper(prefix[i]);
472
        }
473
        pstrcat (optname, optlen, "_");
474
        pstrcat (optname, optlen, opt->name);
475

    
476
        def = 1;
477
        switch (opt->tag) {
478
        case AUD_OPT_BOOL:
479
        case AUD_OPT_INT:
480
            {
481
                int *intp = opt->valp;
482
                *intp = audio_get_conf_int (optname, *intp, &def);
483
            }
484
            break;
485

    
486
        case AUD_OPT_FMT:
487
            {
488
                audfmt_e *fmtp = opt->valp;
489
                *fmtp = audio_get_conf_fmt (optname, *fmtp, &def);
490
            }
491
            break;
492

    
493
        case AUD_OPT_STR:
494
            {
495
                const char **strp = opt->valp;
496
                *strp = audio_get_conf_str (optname, *strp, &def);
497
            }
498
            break;
499

    
500
        default:
501
            dolog ("Bad value tag for option `%s' - %d\n",
502
                   optname, opt->tag);
503
            break;
504
        }
505

    
506
        if (!opt->overriddenp) {
507
            opt->overriddenp = &opt->overridden;
508
        }
509
        *opt->overriddenp = !def;
510
        qemu_free (optname);
511
    }
512
}
513

    
514
static void audio_print_settings (struct audsettings *as)
515
{
516
    dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);
517

    
518
    switch (as->fmt) {
519
    case AUD_FMT_S8:
520
        AUD_log (NULL, "S8");
521
        break;
522
    case AUD_FMT_U8:
523
        AUD_log (NULL, "U8");
524
        break;
525
    case AUD_FMT_S16:
526
        AUD_log (NULL, "S16");
527
        break;
528
    case AUD_FMT_U16:
529
        AUD_log (NULL, "U16");
530
        break;
531
    case AUD_FMT_S32:
532
        AUD_log (NULL, "S32");
533
        break;
534
    case AUD_FMT_U32:
535
        AUD_log (NULL, "U32");
536
        break;
537
    default:
538
        AUD_log (NULL, "invalid(%d)", as->fmt);
539
        break;
540
    }
541

    
542
    AUD_log (NULL, " endianness=");
543
    switch (as->endianness) {
544
    case 0:
545
        AUD_log (NULL, "little");
546
        break;
547
    case 1:
548
        AUD_log (NULL, "big");
549
        break;
550
    default:
551
        AUD_log (NULL, "invalid");
552
        break;
553
    }
554
    AUD_log (NULL, "\n");
555
}
556

    
557
static int audio_validate_settings (struct audsettings *as)
558
{
559
    int invalid;
560

    
561
    invalid = as->nchannels != 1 && as->nchannels != 2;
562
    invalid |= as->endianness != 0 && as->endianness != 1;
563

    
564
    switch (as->fmt) {
565
    case AUD_FMT_S8:
566
    case AUD_FMT_U8:
567
    case AUD_FMT_S16:
568
    case AUD_FMT_U16:
569
    case AUD_FMT_S32:
570
    case AUD_FMT_U32:
571
        break;
572
    default:
573
        invalid = 1;
574
        break;
575
    }
576

    
577
    invalid |= as->freq <= 0;
578
    return invalid ? -1 : 0;
579
}
580

    
581
static int audio_pcm_info_eq (struct audio_pcm_info *info, struct audsettings *as)
582
{
583
    int bits = 8, sign = 0;
584

    
585
    switch (as->fmt) {
586
    case AUD_FMT_S8:
587
        sign = 1;
588
    case AUD_FMT_U8:
589
        break;
590

    
591
    case AUD_FMT_S16:
592
        sign = 1;
593
    case AUD_FMT_U16:
594
        bits = 16;
595
        break;
596

    
597
    case AUD_FMT_S32:
598
        sign = 1;
599
    case AUD_FMT_U32:
600
        bits = 32;
601
        break;
602
    }
603
    return info->freq == as->freq
604
        && info->nchannels == as->nchannels
605
        && info->sign == sign
606
        && info->bits == bits
607
        && info->swap_endianness == (as->endianness != AUDIO_HOST_ENDIANNESS);
608
}
609

    
610
void audio_pcm_init_info (struct audio_pcm_info *info, struct audsettings *as)
611
{
612
    int bits = 8, sign = 0, shift = 0;
613

    
614
    switch (as->fmt) {
615
    case AUD_FMT_S8:
616
        sign = 1;
617
    case AUD_FMT_U8:
618
        break;
619

    
620
    case AUD_FMT_S16:
621
        sign = 1;
622
    case AUD_FMT_U16:
623
        bits = 16;
624
        shift = 1;
625
        break;
626

    
627
    case AUD_FMT_S32:
628
        sign = 1;
629
    case AUD_FMT_U32:
630
        bits = 32;
631
        shift = 2;
632
        break;
633
    }
634

    
635
    info->freq = as->freq;
636
    info->bits = bits;
637
    info->sign = sign;
638
    info->nchannels = as->nchannels;
639
    info->shift = (as->nchannels == 2) + shift;
640
    info->align = (1 << info->shift) - 1;
641
    info->bytes_per_second = info->freq << info->shift;
642
    info->swap_endianness = (as->endianness != AUDIO_HOST_ENDIANNESS);
643
}
644

    
645
void audio_pcm_info_clear_buf (struct audio_pcm_info *info, void *buf, int len)
646
{
647
    if (!len) {
648
        return;
649
    }
650

    
651
    if (info->sign) {
652
        memset (buf, 0x00, len << info->shift);
653
    }
654
    else {
655
        switch (info->bits) {
656
        case 8:
657
            memset (buf, 0x80, len << info->shift);
658
            break;
659

    
660
        case 16:
661
            {
662
                int i;
663
                uint16_t *p = buf;
664
                int shift = info->nchannels - 1;
665
                short s = INT16_MAX;
666

    
667
                if (info->swap_endianness) {
668
                    s = bswap16 (s);
669
                }
670

    
671
                for (i = 0; i < len << shift; i++) {
672
                    p[i] = s;
673
                }
674
            }
675
            break;
676

    
677
        case 32:
678
            {
679
                int i;
680
                uint32_t *p = buf;
681
                int shift = info->nchannels - 1;
682
                int32_t s = INT32_MAX;
683

    
684
                if (info->swap_endianness) {
685
                    s = bswap32 (s);
686
                }
687

    
688
                for (i = 0; i < len << shift; i++) {
689
                    p[i] = s;
690
                }
691
            }
692
            break;
693

    
694
        default:
695
            AUD_log (NULL, "audio_pcm_info_clear_buf: invalid bits %d\n",
696
                     info->bits);
697
            break;
698
        }
699
    }
700
}
701

    
702
/*
703
 * Capture
704
 */
705
static void noop_conv (struct st_sample *dst, const void *src,
706
                       int samples, struct mixeng_volume *vol)
707
{
708
    (void) src;
709
    (void) dst;
710
    (void) samples;
711
    (void) vol;
712
}
713

    
714
static CaptureVoiceOut *audio_pcm_capture_find_specific (
715
    struct audsettings *as
716
    )
717
{
718
    CaptureVoiceOut *cap;
719
    AudioState *s = &glob_audio_state;
720

    
721
    for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
722
        if (audio_pcm_info_eq (&cap->hw.info, as)) {
723
            return cap;
724
        }
725
    }
726
    return NULL;
727
}
728

    
729
static void audio_notify_capture (CaptureVoiceOut *cap, audcnotification_e cmd)
730
{
731
    struct capture_callback *cb;
732

    
733
#ifdef DEBUG_CAPTURE
734
    dolog ("notification %d sent\n", cmd);
735
#endif
736
    for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
737
        cb->ops.notify (cb->opaque, cmd);
738
    }
739
}
740

    
741
static void audio_capture_maybe_changed (CaptureVoiceOut *cap, int enabled)
742
{
743
    if (cap->hw.enabled != enabled) {
744
        audcnotification_e cmd;
745
        cap->hw.enabled = enabled;
746
        cmd = enabled ? AUD_CNOTIFY_ENABLE : AUD_CNOTIFY_DISABLE;
747
        audio_notify_capture (cap, cmd);
748
    }
749
}
750

    
751
static void audio_recalc_and_notify_capture (CaptureVoiceOut *cap)
752
{
753
    HWVoiceOut *hw = &cap->hw;
754
    SWVoiceOut *sw;
755
    int enabled = 0;
756

    
757
    for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
758
        if (sw->active) {
759
            enabled = 1;
760
            break;
761
        }
762
    }
763
    audio_capture_maybe_changed (cap, enabled);
764
}
765

    
766
static void audio_detach_capture (HWVoiceOut *hw)
767
{
768
    SWVoiceCap *sc = hw->cap_head.lh_first;
769

    
770
    while (sc) {
771
        SWVoiceCap *sc1 = sc->entries.le_next;
772
        SWVoiceOut *sw = &sc->sw;
773
        CaptureVoiceOut *cap = sc->cap;
774
        int was_active = sw->active;
775

    
776
        if (sw->rate) {
777
            st_rate_stop (sw->rate);
778
            sw->rate = NULL;
779
        }
780

    
781
        QLIST_REMOVE (sw, entries);
782
        QLIST_REMOVE (sc, entries);
783
        qemu_free (sc);
784
        if (was_active) {
785
            /* We have removed soft voice from the capture:
786
               this might have changed the overall status of the capture
787
               since this might have been the only active voice */
788
            audio_recalc_and_notify_capture (cap);
789
        }
790
        sc = sc1;
791
    }
792
}
793

    
794
static int audio_attach_capture (HWVoiceOut *hw)
795
{
796
    AudioState *s = &glob_audio_state;
797
    CaptureVoiceOut *cap;
798

    
799
    audio_detach_capture (hw);
800
    for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
801
        SWVoiceCap *sc;
802
        SWVoiceOut *sw;
803
        HWVoiceOut *hw_cap = &cap->hw;
804

    
805
        sc = audio_calloc (AUDIO_FUNC, 1, sizeof (*sc));
806
        if (!sc) {
807
            dolog ("Could not allocate soft capture voice (%zu bytes)\n",
808
                   sizeof (*sc));
809
            return -1;
810
        }
811

    
812
        sc->cap = cap;
813
        sw = &sc->sw;
814
        sw->hw = hw_cap;
815
        sw->info = hw->info;
816
        sw->empty = 1;
817
        sw->active = hw->enabled;
818
        sw->conv = noop_conv;
819
        sw->ratio = ((int64_t) hw_cap->info.freq << 32) / sw->info.freq;
820
        sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq);
821
        if (!sw->rate) {
822
            dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw));
823
            qemu_free (sw);
824
            return -1;
825
        }
826
        QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries);
827
        QLIST_INSERT_HEAD (&hw->cap_head, sc, entries);
828
#ifdef DEBUG_CAPTURE
829
        asprintf (&sw->name, "for %p %d,%d,%d",
830
                  hw, sw->info.freq, sw->info.bits, sw->info.nchannels);
831
        dolog ("Added %s active = %d\n", sw->name, sw->active);
832
#endif
833
        if (sw->active) {
834
            audio_capture_maybe_changed (cap, 1);
835
        }
836
    }
837
    return 0;
838
}
839

    
840
/*
841
 * Hard voice (capture)
842
 */
843
static int audio_pcm_hw_find_min_in (HWVoiceIn *hw)
844
{
845
    SWVoiceIn *sw;
846
    int m = hw->total_samples_captured;
847

    
848
    for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
849
        if (sw->active) {
850
            m = audio_MIN (m, sw->total_hw_samples_acquired);
851
        }
852
    }
853
    return m;
854
}
855

    
856
int audio_pcm_hw_get_live_in (HWVoiceIn *hw)
857
{
858
    int live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw);
859
    if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
860
        dolog ("live=%d hw->samples=%d\n", live, hw->samples);
861
        return 0;
862
    }
863
    return live;
864
}
865

    
866
int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf,
867
                           int live, int pending)
868
{
869
    int left = hw->samples - pending;
870
    int len = audio_MIN (left, live);
871
    int clipped = 0;
872

    
873
    while (len) {
874
        struct st_sample *src = hw->mix_buf + hw->rpos;
875
        uint8_t *dst = advance (pcm_buf, hw->rpos << hw->info.shift);
876
        int samples_till_end_of_buf = hw->samples - hw->rpos;
877
        int samples_to_clip = audio_MIN (len, samples_till_end_of_buf);
878

    
879
        hw->clip (dst, src, samples_to_clip);
880

    
881
        hw->rpos = (hw->rpos + samples_to_clip) % hw->samples;
882
        len -= samples_to_clip;
883
        clipped += samples_to_clip;
884
    }
885
    return clipped;
886
}
887

    
888
/*
889
 * Soft voice (capture)
890
 */
891
static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw)
892
{
893
    HWVoiceIn *hw = sw->hw;
894
    int live = hw->total_samples_captured - sw->total_hw_samples_acquired;
895
    int rpos;
896

    
897
    if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
898
        dolog ("live=%d hw->samples=%d\n", live, hw->samples);
899
        return 0;
900
    }
901

    
902
    rpos = hw->wpos - live;
903
    if (rpos >= 0) {
904
        return rpos;
905
    }
906
    else {
907
        return hw->samples + rpos;
908
    }
909
}
910

    
911
int audio_pcm_sw_read (SWVoiceIn *sw, void *buf, int size)
912
{
913
    HWVoiceIn *hw = sw->hw;
914
    int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;
915
    struct st_sample *src, *dst = sw->buf;
916

    
917
    rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples;
918

    
919
    live = hw->total_samples_captured - sw->total_hw_samples_acquired;
920
    if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
921
        dolog ("live_in=%d hw->samples=%d\n", live, hw->samples);
922
        return 0;
923
    }
924

    
925
    samples = size >> sw->info.shift;
926
    if (!live) {
927
        return 0;
928
    }
929

    
930
    swlim = (live * sw->ratio) >> 32;
931
    swlim = audio_MIN (swlim, samples);
932

    
933
    while (swlim) {
934
        src = hw->conv_buf + rpos;
935
        isamp = hw->wpos - rpos;
936
        /* XXX: <= ? */
937
        if (isamp <= 0) {
938
            isamp = hw->samples - rpos;
939
        }
940

    
941
        if (!isamp) {
942
            break;
943
        }
944
        osamp = swlim;
945

    
946
        if (audio_bug (AUDIO_FUNC, osamp < 0)) {
947
            dolog ("osamp=%d\n", osamp);
948
            return 0;
949
        }
950

    
951
        st_rate_flow (sw->rate, src, dst, &isamp, &osamp);
952
        swlim -= osamp;
953
        rpos = (rpos + isamp) % hw->samples;
954
        dst += osamp;
955
        ret += osamp;
956
        total += isamp;
957
    }
958

    
959
    sw->clip (buf, sw->buf, ret);
960
    sw->total_hw_samples_acquired += total;
961
    return ret << sw->info.shift;
962
}
963

    
964
/*
965
 * Hard voice (playback)
966
 */
967
static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)
968
{
969
    SWVoiceOut *sw;
970
    int m = INT_MAX;
971
    int nb_live = 0;
972

    
973
    for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
974
        if (sw->active || !sw->empty) {
975
            m = audio_MIN (m, sw->total_hw_samples_mixed);
976
            nb_live += 1;
977
        }
978
    }
979

    
980
    *nb_livep = nb_live;
981
    return m;
982
}
983

    
984
static int audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live)
985
{
986
    int smin;
987
    int nb_live1;
988

    
989
    smin = audio_pcm_hw_find_min_out (hw, &nb_live1);
990
    if (nb_live) {
991
        *nb_live = nb_live1;
992
    }
993

    
994
    if (nb_live1) {
995
        int live = smin;
996

    
997
        if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
998
            dolog ("live=%d hw->samples=%d\n", live, hw->samples);
999
            return 0;
1000
        }
1001
        return live;
1002
    }
1003
    return 0;
1004
}
1005

    
1006
/*
1007
 * Soft voice (playback)
1008
 */
1009
int audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int size)
1010
{
1011
    int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;
1012
    int ret = 0, pos = 0, total = 0;
1013

    
1014
    if (!sw) {
1015
        return size;
1016
    }
1017

    
1018
    hwsamples = sw->hw->samples;
1019

    
1020
    live = sw->total_hw_samples_mixed;
1021
    if (audio_bug (AUDIO_FUNC, live < 0 || live > hwsamples)){
1022
        dolog ("live=%d hw->samples=%d\n", live, hwsamples);
1023
        return 0;
1024
    }
1025

    
1026
    if (live == hwsamples) {
1027
#ifdef DEBUG_OUT
1028
        dolog ("%s is full %d\n", sw->name, live);
1029
#endif
1030
        return 0;
1031
    }
1032

    
1033
    wpos = (sw->hw->rpos + live) % hwsamples;
1034
    samples = size >> sw->info.shift;
1035

    
1036
    dead = hwsamples - live;
1037
    swlim = ((int64_t) dead << 32) / sw->ratio;
1038
    swlim = audio_MIN (swlim, samples);
1039
    if (swlim) {
1040
        sw->conv (sw->buf, buf, swlim, &sw->vol);
1041
    }
1042

    
1043
    while (swlim) {
1044
        dead = hwsamples - live;
1045
        left = hwsamples - wpos;
1046
        blck = audio_MIN (dead, left);
1047
        if (!blck) {
1048
            break;
1049
        }
1050
        isamp = swlim;
1051
        osamp = blck;
1052
        st_rate_flow_mix (
1053
            sw->rate,
1054
            sw->buf + pos,
1055
            sw->hw->mix_buf + wpos,
1056
            &isamp,
1057
            &osamp
1058
            );
1059
        ret += isamp;
1060
        swlim -= isamp;
1061
        pos += isamp;
1062
        live += osamp;
1063
        wpos = (wpos + osamp) % hwsamples;
1064
        total += osamp;
1065
    }
1066

    
1067
    sw->total_hw_samples_mixed += total;
1068
    sw->empty = sw->total_hw_samples_mixed == 0;
1069

    
1070
#ifdef DEBUG_OUT
1071
    dolog (
1072
        "%s: write size %d ret %d total sw %d\n",
1073
        SW_NAME (sw),
1074
        size >> sw->info.shift,
1075
        ret,
1076
        sw->total_hw_samples_mixed
1077
        );
1078
#endif
1079

    
1080
    return ret << sw->info.shift;
1081
}
1082

    
1083
#ifdef DEBUG_AUDIO
1084
static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info)
1085
{
1086
    dolog ("%s: bits %d, sign %d, freq %d, nchan %d\n",
1087
           cap, info->bits, info->sign, info->freq, info->nchannels);
1088
}
1089
#endif
1090

    
1091
#define DAC
1092
#include "audio_template.h"
1093
#undef DAC
1094
#include "audio_template.h"
1095

    
1096
/*
1097
 * Timer
1098
 */
1099
static int audio_is_timer_needed (void)
1100
{
1101
    HWVoiceIn *hwi = NULL;
1102
    HWVoiceOut *hwo = NULL;
1103

    
1104
    while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) {
1105
        if (!hwo->poll_mode) return 1;
1106
    }
1107
    while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) {
1108
        if (!hwi->poll_mode) return 1;
1109
    }
1110
    return 0;
1111
}
1112

    
1113
static void audio_reset_timer (AudioState *s)
1114
{
1115
    if (audio_is_timer_needed ()) {
1116
        qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + 1);
1117
    }
1118
    else {
1119
        qemu_del_timer (s->ts);
1120
    }
1121
}
1122

    
1123
static void audio_timer (void *opaque)
1124
{
1125
    audio_run ("timer");
1126
    audio_reset_timer (opaque);
1127
}
1128

    
1129
/*
1130
 * Public API
1131
 */
1132
int AUD_write (SWVoiceOut *sw, void *buf, int size)
1133
{
1134
    int bytes;
1135

    
1136
    if (!sw) {
1137
        /* XXX: Consider options */
1138
        return size;
1139
    }
1140

    
1141
    if (!sw->hw->enabled) {
1142
        dolog ("Writing to disabled voice %s\n", SW_NAME (sw));
1143
        return 0;
1144
    }
1145

    
1146
    bytes = sw->hw->pcm_ops->write (sw, buf, size);
1147
    return bytes;
1148
}
1149

    
1150
int AUD_read (SWVoiceIn *sw, void *buf, int size)
1151
{
1152
    int bytes;
1153

    
1154
    if (!sw) {
1155
        /* XXX: Consider options */
1156
        return size;
1157
    }
1158

    
1159
    if (!sw->hw->enabled) {
1160
        dolog ("Reading from disabled voice %s\n", SW_NAME (sw));
1161
        return 0;
1162
    }
1163

    
1164
    bytes = sw->hw->pcm_ops->read (sw, buf, size);
1165
    return bytes;
1166
}
1167

    
1168
int AUD_get_buffer_size_out (SWVoiceOut *sw)
1169
{
1170
    return sw->hw->samples << sw->hw->info.shift;
1171
}
1172

    
1173
void AUD_set_active_out (SWVoiceOut *sw, int on)
1174
{
1175
    HWVoiceOut *hw;
1176

    
1177
    if (!sw) {
1178
        return;
1179
    }
1180

    
1181
    hw = sw->hw;
1182
    if (sw->active != on) {
1183
        AudioState *s = &glob_audio_state;
1184
        SWVoiceOut *temp_sw;
1185
        SWVoiceCap *sc;
1186

    
1187
        if (on) {
1188
            hw->pending_disable = 0;
1189
            if (!hw->enabled) {
1190
                hw->enabled = 1;
1191
                if (s->vm_running) {
1192
                    hw->pcm_ops->ctl_out (hw, VOICE_ENABLE, conf.try_poll_out);
1193
                    audio_reset_timer (s);
1194
                }
1195
            }
1196
        }
1197
        else {
1198
            if (hw->enabled) {
1199
                int nb_active = 0;
1200

    
1201
                for (temp_sw = hw->sw_head.lh_first; temp_sw;
1202
                     temp_sw = temp_sw->entries.le_next) {
1203
                    nb_active += temp_sw->active != 0;
1204
                }
1205

    
1206
                hw->pending_disable = nb_active == 1;
1207
            }
1208
        }
1209

    
1210
        for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1211
            sc->sw.active = hw->enabled;
1212
            if (hw->enabled) {
1213
                audio_capture_maybe_changed (sc->cap, 1);
1214
            }
1215
        }
1216
        sw->active = on;
1217
    }
1218
}
1219

    
1220
void AUD_set_active_in (SWVoiceIn *sw, int on)
1221
{
1222
    HWVoiceIn *hw;
1223

    
1224
    if (!sw) {
1225
        return;
1226
    }
1227

    
1228
    hw = sw->hw;
1229
    if (sw->active != on) {
1230
        AudioState *s = &glob_audio_state;
1231
        SWVoiceIn *temp_sw;
1232

    
1233
        if (on) {
1234
            if (!hw->enabled) {
1235
                hw->enabled = 1;
1236
                if (s->vm_running) {
1237
                    hw->pcm_ops->ctl_in (hw, VOICE_ENABLE, conf.try_poll_in);
1238
                    audio_reset_timer (s);
1239
                }
1240
            }
1241
            sw->total_hw_samples_acquired = hw->total_samples_captured;
1242
        }
1243
        else {
1244
            if (hw->enabled) {
1245
                int nb_active = 0;
1246

    
1247
                for (temp_sw = hw->sw_head.lh_first; temp_sw;
1248
                     temp_sw = temp_sw->entries.le_next) {
1249
                    nb_active += temp_sw->active != 0;
1250
                }
1251

    
1252
                if (nb_active == 1) {
1253
                    hw->enabled = 0;
1254
                    hw->pcm_ops->ctl_in (hw, VOICE_DISABLE);
1255
                }
1256
            }
1257
        }
1258
        sw->active = on;
1259
    }
1260
}
1261

    
1262
static int audio_get_avail (SWVoiceIn *sw)
1263
{
1264
    int live;
1265

    
1266
    if (!sw) {
1267
        return 0;
1268
    }
1269

    
1270
    live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired;
1271
    if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) {
1272
        dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);
1273
        return 0;
1274
    }
1275

    
1276
    ldebug (
1277
        "%s: get_avail live %d ret %" PRId64 "\n",
1278
        SW_NAME (sw),
1279
        live, (((int64_t) live << 32) / sw->ratio) << sw->info.shift
1280
        );
1281

    
1282
    return (((int64_t) live << 32) / sw->ratio) << sw->info.shift;
1283
}
1284

    
1285
static int audio_get_free (SWVoiceOut *sw)
1286
{
1287
    int live, dead;
1288

    
1289
    if (!sw) {
1290
        return 0;
1291
    }
1292

    
1293
    live = sw->total_hw_samples_mixed;
1294

    
1295
    if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) {
1296
        dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);
1297
        return 0;
1298
    }
1299

    
1300
    dead = sw->hw->samples - live;
1301

    
1302
#ifdef DEBUG_OUT
1303
    dolog ("%s: get_free live %d dead %d ret %" PRId64 "\n",
1304
           SW_NAME (sw),
1305
           live, dead, (((int64_t) dead << 32) / sw->ratio) << sw->info.shift);
1306
#endif
1307

    
1308
    return (((int64_t) dead << 32) / sw->ratio) << sw->info.shift;
1309
}
1310

    
1311
static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples)
1312
{
1313
    int n;
1314

    
1315
    if (hw->enabled) {
1316
        SWVoiceCap *sc;
1317

    
1318
        for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1319
            SWVoiceOut *sw = &sc->sw;
1320
            int rpos2 = rpos;
1321

    
1322
            n = samples;
1323
            while (n) {
1324
                int till_end_of_hw = hw->samples - rpos2;
1325
                int to_write = audio_MIN (till_end_of_hw, n);
1326
                int bytes = to_write << hw->info.shift;
1327
                int written;
1328

    
1329
                sw->buf = hw->mix_buf + rpos2;
1330
                written = audio_pcm_sw_write (sw, NULL, bytes);
1331
                if (written - bytes) {
1332
                    dolog ("Could not mix %d bytes into a capture "
1333
                           "buffer, mixed %d\n",
1334
                           bytes, written);
1335
                    break;
1336
                }
1337
                n -= to_write;
1338
                rpos2 = (rpos2 + to_write) % hw->samples;
1339
            }
1340
        }
1341
    }
1342

    
1343
    n = audio_MIN (samples, hw->samples - rpos);
1344
    mixeng_clear (hw->mix_buf + rpos, n);
1345
    mixeng_clear (hw->mix_buf, samples - n);
1346
}
1347

    
1348
static void audio_run_out (AudioState *s)
1349
{
1350
    HWVoiceOut *hw = NULL;
1351
    SWVoiceOut *sw;
1352

    
1353
    while ((hw = audio_pcm_hw_find_any_enabled_out (hw))) {
1354
        int played;
1355
        int live, free, nb_live, cleanup_required, prev_rpos;
1356

    
1357
        live = audio_pcm_hw_get_live_out (hw, &nb_live);
1358
        if (!nb_live) {
1359
            live = 0;
1360
        }
1361

    
1362
        if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
1363
            dolog ("live=%d hw->samples=%d\n", live, hw->samples);
1364
            continue;
1365
        }
1366

    
1367
        if (hw->pending_disable && !nb_live) {
1368
            SWVoiceCap *sc;
1369
#ifdef DEBUG_OUT
1370
            dolog ("Disabling voice\n");
1371
#endif
1372
            hw->enabled = 0;
1373
            hw->pending_disable = 0;
1374
            hw->pcm_ops->ctl_out (hw, VOICE_DISABLE);
1375
            for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1376
                sc->sw.active = 0;
1377
                audio_recalc_and_notify_capture (sc->cap);
1378
            }
1379
            continue;
1380
        }
1381

    
1382
        if (!live) {
1383
            for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1384
                if (sw->active) {
1385
                    free = audio_get_free (sw);
1386
                    if (free > 0) {
1387
                        sw->callback.fn (sw->callback.opaque, free);
1388
                    }
1389
                }
1390
            }
1391
            continue;
1392
        }
1393

    
1394
        prev_rpos = hw->rpos;
1395
        played = hw->pcm_ops->run_out (hw, live);
1396
        if (audio_bug (AUDIO_FUNC, hw->rpos >= hw->samples)) {
1397
            dolog ("hw->rpos=%d hw->samples=%d played=%d\n",
1398
                   hw->rpos, hw->samples, played);
1399
            hw->rpos = 0;
1400
        }
1401

    
1402
#ifdef DEBUG_OUT
1403
        dolog ("played=%d\n", played);
1404
#endif
1405

    
1406
        if (played) {
1407
            hw->ts_helper += played;
1408
            audio_capture_mix_and_clear (hw, prev_rpos, played);
1409
        }
1410

    
1411
        cleanup_required = 0;
1412
        for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1413
            if (!sw->active && sw->empty) {
1414
                continue;
1415
            }
1416

    
1417
            if (audio_bug (AUDIO_FUNC, played > sw->total_hw_samples_mixed)) {
1418
                dolog ("played=%d sw->total_hw_samples_mixed=%d\n",
1419
                       played, sw->total_hw_samples_mixed);
1420
                played = sw->total_hw_samples_mixed;
1421
            }
1422

    
1423
            sw->total_hw_samples_mixed -= played;
1424

    
1425
            if (!sw->total_hw_samples_mixed) {
1426
                sw->empty = 1;
1427
                cleanup_required |= !sw->active && !sw->callback.fn;
1428
            }
1429

    
1430
            if (sw->active) {
1431
                free = audio_get_free (sw);
1432
                if (free > 0) {
1433
                    sw->callback.fn (sw->callback.opaque, free);
1434
                }
1435
            }
1436
        }
1437

    
1438
        if (cleanup_required) {
1439
            SWVoiceOut *sw1;
1440

    
1441
            sw = hw->sw_head.lh_first;
1442
            while (sw) {
1443
                sw1 = sw->entries.le_next;
1444
                if (!sw->active && !sw->callback.fn) {
1445
#ifdef DEBUG_PLIVE
1446
                    dolog ("Finishing with old voice\n");
1447
#endif
1448
                    audio_close_out (sw);
1449
                }
1450
                sw = sw1;
1451
            }
1452
        }
1453
    }
1454
}
1455

    
1456
static void audio_run_in (AudioState *s)
1457
{
1458
    HWVoiceIn *hw = NULL;
1459

    
1460
    while ((hw = audio_pcm_hw_find_any_enabled_in (hw))) {
1461
        SWVoiceIn *sw;
1462
        int captured, min;
1463

    
1464
        captured = hw->pcm_ops->run_in (hw);
1465

    
1466
        min = audio_pcm_hw_find_min_in (hw);
1467
        hw->total_samples_captured += captured - min;
1468
        hw->ts_helper += captured;
1469

    
1470
        for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1471
            sw->total_hw_samples_acquired -= min;
1472

    
1473
            if (sw->active) {
1474
                int avail;
1475

    
1476
                avail = audio_get_avail (sw);
1477
                if (avail > 0) {
1478
                    sw->callback.fn (sw->callback.opaque, avail);
1479
                }
1480
            }
1481
        }
1482
    }
1483
}
1484

    
1485
static void audio_run_capture (AudioState *s)
1486
{
1487
    CaptureVoiceOut *cap;
1488

    
1489
    for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
1490
        int live, rpos, captured;
1491
        HWVoiceOut *hw = &cap->hw;
1492
        SWVoiceOut *sw;
1493

    
1494
        captured = live = audio_pcm_hw_get_live_out (hw, NULL);
1495
        rpos = hw->rpos;
1496
        while (live) {
1497
            int left = hw->samples - rpos;
1498
            int to_capture = audio_MIN (live, left);
1499
            struct st_sample *src;
1500
            struct capture_callback *cb;
1501

    
1502
            src = hw->mix_buf + rpos;
1503
            hw->clip (cap->buf, src, to_capture);
1504
            mixeng_clear (src, to_capture);
1505

    
1506
            for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
1507
                cb->ops.capture (cb->opaque, cap->buf,
1508
                                 to_capture << hw->info.shift);
1509
            }
1510
            rpos = (rpos + to_capture) % hw->samples;
1511
            live -= to_capture;
1512
        }
1513
        hw->rpos = rpos;
1514

    
1515
        for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1516
            if (!sw->active && sw->empty) {
1517
                continue;
1518
            }
1519

    
1520
            if (audio_bug (AUDIO_FUNC, captured > sw->total_hw_samples_mixed)) {
1521
                dolog ("captured=%d sw->total_hw_samples_mixed=%d\n",
1522
                       captured, sw->total_hw_samples_mixed);
1523
                captured = sw->total_hw_samples_mixed;
1524
            }
1525

    
1526
            sw->total_hw_samples_mixed -= captured;
1527
            sw->empty = sw->total_hw_samples_mixed == 0;
1528
        }
1529
    }
1530
}
1531

    
1532
void audio_run (const char *msg)
1533
{
1534
    AudioState *s = &glob_audio_state;
1535

    
1536
    audio_run_out (s);
1537
    audio_run_in (s);
1538
    audio_run_capture (s);
1539
#ifdef DEBUG_POLL
1540
    {
1541
        static double prevtime;
1542
        double currtime;
1543
        struct timeval tv;
1544

    
1545
        if (gettimeofday (&tv, NULL)) {
1546
            perror ("audio_run: gettimeofday");
1547
            return;
1548
        }
1549

    
1550
        currtime = tv.tv_sec + tv.tv_usec * 1e-6;
1551
        dolog ("Elapsed since last %s: %f\n", msg, currtime - prevtime);
1552
        prevtime = currtime;
1553
    }
1554
#endif
1555
}
1556

    
1557
static struct audio_option audio_options[] = {
1558
    /* DAC */
1559
    {
1560
        .name  = "DAC_FIXED_SETTINGS",
1561
        .tag   = AUD_OPT_BOOL,
1562
        .valp  = &conf.fixed_out.enabled,
1563
        .descr = "Use fixed settings for host DAC"
1564
    },
1565
    {
1566
        .name  = "DAC_FIXED_FREQ",
1567
        .tag   = AUD_OPT_INT,
1568
        .valp  = &conf.fixed_out.settings.freq,
1569
        .descr = "Frequency for fixed host DAC"
1570
    },
1571
    {
1572
        .name  = "DAC_FIXED_FMT",
1573
        .tag   = AUD_OPT_FMT,
1574
        .valp  = &conf.fixed_out.settings.fmt,
1575
        .descr = "Format for fixed host DAC"
1576
    },
1577
    {
1578
        .name  = "DAC_FIXED_CHANNELS",
1579
        .tag   = AUD_OPT_INT,
1580
        .valp  = &conf.fixed_out.settings.nchannels,
1581
        .descr = "Number of channels for fixed DAC (1 - mono, 2 - stereo)"
1582
    },
1583
    {
1584
        .name  = "DAC_VOICES",
1585
        .tag   = AUD_OPT_INT,
1586
        .valp  = &conf.fixed_out.nb_voices,
1587
        .descr = "Number of voices for DAC"
1588
    },
1589
    {
1590
        .name  = "DAC_TRY_POLL",
1591
        .tag   = AUD_OPT_BOOL,
1592
        .valp  = &conf.try_poll_out,
1593
        .descr = "Attempt using poll mode for DAC"
1594
    },
1595
    /* ADC */
1596
    {
1597
        .name  = "ADC_FIXED_SETTINGS",
1598
        .tag   = AUD_OPT_BOOL,
1599
        .valp  = &conf.fixed_in.enabled,
1600
        .descr = "Use fixed settings for host ADC"
1601
    },
1602
    {
1603
        .name  = "ADC_FIXED_FREQ",
1604
        .tag   = AUD_OPT_INT,
1605
        .valp  = &conf.fixed_in.settings.freq,
1606
        .descr = "Frequency for fixed host ADC"
1607
    },
1608
    {
1609
        .name  = "ADC_FIXED_FMT",
1610
        .tag   = AUD_OPT_FMT,
1611
        .valp  = &conf.fixed_in.settings.fmt,
1612
        .descr = "Format for fixed host ADC"
1613
    },
1614
    {
1615
        .name  = "ADC_FIXED_CHANNELS",
1616
        .tag   = AUD_OPT_INT,
1617
        .valp  = &conf.fixed_in.settings.nchannels,
1618
        .descr = "Number of channels for fixed ADC (1 - mono, 2 - stereo)"
1619
    },
1620
    {
1621
        .name  = "ADC_VOICES",
1622
        .tag   = AUD_OPT_INT,
1623
        .valp  = &conf.fixed_in.nb_voices,
1624
        .descr = "Number of voices for ADC"
1625
    },
1626
    {
1627
        .name  = "ADC_TRY_POLL",
1628
        .tag   = AUD_OPT_BOOL,
1629
        .valp  = &conf.try_poll_in,
1630
        .descr = "Attempt using poll mode for ADC"
1631
    },
1632
    /* Misc */
1633
    {
1634
        .name  = "TIMER_PERIOD",
1635
        .tag   = AUD_OPT_INT,
1636
        .valp  = &conf.period.hertz,
1637
        .descr = "Timer period in HZ (0 - use lowest possible)"
1638
    },
1639
    {
1640
        .name  = "PLIVE",
1641
        .tag   = AUD_OPT_BOOL,
1642
        .valp  = &conf.plive,
1643
        .descr = "(undocumented)"
1644
    },
1645
    {
1646
        .name  = "LOG_TO_MONITOR",
1647
        .tag   = AUD_OPT_BOOL,
1648
        .valp  = &conf.log_to_monitor,
1649
        .descr = "Print logging messages to monitor instead of stderr"
1650
    },
1651
    { /* End of list */ }
1652
};
1653

    
1654
static void audio_pp_nb_voices (const char *typ, int nb)
1655
{
1656
    switch (nb) {
1657
    case 0:
1658
        printf ("Does not support %s\n", typ);
1659
        break;
1660
    case 1:
1661
        printf ("One %s voice\n", typ);
1662
        break;
1663
    case INT_MAX:
1664
        printf ("Theoretically supports many %s voices\n", typ);
1665
        break;
1666
    default:
1667
        printf ("Theoretically supports upto %d %s voices\n", nb, typ);
1668
        break;
1669
    }
1670

    
1671
}
1672

    
1673
void AUD_help (void)
1674
{
1675
    size_t i;
1676

    
1677
    audio_process_options ("AUDIO", audio_options);
1678
    for (i = 0; i < ARRAY_SIZE (drvtab); i++) {
1679
        struct audio_driver *d = drvtab[i];
1680
        if (d->options) {
1681
            audio_process_options (d->name, d->options);
1682
        }
1683
    }
1684

    
1685
    printf ("Audio options:\n");
1686
    audio_print_options ("AUDIO", audio_options);
1687
    printf ("\n");
1688

    
1689
    printf ("Available drivers:\n");
1690

    
1691
    for (i = 0; i < ARRAY_SIZE (drvtab); i++) {
1692
        struct audio_driver *d = drvtab[i];
1693

    
1694
        printf ("Name: %s\n", d->name);
1695
        printf ("Description: %s\n", d->descr);
1696

    
1697
        audio_pp_nb_voices ("playback", d->max_voices_out);
1698
        audio_pp_nb_voices ("capture", d->max_voices_in);
1699

    
1700
        if (d->options) {
1701
            printf ("Options:\n");
1702
            audio_print_options (d->name, d->options);
1703
        }
1704
        else {
1705
            printf ("No options\n");
1706
        }
1707
        printf ("\n");
1708
    }
1709

    
1710
    printf (
1711
        "Options are settable through environment variables.\n"
1712
        "Example:\n"
1713
#ifdef _WIN32
1714
        "  set QEMU_AUDIO_DRV=wav\n"
1715
        "  set QEMU_WAV_PATH=c:\\tune.wav\n"
1716
#else
1717
        "  export QEMU_AUDIO_DRV=wav\n"
1718
        "  export QEMU_WAV_PATH=$HOME/tune.wav\n"
1719
        "(for csh replace export with setenv in the above)\n"
1720
#endif
1721
        "  qemu ...\n\n"
1722
        );
1723
}
1724

    
1725
static int audio_driver_init (AudioState *s, struct audio_driver *drv)
1726
{
1727
    if (drv->options) {
1728
        audio_process_options (drv->name, drv->options);
1729
    }
1730
    s->drv_opaque = drv->init ();
1731

    
1732
    if (s->drv_opaque) {
1733
        audio_init_nb_voices_out (drv);
1734
        audio_init_nb_voices_in (drv);
1735
        s->drv = drv;
1736
        return 0;
1737
    }
1738
    else {
1739
        dolog ("Could not init `%s' audio driver\n", drv->name);
1740
        return -1;
1741
    }
1742
}
1743

    
1744
static void audio_vm_change_state_handler (void *opaque, int running,
1745
                                           int reason)
1746
{
1747
    AudioState *s = opaque;
1748
    HWVoiceOut *hwo = NULL;
1749
    HWVoiceIn *hwi = NULL;
1750
    int op = running ? VOICE_ENABLE : VOICE_DISABLE;
1751

    
1752
    s->vm_running = running;
1753
    while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) {
1754
        hwo->pcm_ops->ctl_out (hwo, op, conf.try_poll_out);
1755
    }
1756

    
1757
    while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) {
1758
        hwi->pcm_ops->ctl_in (hwi, op, conf.try_poll_in);
1759
    }
1760
    audio_reset_timer (s);
1761
}
1762

    
1763
static void audio_atexit (void)
1764
{
1765
    AudioState *s = &glob_audio_state;
1766
    HWVoiceOut *hwo = NULL;
1767
    HWVoiceIn *hwi = NULL;
1768

    
1769
    while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) {
1770
        SWVoiceCap *sc;
1771

    
1772
        hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE);
1773
        hwo->pcm_ops->fini_out (hwo);
1774

    
1775
        for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1776
            CaptureVoiceOut *cap = sc->cap;
1777
            struct capture_callback *cb;
1778

    
1779
            for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
1780
                cb->ops.destroy (cb->opaque);
1781
            }
1782
        }
1783
    }
1784

    
1785
    while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) {
1786
        hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE);
1787
        hwi->pcm_ops->fini_in (hwi);
1788
    }
1789

    
1790
    if (s->drv) {
1791
        s->drv->fini (s->drv_opaque);
1792
    }
1793
}
1794

    
1795
static const VMStateDescription vmstate_audio = {
1796
    .name = "audio",
1797
    .version_id = 1,
1798
    .minimum_version_id = 1,
1799
    .minimum_version_id_old = 1,
1800
    .fields      = (VMStateField []) {
1801
        VMSTATE_END_OF_LIST()
1802
    }
1803
};
1804

    
1805
static void audio_init (void)
1806
{
1807
    size_t i;
1808
    int done = 0;
1809
    const char *drvname;
1810
    VMChangeStateEntry *e;
1811
    AudioState *s = &glob_audio_state;
1812

    
1813
    if (s->drv) {
1814
        return;
1815
    }
1816

    
1817
    QLIST_INIT (&s->hw_head_out);
1818
    QLIST_INIT (&s->hw_head_in);
1819
    QLIST_INIT (&s->cap_head);
1820
    atexit (audio_atexit);
1821

    
1822
    s->ts = qemu_new_timer (vm_clock, audio_timer, s);
1823
    if (!s->ts) {
1824
        hw_error("Could not create audio timer\n");
1825
    }
1826

    
1827
    audio_process_options ("AUDIO", audio_options);
1828

    
1829
    s->nb_hw_voices_out = conf.fixed_out.nb_voices;
1830
    s->nb_hw_voices_in = conf.fixed_in.nb_voices;
1831

    
1832
    if (s->nb_hw_voices_out <= 0) {
1833
        dolog ("Bogus number of playback voices %d, setting to 1\n",
1834
               s->nb_hw_voices_out);
1835
        s->nb_hw_voices_out = 1;
1836
    }
1837

    
1838
    if (s->nb_hw_voices_in <= 0) {
1839
        dolog ("Bogus number of capture voices %d, setting to 0\n",
1840
               s->nb_hw_voices_in);
1841
        s->nb_hw_voices_in = 0;
1842
    }
1843

    
1844
    {
1845
        int def;
1846
        drvname = audio_get_conf_str ("QEMU_AUDIO_DRV", NULL, &def);
1847
    }
1848

    
1849
    if (drvname) {
1850
        int found = 0;
1851

    
1852
        for (i = 0; i < ARRAY_SIZE (drvtab); i++) {
1853
            if (!strcmp (drvname, drvtab[i]->name)) {
1854
                done = !audio_driver_init (s, drvtab[i]);
1855
                found = 1;
1856
                break;
1857
            }
1858
        }
1859

    
1860
        if (!found) {
1861
            dolog ("Unknown audio driver `%s'\n", drvname);
1862
            dolog ("Run with -audio-help to list available drivers\n");
1863
        }
1864
    }
1865

    
1866
    if (!done) {
1867
        for (i = 0; !done && i < ARRAY_SIZE (drvtab); i++) {
1868
            if (drvtab[i]->can_be_default) {
1869
                done = !audio_driver_init (s, drvtab[i]);
1870
            }
1871
        }
1872
    }
1873

    
1874
    if (!done) {
1875
        done = !audio_driver_init (s, &no_audio_driver);
1876
        if (!done) {
1877
            hw_error("Could not initialize audio subsystem\n");
1878
        }
1879
        else {
1880
            dolog ("warning: Using timer based audio emulation\n");
1881
        }
1882
    }
1883

    
1884
    if (conf.period.hertz <= 0) {
1885
        if (conf.period.hertz < 0) {
1886
            dolog ("warning: Timer period is negative - %d "
1887
                   "treating as zero\n",
1888
                   conf.period.hertz);
1889
        }
1890
        conf.period.ticks = 1;
1891
    } else {
1892
        conf.period.ticks =
1893
            muldiv64 (1, get_ticks_per_sec (), conf.period.hertz);
1894
    }
1895

    
1896
    e = qemu_add_vm_change_state_handler (audio_vm_change_state_handler, s);
1897
    if (!e) {
1898
        dolog ("warning: Could not register change state handler\n"
1899
               "(Audio can continue looping even after stopping the VM)\n");
1900
    }
1901

    
1902
    QLIST_INIT (&s->card_head);
1903
    vmstate_register (NULL, 0, &vmstate_audio, s);
1904
}
1905

    
1906
void AUD_register_card (const char *name, QEMUSoundCard *card)
1907
{
1908
    audio_init ();
1909
    card->name = qemu_strdup (name);
1910
    memset (&card->entries, 0, sizeof (card->entries));
1911
    QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries);
1912
}
1913

    
1914
void AUD_remove_card (QEMUSoundCard *card)
1915
{
1916
    QLIST_REMOVE (card, entries);
1917
    qemu_free (card->name);
1918
}
1919

    
1920

    
1921
CaptureVoiceOut *AUD_add_capture (
1922
    struct audsettings *as,
1923
    struct audio_capture_ops *ops,
1924
    void *cb_opaque
1925
    )
1926
{
1927
    AudioState *s = &glob_audio_state;
1928
    CaptureVoiceOut *cap;
1929
    struct capture_callback *cb;
1930

    
1931
    if (audio_validate_settings (as)) {
1932
        dolog ("Invalid settings were passed when trying to add capture\n");
1933
        audio_print_settings (as);
1934
        goto err0;
1935
    }
1936

    
1937
    cb = audio_calloc (AUDIO_FUNC, 1, sizeof (*cb));
1938
    if (!cb) {
1939
        dolog ("Could not allocate capture callback information, size %zu\n",
1940
               sizeof (*cb));
1941
        goto err0;
1942
    }
1943
    cb->ops = *ops;
1944
    cb->opaque = cb_opaque;
1945

    
1946
    cap = audio_pcm_capture_find_specific (as);
1947
    if (cap) {
1948
        QLIST_INSERT_HEAD (&cap->cb_head, cb, entries);
1949
        return cap;
1950
    }
1951
    else {
1952
        HWVoiceOut *hw;
1953
        CaptureVoiceOut *cap;
1954

    
1955
        cap = audio_calloc (AUDIO_FUNC, 1, sizeof (*cap));
1956
        if (!cap) {
1957
            dolog ("Could not allocate capture voice, size %zu\n",
1958
                   sizeof (*cap));
1959
            goto err1;
1960
        }
1961

    
1962
        hw = &cap->hw;
1963
        QLIST_INIT (&hw->sw_head);
1964
        QLIST_INIT (&cap->cb_head);
1965

    
1966
        /* XXX find a more elegant way */
1967
        hw->samples = 4096 * 4;
1968
        hw->mix_buf = audio_calloc (AUDIO_FUNC, hw->samples,
1969
                                    sizeof (struct st_sample));
1970
        if (!hw->mix_buf) {
1971
            dolog ("Could not allocate capture mix buffer (%d samples)\n",
1972
                   hw->samples);
1973
            goto err2;
1974
        }
1975

    
1976
        audio_pcm_init_info (&hw->info, as);
1977

    
1978
        cap->buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
1979
        if (!cap->buf) {
1980
            dolog ("Could not allocate capture buffer "
1981
                   "(%d samples, each %d bytes)\n",
1982
                   hw->samples, 1 << hw->info.shift);
1983
            goto err3;
1984
        }
1985

    
1986
        hw->clip = mixeng_clip
1987
            [hw->info.nchannels == 2]
1988
            [hw->info.sign]
1989
            [hw->info.swap_endianness]
1990
            [audio_bits_to_index (hw->info.bits)];
1991

    
1992
        QLIST_INSERT_HEAD (&s->cap_head, cap, entries);
1993
        QLIST_INSERT_HEAD (&cap->cb_head, cb, entries);
1994

    
1995
        hw = NULL;
1996
        while ((hw = audio_pcm_hw_find_any_out (hw))) {
1997
            audio_attach_capture (hw);
1998
        }
1999
        return cap;
2000

    
2001
    err3:
2002
        qemu_free (cap->hw.mix_buf);
2003
    err2:
2004
        qemu_free (cap);
2005
    err1:
2006
        qemu_free (cb);
2007
    err0:
2008
        return NULL;
2009
    }
2010
}
2011

    
2012
void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque)
2013
{
2014
    struct capture_callback *cb;
2015

    
2016
    for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
2017
        if (cb->opaque == cb_opaque) {
2018
            cb->ops.destroy (cb_opaque);
2019
            QLIST_REMOVE (cb, entries);
2020
            qemu_free (cb);
2021

    
2022
            if (!cap->cb_head.lh_first) {
2023
                SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1;
2024

    
2025
                while (sw) {
2026
                    SWVoiceCap *sc = (SWVoiceCap *) sw;
2027
#ifdef DEBUG_CAPTURE
2028
                    dolog ("freeing %s\n", sw->name);
2029
#endif
2030

    
2031
                    sw1 = sw->entries.le_next;
2032
                    if (sw->rate) {
2033
                        st_rate_stop (sw->rate);
2034
                        sw->rate = NULL;
2035
                    }
2036
                    QLIST_REMOVE (sw, entries);
2037
                    QLIST_REMOVE (sc, entries);
2038
                    qemu_free (sc);
2039
                    sw = sw1;
2040
                }
2041
                QLIST_REMOVE (cap, entries);
2042
                qemu_free (cap);
2043
            }
2044
            return;
2045
        }
2046
    }
2047
}
2048

    
2049
void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol)
2050
{
2051
    if (sw) {
2052
        sw->vol.mute = mute;
2053
        sw->vol.l = nominal_volume.l * lvol / 255;
2054
        sw->vol.r = nominal_volume.r * rvol / 255;
2055
    }
2056
}
2057

    
2058
void AUD_set_volume_in (SWVoiceIn *sw, int mute, uint8_t lvol, uint8_t rvol)
2059
{
2060
    if (sw) {
2061
        sw->vol.mute = mute;
2062
        sw->vol.l = nominal_volume.l * lvol / 255;
2063
        sw->vol.r = nominal_volume.r * rvol / 255;
2064
    }
2065
}