[mirror_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 (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) (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,
    struct audsettings *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,
                                               struct audsettings *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->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 (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,
                                           struct audsettings *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,
    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) (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)) {
        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,
    struct audsettings *as
    )
{
    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_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) (s, name, as);
        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	{
1ea879e5	85	HWBUF = audio_calloc (AUDIO_FUNC, hw->samples, sizeof (struct st_sample));
571ec3d6 FB	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
1ea879e5	119	sw->buf = audio_calloc (AUDIO_FUNC, samples, sizeof (struct st_sample));
571ec3d6 FB	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,
1ea879e5	143	struct audsettings *as
571ec3d6 FB	144	)
	145	{
	146	int err;
	147
d929eba5	148	audio_pcm_init_info (&sw->info, as);
571ec3d6 FB	149	sw->hw = hw;
	150	sw->active = 0;
	151	#ifdef DAC
	152	sw->ratio = ((int64_t) sw->hw->info.freq << 32) / sw->info.freq;
	153	sw->total_hw_samples_mixed = 0;
	154	sw->empty = 1;
	155	#else
	156	sw->ratio = ((int64_t) sw->info.freq << 32) / sw->hw->info.freq;
	157	#endif
	158
	159	#ifdef DAC
	160	sw->conv = mixeng_conv
	161	#else
	162	sw->clip = mixeng_clip
	163	#endif
	164	[sw->info.nchannels == 2]
	165	[sw->info.sign]
d929eba5	166	[sw->info.swap_endianness]
f941aa25	167	[audio_bits_to_index (sw->info.bits)];
571ec3d6 FB	168
	169	sw->name = qemu_strdup (name);
	170	err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw);
	171	if (err) {
	172	qemu_free (sw->name);
	173	sw->name = NULL;
	174	}
	175	return err;
	176	}
	177
1d14ffa9 FB	178	static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw)
	179	{
	180	glue (audio_pcm_sw_free_resources_, TYPE) (sw);
	181	if (sw->name) {
	182	qemu_free (sw->name);
	183	sw->name = NULL;
	184	}
	185	}
	186
	187	static void glue (audio_pcm_hw_add_sw_, TYPE) (HW hw, SW sw)
	188	{
	189	LIST_INSERT_HEAD (&hw->sw_head, sw, entries);
	190	}
	191
	192	static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw)
	193	{
	194	LIST_REMOVE (sw, entries);
	195	}
	196
c0fe3827	197	static void glue (audio_pcm_hw_gc_, TYPE) (AudioState s, HW *hwp)
1d14ffa9	198	{
c0fe3827	199	HW hw = hwp;
1d14ffa9	200
1d14ffa9	201	if (!hw->sw_head.lh_first) {
8ead62cf FB	202	#ifdef DAC
	203	audio_detach_capture (hw);
	204	#endif
c0fe3827 FB	205	LIST_REMOVE (hw, entries);
	206	glue (s->nb_hw_voices_, TYPE) += 1;
	207	glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);
	208	glue (hw->pcm_ops->fini_, TYPE) (hw);
	209	qemu_free (hw);
	210	*hwp = NULL;
1d14ffa9 FB	211	}
	212	}
	213
c0fe3827	214	static HW glue (audio_pcm_hw_find_any_, TYPE) (AudioState s, HW *hw)
1d14ffa9	215	{
c0fe3827	216	return hw ? hw->entries.le_next : s->glue (hw_head_, TYPE).lh_first;
1d14ffa9 FB	217	}
1d14ffa9 FB	218
c0fe3827	219	static HW glue (audio_pcm_hw_find_any_enabled_, TYPE) (AudioState s, HW *hw)
1d14ffa9	220	{
c0fe3827 FB	221	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
c0fe3827 FB	222	if (hw->enabled) {
1d14ffa9 FB	223	return hw;
	224	}
	225	}
	226	return NULL;
	227	}
	228
1d14ffa9	229	static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
c0fe3827	230	AudioState *s,
1d14ffa9	231	HW *hw,
1ea879e5	232	struct audsettings *as
1d14ffa9 FB	233	)
1d14ffa9 FB	234	{
c0fe3827 FB	235	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
c0fe3827 FB	236	if (audio_pcm_info_eq (&hw->info, as)) {
1d14ffa9 FB	237	return hw;
	238	}
	239	}
	240	return NULL;
	241	}
	242
