Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libsndio/sio_aucat.c	Lines:	0	242	0.0 %
Date:	2017-11-07	Branches:	0	145	0.0 %


/*	$OpenBSD: sio_aucat.c,v 1.20 2016/01/09 08:27:24 ratchov Exp $	*/
/*
 * Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>

#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "aucat.h"
#include "debug.h"
#include "sio_priv.h"

struct sio_aucat_hdl {
	struct sio_hdl sio;
	struct aucat aucat;
	unsigned int rbpf, wbpf;	/* read and write bytes-per-frame */
	int events;			/* events the user requested */
	unsigned int curvol, reqvol;	/* current and requested volume */
	int delta;			/* some of received deltas */
#define PSTATE_INIT	0
#define PSTATE_RUN	1
	int pstate;
	size_t round;	       		/* write block size */
	size_t walign;			/* align write packets size to this */
};

static void sio_aucat_close(struct sio_hdl *);
static int sio_aucat_start(struct sio_hdl *);
static int sio_aucat_stop(struct sio_hdl *);
static int sio_aucat_setpar(struct sio_hdl *, struct sio_par *);
static int sio_aucat_getpar(struct sio_hdl *, struct sio_par *);
static int sio_aucat_getcap(struct sio_hdl *, struct sio_cap *);
static size_t sio_aucat_read(struct sio_hdl *, void *, size_t);
static size_t sio_aucat_write(struct sio_hdl *, const void *, size_t);
static int sio_aucat_nfds(struct sio_hdl *);
static int sio_aucat_pollfd(struct sio_hdl *, struct pollfd *, int);
static int sio_aucat_revents(struct sio_hdl *, struct pollfd *);
static int sio_aucat_setvol(struct sio_hdl *, unsigned int);
static void sio_aucat_getvol(struct sio_hdl *);

static struct sio_ops sio_aucat_ops = {
	sio_aucat_close,
	sio_aucat_setpar,
	sio_aucat_getpar,
	sio_aucat_getcap,
	sio_aucat_write,
	sio_aucat_read,
	sio_aucat_start,
	sio_aucat_stop,
	sio_aucat_nfds,
	sio_aucat_pollfd,
	sio_aucat_revents,
	sio_aucat_setvol,
	sio_aucat_getvol
};

/*
 * execute the next message, return 0 if blocked
 */
static int
sio_aucat_runmsg(struct sio_aucat_hdl *hdl)
{
	int delta;
	unsigned int size, ctl;

	if (!_aucat_rmsg(&hdl->aucat, &hdl->sio.eof))
		return 0;
	switch (ntohl(hdl->aucat.rmsg.cmd)) {
	case AMSG_DATA:
		size = ntohl(hdl->aucat.rmsg.u.data.size);
		if (size == 0 || size % hdl->rbpf) {
			DPRINTF("sio_aucat_runmsg: bad data message\n");
			hdl->sio.eof = 1;
			return 0;
		}
		DPRINTFN(3, "aucat: data(%d)\n", size);
		return 1;
	case AMSG_FLOWCTL:
		delta = ntohl(hdl->aucat.rmsg.u.ts.delta);
		hdl->aucat.maxwrite += delta * (int)hdl->wbpf;
		DPRINTFN(3, "aucat: flowctl(%d), maxwrite = %d\n",
		    delta, hdl->aucat.maxwrite);
		break;
	case AMSG_MOVE:
		delta = ntohl(hdl->aucat.rmsg.u.ts.delta);
		hdl->delta += delta;
		DPRINTFN(3, "aucat: move(%d), delta = %d, maxwrite = %d\n",
		    delta, hdl->delta, hdl->aucat.maxwrite);
		if (hdl->delta >= 0) {
			_sio_onmove_cb(&hdl->sio, hdl->delta);
			hdl->delta = 0;
		}
		break;
	case AMSG_SETVOL:
		ctl = ntohl(hdl->aucat.rmsg.u.vol.ctl);
		hdl->curvol = hdl->reqvol = ctl;
		DPRINTFN(3, "aucat: setvol(%d)\n", ctl);
		_sio_onvol_cb(&hdl->sio, ctl);
		break;
	case AMSG_STOP:
		DPRINTFN(3, "aucat: stop()\n");
		hdl->pstate = PSTATE_INIT;
		break;
	default:
		DPRINTF("sio_aucat_runmsg: unhandled message %u\n",
		    hdl->aucat.rmsg.cmd);
		hdl->sio.eof = 1;
		return 0;
	}
	hdl->aucat.rstate = RSTATE_MSG;
	hdl->aucat.rtodo = sizeof(struct amsg);
	return 1;
}

