[qemu.git] / audio / audio_template.h

/*
 * QEMU Audio subsystem header
 *
 * Copyright (c) 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.
 */

#ifdef DAC
#define NAME "playback"
#define HWBUF hw->mix_buf
#define TYPE out
#define HW HWVoiceOut
#define SW SWVoiceOut
#else
#define NAME "capture"
#define TYPE in
#define HW HWVoiceIn
#define SW SWVoiceIn
#define HWBUF hw->conv_buf
#endif

static void glue (audio_init_nb_voices_, TYPE) (
    AudioState *s,
    struct audio_driver *drv
    )
{
    int max_voices = glue (drv->max_voices_, TYPE);
    int voice_size = glue (drv->voice_size_, TYPE);

    if (glue (s->nb_hw_voices_, TYPE) > max_voices) {
        if (!max_voices) {
#ifdef DAC
            dolog ("Driver `%s' does not support " NAME "\n", drv->name);
#endif
        }
        else {
            dolog ("Driver `%s' does not support %d " NAME " voices, max %d\n",
                   drv->name,
                   glue (s->nb_hw_voices_, TYPE),
                   max_voices);
        }
        glue (s->nb_hw_voices_, TYPE) = max_voices;
    }

    if (audio_bug (AUDIO_FUNC, !voice_size && max_voices)) {
        dolog ("drv=`%s' voice_size=0 max_voices=%d\n",
               drv->name, max_voices);
        glue (s->nb_hw_voices_, TYPE) = 0;
    }

    if (audio_bug (AUDIO_FUNC, voice_size && !max_voices)) {
        dolog ("drv=`%s' voice_size=%d max_voices=0\n",
               drv->name, voice_size);
    }
}

static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw)
{
    if (HWBUF) {
        qemu_free (HWBUF);
    }

    HWBUF = NULL;
}

static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw)
{
    HWBUF = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (st_sample_t));
    if (!HWBUF) {
        dolog ("Could not allocate " NAME " buffer (%d samples)\n",
               hw->samples);
        return -1;
    }

    return 0;
}

static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw)
{
    if (sw->buf) {
        qemu_free (sw->buf);
    }

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

    sw->buf = NULL;
    sw->rate = NULL;
}

static int glue (audio_pcm_sw_alloc_resources_, TYPE) (SW *sw)
{
    int samples;

#ifdef DAC
    samples = sw->hw->samples;
#else
    samples = ((int64_t) sw->hw->samples << 32) / sw->ratio;
#endif

    sw->buf = audio_calloc (AUDIO_FUNC, samples, sizeof (st_sample_t));
    if (!sw->buf) {
        dolog ("Could not allocate buffer for `%s' (%d samples)\n",
               SW_NAME (sw), samples);
        return -1;
    }

#ifdef DAC
    sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq);
#else
    sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq);
#endif
    if (!sw->rate) {
        qemu_free (sw->buf);
        sw->buf = NULL;
        return -1;
    }
    return 0;
}

static int glue (audio_pcm_sw_init_, TYPE) (
    SW *sw,
    HW *hw,
    const char *name,
    audsettings_t *as,
    int endian
    )
{
    int err;

    audio_pcm_init_info (&sw->info, as, audio_need_to_swap_endian (endian));
    sw->hw = hw;
    sw->active = 0;
#ifdef DAC
    sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq;
    sw->total_hw_samples_mixed = 0;
    sw->empty = 1;
#else
    sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq;
#endif

#ifdef DAC
    sw->conv = mixeng_conv
#else
    sw->clip = mixeng_clip
#endif
        [sw->info.nchannels == 2]
        [sw->info.sign]
        [sw->info.swap_endian]
        [sw->info.bits == 16];

    sw->name = qemu_strdup (name);
    err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw);
    if (err) {
        qemu_free (sw->name);
        sw->name = NULL;
    }
    return err;
}

static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw)
{
    glue (audio_pcm_sw_free_resources_, TYPE) (sw);
    if (sw->name) {
        qemu_free (sw->name);
        sw->name = NULL;
    }
}

static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw)
{
    LIST_INSERT_HEAD (&hw->sw_head, sw, entries);
}

static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw)
{
    LIST_REMOVE (sw, entries);
}

