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 "vl.h"

#define AUDIO_CAP "audio"

#include "audio_int.h"

/* #define DEBUG_PLIVE */

/* #define DEBUG_LIVE */

/* #define DEBUG_OUT */

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

static struct audio_driver *drvtab[] = {

#ifdef CONFIG_OSS

    &oss_audio_driver,

#endif

#ifdef CONFIG_ALSA

    &alsa_audio_driver,

#endif

#ifdef CONFIG_COREAUDIO

    &coreaudio_audio_driver,

#endif

#ifdef CONFIG_DSOUND

    &dsound_audio_driver,

#endif

#ifdef CONFIG_FMOD

    &fmod_audio_driver,

#endif

#ifdef CONFIG_SDL

    &sdl_audio_driver,

#endif

    &no_audio_driver,

    &wav_audio_driver

};

struct fixed_settings {

    int enabled;

    int nb_voices;

    int greedy;

    audsettings_t settings;

};

static struct {

    struct fixed_settings fixed_out;

    struct fixed_settings fixed_in;

    union {

        int hz;

        int64_t ticks;

    } period;

    int plive;

    int log_to_monitor;

} conf = {

    {                           /* DAC fixed settings */

        1,                      /* enabled */

        1,                      /* nb_voices */

        1,                      /* greedy */

        {

            44100,              /* freq */

            2,                  /* nchannels */

            AUD_FMT_S16         /* fmt */

        }

    },

    {                           /* ADC fixed settings */

        1,                      /* enabled */

        1,                      /* nb_voices */

        1,                      /* greedy */

        {

            44100,              /* freq */

            2,                  /* nchannels */

            AUD_FMT_S16         /* fmt */

        }

    },

    { 0 },                      /* period */

    0,                          /* plive */

    0                           /* log_to_monitor */

};

static AudioState glob_audio_state;

volume_t nominal_volume = {

    0,

#ifdef FLOAT_MIXENG

    1.0,

    1.0

#else

    UINT_MAX,

    UINT_MAX

#endif

};

/* http://www.df.lth.se/~john_e/gems/gem002d.html */

/* http://www.multi-platforms.com/Tips/PopCount.htm */

uint32_t popcount (uint32_t u)

{

    u = ((u&0x55555555) + ((u>>1)&0x55555555));

    u = ((u&0x33333333) + ((u>>2)&0x33333333));

    u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));

    u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));

    u = ( u&0x0000ffff) + (u>>16);

    return u;

}

inline uint32_t lsbindex (uint32_t u)

{

    return popcount ((u&-u)-1);

}

#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, "Error a bug that 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 malc@pulsesoft.com\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

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;

    char *r;

    if (!s) {

        return NULL;

    }

    len = strlen (s);

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

    if (r) {

        size_t i;

        char *u = r + sizeof (qemu_prefix) - 1;

        strcpy (r, qemu_prefix);

        strcat (r, s);

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

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

        }

    }

    return r;

}

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";

    }

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

    return "S16";

}

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, "s8")) {

        *defaultp = 0;

        return AUD_FMT_S8;

    }

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

        *defaultp = 0;

        return AUD_FMT_S16;

    }

    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) {

            term_printf ("%s: ", cap);

        }

        term_vprintf (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->overridenp && *opt->overridenp) {

            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)\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;

    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) */

        optname = qemu_malloc (len + preflen + sizeof (qemu_prefix) + 1);

        if (!optname) {

            dolog ("Could not allocate memory for option name `%s'\n",

                   opt->name);

            continue;

        }

        strcpy (optname, qemu_prefix);

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

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

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

        }

        strcat (optname, "_");

        strcat (optname, 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->overridenp) {

            opt->overridenp = &opt->overriden;

        }

        *opt->overridenp = !def;

        qemu_free (optname);

    }

}

static void audio_print_settings (audsettings_t *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;

    default:

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

        break;

    }

    AUD_log (NULL, "\n");

}

static int audio_validate_settigs (audsettings_t *as)

{

    int invalid;

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

    switch (as->fmt) {

    case AUD_FMT_S8:

    case AUD_FMT_U8:

    case AUD_FMT_S16:

    case AUD_FMT_U16:

        break;

    default:

        invalid = 1;

        break;

    }

    invalid |= as->freq <= 0;

    if (invalid) {

        return -1;

    }

    return 0;

}

static int audio_pcm_info_eq (struct audio_pcm_info *info, audsettings_t *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;

    }

    return info->freq == as->freq

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

        && info->sign == sign

        && info->bits == bits;

}

void audio_pcm_init_info (

    struct audio_pcm_info *info,

    audsettings_t *as,

    int swap_endian

    )

{

    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;

    }

    info->freq = as->freq;

    info->bits = bits;

    info->sign = sign;

    info->nchannels = as->nchannels;

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

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

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

    info->swap_endian = swap_endian;

}

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

{

    if (!len) {

        return;

    }

    if (info->sign) {

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

    }

    else {

        if (info->bits == 8) {

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

        }

        else {

            int i;

            uint16_t *p = buf;

            int shift = info->nchannels - 1;

            short s = INT16_MAX;

            if (info->swap_endian) {

                s = bswap16 (s);

            }

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

                p[i] = s;

            }

        }

    }

}