static int
sio_aucat_buildmsg(struct sio_aucat_hdl *hdl)
{
	if (hdl->curvol != hdl->reqvol) {
		hdl->aucat.wstate = WSTATE_MSG;
		hdl->aucat.wtodo = sizeof(struct amsg);
		hdl->aucat.wmsg.cmd = htonl(AMSG_SETVOL);
		hdl->aucat.wmsg.u.vol.ctl = htonl(hdl->reqvol);
		hdl->curvol = hdl->reqvol;
		return _aucat_wmsg(&hdl->aucat, &hdl->sio.eof);
	}
	return 0;
}

struct sio_hdl *
_sio_aucat_open(const char *str, unsigned int mode, int nbio)
{
	struct sio_aucat_hdl *hdl;

	hdl = malloc(sizeof(struct sio_aucat_hdl));
	if (hdl == NULL)
		return NULL;
	if (!_aucat_open(&hdl->aucat, str, mode)) {
		free(hdl);
		return NULL;
	}
	_sio_create(&hdl->sio, &sio_aucat_ops, mode, nbio);
	hdl->curvol = SIO_MAXVOL;
	hdl->reqvol = SIO_MAXVOL;
	hdl->pstate = PSTATE_INIT;
	hdl->round = 0xdeadbeef;
	hdl->walign = 0xdeadbeef;
	return (struct sio_hdl *)hdl;
}

static void
sio_aucat_close(struct sio_hdl *sh)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	if (!hdl->sio.eof && hdl->sio.started)
		(void)sio_aucat_stop(&hdl->sio);
	_aucat_close(&hdl->aucat, hdl->sio.eof);
	free(hdl);
}

static int
sio_aucat_start(struct sio_hdl *sh)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	hdl->wbpf = hdl->sio.par.bps * hdl->sio.par.pchan;
	hdl->rbpf = hdl->sio.par.bps * hdl->sio.par.rchan;
	hdl->aucat.maxwrite = 0;
	hdl->round = hdl->sio.par.round;
	hdl->delta = 0;
	DPRINTFN(2, "aucat: start, maxwrite = %d\n", hdl->aucat.maxwrite);

	AMSG_INIT(&hdl->aucat.wmsg);
	hdl->aucat.wmsg.cmd = htonl(AMSG_START);
	hdl->aucat.wtodo = sizeof(struct amsg);
	if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
		return 0;
	hdl->aucat.rstate = RSTATE_MSG;
	hdl->aucat.rtodo = sizeof(struct amsg);
	if (!_aucat_setfl(&hdl->aucat, 1, &hdl->sio.eof))
		return 0;
	hdl->walign = hdl->round * hdl->wbpf;
	hdl->pstate = PSTATE_RUN;
	return 1;
}

static int
sio_aucat_stop(struct sio_hdl *sh)
{
#define ZERO_MAX 0x400
	static unsigned char zero[ZERO_MAX];
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;
	unsigned int n, count;

	if (!_aucat_setfl(&hdl->aucat, 0, &hdl->sio.eof))
		return 0;
	/*
	 * complete message or data block in progress
	 */
	if (hdl->aucat.wstate == WSTATE_MSG) {
		if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
			return 0;
	}
	if (hdl->aucat.wstate == WSTATE_DATA) {
		hdl->aucat.maxwrite = hdl->aucat.wtodo;
		while (hdl->aucat.wstate != WSTATE_IDLE) {
			count = hdl->aucat.wtodo;
			if (count > ZERO_MAX)
				count = ZERO_MAX;
			n = sio_aucat_write(&hdl->sio, zero, count);
			if (n == 0)
				return 0;
		}
	}

	/*
	 * send stop message
	 */
	AMSG_INIT(&hdl->aucat.wmsg);
	hdl->aucat.wmsg.cmd = htonl(AMSG_STOP);
	hdl->aucat.wtodo = sizeof(struct amsg);
	if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
		return 0;

	/*
	 * wait for the STOP ACK
	 */
	while (hdl->pstate != PSTATE_INIT) {
		switch (hdl->aucat.rstate) {
		case RSTATE_MSG:
			if (!sio_aucat_runmsg(hdl))
				return 0;
			break;
		case RSTATE_DATA:
			if (!sio_aucat_read(&hdl->sio, zero, ZERO_MAX))
				return 0;
			break;
		}
	}
	return 1;
}

