[qemu.git] / audio / esdaudio.c

/*
 * QEMU ESD audio driver
 *
 * Copyright (c) 2006 Frederick Reeve (brushed up by 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.
 */
#include <esd.h>
#include "qemu-common.h"
#include "audio.h"

#define AUDIO_CAP "esd"
#include "audio_int.h"
#include "audio_pt_int.h"

typedef struct {
    HWVoiceOut hw;
    int done;
    int live;
    int decr;
    int rpos;
    void *pcm_buf;
    int fd;
    struct audio_pt pt;
} ESDVoiceOut;

typedef struct {
    HWVoiceIn hw;
    int done;
    int dead;
    int incr;
    int wpos;
    void *pcm_buf;
    int fd;
    struct audio_pt pt;
} ESDVoiceIn;

static struct {
    int samples;
    int divisor;
    char *dac_host;
    char *adc_host;
} conf = {
    .samples = 1024,
    .divisor = 2,
};

static void GCC_FMT_ATTR (2, 3) qesd_logerr (int err, const char *fmt, ...)
{
    va_list ap;

    va_start (ap, fmt);
    AUD_vlog (AUDIO_CAP, fmt, ap);
    va_end (ap);

    AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
}

/* playback */
static void *qesd_thread_out (void *arg)
{
    ESDVoiceOut *esd = arg;
    HWVoiceOut *hw = &esd->hw;
    int threshold;

    threshold = conf.divisor ? hw->samples / conf.divisor : 0;

    if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
        return NULL;
    }

    for (;;) {
        int decr, to_mix, rpos;

        for (;;) {
            if (esd->done) {
                goto exit;
            }

            if (esd->live > threshold) {
                break;
            }

            if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
                goto exit;
            }
        }

        decr = to_mix = esd->live;
        rpos = hw->rpos;

        if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
            return NULL;
        }

        while (to_mix) {
            ssize_t written;
            int chunk = audio_MIN (to_mix, hw->samples - rpos);
            struct st_sample *src = hw->mix_buf + rpos;

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

        again:
            written = write (esd->fd, esd->pcm_buf, chunk << hw->info.shift);
            if (written == -1) {
                if (errno == EINTR || errno == EAGAIN) {
                    goto again;
                }
                qesd_logerr (errno, "write failed\n");
                return NULL;
            }

            if (written != chunk << hw->info.shift) {
                int wsamples = written >> hw->info.shift;
                int wbytes = wsamples << hw->info.shift;
                if (wbytes != written) {
                    dolog ("warning: Misaligned write %d (requested %zd), "
                           "alignment %d\n",
                           wbytes, written, hw->info.align + 1);
                }
                to_mix -= wsamples;
                rpos = (rpos + wsamples) % hw->samples;
                break;
            }

            rpos = (rpos + chunk) % hw->samples;
            to_mix -= chunk;
        }

        if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
            return NULL;
        }

        esd->rpos = rpos;
        esd->live -= decr;
        esd->decr += decr;
    }

 exit:
    audio_pt_unlock (&esd->pt, AUDIO_FUNC);
    return NULL;
}

static int qesd_run_out (HWVoiceOut *hw, int live)
{
    int decr;
    ESDVoiceOut *esd = (ESDVoiceOut *) hw;

    if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
        return 0;
    }

    decr = audio_MIN (live, esd->decr);
    esd->decr -= decr;
    esd->live = live - decr;
    hw->rpos = esd->rpos;
    if (esd->live > 0) {
        audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
    }
    else {
        audio_pt_unlock (&esd->pt, AUDIO_FUNC);
    }
    return decr;
}

static int qesd_write (SWVoiceOut *sw, void *buf, int len)
{
    return audio_pcm_sw_write (sw, buf, len);
}

