Archipelago » qemu

#After enabling Adlib and/or FMOD rebuild QEMU from scratch

#Uncomment following for adlib support

#USE_ADLIB=1

#Uncomment following and specify proper paths/names for FMOD support

#USE_FMOD=1

#FMOD_INCLUDE=/net/include/fmod

#FMOD_LIBPATH=/net/lib

#FMOD_VERSION=3.74

VPATH=$(SRC_PATH):$(TARGET_PATH):$(SRC_PATH)/hw:$(SRC_PATH)/audio

SOUND_HW = sb16.o

AUDIODRV = audio.o ossaudio.o sdlaudio.o wavaudio.o

ifeq ($(USE_ADLIB),1)

SOUND_HW += fmopl.o adlib.o

audio.o: DEFINES := -DUSE_ADLIB $(DEFINES)

endif

ifeq ($(USE_FMOD),1)

AUDIODRV += fmodaudio.o

audio.o fmodaudio.o: DEFINES := -DUSE_FMOD_AUDIO -I$(FMOD_INCLUDE) $(DEFINES)

LDFLAGS += -L$(FMOD_LIBPATH) -Wl,-rpath,$(FMOD_LIBPATH)

LIBS += -lfmod-$(FMOD_VERSION)

endif

VL_OBJS+= ide.o ne2000.o pckbd.o vga.o $(SOUND_HW) dma.o $(AUDIODRV)

VL_OBJS+= fdc.o mc146818rtc.o serial.o i8259.o i8254.o pc.o

VL_OBJS+= cirrus_vga.o mixeng.o

VL_OBJS+= ppc.o ide.o ne2000.o pckbd.o vga.o $(SOUND_HW) dma.o $(AUDIODRV)

VL_OBJS+= ppc_prep.o ppc_chrp.o cuda.o adb.o openpic.o mixeng.o

mixeng.o: mixeng.c mixeng.h mixeng_template.h

/*

 * QEMU Audio subsystem

 * 

 * Copyright (c) 2003-2004 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 <assert.h>

#include <limits.h>

#include "vl.h"

#define AUDIO_CAP "audio"

#include "audio/audio.h"

#define USE_SDL_AUDIO

#define USE_WAV_AUDIO

#if defined __linux__ || (defined _BSD && !defined __APPLE__)

#define USE_OSS_AUDIO

#endif

#ifdef USE_OSS_AUDIO

#include "audio/ossaudio.h"

#endif

#ifdef USE_SDL_AUDIO

#include "audio/sdlaudio.h"

#endif

#ifdef USE_WAV_AUDIO

#include "audio/wavaudio.h"

#endif

#ifdef USE_FMOD_AUDIO

#include "audio/fmodaudio.h"

#endif

#define QC_AUDIO_DRV    "QEMU_AUDIO_DRV"

#define QC_VOICES    "QEMU_VOICES"

#define QC_FIXED_FORMAT "QEMU_FIXED_FORMAT"

#define QC_FIXED_FREQ   "QEMU_FIXED_FREQ"

extern void SB16_init (void);

#ifdef USE_ADLIB

extern void Adlib_init (void);

#endif

#ifdef USE_GUS

extern void GUS_init (void);

#endif

static void (*hw_ctors[]) (void) = {

    SB16_init,

#ifdef USE_ADLIB

    Adlib_init,

#endif

#ifdef USE_GUS

    GUS_init,

#endif

    NULL

};

static HWVoice *hw_voice;

AudioState audio_state = {

    1,                          /* use fixed settings */

    44100,                      /* fixed frequency */

    2,                          /* fixed channels */

    AUD_FMT_S16,                /* fixed format */

    1,                          /* number of hw voices */

    -1                          /* voice size */

};

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

}

int audio_get_conf_int (const char *key, int defval)

{

    int val = defval;

    char *strval;

    strval = getenv (key);

    if (strval) {

        val = atoi (strval);

    }

    return val;

}

const char *audio_get_conf_str (const char *key, const char *defval)

{

    const char *val = getenv (key);

    if (!val)

        return defval;

    else

        return val;

}

void audio_log (const char *fmt, ...)

{

    va_list ap;

    va_start (ap, fmt);

    vfprintf (stderr, fmt, ap);

    va_end (ap);

}

/*

 * Soft Voice

 */

void pcm_sw_free_resources (SWVoice *sw)

{

    if (sw->buf) qemu_free (sw->buf);

    if (sw->rate) st_rate_stop (sw->rate);

    sw->buf = NULL;

    sw->rate = NULL;

}

int pcm_sw_alloc_resources (SWVoice *sw)

{

    sw->buf = qemu_mallocz (sw->hw->samples * sizeof (st_sample_t));

    if (!sw->buf)

        return -1;

    sw->rate = st_rate_start (sw->freq, sw->hw->freq);

    if (!sw->rate) {

        qemu_free (sw->buf);

        sw->buf = NULL;

        return -1;

    }

    return 0;

}

