Archipelago » qemu

/*

 * QEMU Audio subsystem

 *

 * Copyright (c) 2003-2005 Vassili Karpov (malc)

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "hw/hw.h"

#include "audio.h"

#include "monitor.h"

#include "qemu-timer.h"

#include "sysemu.h"

#define AUDIO_CAP "audio"

#include "audio_int.h"

/* #define DEBUG_PLIVE */

/* #define DEBUG_LIVE */

/* #define DEBUG_OUT */

/* #define DEBUG_CAPTURE */

/* #define DEBUG_POLL */

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

/* Order of CONFIG_AUDIO_DRIVERS is import.

   The 1st one is the one used by default, that is the reason

    that we generate the list.

*/

static struct audio_driver *drvtab[] = {

    CONFIG_AUDIO_DRIVERS

    &no_audio_driver,

    &wav_audio_driver

};

struct fixed_settings {

    int enabled;

    int nb_voices;

    int greedy;

    struct audsettings settings;

};

static struct {

    struct fixed_settings fixed_out;

    struct fixed_settings fixed_in;

    union {

        int hertz;

        int64_t ticks;

    } period;

    int plive;

    int log_to_monitor;

    int try_poll_in;

    int try_poll_out;

} conf = {

    .fixed_out = { /* DAC fixed settings */

        .enabled = 1,

        .nb_voices = 1,

        .greedy = 1,

        .settings = {

            .freq = 44100,

            .nchannels = 2,

            .fmt = AUD_FMT_S16,

            .endianness =  AUDIO_HOST_ENDIANNESS,

        }

    },

    .fixed_in = { /* ADC fixed settings */

        .enabled = 1,

        .nb_voices = 1,

        .greedy = 1,

        .settings = {

            .freq = 44100,

            .nchannels = 2,

            .fmt = AUD_FMT_S16,

            .endianness = AUDIO_HOST_ENDIANNESS,

        }

    },

    .period = { .hertz = 250 },

    .plive = 0,

    .log_to_monitor = 0,

    .try_poll_in = 1,

    .try_poll_out = 1,

};

static AudioState glob_audio_state;

struct mixeng_volume nominal_volume = {

    .mute = 0,

#ifdef FLOAT_MIXENG

    .r = 1.0,

    .l = 1.0,

#else

    .r = 1ULL << 32,

    .l = 1ULL << 32,

#endif

};

#ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED

#error No its not

#else

int audio_bug (const char *funcname, int cond)

{

    if (cond) {

        static int shown;

        AUD_log (NULL, "A bug was just triggered in %s\n", funcname);

        if (!shown) {

            shown = 1;

            AUD_log (NULL, "Save all your work and restart without audio\n");

            AUD_log (NULL, "Please send bug report to av1474@comtv.ru\n");

            AUD_log (NULL, "I am sorry\n");

        }

        AUD_log (NULL, "Context:\n");

#if defined AUDIO_BREAKPOINT_ON_BUG

#  if defined HOST_I386

#    if defined __GNUC__

        __asm__ ("int3");

#    elif defined _MSC_VER

        _asm _emit 0xcc;

#    else

        abort ();

#    endif

#  else

        abort ();

#  endif

#endif

    }

    return cond;

}

#endif

static inline int audio_bits_to_index (int bits)

{

    switch (bits) {

    case 8:

        return 0;

    case 16:

        return 1;

    case 32:

        return 2;

    default:

        audio_bug ("bits_to_index", 1);

        AUD_log (NULL, "invalid bits %d\n", bits);

        return 0;

    }

}

void *audio_calloc (const char *funcname, int nmemb, size_t size)

{

    int cond;

    size_t len;

    len = nmemb * size;

    cond = !nmemb || !size;

    cond |= nmemb < 0;

    cond |= len < size;

    if (audio_bug ("audio_calloc", cond)) {

        AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n",

                 funcname);

        AUD_log (NULL, "nmemb=%d size=%zu (len=%zu)\n", nmemb, size, len);

        return NULL;

    }

    return qemu_mallocz (len);

}

static char *audio_alloc_prefix (const char *s)