static int qesd_init_out (HWVoiceOut *hw, struct audsettings *as)
{
    ESDVoiceOut *esd = (ESDVoiceOut *) hw;
    struct audsettings obt_as = *as;
    int esdfmt = ESD_STREAM | ESD_PLAY;

    esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
    switch (as->fmt) {
    case AUD_FMT_S8:
    case AUD_FMT_U8:
        esdfmt |= ESD_BITS8;
        obt_as.fmt = AUD_FMT_U8;
        break;

    case AUD_FMT_S32:
    case AUD_FMT_U32:
        dolog ("Will use 16 instead of 32 bit samples\n");
        /* fall through */
    case AUD_FMT_S16:
    case AUD_FMT_U16:
    deffmt:
        esdfmt |= ESD_BITS16;
        obt_as.fmt = AUD_FMT_S16;
        break;

    default:
        dolog ("Internal logic error: Bad audio format %d\n", as->fmt);
        goto deffmt;

    }
    obt_as.endianness = AUDIO_HOST_ENDIANNESS;

    audio_pcm_init_info (&hw->info, &obt_as);

    hw->samples = conf.samples;
    esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
    if (!esd->pcm_buf) {
        dolog ("Could not allocate buffer (%d bytes)\n",
               hw->samples << hw->info.shift);
        return -1;
    }

    esd->fd = esd_play_stream (esdfmt, as->freq, conf.dac_host, NULL);
    if (esd->fd < 0) {
        qesd_logerr (errno, "esd_play_stream failed\n");
        goto fail1;
    }

    if (audio_pt_init (&esd->pt, qesd_thread_out, esd, AUDIO_CAP, AUDIO_FUNC)) {
        goto fail2;
    }

    return 0;

 fail2:
    if (close (esd->fd)) {
        qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
                     AUDIO_FUNC, esd->fd);
    }
    esd->fd = -1;

 fail1:
    g_free (esd->pcm_buf);
    esd->pcm_buf = NULL;
    return -1;
}

static void qesd_fini_out (HWVoiceOut *hw)
{
    void *ret;
    ESDVoiceOut *esd = (ESDVoiceOut *) hw;

    audio_pt_lock (&esd->pt, AUDIO_FUNC);
    esd->done = 1;
    audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
    audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);

    if (esd->fd >= 0) {
        if (close (esd->fd)) {
            qesd_logerr (errno, "failed to close esd socket\n");
        }
        esd->fd = -1;
    }

    audio_pt_fini (&esd->pt, AUDIO_FUNC);

    g_free (esd->pcm_buf);
    esd->pcm_buf = NULL;
}

static int qesd_ctl_out (HWVoiceOut *hw, int cmd, ...)
{
    (void) hw;
    (void) cmd;
    return 0;
}

/* capture */
static void *qesd_thread_in (void *arg)
{
    ESDVoiceIn *esd = arg;
    HWVoiceIn *hw = &esd->hw;
    int threshold;

    threshold = conf.divisor ? hw->samples / conf.divisor : 0;

    if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
        return NULL;
    }

    for (;;) {
        int incr, to_grab, wpos;

        for (;;) {
            if (esd->done) {
                goto exit;
            }

            if (esd->dead > threshold) {
                break;
            }

            if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
                goto exit;
            }
        }

        incr = to_grab = esd->dead;
        wpos = hw->wpos;

        if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
            return NULL;
        }

        while (to_grab) {
            ssize_t nread;
            int chunk = audio_MIN (to_grab, hw->samples - wpos);
            void *buf = advance (esd->pcm_buf, wpos);

        again:
            nread = read (esd->fd, buf, chunk << hw->info.shift);
            if (nread == -1) {
                if (errno == EINTR || errno == EAGAIN) {
                    goto again;
                }
                qesd_logerr (errno, "read failed\n");
                return NULL;
            }

            if (nread != chunk << hw->info.shift) {
                int rsamples = nread >> hw->info.shift;
                int rbytes = rsamples << hw->info.shift;
                if (rbytes != nread) {
                    dolog ("warning: Misaligned write %d (requested %zd), "
                           "alignment %d\n",
                           rbytes, nread, hw->info.align + 1);
                }
                to_grab -= rsamples;
                wpos = (wpos + rsamples) % hw->samples;
                break;
            }

            hw->conv (hw->conv_buf + wpos, buf, nread >> hw->info.shift);
            wpos = (wpos + chunk) % hw->samples;
            to_grab -= chunk;
        }

        if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
            return NULL;
        }

        esd->wpos = wpos;
        esd->dead -= incr;
        esd->incr += incr;
    }

 exit:
    audio_pt_unlock (&esd->pt, AUDIO_FUNC);
    return NULL;
}

