Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libsndio/sio_sun.c	Lines:	0	305	0.0 %
Date:	2017-11-07	Branches:	0	234	0.0 %


/*	$OpenBSD: sio_sun.c,v 1.26 2016/04/07 06:30:13 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/ioctl.h>
#include <sys/audioio.h>
#include <sys/stat.h>

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

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

#define DEVPATH_PREFIX	"/dev/audio"
#define DEVPATH_MAX 	(1 +		\
	sizeof(DEVPATH_PREFIX) - 1 +	\
	sizeof(int) * 3)

struct sio_sun_hdl {
	struct sio_hdl sio;
	int fd;
	int filling;
	unsigned int ibpf, obpf;	/* bytes per frame */
	unsigned int ibytes, obytes;	/* bytes the hw transferred */
	unsigned int ierr, oerr;	/* frames the hw dropped */
	int idelta, odelta;		/* position reported to client */
};

static void sio_sun_close(struct sio_hdl *);
static int sio_sun_start(struct sio_hdl *);
static int sio_sun_stop(struct sio_hdl *);
static int sio_sun_setpar(struct sio_hdl *, struct sio_par *);
static int sio_sun_getpar(struct sio_hdl *, struct sio_par *);
static int sio_sun_getcap(struct sio_hdl *, struct sio_cap *);
static size_t sio_sun_read(struct sio_hdl *, void *, size_t);
static size_t sio_sun_write(struct sio_hdl *, const void *, size_t);
static int sio_sun_nfds(struct sio_hdl *);
static int sio_sun_pollfd(struct sio_hdl *, struct pollfd *, int);
static int sio_sun_revents(struct sio_hdl *, struct pollfd *);

static struct sio_ops sio_sun_ops = {
	sio_sun_close,
	sio_sun_setpar,
	sio_sun_getpar,
	sio_sun_getcap,
	sio_sun_write,
	sio_sun_read,
	sio_sun_start,
	sio_sun_stop,
	sio_sun_nfds,
	sio_sun_pollfd,
	sio_sun_revents,
	NULL, /* setvol */
	NULL, /* getvol */
};

static int
sio_sun_adjpar(struct sio_sun_hdl *hdl, struct audio_swpar *ap)
{
	if (hdl->sio.eof)
		return 0;
	if (ioctl(hdl->fd, AUDIO_SETPAR, ap)) {
		DPERROR("AUDIO_SETPAR");
		hdl->sio.eof = 1;
		return 0;
	}
	if (ioctl(hdl->fd, AUDIO_GETPAR, ap)) {
		DPERROR("AUDIO_GETPAR");
		hdl->sio.eof = 1;
		return 0;
	}
	return 1;
}

/*
 * try to set the device to the given parameters and check that the
 * device can use them; return 1 on success, 0 on failure or error
 */
static int
sio_sun_testpar(struct sio_sun_hdl *hdl, struct sio_enc *enc,
    unsigned int pchan, unsigned int rchan, unsigned int rate)
{
	struct audio_swpar ap;

	AUDIO_INITPAR(&ap);
	if (enc != NULL) {
		ap.sig = enc->sig;
		ap.bits = enc->bits;
		ap.bps = enc->bps;
		if (ap.bps > 1)
			ap.le = enc->le;
		if (ap.bps * 8 > ap.bits)
			ap.msb = enc->msb;
	}
	if (rate)
		ap.rate = rate;
	if (pchan && (hdl->sio.mode & SIO_PLAY))
		ap.pchan = pchan;
	if (rchan && (hdl->sio.mode & SIO_REC))
		ap.rchan = rchan;
	if (!sio_sun_adjpar(hdl, &ap))
		return 0;
	if (pchan && ap.pchan != pchan)
		return 0;
	if (rchan && ap.rchan != rchan)
		return 0;
	if (rate && ap.rate != rate)
		return 0;
	if (enc) {
		if (ap.sig != enc->sig)
			return 0;
		if (ap.bits != enc->bits)
			return 0;
		if (ap.bps != enc->bps)
			return 0;
		if (ap.bps > 1 && ap.le != enc->le)
			return 0;
		if (ap.bits < ap.bps * 8 && ap.msb != enc->msb)
			return 0;
	}
	return 1;
}

/*
 * guess device capabilities
 */