void pcm_sw_fini (SWVoice *sw)

{

    pcm_sw_free_resources (sw);

}

int pcm_sw_init (SWVoice *sw, HWVoice *hw, int freq,

                 int nchannels, audfmt_e fmt)

{

    int bits = 8, sign = 0;

    switch (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;

    }

    sw->hw = hw;

    sw->freq = freq;

    sw->fmt = fmt;

    sw->nchannels = nchannels;

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

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

    sw->left = 0;

    sw->pos = 0;

    sw->wpos = 0;

    sw->live = 0;

    sw->ratio = (sw->hw->freq * ((int64_t) INT_MAX)) / sw->freq;

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

    sw->conv = mixeng_conv[nchannels == 2][sign][bits == 16];

    pcm_sw_free_resources (sw);

    return pcm_sw_alloc_resources (sw);

}

/* Hard voice */

void pcm_hw_free_resources (HWVoice *hw)

{

    if (hw->mix_buf)

        qemu_free (hw->mix_buf);

    hw->mix_buf = NULL;

}

int pcm_hw_alloc_resources (HWVoice *hw)

{

    hw->mix_buf = qemu_mallocz (hw->samples * sizeof (st_sample_t));

    if (!hw->mix_buf)

        return -1;

    return 0;

}

void pcm_hw_fini (HWVoice *hw)

{

    if (hw->active) {

        ldebug ("pcm_hw_fini: %d %d %d\n", hw->freq, hw->nchannels, hw->fmt);

        pcm_hw_free_resources (hw);

        hw->pcm_ops->fini (hw);

        memset (hw, 0, audio_state.drv->voice_size);

    }

}

void pcm_hw_gc (HWVoice *hw)

{

    if (hw->nb_voices)

        return;

    pcm_hw_fini (hw);

}

int pcm_hw_get_live (HWVoice *hw)

{

    int i, alive = 0, live = hw->samples;

    for (i = 0; i < hw->nb_voices; i++) {

        if (hw->pvoice[i]->live) {

            live = audio_MIN (hw->pvoice[i]->live, live);

            alive += 1;

        }

    }

    if (alive)

        return live;

    else

        return -1;

}

int pcm_hw_get_live2 (HWVoice *hw, int *nb_active)

{

    int i, alive = 0, live = hw->samples;

    *nb_active = 0;

    for (i = 0; i < hw->nb_voices; i++) {

        if (hw->pvoice[i]->live) {

            if (hw->pvoice[i]->live < live) {

                *nb_active = hw->pvoice[i]->active != 0;

                live = hw->pvoice[i]->live;

            }

            alive += 1;

        }

    }

    if (alive)

        return live;

    else

        return -1;

}

void pcm_hw_dec_live (HWVoice *hw, int decr)

{

    int i;

    for (i = 0; i < hw->nb_voices; i++) {

        if (hw->pvoice[i]->live) {

            hw->pvoice[i]->live -= decr;

        }

    }

}

void pcm_hw_clear (HWVoice *hw, void *buf, int len)

{

    if (!len)

        return;

    switch (hw->fmt) {

    case AUD_FMT_S16:

    case AUD_FMT_S8:

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

        break;

    case AUD_FMT_U8:

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

        break;

    case AUD_FMT_U16:

        {

            unsigned int i;

            uint16_t *p = buf;

            int shift = hw->nchannels - 1;

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

                p[i] = INT16_MAX;

            }

        }

        break;

    }

}

int pcm_hw_write (SWVoice *sw, void *buf, int size)

{

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

    int ret = 0, pos = 0;

    if (!sw)

        return size;

    hwsamples = sw->hw->samples;

    samples = size >> sw->shift;

    if (!sw->live) {

        sw->wpos = sw->hw->rpos;

    }

    wpos = sw->wpos;

    live = sw->live;

    dead = hwsamples - live;

    swlim = (dead * ((int64_t) INT_MAX)) / sw->ratio;

    swlim = audio_MIN (swlim, samples);

    ldebug ("size=%d live=%d dead=%d swlim=%d wpos=%d\n",

           size, live, dead, swlim, wpos);

    if (swlim)

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

    while (swlim) {

        dead = hwsamples - live;

        left = hwsamples - wpos;

        blck = audio_MIN (dead, left);

        if (!blck) {

            /* dolog ("swlim=%d\n", swlim); */

            break;

        }

        isamp = swlim;

        osamp = blck;

        st_rate_flow (sw->rate, sw->buf + pos, sw->hw->mix_buf + wpos, &isamp, &osamp);

        ret += isamp;

        swlim -= isamp;

        pos += isamp;

        live += osamp;

        wpos = (wpos + osamp) % hwsamples;

    }

    sw->wpos = wpos;

    sw->live = live;

    return ret << sw->shift;

}