static int qesd_run_in (HWVoiceIn *hw)
{
    int live, incr, dead;
    ESDVoiceIn *esd = (ESDVoiceIn *) hw;

    if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
        return 0;
    }

    live = audio_pcm_hw_get_live_in (hw);
    dead = hw->samples - live;
    incr = audio_MIN (dead, esd->incr);
    esd->incr -= incr;
    esd->dead = dead - incr;
    hw->wpos = esd->wpos;
    if (esd->dead > 0) {
        audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
    }
    else {
        audio_pt_unlock (&esd->pt, AUDIO_FUNC);
    }
    return incr;
}

static int qesd_read (SWVoiceIn *sw, void *buf, int len)
{
    return audio_pcm_sw_read (sw, buf, len);
}

static int qesd_init_in (HWVoiceIn *hw, struct audsettings *as)
{
    ESDVoiceIn *esd = (ESDVoiceIn *) hw;
    struct audsettings obt_as = *as;
    int esdfmt = ESD_STREAM | ESD_RECORD;

    esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
    switch (as->fmt) {
    case AUD_FMT_S8:
    case AUD_FMT_U8:
        esdfmt |= ESD_BITS8;
        obt_as.fmt = AUD_FMT_U8;
        break;

    case AUD_FMT_S16:
    case AUD_FMT_U16:
        esdfmt |= ESD_BITS16;
        obt_as.fmt = AUD_FMT_S16;
        break;

    case AUD_FMT_S32:
    case AUD_FMT_U32:
        dolog ("Will use 16 instead of 32 bit samples\n");
        esdfmt |= ESD_BITS16;
        obt_as.fmt = AUD_FMT_S16;
        break;
    }
    obt_as.endianness = AUDIO_HOST_ENDIANNESS;

    audio_pcm_init_info (&hw->info, &obt_as);

    hw->samples = conf.samples;
    esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
    if (!esd->pcm_buf) {
        dolog ("Could not allocate buffer (%d bytes)\n",
               hw->samples << hw->info.shift);
        return -1;
    }

    esd->fd = esd_record_stream (esdfmt, as->freq, conf.adc_host, NULL);
    if (esd->fd < 0) {
        qesd_logerr (errno, "esd_record_stream failed\n");
        goto fail1;
    }

    if (audio_pt_init (&esd->pt, qesd_thread_in, esd, AUDIO_CAP, AUDIO_FUNC)) {
        goto fail2;
    }

    return 0;

 fail2:
    if (close (esd->fd)) {
        qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
                     AUDIO_FUNC, esd->fd);
    }
    esd->fd = -1;

 fail1:
    g_free (esd->pcm_buf);
    esd->pcm_buf = NULL;
    return -1;
}

static void qesd_fini_in (HWVoiceIn *hw)
{
    void *ret;
    ESDVoiceIn *esd = (ESDVoiceIn *) hw;

    audio_pt_lock (&esd->pt, AUDIO_FUNC);
    esd->done = 1;
    audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
    audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);

    if (esd->fd >= 0) {
        if (close (esd->fd)) {
            qesd_logerr (errno, "failed to close esd socket\n");
        }
        esd->fd = -1;
    }

    audio_pt_fini (&esd->pt, AUDIO_FUNC);

    g_free (esd->pcm_buf);
    esd->pcm_buf = NULL;
}

static int qesd_ctl_in (HWVoiceIn *hw, int cmd, ...)
{
    (void) hw;
    (void) cmd;
    return 0;
}

/* common */
static void *qesd_audio_init (void)
{
    return &conf;
}

static void qesd_audio_fini (void *opaque)
{
    (void) opaque;
    ldebug ("esd_fini");
}