static int
sio_sun_getcap(struct sio_hdl *sh, struct sio_cap *cap)
{
	static unsigned int chans[] = {
		1, 2, 4, 6, 8, 10, 12
	};
	static unsigned int rates[] = {
		8000, 11025, 12000, 16000, 22050, 24000,
		32000, 44100, 48000, 64000, 88200, 96000
	};
	static unsigned int encs[] = {
		8, 16, 24, 32
	};
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
	struct audio_swpar savepar, ap;
	unsigned int nconf = 0;
	unsigned int enc_map = 0, rchan_map = 0, pchan_map = 0, rate_map;
	unsigned int i, j, conf;

	if (ioctl(hdl->fd, AUDIO_GETPAR, &savepar)) {
		DPERROR("AUDIO_GETPAR");
		hdl->sio.eof = 1;
		return 0;
	}

	/*
	 * get a subset of supported encodings
	 */
	for (i = 0; i < sizeof(encs) / sizeof(encs[0]); i++) {
		AUDIO_INITPAR(&ap);
		ap.bits = encs[i];
		ap.sig = (ap.bits > 8) ? 1 : 0;
		if (!sio_sun_adjpar(hdl, &ap))
			return 0;
		if (ap.bits == encs[i]) {
			cap->enc[i].sig = ap.sig;
			cap->enc[i].bits = ap.bits;
			cap->enc[i].le = ap.le;
			cap->enc[i].bps = ap.bps;
			cap->enc[i].msb = ap.msb;
			enc_map |= 1 << i;
		}
	}

	/*
	 * fill channels
	 *
	 * for now we're lucky: all kernel devices assume that the
	 * number of channels and the encoding are independent so we can
	 * use the current encoding and try various channels.
	 */
	if (hdl->sio.mode & SIO_PLAY) {
		for (i = 0; i < sizeof(chans) / sizeof(chans[0]); i++) {
			AUDIO_INITPAR(&ap);
			ap.pchan = chans[i];
			if (!sio_sun_adjpar(hdl, &ap))
				return 0;
			if (ap.pchan == chans[i]) {
				cap->pchan[i] = chans[i];
				pchan_map |= (1 << i);
			}
		}
	}
	if (hdl->sio.mode & SIO_REC) {
		for (i = 0; i < sizeof(chans) / sizeof(chans[0]); i++) {
			AUDIO_INITPAR(&ap);
			ap.pchan = chans[i];
			if (!sio_sun_adjpar(hdl, &ap))
				return 0;
			if (ap.rchan == chans[i]) {
				cap->rchan[i] = chans[i];
				rchan_map |= (1 << i);
			}
		}
	}

	/*
	 * fill rates
	 *
	 * rates are not independent from other parameters (eg. on
	 * uaudio devices), so certain rates may not be allowed with
	 * certain encodings. We have to check rates for all encodings
	 */
	for (j = 0; j < sizeof(encs) / sizeof(encs[0]); j++) {
		rate_map = 0;
		if ((enc_map & (1 << j)) == 0)
			continue;
		for (i = 0; i < sizeof(rates) / sizeof(rates[0]); i++) {
			if (sio_sun_testpar(hdl,
				&cap->enc[j], 0, 0, rates[i])) {
				cap->rate[i] = rates[i];
				rate_map |= (1 << i);
			}
		}
		for (conf = 0; conf < nconf; conf++) {
			if (cap->confs[conf].rate == rate_map) {
				cap->confs[conf].enc |= (1 << j);
				break;
			}
		}
		if (conf == nconf) {
			if (nconf == SIO_NCONF)
				break;
			cap->confs[nconf].enc = (1 << j);
			cap->confs[nconf].pchan = pchan_map;
			cap->confs[nconf].rchan = rchan_map;
			cap->confs[nconf].rate = rate_map;
			nconf++;
		}
	}
	cap->nconf = nconf;

	if (ioctl(hdl->fd, AUDIO_SETPAR, &savepar)) {
		DPERROR("AUDIO_SETPAR");
		hdl->sio.eof = 1;
		return 0;
	}
	return 1;
}

int
sio_sun_getfd(const char *str, unsigned int mode, int nbio)
{
	const char *p;
	char path[DEVPATH_MAX];
	unsigned int devnum;
	int fd, flags;

#ifdef DEBUG
	_sndio_debug_init();
#endif
	p = _sndio_parsetype(str, "rsnd");
	if (p == NULL) {
		DPRINTF("sio_sun_getfd: %s: \"rsnd\" expected\n", str);
		return -1;
	}
	switch (*p) {
	case '/':
		p++;
		break;
	default:
		DPRINTF("sio_sun_getfd: %s: '/' expected\n", str);
		return -1;
	}
	p = _sndio_parsenum(p, &devnum, 255);
	if (p == NULL || *p != '\0') {
		DPRINTF("sio_sun_getfd: %s: number expected after '/'\n", str);
		return -1;
	}
	snprintf(path, sizeof(path), DEVPATH_PREFIX "%u", devnum);
	if (mode == (SIO_PLAY | SIO_REC))
		flags = O_RDWR;
	else
		flags = (mode & SIO_PLAY) ? O_WRONLY : O_RDONLY;
	while ((fd = open(path, flags | O_NONBLOCK | O_CLOEXEC)) < 0) {
		if (errno == EINTR)
			continue;
		DPERROR(path);
		return -1;
	}
	return fd;
}

