[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) (struct audio_driver *drv)
{
    AudioState *s = &glob_audio_state;
    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 (struct st_sample));
    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 (struct st_sample));
    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,
    struct audsettings *as
    )
{
    int err;

    audio_pcm_init_info (&sw->info, as);
    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_endianness]
        [audio_bits_to_index (sw->info.bits)];

    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) (HW **hwp)
{
    AudioState *s = &glob_audio_state;
    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) (HW *hw)
{
    AudioState *s = &glob_audio_state;
    return hw ? hw->entries.le_next : glue (s->hw_head_, TYPE).lh_first;
}

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

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

static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as)
{
    HW *hw;
    AudioState *s = &glob_audio_state;
    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->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_endianness]
        [audio_bits_to_index (hw->info.bits)];

    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 (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) (struct audsettings *as)
{
    HW *hw;

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

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

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

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

static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
    const char *sw_name,
    struct audsettings *as
    )
{
    SW *sw;
    HW *hw;
    struct audsettings 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) (&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)) {
        goto err3;
    }

    return sw;

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

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

void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw)
{
    if (sw) {
        if (audio_bug (AUDIO_FUNC, !card)) {
            dolog ("card=%p\n", card);
            return;
        }

        glue (audio_close_, TYPE) (sw);
    }
}

SW *glue (AUD_open_, TYPE) (
    QEMUSoundCard *card,
    SW *sw,
    const char *name,
    void *callback_opaque ,
    audio_callback_fn_t callback_fn,
    struct audsettings *as
    )
{
    AudioState *s = &glob_audio_state;
#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 || !name || !callback_fn || !as)) {
        dolog ("card=%p name=%p callback_fn=%p as=%p\n",
               card, name, callback_fn, as);
        goto fail;
    }

    if (audio_bug (AUDIO_FUNC, audio_validate_settings (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)) {
            goto fail;
        }
    }
    else {
        sw = glue (audio_pcm_create_voice_pair_, TYPE) (name, as);
        if (!sw) {
            dolog ("Failed to create voice `%s'\n", name);
            return NULL;
        }
    }

    if (sw) {
        sw->card = card;
        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
1a7dafce	39	static void glue (audio_init_nb_voices_, TYPE) (struct audio_driver *drv)
c0fe3827	40	{
1a7dafce	41	AudioState *s = &glob_audio_state;
571ec3d6 FB	42	int max_voices = glue (drv->max_voices_, TYPE);
571ec3d6 FB	43	int voice_size = glue (drv->voice_size_, TYPE);
c0fe3827	44
571ec3d6 FB	45	if (glue (s->nb_hw_voices_, TYPE) > max_voices) {
	46	if (!max_voices) {
	47	#ifdef DAC
	48	dolog ("Driver `%s' does not support " NAME "\n", drv->name);
	49	#endif
	50	}
	51	else {
	52	dolog ("Driver `%s' does not support %d " NAME " voices, max %d\n",
	53	drv->name,
	54	glue (s->nb_hw_voices_, TYPE),
	55	max_voices);
	56	}
	57	glue (s->nb_hw_voices_, TYPE) = max_voices;
c0fe3827 FB	58	}
c0fe3827 FB	59
571ec3d6 FB	60	if (audio_bug (AUDIO_FUNC, !voice_size && max_voices)) {
	61	dolog ("drv=`%s' voice_size=0 max_voices=%d\n",
	62	drv->name, max_voices);
	63	glue (s->nb_hw_voices_, TYPE) = 0;
	64	}
	65
	66	if (audio_bug (AUDIO_FUNC, voice_size && !max_voices)) {
	67	dolog ("drv=`%s' voice_size=%d max_voices=0\n",
	68	drv->name, voice_size);
	69	}
	70	}
	71
	72	static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw)
	73	{
	74	if (HWBUF) {
	75	qemu_free (HWBUF);
	76	}
	77
	78	HWBUF = NULL;
	79	}
	80
	81	static int glue (audio_pcm_hw_alloc_resources_, TYPE) (HW *hw)
	82	{
1ea879e5	83	HWBUF = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (struct st_sample));
571ec3d6 FB	84	if (!HWBUF) {
	85	dolog ("Could not allocate " NAME " buffer (%d samples)\n",
	86	hw->samples);
c0fe3827 FB	87	return -1;
	88	}
	89