struct audio_option qesd_options[] = {
    {
        .name  = "SAMPLES",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.samples,
        .descr = "buffer size in samples"
    },
    {
        .name  = "DIVISOR",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.divisor,
        .descr = "threshold divisor"
    },
    {
        .name  = "DAC_HOST",
        .tag   = AUD_OPT_STR,
        .valp  = &conf.dac_host,
        .descr = "playback host"
    },
    {
        .name  = "ADC_HOST",
        .tag   = AUD_OPT_STR,
        .valp  = &conf.adc_host,
        .descr = "capture host"
    },
    { /* End of list */ }
};

static struct audio_pcm_ops qesd_pcm_ops = {
    .init_out = qesd_init_out,
    .fini_out = qesd_fini_out,
    .run_out  = qesd_run_out,
    .write    = qesd_write,
    .ctl_out  = qesd_ctl_out,

    .init_in  = qesd_init_in,
    .fini_in  = qesd_fini_in,
    .run_in   = qesd_run_in,
    .read     = qesd_read,
    .ctl_in   = qesd_ctl_in,
};

struct audio_driver esd_audio_driver = {
    .name           = "esd",
    .descr          = "http://en.wikipedia.org/wiki/Esound",
    .options        = qesd_options,
    .init           = qesd_audio_init,
    .fini           = qesd_audio_fini,
    .pcm_ops        = &qesd_pcm_ops,
    .can_be_default = 0,
    .max_voices_out = INT_MAX,
    .max_voices_in  = INT_MAX,
    .voice_size_out = sizeof (ESDVoiceOut),
    .voice_size_in  = sizeof (ESDVoiceIn)
};
Commit	Line	Data
ca9cc28c AZ	1	/*
	2	* QEMU ESD audio driver
	3	*
	4	* Copyright (c) 2006 Frederick Reeve (brushed up by 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	#include <esd.h>
	25	#include "qemu-common.h"
	26	#include "audio.h"
ca9cc28c AZ	27
	28	#define AUDIO_CAP "esd"
	29	#include "audio_int.h"
	30	#include "audio_pt_int.h"
	31
	32	typedef struct {
	33	HWVoiceOut hw;
	34	int done;
	35	int live;
	36	int decr;
	37	int rpos;
	38	void *pcm_buf;
	39	int fd;
	40	struct audio_pt pt;
	41	} ESDVoiceOut;
	42
	43	typedef struct {
	44	HWVoiceIn hw;
	45	int done;
	46	int dead;
	47	int incr;
	48	int wpos;
	49	void *pcm_buf;
	50	int fd;
	51	struct audio_pt pt;
	52	} ESDVoiceIn;
	53
	54	static struct {
	55	int samples;
	56	int divisor;
	57	char *dac_host;
	58	char *adc_host;
	59	} conf = {
1a40d5e2 JQ	60	.samples = 1024,
1a40d5e2 JQ	61	.divisor = 2,
ca9cc28c AZ	62	};
	63
	64	static void GCC_FMT_ATTR (2, 3) qesd_logerr (int err, const char *fmt, ...)
	65	{
	66	va_list ap;
	67
	68	va_start (ap, fmt);
	69	AUD_vlog (AUDIO_CAP, fmt, ap);
	70	va_end (ap);
	71
	72	AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
	73	}
	74
	75	/* playback */
	76	static void qesd_thread_out (void arg)
	77	{
	78	ESDVoiceOut *esd = arg;
	79	HWVoiceOut *hw = &esd->hw;
	80	int threshold;
	81
	82	threshold = conf.divisor ? hw->samples / conf.divisor : 0;
	83
deb9d2ee AZ	84	if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
	85	return NULL;
	86	}
	87
