Archipelago » qemu

    int rpos, live, decr;

    int samples;

    uint8_t *dst;

    snd_pcm_sframes_t avail;

    live = audio_pcm_hw_get_live_out (hw);

    }

}

{

    ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;

    struct alsa_params_req req;

    struct alsa_params_obt obt;

    snd_pcm_t *handle;

    req.fmt = aud_to_alsafmt (as->fmt);

    req.freq = as->freq;

    return -1;

}

{

    ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;

    struct alsa_params_req req;

    struct alsa_params_obt obt;

    snd_pcm_t *handle;

    req.fmt = aud_to_alsafmt (as->fmt);

    req.freq = as->freq;

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

        void *src;

        snd_pcm_sframes_t nread;

        snd_pcm_uframes_t len;

    int enabled;

    int nb_voices;

    int greedy;

};

static struct {

static AudioState glob_audio_state;

    0,

#ifdef FLOAT_MIXENG

    1.0,

    }

}

{

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

    AUD_log (NULL, "\n");

}

{

    int invalid;

    return invalid ? -1 : 0;

}

{

    int bits = 8, sign = 0;

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

}

{

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

/*

 * Capture

 */

{

    (void) src;

    (void) dst;

static CaptureVoiceOut *audio_pcm_capture_find_specific (

    AudioState *s,

    )

{

    CaptureVoiceOut *cap;

{

    HWVoiceIn *hw = sw->hw;

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

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

        while (live) {

            int left = hw->samples - rpos;

            int to_capture = audio_MIN (live, left);

            struct capture_callback *cb;

            src = hw->mix_buf + rpos;

CaptureVoiceOut *AUD_add_capture (

    AudioState *s,

    struct audio_capture_ops *ops,

    void *cb_opaque

    )

        /* XXX find a more elegant way */

        hw->samples = 4096 * 4;

        hw->mix_buf = audio_calloc (AUDIO_FUNC, hw->samples,

        if (!hw->mix_buf) {

            dolog ("Could not allocate capture mix buffer (%d samples)\n",

                   hw->samples);

#define AUDIO_HOST_ENDIANNESS 0

#endif

    int freq;

    int nchannels;

    audfmt_e fmt;

    int endianness;

typedef enum {

    AUD_CNOTIFY_ENABLE,

void AUD_remove_card (QEMUSoundCard *card);

CaptureVoiceOut *AUD_add_capture (

    AudioState *s,

    struct audio_capture_ops *ops,

    void *opaque

    );

    const char *name,

    void *callback_opaque,

    audio_callback_fn_t callback_fn,

    );

void AUD_close_out (QEMUSoundCard *card, SWVoiceOut *sw);

    const char *name,

    void *callback_opaque,

    audio_callback_fn_t callback_fn,

    );

void AUD_close_in (QEMUSoundCard *card, SWVoiceIn *sw);

    int rpos;

    uint64_t ts_helper;

    int samples;

    LIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head;

    int total_samples_captured;

    uint64_t ts_helper;

    int samples;

    LIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head;

    struct audio_pcm_info info;

    t_sample *conv;

    int64_t ratio;

    void *rate;

    int total_hw_samples_mixed;

    int active;

    int empty;

    HWVoiceOut *hw;

    char *name;

    struct audio_callback callback;

    LIST_ENTRY (SWVoiceOut) entries;

};

    int64_t ratio;

    void *rate;

    int total_hw_samples_acquired;

    f_sample *clip;

    HWVoiceIn *hw;

    char *name;

    struct audio_callback callback;

    LIST_ENTRY (SWVoiceIn) entries;

};

};

struct audio_pcm_ops {

    void (*fini_out)(HWVoiceOut *hw);

    int  (*run_out) (HWVoiceOut *hw);

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

    int  (*ctl_out) (HWVoiceOut *hw, int cmd, ...);

    void (*fini_in) (HWVoiceIn *hw);

    int  (*run_in)  (HWVoiceIn *hw);

    int  (*read)    (SWVoiceIn *sw, void *buf, int size);

extern struct audio_driver dsound_audio_driver;

extern struct audio_driver esd_audio_driver;

extern struct audio_driver pa_audio_driver;

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

int  audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int len);

static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw)

{

    if (!HWBUF) {

        dolog ("Could not allocate " NAME " buffer (%d samples)\n",

               hw->samples);

    samples = ((int64_t) sw->hw->samples << 32) / sw->ratio;

#endif

    if (!sw->buf) {

        dolog ("Could not allocate buffer for `%s' (%d samples)\n",

               SW_NAME (sw), samples);

    SW *sw,

    HW *hw,

    const char *name,

    )

{

    int err;

static HW *glue (audio_pcm_hw_find_specific_, TYPE) (

    AudioState *s,

    HW *hw,

    )

{

    while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {

    return NULL;

}

{

    HW *hw;

    struct audio_driver *drv = s->drv;

    return NULL;

}

{

    HW *hw;

static SW *glue (audio_pcm_create_voice_pair_, TYPE) (

    AudioState *s,

    const char *sw_name,

    )

{

    SW *sw;

    HW *hw;

    if (glue (conf.fixed_, TYPE).enabled) {

        hw_as = glue (conf.fixed_, TYPE).settings;

    const char *name,

    void *callback_opaque ,

    audio_callback_fn_t callback_fn,

    )

{

    AudioState *s;

    HWVoiceOut *hw = hwptr;

    coreaudioVoiceOut *core = (coreaudioVoiceOut *) hwptr;

    int rpos, live;

#ifndef FLOAT_MIXENG

#ifdef RECIPROCAL

    const float scale = 1.f / UINT_MAX;

    return audio_pcm_sw_write (sw, buf, len);

}

{

    OSStatus status;

    coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;

}

#ifdef DSBTYPE_IN

#else

#endif

{

    int err;

    HRESULT hr;

    dsound *s = &glob_dsound;

    WAVEFORMATEX wfx;

#ifdef DSBTYPE_IN

    const char *typ = "ADC";

    DSoundVoiceIn *ds = (DSoundVoiceIn *) hw;

    int set_primary;

    int bufsize_in;

    int bufsize_out;

    int latency_millis;

} conf = {

    1,

    LPDIRECTSOUND dsound;

    LPDIRECTSOUNDCAPTURE dsound_capture;

    LPDIRECTSOUNDBUFFER dsound_primary_buffer;

} dsound;

static dsound glob_dsound;

    return -1;

}

{

    memset (wfx, 0, sizeof (*wfx));

    return 0;

}

{

    if (wfx->wFormatTag != WAVE_FORMAT_PCM) {

        dolog ("Invalid wave format, tag is not PCM, but %d\n",

    int src_len1 = dst_len;

    int src_len2 = 0;

    int pos = hw->rpos + dst_len;

    if (pos > hw->samples) {

        src_len1 = hw->samples - hw->rpos;

        while (to_mix) {

            ssize_t written;

            int chunk = audio_MIN (to_mix, hw->samples - rpos);

            hw->clip (esd->pcm_buf, src, chunk);

    return audio_pcm_sw_write (sw, buf, len);

}

{

    ESDVoiceOut *esd = (ESDVoiceOut *) hw;

    int esdfmt = ESD_STREAM | ESD_PLAY;

    int err;

    sigset_t set, old_set;

    return audio_pcm_sw_read (sw, buf, len);

}

{

    ESDVoiceIn *esd = (ESDVoiceIn *) hw;

    int esdfmt = ESD_STREAM | ESD_RECORD;

    int err;

    sigset_t set, old_set;

    int src_len1 = dst_len;

    int src_len2 = 0;

    int pos = hw->rpos + dst_len;

    if (pos > hw->samples) {

        src_len1 = hw->samples - hw->rpos;

    }

}

{

    int bits16, mode, channel;

    FMODVoiceOut *fmd = (FMODVoiceOut *) hw;

    mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0);

    fmd->fmod_sample = FSOUND_Sample_Alloc (

    return 0;

}

{

    int bits16, mode;

    FMODVoiceIn *fmd = (FMODVoiceIn *) hw;

    if (conf.broken_adc) {

        return -1;

    uint64_t opos;

    uint64_t opos_inc;

    uint32_t ipos;              /* position in the input stream (integer) */

};

/*

    qemu_free (opaque);

}

{

}

#define QEMU_MIXENG_H

#ifdef FLOAT_MIXENG

#else

#endif

extern t_sample *mixeng_conv[2][2][2][3];

extern f_sample *mixeng_clip[2][2][2][3];

void *st_rate_start (int inrate, int outrate);

                   int *isamp, int *osamp);

                       int *isamp, int *osamp);

void st_rate_stop (void *opaque);

#endif  /* mixeng.h */

#define ET glue (ENDIAN_CONVERSION, glue (_, IN_T))

#ifdef FLOAT_MIXENG

{

    IN_T nv = ENDIAN_CONVERT (v);

#ifdef RECIPROCAL

#ifdef SIGNED

#else

#endif

#else  /* !RECIPROCAL */

#ifdef SIGNED

#else

#endif

#endif

}

{

    if (v >= 0.5) {

        return IN_MAX;

#endif

static void glue (glue (conv_, ET), _to_stereo)

{

    IN_T *in = (IN_T *) src;

#ifdef CONFIG_MIXEMU

    if (vol->mute) {

}

static void glue (glue (conv_, ET), _to_mono)

{

    IN_T *in = (IN_T *) src;

#ifdef CONFIG_MIXEMU

    if (vol->mute) {

}

static void glue (glue (clip_, ET), _from_stereo)

{

    IN_T *out = (IN_T *) dst;

    while (samples--) {

        *out++ = glue (clip_, ET) (in->l);

}

static void glue (glue (clip_, ET), _from_mono)

{

    IN_T *out = (IN_T *) dst;

    while (samples--) {

        *out++ = glue (clip_, ET) (in->l + in->r);

    return audio_pcm_sw_write (sw, buf, len);

}

{

    audio_pcm_init_info (&hw->info, as);

    hw->samples = 1024;

    return 0;

}

{

    audio_pcm_init_info (&hw->info, as);

    hw->samples = 1024;

    int err, rpos, live, decr;

    int samples;

    uint8_t *dst;

    struct audio_buf_info abinfo;

    struct count_info cntinfo;

    int bufsize;

    }

}

{

    OSSVoiceOut *oss = (OSSVoiceOut *) hw;

    struct oss_params req, obt;

    int err;

    int fd;

    audfmt_e effective_fmt;

    oss->fd = -1;

    return 0;

}

{

    OSSVoiceIn *oss = (OSSVoiceIn *) hw;

    struct oss_params req, obt;

    int err;

    int fd;

    audfmt_e effective_fmt;

    oss->fd = -1;

        while (to_mix) {

            int error;

            int chunk = audio_MIN (to_mix, hw->samples - rpos);

            hw->clip (pa->pcm_buf, src, chunk);

    }

}

{

    int error;

    static pa_sample_spec ss;

    PAVoiceOut *pa = (PAVoiceOut *) hw;

    ss.format = audfmt_to_pa (as->fmt, as->endianness);

    return -1;

}

{

    int error;

    static pa_sample_spec ss;

    PAVoiceIn *pa = (PAVoiceIn *) hw;

    ss.format = audfmt_to_pa (as->fmt, as->endianness);

 * Processed signed long samples from ibuf to obuf.

 * Return number of samples processed.

 */

           int *isamp, int *osamp)

{

    struct rate *rate = opaque;

#ifdef FLOAT_MIXENG

#else

    int64_t t;

#endif

#ifdef RECIPROCAL

        t = (rate->opos & UINT_MAX) * (1.f / UINT_MAX);

#else

#endif

        out.l = (ilast.l * (1.0 - t)) + icur.l * t;

        out.r = (ilast.r * (1.0 - t)) + icur.r * t;

        decr = to_mix;

        while (to_mix) {

            int chunk = audio_MIN (to_mix, hw->samples - hw->rpos);

            /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */

            hw->clip (buf, src, chunk);

    sdl_close (&glob_sdl);

}

{

    SDLVoiceOut *sdl = (SDLVoiceOut *) hw;

    SDLAudioState *s = &glob_sdl;

    int endianess;

    int err;

    audfmt_e effective_fmt;

    shift <<= as->nchannels == 2;

} WAVVoiceOut;

static struct {

    const char *wav_path;

} conf = {

    {

    WAVVoiceOut *wav = (WAVVoiceOut *) hw;

    int rpos, live, decr, samples;

    uint8_t *dst;

    int64_t now = qemu_get_clock (vm_clock);

    int64_t ticks = now - wav->old_ticks;

    int64_t bytes = (ticks * hw->info.bytes_per_second) / ticks_per_sec;

    }

}

{

    WAVVoiceOut *wav = (WAVVoiceOut *) hw;

    int bits16 = 0, stereo = 0;

        0x02, 0x00, 0x44, 0xac, 0x00, 0x00, 0x10, 0xb1, 0x02, 0x00, 0x04,

        0x00, 0x10, 0x00, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x00

    };

    (void) as;

        0x02, 0x00, 0x44, 0xac, 0x00, 0x00, 0x10, 0xb1, 0x02, 0x00, 0x04,

        0x00, 0x10, 0x00, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x00

    };

    struct audio_capture_ops ops;

    int stereo, bits16, shift;

    CaptureVoiceOut *cap;

static void open_voice (AC97LinkState *s, int index, int freq)

{

    as.freq = freq;

    as.nchannels = 2;

int Adlib_init (AudioState *audio, qemu_irq *pic)

{

    AdlibState *s = &glob_adlib;

    if (!audio) {

        dolog ("No audio state\n");

static void cs_reset_voices (CSState *s, uint32_t val)

{

    int xtal;

#ifdef DEBUG_XLAW

    if (val == 0 || val == 32)

                    (new_fmt & 2) ? AUD_FMT_S16 : AUD_FMT_U8,

                    d->shift);

            if (new_freq) {

                as.freq = new_freq;

                as.nchannels = 1 << (new_fmt & 1);

int GUS_init (AudioState *audio, qemu_irq *pic)

{

    GUSState *s;

    if (!audio) {

        dolog ("No audio state\n");

static void omap_eac_format_update(struct omap_eac_s *s)

{

    /* The hardware buffers at most one sample */

    if (s->codec.rxlen)

int pcspk_audio_init(AudioState *audio, qemu_irq *pic)

{

    PCSpkState *s = &pcspk_state;

    if (!audio) {

        AUD_log(s_spk, "No audio state\n");

static void continue_dma8 (SB16State *s)

{

    if (s->freq > 0) {

        s->audio_free = 0;

    }

    if (s->freq) {

        s->audio_free = 0;

static void legacy_reset (SB16State *s)

{

    s->freq = 11025;

    s->fmt_signed = 0;

    if (s->dma_running) {

        if (s->freq) {

            s->audio_free = 0;

static void tsc2102_audio_output_update(struct tsc210x_state_s *s)

{

    int enable;

    if (s->dac_voice[0]) {

        tsc210x_out_flush(s, s->codec.out.len);

static void wm8750_set_format(struct wm8750_s *s)

{

    int i;

    wm8750_out_flush(s);

    int client_blue_shift, client_blue_max, server_blue_shift, server_blue_max;

    CaptureVoiceOut *audio_cap;

    VncReadEvent *read_handler;

    size_t read_handler_expect;