static int
sio_aucat_setpar(struct sio_hdl *sh, struct sio_par *par)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	AMSG_INIT(&hdl->aucat.wmsg);
	hdl->aucat.wmsg.cmd = htonl(AMSG_SETPAR);
	hdl->aucat.wmsg.u.par.bits = par->bits;
	hdl->aucat.wmsg.u.par.bps = par->bps;
	hdl->aucat.wmsg.u.par.sig = par->sig;
	hdl->aucat.wmsg.u.par.le = par->le;
	hdl->aucat.wmsg.u.par.msb = par->msb;
	hdl->aucat.wmsg.u.par.rate = htonl(par->rate);
	hdl->aucat.wmsg.u.par.appbufsz = htonl(par->appbufsz);
	hdl->aucat.wmsg.u.par.xrun = par->xrun;
	if (hdl->sio.mode & SIO_REC)
		hdl->aucat.wmsg.u.par.rchan = htons(par->rchan);
	if (hdl->sio.mode & SIO_PLAY)
		hdl->aucat.wmsg.u.par.pchan = htons(par->pchan);
	hdl->aucat.wtodo = sizeof(struct amsg);
	if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
		return 0;
	return 1;
}

static int
sio_aucat_getpar(struct sio_hdl *sh, struct sio_par *par)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	AMSG_INIT(&hdl->aucat.wmsg);
	hdl->aucat.wmsg.cmd = htonl(AMSG_GETPAR);
	hdl->aucat.wtodo = sizeof(struct amsg);
	if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
		return 0;
	hdl->aucat.rtodo = sizeof(struct amsg);
	if (!_aucat_rmsg(&hdl->aucat, &hdl->sio.eof))
		return 0;
	if (ntohl(hdl->aucat.rmsg.cmd) != AMSG_GETPAR) {
		DPRINTF("sio_aucat_getpar: protocol err\n");
		hdl->sio.eof = 1;
		return 0;
	}
	par->bits = hdl->aucat.rmsg.u.par.bits;
	par->bps = hdl->aucat.rmsg.u.par.bps;
	par->sig = hdl->aucat.rmsg.u.par.sig;
	par->le = hdl->aucat.rmsg.u.par.le;
	par->msb = hdl->aucat.rmsg.u.par.msb;
	par->rate = ntohl(hdl->aucat.rmsg.u.par.rate);
	par->bufsz = ntohl(hdl->aucat.rmsg.u.par.bufsz);
	par->appbufsz = ntohl(hdl->aucat.rmsg.u.par.appbufsz);
	par->xrun = hdl->aucat.rmsg.u.par.xrun;
	par->round = ntohl(hdl->aucat.rmsg.u.par.round);
	if (hdl->sio.mode & SIO_PLAY)
		par->pchan = ntohs(hdl->aucat.rmsg.u.par.pchan);
	if (hdl->sio.mode & SIO_REC)
		par->rchan = ntohs(hdl->aucat.rmsg.u.par.rchan);
	return 1;
}

static int
sio_aucat_getcap(struct sio_hdl *sh, struct sio_cap *cap)
{
	unsigned int i, bps, le, sig, chan, rindex, rmult;
	static unsigned int rates[] = { 8000, 11025, 12000 };

	bps = 1;
	sig = le = 0;
	cap->confs[0].enc = 0;
	for (i = 0; i < SIO_NENC; i++) {
		if (bps > 4)
			break;
		cap->confs[0].enc |= 1 << i;
		cap->enc[i].bits = bps == 4 ? 24 : bps * 8;
		cap->enc[i].bps = bps;
		cap->enc[i].sig = sig ^ 1;
		cap->enc[i].le = bps > 1 ? le : SIO_LE_NATIVE;
		cap->enc[i].msb = 1;
		le++;
		if (le > 1 || bps == 1) {
			le = 0;
			sig++;
		}
		if (sig > 1 || (le == 0 && bps > 1)) {
			sig = 0;
			bps++;
		}
	}
	chan = 1;
	cap->confs[0].rchan = 0;
	for (i = 0; i < SIO_NCHAN; i++) {
		if (chan > 16)
			break;
		cap->confs[0].rchan |= 1 << i;
		cap->rchan[i] = chan;
		if (chan >= 12) {
			chan += 4;
		} else if (chan >= 2) {
			chan += 2;
		} else
			chan++;
	}
	chan = 1;
	cap->confs[0].pchan = 0;
	for (i = 0; i < SIO_NCHAN; i++) {
		if (chan > 16)
			break;
		cap->confs[0].pchan |= 1 << i;
		cap->pchan[i] = chan;
		if (chan >= 12) {
			chan += 4;
		} else if (chan >= 2) {
			chan += 2;
		} else
			chan++;
	}
	rindex = 0;
	rmult = 1;
	cap->confs[0].rate = 0;
	for (i = 0; i < SIO_NRATE; i++) {
		if (rmult >= 32)
			break;
		cap->rate[i] = rates[rindex] * rmult;
		cap->confs[0].rate |= 1 << i;
		rindex++;
		if (rindex == sizeof(rates) / sizeof(unsigned int)) {
			rindex = 0;
			rmult *= 2;
		}
	}
	cap->nconf = 1;
	return 1;
}