ca9cc28c AZ	88	for (;;) {
	89	int decr, to_mix, rpos;
	90
	91	for (;;) {
	92	if (esd->done) {
	93	goto exit;
	94	}
	95
	96	if (esd->live > threshold) {
	97	break;
	98	}
	99
	100	if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
	101	goto exit;
	102	}
	103	}
	104
	105	decr = to_mix = esd->live;
	106	rpos = hw->rpos;
	107
	108	if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
	109	return NULL;
	110	}
	111
	112	while (to_mix) {
	113	ssize_t written;
	114	int chunk = audio_MIN (to_mix, hw->samples - rpos);
1ea879e5	115	struct st_sample *src = hw->mix_buf + rpos;
ca9cc28c AZ	116
	117	hw->clip (esd->pcm_buf, src, chunk);
	118
	119	again:
	120	written = write (esd->fd, esd->pcm_buf, chunk << hw->info.shift);
	121	if (written == -1) {
	122	if (errno == EINTR \|\| errno == EAGAIN) {
	123	goto again;
	124	}
	125	qesd_logerr (errno, "write failed\n");
	126	return NULL;
	127	}
	128
	129	if (written != chunk << hw->info.shift) {
	130	int wsamples = written >> hw->info.shift;
	131	int wbytes = wsamples << hw->info.shift;
	132	if (wbytes != written) {
f9c7b77c	133	dolog ("warning: Misaligned write %d (requested %zd), "
ca9cc28c AZ	134	"alignment %d\n",
	135	wbytes, written, hw->info.align + 1);
	136	}
	137	to_mix -= wsamples;
	138	rpos = (rpos + wsamples) % hw->samples;
	139	break;
	140	}
	141
	142	rpos = (rpos + chunk) % hw->samples;
	143	to_mix -= chunk;
	144	}
	145
	146	if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
	147	return NULL;
	148	}
	149
	150	esd->rpos = rpos;
	151	esd->live -= decr;
	152	esd->decr += decr;
	153	}
	154
	155	exit:
	156	audio_pt_unlock (&esd->pt, AUDIO_FUNC);
	157	return NULL;
	158	}
	159
bdff253c	160	static int qesd_run_out (HWVoiceOut *hw, int live)
ca9cc28c	161	{
bdff253c	162	int decr;
ca9cc28c AZ	163	ESDVoiceOut esd = (ESDVoiceOut ) hw;
	164
	165	if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
	166	return 0;
	167	}
	168
ca9cc28c AZ	169	decr = audio_MIN (live, esd->decr);
	170	esd->decr -= decr;
	171	esd->live = live - decr;
	172	hw->rpos = esd->rpos;
	173	if (esd->live > 0) {
	174	audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
	175	}
	176	else {
	177	audio_pt_unlock (&esd->pt, AUDIO_FUNC);
	178	}
	179	return decr;
	180	}
	181
	182	static int qesd_write (SWVoiceOut sw, void buf, int len)
	183	{
	184	return audio_pcm_sw_write (sw, buf, len);
	185	}
	186
1ea879e5	187	static int qesd_init_out (HWVoiceOut hw, struct audsettings as)
ca9cc28c AZ	188	{
ca9cc28c AZ	189	ESDVoiceOut esd = (ESDVoiceOut ) hw;
1ea879e5	190	struct audsettings obt_as = *as;
ca9cc28c	191	int esdfmt = ESD_STREAM \| ESD_PLAY;
ca9cc28c AZ	192
	193	esdfmt \|= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
	194	switch (as->fmt) {
	195	case AUD_FMT_S8:
	196	case AUD_FMT_U8:
	197	esdfmt \|= ESD_BITS8;
	198	obt_as.fmt = AUD_FMT_U8;
	199	break;
	200
	201	case AUD_FMT_S32:
	202	case AUD_FMT_U32:
	203	dolog ("Will use 16 instead of 32 bit samples\n");
b4bd0b16	204	/* fall through */
ca9cc28c AZ	205	case AUD_FMT_S16:
	206	case AUD_FMT_U16:
	207	deffmt:
	208	esdfmt \|= ESD_BITS16;
	209	obt_as.fmt = AUD_FMT_S16;
	210	break;
	211
	212	default:
	213	dolog ("Internal logic error: Bad audio format %d\n", as->fmt);
ca9cc28c AZ	214	goto deffmt;
	215
	216	}
deb9d2ee	217	obt_as.endianness = AUDIO_HOST_ENDIANNESS;
ca9cc28c AZ	218
	219	audio_pcm_init_info (&hw->info, &obt_as);
	220
	221	hw->samples = conf.samples;
	222	esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
	223	if (!esd->pcm_buf) {
	224	dolog ("Could not allocate buffer (%d bytes)\n",
	225	hw->samples << hw->info.shift);
	226	return -1;
	227	}
	228
ca9cc28c AZ	229	esd->fd = esd_play_stream (esdfmt, as->freq, conf.dac_host, NULL);
	230	if (esd->fd < 0) {
	231	qesd_logerr (errno, "esd_play_stream failed\n");
4b7c0418	232	goto fail1;
ca9cc28c AZ	233	}
	234
	235	if (audio_pt_init (&esd->pt, qesd_thread_out, esd, AUDIO_CAP, AUDIO_FUNC)) {
4b7c0418	236	goto fail2;
ca9cc28c AZ	237	}
	238
	239	return 0;
	240
4b7c0418	241	fail2:
ca9cc28c AZ	242	if (close (esd->fd)) {
	243	qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
	244	AUDIO_FUNC, esd->fd);
	245	}
	246	esd->fd = -1;
	247