int pcm_hw_init (HWVoice *hw, int freq, int nchannels, audfmt_e fmt)

{

    int sign = 0, bits = 8;

    pcm_hw_fini (hw);

    ldebug ("pcm_hw_init: %d %d %d\n", freq, nchannels, fmt);

    if (hw->pcm_ops->init (hw, freq, nchannels, fmt)) {

        memset (hw, 0, audio_state.drv->voice_size);

        return -1;

    }

    switch (hw->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;

    }

    hw->nb_voices = 0;

    hw->active = 1;

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

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

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

    hw->samples = hw->bufsize >> hw->shift;

    hw->clip = mixeng_clip[hw->nchannels == 2][sign][bits == 16];

    if (pcm_hw_alloc_resources (hw)) {

        pcm_hw_fini (hw);

        return -1;

    }

    return 0;

}

static int dist (void *hw)

{

    if (hw) {

        return (((uint8_t *) hw - (uint8_t *) hw_voice)

                / audio_state.voice_size) + 1;

    }

    else {

        return 0;

    }

}

#define ADVANCE(hw) hw ? advance (hw, audio_state.voice_size) : hw_voice

HWVoice *pcm_hw_find_any (HWVoice *hw)

{

    int i = dist (hw);

    for (; i < audio_state.nb_hw_voices; i++) {

        hw = ADVANCE (hw);

        return hw;

    }

    return NULL;

}

HWVoice *pcm_hw_find_any_active (HWVoice *hw)

{

    int i = dist (hw);

    for (; i < audio_state.nb_hw_voices; i++) {

        hw = ADVANCE (hw);

        if (hw->active)

            return hw;

    }

    return NULL;

}

HWVoice *pcm_hw_find_any_active_enabled (HWVoice *hw)

{

    int i = dist (hw);

    for (; i < audio_state.nb_hw_voices; i++) {

        hw = ADVANCE (hw);

        if (hw->active && hw->enabled)

            return hw;

    }

    return NULL;

}

HWVoice *pcm_hw_find_any_passive (HWVoice *hw)

{

    int i = dist (hw);

    for (; i < audio_state.nb_hw_voices; i++) {

        hw = ADVANCE (hw);

        if (!hw->active)

            return hw;

    }

    return NULL;

}

HWVoice *pcm_hw_find_specific (HWVoice *hw, int freq,

                               int nchannels, audfmt_e fmt)

{

    while ((hw = pcm_hw_find_any_active (hw))) {

        if (hw->freq == freq &&

            hw->nchannels == nchannels &&

            hw->fmt == fmt)

            return hw;

    }

    return NULL;

}

HWVoice *pcm_hw_add (int freq, int nchannels, audfmt_e fmt)

{

    HWVoice *hw;

    if (audio_state.fixed_format) {

        freq = audio_state.fixed_freq;

        nchannels = audio_state.fixed_channels;

        fmt = audio_state.fixed_fmt;

    }

    hw = pcm_hw_find_specific (NULL, freq, nchannels, fmt);

    if (hw)

        return hw;

    hw = pcm_hw_find_any_passive (NULL);

    if (hw) {

        hw->pcm_ops = audio_state.drv->pcm_ops;

        if (!hw->pcm_ops)

            return NULL;

        if (pcm_hw_init (hw, freq, nchannels, fmt)) {

            pcm_hw_gc (hw);

            return NULL;

        }

        else

            return hw;

    }

    return pcm_hw_find_any (NULL);

}

int pcm_hw_add_sw (HWVoice *hw, SWVoice *sw)

{

    SWVoice **pvoice = qemu_mallocz ((hw->nb_voices + 1) * sizeof (sw));

    if (!pvoice)

        return -1;

    memcpy (pvoice, hw->pvoice, hw->nb_voices * sizeof (sw));

    qemu_free (hw->pvoice);

    hw->pvoice = pvoice;

    hw->pvoice[hw->nb_voices++] = sw;

    return 0;

}

int pcm_hw_del_sw (HWVoice *hw, SWVoice *sw)

{

    int i, j;

    if (hw->nb_voices > 1) {

        SWVoice **pvoice = qemu_mallocz ((hw->nb_voices - 1) * sizeof (sw));

        if (!pvoice) {

            dolog ("Can not maintain consistent state (not enough memory)\n");

            return -1;

        }

        for (i = 0, j = 0; i < hw->nb_voices; i++) {

            if (j >= hw->nb_voices - 1) {

                dolog ("Can not maintain consistent state "

                       "(invariant violated)\n");

                return -1;

            }

            if (hw->pvoice[i] != sw)

                pvoice[j++] = hw->pvoice[i];

        }

        qemu_free (hw->pvoice);

        hw->pvoice = pvoice;

        hw->nb_voices -= 1;

    }

    else {

        qemu_free (hw->pvoice);

        hw->pvoice = NULL;

        hw->nb_voices = 0;

    }

    return 0;

}

