[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 (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) {
        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);

    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;
    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 %" PRId64 " old %" PRId64 "\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) {
c0fe3827 FB	203	LIST_REMOVE (hw, entries);
	204	glue (s->nb_hw_voices_, TYPE) += 1;
	205	glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);
	206	glue (hw->pcm_ops->fini_, TYPE) (hw);
	207	qemu_free (hw);
	208	*hwp = NULL;
1d14ffa9 FB	209	}
	210	}
	211
c0fe3827	212	static HW glue (audio_pcm_hw_find_any_, TYPE) (AudioState s, HW *hw)
1d14ffa9	213	{
c0fe3827	214	return hw ? hw->entries.le_next : s->glue (hw_head_, TYPE).lh_first;
1d14ffa9 FB	215	}
1d14ffa9 FB	216
c0fe3827	217	static HW glue (audio_pcm_hw_find_any_enabled_, TYPE) (AudioState s, HW *hw)
1d14ffa9	218	{
c0fe3827 FB	219	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
c0fe3827 FB	220	if (hw->enabled) {
1d14ffa9 FB	221	return hw;
	222	}
	223	}
	224	return NULL;
	225	}
	226
1d14ffa9	227	static HW *glue (audio_pcm_hw_find_specific_, TYPE) (
c0fe3827	228	AudioState *s,
1d14ffa9	229	HW *hw,
c0fe3827	230	audsettings_t *as
1d14ffa9 FB	231	)
1d14ffa9 FB	232	{
c0fe3827 FB	233	while ((hw = glue (audio_pcm_hw_find_any_, TYPE) (s, hw))) {
c0fe3827 FB	234	if (audio_pcm_info_eq (&hw->info, as)) {
1d14ffa9 FB	235	return hw;
	236	}
	237	}
	238	return NULL;
	239	}
	240
c0fe3827	241	static HW glue (audio_pcm_hw_add_new_, TYPE) (AudioState s, audsettings_t *as)
1d14ffa9 FB	242	{
1d14ffa9 FB	243	HW *hw;
571ec3d6	244	struct audio_driver *drv = s->drv;
1d14ffa9	245
571ec3d6 FB	246	if (!glue (s->nb_hw_voices_, TYPE)) {
	247	return NULL;
	248	}
1d14ffa9	249
571ec3d6 FB	250	if (audio_bug (AUDIO_FUNC, !drv)) {
	251	dolog ("No host audio driver\n");
	252	return NULL;
1d14ffa9 FB	253	}
1d14ffa9 FB	254
571ec3d6 FB	255	if (audio_bug (AUDIO_FUNC, !drv->pcm_ops)) {
	256	dolog ("Host audio driver without pcm_ops\n");
	257	return NULL;
	258	}
	259
	260	hw = audio_calloc (AUDIO_FUNC, 1, glue (drv->voice_size_, TYPE));
	261	if (!hw) {
	262	dolog ("Can not allocate voice `%s' size %d\n",
	263	drv->name, glue (drv->voice_size_, TYPE));
	264	return NULL;
	265	}
	266
	267	hw->pcm_ops = drv->pcm_ops;
	268	LIST_INIT (&hw->sw_head);
	269
	270	if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
	271	goto err0;
	272	}
	273
	274	if (audio_bug (AUDIO_FUNC, hw->samples <= 0)) {
	275	dolog ("hw->samples=%d\n", hw->samples);
	276	goto err1;
	277	}
	278
	279	#ifdef DAC
	280	hw->clip = mixeng_clip
	281	#else
	282	hw->conv = mixeng_conv
	283	#endif
	284	[hw->info.nchannels == 2]
	285	[hw->info.sign]
	286	[hw->info.swap_endian]
	287	[hw->info.bits == 16];
	288
	289	if (glue (audio_pcm_hw_alloc_resources_, TYPE) (hw)) {
	290	goto err1;
	291	}
	292
	293	LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries);
	294	glue (s->nb_hw_voices_, TYPE) -= 1;
	295	return hw;
	296
	297	err1:
	298	glue (hw->pcm_ops->fini_, TYPE) (hw);
	299	err0:
	300	qemu_free (hw);