ca9cc28c	248	fail1:
7267c094	249	g_free (esd->pcm_buf);
ca9cc28c AZ	250	esd->pcm_buf = NULL;
	251	return -1;
	252	}
	253
	254	static void qesd_fini_out (HWVoiceOut *hw)
	255	{
	256	void *ret;
	257	ESDVoiceOut esd = (ESDVoiceOut ) hw;
	258
	259	audio_pt_lock (&esd->pt, AUDIO_FUNC);
	260	esd->done = 1;
	261	audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
	262	audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);
	263
	264	if (esd->fd >= 0) {
	265	if (close (esd->fd)) {
	266	qesd_logerr (errno, "failed to close esd socket\n");
	267	}
	268	esd->fd = -1;
	269	}
	270
	271	audio_pt_fini (&esd->pt, AUDIO_FUNC);
	272
7267c094	273	g_free (esd->pcm_buf);
ca9cc28c AZ	274	esd->pcm_buf = NULL;
	275	}
	276
	277	static int qesd_ctl_out (HWVoiceOut *hw, int cmd, ...)
	278	{
	279	(void) hw;
	280	(void) cmd;
	281	return 0;
	282	}
	283
	284	/* capture */
	285	static void qesd_thread_in (void arg)
	286	{
	287	ESDVoiceIn *esd = arg;
	288	HWVoiceIn *hw = &esd->hw;
	289	int threshold;
	290
	291	threshold = conf.divisor ? hw->samples / conf.divisor : 0;
	292
deb9d2ee AZ	293	if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
	294	return NULL;
	295	}
	296