SWVoice *pcm_create_voice_pair (int freq, int nchannels, audfmt_e fmt)

{

    SWVoice *sw;

    HWVoice *hw;

    sw = qemu_mallocz (sizeof (*sw));

    if (!sw)

        goto err1;

    hw = pcm_hw_add (freq, nchannels, fmt);

    if (!hw)

        goto err2;

    if (pcm_hw_add_sw (hw, sw))

        goto err3;

    if (pcm_sw_init (sw, hw, freq, nchannels, fmt))

        goto err4;

    return sw;

err4:

    pcm_hw_del_sw (hw, sw);

err3:

    pcm_hw_gc (hw);

err2:

    qemu_free (sw);

err1:

    return NULL;

}

SWVoice *AUD_open (SWVoice *sw, const char *name,

                   int freq, int nchannels, audfmt_e fmt)

{

    if (!audio_state.drv) {

        return NULL;

    }

    if (sw && freq == sw->freq && sw->nchannels == nchannels && sw->fmt == fmt) {

        return sw;

    }

    if (sw) {

        ldebug ("Different format %s %d %d %d\n",

                name,

                sw->freq == freq,

                sw->nchannels == nchannels,

                sw->fmt == fmt);

    }

    if (nchannels != 1 && nchannels != 2) {

        dolog ("Bogus channel count %d for voice %s\n", nchannels, name);

        return NULL;

    }

    if (!audio_state.fixed_format && sw) {

        pcm_sw_fini (sw);

        pcm_hw_del_sw (sw->hw, sw);

        pcm_hw_gc (sw->hw);

        if (sw->name) {

            qemu_free (sw->name);

            sw->name = NULL;

        }

        qemu_free (sw);

        sw = NULL;

    }

    if (sw) {

        HWVoice *hw = sw->hw;

        if (!hw) {

            dolog ("Internal logic error voice %s has no hardware store\n",

                   name);

            return sw;

        }

        if (pcm_sw_init (sw, hw, freq, nchannels, fmt)) {

            pcm_sw_fini (sw);

            pcm_hw_del_sw (hw, sw);

            pcm_hw_gc (hw);

            if (sw->name) {

                qemu_free (sw->name);

                sw->name = NULL;

            }

            qemu_free (sw);

            return NULL;

        }

    }

    else {

        sw = pcm_create_voice_pair (freq, nchannels, fmt);

        if (!sw) {

            dolog ("Failed to create voice %s\n", name);

            return NULL;

        }

    }

    if (sw->name) {

        qemu_free (sw->name);

        sw->name = NULL;

    }

    sw->name = qemu_strdup (name);

    return sw;

}

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

{

    int bytes;

    if (!sw->hw->enabled)

        dolog ("Writing to disabled voice %s\n", sw->name);

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

    return bytes;

}

void AUD_run (void)

{

    HWVoice *hw = NULL;

    while ((hw = pcm_hw_find_any_active_enabled (hw))) {

        int i;

        if (hw->pending_disable && pcm_hw_get_live (hw) <= 0) {

            hw->enabled = 0;

            hw->pcm_ops->ctl (hw, VOICE_DISABLE);

            for (i = 0; i < hw->nb_voices; i++) {

                hw->pvoice[i]->live = 0;

                /* hw->pvoice[i]->old_ticks = 0; */

            }

            continue;

        }

        hw->pcm_ops->run (hw);

        assert (hw->rpos < hw->samples);

        for (i = 0; i < hw->nb_voices; i++) {

            SWVoice *sw = hw->pvoice[i];

            if (!sw->active && !sw->live && sw->old_ticks) {

                int64_t delta = qemu_get_clock (vm_clock) - sw->old_ticks;

                if (delta > audio_state.ticks_threshold) {

                    ldebug ("resetting old_ticks for %s\n", sw->name);

                    sw->old_ticks = 0;

                }

            }

        }

    }

}

int AUD_get_free (SWVoice *sw)

{

    int free;

    if (!sw)

        return 4096;

    free = ((sw->hw->samples - sw->live) << sw->hw->shift) * sw->ratio

        / INT_MAX;

    free &= ~sw->hw->align;

    if (!free) return 0;

    return free;

}

int AUD_get_buffer_size (SWVoice *sw)

{

    return sw->hw->bufsize;

}

void AUD_adjust (SWVoice *sw, int bytes)

{

    if (!sw)

        return;

    sw->old_ticks += (ticks_per_sec * (int64_t) bytes) / sw->bytes_per_second;

}

void AUD_reset (SWVoice *sw)

{

    sw->active = 0;

    sw->old_ticks = 0;

}

int AUD_calc_elapsed (SWVoice *sw)