static size_t
sio_aucat_read(struct sio_hdl *sh, void *buf, size_t len)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	while (hdl->aucat.rstate == RSTATE_MSG) {
		if (!sio_aucat_runmsg(hdl))
			return 0;
	}
	return _aucat_rdata(&hdl->aucat, buf, len, &hdl->sio.eof);
}

static size_t
sio_aucat_write(struct sio_hdl *sh, const void *buf, size_t len)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;
	size_t n;

	while (hdl->aucat.wstate == WSTATE_IDLE) {
		if (!sio_aucat_buildmsg(hdl))
			break;
	}
	if (len <= 0 || hdl->aucat.maxwrite <= 0)
		return 0;
	if (len > hdl->aucat.maxwrite)
		len = hdl->aucat.maxwrite;
	if (len > hdl->walign)
		len = hdl->walign;
	n = _aucat_wdata(&hdl->aucat, buf, len, hdl->wbpf, &hdl->sio.eof);
	hdl->aucat.maxwrite -= n;
	hdl->walign -= n;
	if (hdl->walign == 0)
		hdl->walign = hdl->round * hdl->wbpf;
	return n;
}

static int
sio_aucat_nfds(struct sio_hdl *hdl)
{
	return 1;
 }

static int
sio_aucat_pollfd(struct sio_hdl *sh, struct pollfd *pfd, int events)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	hdl->events = events;
	if (hdl->aucat.maxwrite <= 0)
		events &= ~POLLOUT;
	return _aucat_pollfd(&hdl->aucat, pfd, events);
}

static int
sio_aucat_revents(struct sio_hdl *sh, struct pollfd *pfd)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;
	int revents = pfd->revents;

	if (revents & POLLIN) {
		while (hdl->aucat.rstate == RSTATE_MSG) {
			if (!sio_aucat_runmsg(hdl))
				break;
		}
		if (hdl->aucat.rstate != RSTATE_DATA)
			revents &= ~POLLIN;
	}
	if (revents & POLLOUT) {
		if (hdl->aucat.maxwrite <= 0)
			revents &= ~POLLOUT;
	}
	if (hdl->sio.eof)
		return POLLHUP;
	DPRINTFN(3, "sio_aucat_revents: %x\n", revents & hdl->events);
	return revents & (hdl->events | POLLHUP);
}

static int
sio_aucat_setvol(struct sio_hdl *sh, unsigned int vol)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	hdl->reqvol = vol;
	return 1;
}