ca9cc28c AZ	297	for (;;) {
	298	int incr, to_grab, wpos;
	299
	300	for (;;) {
	301	if (esd->done) {
	302	goto exit;
	303	}
	304
	305	if (esd->dead > threshold) {
	306	break;
	307	}
	308
	309	if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
	310	goto exit;
	311	}
	312	}
	313
	314	incr = to_grab = esd->dead;
	315	wpos = hw->wpos;
	316
	317	if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
	318	return NULL;
	319	}
	320
	321	while (to_grab) {
	322	ssize_t nread;
	323	int chunk = audio_MIN (to_grab, hw->samples - wpos);
	324	void *buf = advance (esd->pcm_buf, wpos);
	325
	326	again:
	327	nread = read (esd->fd, buf, chunk << hw->info.shift);
	328	if (nread == -1) {
	329	if (errno == EINTR \|\| errno == EAGAIN) {
	330	goto again;
	331	}
	332	qesd_logerr (errno, "read failed\n");
	333	return NULL;
	334	}
	335
	336	if (nread != chunk << hw->info.shift) {
	337	int rsamples = nread >> hw->info.shift;
	338	int rbytes = rsamples << hw->info.shift;
	339	if (rbytes != nread) {
f9c7b77c	340	dolog ("warning: Misaligned write %d (requested %zd), "
ca9cc28c AZ	341	"alignment %d\n",
	342	rbytes, nread, hw->info.align + 1);
	343	}
	344	to_grab -= rsamples;
	345	wpos = (wpos + rsamples) % hw->samples;
	346	break;
	347	}
	348
00e07679	349	hw->conv (hw->conv_buf + wpos, buf, nread >> hw->info.shift);
ca9cc28c AZ	350	wpos = (wpos + chunk) % hw->samples;
	351	to_grab -= chunk;
	352	}
	353
	354	if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
	355	return NULL;
	356	}
	357
	358	esd->wpos = wpos;
	359	esd->dead -= incr;
	360	esd->incr += incr;
	361	}
	362
	363	exit:
	364	audio_pt_unlock (&esd->pt, AUDIO_FUNC);
	365	return NULL;
	366	}
	367
	368	static int qesd_run_in (HWVoiceIn *hw)
	369	{
	370	int live, incr, dead;
	371	ESDVoiceIn esd = (ESDVoiceIn ) hw;
	372
	373	if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
	374	return 0;
	375	}
	376
	377	live = audio_pcm_hw_get_live_in (hw);
	378	dead = hw->samples - live;
	379	incr = audio_MIN (dead, esd->incr);
	380	esd->incr -= incr;
	381	esd->dead = dead - incr;
	382	hw->wpos = esd->wpos;
	383	if (esd->dead > 0) {
	384	audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
	385	}
	386	else {
	387	audio_pt_unlock (&esd->pt, AUDIO_FUNC);
	388	}
	389	return incr;
	390	}
	391
	392	static int qesd_read (SWVoiceIn sw, void buf, int len)
	393	{
	394	return audio_pcm_sw_read (sw, buf, len);
	395	}
	396
1ea879e5	397	static int qesd_init_in (HWVoiceIn hw, struct audsettings as)
ca9cc28c AZ	398	{
ca9cc28c AZ	399	ESDVoiceIn esd = (ESDVoiceIn ) hw;
1ea879e5	400	struct audsettings obt_as = *as;
ca9cc28c	401	int esdfmt = ESD_STREAM \| ESD_RECORD;
ca9cc28c AZ	402
	403	esdfmt \|= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
	404	switch (as->fmt) {
	405	case AUD_FMT_S8:
	406	case AUD_FMT_U8:
	407	esdfmt \|= ESD_BITS8;
	408	obt_as.fmt = AUD_FMT_U8;
	409	break;
	410
	411	case AUD_FMT_S16:
	412	case AUD_FMT_U16:
	413	esdfmt \|= ESD_BITS16;
	414	obt_as.fmt = AUD_FMT_S16;
	415	break;
	416
	417	case AUD_FMT_S32:
	418	case AUD_FMT_U32:
	419	dolog ("Will use 16 instead of 32 bit samples\n");
	420	esdfmt \|= ESD_BITS16;
	421	obt_as.fmt = AUD_FMT_S16;
	422	break;
	423	}
deb9d2ee	424	obt_as.endianness = AUDIO_HOST_ENDIANNESS;
ca9cc28c AZ	425
	426	audio_pcm_init_info (&hw->info, &obt_as);
	427
	428	hw->samples = conf.samples;
	429	esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
	430	if (!esd->pcm_buf) {
	431	dolog ("Could not allocate buffer (%d bytes)\n",
	432	hw->samples << hw->info.shift);
	433	return -1;
	434	}
	435
ca9cc28c AZ	436	esd->fd = esd_record_stream (esdfmt, as->freq, conf.adc_host, NULL);
	437	if (esd->fd < 0) {
	438	qesd_logerr (errno, "esd_record_stream failed\n");
4b7c0418	439	goto fail1;
ca9cc28c AZ	440	}
	441
	442	if (audio_pt_init (&esd->pt, qesd_thread_in, esd, AUDIO_CAP, AUDIO_FUNC)) {
4b7c0418	443	goto fail2;
ca9cc28c AZ	444	}
	445
	446	return 0;
	447
4b7c0418	448	fail2:
ca9cc28c AZ	449	if (close (esd->fd)) {
	450	qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
	451	AUDIO_FUNC, esd->fd);
	452	}
	453	esd->fd = -1;
	454