571ec3d6 FB	90	return 0;
	91	}
	92
	93	static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw)
	94	{
	95	if (sw->buf) {
	96	qemu_free (sw->buf);
	97	}
	98
	99	if (sw->rate) {
	100	st_rate_stop (sw->rate);
	101	}
	102
	103	sw->buf = NULL;
	104	sw->rate = NULL;
	105	}
	106
	107	static int glue (audio_pcm_sw_alloc_resources_, TYPE) (SW *sw)
	108	{
	109	int samples;
	110
c0fe3827	111	#ifdef DAC
571ec3d6	112	samples = sw->hw->samples;
c0fe3827	113	#else
571ec3d6	114	samples = ((int64_t) sw->hw->samples << 32) / sw->ratio;
c0fe3827	115	#endif
c0fe3827	116
1ea879e5	117	sw->buf = audio_calloc (AUDIO_FUNC, samples, sizeof (struct st_sample));
571ec3d6 FB	118	if (!sw->buf) {
	119	dolog ("Could not allocate buffer for `%s' (%d samples)\n",
	120	SW_NAME (sw), samples);
c0fe3827 FB	121	return -1;
	122	}
	123
571ec3d6 FB	124	#ifdef DAC
	125	sw->rate = st_rate_start (sw->info.freq, sw->hw->info.freq);
	126	#else
	127	sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq);
	128	#endif
	129	if (!sw->rate) {
	130	qemu_free (sw->buf);
	131	sw->buf = NULL;
	132	return -1;
	133	}
c0fe3827 FB	134	return 0;
	135	}
	136
571ec3d6 FB	137	static int glue (audio_pcm_sw_init_, TYPE) (
	138	SW *sw,
	139	HW *hw,
	140	const char *name,
1ea879e5	141	struct audsettings *as
571ec3d6 FB	142	)
	143	{
	144	int err;
	145
d929eba5	146	audio_pcm_init_info (&sw->info, as);
571ec3d6 FB	147	sw->hw = hw;
	148	sw->active = 0;
	149	#ifdef DAC
	150	sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq;
	151	sw->total_hw_samples_mixed = 0;
	152	sw->empty = 1;
	153	#else
	154	sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq;
	155	#endif
	156
	157	#ifdef DAC
	158	sw->conv = mixeng_conv
	159	#else
	160	sw->clip = mixeng_clip
	161	#endif
	162	[sw->info.nchannels == 2]
	163	[sw->info.sign]
d929eba5	164	[sw->info.swap_endianness]
f941aa25	165	[audio_bits_to_index (sw->info.bits)];
571ec3d6 FB	166
	167	sw->name = qemu_strdup (name);
	168	err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw);
	169	if (err) {
	170	qemu_free (sw->name);
	171	sw->name = NULL;
	172	}
	173	return err;
	174	}
	175
1d14ffa9 FB	176	static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw)
	177	{
	178	glue (audio_pcm_sw_free_resources_, TYPE) (sw);
	179	if (sw->name) {
	180	qemu_free (sw->name);
	181	sw->name = NULL;
	182	}
	183	}
	184
	185	static void glue (audio_pcm_hw_add_sw_, TYPE) (HW hw, SW sw)
	186	{
	187	LIST_INSERT_HEAD (&hw->sw_head, sw, entries);
	188	}
	189
	190	static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw)
	191	{
	192	LIST_REMOVE (sw, entries);
	193	}
	194
1a7dafce	195	static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp)
1d14ffa9	196	{
1a7dafce	197	AudioState *s = &glob_audio_state;
c0fe3827	198	HW hw = hwp;
1d14ffa9	199
1d14ffa9	200	if (!hw->sw_head.lh_first) {
8ead62cf FB	201	#ifdef DAC
	202	audio_detach_capture (hw);
	203	#endif
c0fe3827 FB	204	LIST_REMOVE (hw, entries);
	205	glue (s->nb_hw_voices_, TYPE) += 1;
	206	glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);
	207	glue (hw->pcm_ops->fini_, TYPE) (hw);
	208	qemu_free (hw);
	209	*hwp = NULL;
1d14ffa9 FB	210	}
	211	}
	212
1a7dafce	213	static HW glue (audio_pcm_hw_find_any_, TYPE) (HW hw)
1d14ffa9	214	{
1a7dafce	215	AudioState *s = &glob_audio_state;
1a7dafce	216	return hw ? hw->entries.le_next : glue (s->hw_head_, TYPE).lh_first;
1d14ffa9 FB	217	}
1d14ffa9 FB	218
1a7dafce	219	static HW glue (audio_pcm_hw_find_any_enabled_, TYPE) (HW hw)
1d14ffa9	220	{
1a7dafce	221	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) {
c0fe3827	222	if (hw->enabled) {
1d14ffa9 FB	223	return hw;
	224	}
	225	}
	226	return NULL;
	227	}
	228