static void glue (audio_pcm_hw_gc_, TYPE) (AudioState *s, HW **hwp)
{
    HW *hw = *hwp;

    if (!hw->sw_head.lh_first) {
#ifdef DAC
        audio_detach_capture (hw);
#endif
        LIST_REMOVE (hw, entries);
        glue (s->nb_hw_voices_, TYPE) += 1;
        glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);
        glue (hw->pcm_ops->fini_, TYPE) (hw);
        qemu_free (hw);
        *hwp = NULL;
    }
}

static HW *glue (audio_pcm_hw_find_any_, TYPE) (AudioState *s, HW *hw)
{
    return hw ? hw->entries.le_next : s->glue (hw_head_, TYPE).lh_first;
}

static HW *glue (audio_pcm_hw_find_any_enabled_, TYPE) (AudioState *s, HW *hw)
{
    while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
        if (hw->enabled) {
            return hw;
        }
    }
    return NULL;
}

static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
    AudioState *s,
    HW *hw,
    audsettings_t *as
    )
{
    while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
        if (audio_pcm_info_eq (&hw->info, as)) {
            return hw;
        }
    }
    return NULL;
}

static HW *glue (audio_pcm_hw_add_new_, TYPE) (AudioState *s, audsettings_t *as)
{
    HW *hw;
    struct audio_driver *drv = s->drv;

    if (!glue (s->nb_hw_voices_, TYPE)) {
        return NULL;
    }

    if (audio_bug (AUDIO_FUNC, !drv)) {
        dolog ("No host audio driver\n");
        return NULL;
    }

    if (audio_bug (AUDIO_FUNC, !drv->pcm_ops)) {
        dolog ("Host audio driver without pcm_ops\n");
        return NULL;
    }

    hw = audio_calloc (AUDIO_FUNC, 1, glue (drv->voice_size_, TYPE));
    if (!hw) {
        dolog ("Can not allocate voice `%s' size %d\n",
               drv->name, glue (drv->voice_size_, TYPE));
        return NULL;
    }

    hw->pcm_ops = drv->pcm_ops;
    LIST_INIT (&hw->sw_head);
#ifdef DAC
    LIST_INIT (&hw->sw_cap_head);
#endif
    if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
        goto err0;
    }

    if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) {
        dolog ("hw->samples=%d\n", hw->samples);
        goto err1;
    }

#ifdef DAC
    hw->clip = mixeng_clip
#else
    hw->conv = mixeng_conv
#endif
        [hw->info.nchannels == 2]
        [hw->info.sign]
        [hw->info.swap_endian]
        [hw->info.bits == 16];

    if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
        goto err1;
    }

    LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
    glue (s->nb_hw_voices_, TYPE) -= 1;
#ifdef DAC
    audio_attach_capture (s, hw);
#endif
    return hw;

 err1:
    glue (hw->pcm_ops->fini_, TYPE) (hw);
 err0:
    qemu_free (hw);
    return NULL;
}

static HW *glue (audio_pcm_hw_add_, TYPE) (AudioState *s, audsettings_t *as)
{
    HW *hw;

    if (glue (conf.fixed_, TYPE).enabled && glue (conf.fixed_, TYPE).greedy) {
        hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
        if (hw) {
            return hw;
        }
    }

    hw = glue (audio_pcm_hw_find_specific_, TYPE) (s, NULL, as);
    if (hw) {
        return hw;
    }

    hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
    if (hw) {
        return hw;
    }

    return glue (audio_pcm_hw_find_any_, TYPE) (s, NULL);
}

static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
    AudioState *s,
    const char *sw_name,
    audsettings_t *as,
    int sw_endian
    )
{
    SW *sw;
    HW *hw;
    audsettings_t hw_as;

    if (glue (conf.fixed_, TYPE).enabled) {
        hw_as = glue (conf.fixed_, TYPE).settings;
    }
    else {
        hw_as = *as;
    }

    sw = audio_calloc (AUDIO_FUNC, 1, sizeof (*sw));
    if (!sw) {
        dolog ("Could not allocate soft voice `%s' (%zu bytes)\n",
               sw_name ? sw_name : "unknown", sizeof (*sw));
        goto err1;
    }

    hw = glue (audio_pcm_hw_add_, TYPE) (s, &hw_as);
    if (!hw) {
        goto err2;
    }

    glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw);

    if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as, sw_endian)) {
        goto err3;
    }

    return sw;

err3:
    glue (audio_pcm_hw_del_sw_, TYPE) (sw);
    glue (audio_pcm_hw_gc_, TYPE) (s, &hw);