1d14ffa9 FB	301	return NULL;
	302	}
	303
c0fe3827	304	static HW glue (audio_pcm_hw_add_, TYPE) (AudioState s, audsettings_t *as)
1d14ffa9 FB	305	{
	306	HW *hw;
	307
c0fe3827 FB	308	if (glue (conf.fixed_, TYPE).enabled && glue (conf.fixed_, TYPE).greedy) {
c0fe3827 FB	309	hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
1d14ffa9 FB	310	if (hw) {
	311	return hw;
	312	}
	313	}
	314
c0fe3827	315	hw = glue (audio_pcm_hw_find_specific_, TYPE) (s, NULL, as);
1d14ffa9 FB	316	if (hw) {
	317	return hw;
	318	}
	319
c0fe3827	320	hw = glue (audio_pcm_hw_add_new_, TYPE) (s, as);
1d14ffa9 FB	321	if (hw) {
	322	return hw;
	323	}
	324
c0fe3827	325	return glue (audio_pcm_hw_find_any_, TYPE) (s, NULL);
1d14ffa9 FB	326	}
	327
	328	static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
c0fe3827 FB	329	AudioState *s,
c0fe3827 FB	330	const char *sw_name,
571ec3d6 FB	331	audsettings_t *as,
571ec3d6 FB	332	int sw_endian
1d14ffa9 FB	333	)
	334	{
	335	SW *sw;
	336	HW *hw;
c0fe3827	337	audsettings_t hw_as;
1d14ffa9	338
c0fe3827 FB	339	if (glue (conf.fixed_, TYPE).enabled) {
	340	hw_as = glue (conf.fixed_, TYPE).settings;
	341	}
	342	else {
	343	hw_as = *as;
1d14ffa9 FB	344	}
1d14ffa9 FB	345
c0fe3827	346	sw = audio_calloc (AUDIO_FUNC, 1, sizeof (*sw));
1d14ffa9	347	if (!sw) {
e7cad338	348	dolog ("Could not allocate soft voice `%s' (%zu bytes)\n",
c0fe3827	349	sw_name ? sw_name : "unknown", sizeof (*sw));
1d14ffa9 FB	350	goto err1;
	351	}
	352
c0fe3827	353	hw = glue (audio_pcm_hw_add_, TYPE) (s, &hw_as);
1d14ffa9 FB	354	if (!hw) {
	355	goto err2;
	356	}
	357
	358	glue (audio_pcm_hw_add_sw_, TYPE) (hw, sw);
	359
571ec3d6	360	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, sw_name, as, sw_endian)) {
1d14ffa9 FB	361	goto err3;
	362	}
	363
	364	return sw;
	365
	366	err3:
	367	glue (audio_pcm_hw_del_sw_, TYPE) (sw);
c0fe3827	368	glue (audio_pcm_hw_gc_, TYPE) (s, &hw);
1d14ffa9 FB	369	err2:
	370	qemu_free (sw);
	371	err1:
	372	return NULL;
	373	}
	374
c0fe3827 FB	375	static void glue (audio_close_, TYPE) (AudioState s, SW sw)
	376	{
	377	glue (audio_pcm_sw_fini_, TYPE) (sw);
	378	glue (audio_pcm_hw_del_sw_, TYPE) (sw);
	379	glue (audio_pcm_hw_gc_, TYPE) (s, &sw->hw);
	380	qemu_free (sw);
	381	}