{

    const char qemu_prefix[] = "QEMU_";

    size_t len, i;

    char *r, *u;

    if (!s) {

        return NULL;

    }

    len = strlen (s);

    r = qemu_malloc (len + sizeof (qemu_prefix));

    u = r + sizeof (qemu_prefix) - 1;

    pstrcpy (r, len + sizeof (qemu_prefix), qemu_prefix);

    pstrcat (r, len + sizeof (qemu_prefix), s);

    for (i = 0; i < len; ++i) {

        u[i] = qemu_toupper(u[i]);

    }

    return r;

}

static const char *audio_audfmt_to_string (audfmt_e fmt)

{

    switch (fmt) {

    case AUD_FMT_U8:

        return "U8";

    case AUD_FMT_U16:

        return "U16";

    case AUD_FMT_S8:

        return "S8";

    case AUD_FMT_S16:

        return "S16";

    case AUD_FMT_U32:

        return "U32";

    case AUD_FMT_S32:

        return "S32";

    }

    dolog ("Bogus audfmt %d returning S16\n", fmt);

    return "S16";

}

static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval,

                                        int *defaultp)

{

    if (!strcasecmp (s, "u8")) {

        *defaultp = 0;

        return AUD_FMT_U8;

    }

    else if (!strcasecmp (s, "u16")) {

        *defaultp = 0;

        return AUD_FMT_U16;

    }

    else if (!strcasecmp (s, "u32")) {

        *defaultp = 0;

        return AUD_FMT_U32;

    }

    else if (!strcasecmp (s, "s8")) {

        *defaultp = 0;

        return AUD_FMT_S8;

    }

    else if (!strcasecmp (s, "s16")) {

        *defaultp = 0;

        return AUD_FMT_S16;

    }

    else if (!strcasecmp (s, "s32")) {

        *defaultp = 0;

        return AUD_FMT_S32;

    }

    else {

        dolog ("Bogus audio format `%s' using %s\n",

               s, audio_audfmt_to_string (defval));

        *defaultp = 1;

        return defval;

    }

}

static audfmt_e audio_get_conf_fmt (const char *envname,

                                    audfmt_e defval,

                                    int *defaultp)

{

    const char *var = getenv (envname);

    if (!var) {

        *defaultp = 1;

        return defval;

    }

    return audio_string_to_audfmt (var, defval, defaultp);

}

static int audio_get_conf_int (const char *key, int defval, int *defaultp)

{

    int val;

    char *strval;

    strval = getenv (key);

    if (strval) {

        *defaultp = 0;

        val = atoi (strval);

        return val;

    }

    else {

        *defaultp = 1;

        return defval;

    }

}

static const char *audio_get_conf_str (const char *key,

                                       const char *defval,

                                       int *defaultp)

{

    const char *val = getenv (key);

    if (!val) {

        *defaultp = 1;

        return defval;

    }

    else {

        *defaultp = 0;

        return val;

    }

}

void AUD_vlog (const char *cap, const char *fmt, va_list ap)

{

    if (conf.log_to_monitor) {

        if (cap) {

            monitor_printf(cur_mon, "%s: ", cap);

        }

        monitor_vprintf(cur_mon, fmt, ap);

    }

    else {

        if (cap) {

            fprintf (stderr, "%s: ", cap);

        }

        vfprintf (stderr, fmt, ap);

    }

}

void AUD_log (const char *cap, const char *fmt, ...)

{

    va_list ap;

    va_start (ap, fmt);

    AUD_vlog (cap, fmt, ap);

    va_end (ap);

}

static void audio_print_options (const char *prefix,

                                 struct audio_option *opt)

{

    char *uprefix;

    if (!prefix) {

        dolog ("No prefix specified\n");

        return;

    }

    if (!opt) {

        dolog ("No options\n");

        return;

    }

    uprefix = audio_alloc_prefix (prefix);