static void
sio_aucat_getvol(struct sio_hdl *sh)
{
	struct sio_aucat_hdl *hdl = (struct sio_aucat_hdl *)sh;

	_sio_onvol_cb(&hdl->sio, hdl->reqvol);
	return;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: sio_aucat.c,v 1.20 2016/01/09 08:27:24 ratchov Exp $ */
2			/*
3			* Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/types.h>
19			#include <sys/socket.h>
20			#include <sys/un.h>
21			#include <netinet/in.h>
22
23			#include <errno.h>
24			#include <fcntl.h>
25			#include <poll.h>
26			#include <stdio.h>
27			#include <stdlib.h>
28			#include <string.h>
29			#include <unistd.h>
30
31			#include "aucat.h"
32			#include "debug.h"
33			#include "sio_priv.h"
34
35			struct sio_aucat_hdl {
36			struct sio_hdl sio;
37			struct aucat aucat;
38			unsigned int rbpf, wbpf; /* read and write bytes-per-frame */
39			int events; /* events the user requested */
40			unsigned int curvol, reqvol; /* current and requested volume */
41			int delta; /* some of received deltas */
42			#define PSTATE_INIT 0
43			#define PSTATE_RUN 1
44			int pstate;
45			size_t round; /* write block size */
46			size_t walign; /* align write packets size to this */
47			};
48
49			static void sio_aucat_close(struct sio_hdl *);
50			static int sio_aucat_start(struct sio_hdl *);
51			static int sio_aucat_stop(struct sio_hdl *);
52			static int sio_aucat_setpar(struct sio_hdl , struct sio_par );
53			static int sio_aucat_getpar(struct sio_hdl , struct sio_par );
54			static int sio_aucat_getcap(struct sio_hdl , struct sio_cap );
55			static size_t sio_aucat_read(struct sio_hdl , void , size_t);
56			static size_t sio_aucat_write(struct sio_hdl , const void , size_t);
57			static int sio_aucat_nfds(struct sio_hdl *);
58			static int sio_aucat_pollfd(struct sio_hdl , struct pollfd , int);
59			static int sio_aucat_revents(struct sio_hdl , struct pollfd );
60			static int sio_aucat_setvol(struct sio_hdl *, unsigned int);
61			static void sio_aucat_getvol(struct sio_hdl *);
62
63			static struct sio_ops sio_aucat_ops = {
64			sio_aucat_close,
65			sio_aucat_setpar,
66			sio_aucat_getpar,
67			sio_aucat_getcap,
68			sio_aucat_write,
69			sio_aucat_read,
70			sio_aucat_start,
71			sio_aucat_stop,
72			sio_aucat_nfds,
73			sio_aucat_pollfd,
74			sio_aucat_revents,
75			sio_aucat_setvol,
76			sio_aucat_getvol
77			};
78
79			/*
80			* execute the next message, return 0 if blocked
81			*/
82			static int
83			sio_aucat_runmsg(struct sio_aucat_hdl *hdl)
84			{
85			int delta;
86			unsigned int size, ctl;
87
88			if (!_aucat_rmsg(&hdl->aucat, &hdl->sio.eof))
89			return 0;
90			switch (ntohl(hdl->aucat.rmsg.cmd)) {
91			case AMSG_DATA:
92			size = ntohl(hdl->aucat.rmsg.u.data.size);
93			if (size == 0 \|\| size % hdl->rbpf) {
94			DPRINTF("sio_aucat_runmsg: bad data message\n");
95			hdl->sio.eof = 1;
96			return 0;
97			}
98			DPRINTFN(3, "aucat: data(%d)\n", size);
99			return 1;
100			case AMSG_FLOWCTL:
101			delta = ntohl(hdl->aucat.rmsg.u.ts.delta);
102			hdl->aucat.maxwrite += delta * (int)hdl->wbpf;
103			DPRINTFN(3, "aucat: flowctl(%d), maxwrite = %d\n",
104			delta, hdl->aucat.maxwrite);
105			break;
106			case AMSG_MOVE:
107			delta = ntohl(hdl->aucat.rmsg.u.ts.delta);
108			hdl->delta += delta;
109			DPRINTFN(3, "aucat: move(%d), delta = %d, maxwrite = %d\n",
110			delta, hdl->delta, hdl->aucat.maxwrite);
111			if (hdl->delta >= 0) {
112			_sio_onmove_cb(&hdl->sio, hdl->delta);
113			hdl->delta = 0;
114			}
115			break;
116			case AMSG_SETVOL:
117			ctl = ntohl(hdl->aucat.rmsg.u.vol.ctl);
118			hdl->curvol = hdl->reqvol = ctl;
119			DPRINTFN(3, "aucat: setvol(%d)\n", ctl);
120			_sio_onvol_cb(&hdl->sio, ctl);
121			break;
122			case AMSG_STOP:
123			DPRINTFN(3, "aucat: stop()\n");
124			hdl->pstate = PSTATE_INIT;
125			break;
126			default:
127			DPRINTF("sio_aucat_runmsg: unhandled message %u\n",
128			hdl->aucat.rmsg.cmd);
129			hdl->sio.eof = 1;
130			return 0;
131			}
132			hdl->aucat.rstate = RSTATE_MSG;
133			hdl->aucat.rtodo = sizeof(struct amsg);
134			return 1;
135			}
136
137			static int
138			sio_aucat_buildmsg(struct sio_aucat_hdl *hdl)
139			{
140			if (hdl->curvol != hdl->reqvol) {
141			hdl->aucat.wstate = WSTATE_MSG;
142			hdl->aucat.wtodo = sizeof(struct amsg);
143			hdl->aucat.wmsg.cmd = htonl(AMSG_SETVOL);
144			hdl->aucat.wmsg.u.vol.ctl = htonl(hdl->reqvol);
145			hdl->curvol = hdl->reqvol;
146			return _aucat_wmsg(&hdl->aucat, &hdl->sio.eof);
147			}
148			return 0;
149			}
150
151			struct sio_hdl *
152			_sio_aucat_open(const char *str, unsigned int mode, int nbio)
153			{
154			struct sio_aucat_hdl *hdl;
155
156			hdl = malloc(sizeof(struct sio_aucat_hdl));
157			if (hdl == NULL)
158			return NULL;
159			if (!_aucat_open(&hdl->aucat, str, mode)) {
160			free(hdl);
161			return NULL;
162			}
163			_sio_create(&hdl->sio, &sio_aucat_ops, mode, nbio);
164			hdl->curvol = SIO_MAXVOL;
165			hdl->reqvol = SIO_MAXVOL;
166			hdl->pstate = PSTATE_INIT;
167			hdl->round = 0xdeadbeef;
168			hdl->walign = 0xdeadbeef;
169			return (struct sio_hdl *)hdl;
170			}
171
172			static void
173			sio_aucat_close(struct sio_hdl *sh)
174			{
175			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
176
177			if (!hdl->sio.eof && hdl->sio.started)
178			(void)sio_aucat_stop(&hdl->sio);
179			_aucat_close(&hdl->aucat, hdl->sio.eof);
180			free(hdl);
181			}
182
183			static int
184			sio_aucat_start(struct sio_hdl *sh)
185			{
186			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
187
188			hdl->wbpf = hdl->sio.par.bps * hdl->sio.par.pchan;
189			hdl->rbpf = hdl->sio.par.bps * hdl->sio.par.rchan;
190			hdl->aucat.maxwrite = 0;
191			hdl->round = hdl->sio.par.round;
192			hdl->delta = 0;
193			DPRINTFN(2, "aucat: start, maxwrite = %d\n", hdl->aucat.maxwrite);
194
195			AMSG_INIT(&hdl->aucat.wmsg);
196			hdl->aucat.wmsg.cmd = htonl(AMSG_START);
197			hdl->aucat.wtodo = sizeof(struct amsg);
198			if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
199			return 0;
200			hdl->aucat.rstate = RSTATE_MSG;
201			hdl->aucat.rtodo = sizeof(struct amsg);
202			if (!_aucat_setfl(&hdl->aucat, 1, &hdl->sio.eof))
203			return 0;
204			hdl->walign = hdl->round * hdl->wbpf;
205			hdl->pstate = PSTATE_RUN;
206			return 1;
207			}
208
209			static int
210			sio_aucat_stop(struct sio_hdl *sh)
211			{
212			#define ZERO_MAX 0x400
213			static unsigned char zero[ZERO_MAX];
214			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
215			unsigned int n, count;
216
217			if (!_aucat_setfl(&hdl->aucat, 0, &hdl->sio.eof))
218			return 0;
219			/*
220			* complete message or data block in progress
221			*/
222			if (hdl->aucat.wstate == WSTATE_MSG) {
223			if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
224			return 0;
225			}
226			if (hdl->aucat.wstate == WSTATE_DATA) {
227			hdl->aucat.maxwrite = hdl->aucat.wtodo;
228			while (hdl->aucat.wstate != WSTATE_IDLE) {
229			count = hdl->aucat.wtodo;
230			if (count > ZERO_MAX)
231			count = ZERO_MAX;
232			n = sio_aucat_write(&hdl->sio, zero, count);
233			if (n == 0)
234			return 0;
235			}
236			}
237
238			/*
239			* send stop message
240			*/
241			AMSG_INIT(&hdl->aucat.wmsg);
242			hdl->aucat.wmsg.cmd = htonl(AMSG_STOP);
243			hdl->aucat.wtodo = sizeof(struct amsg);
244			if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
245			return 0;
246
247			/*
248			* wait for the STOP ACK
249			*/
250			while (hdl->pstate != PSTATE_INIT) {
251			switch (hdl->aucat.rstate) {
252			case RSTATE_MSG:
253			if (!sio_aucat_runmsg(hdl))
254			return 0;
255			break;
256			case RSTATE_DATA:
257			if (!sio_aucat_read(&hdl->sio, zero, ZERO_MAX))
258			return 0;
259			break;
260			}
261			}
262			return 1;
263			}
264
265			static int
266			sio_aucat_setpar(struct sio_hdl sh, struct sio_par par)
267			{
268			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
269
270			AMSG_INIT(&hdl->aucat.wmsg);
271			hdl->aucat.wmsg.cmd = htonl(AMSG_SETPAR);
272			hdl->aucat.wmsg.u.par.bits = par->bits;
273			hdl->aucat.wmsg.u.par.bps = par->bps;
274			hdl->aucat.wmsg.u.par.sig = par->sig;
275			hdl->aucat.wmsg.u.par.le = par->le;
276			hdl->aucat.wmsg.u.par.msb = par->msb;
277			hdl->aucat.wmsg.u.par.rate = htonl(par->rate);
278			hdl->aucat.wmsg.u.par.appbufsz = htonl(par->appbufsz);
279			hdl->aucat.wmsg.u.par.xrun = par->xrun;
280			if (hdl->sio.mode & SIO_REC)
281			hdl->aucat.wmsg.u.par.rchan = htons(par->rchan);
282			if (hdl->sio.mode & SIO_PLAY)
283			hdl->aucat.wmsg.u.par.pchan = htons(par->pchan);
284			hdl->aucat.wtodo = sizeof(struct amsg);
285			if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
286			return 0;
287			return 1;
288			}
289
290			static int
291			sio_aucat_getpar(struct sio_hdl sh, struct sio_par par)
292			{
293			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
294
295			AMSG_INIT(&hdl->aucat.wmsg);
296			hdl->aucat.wmsg.cmd = htonl(AMSG_GETPAR);
297			hdl->aucat.wtodo = sizeof(struct amsg);
298			if (!_aucat_wmsg(&hdl->aucat, &hdl->sio.eof))
299			return 0;
300			hdl->aucat.rtodo = sizeof(struct amsg);
301			if (!_aucat_rmsg(&hdl->aucat, &hdl->sio.eof))
302			return 0;
303			if (ntohl(hdl->aucat.rmsg.cmd) != AMSG_GETPAR) {
304			DPRINTF("sio_aucat_getpar: protocol err\n");
305			hdl->sio.eof = 1;
306			return 0;
307			}
308			par->bits = hdl->aucat.rmsg.u.par.bits;
309			par->bps = hdl->aucat.rmsg.u.par.bps;
310			par->sig = hdl->aucat.rmsg.u.par.sig;
311			par->le = hdl->aucat.rmsg.u.par.le;
312			par->msb = hdl->aucat.rmsg.u.par.msb;
313			par->rate = ntohl(hdl->aucat.rmsg.u.par.rate);
314			par->bufsz = ntohl(hdl->aucat.rmsg.u.par.bufsz);
315			par->appbufsz = ntohl(hdl->aucat.rmsg.u.par.appbufsz);
316			par->xrun = hdl->aucat.rmsg.u.par.xrun;
317			par->round = ntohl(hdl->aucat.rmsg.u.par.round);
318			if (hdl->sio.mode & SIO_PLAY)
319			par->pchan = ntohs(hdl->aucat.rmsg.u.par.pchan);
320			if (hdl->sio.mode & SIO_REC)
321			par->rchan = ntohs(hdl->aucat.rmsg.u.par.rchan);
322			return 1;
323			}
324
325			static int
326			sio_aucat_getcap(struct sio_hdl sh, struct sio_cap cap)
327			{
328			unsigned int i, bps, le, sig, chan, rindex, rmult;
329			static unsigned int rates[] = { 8000, 11025, 12000 };
330
331			bps = 1;
332			sig = le = 0;
333			cap->confs[0].enc = 0;
334			for (i = 0; i < SIO_NENC; i++) {
335			if (bps > 4)
336			break;
337			cap->confs[0].enc \|= 1 << i;
338			cap->enc[i].bits = bps == 4 ? 24 : bps * 8;
339			cap->enc[i].bps = bps;
340			cap->enc[i].sig = sig ^ 1;
341			cap->enc[i].le = bps > 1 ? le : SIO_LE_NATIVE;
342			cap->enc[i].msb = 1;
343			le++;
344			if (le > 1 \|\| bps == 1) {
345			le = 0;
346			sig++;
347			}
348			if (sig > 1 \|\| (le == 0 && bps > 1)) {
349			sig = 0;
350			bps++;
351			}
352			}
353			chan = 1;
354			cap->confs[0].rchan = 0;
355			for (i = 0; i < SIO_NCHAN; i++) {
356			if (chan > 16)
357			break;
358			cap->confs[0].rchan \|= 1 << i;
359			cap->rchan[i] = chan;
360			if (chan >= 12) {
361			chan += 4;
362			} else if (chan >= 2) {
363			chan += 2;
364			} else
365			chan++;
366			}
367			chan = 1;
368			cap->confs[0].pchan = 0;
369			for (i = 0; i < SIO_NCHAN; i++) {
370			if (chan > 16)
371			break;
372			cap->confs[0].pchan \|= 1 << i;
373			cap->pchan[i] = chan;
374			if (chan >= 12) {
375			chan += 4;
376			} else if (chan >= 2) {
377			chan += 2;
378			} else
379			chan++;
380			}
381			rindex = 0;
382			rmult = 1;
383			cap->confs[0].rate = 0;
384			for (i = 0; i < SIO_NRATE; i++) {
385			if (rmult >= 32)
386			break;
387			cap->rate[i] = rates[rindex] * rmult;
388			cap->confs[0].rate \|= 1 << i;
389			rindex++;
390			if (rindex == sizeof(rates) / sizeof(unsigned int)) {
391			rindex = 0;
392			rmult *= 2;
393			}
394			}
395			cap->nconf = 1;
396			return 1;
397			}
398
399			static size_t
400			sio_aucat_read(struct sio_hdl sh, void buf, size_t len)
401			{
402			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
403
404			while (hdl->aucat.rstate == RSTATE_MSG) {
405			if (!sio_aucat_runmsg(hdl))
406			return 0;
407			}
408			return _aucat_rdata(&hdl->aucat, buf, len, &hdl->sio.eof);
409			}
410
411			static size_t
412			sio_aucat_write(struct sio_hdl sh, const void buf, size_t len)
413			{
414			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
415			size_t n;
416
417			while (hdl->aucat.wstate == WSTATE_IDLE) {
418			if (!sio_aucat_buildmsg(hdl))
419			break;
420			}
421			if (len <= 0 \|\| hdl->aucat.maxwrite <= 0)
422			return 0;
423			if (len > hdl->aucat.maxwrite)
424			len = hdl->aucat.maxwrite;
425			if (len > hdl->walign)
426			len = hdl->walign;
427			n = _aucat_wdata(&hdl->aucat, buf, len, hdl->wbpf, &hdl->sio.eof);
428			hdl->aucat.maxwrite -= n;
429			hdl->walign -= n;
430			if (hdl->walign == 0)
431			hdl->walign = hdl->round * hdl->wbpf;
432			return n;
433			}
434
435			static int
436			sio_aucat_nfds(struct sio_hdl *hdl)
437			{
438			return 1;
439			}
440
441			static int
442			sio_aucat_pollfd(struct sio_hdl sh, struct pollfd pfd, int events)
443			{
444			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
445
446			hdl->events = events;
447			if (hdl->aucat.maxwrite <= 0)
448			events &= ~POLLOUT;
449			return _aucat_pollfd(&hdl->aucat, pfd, events);
450			}
451
452			static int
453			sio_aucat_revents(struct sio_hdl sh, struct pollfd pfd)
454			{
455			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
456			int revents = pfd->revents;
457
458			if (revents & POLLIN) {
459			while (hdl->aucat.rstate == RSTATE_MSG) {
460			if (!sio_aucat_runmsg(hdl))
461			break;
462			}
463			if (hdl->aucat.rstate != RSTATE_DATA)
464			revents &= ~POLLIN;
465			}
466			if (revents & POLLOUT) {
467			if (hdl->aucat.maxwrite <= 0)
468			revents &= ~POLLOUT;
469			}
470			if (hdl->sio.eof)
471			return POLLHUP;
472			DPRINTFN(3, "sio_aucat_revents: %x\n", revents & hdl->events);
473			return revents & (hdl->events \| POLLHUP);
474			}
475
476			static int
477			sio_aucat_setvol(struct sio_hdl *sh, unsigned int vol)
478			{
479			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
480
481			hdl->reqvol = vol;
482			return 1;
483			}
484
485			static void
486			sio_aucat_getvol(struct sio_hdl *sh)
487			{
488			struct sio_aucat_hdl hdl = (struct sio_aucat_hdl )sh;
489
490			_sio_onvol_cb(&hdl->sio, hdl->reqvol);
491			return;
492			}