1ea879e5	243	static HW glue (audio_pcm_hw_add_new_, TYPE) (AudioState s,
1ea879e5	244	struct audsettings *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	272	#ifdef DAC
ec36b695	273	LIST_INIT (&hw->cap_head);
8ead62cf	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]
d929eba5	291	[hw->info.swap_endianness]
f941aa25	292	[audio_bits_to_index (hw->info.bits)];
571ec3d6 FB	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
1ea879e5	312	static HW glue (audio_pcm_hw_add_, TYPE) (AudioState s,
1ea879e5	313	struct audsettings *as)
1d14ffa9 FB	314	{
	315	HW *hw;
	316
c0fe3827 FB	317	if (glue (conf.fixed_, TYPE).enabled && glue (conf.fixed_, TYPE).greedy) {
c0fe3827 FB	318	hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
1d14ffa9 FB	319	if (hw) {
	320	return hw;
	321	}
	322	}
	323
c0fe3827	324	hw = glue (audio_pcm_hw_find_specific_, TYPE) (s, NULL, as);
1d14ffa9 FB	325	if (hw) {
	326	return hw;
	327	}
	328
c0fe3827	329	hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
1d14ffa9 FB	330	if (hw) {
	331	return hw;
	332	}
	333
c0fe3827	334	return glue (audio_pcm_hw_find_any_, TYPE) (s, NULL);
1d14ffa9 FB	335	}
	336
	337	static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