err2:
    qemu_free (sw);
err1:
    return NULL;
}

static void glue (audio_close_, TYPE) (AudioState *s, SW *sw)
{
    glue (audio_pcm_sw_fini_, TYPE) (sw);
    glue (audio_pcm_hw_del_sw_, TYPE) (sw);
    glue (audio_pcm_hw_gc_, TYPE) (s, &sw->hw);
    qemu_free (sw);
}

void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw)
{
    if (sw) {
        if (audio_bug (AUDIO_FUNC, !card || !card->audio)) {
            dolog ("card=%p card->audio=%p\n",
                   card, card ? card->audio : NULL);
            return;
        }

        glue (audio_close_, TYPE) (card->audio, sw);
    }
}

SW *glue (AUD_open_, TYPE) (
    QEMUSoundCard *card,
    SW *sw,
    const char *name,
    void *callback_opaque ,
    audio_callback_fn_t callback_fn,
    audsettings_t *as,
    int sw_endian
    )
{
    AudioState *s;
#ifdef DAC
    int live = 0;
    SW *old_sw = NULL;
#endif

    ldebug ("open %s, freq %d, nchannels %d, fmt %d\n",
            name, as->freq, as->nchannels, as->fmt);

    if (audio_bug (AUDIO_FUNC,
                   !card || !card->audio || !name || !callback_fn || !as)) {
        dolog ("card=%p card->audio=%p name=%p callback_fn=%p as=%p\n",
               card, card ? card->audio : NULL, name, callback_fn, as);
        goto fail;
    }

    s = card->audio;

    if (audio_bug (AUDIO_FUNC, audio_validate_settigs (as))) {
        audio_print_settings (as);
        goto fail;
    }

    if (audio_bug (AUDIO_FUNC, !s->drv)) {
        dolog ("Can not open `%s' (no host audio driver)\n", name);
        goto fail;
    }

    if (sw && audio_pcm_info_eq (&sw->info, as)) {
        return sw;
    }

#ifdef DAC
    if (conf.plive && sw && (!sw->active && !sw->empty)) {
        live = sw->total_hw_samples_mixed;

#ifdef DEBUG_PLIVE
        dolog ("Replacing voice %s with %d live samples\n", SW_NAME (sw), live);
        dolog ("Old %s freq %d, bits %d, channels %d\n",
               SW_NAME (sw), sw->info.freq, sw->info.bits, sw->info.nchannels);
        dolog ("New %s freq %d, bits %d, channels %d\n",
               name,
               freq,
               (fmt == AUD_FMT_S16 || fmt == AUD_FMT_U16) ? 16 : 8,
               nchannels);
#endif

        if (live) {
            old_sw = sw;
            old_sw->callback.fn = NULL;
            sw = NULL;
        }
    }
#endif

    if (!glue (conf.fixed_, TYPE).enabled && sw) {
        glue (AUD_close_, TYPE) (card, sw);
        sw = NULL;
    }

    if (sw) {
        HW *hw = sw->hw;

        if (!hw) {
            dolog ("Internal logic error voice `%s' has no hardware store\n",
                   SW_NAME (sw));
            goto fail;
        }

        glue (audio_pcm_sw_fini_, TYPE) (sw);
        if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as, sw_endian)) {
            goto fail;
        }
    }
    else {
        sw = glue (audio_pcm_create_voice_pair_, TYPE) (s, name, as, sw_endian);
        if (!sw) {
            dolog ("Failed to create voice `%s'\n", name);
            return NULL;
        }
    }

    if (sw) {
        sw->vol = nominal_volume;
        sw->callback.fn = callback_fn;
        sw->callback.opaque = callback_opaque;

#ifdef DAC
        if (live) {
            int mixed =
                (live << old_sw->info.shift)
                * old_sw->info.bytes_per_second
                / sw->info.bytes_per_second;

#ifdef DEBUG_PLIVE
            dolog ("Silence will be mixed %d\n", mixed);
#endif
            sw->total_hw_samples_mixed += mixed;
        }
#endif

#ifdef DEBUG_AUDIO
        dolog ("%s\n", name);
        audio_pcm_print_info ("hw", &sw->hw->info);
        audio_pcm_print_info ("sw", &sw->info);
#endif
    }

    return sw;

 fail:
    glue (AUD_close_, TYPE) (card, sw);
    return NULL;
}