struct sio_hdl *
sio_sun_fdopen(int fd, unsigned int mode, int nbio)
{
	struct sio_sun_hdl *hdl;

#ifdef DEBUG
	_sndio_debug_init();
#endif
	hdl = malloc(sizeof(struct sio_sun_hdl));
	if (hdl == NULL)
		return NULL;
	_sio_create(&hdl->sio, &sio_sun_ops, mode, nbio);

	/*
	 * pause the device
	 */
	if (ioctl(fd, AUDIO_STOP) < 0) {
		DPERROR("AUDIO_STOP");
		free(hdl);
		return NULL;
	}
	hdl->fd = fd;
	hdl->filling = 0;
	return (struct sio_hdl *)hdl;
}

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

	fd = sio_sun_getfd(str, mode, nbio);
	if (fd < 0)
		return NULL;
	hdl = sio_sun_fdopen(fd, mode, nbio);
	if (hdl != NULL)
		return hdl;
	while (close(fd) < 0 && errno == EINTR)
		; /* retry */
	return NULL;
}

static void
sio_sun_close(struct sio_hdl *sh)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;

	while (close(hdl->fd) < 0 && errno == EINTR)
		; /* retry */
	free(hdl);
}

static int
sio_sun_start(struct sio_hdl *sh)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;

	hdl->obpf = hdl->sio.par.pchan * hdl->sio.par.bps;
	hdl->ibpf = hdl->sio.par.rchan * hdl->sio.par.bps;
	hdl->ibytes = 0;
	hdl->obytes = 0;
	hdl->ierr = 0;
	hdl->oerr = 0;
	hdl->idelta = 0;
	hdl->odelta = 0;

	if (hdl->sio.mode & SIO_PLAY) {
		/*
		 * keep the device paused and let sio_sun_pollfd() trigger the
		 * start later, to avoid buffer underruns
		 */
		hdl->filling = 1;
	} else {
		/*
		 * no play buffers to fill, start now!
		 */
		if (ioctl(hdl->fd, AUDIO_START) < 0) {
			DPERROR("AUDIO_START");
			hdl->sio.eof = 1;
			return 0;
		}
		_sio_onmove_cb(&hdl->sio, 0);
	}
	return 1;
}

static int
sio_sun_stop(struct sio_hdl *sh)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;

	if (hdl->filling) {
		hdl->filling = 0;
		return 1;
	}
	if (ioctl(hdl->fd, AUDIO_STOP) < 0) {
		DPERROR("AUDIO_STOP");
		hdl->sio.eof = 1;
		return 0;
	}
	return 1;
}

static int
sio_sun_setpar(struct sio_hdl *sh, struct sio_par *par)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
	struct audio_swpar ap;

	AUDIO_INITPAR(&ap);
	ap.sig = par->sig;
	ap.le = par->le;
	ap.bits = par->bits;
	ap.bps = par->bps;
	ap.msb = par->msb;
	ap.rate = par->rate;
	if (hdl->sio.mode & SIO_PLAY)
		ap.pchan = par->pchan;
	if (hdl->sio.mode & SIO_REC)
		ap.rchan = par->rchan;
	if (par->round != ~0U && par->appbufsz != ~0U) {
		ap.round = par->round;
		ap.nblks = par->appbufsz / par->round;
	} else if (par->round != ~0U) {
		ap.round = par->round;
		ap.nblks = 2;
	} else if (par->appbufsz != ~0U) {
		ap.round = par->appbufsz / 2;
		ap.nblks = 2;
	}
	if (ioctl(hdl->fd, AUDIO_SETPAR, &ap) < 0) {
		DPERROR("AUDIO_SETPAR");
		hdl->sio.eof = 1;
		return 0;
	}
	return 1;
}

static int
sio_sun_getpar(struct sio_hdl *sh, struct sio_par *par)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
	struct audio_swpar ap;

	if (ioctl(hdl->fd, AUDIO_GETPAR, &ap) < 0) {
		DPERROR("AUDIO_GETPAR");
		hdl->sio.eof = 1;
		return 0;
	}
	par->sig = ap.sig;
	par->le = ap.le;
	par->bits = ap.bits;
	par->bps = ap.bps;
	par->msb = ap.msb;
	par->rate = ap.rate;
	par->pchan = ap.pchan;
	par->rchan = ap.rchan;
	par->round = ap.round;
	par->appbufsz = par->bufsz = ap.nblks * ap.round;
	par->xrun = SIO_IGNORE;
	return 1;
}

static size_t
sio_sun_read(struct sio_hdl *sh, void *buf, size_t len)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
	ssize_t n;

	while ((n = read(hdl->fd, buf, len)) < 0) {
		if (errno == EINTR)
			continue;
		if (errno != EAGAIN) {
			DPERROR("sio_sun_read: read");
			hdl->sio.eof = 1;
		}
		return 0;
	}
	if (n == 0) {
		DPRINTF("sio_sun_read: eof\n");
		hdl->sio.eof = 1;
		return 0;
	}
	return n;
}