    for (; opt->name; opt++) {

        const char *state = "default";

        printf ("  %s_%s: ", uprefix, opt->name);

        if (opt->overriddenp && *opt->overriddenp) {

            state = "current";

        }

        switch (opt->tag) {

        case AUD_OPT_BOOL:

            {

                int *intp = opt->valp;

                printf ("boolean, %s = %d\n", state, *intp ? 1 : 0);

            }

            break;

        case AUD_OPT_INT:

            {

                int *intp = opt->valp;

                printf ("integer, %s = %d\n", state, *intp);

            }

            break;

        case AUD_OPT_FMT:

            {

                audfmt_e *fmtp = opt->valp;

                printf (

                    "format, %s = %s, (one of: U8 S8 U16 S16 U32 S32)\n",

                    state,

                    audio_audfmt_to_string (*fmtp)

                    );

            }

            break;

        case AUD_OPT_STR:

            {

                const char **strp = opt->valp;

                printf ("string, %s = %s\n",

                        state,

                        *strp ? *strp : "(not set)");

            }

            break;

        default:

            printf ("???\n");

            dolog ("Bad value tag for option %s_%s %d\n",

                   uprefix, opt->name, opt->tag);

            break;

        }

        printf ("    %s\n", opt->descr);

    }

    qemu_free (uprefix);

}

static void audio_process_options (const char *prefix,

                                   struct audio_option *opt)

{

    char *optname;

    const char qemu_prefix[] = "QEMU_";

    size_t preflen, optlen;

    if (audio_bug (AUDIO_FUNC, !prefix)) {

        dolog ("prefix = NULL\n");

        return;

    }

    if (audio_bug (AUDIO_FUNC, !opt)) {

        dolog ("opt = NULL\n");

        return;

    }

    preflen = strlen (prefix);

    for (; opt->name; opt++) {

        size_t len, i;

        int def;

        if (!opt->valp) {

            dolog ("Option value pointer for `%s' is not set\n",

                   opt->name);

            continue;

        }

        len = strlen (opt->name);

        /* len of opt->name + len of prefix + size of qemu_prefix

         * (includes trailing zero) + zero + underscore (on behalf of

         * sizeof) */

        optlen = len + preflen + sizeof (qemu_prefix) + 1;

        optname = qemu_malloc (optlen);

        pstrcpy (optname, optlen, qemu_prefix);

        /* copy while upper-casing, including trailing zero */

        for (i = 0; i <= preflen; ++i) {

            optname[i + sizeof (qemu_prefix) - 1] = qemu_toupper(prefix[i]);

        }

        pstrcat (optname, optlen, "_");

        pstrcat (optname, optlen, opt->name);

        def = 1;

        switch (opt->tag) {

        case AUD_OPT_BOOL:

        case AUD_OPT_INT:

            {

                int *intp = opt->valp;

                *intp = audio_get_conf_int (optname, *intp, &def);

            }

            break;

        case AUD_OPT_FMT:

            {

                audfmt_e *fmtp = opt->valp;

                *fmtp = audio_get_conf_fmt (optname, *fmtp, &def);

            }

            break;

        case AUD_OPT_STR:

            {

                const char **strp = opt->valp;

                *strp = audio_get_conf_str (optname, *strp, &def);

            }

            break;

        default:

            dolog ("Bad value tag for option `%s' - %d\n",

                   optname, opt->tag);

            break;

        }

        if (!opt->overriddenp) {

            opt->overriddenp = &opt->overridden;

        }

        *opt->overriddenp = !def;

        qemu_free (optname);

    }

}

static void audio_print_settings (struct audsettings *as)

{

    dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);

    switch (as->fmt) {

    case AUD_FMT_S8:

        AUD_log (NULL, "S8");

        break;

    case AUD_FMT_U8:

        AUD_log (NULL, "U8");

        break;

    case AUD_FMT_S16:

        AUD_log (NULL, "S16");

        break;

    case AUD_FMT_U16:

        AUD_log (NULL, "U16");

        break;

    case AUD_FMT_S32:

        AUD_log (NULL, "S32");

        break;

    case AUD_FMT_U32:

        AUD_log (NULL, "U32");

        break;

    default:

        AUD_log (NULL, "invalid(%d)", as->fmt);

        break;

    }

    AUD_log (NULL, " endianness=");

    switch (as->endianness) {

    case 0:

        AUD_log (NULL, "little");

        break;

    case 1:

        AUD_log (NULL, "big");

        break;

    default:

        AUD_log (NULL, "invalid");

        break;

    }

    AUD_log (NULL, "\n");

}

static int audio_validate_settings (struct audsettings *as)