int glue (AUD_is_active_, TYPE) (SW *sw)
{
    return sw ? sw->active : 0;
}

void glue (AUD_init_time_stamp_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts)
{
    if (!sw) {
        return;
    }

    ts->old_ts = sw->hw->ts_helper;
}

uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW *sw, QEMUAudioTimeStamp *ts)
{
    uint64_t delta, cur_ts, old_ts;

    if (!sw) {
        return 0;
    }

    cur_ts = sw->hw->ts_helper;
    old_ts = ts->old_ts;
    /* dolog ("cur %lld old %lld\n", cur_ts, old_ts); */

    if (cur_ts >= old_ts) {
        delta = cur_ts - old_ts;
    }
    else {
        delta = UINT64_MAX - old_ts + cur_ts;
    }

    if (!delta) {
        return 0;
    }

    return (delta * sw->hw->info.freq) / 1000000;
}

#undef TYPE
#undef HW
#undef SW
#undef HWBUF
#undef NAME
Commit	Line	Data
1d14ffa9 FB	1	/*
	2	* QEMU Audio subsystem header
	3	*
	4	* Copyright (c) 2005 Vassili Karpov (malc)
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
	25	#ifdef DAC
571ec3d6 FB	26	#define NAME "playback"
571ec3d6 FB	27	#define HWBUF hw->mix_buf
1d14ffa9	28	#define TYPE out
571ec3d6 FB	29	#define HW HWVoiceOut
571ec3d6 FB	30	#define SW SWVoiceOut
1d14ffa9	31	#else
571ec3d6	32	#define NAME "capture"
1d14ffa9	33	#define TYPE in
571ec3d6 FB	34	#define HW HWVoiceIn
	35	#define SW SWVoiceIn
	36	#define HWBUF hw->conv_buf
1d14ffa9 FB	37	#endif
1d14ffa9 FB	38
571ec3d6 FB	39	static void glue (audio_init_nb_voices_, TYPE) (
	40	AudioState *s,
	41	struct audio_driver *drv
c0fe3827 FB	42	)
c0fe3827 FB	43	{
571ec3d6 FB	44	int max_voices = glue (drv->max_voices_, TYPE);
571ec3d6 FB	45	int voice_size = glue (drv->voice_size_, TYPE);
c0fe3827	46
571ec3d6 FB	47	if (glue (s->nb_hw_voices_, TYPE) > max_voices) {
	48	if (!max_voices) {
	49	#ifdef DAC
	50	dolog ("Driver `%s' does not support " NAME "\n", drv->name);
	51	#endif
	52	}
	53	else {
	54	dolog ("Driver `%s' does not support %d " NAME " voices, max %d\n",
	55	drv->name,
	56	glue (s->nb_hw_voices_, TYPE),
	57	max_voices);
	58	}
	59	glue (s->nb_hw_voices_, TYPE) = max_voices;
c0fe3827 FB	60	}
c0fe3827 FB	61
571ec3d6 FB	62	if (audio_bug (AUDIO_FUNC, !voice_size && max_voices)) {
	63	dolog ("drv=`%s' voice_size=0 max_voices=%d\n",
	64	drv->name, max_voices);
	65	glue (s->nb_hw_voices_, TYPE) = 0;
	66	}
	67
	68	if (audio_bug (AUDIO_FUNC, voice_size && !max_voices)) {
	69	dolog ("drv=`%s' voice_size=%d max_voices=0\n",
	70	drv->name, voice_size);
	71	}
	72	}
	73
	74	static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw)
	75	{
	76	if (HWBUF) {
	77	qemu_free (HWBUF);
	78	}
	79
	80	HWBUF = NULL;
	81	}
	82
	83	static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw)
	84	{
	85	HWBUF = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (st_sample_t));
	86	if (!HWBUF) {
	87	dolog ("Could not allocate " NAME " buffer (%d samples)\n",
	88	hw->samples);
c0fe3827 FB	89	return -1;
	90	}
	91
571ec3d6 FB	92	return 0;
	93	}
	94
	95	static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw)
	96	{
	97	if (sw->buf) {
	98	qemu_free (sw->buf);
	99	}
	100
	101	if (sw->rate) {
	102	st_rate_stop (sw->rate);
	103	}
	104
	105	sw->buf = NULL;
	106	sw->rate = NULL;
	107	}
	108
	109	static int glue (audio_pcm_sw_alloc_resources_, TYPE) (SW *sw)
	110	{
	111	int samples;
	112
c0fe3827	113	#ifdef DAC
571ec3d6	114	samples = sw->hw->samples;
c0fe3827	115	#else
571ec3d6	116	samples = ((int64_t) sw->hw->samples << 32) / sw->ratio;
c0fe3827	117	#endif
c0fe3827	118
571ec3d6 FB	119	sw->buf = audio_calloc (AUDIO_FUNC, samples, sizeof (st_sample_t));
	120	if (!sw->buf) {
	121	dolog ("Could not allocate buffer for `%s' (%d samples)\n",
	122	SW_NAME (sw), samples);
c0fe3827 FB	123	return -1;
	124	}
	125
571ec3d6 FB	126	#ifdef DAC
	127	sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq);
	128	#else
	129	sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq);
	130	#endif
	131	if (!sw->rate) {
	132	qemu_free (sw->buf);
	133	sw->buf = NULL;
	134	return -1;
	135	}
c0fe3827 FB	136	return 0;
	137	}
	138
571ec3d6 FB	139	static int glue (audio_pcm_sw_init_, TYPE) (
	140	SW *sw,
	141	HW *hw,
	142	const char *name,
	143	audsettings_t *as,
	144	int endian
	145	)
	146	{
	147	int err;
	148
	149	audio_pcm_init_info (&sw->info, as, audio_need_to_swap_endian (endian));
	150	sw->hw = hw;
	151	sw->active = 0;
	152	#ifdef DAC
	153	sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq;
	154	sw->total_hw_samples_mixed = 0;
	155	sw->empty = 1;
	156	#else
	157	sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq;
	158	#endif
	159
	160	#ifdef DAC
	161	sw->conv = mixeng_conv
	162	#else
	163	sw->clip = mixeng_clip
	164	#endif
	165	[sw->info.nchannels == 2]
	166	[sw->info.sign]
	167	[sw->info.swap_endian]
	168	[sw->info.bits == 16];
	169
	170	sw->name = qemu_strdup (name);
	171	err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw);
	172	if (err) {
	173	qemu_free (sw->name);
	174	sw->name = NULL;
	175	}
	176	return err;
	177	}
	178
1d14ffa9 FB	179	static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw)
	180	{
	181	glue (audio_pcm_sw_free_resources_, TYPE) (sw);
	182	if (sw->name) {
	183	qemu_free (sw->name);
	184	sw->name = NULL;
	185	}
	186	}
	187
	188	static void glue (audio_pcm_hw_add_sw_, TYPE) (HW hw, SW sw)
	189	{
	190	LIST_INSERT_HEAD (&hw->sw_head, sw, entries);
	191	}
	192
	193	static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw)
	194	{
	195	LIST_REMOVE (sw, entries);
	196	}
	197
c0fe3827	198	static void glue (audio_pcm_hw_gc_, TYPE) (AudioState s, HW *hwp)
1d14ffa9	199	{
c0fe3827	200	HW hw = hwp;
1d14ffa9	201
1d14ffa9	202	if (!hw->sw_head.lh_first) {
8ead62cf FB	203	#ifdef DAC
	204	audio_detach_capture (hw);
	205	#endif
c0fe3827 FB	206	LIST_REMOVE (hw, entries);
	207	glue (s->nb_hw_voices_, TYPE) += 1;
	208	glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);
	209	glue (hw->pcm_ops->fini_, TYPE) (hw);
	210	qemu_free (hw);
	211	*hwp = NULL;
1d14ffa9 FB	212	}
	213	}
	214
c0fe3827	215	static HW glue (audio_pcm_hw_find_any_, TYPE) (AudioState s, HW *hw)
1d14ffa9	216	{
c0fe3827	217	return hw ? hw->entries.le_next : s->glue (hw_head_, TYPE).lh_first;
1d14ffa9 FB	218	}
1d14ffa9 FB	219
c0fe3827	220	static HW glue (audio_pcm_hw_find_any_enabled_, TYPE) (AudioState s, HW *hw)
1d14ffa9	221	{
c0fe3827 FB	222	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
c0fe3827 FB	223	if (hw->enabled) {
1d14ffa9 FB	224	return hw;
	225	}
	226	}
	227	return NULL;
	228	}
	229
1d14ffa9	230	static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
c0fe3827	231	AudioState *s,
1d14ffa9	232	HW *hw,
c0fe3827	233	audsettings_t *as
1d14ffa9 FB	234	)
1d14ffa9 FB	235	{
c0fe3827 FB	236	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
c0fe3827 FB	237	if (audio_pcm_info_eq (&hw->info, as)) {
1d14ffa9 FB	238	return hw;
	239	}
	240	}
	241	return NULL;
	242	}
	243
c0fe3827	244	static HW glue (audio_pcm_hw_add_new_, TYPE) (AudioState s, audsettings_t *as)
1d14ffa9 FB	245	{
1d14ffa9 FB	246	HW *hw;
571ec3d6	247	struct audio_driver *drv = s->drv;
1d14ffa9	248
571ec3d6 FB	249	if (!glue (s->nb_hw_voices_, TYPE)) {
	250	return NULL;
	251	}
1d14ffa9	252
571ec3d6 FB	253	if (audio_bug (AUDIO_FUNC, !drv)) {
	254	dolog ("No host audio driver\n");
	255	return NULL;
1d14ffa9 FB	256	}
1d14ffa9 FB	257
571ec3d6 FB	258	if (audio_bug (AUDIO_FUNC, !drv->pcm_ops)) {
	259	dolog ("Host audio driver without pcm_ops\n");
	260	return NULL;
	261	}
	262
	263	hw = audio_calloc (AUDIO_FUNC, 1, glue (drv->voice_size_, TYPE));
	264	if (!hw) {
	265	dolog ("Can not allocate voice `%s' size %d\n",
	266	drv->name, glue (drv->voice_size_, TYPE));
	267	return NULL;
	268	}
	269
	270	hw->pcm_ops = drv->pcm_ops;
	271	LIST_INIT (&hw->sw_head);
8ead62cf FB	272	#ifdef DAC
	273	LIST_INIT (&hw->sw_cap_head);
	274	#endif
571ec3d6 FB	275	if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
	276	goto err0;
	277	}
	278
	279	if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) {
	280	dolog ("hw->samples=%d\n", hw->samples);
	281	goto err1;
	282	}
	283
	284	#ifdef DAC
	285	hw->clip = mixeng_clip
	286	#else
	287	hw->conv = mixeng_conv
	288	#endif
	289	[hw->info.nchannels == 2]
	290	[hw->info.sign]
	291	[hw->info.swap_endian]
	292	[hw->info.bits == 16];
	293
	294	if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
	295	goto err1;
	296	}
	297
	298	LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
	299	glue (s->nb_hw_voices_, TYPE) -= 1;
8ead62cf FB	300	#ifdef DAC
	301	audio_attach_capture (s, hw);
	302	#endif
571ec3d6 FB	303	return hw;
	304
	305	err1:
	306	glue (hw->pcm_ops->fini_, TYPE) (hw);
	307	err0:
	308	qemu_free (hw);
1d14ffa9 FB	309	return NULL;
	310	}
	311
c0fe3827	312	static HW glue (audio_pcm_hw_add_, TYPE) (AudioState s, audsettings_t *as)
1d14ffa9 FB	313	{
	314	HW *hw;
	315
c0fe3827 FB	316	if (glue (conf.fixed_, TYPE).enabled && glue (conf.fixed_, TYPE).greedy) {
c0fe3827 FB	317	hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
1d14ffa9 FB	318	if (hw) {
	319	return hw;
	320	}
	321	}
	322
c0fe3827	323	hw = glue (audio_pcm_hw_find_specific_, TYPE) (s, NULL, as);
1d14ffa9 FB	324	if (hw) {
	325	return hw;
	326	}
	327
c0fe3827	328	hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
1d14ffa9 FB	329	if (hw) {
	330	return hw;
	331	}
	332
c0fe3827	333	return glue (audio_pcm_hw_find_any_, TYPE) (s, NULL);
1d14ffa9 FB	334	}
	335
	336	static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
c0fe3827 FB	337	AudioState *s,
c0fe3827 FB	338	const char *sw_name,
571ec3d6 FB	339	audsettings_t *as,
571ec3d6 FB	340	int sw_endian
1d14ffa9 FB	341	)
	342	{
	343	SW *sw;
	344	HW *hw;
c0fe3827	345	audsettings_t hw_as;
1d14ffa9	346
c0fe3827 FB	347	if (glue (conf.fixed_, TYPE).enabled) {
	348	hw_as = glue (conf.fixed_, TYPE).settings;
	349	}
	350	else {
	351	hw_as = *as;
1d14ffa9 FB	352	}
1d14ffa9 FB	353
c0fe3827	354	sw = audio_calloc (AUDIO_FUNC, 1, sizeof (*sw));
1d14ffa9	355	if (!sw) {
e7cad338	356	dolog ("Could not allocate soft voice `%s' (%zu bytes)\n",
c0fe3827	357	sw_name ? sw_name : "unknown", sizeof (*sw));
1d14ffa9 FB	358	goto err1;
	359	}
	360
c0fe3827	361	hw = glue (audio_pcm_hw_add_, TYPE) (s, &hw_as);
1d14ffa9 FB	362	if (!hw) {
	363	goto err2;
	364	}
	365
	366	glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw);
	367
571ec3d6	368	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as, sw_endian)) {
1d14ffa9 FB	369	goto err3;
	370	}
	371
	372	return sw;
	373
	374	err3:
	375	glue (audio_pcm_hw_del_sw_, TYPE) (sw);
c0fe3827	376	glue (audio_pcm_hw_gc_, TYPE) (s, &hw);
1d14ffa9 FB	377	err2:
	378	qemu_free (sw);
	379	err1:
	380	return NULL;
	381	}
	382
c0fe3827 FB	383	static void glue (audio_close_, TYPE) (AudioState s, SW sw)
	384	{
	385	glue (audio_pcm_sw_fini_, TYPE) (sw);
	386	glue (audio_pcm_hw_del_sw_, TYPE) (sw);
	387	glue (audio_pcm_hw_gc_, TYPE) (s, &sw->hw);
	388	qemu_free (sw);
	389	}
571ec3d6	390
c0fe3827	391	void glue (AUD_close_, TYPE) (QEMUSoundCard card, SW sw)
1d14ffa9 FB	392	{
1d14ffa9 FB	393	if (sw) {
c0fe3827 FB	394	if (audio_bug (AUDIO_FUNC, !card \|\| !card->audio)) {
	395	dolog ("card=%p card->audio=%p\n",
	396	card, card ? card->audio : NULL);
	397	return;
	398	}
	399
	400	glue (audio_close_, TYPE) (card->audio, sw);
1d14ffa9 FB	401	}
	402	}
	403
	404	SW *glue (AUD_open_, TYPE) (
c0fe3827	405	QEMUSoundCard *card,
1d14ffa9 FB	406	SW *sw,
	407	const char *name,
	408	void *callback_opaque ,
	409	audio_callback_fn_t callback_fn,
571ec3d6 FB	410	audsettings_t *as,
571ec3d6 FB	411	int sw_endian
1d14ffa9 FB	412	)
1d14ffa9 FB	413	{
c0fe3827	414	AudioState *s;
1d14ffa9 FB	415	#ifdef DAC
	416	int live = 0;
	417	SW *old_sw = NULL;
	418	#endif
	419
c0fe3827 FB	420	ldebug ("open %s, freq %d, nchannels %d, fmt %d\n",
	421	name, as->freq, as->nchannels, as->fmt);
	422
	423	if (audio_bug (AUDIO_FUNC,
	424	!card \|\| !card->audio \|\| !name \|\| !callback_fn \|\| !as)) {
	425	dolog ("card=%p card->audio=%p name=%p callback_fn=%p as=%p\n",
	426	card, card ? card->audio : NULL, name, callback_fn, as);
1d14ffa9 FB	427	goto fail;
	428	}
	429
c0fe3827 FB	430	s = card->audio;
	431
	432	if (audio_bug (AUDIO_FUNC, audio_validate_settigs (as))) {
	433	audio_print_settings (as);
1d14ffa9 FB	434	goto fail;
	435	}
	436
c0fe3827 FB	437	if (audio_bug (AUDIO_FUNC, !s->drv)) {
c0fe3827 FB	438	dolog ("Can not open `%s' (no host audio driver)\n", name);
1d14ffa9 FB	439	goto fail;
	440	}
	441
c0fe3827	442	if (sw && audio_pcm_info_eq (&sw->info, as)) {
1d14ffa9 FB	443	return sw;
	444	}
	445
	446	#ifdef DAC
c0fe3827	447	if (conf.plive && sw && (!sw->active && !sw->empty)) {
1d14ffa9 FB	448	live = sw->total_hw_samples_mixed;
	449
	450	#ifdef DEBUG_PLIVE
c0fe3827	451	dolog ("Replacing voice %s with %d live samples\n", SW_NAME (sw), live);
1d14ffa9	452	dolog ("Old %s freq %d, bits %d, channels %d\n",
c0fe3827	453	SW_NAME (sw), sw->info.freq, sw->info.bits, sw->info.nchannels);
1d14ffa9	454	dolog ("New %s freq %d, bits %d, channels %d\n",
c0fe3827 FB	455	name,
	456	freq,
	457	(fmt == AUD_FMT_S16 \|\| fmt == AUD_FMT_U16) ? 16 : 8,
1d14ffa9 FB	458	nchannels);
	459	#endif
	460
	461	if (live) {
	462	old_sw = sw;
	463	old_sw->callback.fn = NULL;
	464	sw = NULL;
	465	}
	466	}
	467	#endif
	468
c0fe3827 FB	469	if (!glue (conf.fixed_, TYPE).enabled && sw) {
c0fe3827 FB	470	glue (AUD_close_, TYPE) (card, sw);
1d14ffa9 FB	471	sw = NULL;
	472	}
	473
	474	if (sw) {
	475	HW *hw = sw->hw;
	476
	477	if (!hw) {
c0fe3827 FB	478	dolog ("Internal logic error voice `%s' has no hardware store\n",
c0fe3827 FB	479	SW_NAME (sw));
1d14ffa9 FB	480	goto fail;
	481	}
	482
571ec3d6 FB	483	glue (audio_pcm_sw_fini_, TYPE) (sw);
571ec3d6 FB	484	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as, sw_endian)) {
1d14ffa9 FB	485	goto fail;
	486	}
	487	}
	488	else {
571ec3d6	489	sw = glue (audio_pcm_create_voice_pair_, TYPE) (s, name, as, sw_endian);
1d14ffa9	490	if (!sw) {
c0fe3827	491	dolog ("Failed to create voice `%s'\n", name);
571ec3d6	492	return NULL;
1d14ffa9 FB	493	}
	494	}
	495
	496	if (sw) {
	497	sw->vol = nominal_volume;
	498	sw->callback.fn = callback_fn;
	499	sw->callback.opaque = callback_opaque;
	500
	501	#ifdef DAC
	502	if (live) {
	503	int mixed =
	504	(live << old_sw->info.shift)
	505	* old_sw->info.bytes_per_second
	506	/ sw->info.bytes_per_second;
	507
	508	#ifdef DEBUG_PLIVE
	509	dolog ("Silence will be mixed %d\n", mixed);
	510	#endif
	511	sw->total_hw_samples_mixed += mixed;
	512	}
	513	#endif
	514
	515	#ifdef DEBUG_AUDIO
	516	dolog ("%s\n", name);
	517	audio_pcm_print_info ("hw", &sw->hw->info);
	518	audio_pcm_print_info ("sw", &sw->info);
	519	#endif
	520	}
	521
	522	return sw;
	523
	524	fail:
c0fe3827	525	glue (AUD_close_, TYPE) (card, sw);
1d14ffa9 FB	526	return NULL;
	527	}
	528
	529	int glue (AUD_is_active_, TYPE) (SW *sw)
	530	{
	531	return sw ? sw->active : 0;
	532	}
	533
	534	void glue (AUD_init_time_stamp_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
	535	{
	536	if (!sw) {
	537	return;
	538	}
	539
	540	ts->old_ts = sw->hw->ts_helper;
	541	}
	542
c0fe3827	543	uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
1d14ffa9 FB	544	{
	545	uint64_t delta, cur_ts, old_ts;
	546
	547	if (!sw) {
	548	return 0;
	549	}
	550
	551	cur_ts = sw->hw->ts_helper;
	552	old_ts = ts->old_ts;
8ead62cf	553	/* dolog ("cur %lld old %lld\n", cur_ts, old_ts); */
1d14ffa9 FB	554
	555	if (cur_ts >= old_ts) {
	556	delta = cur_ts - old_ts;
	557	}
	558	else {
	559	delta = UINT64_MAX - old_ts + cur_ts;
	560	}
	561
	562	if (!delta) {
	563	return 0;
	564	}
	565
	566	return (delta * sw->hw->info.freq) / 1000000;
	567	}
	568
	569	#undef TYPE
	570	#undef HW
	571	#undef SW
571ec3d6 FB	572	#undef HWBUF
571ec3d6 FB	573	#undef NAME