{

    int64_t now, delta, bytes;

    int dead, swlim;

    if (!sw)

        return 0;

    now = qemu_get_clock (vm_clock);

    delta = now - sw->old_ticks;

    bytes = (delta * sw->bytes_per_second) / ticks_per_sec;

    if (delta < 0) {

        dolog ("whoops delta(<0)=%lld\n", delta);

        return 0;

    }

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

    swlim = ((dead * (int64_t) INT_MAX) / sw->ratio);

    if (bytes > swlim) {

        return swlim;

    }

    else {

        return bytes;

    }

}

void AUD_enable (SWVoice *sw, int on)

{

    int i;

    HWVoice *hw;

    if (!sw)

        return;

    hw = sw->hw;

    if (on) {

        if (!sw->live)

            sw->wpos = sw->hw->rpos;

        if (!sw->old_ticks) {

            sw->old_ticks = qemu_get_clock (vm_clock);

        }

    }

    if (sw->active != on) {

        if (on) {

            hw->pending_disable = 0;

            if (!hw->enabled) {

                hw->enabled = 1;

                for (i = 0; i < hw->nb_voices; i++) {

                    ldebug ("resetting voice\n");

                    sw = hw->pvoice[i];

                    sw->old_ticks = qemu_get_clock (vm_clock);

                }

                hw->pcm_ops->ctl (hw, VOICE_ENABLE);

            }

        }

        else {

            if (hw->enabled && !hw->pending_disable) {

                int nb_active = 0;

                for (i = 0; i < hw->nb_voices; i++) {

                    nb_active += hw->pvoice[i]->active != 0;

                }

                if (nb_active == 1) {

                    hw->pending_disable = 1;

                }

            }

        }

        sw->active = on;

    }

}

static struct audio_output_driver *drvtab[] = {

#ifdef USE_OSS_AUDIO

    &oss_output_driver,

#endif

#ifdef USE_FMOD_AUDIO

    &fmod_output_driver,

#endif

#ifdef USE_SDL_AUDIO

    &sdl_output_driver,

#endif

#ifdef USE_WAV_AUDIO

    &wav_output_driver,

#endif

};

static int voice_init (struct audio_output_driver *drv)

{

    audio_state.opaque = drv->init ();

    if (audio_state.opaque) {

        if (audio_state.nb_hw_voices > drv->max_voices) {

            dolog ("`%s' does not support %d multiple hardware channels\n"

                   "Resetting to %d\n",

                   drv->name, audio_state.nb_hw_voices, drv->max_voices);

            audio_state.nb_hw_voices = drv->max_voices;

        }

        hw_voice = qemu_mallocz (audio_state.nb_hw_voices * drv->voice_size);

        if (hw_voice) {

            audio_state.drv = drv;

            return 1;

        }

        else {

            dolog ("Not enough memory for %d `%s' voices (each %d bytes)\n",

                   audio_state.nb_hw_voices, drv->name, drv->voice_size);

            drv->fini (audio_state.opaque);

            return 0;

        }

    }

    else {

        dolog ("Could not init `%s' audio\n", drv->name);

        return 0;

    }

}

static void audio_vm_stop_handler (void *opaque, int reason)

{

    HWVoice *hw = NULL;

    while ((hw = pcm_hw_find_any (hw))) {

        if (!hw->pcm_ops)

            continue;

        hw->pcm_ops->ctl (hw, reason ? VOICE_ENABLE : VOICE_DISABLE);

    }

}

static void audio_atexit (void)

{

    HWVoice *hw = NULL;

    while ((hw = pcm_hw_find_any (hw))) {

        if (!hw->pcm_ops)

            continue;

        hw->pcm_ops->ctl (hw, VOICE_DISABLE);

        hw->pcm_ops->fini (hw);

    }

    audio_state.drv->fini (audio_state.opaque);

}

static void audio_save (QEMUFile *f, void *opaque)

{

}

static int audio_load (QEMUFile *f, void *opaque, int version_id)

{

    if (version_id != 1)

        return -EINVAL;

    return 0;

}

void AUD_init (void)