1d14ffa9 FB	229	static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
1d14ffa9 FB	230	HW *hw,
1ea879e5	231	struct audsettings *as
1d14ffa9 FB	232	)
1d14ffa9 FB	233	{
1a7dafce	234	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (hw))) {
c0fe3827	235	if (audio_pcm_info_eq (&hw->info, as)) {
1d14ffa9 FB	236	return hw;
	237	}
	238	}
	239	return NULL;
	240	}
	241
1a7dafce	242	static HW glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings as)
1d14ffa9 FB	243	{
1d14ffa9 FB	244	HW *hw;
1a7dafce	245	AudioState *s = &glob_audio_state;
571ec3d6	246	struct audio_driver *drv = s->drv;
1d14ffa9	247
571ec3d6 FB	248	if (!glue (s->nb_hw_voices_, TYPE)) {
	249	return NULL;
	250	}
1d14ffa9	251
571ec3d6 FB	252	if (audio_bug (AUDIO_FUNC, !drv)) {
	253	dolog ("No host audio driver\n");
	254	return NULL;
1d14ffa9 FB	255	}
1d14ffa9 FB	256
571ec3d6 FB	257	if (audio_bug (AUDIO_FUNC, !drv->pcm_ops)) {
	258	dolog ("Host audio driver without pcm_ops\n");
	259	return NULL;
	260	}
	261
	262	hw = audio_calloc (AUDIO_FUNC, 1, glue (drv->voice_size_, TYPE));
	263	if (!hw) {
	264	dolog ("Can not allocate voice `%s' size %d\n",
	265	drv->name, glue (drv->voice_size_, TYPE));
	266	return NULL;
	267	}
	268
	269	hw->pcm_ops = drv->pcm_ops;
	270	LIST_INIT (&hw->sw_head);
8ead62cf	271	#ifdef DAC
ec36b695	272	LIST_INIT (&hw->cap_head);
8ead62cf	273	#endif
571ec3d6 FB	274	if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
	275	goto err0;
	276	}
	277
	278	if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) {
	279	dolog ("hw->samples=%d\n", hw->samples);
	280	goto err1;
	281	}
	282
	283	#ifdef DAC
	284	hw->clip = mixeng_clip
	285	#else
	286	hw->conv = mixeng_conv
	287	#endif
	288	[hw->info.nchannels == 2]
	289	[hw->info.sign]
d929eba5	290	[hw->info.swap_endianness]
f941aa25	291	[audio_bits_to_index (hw->info.bits)];
571ec3d6 FB	292
	293	if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
	294	goto err1;
	295	}
	296
	297	LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
	298	glue (s->nb_hw_voices_, TYPE) -= 1;
8ead62cf	299	#ifdef DAC
1a7dafce	300	audio_attach_capture (hw);
8ead62cf	301	#endif
571ec3d6 FB	302	return hw;
	303
	304	err1:
	305	glue (hw->pcm_ops->fini_, TYPE) (hw);
	306	err0:
	307	qemu_free (hw);
1d14ffa9 FB	308	return NULL;
	309	}
	310
1a7dafce	311	static HW glue (audio_pcm_hw_add_, TYPE) (struct audsettings as)
1d14ffa9 FB	312	{
	313	HW *hw;
	314
c0fe3827	315	if (glue (conf.fixed_, TYPE).enabled && glue (conf.fixed_, TYPE).greedy) {
1a7dafce	316	hw = glue (audio_pcm_hw_add_new_, TYPE) (as);
1d14ffa9 FB	317	if (hw) {
	318	return hw;
	319	}
	320	}
	321
1a7dafce	322	hw = glue (audio_pcm_hw_find_specific_, TYPE) (NULL, as);
1d14ffa9 FB	323	if (hw) {
	324	return hw;
	325	}
	326
1a7dafce	327	hw = glue (audio_pcm_hw_add_new_, TYPE) (as);
1d14ffa9 FB	328	if (hw) {
	329	return hw;
	330	}
	331
1a7dafce	332	return glue (audio_pcm_hw_find_any_, TYPE) (NULL);
1d14ffa9 FB	333	}
	334
	335	static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