static size_t
sio_sun_write(struct sio_hdl *sh, const void *buf, size_t len)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
	const unsigned char *data = buf;
	ssize_t n, todo;

	todo = len;
	while ((n = write(hdl->fd, data, todo)) < 0) {
		if (errno == EINTR)
			continue;
		if (errno != EAGAIN) {
			DPERROR("sio_sun_write: write");
			hdl->sio.eof = 1;
		}
		return 0;
	}
	return n;
}

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

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

	pfd->fd = hdl->fd;
	pfd->events = events;
	if (hdl->filling && hdl->sio.wused == hdl->sio.par.bufsz *
		hdl->sio.par.pchan * hdl->sio.par.bps) {
		hdl->filling = 0;
		if (ioctl(hdl->fd, AUDIO_START) < 0) {
			DPERROR("AUDIO_START");
			hdl->sio.eof = 1;
			return 0;
		}
		_sio_onmove_cb(&hdl->sio, 0);
	}
	return 1;
}

int
sio_sun_revents(struct sio_hdl *sh, struct pollfd *pfd)
{
	struct sio_sun_hdl *hdl = (struct sio_sun_hdl *)sh;
	struct audio_pos ap;
	int dierr = 0, doerr = 0, offset, delta;
	int revents = pfd->revents;

	if ((pfd->revents & POLLHUP) ||
	    (pfd->revents & (POLLIN | POLLOUT)) == 0)
		return pfd->revents;
	if (ioctl(hdl->fd, AUDIO_GETPOS, &ap) < 0) {
		DPERROR("sio_sun_revents: GETPOS");
		hdl->sio.eof = 1;
		return POLLHUP;
	}
	if (hdl->sio.mode & SIO_PLAY) {
		delta = (ap.play_pos - hdl->obytes) / hdl->obpf;
		doerr = (ap.play_xrun - hdl->oerr) / hdl->obpf;
		hdl->obytes = ap.play_pos;
		hdl->oerr = ap.play_xrun;
		hdl->odelta += delta;
		if (!(hdl->sio.mode & SIO_REC)) {
			hdl->idelta += delta;
			dierr = doerr;
		}
		if (doerr > 0)
			DPRINTFN(2, "play xrun %d\n", doerr);
	}
	if (hdl->sio.mode & SIO_REC) {
		delta = (ap.rec_pos - hdl->ibytes) / hdl->ibpf;
		dierr = (ap.rec_xrun - hdl->ierr) / hdl->ibpf;
		hdl->ibytes = ap.rec_pos;
		hdl->ierr = ap.rec_xrun;
		hdl->idelta += delta;
		if (!(hdl->sio.mode & SIO_PLAY)) {
			hdl->odelta += delta;
			doerr = dierr;
		}
		if (dierr > 0)
			DPRINTFN(2, "rec xrun %d\n", dierr);
	}

	/*
	 * GETPOS reports positions including xruns,
	 * so we have to substract to get the real position
	 */
	hdl->idelta -= dierr;
	hdl->odelta -= doerr;

	offset = doerr - dierr;
	if (offset > 0) {
		hdl->sio.rdrop += offset * hdl->ibpf;
		hdl->idelta -= offset;
		DPRINTFN(2, "will drop %d and pause %d\n", offset, doerr);
	} else if (offset < 0) {
		hdl->sio.wsil += -offset * hdl->obpf;
		hdl->odelta -= -offset;
		DPRINTFN(2, "will insert %d and pause %d\n", -offset, dierr);
	}

	delta = (hdl->idelta > hdl->odelta) ? hdl->idelta : hdl->odelta;
	if (delta > 0) {
		_sio_onmove_cb(&hdl->sio, delta);
		hdl->idelta -= delta;
		hdl->odelta -= delta;
	}
	return revents;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: sio_sun.c,v 1.26 2016/04/07 06:30:13 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/ioctl.h>
20			#include <sys/audioio.h>
21			#include <sys/stat.h>
22
23			#include <errno.h>
24			#include <fcntl.h>
25			#include <limits.h>
26			#include <poll.h>
27			#include <stdio.h>
28			#include <stdlib.h>
29			#include <string.h>
30			#include <unistd.h>
31
32			#include "debug.h"
33			#include "sio_priv.h"
34
35			#define DEVPATH_PREFIX "/dev/audio"
36			#define DEVPATH_MAX (1 + \
37			sizeof(DEVPATH_PREFIX) - 1 + \
38			sizeof(int) * 3)
39
40			struct sio_sun_hdl {
41			struct sio_hdl sio;
42			int fd;
43			int filling;
44			unsigned int ibpf, obpf; /* bytes per frame */
45			unsigned int ibytes, obytes; /* bytes the hw transferred */
46			unsigned int ierr, oerr; /* frames the hw dropped */
47			int idelta, odelta; /* position reported to client */
48			};
49
50			static void sio_sun_close(struct sio_hdl *);
51			static int sio_sun_start(struct sio_hdl *);
52			static int sio_sun_stop(struct sio_hdl *);
53			static int sio_sun_setpar(struct sio_hdl , struct sio_par );
54			static int sio_sun_getpar(struct sio_hdl , struct sio_par );
55			static int sio_sun_getcap(struct sio_hdl , struct sio_cap );
56			static size_t sio_sun_read(struct sio_hdl , void , size_t);
57			static size_t sio_sun_write(struct sio_hdl , const void , size_t);
58			static int sio_sun_nfds(struct sio_hdl *);
59			static int sio_sun_pollfd(struct sio_hdl , struct pollfd , int);
60			static int sio_sun_revents(struct sio_hdl , struct pollfd );
61
62			static struct sio_ops sio_sun_ops = {
63			sio_sun_close,
64			sio_sun_setpar,
65			sio_sun_getpar,
66			sio_sun_getcap,
67			sio_sun_write,
68			sio_sun_read,
69			sio_sun_start,
70			sio_sun_stop,
71			sio_sun_nfds,
72			sio_sun_pollfd,
73			sio_sun_revents,
74			NULL, /* setvol */
75			NULL, /* getvol */
76			};
77
78			static int
79			sio_sun_adjpar(struct sio_sun_hdl hdl, struct audio_swpar ap)
80			{
81			if (hdl->sio.eof)
82			return 0;
83			if (ioctl(hdl->fd, AUDIO_SETPAR, ap)) {
84			DPERROR("AUDIO_SETPAR");
85			hdl->sio.eof = 1;
86			return 0;
87			}
88			if (ioctl(hdl->fd, AUDIO_GETPAR, ap)) {
89			DPERROR("AUDIO_GETPAR");
90			hdl->sio.eof = 1;
91			return 0;
92			}
93			return 1;
94			}
95
96			/*
97			* try to set the device to the given parameters and check that the
98			* device can use them; return 1 on success, 0 on failure or error
99			*/
100			static int
101			sio_sun_testpar(struct sio_sun_hdl hdl, struct sio_enc enc,
102			unsigned int pchan, unsigned int rchan, unsigned int rate)
103			{
104			struct audio_swpar ap;
105
106			AUDIO_INITPAR(&ap);
107			if (enc != NULL) {
108			ap.sig = enc->sig;
109			ap.bits = enc->bits;
110			ap.bps = enc->bps;
111			if (ap.bps > 1)
112			ap.le = enc->le;
113			if (ap.bps * 8 > ap.bits)
114			ap.msb = enc->msb;
115			}
116			if (rate)
117			ap.rate = rate;
118			if (pchan && (hdl->sio.mode & SIO_PLAY))
119			ap.pchan = pchan;
120			if (rchan && (hdl->sio.mode & SIO_REC))
121			ap.rchan = rchan;
122			if (!sio_sun_adjpar(hdl, &ap))
123			return 0;
124			if (pchan && ap.pchan != pchan)
125			return 0;
126			if (rchan && ap.rchan != rchan)
127			return 0;
128			if (rate && ap.rate != rate)
129			return 0;
130			if (enc) {
131			if (ap.sig != enc->sig)
132			return 0;
133			if (ap.bits != enc->bits)
134			return 0;
135			if (ap.bps != enc->bps)
136			return 0;
137			if (ap.bps > 1 && ap.le != enc->le)
138			return 0;
139			if (ap.bits < ap.bps * 8 && ap.msb != enc->msb)
140			return 0;
141			}
142			return 1;
143			}
144
145			/*
146			* guess device capabilities
147			*/
148			static int
149			sio_sun_getcap(struct sio_hdl sh, struct sio_cap cap)
150			{
151			static unsigned int chans[] = {
152			1, 2, 4, 6, 8, 10, 12
153			};
154			static unsigned int rates[] = {
155			8000, 11025, 12000, 16000, 22050, 24000,
156			32000, 44100, 48000, 64000, 88200, 96000
157			};
158			static unsigned int encs[] = {
159			8, 16, 24, 32
160			};
161			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
162			struct audio_swpar savepar, ap;
163			unsigned int nconf = 0;
164			unsigned int enc_map = 0, rchan_map = 0, pchan_map = 0, rate_map;
165			unsigned int i, j, conf;
166
167			if (ioctl(hdl->fd, AUDIO_GETPAR, &savepar)) {
168			DPERROR("AUDIO_GETPAR");
169			hdl->sio.eof = 1;
170			return 0;
171			}
172
173			/*
174			* get a subset of supported encodings
175			*/
176			for (i = 0; i < sizeof(encs) / sizeof(encs[0]); i++) {
177			AUDIO_INITPAR(&ap);
178			ap.bits = encs[i];
179			ap.sig = (ap.bits > 8) ? 1 : 0;
180			if (!sio_sun_adjpar(hdl, &ap))
181			return 0;
182			if (ap.bits == encs[i]) {
183			cap->enc[i].sig = ap.sig;
184			cap->enc[i].bits = ap.bits;
185			cap->enc[i].le = ap.le;
186			cap->enc[i].bps = ap.bps;
187			cap->enc[i].msb = ap.msb;
188			enc_map \|= 1 << i;
189			}
190			}
191
192			/*
193			* fill channels
194			*
195			* for now we're lucky: all kernel devices assume that the
196			* number of channels and the encoding are independent so we can
197			* use the current encoding and try various channels.
198			*/
199			if (hdl->sio.mode & SIO_PLAY) {
200			for (i = 0; i < sizeof(chans) / sizeof(chans[0]); i++) {
201			AUDIO_INITPAR(&ap);
202			ap.pchan = chans[i];
203			if (!sio_sun_adjpar(hdl, &ap))
204			return 0;
205			if (ap.pchan == chans[i]) {
206			cap->pchan[i] = chans[i];
207			pchan_map \|= (1 << i);
208			}
209			}
210			}
211			if (hdl->sio.mode & SIO_REC) {
212			for (i = 0; i < sizeof(chans) / sizeof(chans[0]); i++) {
213			AUDIO_INITPAR(&ap);
214			ap.pchan = chans[i];
215			if (!sio_sun_adjpar(hdl, &ap))
216			return 0;
217			if (ap.rchan == chans[i]) {
218			cap->rchan[i] = chans[i];
219			rchan_map \|= (1 << i);
220			}
221			}
222			}
223
224			/*
225			* fill rates
226			*
227			* rates are not independent from other parameters (eg. on
228			* uaudio devices), so certain rates may not be allowed with
229			* certain encodings. We have to check rates for all encodings
230			*/
231			for (j = 0; j < sizeof(encs) / sizeof(encs[0]); j++) {
232			rate_map = 0;
233			if ((enc_map & (1 << j)) == 0)
234			continue;
235			for (i = 0; i < sizeof(rates) / sizeof(rates[0]); i++) {
236			if (sio_sun_testpar(hdl,
237			&cap->enc[j], 0, 0, rates[i])) {
238			cap->rate[i] = rates[i];
239			rate_map \|= (1 << i);
240			}
241			}
242			for (conf = 0; conf < nconf; conf++) {
243			if (cap->confs[conf].rate == rate_map) {
244			cap->confs[conf].enc \|= (1 << j);
245			break;
246			}
247			}
248			if (conf == nconf) {
249			if (nconf == SIO_NCONF)
250			break;
251			cap->confs[nconf].enc = (1 << j);
252			cap->confs[nconf].pchan = pchan_map;
253			cap->confs[nconf].rchan = rchan_map;
254			cap->confs[nconf].rate = rate_map;
255			nconf++;
256			}
257			}
258			cap->nconf = nconf;
259
260			if (ioctl(hdl->fd, AUDIO_SETPAR, &savepar)) {
261			DPERROR("AUDIO_SETPAR");
262			hdl->sio.eof = 1;
263			return 0;
264			}
265			return 1;
266			}
267
268			int
269			sio_sun_getfd(const char *str, unsigned int mode, int nbio)
270			{
271			const char *p;
272			char path[DEVPATH_MAX];
273			unsigned int devnum;
274			int fd, flags;
275
276			#ifdef DEBUG
277			_sndio_debug_init();
278			#endif
279			p = _sndio_parsetype(str, "rsnd");
280			if (p == NULL) {
281			DPRINTF("sio_sun_getfd: %s: \"rsnd\" expected\n", str);
282			return -1;
283			}
284			switch (*p) {
285			case '/':
286			p++;
287			break;
288			default:
289			DPRINTF("sio_sun_getfd: %s: '/' expected\n", str);
290			return -1;
291			}
292			p = _sndio_parsenum(p, &devnum, 255);
293			if (p == NULL \|\| *p != '\0') {
294			DPRINTF("sio_sun_getfd: %s: number expected after '/'\n", str);
295			return -1;
296			}
297			snprintf(path, sizeof(path), DEVPATH_PREFIX "%u", devnum);
298			if (mode == (SIO_PLAY \| SIO_REC))
299			flags = O_RDWR;
300			else
301			flags = (mode & SIO_PLAY) ? O_WRONLY : O_RDONLY;
302			while ((fd = open(path, flags \| O_NONBLOCK \| O_CLOEXEC)) < 0) {
303			if (errno == EINTR)
304			continue;
305			DPERROR(path);
306			return -1;
307			}
308			return fd;
309			}
310
311			struct sio_hdl *
312			sio_sun_fdopen(int fd, unsigned int mode, int nbio)
313			{
314			struct sio_sun_hdl *hdl;
315
316			#ifdef DEBUG
317			_sndio_debug_init();
318			#endif
319			hdl = malloc(sizeof(struct sio_sun_hdl));
320			if (hdl == NULL)
321			return NULL;
322			_sio_create(&hdl->sio, &sio_sun_ops, mode, nbio);
323
324			/*
325			* pause the device
326			*/
327			if (ioctl(fd, AUDIO_STOP) < 0) {
328			DPERROR("AUDIO_STOP");
329			free(hdl);
330			return NULL;
331			}
332			hdl->fd = fd;
333			hdl->filling = 0;
334			return (struct sio_hdl *)hdl;
335			}
336
337			struct sio_hdl *
338			_sio_sun_open(const char *str, unsigned int mode, int nbio)
339			{
340			struct sio_hdl *hdl;
341			int fd;
342
343			fd = sio_sun_getfd(str, mode, nbio);
344			if (fd < 0)
345			return NULL;
346			hdl = sio_sun_fdopen(fd, mode, nbio);
347			if (hdl != NULL)
348			return hdl;
349			while (close(fd) < 0 && errno == EINTR)
350			; /* retry */
351			return NULL;
352			}
353
354			static void
355			sio_sun_close(struct sio_hdl *sh)
356			{
357			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
358
359			while (close(hdl->fd) < 0 && errno == EINTR)
360			; /* retry */
361			free(hdl);
362			}
363
364			static int
365			sio_sun_start(struct sio_hdl *sh)
366			{
367			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
368
369			hdl->obpf = hdl->sio.par.pchan * hdl->sio.par.bps;
370			hdl->ibpf = hdl->sio.par.rchan * hdl->sio.par.bps;
371			hdl->ibytes = 0;
372			hdl->obytes = 0;
373			hdl->ierr = 0;
374			hdl->oerr = 0;
375			hdl->idelta = 0;
376			hdl->odelta = 0;
377
378			if (hdl->sio.mode & SIO_PLAY) {
379			/*
380			* keep the device paused and let sio_sun_pollfd() trigger the
381			* start later, to avoid buffer underruns
382			*/
383			hdl->filling = 1;
384			} else {
385			/*
386			* no play buffers to fill, start now!
387			*/
388			if (ioctl(hdl->fd, AUDIO_START) < 0) {
389			DPERROR("AUDIO_START");
390			hdl->sio.eof = 1;
391			return 0;
392			}
393			_sio_onmove_cb(&hdl->sio, 0);
394			}
395			return 1;
396			}
397
398			static int
399			sio_sun_stop(struct sio_hdl *sh)
400			{
401			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
402
403			if (hdl->filling) {
404			hdl->filling = 0;
405			return 1;
406			}
407			if (ioctl(hdl->fd, AUDIO_STOP) < 0) {
408			DPERROR("AUDIO_STOP");
409			hdl->sio.eof = 1;
410			return 0;
411			}
412			return 1;
413			}
414
415			static int
416			sio_sun_setpar(struct sio_hdl sh, struct sio_par par)
417			{
418			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
419			struct audio_swpar ap;
420
421			AUDIO_INITPAR(&ap);
422			ap.sig = par->sig;
423			ap.le = par->le;
424			ap.bits = par->bits;
425			ap.bps = par->bps;
426			ap.msb = par->msb;
427			ap.rate = par->rate;
428			if (hdl->sio.mode & SIO_PLAY)
429			ap.pchan = par->pchan;
430			if (hdl->sio.mode & SIO_REC)
431			ap.rchan = par->rchan;
432			if (par->round != ~0U && par->appbufsz != ~0U) {
433			ap.round = par->round;
434			ap.nblks = par->appbufsz / par->round;
435			} else if (par->round != ~0U) {
436			ap.round = par->round;
437			ap.nblks = 2;
438			} else if (par->appbufsz != ~0U) {
439			ap.round = par->appbufsz / 2;
440			ap.nblks = 2;
441			}
442			if (ioctl(hdl->fd, AUDIO_SETPAR, &ap) < 0) {
443			DPERROR("AUDIO_SETPAR");
444			hdl->sio.eof = 1;
445			return 0;
446			}
447			return 1;
448			}
449
450			static int
451			sio_sun_getpar(struct sio_hdl sh, struct sio_par par)
452			{
453			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
454			struct audio_swpar ap;
455
456			if (ioctl(hdl->fd, AUDIO_GETPAR, &ap) < 0) {
457			DPERROR("AUDIO_GETPAR");
458			hdl->sio.eof = 1;
459			return 0;
460			}
461			par->sig = ap.sig;
462			par->le = ap.le;
463			par->bits = ap.bits;
464			par->bps = ap.bps;
465			par->msb = ap.msb;
466			par->rate = ap.rate;
467			par->pchan = ap.pchan;
468			par->rchan = ap.rchan;
469			par->round = ap.round;
470			par->appbufsz = par->bufsz = ap.nblks * ap.round;
471			par->xrun = SIO_IGNORE;
472			return 1;
473			}
474
475			static size_t
476			sio_sun_read(struct sio_hdl sh, void buf, size_t len)
477			{
478			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
479			ssize_t n;
480
481			while ((n = read(hdl->fd, buf, len)) < 0) {
482			if (errno == EINTR)
483			continue;
484			if (errno != EAGAIN) {
485			DPERROR("sio_sun_read: read");
486			hdl->sio.eof = 1;
487			}
488			return 0;
489			}
490			if (n == 0) {
491			DPRINTF("sio_sun_read: eof\n");
492			hdl->sio.eof = 1;
493			return 0;
494			}
495			return n;
496			}
497
498			static size_t
499			sio_sun_write(struct sio_hdl sh, const void buf, size_t len)
500			{
501			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
502			const unsigned char *data = buf;
503			ssize_t n, todo;
504
505			todo = len;
506			while ((n = write(hdl->fd, data, todo)) < 0) {
507			if (errno == EINTR)
508			continue;
509			if (errno != EAGAIN) {
510			DPERROR("sio_sun_write: write");
511			hdl->sio.eof = 1;
512			}
513			return 0;
514			}
515			return n;
516			}
517
518			static int
519			sio_sun_nfds(struct sio_hdl *hdl)
520			{
521			return 1;
522			}
523
524			static int
525			sio_sun_pollfd(struct sio_hdl sh, struct pollfd pfd, int events)
526			{
527			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
528
529			pfd->fd = hdl->fd;
530			pfd->events = events;
531			if (hdl->filling && hdl->sio.wused == hdl->sio.par.bufsz *
532			hdl->sio.par.pchan * hdl->sio.par.bps) {
533			hdl->filling = 0;
534			if (ioctl(hdl->fd, AUDIO_START) < 0) {
535			DPERROR("AUDIO_START");
536			hdl->sio.eof = 1;
537			return 0;
538			}
539			_sio_onmove_cb(&hdl->sio, 0);
540			}
541			return 1;
542			}
543
544			int
545			sio_sun_revents(struct sio_hdl sh, struct pollfd pfd)
546			{
547			struct sio_sun_hdl hdl = (struct sio_sun_hdl )sh;
548			struct audio_pos ap;
549			int dierr = 0, doerr = 0, offset, delta;
550			int revents = pfd->revents;
551
552			if ((pfd->revents & POLLHUP) \|\|
553			(pfd->revents & (POLLIN \| POLLOUT)) == 0)
554			return pfd->revents;
555			if (ioctl(hdl->fd, AUDIO_GETPOS, &ap) < 0) {
556			DPERROR("sio_sun_revents: GETPOS");
557			hdl->sio.eof = 1;
558			return POLLHUP;
559			}
560			if (hdl->sio.mode & SIO_PLAY) {
561			delta = (ap.play_pos - hdl->obytes) / hdl->obpf;
562			doerr = (ap.play_xrun - hdl->oerr) / hdl->obpf;
563			hdl->obytes = ap.play_pos;
564			hdl->oerr = ap.play_xrun;
565			hdl->odelta += delta;
566			if (!(hdl->sio.mode & SIO_REC)) {
567			hdl->idelta += delta;
568			dierr = doerr;
569			}
570			if (doerr > 0)
571			DPRINTFN(2, "play xrun %d\n", doerr);
572			}
573			if (hdl->sio.mode & SIO_REC) {
574			delta = (ap.rec_pos - hdl->ibytes) / hdl->ibpf;
575			dierr = (ap.rec_xrun - hdl->ierr) / hdl->ibpf;
576			hdl->ibytes = ap.rec_pos;
577			hdl->ierr = ap.rec_xrun;
578			hdl->idelta += delta;
579			if (!(hdl->sio.mode & SIO_PLAY)) {
580			hdl->odelta += delta;
581			doerr = dierr;
582			}
583			if (dierr > 0)
584			DPRINTFN(2, "rec xrun %d\n", dierr);
585			}
586
587			/*
588			* GETPOS reports positions including xruns,
589			* so we have to substract to get the real position
590			*/
591			hdl->idelta -= dierr;
592			hdl->odelta -= doerr;
593
594			offset = doerr - dierr;
595			if (offset > 0) {
596			hdl->sio.rdrop += offset * hdl->ibpf;
597			hdl->idelta -= offset;
598			DPRINTFN(2, "will drop %d and pause %d\n", offset, doerr);
599			} else if (offset < 0) {
600			hdl->sio.wsil += -offset * hdl->obpf;
601			hdl->odelta -= -offset;
602			DPRINTFN(2, "will insert %d and pause %d\n", -offset, dierr);
603			}
604
605			delta = (hdl->idelta > hdl->odelta) ? hdl->idelta : hdl->odelta;
606			if (delta > 0) {
607			_sio_onmove_cb(&hdl->sio, delta);
608			hdl->idelta -= delta;
609			hdl->odelta -= delta;
610			}
611			return revents;
612			}