{

    int i;

    int done = 0;

    const char *drvname;

    audio_state.fixed_format =

        !!audio_get_conf_int (QC_FIXED_FORMAT, audio_state.fixed_format);

    audio_state.fixed_freq =

        audio_get_conf_int (QC_FIXED_FREQ, audio_state.fixed_freq);

    audio_state.nb_hw_voices =

        audio_get_conf_int (QC_VOICES, audio_state.nb_hw_voices);

    if (audio_state.nb_hw_voices <= 0) {

        dolog ("Bogus number of voices %d, resetting to 1\n",

               audio_state.nb_hw_voices);

    }

    drvname = audio_get_conf_str (QC_AUDIO_DRV, NULL);

    if (drvname) {

        int found = 0;

        for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {

            if (!strcmp (drvname, drvtab[i]->name)) {

                done = voice_init (drvtab[i]);

                found = 1;

                break;

            }

        }

        if (!found) {

            dolog ("Unknown audio driver `%s'\n", drvname);

        }

    }

    qemu_add_vm_stop_handler (audio_vm_stop_handler, NULL);

    atexit (audio_atexit);

    if (!done) {

        for (i = 0; !done && i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {

            if (drvtab[i]->can_be_default)

                done = voice_init (drvtab[i]);

        }

    }

    audio_state.ticks_threshold = ticks_per_sec / 50;

    audio_state.freq_threshold = 100;

    register_savevm ("audio", 0, 1, audio_save, audio_load, NULL);

    if (!done) {

        dolog ("Can not initialize audio subsystem\n");

        return;

    }

    for (i = 0; hw_ctors[i]; i++) {

        hw_ctors[i] ();

    }

}

/*

 * QEMU Audio subsystem header

 * 

 * Copyright (c) 2003-2004 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.

 */

#ifndef QEMU_AUDIO_H

#define QEMU_AUDIO_H

#include "mixeng.h"

#define dolog(...) fprintf (stderr, AUDIO_CAP ": " __VA_ARGS__)

#ifdef DEBUG

#define ldebug(...) dolog (__VA_ARGS__)

#else

#define ldebug(...)

#endif

typedef enum {

  AUD_FMT_U8,

  AUD_FMT_S8,

  AUD_FMT_U16,

  AUD_FMT_S16

} audfmt_e;

typedef struct HWVoice HWVoice;

struct audio_output_driver;

typedef struct AudioState {

    int fixed_format;

    int fixed_freq;

    int fixed_channels;

    int fixed_fmt;

    int nb_hw_voices;

    int voice_size;

    int64_t ticks_threshold;

    int freq_threshold;

    void *opaque;

    struct audio_output_driver *drv;

} AudioState;

extern AudioState audio_state;

typedef struct SWVoice {

    int freq;

    audfmt_e fmt;

    int nchannels;

    int shift;

    int align;

    t_sample *conv;

    int left;

    int pos;

    int bytes_per_second;

    int64_t ratio;

    st_sample_t *buf;

    void *rate;

    int wpos;

    int live;

    int active;

    int64_t old_ticks;

    HWVoice *hw;

    char *name;

} SWVoice;

#define VOICE_ENABLE 1

#define VOICE_DISABLE 2

struct pcm_ops {

    int  (*init)  (HWVoice *hw, int freq, int nchannels, audfmt_e fmt);

    void (*fini)  (HWVoice *hw);

    void (*run)   (HWVoice *hw);

    int  (*write) (SWVoice *sw, void *buf, int size);

    int  (*ctl)   (HWVoice *hw, int cmd, ...);

};

struct audio_output_driver {

    const char *name;

    void *(*init) (void);

    void (*fini) (void *);

    struct pcm_ops *pcm_ops;

    int can_be_default;

    int max_voices;

    int voice_size;

};

struct HWVoice {

    int active;

    int enabled;

    int pending_disable;

    int valid;

    int freq;

    f_sample *clip;

    audfmt_e fmt;

    int nchannels;

    int align;

    int shift;

    int rpos;

    int bufsize;

    int bytes_per_second;

    st_sample_t *mix_buf;

    int samples;

    int64_t old_ticks;

    int nb_voices;

    struct SWVoice **pvoice;

    struct pcm_ops *pcm_ops;

};

void      audio_log (const char *fmt, ...);

void      pcm_sw_free_resources (SWVoice *sw);

int       pcm_sw_alloc_resources (SWVoice *sw);

void      pcm_sw_fini (SWVoice *sw);

int       pcm_sw_init (SWVoice *sw, HWVoice *hw, int freq,

                       int nchannels, audfmt_e fmt);

void      pcm_hw_clear (HWVoice *hw, void *buf, int len);

HWVoice * pcm_hw_find_any (HWVoice *hw);

HWVoice * pcm_hw_find_any_active (HWVoice *hw);

HWVoice * pcm_hw_find_any_passive (HWVoice *hw);

HWVoice * pcm_hw_find_specific (HWVoice *hw, int freq,

                                int nchannels, audfmt_e fmt);

HWVoice * pcm_hw_add (int freq, int nchannels, audfmt_e fmt);

int       pcm_hw_add_sw (HWVoice *hw, SWVoice *sw);

int       pcm_hw_del_sw (HWVoice *hw, SWVoice *sw);

SWVoice * pcm_create_voice_pair (int freq, int nchannels, audfmt_e fmt);

void      pcm_hw_free_resources (HWVoice *hw);

int       pcm_hw_alloc_resources (HWVoice *hw);

void      pcm_hw_fini (HWVoice *hw);

void      pcm_hw_gc (HWVoice *hw);

int       pcm_hw_get_live (HWVoice *hw);

int       pcm_hw_get_live2 (HWVoice *hw, int *nb_active);

void      pcm_hw_dec_live (HWVoice *hw, int decr);

int       pcm_hw_write (SWVoice *sw, void *buf, int len);

int         audio_get_conf_int (const char *key, int defval);

const char *audio_get_conf_str (const char *key, const char *defval);

/* Public API */

SWVoice * AUD_open (SWVoice *sw, const char *name, int freq,

                    int nchannels, audfmt_e fmt);

int    AUD_write (SWVoice *sw, void *pcm_buf, int size);

void   AUD_adjust (SWVoice *sw, int leftover);

void   AUD_reset (SWVoice *sw);

int    AUD_get_free (SWVoice *sw);

int    AUD_get_buffer_size (SWVoice *sw);

void   AUD_run (void);

void   AUD_enable (SWVoice *sw, int on);

int    AUD_calc_elapsed (SWVoice *sw);

static inline void *advance (void *p, int incr)

{

    uint8_t *d = p;

    return (d + incr);

}

uint32_t popcount (uint32_t u);

inline uint32_t lsbindex (uint32_t u);

#define audio_MIN(a, b) ((a)>(b)?(b):(a))

#define audio_MAX(a, b) ((a)<(b)?(b):(a))

#endif  /* audio.h */

/*

 * QEMU FMOD audio output driver

 * 

 * Copyright (c) 2004 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 <fmod.h>

#include <fmod_errors.h>

#include "vl.h"

#define AUDIO_CAP "fmod"

#include "audio/audio.h"

#include "audio/fmodaudio.h"

#define QC_FMOD_DRV "QEMU_FMOD_DRV"

#define QC_FMOD_FREQ "QEMU_FMOD_FREQ"

#define QC_FMOD_SAMPLES "QEMU_FMOD_SAMPLES"

#define QC_FMOD_CHANNELS "QEMU_FMOD_CHANNELS"

#define QC_FMOD_BUFSIZE "QEMU_FMOD_BUFSIZE"

#define QC_FMOD_THRESHOLD "QEMU_FMOD_THRESHOLD"

static struct {

    int nb_samples;

    int freq;

    int nb_channels;

    int bufsize;

    int threshold;

} conf = {

    2048,

    44100,

    1,

    0,

    128

};

#define errstr() FMOD_ErrorString (FSOUND_GetError ())

static int fmod_hw_write (SWVoice *sw, void *buf, int len)

{

    return pcm_hw_write (sw, buf, len);

}

static void fmod_clear_sample (FMODVoice *fmd)

{

    HWVoice *hw = &fmd->hw;

    int status;

    void *p1 = 0, *p2 = 0;

    unsigned int len1 = 0, len2 = 0;

    status = FSOUND_Sample_Lock (

        fmd->fmod_sample,

        0,

        hw->samples << hw->shift,

        &p1,

        &p2,

        &len1,

        &len2

        );

    if (!status) {

        dolog ("Failed to lock sample\nReason: %s\n", errstr ());

        return;

    }

    if ((len1 & hw->align) || (len2 & hw->align)) {

        dolog ("Locking sample returned unaligned length %d, %d\n",

               len1, len2);

        goto fail;

    }

    if (len1 + len2 != hw->samples << hw->shift) {

        dolog ("Locking sample returned incomplete length %d, %d\n",

               len1 + len2, hw->samples << hw->shift);

        goto fail;

    }

    pcm_hw_clear (hw, p1, hw->samples);

 fail:

    status = FSOUND_Sample_Unlock (fmd->fmod_sample, p1, p2, len1, len2);

    if (!status) {

        dolog ("Failed to unlock sample\nReason: %s\n", errstr ());

    }

}

static int fmod_write_sample (HWVoice *hw, uint8_t *dst, st_sample_t *src,

                              int src_size, int src_pos, int dst_len)

{

    int src_len1 = dst_len, src_len2 = 0, pos = src_pos + dst_len;

    st_sample_t *src1 = src + src_pos, *src2 = 0;

    if (src_pos + dst_len > src_size) {

        src_len1 = src_size - src_pos;

        src2 = src;

        src_len2 = dst_len - src_len1;

        pos = src_len2;

    }

    if (src_len1) {

        hw->clip (dst, src1, src_len1);

        memset (src1, 0, src_len1 * sizeof (st_sample_t));

        advance (dst, src_len1);

    }

    if (src_len2) {

        hw->clip (dst, src2, src_len2);

        memset (src2, 0, src_len2 * sizeof (st_sample_t));

    }

    return pos;

}

static int fmod_unlock_sample (FMODVoice *fmd, void *p1, void *p2,

                               unsigned int blen1, unsigned int blen2)

{

    int status = FSOUND_Sample_Unlock (fmd->fmod_sample, p1, p2, blen1, blen2);

    if (!status) {

        dolog ("Failed to unlock sample\nReason: %s\n", errstr ());

        return -1;

    }

    return 0;

}

static int fmod_lock_sample (FMODVoice *fmd, int pos, int len,

                             void **p1, void **p2,

                             unsigned int *blen1, unsigned int *blen2)

{

    HWVoice *hw = &fmd->hw;

    int status;

    status = FSOUND_Sample_Lock (

        fmd->fmod_sample,

        pos << hw->shift,

        len << hw->shift,

        p1,

        p2,

        blen1,

        blen2

        );

    if (!status) {

        dolog ("Failed to lock sample\nReason: %s\n", errstr ());

        return -1;

    }

    if ((*blen1 & hw->align) || (*blen2 & hw->align)) {

        dolog ("Locking sample returned unaligned length %d, %d\n",

               *blen1, *blen2);

        fmod_unlock_sample (fmd, *p1, *p2, *blen1, *blen2);

        return -1;

    }

    return 0;

}

static void fmod_hw_run (HWVoice *hw)

{

    FMODVoice *fmd = (FMODVoice *) hw;

    int rpos, live, decr;

    void *p1 = 0, *p2 = 0;

    unsigned int blen1 = 0, blen2 = 0;

    unsigned int len1 = 0, len2 = 0;

    int nb_active;

    live = pcm_hw_get_live2 (hw, &nb_active);

    if (live <= 0) {

        return;

    }

    if (!hw->pending_disable

        && nb_active

        && conf.threshold

        && live <= conf.threshold) {

        ldebug ("live=%d nb_active=%d\n", live, nb_active);

        return;

    }

    decr = live;

#if 1

    if (fmd->channel >= 0) {

        int pos2 = (fmd->old_pos + decr) % hw->samples;

        int pos = FSOUND_GetCurrentPosition (fmd->channel);

        if (fmd->old_pos < pos && pos2 >= pos) {

            decr = pos - fmd->old_pos - (pos2 == pos) - 1;

        }

        else if (fmd->old_pos > pos && pos2 >= pos && pos2 < fmd->old_pos) {

            decr = (hw->samples - fmd->old_pos) + pos - (pos2 == pos) - 1;

        }

/*         ldebug ("pos=%d pos2=%d old=%d live=%d decr=%d\n", */

/*                 pos, pos2, fmd->old_pos, live, decr); */

    }