c0fe3827 FB	338	AudioState *s,
c0fe3827 FB	339	const char *sw_name,
1ea879e5	340	struct audsettings *as
1d14ffa9 FB	341	)
	342	{
	343	SW *sw;
	344	HW *hw;
1ea879e5	345	struct audsettings 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
d929eba5	368	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as)) {
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,
1ea879e5	410	struct audsettings *as
1d14ffa9 FB	411	)
1d14ffa9 FB	412	{
c0fe3827	413	AudioState *s;
1d14ffa9 FB	414	#ifdef DAC
	415	int live = 0;
	416	SW *old_sw = NULL;
	417	#endif
	418
c0fe3827 FB	419	ldebug ("open %s, freq %d, nchannels %d, fmt %d\n",
	420	name, as->freq, as->nchannels, as->fmt);
	421
	422	if (audio_bug (AUDIO_FUNC,
	423	!card \|\| !card->audio \|\| !name \|\| !callback_fn \|\| !as)) {
	424	dolog ("card=%p card->audio=%p name=%p callback_fn=%p as=%p\n",
	425	card, card ? card->audio : NULL, name, callback_fn, as);
1d14ffa9 FB	426	goto fail;
	427	}
	428
c0fe3827 FB	429	s = card->audio;
c0fe3827 FB	430
ec36b695	431	if (audio_bug (AUDIO_FUNC, audio_validate_settings (as))) {
c0fe3827	432	audio_print_settings (as);
1d14ffa9 FB	433	goto fail;
	434	}
	435
c0fe3827 FB	436	if (audio_bug (AUDIO_FUNC, !s->drv)) {
c0fe3827 FB	437	dolog ("Can not open `%s' (no host audio driver)\n", name);
1d14ffa9 FB	438	goto fail;
	439	}
	440
c0fe3827	441	if (sw && audio_pcm_info_eq (&sw->info, as)) {
1d14ffa9 FB	442	return sw;
	443	}
	444
	445	#ifdef DAC
c0fe3827	446	if (conf.plive && sw && (!sw->active && !sw->empty)) {
1d14ffa9 FB	447	live = sw->total_hw_samples_mixed;
	448
	449	#ifdef DEBUG_PLIVE
c0fe3827	450	dolog ("Replacing voice %s with %d live samples\n", SW_NAME (sw), live);
1d14ffa9	451	dolog ("Old %s freq %d, bits %d, channels %d\n",
c0fe3827	452	SW_NAME (sw), sw->info.freq, sw->info.bits, sw->info.nchannels);
1d14ffa9	453	dolog ("New %s freq %d, bits %d, channels %d\n",
c0fe3827 FB	454	name,
	455	freq,
	456	(fmt == AUD_FMT_S16 \|\| fmt == AUD_FMT_U16) ? 16 : 8,
1d14ffa9 FB	457	nchannels);
	458	#endif
	459
	460	if (live) {
	461	old_sw = sw;
	462	old_sw->callback.fn = NULL;
	463	sw = NULL;
	464	}
	465	}
	466	#endif
	467
c0fe3827 FB	468	if (!glue (conf.fixed_, TYPE).enabled && sw) {
c0fe3827 FB	469	glue (AUD_close_, TYPE) (card, sw);
1d14ffa9 FB	470	sw = NULL;
	471	}
	472
	473	if (sw) {
	474	HW *hw = sw->hw;
	475
	476	if (!hw) {
c0fe3827 FB	477	dolog ("Internal logic error voice `%s' has no hardware store\n",
c0fe3827 FB	478	SW_NAME (sw));
1d14ffa9 FB	479	goto fail;
	480	}
	481
571ec3d6	482	glue (audio_pcm_sw_fini_, TYPE) (sw);
d929eba5	483	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as)) {
1d14ffa9 FB	484	goto fail;
	485	}
	486	}
	487	else {
d929eba5	488	sw = glue (audio_pcm_create_voice_pair_, TYPE) (s, name, as);
1d14ffa9	489	if (!sw) {
c0fe3827	490	dolog ("Failed to create voice `%s'\n", name);
571ec3d6	491	return NULL;
1d14ffa9 FB	492	}
	493	}
	494
	495	if (sw) {
	496	sw->vol = nominal_volume;
	497	sw->callback.fn = callback_fn;
	498	sw->callback.opaque = callback_opaque;
	499
	500	#ifdef DAC
	501	if (live) {
	502	int mixed =
	503	(live << old_sw->info.shift)
	504	* old_sw->info.bytes_per_second
	505	/ sw->info.bytes_per_second;
	506
	507	#ifdef DEBUG_PLIVE
	508	dolog ("Silence will be mixed %d\n", mixed);
	509	#endif
	510	sw->total_hw_samples_mixed += mixed;
	511	}
	512	#endif
	513
	514	#ifdef DEBUG_AUDIO
	515	dolog ("%s\n", name);
	516	audio_pcm_print_info ("hw", &sw->hw->info);
	517	audio_pcm_print_info ("sw", &sw->info);
	518	#endif
	519	}
	520
	521	return sw;
	522
	523	fail:
c0fe3827	524	glue (AUD_close_, TYPE) (card, sw);
1d14ffa9 FB	525	return NULL;
	526	}
	527
	528	int glue (AUD_is_active_, TYPE) (SW *sw)
	529	{
	530	return sw ? sw->active : 0;
	531	}
	532
	533	void glue (AUD_init_time_stamp_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
	534	{
	535	if (!sw) {
	536	return;
	537	}
	538
	539	ts->old_ts = sw->hw->ts_helper;
	540	}
	541
c0fe3827	542	uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
1d14ffa9 FB	543	{
	544	uint64_t delta, cur_ts, old_ts;
	545
	546	if (!sw) {
	547	return 0;
	548	}
	549
	550	cur_ts = sw->hw->ts_helper;
	551	old_ts = ts->old_ts;
8ead62cf	552	/* dolog ("cur %lld old %lld\n", cur_ts, old_ts); */
1d14ffa9 FB	553
	554	if (cur_ts >= old_ts) {
	555	delta = cur_ts - old_ts;
	556	}
	557	else {
	558	delta = UINT64_MAX - old_ts + cur_ts;
	559	}
	560
	561	if (!delta) {
	562	return 0;
	563	}
	564
	565	return (delta * sw->hw->info.freq) / 1000000;
	566	}
	567
	568	#undef TYPE
	569	#undef HW
	570	#undef SW
571ec3d6 FB	571	#undef HWBUF
571ec3d6 FB	572	#undef NAME