c0fe3827	336	const char *sw_name,
1ea879e5	337	struct audsettings *as
1d14ffa9 FB	338	)
	339	{
	340	SW *sw;
	341	HW *hw;
1ea879e5	342	struct audsettings hw_as;
1d14ffa9	343
c0fe3827 FB	344	if (glue (conf.fixed_, TYPE).enabled) {
	345	hw_as = glue (conf.fixed_, TYPE).settings;
	346	}
	347	else {
	348	hw_as = *as;
1d14ffa9 FB	349	}
1d14ffa9 FB	350
c0fe3827	351	sw = audio_calloc (AUDIO_FUNC, 1, sizeof (*sw));
1d14ffa9	352	if (!sw) {
e7cad338	353	dolog ("Could not allocate soft voice `%s' (%zu bytes)\n",
c0fe3827	354	sw_name ? sw_name : "unknown", sizeof (*sw));
1d14ffa9 FB	355	goto err1;
	356	}
	357
1a7dafce	358	hw = glue (audio_pcm_hw_add_, TYPE) (&hw_as);
1d14ffa9 FB	359	if (!hw) {
	360	goto err2;
	361	}
	362
	363	glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw);
	364
d929eba5	365	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) {
1d14ffa9 FB	366	goto err3;
	367	}
	368
	369	return sw;
	370
	371	err3:
	372	glue (audio_pcm_hw_del_sw_, TYPE) (sw);
1a7dafce	373	glue (audio_pcm_hw_gc_, TYPE) (&hw);
1d14ffa9 FB	374	err2:
	375	qemu_free (sw);
	376	err1:
	377	return NULL;
	378	}
	379