ca9cc28c	455	fail1:
7267c094	456	g_free (esd->pcm_buf);
ca9cc28c AZ	457	esd->pcm_buf = NULL;
	458	return -1;
	459	}
	460
	461	static void qesd_fini_in (HWVoiceIn *hw)
	462	{
	463	void *ret;
	464	ESDVoiceIn esd = (ESDVoiceIn ) hw;
	465
	466	audio_pt_lock (&esd->pt, AUDIO_FUNC);
	467	esd->done = 1;
	468	audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
	469	audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);
	470
	471	if (esd->fd >= 0) {
	472	if (close (esd->fd)) {
	473	qesd_logerr (errno, "failed to close esd socket\n");
	474	}
	475	esd->fd = -1;
	476	}
	477
	478	audio_pt_fini (&esd->pt, AUDIO_FUNC);
	479
7267c094	480	g_free (esd->pcm_buf);
ca9cc28c AZ	481	esd->pcm_buf = NULL;
	482	}
	483
	484	static int qesd_ctl_in (HWVoiceIn *hw, int cmd, ...)
	485	{
	486	(void) hw;
	487	(void) cmd;
	488	return 0;
	489	}
	490
	491	/* common */
	492	static void *qesd_audio_init (void)
	493	{
	494	return &conf;
	495	}
	496
	497	static void qesd_audio_fini (void *opaque)
	498	{
	499	(void) opaque;
	500	ldebug ("esd_fini");
	501	}
	502
	503	struct audio_option qesd_options[] = {
98f9f48c	504	{
	505	.name = "SAMPLES",
	506	.tag = AUD_OPT_INT,
	507	.valp = &conf.samples,
	508	.descr = "buffer size in samples"
	509	},
	510	{
	511	.name = "DIVISOR",
	512	.tag = AUD_OPT_INT,
	513	.valp = &conf.divisor,
	514	.descr = "threshold divisor"
	515	},
	516	{
	517	.name = "DAC_HOST",
	518	.tag = AUD_OPT_STR,
	519	.valp = &conf.dac_host,
	520	.descr = "playback host"
	521	},
	522	{
	523	.name = "ADC_HOST",
	524	.tag = AUD_OPT_STR,
	525	.valp = &conf.adc_host,
	526	.descr = "capture host"
	527	},
2700efa3	528	{ /* End of list */ }
ca9cc28c AZ	529	};
ca9cc28c AZ	530
35f4b58c	531	static struct audio_pcm_ops qesd_pcm_ops = {
1dd3e4d1 JQ	532	.init_out = qesd_init_out,
	533	.fini_out = qesd_fini_out,
	534	.run_out = qesd_run_out,
	535	.write = qesd_write,
	536	.ctl_out = qesd_ctl_out,
	537
	538	.init_in = qesd_init_in,
	539	.fini_in = qesd_fini_in,
	540	.run_in = qesd_run_in,
	541	.read = qesd_read,
	542	.ctl_in = qesd_ctl_in,
ca9cc28c AZ	543	};
	544
	545	struct audio_driver esd_audio_driver = {
bee37f32 JQ	546	.name = "esd",
	547	.descr = "http://en.wikipedia.org/wiki/Esound",
	548	.options = qesd_options,
	549	.init = qesd_audio_init,
	550	.fini = qesd_audio_fini,
	551	.pcm_ops = &qesd_pcm_ops,
	552	.can_be_default = 0,
	553	.max_voices_out = INT_MAX,
	554	.max_voices_in = INT_MAX,
	555	.voice_size_out = sizeof (ESDVoiceOut),
	556	.voice_size_in = sizeof (ESDVoiceIn)
ca9cc28c	557	};