/*

 * 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 "console.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 SW_NAME(sw) (sw)->name ? (sw)->name : "unknown"

static struct audio_driver *drvtab[] = {

    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;

} conf = {

    {                           /* DAC fixed settings */

        1,                      /* enabled */

        1,                      /* nb_voices */

        1,                      /* greedy */

        {

            44100,              /* freq */

            2,                  /* nchannels */

            AUD_FMT_S16,        /* fmt */

            AUDIO_HOST_ENDIANNESS

        }

    },

    {                           /* ADC fixed settings */

        1,                      /* enabled */

        1,                      /* nb_voices */

        1,                      /* greedy */

        {

            44100,              /* freq */

            2,                  /* nchannels */

            AUD_FMT_S16,        /* fmt */

            AUDIO_HOST_ENDIANNESS

        }

    },

    { 250 },                    /* period */

    0,                          /* plive */

    0                           /* log_to_monitor */

};

static AudioState glob_audio_state;

struct mixeng_volume nominal_volume = {

    0,

#ifdef FLOAT_MIXENG

    1.0,

    1.0

#else

    1ULL << 32,

    1ULL << 32

#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, "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 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

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;

    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;

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

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

        if (!optname) {

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

                   opt->name);

            continue;

        }

        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;