1a7dafce	380	static void glue (audio_close_, TYPE) (SW *sw)
c0fe3827 FB	381	{
	382	glue (audio_pcm_sw_fini_, TYPE) (sw);
	383	glue (audio_pcm_hw_del_sw_, TYPE) (sw);
1a7dafce	384	glue (audio_pcm_hw_gc_, TYPE) (&sw->hw);
c0fe3827 FB	385	qemu_free (sw);
c0fe3827 FB	386	}
571ec3d6	387
c0fe3827	388	void glue (AUD_close_, TYPE) (QEMUSoundCard card, SW sw)
1d14ffa9 FB	389	{
1d14ffa9 FB	390	if (sw) {
1a7dafce	391	if (audio_bug (AUDIO_FUNC, !card)) {
1a7dafce	392	dolog ("card=%p\n", card);
c0fe3827 FB	393	return;
	394	}
	395
1a7dafce	396	glue (audio_close_, TYPE) (sw);
1d14ffa9 FB	397	}
	398	}
	399
	400	SW *glue (AUD_open_, TYPE) (
c0fe3827	401	QEMUSoundCard *card,
1d14ffa9 FB	402	SW *sw,
	403	const char *name,
	404	void *callback_opaque ,
	405	audio_callback_fn_t callback_fn,
1ea879e5	406	struct audsettings *as
1d14ffa9 FB	407	)
1d14ffa9 FB	408	{
1a7dafce	409	AudioState *s = &glob_audio_state;
1d14ffa9 FB	410	#ifdef DAC
	411	int live = 0;
	412	SW *old_sw = NULL;
	413	#endif
	414
c0fe3827 FB	415	ldebug ("open %s, freq %d, nchannels %d, fmt %d\n",
	416	name, as->freq, as->nchannels, as->fmt);
	417
1a7dafce	418	if (audio_bug (AUDIO_FUNC, !card \|\| !name \|\| !callback_fn \|\| !as)) {
	419	dolog ("card=%p name=%p callback_fn=%p as=%p\n",
	420	card, name, callback_fn, as);
1d14ffa9 FB	421	goto fail;
	422	}
	423
ec36b695	424	if (audio_bug (AUDIO_FUNC, audio_validate_settings (as))) {
c0fe3827	425	audio_print_settings (as);
1d14ffa9 FB	426	goto fail;
	427	}
	428
c0fe3827 FB	429	if (audio_bug (AUDIO_FUNC, !s->drv)) {
c0fe3827 FB	430	dolog ("Can not open `%s' (no host audio driver)\n", name);
1d14ffa9 FB	431	goto fail;
	432	}
	433
c0fe3827	434	if (sw && audio_pcm_info_eq (&sw->info, as)) {
1d14ffa9 FB	435	return sw;
	436	}
	437
	438	#ifdef DAC
c0fe3827	439	if (conf.plive && sw && (!sw->active && !sw->empty)) {
1d14ffa9 FB	440	live = sw->total_hw_samples_mixed;
	441
	442	#ifdef DEBUG_PLIVE
c0fe3827	443	dolog ("Replacing voice %s with %d live samples\n", SW_NAME (sw), live);
1d14ffa9	444	dolog ("Old %s freq %d, bits %d, channels %d\n",
c0fe3827	445	SW_NAME (sw), sw->info.freq, sw->info.bits, sw->info.nchannels);
1d14ffa9	446	dolog ("New %s freq %d, bits %d, channels %d\n",
c0fe3827 FB	447	name,
	448	freq,
	449	(fmt == AUD_FMT_S16 \|\| fmt == AUD_FMT_U16) ? 16 : 8,
1d14ffa9 FB	450	nchannels);
	451	#endif
	452
	453	if (live) {
	454	old_sw = sw;
	455	old_sw->callback.fn = NULL;
	456	sw = NULL;
	457	}
	458	}
	459	#endif
	460
c0fe3827 FB	461	if (!glue (conf.fixed_, TYPE).enabled && sw) {
c0fe3827 FB	462	glue (AUD_close_, TYPE) (card, sw);
1d14ffa9 FB	463	sw = NULL;
	464	}
	465
	466	if (sw) {
	467	HW *hw = sw->hw;
	468
	469	if (!hw) {
c0fe3827 FB	470	dolog ("Internal logic error voice `%s' has no hardware store\n",
c0fe3827 FB	471	SW_NAME (sw));
1d14ffa9 FB	472	goto fail;
	473	}
	474
571ec3d6	475	glue (audio_pcm_sw_fini_, TYPE) (sw);
d929eba5	476	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) {
1d14ffa9 FB	477	goto fail;
	478	}
	479	}
	480	else {
1a7dafce	481	sw = glue (audio_pcm_create_voice_pair_, TYPE) (name, as);
1d14ffa9	482	if (!sw) {
c0fe3827	483	dolog ("Failed to create voice `%s'\n", name);
571ec3d6	484	return NULL;
1d14ffa9 FB	485	}
	486	}
	487
	488	if (sw) {
1a7dafce	489	sw->card = card;
1d14ffa9 FB	490	sw->vol = nominal_volume;
	491	sw->callback.fn = callback_fn;
	492	sw->callback.opaque = callback_opaque;
	493
	494	#ifdef DAC
	495	if (live) {
	496	int mixed =
	497	(live << old_sw->info.shift)
	498	* old_sw->info.bytes_per_second
	499	/ sw->info.bytes_per_second;
	500
	501	#ifdef DEBUG_PLIVE
	502	dolog ("Silence will be mixed %d\n", mixed);
	503	#endif
	504	sw->total_hw_samples_mixed += mixed;
	505	}
	506	#endif
	507
	508	#ifdef DEBUG_AUDIO
	509	dolog ("%s\n", name);
	510	audio_pcm_print_info ("hw", &sw->hw->info);
	511	audio_pcm_print_info ("sw", &sw->info);
	512	#endif
	513	}
	514
	515	return sw;
	516
	517	fail:
c0fe3827	518	glue (AUD_close_, TYPE) (card, sw);
1d14ffa9 FB	519	return NULL;
	520	}
	521
	522	int glue (AUD_is_active_, TYPE) (SW *sw)
	523	{
	524	return sw ? sw->active : 0;
	525	}
	526
	527	void glue (AUD_init_time_stamp_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
	528	{
	529	if (!sw) {
	530	return;
	531	}
	532
	533	ts->old_ts = sw->hw->ts_helper;
	534	}
	535
c0fe3827	536	uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
1d14ffa9 FB	537	{
	538	uint64_t delta, cur_ts, old_ts;
	539
	540	if (!sw) {
	541	return 0;
	542	}
	543
	544	cur_ts = sw->hw->ts_helper;
	545	old_ts = ts->old_ts;
8ead62cf	546	/* dolog ("cur %lld old %lld\n", cur_ts, old_ts); */
1d14ffa9 FB	547
	548	if (cur_ts >= old_ts) {
	549	delta = cur_ts - old_ts;
	550	}
	551	else {
	552	delta = UINT64_MAX - old_ts + cur_ts;
	553	}
	554
	555	if (!delta) {
	556	return 0;
	557	}
	558
	559	return (delta * sw->hw->info.freq) / 1000000;
	560	}
	561
	562	#undef TYPE
	563	#undef HW
	564	#undef SW
571ec3d6 FB	565	#undef HWBUF
571ec3d6 FB	566	#undef NAME