/*

 * 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;

}

/*

 * Soft voice (capture)

 */

static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw)

{

    HWVoiceIn *hw = sw->hw;

    int live = hw->total_samples_captured - sw->total_hw_samples_acquired;

    int rpos;

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

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

        return 0;

    }

    rpos = hw->wpos - live;

    if (rpos >= 0) {

        return rpos;

    }

    else {

        return hw->samples + rpos;

    }

}

int audio_pcm_sw_read (SWVoiceIn *sw, void *buf, int size)

{

    HWVoiceIn *hw = sw->hw;

    int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;

    st_sample_t *src, *dst = sw->buf;

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

    live = hw->total_samples_captured - sw->total_hw_samples_acquired;

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

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

        return 0;

    }

    samples = size >> sw->info.shift;

    if (!live) {

        return 0;

    }

    swlim = (live * sw->ratio) >> 32;

    swlim = audio_MIN (swlim, samples);

    while (swlim) {

        src = hw->conv_buf + rpos;

        isamp = hw->wpos - rpos;

        /* XXX: <= ? */

        if (isamp <= 0) {

            isamp = hw->samples - rpos;

        }

        if (!isamp) {

            break;

        }

        osamp = swlim;

        if (audio_bug (AUDIO_FUNC, osamp < 0)) {

            dolog ("osamp=%d\n", osamp);

            return 0;

        }

        st_rate_flow (sw->rate, src, dst, &isamp, &osamp);

        swlim -= osamp;

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

        dst += osamp;

        ret += osamp;

        total += isamp;

    }

    sw->clip (buf, sw->buf, ret);

    sw->total_hw_samples_acquired += total;

    return ret << sw->info.shift;

}

/*

 * Hard voice (playback)

 */

static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)

{

    SWVoiceOut *sw;

    int m = INT_MAX;

    int nb_live = 0;

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

        if (sw->active || !sw->empty) {

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

            nb_live += 1;

        }

    }

    *nb_livep = nb_live;

    return m;

}

int audio_pcm_hw_get_live_out2 (HWVoiceOut *hw, int *nb_live)

{

    int smin;

    smin = audio_pcm_hw_find_min_out (hw, nb_live);

    if (!*nb_live) {

        return 0;

    }

    else {

        int live = smin;

        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_get_live_out (HWVoiceOut *hw)

{

    int nb_live;

    int live;

    live = audio_pcm_hw_get_live_out2 (hw, &nb_live);

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

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

        return 0;

    }

    return live;

}

/*

 * Soft voice (playback)

 */

int audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int size)

{

    int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;

    int ret = 0, pos = 0, total = 0;

    if (!sw) {

        return size;

    }

    hwsamples = sw->hw->samples;

    live = sw->total_hw_samples_mixed;

    if (audio_bug (AUDIO_FUNC, live < 0 || live > hwsamples)){

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

        return 0;

    }

    if (live == hwsamples) {

        return 0;

    }

    wpos = (sw->hw->rpos + live) % hwsamples;

    samples = size >> sw->info.shift;

    dead = hwsamples - live;

    swlim = ((int64_t) dead << 32) / sw->ratio;

    swlim = audio_MIN (swlim, samples);

    if (swlim) {

        sw->conv (sw->buf, buf, swlim, &sw->vol);

    }

    while (swlim) {

        dead = hwsamples - live;

        left = hwsamples - wpos;

        blck = audio_MIN (dead, left);

        if (!blck) {

            break;

        }

        isamp = swlim;

        osamp = blck;

        st_rate_flow_mix (

            sw->rate,

            sw->buf + pos,

            sw->hw->mix_buf + wpos,

            &isamp,

            &osamp

            );

        ret += isamp;

        swlim -= isamp;

        pos += isamp;

        live += osamp;

        wpos = (wpos + osamp) % hwsamples;

        total += osamp;

    }

    sw->total_hw_samples_mixed += total;

    sw->empty = sw->total_hw_samples_mixed == 0;

#ifdef DEBUG_OUT

    dolog (

        "%s: write size %d ret %d total sw %d\n",

        SW_NAME (sw),

        size >> sw->info.shift,

        ret,

        sw->total_hw_samples_mixed

        );

#endif

    return ret << sw->info.shift;

}

#ifdef DEBUG_AUDIO

static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info)

{

    dolog ("%s: bits %d, sign %d, freq %d, nchan %d\n",

           cap, info->bits, info->sign, info->freq, info->nchannels);

}

#endif

#define DAC

#include "audio_template.h"

#undef DAC

#include "audio_template.h"

int AUD_write (SWVoiceOut *sw, void *buf, int size)

{

    int bytes;

    if (!sw) {

        /* XXX: Consider options */

        return size;

    }

    if (!sw->hw->enabled) {

        dolog ("Writing to disabled voice %s\n", SW_NAME (sw));

        return 0;

    }

    bytes = sw->hw->pcm_ops->write (sw, buf, size);

    return bytes;

}

int AUD_read (SWVoiceIn *sw, void *buf, int size)