#endif

    if (decr <= 0) {

        return;

    }

    if (fmod_lock_sample (fmd, fmd->old_pos, decr, &p1, &p2, &blen1, &blen2)) {

        return;

    }

    len1 = blen1 >> hw->shift;

    len2 = blen2 >> hw->shift;

    ldebug ("%p %p %d %d %d %d\n", p1, p2, len1, len2, blen1, blen2);

    decr = len1 + len2;

    rpos = hw->rpos;

    if (len1) {

        rpos = fmod_write_sample (hw, p1, hw->mix_buf, hw->samples, rpos, len1);

    }

    if (len2) {

        rpos = fmod_write_sample (hw, p2, hw->mix_buf, hw->samples, rpos, len2);

    }

    fmod_unlock_sample (fmd, p1, p2, blen1, blen2);

    pcm_hw_dec_live (hw, decr);

    hw->rpos = rpos % hw->samples;

    fmd->old_pos = (fmd->old_pos + decr) % hw->samples;

}

static int AUD_to_fmodfmt (audfmt_e fmt, int stereo)

{

    int mode = FSOUND_LOOP_NORMAL;

    switch (fmt) {

    case AUD_FMT_S8:

        mode |= FSOUND_SIGNED | FSOUND_8BITS;

        break;

    case AUD_FMT_U8:

        mode |= FSOUND_UNSIGNED | FSOUND_8BITS;

        break;

    case AUD_FMT_S16:

        mode |= FSOUND_SIGNED | FSOUND_16BITS;

        break;

    case AUD_FMT_U16:

        mode |= FSOUND_UNSIGNED | FSOUND_16BITS;

        break;

    default:

        dolog ("Internal logic error: Bad audio format %d\nAborting\n", fmt);

        exit (EXIT_FAILURE);

    }

    mode |= stereo ? FSOUND_STEREO : FSOUND_MONO;

    return mode;

}

static void fmod_hw_fini (HWVoice *hw)

{

    FMODVoice *fmd = (FMODVoice *) hw;

    if (fmd->fmod_sample) {

        FSOUND_Sample_Free (fmd->fmod_sample);

        fmd->fmod_sample = 0;

        if (fmd->channel >= 0) {

            FSOUND_StopSound (fmd->channel);

        }

    }

}

static int fmod_hw_init (HWVoice *hw, int freq, int nchannels, audfmt_e fmt)