{

    int invalid;

    invalid = as->nchannels != 1 && as->nchannels != 2;

    invalid |= as->endianness != 0 && as->endianness != 1;

    switch (as->fmt) {

    case AUD_FMT_S8:

    case AUD_FMT_U8:

    case AUD_FMT_S16:

    case AUD_FMT_U16:

    case AUD_FMT_S32:

    case AUD_FMT_U32:

        break;

    default:

        invalid = 1;

        break;

    }

    invalid |= as->freq <= 0;

    return invalid ? -1 : 0;

}

static int audio_pcm_info_eq (struct audio_pcm_info *info, struct audsettings *as)

{

    int bits = 8, sign = 0;

    switch (as->fmt) {

    case AUD_FMT_S8:

        sign = 1;

    case AUD_FMT_U8:

        break;

    case AUD_FMT_S16:

        sign = 1;

    case AUD_FMT_U16:

        bits = 16;

        break;

    case AUD_FMT_S32:

        sign = 1;

    case AUD_FMT_U32:

        bits = 32;

        break;

    }

    return info->freq == as->freq

        && info->nchannels == as->nchannels

        && info->sign == sign

        && info->bits == bits

        && info->swap_endianness == (as->endianness != AUDIO_HOST_ENDIANNESS);

}

void audio_pcm_init_info (struct audio_pcm_info *info, struct audsettings *as)

{

    int bits = 8, sign = 0, shift = 0;

    switch (as->fmt) {

    case AUD_FMT_S8:

        sign = 1;

    case AUD_FMT_U8:

        break;

    case AUD_FMT_S16:

        sign = 1;

    case AUD_FMT_U16:

        bits = 16;

        shift = 1;

        break;

    case AUD_FMT_S32:

        sign = 1;

    case AUD_FMT_U32:

        bits = 32;

        shift = 2;

        break;

    }

    info->freq = as->freq;

    info->bits = bits;

    info->sign = sign;

    info->nchannels = as->nchannels;

    info->shift = (as->nchannels == 2) + shift;

    info->align = (1 << info->shift) - 1;

    info->bytes_per_second = info->freq << info->shift;

    info->swap_endianness = (as->endianness != AUDIO_HOST_ENDIANNESS);

}

void audio_pcm_info_clear_buf (struct audio_pcm_info *info, void *buf, int len)

{

    if (!len) {

        return;

    }

    if (info->sign) {

        memset (buf, 0x00, len << info->shift);

    }

    else {

        switch (info->bits) {

        case 8:

            memset (buf, 0x80, len << info->shift);

            break;

        case 16:

            {

                int i;

                uint16_t *p = buf;

                int shift = info->nchannels - 1;

                short s = INT16_MAX;

                if (info->swap_endianness) {

                    s = bswap16 (s);

                }

                for (i = 0; i < len << shift; i++) {

                    p[i] = s;

                }

            }

            break;

        case 32:

            {

                int i;

                uint32_t *p = buf;

                int shift = info->nchannels - 1;

                int32_t s = INT32_MAX;

                if (info->swap_endianness) {

                    s = bswap32 (s);

                }

                for (i = 0; i < len << shift; i++) {

                    p[i] = s;

                }

            }

            break;

        default:

            AUD_log (NULL, "audio_pcm_info_clear_buf: invalid bits %d\n",

                     info->bits);

            break;

        }

    }

}

/*

 * Capture

 */

static void noop_conv (struct st_sample *dst, const void *src,

                       int samples, struct mixeng_volume *vol)

{

    (void) src;

    (void) dst;

    (void) samples;

    (void) vol;

}

static CaptureVoiceOut *audio_pcm_capture_find_specific (

    struct audsettings *as

    )

{

    CaptureVoiceOut *cap;

    AudioState *s = &glob_audio_state;

    for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {

        if (audio_pcm_info_eq (&cap->hw.info, as)) {

            return cap;

        }

    }

    return NULL;

}

static void audio_notify_capture (CaptureVoiceOut *cap, audcnotification_e cmd)

{

    struct capture_callback *cb;

#ifdef DEBUG_CAPTURE

    dolog ("notification %d sent\n", cmd);

#endif

    for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {

        cb->ops.notify (cb->opaque, cmd);

    }

}

static void audio_capture_maybe_changed (CaptureVoiceOut *cap, int enabled)