571ec3d6	382
c0fe3827	383	void glue (AUD_close_, TYPE) (QEMUSoundCard card, SW sw)
1d14ffa9 FB	384	{
1d14ffa9 FB	385	if (sw) {
c0fe3827 FB	386	if (audio_bug (AUDIO_FUNC, !card \|\| !card->audio)) {
	387	dolog ("card=%p card->audio=%p\n",
	388	card, card ? card->audio : NULL);
	389	return;
	390	}
	391
	392	glue (audio_close_, TYPE) (card->audio, sw);
1d14ffa9 FB	393	}
	394	}
	395
	396	SW *glue (AUD_open_, TYPE) (
c0fe3827	397	QEMUSoundCard *card,
1d14ffa9 FB	398	SW *sw,
	399	const char *name,
	400	void *callback_opaque ,
	401	audio_callback_fn_t callback_fn,
571ec3d6 FB	402	audsettings_t *as,
571ec3d6 FB	403	int sw_endian
1d14ffa9 FB	404	)
1d14ffa9 FB	405	{
c0fe3827	406	AudioState *s;
1d14ffa9 FB	407	#ifdef DAC
	408	int live = 0;
	409	SW *old_sw = NULL;
	410	#endif
	411
c0fe3827 FB	412	ldebug ("open %s, freq %d, nchannels %d, fmt %d\n",
	413	name, as->freq, as->nchannels, as->fmt);
	414
	415	if (audio_bug (AUDIO_FUNC,
	416	!card \|\| !card->audio \|\| !name \|\| !callback_fn \|\| !as)) {
	417	dolog ("card=%p card->audio=%p name=%p callback_fn=%p as=%p\n",
	418	card, card ? card->audio : NULL, name, callback_fn, as);
1d14ffa9 FB	419	goto fail;
	420	}
	421
c0fe3827 FB	422	s = card->audio;
	423
	424	if (audio_bug (AUDIO_FUNC, audio_validate_settigs (as))) {
	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 FB	475	glue (audio_pcm_sw_fini_, TYPE) (sw);
571ec3d6 FB	476	if (glue (audio_pcm_sw_init_, TYPE) (sw, hw, name, as, sw_endian)) {
1d14ffa9 FB	477	goto fail;
	478	}
	479	}
	480	else {
571ec3d6	481	sw = glue (audio_pcm_create_voice_pair_, TYPE) (s, name, as, sw_endian);
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) {
	489	sw->vol = nominal_volume;
	490	sw->callback.fn = callback_fn;
	491	sw->callback.opaque = callback_opaque;
	492
	493	#ifdef DAC
	494	if (live) {
	495	int mixed =
	496	(live << old_sw->info.shift)
	497	* old_sw->info.bytes_per_second
	498	/ sw->info.bytes_per_second;
	499
	500	#ifdef DEBUG_PLIVE
	501	dolog ("Silence will be mixed %d\n", mixed);
	502	#endif
	503	sw->total_hw_samples_mixed += mixed;
	504	}
	505	#endif
	506
	507	#ifdef DEBUG_AUDIO
	508	dolog ("%s\n", name);
	509	audio_pcm_print_info ("hw", &sw->hw->info);
	510	audio_pcm_print_info ("sw", &sw->info);
	511	#endif
	512	}
	513
	514	return sw;
	515
	516	fail:
c0fe3827	517	glue (AUD_close_, TYPE) (card, sw);
1d14ffa9 FB	518	return NULL;
	519	}
	520
	521	int glue (AUD_is_active_, TYPE) (SW *sw)
	522	{
	523	return sw ? sw->active : 0;
	524	}
	525
	526	void glue (AUD_init_time_stamp_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
	527	{
	528	if (!sw) {
	529	return;
	530	}
	531
	532	ts->old_ts = sw->hw->ts_helper;
	533	}
	534
c0fe3827	535	uint64_t glue (AUD_get_elapsed_usec_, TYPE) (SW sw, QEMUAudioTimeStamp ts)
1d14ffa9 FB	536	{
	537	uint64_t delta, cur_ts, old_ts;
	538
	539	if (!sw) {
	540	return 0;
	541	}
	542
	543	cur_ts = sw->hw->ts_helper;
	544	old_ts = ts->old_ts;
26a76461	545	/* dolog ("cur %" PRId64 " old %" PRId64 "\n", cur_ts, old_ts); */
1d14ffa9 FB	546
	547	if (cur_ts >= old_ts) {
	548	delta = cur_ts - old_ts;
	549	}
	550	else {
	551	delta = UINT64_MAX - old_ts + cur_ts;
	552	}
	553
	554	if (!delta) {
	555	return 0;
	556	}
	557
	558	return (delta * sw->hw->info.freq) / 1000000;
	559	}
	560
	561	#undef TYPE
	562	#undef HW
	563	#undef SW
571ec3d6 FB	564	#undef HWBUF
571ec3d6 FB	565	#undef NAME