{

    if (cap->hw.enabled != enabled) {

        audcnotification_e cmd;

        cap->hw.enabled = enabled;

        cmd = enabled ? AUD_CNOTIFY_ENABLE : AUD_CNOTIFY_DISABLE;

        audio_notify_capture (cap, cmd);

    }

}

static void audio_recalc_and_notify_capture (CaptureVoiceOut *cap)

{

    HWVoiceOut *hw = &cap->hw;

    SWVoiceOut *sw;

    int enabled = 0;

    for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {

        if (sw->active) {

            enabled = 1;

            break;

        }

    }

    audio_capture_maybe_changed (cap, enabled);

}

static void audio_detach_capture (HWVoiceOut *hw)

{

    SWVoiceCap *sc = hw->cap_head.lh_first;

    while (sc) {

        SWVoiceCap *sc1 = sc->entries.le_next;

        SWVoiceOut *sw = &sc->sw;

        CaptureVoiceOut *cap = sc->cap;

        int was_active = sw->active;

        if (sw->rate) {

            st_rate_stop (sw->rate);

            sw->rate = NULL;

        }

        QLIST_REMOVE (sw, entries);

        QLIST_REMOVE (sc, entries);

        qemu_free (sc);

        if (was_active) {

            /* We have removed soft voice from the capture:

               this might have changed the overall status of the capture

               since this might have been the only active voice */

            audio_recalc_and_notify_capture (cap);

        }

        sc = sc1;

    }

}

static int audio_attach_capture (HWVoiceOut *hw)

{

    AudioState *s = &glob_audio_state;

    CaptureVoiceOut *cap;

    audio_detach_capture (hw);

    for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {

        SWVoiceCap *sc;

        SWVoiceOut *sw;

        HWVoiceOut *hw_cap = &cap->hw;

        sc = audio_calloc (AUDIO_FUNC, 1, sizeof (*sc));

        if (!sc) {

            dolog ("Could not allocate soft capture voice (%zu bytes)\n",

                   sizeof (*sc));

            return -1;

        }

        sc->cap = cap;

        sw = &sc->sw;

        sw->hw = hw_cap;

        sw->info = hw->info;

        sw->empty = 1;

        sw->active = hw->enabled;

        sw->conv = noop_conv;

        sw->ratio = ((int64_t) hw_cap->info.freq << 32) / sw->info.freq;

        sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq);

        if (!sw->rate) {

            dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw));

            qemu_free (sw);

            return -1;

        }

        QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries);

        QLIST_INSERT_HEAD (&hw->cap_head, sc, entries);

#ifdef DEBUG_CAPTURE

        asprintf (&sw->name, "for %p %d,%d,%d",

                  hw, sw->info.freq, sw->info.bits, sw->info.nchannels);

        dolog ("Added %s active = %d\n", sw->name, sw->active);

#endif

        if (sw->active) {

            audio_capture_maybe_changed (cap, 1);

        }

    }

    return 0;

}

/*

 * Hard voice (capture)

 */

static int audio_pcm_hw_find_min_in (HWVoiceIn *hw)

{

    SWVoiceIn *sw;

    int m = hw->total_samples_captured;

    for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {

        if (sw->active) {

            m = audio_MIN (m, sw->total_hw_samples_acquired);

        }

    }

    return m;

}

int audio_pcm_hw_get_live_in (HWVoiceIn *hw)

{

    int live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw);

    if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {

        dolog ("live=%d hw->samples=%d\n", live, hw->samples);

        return 0;

    }

    return live;

}

int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf,

                           int live, int pending)

{

    int left = hw->samples - pending;

    int len = audio_MIN (left, live);

    int clipped = 0;

    while (len) {

        struct st_sample *src = hw->mix_buf + hw->rpos;

        uint8_t *dst = advance (pcm_buf, hw->rpos << hw->info.shift);

        int samples_till_end_of_buf = hw->samples - hw->rpos;

        int samples_to_clip = audio_MIN (len, samples_till_end_of_buf);

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

        hw->rpos = (hw->rpos + samples_to_clip) % hw->samples;

        len -= samples_to_clip;

        clipped += samples_to_clip;

    }

    return clipped;

}

/*

 * Soft voice (capture)

 */