Attachment #176617 for bug #214210

Lines 3-9 Link Here

(-)b/audio/sndio/Makefile (-1 / +1 lines)
3		3
4	PORTNAME= sndio	4	PORTNAME= sndio
5	PORTVERSION= 1.1.0	5	PORTVERSION= 1.1.0
6	PORTREVISION= 1	6	PORTREVISION= 2
7	CATEGORIES= audio	7	CATEGORIES= audio
8	MASTER_SITES= http://www.sndio.org/	8	MASTER_SITES= http://www.sndio.org/
9		9




--- configure.orig	2015-12-15 05:28:04 UTC
+++ configure
@@ -20,6 +20,8 @@ Usage: configure [options]
 --disable-sun			disable sun audio backend
 --enable-rmidi			enable character device midi backend [$rmidi]
 --disable-rmidi			disable character device midi backend
+--enable-umidi			enable character device midi backend [$umidi]
+--disable-umidi			disable character device midi backend
 --with-libbsd			use the libbsd rather than bsd-compat/*
 --without-libbsd		don't use libbsd
 END
@@ -32,7 +34,9 @@ prefix=/usr/local			# where to install s
 so="libsndio.so.\${MAJ}.\${MIN}"	# shared libs to build
 alsa=no					# do we want alsa support ?
 sun=no					# do we want sun support ?
+oss=no					# do we want oss support ?
 rmidi=no				# do we want support for raw char dev ?
+umidi=no				# do we want support for raw char dev ?
 precision=16				# aucat/sndiod arithmetic precision
 user=_sndio				# non-privileged user for sndio daemon
 libbsd=no				# use libbsd?
@@ -71,6 +75,15 @@ case `uname` in
 		defs='-DHAVE_ARC4RANDOM -DHAVE_ISSETUGID \\\
 		-DHAVE_STRLCAT -DHAVE_STRLCPY -DHAVE_STRTONUM'
 		;;
+	DragonFly|FreeBSD)
+		user=_sndio
+		so="$so libsndio.so"
+		defs='-DHAVE_ARC4RANDOM -DHAVE_ISSETUGID \\\
+		-DHAVE_STRLCAT -DHAVE_STRLCPY -DHAVE_STRTONUM'
+		-DDEFAULT_DEV=\\"fallback\\"'
+		oss=yes
+		umidi=yes
+		mandir=${prefix}/man
+		;;
 esac
 
 # shell word separator (none)
@@ -106,6 +119,12 @@ for i; do
 	--disable-alsa)
 		alsa=no
 		shift;;

 	--enable-sun)
 		sun=yes
 		shift;;
@@ -118,6 +137,12 @@ for i; do
 	--disable-rmidi)
 		rmidi=no
 		shift;;
+	--enable-umidi)
+		umidi=yes
+		shift;;
+	--disable-umidi)
+		umidi=no
+		shift;;
 	--privsep-user=*)
 		user="${i#--privsep-user=}"
 		shift;;
@@ -162,6 +187,13 @@ if [ $alsa = yes ]; then
 fi
 
 #

 # if using Sun API, add corresponding parameters
 #
 if [ $sun = yes ]; then
@@ -176,6 +208,13 @@ if [ $rmidi = yes ]; then
 fi
 
 #
+# if using raw character devices for midi, add corresponding parameters
+#
+if [ $umidi = yes ]; then
+	defs="$defs -DUSE_UMIDI"
+fi
+
+#
 # if using libbsd, add corresponding parameters
 #
 if [ $libbsd = yes ]; then
@@ -215,8 +254,10 @@ user..................... $user
 libbsd................... $libbsd
 precision................ $precision
 alsa..................... $alsa
+oss...................... $oss
 sun...................... $sun
 rmidi.................... $rmidi
+umidi.................... $umidi
 
 Do "make && make install" to compile and install sndio
 




--- libsndio/Makefile.in.orig	2015-12-30 11:54:40 UTC
+++ libsndio/Makefile.in
@@ -98,8 +98,8 @@ clean:
 # loader to determine dependencies in a single pass
 #
 OBJS = debug.o aucat.o \
-mio.o mio_rmidi.o mio_alsa.o mio_aucat.o \
-sio.o sio_alsa.o sio_aucat.o sio_sun.o \
+mio.o mio_rmidi.o mio_umidi.o mio_alsa.o mio_aucat.o \
+sio.o sio_alsa.o sio_aucat.o sio_oss.o sio_sun.o \
 issetugid.o strlcat.o strlcpy.o strtonum.o
 
 .c.o:
@@ -132,6 +132,7 @@ mio_alsa.o:	mio_alsa.c debug.h mio_priv.
 mio_aucat.o:	mio_aucat.c aucat.h amsg.h debug.h mio_priv.h sndio.h \
 		../bsd-compat/bsd-compat.h
 mio_rmidi.o:	mio_rmidi.c debug.h mio_priv.h sndio.h
+mio_umidi.o:	mio_umidi.c debug.h mio_priv.h sndio.h
 sio.o:		sio.c debug.h sio_priv.h sndio.h \
 		../bsd-compat/bsd-compat.h
 sio_alsa.o:	sio_alsa.c debug.h sio_priv.h sndio.h \
@@ -140,3 +141,5 @@ sio_aucat.o:	sio_aucat.c aucat.h amsg.h 
 		../bsd-compat/bsd-compat.h
 sio_sun.o:	sio_sun.c debug.h sio_priv.h sndio.h \
 		../bsd-compat/bsd-compat.h




--- libsndio/mio.c.orig	2015-12-09 10:13:10 UTC
+++ libsndio/mio.c
@@ -55,6 +55,8 @@ mio_open(const char *str, unsigned int m
 			return hdl;
 #if defined(USE_RMIDI)
 		return _mio_rmidi_open("rmidi/0", mode, nbio);
+#elif defined(USE_UMIDI)
+		return _mio_umidi_open("rmidi/0", mode, nbio);
 #elif defined(USE_ALSA)
 		return _mio_alsa_open("rmidi/0", mode, nbio);
 #else
@@ -68,6 +70,8 @@ mio_open(const char *str, unsigned int m
 	if (_sndio_parsetype(str, "rmidi"))
 #if defined(USE_RMIDI)
 		return _mio_rmidi_open(str, mode, nbio);
+#elif defined(USE_UMIDI)
+		return _mio_umidi_open(str, mode, nbio);
 #elif defined(USE_ALSA)
 		return _mio_alsa_open(str, mode, nbio);
 #else




--- libsndio/mio_priv.h.orig	2015-12-09 10:13:10 UTC
+++ libsndio/mio_priv.h
@@ -44,6 +44,9 @@ struct mio_ops {
 };
 
 struct mio_hdl *_mio_rmidi_open(const char *, unsigned, int);
+#ifdef USE_UMIDI
+struct mio_hdl *_mio_umidi_open(const char *, unsigned, int);
+#endif
 #ifdef USE_ALSA
 struct mio_hdl *_mio_alsa_open(const char *, unsigned, int);
 #endif




--- libsndio/mio_umidi.c.orig	2016-11-04 12:06:45 UTC
+++ libsndio/mio_umidi.c
@@ -0,0 +1,219 @@
+/*	$OpenBSD$	*/
+/*
+ * Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>
+ * Copyright (c) 2016 Tobias Kortkamp <t@tobik.me>
+ *
+ * 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.
+ */
+
+#ifdef USE_UMIDI
+#include <sys/types.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 "mio_priv.h"
+
+#define DEVPATH_PREFIX	"/dev/umidi"
+#define DEVPATH_MAX 	(1 +		\
+	sizeof(DEVPATH_PREFIX) - 1 +	\
+	sizeof(int) * 3)
+
+struct mio_umidi_hdl {
+	struct mio_hdl mio;
+	int fd;
+};
+
+static void mio_umidi_close(struct mio_hdl *);
+static size_t mio_umidi_read(struct mio_hdl *, void *, size_t);
+static size_t mio_umidi_write(struct mio_hdl *, const void *, size_t);
+static int mio_umidi_nfds(struct mio_hdl *);
+static int mio_umidi_pollfd(struct mio_hdl *, struct pollfd *, int);
+static int mio_umidi_revents(struct mio_hdl *, struct pollfd *);
+
+static struct mio_ops mio_umidi_ops = {
+	mio_umidi_close,
+	mio_umidi_write,
+	mio_umidi_read,
+	mio_umidi_nfds,
+	mio_umidi_pollfd,
+	mio_umidi_revents
+};
+
+static int
+mio_umidi_getfd(const char *str, unsigned int mode, int nbio)
+{
+	const char *p;
+	char path[DEVPATH_MAX];
+	unsigned int devnum;
+	unsigned int subdevnum;
+	int fd, flags;
+
+	p = _sndio_parsetype(str, "rmidi");
+	if (p == NULL) {
+		DPRINTF("mio_umidi_getfd: %s: \"rsnd\" expected\n", str);
+		return -1;
+	}
+	switch (*p) {
+	case '/':
+		p++;
+		break;
+	default:
+		DPRINTF("mio_umidi_getfd: %s: '/' expected\n", str);
+		return -1;
+	}
+	p = _sndio_parsenum(p, &devnum, 255);
+	if (p == NULL) {
+		DPRINTF("mio_umidi_getfd: %s: number expected after '/'\n", str);
+		return -1;
+	}
+	switch (*p) {
+	case '.':
+		p++;
+		p = _sndio_parsenum(p, &subdevnum, 255);
+		if (p == NULL || *p != '\0') {
+			DPRINTF("mio_umidi_getfd: %s: number expected after '.'\n",
+				str);
+			return -1;
+		}
+		break;
+	default:
+		subdevnum = 0;
+	}
+	snprintf(path, sizeof(path), DEVPATH_PREFIX "%u.%u", devnum, subdevnum);
+	if (mode == (MIO_IN | MIO_OUT))
+		flags = O_RDWR;
+	else
+		flags = (mode & MIO_OUT) ? O_WRONLY : O_RDONLY;
+	while ((fd = open(path, flags | O_NONBLOCK | O_CLOEXEC)) < 0) {
+		if (errno == EINTR)
+			continue;
+		DPERROR(path);
+		return -1;
+	}
+	return fd;
+}
+
+static struct mio_hdl *
+mio_umidi_fdopen(int fd, unsigned int mode, int nbio)
+{
+	struct mio_umidi_hdl *hdl;
+
+	hdl = malloc(sizeof(struct mio_umidi_hdl));
+	if (hdl == NULL)
+		return NULL;
+	_mio_create(&hdl->mio, &mio_umidi_ops, mode, nbio);
+	hdl->fd = fd;
+	return (struct mio_hdl *)hdl;
+}
+
+struct mio_hdl *
+_mio_umidi_open(const char *str, unsigned int mode, int nbio)
+{
+	struct mio_hdl *hdl;
+	int fd;
+
+	fd = mio_umidi_getfd(str, mode, nbio);
+	if (fd < 0)
+		return NULL;
+	hdl = mio_umidi_fdopen(fd, mode, nbio);
+	if (hdl != NULL)
+		return hdl;
+	while (close(fd) < 0 && errno == EINTR)
+		; /* retry */
+	return NULL;
+}
+
+static void
+mio_umidi_close(struct mio_hdl *sh)
+{
+	struct mio_umidi_hdl *hdl = (struct mio_umidi_hdl *)sh;
+	int rc;
+
+	do {
+		rc = close(hdl->fd);
+	} while (rc < 0 && errno == EINTR);
+	free(hdl);
+}
+
+static size_t
+mio_umidi_read(struct mio_hdl *sh, void *buf, size_t len)
+{
+	struct mio_umidi_hdl *hdl = (struct mio_umidi_hdl *)sh;
+	ssize_t n;
+
+	while ((n = read(hdl->fd, buf, len)) < 0) {
+		if (errno == EINTR)
+			continue;
+		if (errno != EAGAIN) {
+			DPERROR("mio_umidi_read: read");
+			hdl->mio.eof = 1;
+		}
+		return 0;
+	}
+	if (n == 0) {
+		DPRINTF("mio_umidi_read: eof\n");
+		hdl->mio.eof = 1;
+		return 0;
+	}
+	return n;
+}
+
+static size_t
+mio_umidi_write(struct mio_hdl *sh, const void *buf, size_t len)
+{
+	struct mio_umidi_hdl *hdl = (struct mio_umidi_hdl *)sh;
+	ssize_t n;
+
+	while ((n = write(hdl->fd, buf, len)) < 0) {
+		if (errno == EINTR)
+			continue;
+		if (errno != EAGAIN) {
+			DPERROR("mio_umidi_write: write");
+			hdl->mio.eof = 1;
+		}
+		return 0;
+	}
+	return n;
+}
+
+static int
+mio_umidi_nfds(struct mio_hdl *sh)
+{
+	return 1;
+}
+
+static int
+mio_umidi_pollfd(struct mio_hdl *sh, struct pollfd *pfd, int events)
+{
+	struct mio_umidi_hdl *hdl = (struct mio_umidi_hdl *)sh;
+
+	pfd->fd = hdl->fd;
+	pfd->events = events;
+	return 1;
+}
+
+static int
+mio_umidi_revents(struct mio_hdl *sh, struct pollfd *pfd)
+{
+	return pfd->revents;
+}
+#endif /* defined USE_UMIDI */




--- libsndio/sio.c.orig	2016-01-08 20:51:12 UTC
+++ libsndio/sio.c
@@ -64,6 +64,8 @@ sio_open(const char *str, unsigned int m
 			return hdl;
 #if defined(USE_SUN)
 		return _sio_sun_open("rsnd/0", mode, nbio);
+#elif defined(USE_OSS)
+		return _sio_oss_open("rsnd/0", mode, nbio);
 #elif defined(USE_ALSA)
 		return _sio_alsa_open("rsnd/0", mode, nbio);
 #else
@@ -75,6 +77,8 @@ sio_open(const char *str, unsigned int m
 #endif
 	}
+#if defined(USE_OSS)
+	if (strcmp(str, "fallback") == 0)
+		return _sio_oss_open(str, mode, nbio);
+#endif
 	if (_sndio_parsetype(str, "snd"))
 		return _sio_aucat_open(str, mode, nbio);
 	if (_sndio_parsetype(str, "rsnd"))
 #if defined(USE_SUN)
 		return _sio_sun_open(str, mode, nbio);




--- libsndio/sio_oss.c.orig	2016-11-04 12:06:45 UTC
+++ libsndio/sio_oss.c
@@ -0,0 +1,644 @@
+/*	$OpenBSD$	*/
+/*
+ * Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>

+ */
+
+#ifdef USE_OSS
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/param.h>
+#include <sys/soundcard.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>

+	sizeof(DEVPATH_PREFIX) - 1 +	\
+	sizeof(int) * 3)
+
+struct sio_oss_fmt {
+	int fmt;
+	unsigned int bits;
+	unsigned int bps;
+	unsigned int sig;
+	unsigned int le;
+	unsigned int msb;
+};
+static struct sio_oss_fmt formats[] = {
+	/* See http://manuals.opensound.com/developer/formats.html.
+	 * AFMT_{S8,U16}_* are marked as obsolete so are missing here.
+	 */
+
+	/* le+msb not important */
+	{ AFMT_U8,      8, 1, 0, 0, 0 },
+	{ AFMT_U8,      8, 1, 0, 1, 0 },
+	{ AFMT_U8,      8, 1, 0, 0, 1 },
+	{ AFMT_U8,      8, 1, 0, 1, 1 },
+
+	/* msb not important */
+	{ AFMT_S16_BE, 16, 2, 1, 0, 0 },
+	{ AFMT_S16_BE, 16, 2, 1, 0, 1 },
+	{ AFMT_S16_LE, 16, 2, 1, 1, 0 },
+	{ AFMT_S16_LE, 16, 2, 1, 1, 1 },
+	{ AFMT_S24_BE, 24, 3, 1, 0, 0 },
+	{ AFMT_S24_BE, 24, 3, 1, 0, 1 },
+	{ AFMT_S24_LE, 24, 3, 1, 1, 0 },
+	{ AFMT_S24_LE, 24, 3, 1, 1, 1 },
+	{ AFMT_U24_BE, 24, 3, 0, 0, 0 },
+	{ AFMT_U24_BE, 24, 3, 0, 0, 1 },
+	{ AFMT_U24_LE, 24, 3, 0, 1, 0 },
+	{ AFMT_U24_LE, 24, 3, 0, 1, 1 },
+
+	{ AFMT_S32_BE, 32, 4, 1, 0, 1 },
+	{ AFMT_S32_LE, 32, 4, 1, 1, 1 },
+	{ AFMT_U32_BE, 32, 4, 0, 0, 1 },
+	{ AFMT_U32_LE, 32, 4, 0, 1, 1 },
+};
+
+struct sio_oss_hdl {
+	struct sio_hdl sio;
+	int fd;
+	unsigned int ibpf, obpf;	/* bytes per frame */
+	unsigned int isamples;
+	unsigned int osamples;
+	int idelta, odelta;
+
+	char *devstr;
+
+	int fmt;
+	unsigned int rate;
+	unsigned int chan;
+	unsigned int appbufsz;
+	unsigned int round;
+};
+
+static struct sio_hdl *sio_oss_fdopen(const char *, int, unsigned int, int);
+static int sio_oss_start(struct sio_hdl *);
+static int sio_oss_stop(struct sio_hdl *);
+static int sio_oss_setpar(struct sio_hdl *, struct sio_par *);
+static int sio_oss_getpar(struct sio_hdl *, struct sio_par *);
+static int sio_oss_getcap(struct sio_hdl *, struct sio_cap *);
+static int sio_oss_getfd(const char *, unsigned int, int);
+static int sio_oss_getpar(struct sio_hdl *, struct sio_par *);
+static int sio_oss_nfds(struct sio_hdl *);
+static int sio_oss_pollfd(struct sio_hdl *, struct pollfd *, int);
+static int sio_oss_revents(struct sio_hdl *, struct pollfd *);
+static int sio_oss_setpar(struct sio_hdl *, struct sio_par *);
+static int sio_oss_start(struct sio_hdl *);
+static int sio_oss_stop(struct sio_hdl *);
+static int sio_oss_xrun(struct sio_oss_hdl *);
+static size_t sio_oss_read(struct sio_hdl *, void *, size_t);
+static size_t sio_oss_write(struct sio_hdl *, const void *, size_t);
+static void sio_oss_close(struct sio_hdl *);
+
+static struct sio_ops sio_oss_ops = {
+	sio_oss_close,

+	NULL, /* getvol */
+};
+
+static int
+sio_oss_adjpar(struct sio_oss_hdl *hdl, struct audio_swpar *ap)
+{
+	if (hdl->sio.eof)
+		return 0;
+	if (sio_oss_audio_setpar(hdl, ap)) {
+		DPERROR("AUDIO_SETPAR");
+		hdl->sio.eof = 1;
+		return 0;
+	}
+	if (sio_oss_audio_getpar(hdl, 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_oss_testpar(struct sio_oss_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_oss_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_oss_getcap(struct sio_hdl *sh, struct sio_cap *cap)
+{
+	/* From sound(4):
+	 * The FreeBSD multichannel matrix processor supports up to 18
+	 * interleaved channels, but the limit is currently set to 8
+	 * channels (as commonly used for 7.1 surround sound).
+	 */
+	static unsigned int chans[] = {
+		1, 2, 4, 6, 8
+	};
+	static unsigned int rates[] = {
+		8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100,
+		48000, 64000, 88200, 96000, 192000
+	};
+	static int afmts[] = {
+		AFMT_U8, AFMT_S16_LE, AFMT_S16_BE, AFMT_S24_LE, AFMT_U24_LE,
+		AFMT_S32_LE, AFMT_U32_LE
+	};
+	struct sio_oss_hdl *hdl = (struct sio_oss_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, k, conf;
+	int fmts;
+
+	if (ioctl(hdl->fd, SNDCTL_DSP_GETFMTS, &fmts) < 0) {
+		DPERROR("sio_oss_getcap: GETFMTS");
+		hdl->sio.eof = 1;
+		return 0;
+	}

+	/*
+	 * get a subset of supported encodings
+	 */
+	for (j = 0, i = 0; i < sizeof(afmts) / sizeof(afmts[0]); i++) {
+		if (fmts & afmts[i]) {
+			for (k = 0; k < sizeof(formats) / sizeof(formats[0]); k++) {
+				if (formats[k].fmt == afmts[i]) {
+					cap->enc[j].sig = formats[k].sig;
+					cap->enc[j].bits = formats[k].bits;
+					cap->enc[j].bps = formats[k].bps;
+					cap->enc[j].le = formats[k].le;
+					cap->enc[j].msb = formats[k].msb;
+					enc_map |= 1 << j;
+					j++;
+					break;
+				}
+			}
+		}
+	}
+
+	/*
+	 * 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++) {
+			cap->pchan[i] = chans[i];
+			pchan_map |= (1 << i);
+			if (!sio_oss_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++) {
+			cap->rchan[i] = chans[i];
+			rchan_map |= (1 << i);
+			if (!sio_oss_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(formats) / sizeof(formats[0]); j++) {
+		rate_map = 0;
+		if ((enc_map & (1 << j)) == 0)
+			continue;
+		for (i = 0; i < sizeof(rates) / sizeof(rates[0]); i++) {
+			cap->rate[i] = rates[i];
+			rate_map |= (1 << i);
+				cap->rate[i] = rates[i];
+				rate_map |= (1 << i);
+			}
+		}
+		for (conf = 0; conf < nconf; conf++) {
+			if (cap->confs[conf].rate == rate_map) {

+	}
+	cap->nconf = nconf;
+
+	if (sio_oss_audio_setpar(hdl, &savepar)) {
+		DPERROR("AUDIO_SETPAR");
+		hdl->sio.eof = 1;
+		return 0;
+	}
+	return 1;
+}
+

+	unsigned int devnum;
+	int fd, flags;
+
+	p = _sndio_parsetype(str, "rsnd");
+	if (p == NULL) {
+		DPRINTF("sio_oss_getfd: %s: \"rsnd\" expected\n", str);
+		return -1;
+	}
+	switch (*p) {
+	case '/':
+		p++;
+		break;
+	default:
+		DPRINTF("sio_oss_getfd: %s: '/' expected\n", str);
+		return -1;
+	}
+	p = _sndio_parsenum(p, &devnum, 255);
+	if (p == NULL || *p != '\0') {
+		DPRINTF("sio_oss_getfd: %s: number expected after '/'\n", str);
+		return -1;
+			DPRINTF("sio_oss_getfd: %s: '/' expected\n", str);
+			return -1;
+		}
+		p = _sndio_parsenum(p, &devnum, 255);
+		if (p == NULL || *p != '\0') {
+			DPRINTF("sio_oss_getfd: %s: number expected after '/'\n", str);
+			return -1;
+		}
+		snprintf(path, sizeof(path), DEVPATH_PREFIX "%u", devnum);
+	}
+	snprintf(path, sizeof(path), DEVPATH_PREFIX "%u", devnum);
+	if (mode == (SIO_PLAY | SIO_REC))
+		flags = O_RDWR;
+	else

+	return fd;
+}
+
+static struct sio_hdl *
+sio_oss_fdopen(const char *str, int fd, unsigned int mode, int nbio)
+{
+	struct sio_oss_hdl *hdl;
+

+	_sio_create(&hdl->sio, &sio_oss_ops, mode, nbio);
+
+	/* Set default device parameters */
+	hdl->fmt = AFMT_S16_LE;
+	hdl->rate = 48000;
+	hdl->chan = 2;
+	hdl->round = 960;
+	hdl->appbufsz = 8 * 960;
+
+	hdl->fd = fd;
+
+	return (struct sio_hdl *)hdl;
+}
+
+struct sio_hdl *

+	if (fd < 0)
+		return NULL;
+
+	hdl = (struct sio_oss_hdl *)sio_oss_fdopen(str, fd, mode, nbio);
+	if (hdl != NULL)
+		hdl->devstr = strdup(str);
+		return (struct sio_hdl*)hdl;
+
+	while (close(fd) < 0 && errno == EINTR)
+		; /* retry */
+

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

+sio_oss_start(struct sio_hdl *sh)
+{
+	struct sio_oss_hdl *hdl = (struct sio_oss_hdl *)sh;
+	int low;
+
+	hdl->obpf = hdl->sio.par.pchan * hdl->sio.par.bps;
+	hdl->ibpf = hdl->sio.par.rchan * hdl->sio.par.bps;
+	hdl->isamples = 0;
+	hdl->osamples = 0;
+	hdl->idelta = 0;
+	hdl->odelta = 0;
+
+	/* Nothing else to do here.  OSS starts playing/recording
+	 * on first write/read.
+	 * write/read.
+	 */
+	_sio_onmove_cb(&hdl->sio, 0);
+

+sio_oss_stop(struct sio_hdl *sh)
+{
+	struct sio_oss_hdl *hdl = (struct sio_oss_hdl*)sh;
+
+        if (ioctl(hdl->fd, SNDCTL_DSP_SYNC, NULL) < 0) {
+            DPERROR("sio_oss_stop: SYNC");
+            hdl->sio.eof = 1;
+            return 0;
+        }
+        if (ioctl(hdl->fd, SNDCTL_DSP_HALT, NULL) < 0) {
+            DPERROR("sio_oss_stop: HALT");
+            hdl->sio.eof = 1;
+            return 0;
+        }
+
+        /* Reset device parameters.  When we do not do this, resuming
+         * playback/recording will trigger poll with revents=POLLIN
+         * too often, which leads to sndiod using 100 % CPU.
+         */
+        return sio_oss_setpar(sh, &hdl->sio.par);
+}
+
+static int
+sio_oss_setpar(struct sio_hdl *sh, struct sio_par *par)
+{
+	struct sio_oss_hdl *hdl = (struct sio_oss_hdl *)sh;
+	unsigned int i;
+	int policy;
+
+	hdl->fmt = AFMT_S16_LE;
+	for (i = 0; i < sizeof(formats)/sizeof(formats[0]); i++) {
+		if (formats[i].bits == par->bits
+		    && formats[i].le == par->le
+		    && formats[i].sig == par->sig
+		    && formats[i].msb == par->msb) {
+			hdl->fmt = formats[i].fmt;
+			break;
+		}
+	}
+
+	if (par->rate != ~0U)
+		hdl->rate = par->rate;
+	if (hdl->rate < 8000)
+		hdl->rate = 8000;
+	if (hdl->rate > 192000)
+		hdl->rate = 192000;
+
+	if (hdl->sio.mode & SIO_PLAY)
+		hdl->chan = par->pchan;
+	else if (hdl->sio.mode & SIO_REC)
+		hdl->chan = par->rchan;
+
+	if (par->round != ~0U && par->appbufsz != ~0U) {
+		hdl->round = par->round;
+		hdl->appbufsz = par->appbufsz;
+	} else if (par->round != ~0U) {
+		hdl->round = par->round;
+		hdl->appbufsz = 2 * par->round;
+	} else if (par->appbufsz != ~0U) {
+		hdl->round = par->appbufsz / 2;
+		hdl->appbufsz = par->appbufsz;
+	}
+
+	/* Set timing policy to 5 which is OSS' default.  The
+	 * user-settable hw.snd.latency sysctl influences the default
+	 * policy.
+	 */
+	policy = 5;
+	if (ioctl(hdl->fd, SNDCTL_DSP_POLICY, &policy) < 0) {
+		DPERROR("sio_oss_setpar: POLICY");
+		hdl->sio.eof = 1;
+		return 0;
+	}
+
+	if (ioctl(hdl->fd, SNDCTL_DSP_SETFMT, &hdl->fmt) < 0) {
+		DPERROR("sio_oss_setpar: SETFMT");
+		hdl->sio.eof = 1;
+		return 0;
+	}
+
+	if (ioctl(hdl->fd, SNDCTL_DSP_SPEED, &hdl->rate) < 0) {
+		DPERROR("sio_oss_setpar: SPEED");
+		hdl->sio.eof = 1;
+		return 0;
+	}
+
+	if (ioctl(hdl->fd, SNDCTL_DSP_CHANNELS, &hdl->chan) < 0) {
+		DPERROR("sio_oss_setpar: CHANNELS");
+		hdl->sio.eof = 1;
+		return 0;
+	}
+
+	return 1;
+}
+

+sio_oss_getpar(struct sio_hdl *sh, struct sio_par *par)
+{
+	struct sio_oss_hdl *hdl = (struct sio_oss_hdl *)sh;
+	unsigned int i, found = 0;
+
+	for (i = 0; i < sizeof(formats)/sizeof(formats[0]); i++) {
+		if (formats[i].fmt == hdl->fmt) {
+			par->sig = formats[i].sig;
+			par->le = formats[i].le;
+			par->bits = formats[i].bits;
+			par->bps = formats[i].bps;
+			par->msb = formats[i].msb;
+			found = 1;
+			break;
+		}
+	}
+	if (!found) {
+		DPRINTF("sio_oss_getpar: unknown format %d\n", hdl->fmt);
+		hdl->sio.eof = 1;
+		return 0;
+	}
+
+	par->rate = hdl->rate;
+	par->pchan = hdl->chan;
+	par->rchan = hdl->chan;
+	par->round = hdl->round;
+	par->appbufsz = par->bufsz = hdl->appbufsz;
+	par->pchan = ap.pchan;
+	par->rchan = ap.rchan;
+	par->round = ap.round;
+	par->appbufsz = par->bufsz = ap.round * ap.nblks;
+	par->xrun = SIO_IGNORE;
+
+	return 1;
+}
+

+	return 1;
+}
+
+static int
+sio_oss_xrun(struct sio_oss_hdl *hdl)
+{
+	int clk;
+	int wsil, rdrop, cmove;
+	int rbpf, rround;
+	int wbpf;
+
+	DPRINTFN(2, "sio_oss_xrun:\n");
+	if (_sndio_debug >= 2)
+		_sio_printpos(&hdl->sio);
+
+	/*
+	 * we assume rused/wused are zero if rec/play modes are not
+	 * selected. This allows us to keep the same formula for all
+	 * modes, provided we set rbpf/wbpf to 1 to avoid division by
+	 * zero.
+	 *
+	 * to understand the formula, draw a picture :)
+	 */
+	rbpf = (hdl->sio.mode & SIO_REC) ?
+	    hdl->sio.par.bps * hdl->sio.par.rchan : 1;
+	wbpf = (hdl->sio.mode & SIO_PLAY) ?
+	    hdl->sio.par.bps * hdl->sio.par.pchan : 1;
+	rround = hdl->sio.par.round * rbpf;
+
+	clk = hdl->sio.cpos % hdl->sio.par.round;
+	rdrop = (clk * rbpf - hdl->sio.rused) % rround;
+	if (rdrop < 0)
+		rdrop += rround;
+	cmove = (rdrop + hdl->sio.rused) / rbpf;
+	wsil = cmove * wbpf + hdl->sio.wused;
+
+	DPRINTFN(2, "wsil = %d, cmove = %d, rdrop = %d\n", wsil, cmove, rdrop);
+
+	if (!sio_oss_stop(&hdl->sio))
+		return 0;
+	if (!sio_oss_start(&hdl->sio))
+		return 0;
+	if (hdl->sio.mode & SIO_PLAY) {
+		hdl->odelta -= cmove;
+		hdl->sio.wsil = wsil;
+	}
+	if (hdl->sio.mode & SIO_REC) {
+		hdl->idelta -= cmove;
+		hdl->sio.rdrop = rdrop;
+	}
+	DPRINTFN(2, "xrun: corrected\n");
+	DPRINTFN(2, "wsil = %d, rdrop = %d, odelta = %d, idelta = %d\n",
+	    wsil, rdrop, hdl->odelta, hdl->idelta);
+	return 1;
+}
+
+static int
+sio_oss_revents(struct sio_hdl *sh, struct pollfd *pfd)
+{
+	struct sio_oss_hdl *hdl = (struct sio_oss_hdl *)sh;
+	audio_errinfo ei;
+	int delta;
+	int revents = pfd->revents;
+	long long play_pos, rec_pos;

+	    (pfd->revents & (POLLIN | POLLOUT)) == 0)
+		return pfd->revents;
+
+	/* Hide xruns from clients */
+	if (ioctl(hdl->fd, SNDCTL_DSP_GETERROR, &ei) < 0) {
+		DPERROR("sio_oss_revents: GETERROR");
+		hdl->sio.eof = 1;
+		return POLLHUP;
+	}
+	if (ei.play_underruns > 0 || ei.rec_overruns > 0) {
+		if (!sio_oss_xrun(hdl))
+			return POLLHUP;
+		return 0;
+	}
+
+	if (hdl->sio.mode & SIO_PLAY) {
+		if (ioctl(hdl->fd, SNDCTL_DSP_CURRENT_OPTR, &optr) < 0) {
+			DPERROR("sio_oss_revents: CURRENT_OPTR");
+			hdl->sio.eof = 1;
+			return POLLHUP;
+		}

+	}
+	if (hdl->sio.mode & SIO_REC) {
+		if (ioctl(hdl->fd, SNDCTL_DSP_CURRENT_IPTR, &iptr) < 0) {
+			DPERROR("sio_oss_revents: CURRENT_IPTR");
+			hdl->sio.eof = 1;
+			return POLLHUP;
+		}

+	return revents;
+}
+
+static void
+sio_oss_fmt_to_swpar(int fmt, struct audio_swpar *ap) {
+	switch(fmt) {
+	case AFMT_S8:
+		ap->le = 1;
+		ap->sig = 1;
+		ap->bits = 8;
+		break;
+	case AFMT_U8:
+		ap->le = 1;
+		ap->sig = 0;
+		ap->bits = 8;
+		break;
+	case AFMT_S16_LE:
+		ap->le = 1;
+		ap->sig = 1;
+		ap->bits = 16;
+		break;
+	case AFMT_S16_BE:
+		ap->le = 0;
+		ap->sig = 1;
+		ap->bits = 16;
+		break;
+	case AFMT_U16_LE:
+		ap->le = 1;
+		ap->sig = 0;
+		ap->bits = 16;
+		break;
+	case AFMT_U16_BE:
+		ap->le = 0;
+		ap->sig = 0;
+		ap->bits = 16;
+		break;
+	case AFMT_S24_LE:
+		ap->le = 1;
+		ap->sig = 1;
+		ap->bits = 24;
+		break;
+	case AFMT_S24_BE:
+		ap->le = 0;
+		ap->sig = 1;
+		ap->bits = 24;
+		break;
+	case AFMT_U24_LE:
+		ap->le = 1;
+		ap->sig = 0;
+		ap->bits = 24;
+		break;
+	case AFMT_U24_BE:
+		ap->le = 0;
+		ap->sig = 0;
+		ap->bits = 24;
+		break;
+	case AFMT_S32_LE:
+		ap->le = 1;
+		ap->sig = 1;
+		ap->bits = 32;
+		break;
+	case AFMT_S32_BE:
+		ap->le = 0;
+		ap->sig = 1;
+		ap->bits = 32;
+		break;
+	case AFMT_U32_LE:
+		ap->le = 1;
+		ap->sig = 0;
+		ap->bits = 32;
+		break;
+	case AFMT_U32_BE:
+		ap->le = 0;
+		ap->sig = 0;
+		ap->bits = 32;
+		break;
+	}
+}
+
+static int
+sio_oss_swpar_to_fmt(struct audio_swpar *ap)
+{
+	unsigned int bits = ap->bits;
+	unsigned int sig = ap->sig;
+	unsigned int le = ap->le;
+
+	switch(bits) {
+	case 8:
+		if (sig)
+			return AFMT_S8;
+		else
+			return AFMT_U8;
+		break;
+	case 16:
+		if (sig)
+			if (le)
+				return AFMT_S16_LE;
+			else
+				return AFMT_S16_BE;
+		else
+			if (le)
+				return AFMT_U16_LE;
+			else
+				return AFMT_U16_BE;
+		break;
+		break;
+	case 24:
+		if (sig)
+			if (le)
+				return AFMT_S24_LE;
+			else
+				return AFMT_S24_BE;
+		else
+			if (le)
+				return AFMT_U24_LE;
+			else
+				return AFMT_U24_BE;
+		break;
+		break;
+	case 32:
+		if (sig)
+			if (le)
+				return AFMT_S32_LE;
+			else
+				return AFMT_S32_BE;
+		else
+			if (le)
+				return AFMT_U32_LE;
+			else
+				return AFMT_U32_BE;
+		break;
+	default:
+		if (sig)
+			if (SIO_LE_NATIVE)
+				return AFMT_S16_LE;
+			else
+				return AFMT_S16_BE;
+		else
+			if (SIO_LE_NATIVE)
+				return AFMT_U16_LE;
+			else
+				return AFMT_U16_BE;
+	}
+}
+
+static int sio_oss_audio_getpar(struct sio_oss_hdl *hdl, struct audio_swpar *ap)
+{
+	audio_buf_info bi;
+
+	*ap = hdl->swpar;
+
+	return 0;
+}
+
+static int sio_oss_audio_setpar(struct sio_oss_hdl *hdl, struct audio_swpar *ap)
+{
+	audio_buf_info bi;
+	int bufsz;
+	int chan;
+	int fmt;
+	int rate;
+
+	if (sio_oss_reopen(hdl) < 0) {
+		DPERROR("sio_oss_audio_setpar: reopen");
+		return -1;
+	}
+
+	ap->msb = ap->msb == -1 ? 0 : ap->msb;
+	ap->sig = ap->sig == -1 ? 1 : ap->sig;
+	ap->bits = ap->bits == -1 ? ap->bps == -1 ? 16 : ap->bps*8 : ap->bits;
+	ap->le = ap->le == -1 ? SIO_LE_NATIVE : ap->le;
+	ap->bps = ap->bps == -1 ? SIO_BPS(ap->bits) : ap->bps;
+	ap->msb = 0;
+	ap->rate = ap->rate == -1 ? 48000 : ap->rate;
+
+	if (ap->bits < 8)
+		ap->bits = 8;
+	if (ap->bits > 32)
+		ap->bits = 32;
+	if (ap->bps < 1)
+		ap->bps = 1;
+	if (ap->bps > 4)
+		ap->bps = 4;
+	if (ap->rate < 4000)
+		ap->rate = 4000;
+	if (ap->rate > 192000)
+		ap->rate = 192000;
+
+	fmt = sio_oss_swpar_to_fmt(ap);
+	if (fmt < 0)
+		return -1;
+	if (ioctl(hdl->fd, SNDCTL_DSP_SETFMT, &fmt) < 0) {
+		DPERROR("sio_oss_audio_setpar: SETFMT");
+		return -1;
+	}
+	sio_oss_fmt_to_swpar(fmt, ap);
+
+	if (ioctl(hdl->fd, SNDCTL_DSP_SPEED, &ap->rate) < 0) {
+		DPERROR("sio_oss_audio_setpar: SPEED");
+		return -1;
+	}
+
+	chan = ap->pchan == ~0U ? ap->pchan : ap->rchan;
+	chan = chan == -1 ? 2 : chan;
+	if (ioctl(hdl->fd, SNDCTL_DSP_CHANNELS, &chan) < 0) {
+		DPERROR("sio_oss_audio_setpar: CHANNELS");
+		return -1;
+	}
+	ap->pchan = ap->rchan = chan;
+
+	ap->nblks = ap->nblks <= 0 ? 8 : ap->nblks;
+	ap->round = ap->round <= 0 ? 960 : ap->round;
+
+	hdl->swpar = *ap;
+
+	return 0;
+}
+
+static int sio_oss_reopen(struct sio_oss_hdl *hdl) {
+	/* Reopen device */
+	while (close(hdl->fd) < 0 && errno == EINTR)
+		; /* retry */
+	hdl->fd = sio_oss_getfd(hdl->devstr, hdl->sio.mode, 1);
+	if (hdl->fd < 0) {
+		DPERROR("sio_oss_audio_setpar: reopen");
+		return -1;
+	}
+	return 0;
+}
+
+#endif /* defined USE_OSS */




# $FreeBSD$
#
# PROVIDE: sndiod
# REQUIRE: NETWORKING sysctl
# BEFORE:  DAEMON
# KEYWORD: shutdown

# By default sndiod will use the audio device from
# hw.snd.default_unit.  You can override this by setting sndiod_flags.
#
# To connect to a remote sndiod use e.g.
# sndiod_flags="-f snd@remotehost/0"
#
# To use /dev/dsp5
# sndiod_flags="-f rsnd/5"

. /etc/rc.subr

name=sndiod


load_rc_config $name

: ${sndiod_dev="rsnd/$($SYSCTL -n hw.snd.default_unit)"}
: ${sndiod_enable="NO"}
: ${sndiod_flags="-f ${sndiod_dev} -c 0:7 -j off -s default -m mon -s monitor"}

command="%%PREFIX%%/bin/sndiod"





Sndio's OSS support (i.e. local playback/recording support) is highly
experimental.  If you run into problems please file a bug at
https://github.com/t6/sndio or send an email to t+sndio@tobik.me.

Enable the sndiod server with:

    sysrc sndiod_enable=YES


    aucat -f snd/0.monitor -o recording.wav

Make sure you override sndiod_flags if this is not wanted.

    sysrc sndiod_flags=""

If you want clients to auto-play to your remote sndio server set
sndiod_flags accordingly:

    sysrc sndiod_flags="-f snd@remotehost/0"

Alternatively you can always set the AUDIODEVICE environment variable
so clients know where to stream to:

By default the rc.d script passes '-c 0:7 -j off' to sndiod, so that
it uses all 8 virtual channels provided by OSS.  If you override
sndiod_flags consider keeping these options, so that multi-channel
audio works as you'd expect.

There is little sndio support in the FreeBSD ports tree right now.  If
your favourite port is missing support please take a look at the fork

Return to bug 214210

Lines 1-30 Link Here

(-)b/audio/sndio/files/patch-configure (-8 / +49 lines)
1	--- configure.orig 2015-12-15 05:28:04 UTC	1	--- configure.orig 2015-12-15 05:28:04 UTC
2	+++ configure	2	+++ configure
3	@@ -32,6 +32,7 @@ prefix=/usr/local # where to install s	3	@@ -20,6 +20,8 @@ Usage: configure [options]
		4	--disable-sun disable sun audio backend
		5	--enable-rmidi enable character device midi backend [$rmidi]
		6	--disable-rmidi disable character device midi backend
		7	+--enable-umidi enable character device midi backend [$umidi]
		8	+--disable-umidi disable character device midi backend
		9	--with-libbsd use the libbsd rather than bsd-compat/*
		10	--without-libbsd don't use libbsd
		11	END
		12	@@ -32,7 +34,9 @@ prefix=/usr/local # where to install s
4	so="libsndio.so.\${MAJ}.\${MIN}" # shared libs to build	13	so="libsndio.so.\${MAJ}.\${MIN}" # shared libs to build
5	alsa=no # do we want alsa support ?	14	alsa=no # do we want alsa support ?
6	sun=no # do we want sun support ?	15	sun=no # do we want sun support ?
7	+oss=no # do we want oss support ?	16	+oss=no # do we want oss support ?
8	rmidi=no # do we want support for raw char dev ?	17	rmidi=no # do we want support for raw char dev ?
		18	+umidi=no # do we want support for raw char dev ?
9	precision=16 # aucat/sndiod arithmetic precision	19	precision=16 # aucat/sndiod arithmetic precision
10	user=_sndio # non-privileged user for sndio daemon	20	user=_sndio # non-privileged user for sndio daemon
11	@@ -71,6 +72,15 @@ case `uname` in	21	libbsd=no # use libbsd?
		22	@@ -71,6 +75,15 @@ case `uname` in
12	defs='-DHAVE_ARC4RANDOM -DHAVE_ISSETUGID \\\	23	defs='-DHAVE_ARC4RANDOM -DHAVE_ISSETUGID \\\
13	-DHAVE_STRLCAT -DHAVE_STRLCPY -DHAVE_STRTONUM'	24	-DHAVE_STRLCAT -DHAVE_STRLCPY -DHAVE_STRTONUM'
14	;;	25	;;
15	+ FreeBSD)	26	+ DragonFly\|FreeBSD)
16	+ user=_sndio	27	+ user=_sndio
17	+ so="$so libsndio.so"	28	+ so="$so libsndio.so"
18	+ defs='-DHAVE_ARC4RANDOM -DHAVE_ISSETUGID \\\	29	+ defs='-DHAVE_ARC4RANDOM -DHAVE_ISSETUGID \\\
19	+ -DHAVE_STRLCAT -DHAVE_STRLCPY -DHAVE_STRTONUM \\\	30	+ -DHAVE_STRLCAT -DHAVE_STRLCPY -DHAVE_STRTONUM'
20	+ -DDEFAULT_DEV=\\"fallback\\"'
21	+ oss=yes	31	+ oss=yes
		32	+ umidi=yes
22	+ mandir=${prefix}/man	33	+ mandir=${prefix}/man
23	+ ;;	34	+ ;;
24	esac	35	esac
25		36
26	# shell word separator (none)	37	# shell word separator (none)
27	@@ -106,6 +116,12 @@ for i; do	38	@@ -106,6 +119,12 @@ for i; do
28	--disable-alsa)	39	--disable-alsa)
29	alsa=no	40	alsa=no
30	shift;;	41	shift;;
Lines 37-43 Link Here
37	--enable-sun)	48	--enable-sun)
38	sun=yes	49	sun=yes
39	shift;;	50	shift;;
40	@@ -162,6 +178,13 @@ if [ $alsa = yes ]; then	51	@@ -118,6 +137,12 @@ for i; do
		52	--disable-rmidi)
		53	rmidi=no
		54	shift;;
		55	+ --enable-umidi)
		56	+ umidi=yes
		57	+ shift;;
		58	+ --disable-umidi)
		59	+ umidi=no
		60	+ shift;;
		61	--privsep-user=*)
		62	user="${i#--privsep-user=}"
		63	shift;;
		64	@@ -162,6 +187,13 @@ if [ $alsa = yes ]; then
41	fi	65	fi
42		66
43	#	67	#
Lines 51-61 Link Here
51	# if using Sun API, add corresponding parameters	75	# if using Sun API, add corresponding parameters
52	#	76	#
53	if [ $sun = yes ]; then	77	if [ $sun = yes ]; then
54	@@ -215,6 +238,7 @@ user..................... $user	78	@@ -176,6 +208,13 @@ if [ $rmidi = yes ]; then
		79	fi
		80
		81	#
		82	+# if using raw character devices for midi, add corresponding parameters
		83	+#
		84	+if [ $umidi = yes ]; then
		85	+ defs="$defs -DUSE_UMIDI"
		86	+fi
		87	+
		88	+#
		89	# if using libbsd, add corresponding parameters
		90	#
		91	if [ $libbsd = yes ]; then
		92	@@ -215,8 +254,10 @@ user..................... $user
55	libbsd................... $libbsd	93	libbsd................... $libbsd
56	precision................ $precision	94	precision................ $precision
57	alsa..................... $alsa	95	alsa..................... $alsa
58	+oss...................... $oss	96	+oss...................... $oss
59	sun...................... $sun	97	sun...................... $sun
60	rmidi.................... $rmidi	98	rmidi.................... $rmidi
		99	+umidi.................... $umidi
		100
		101	Do "make && make install" to compile and install sndio
61		102

Lines 1-15 Link Here

(-)b/audio/sndio/files/patch-libsndio_Makefile.in (-3 / +13 lines)
1	--- libsndio/Makefile.in.orig 2015-12-30 11:54:40 UTC	1	--- libsndio/Makefile.in.orig 2015-12-30 11:54:40 UTC
2	+++ libsndio/Makefile.in	2	+++ libsndio/Makefile.in
3	@@ -99,7 +99,7 @@ clean:	3	@@ -98,8 +98,8 @@ clean:
		4	# loader to determine dependencies in a single pass
4	#	5	#
5	OBJS = debug.o aucat.o \	6	OBJS = debug.o aucat.o \
6	mio.o mio_rmidi.o mio_alsa.o mio_aucat.o \	7	-mio.o mio_rmidi.o mio_alsa.o mio_aucat.o \
7	-sio.o sio_alsa.o sio_aucat.o sio_sun.o \	8	-sio.o sio_alsa.o sio_aucat.o sio_sun.o \
		9	+mio.o mio_rmidi.o mio_umidi.o mio_alsa.o mio_aucat.o \
8	+sio.o sio_alsa.o sio_aucat.o sio_oss.o sio_sun.o \	10	+sio.o sio_alsa.o sio_aucat.o sio_oss.o sio_sun.o \
9	issetugid.o strlcat.o strlcpy.o strtonum.o	11	issetugid.o strlcat.o strlcpy.o strtonum.o
10		12
11	.c.o:	13	.c.o:
12	@@ -140,3 +140,5 @@ sio_aucat.o: sio_aucat.c aucat.h amsg.h	14	@@ -132,6 +132,7 @@ mio_alsa.o: mio_alsa.c debug.h mio_priv.
		15	mio_aucat.o: mio_aucat.c aucat.h amsg.h debug.h mio_priv.h sndio.h \
		16	../bsd-compat/bsd-compat.h
		17	mio_rmidi.o: mio_rmidi.c debug.h mio_priv.h sndio.h
		18	+mio_umidi.o: mio_umidi.c debug.h mio_priv.h sndio.h
		19	sio.o: sio.c debug.h sio_priv.h sndio.h \
		20	../bsd-compat/bsd-compat.h
		21	sio_alsa.o: sio_alsa.c debug.h sio_priv.h sndio.h \
		22	@@ -140,3 +141,5 @@ sio_aucat.o: sio_aucat.c aucat.h amsg.h
13	../bsd-compat/bsd-compat.h	23	../bsd-compat/bsd-compat.h
14	sio_sun.o: sio_sun.c debug.h sio_priv.h sndio.h \	24	sio_sun.o: sio_sun.c debug.h sio_priv.h sndio.h \
15	../bsd-compat/bsd-compat.h	25	../bsd-compat/bsd-compat.h

Added Link Here

(-)b/audio/sndio/files/patch-libsndio_mio.c (+20 lines)
1	--- libsndio/mio.c.orig 2015-12-09 10:13:10 UTC
2	+++ libsndio/mio.c
3	@@ -55,6 +55,8 @@ mio_open(const char *str, unsigned int m
4	return hdl;
5	#if defined(USE_RMIDI)
6	return _mio_rmidi_open("rmidi/0", mode, nbio);
7	+#elif defined(USE_UMIDI)
8	+ return _mio_umidi_open("rmidi/0", mode, nbio);
9	#elif defined(USE_ALSA)
10	return _mio_alsa_open("rmidi/0", mode, nbio);
11	#else
12	@@ -68,6 +70,8 @@ mio_open(const char *str, unsigned int m
13	if (_sndio_parsetype(str, "rmidi"))
14	#if defined(USE_RMIDI)
15	return _mio_rmidi_open(str, mode, nbio);
16	+#elif defined(USE_UMIDI)
17	+ return _mio_umidi_open(str, mode, nbio);
18	#elif defined(USE_ALSA)
19	return _mio_alsa_open(str, mode, nbio);
20	#else

Added Link Here

(-)b/audio/sndio/files/patch-libsndio_mio__priv.h (+12 lines)
1	--- libsndio/mio_priv.h.orig 2015-12-09 10:13:10 UTC
2	+++ libsndio/mio_priv.h
3	@@ -44,6 +44,9 @@ struct mio_ops {
4	};
5
6	struct mio_hdl _mio_rmidi_open(const char , unsigned, int);
7	+#ifdef USE_UMIDI
8	+struct mio_hdl _mio_umidi_open(const char , unsigned, int);
9	+#endif
10	#ifdef USE_ALSA
11	struct mio_hdl _mio_alsa_open(const char , unsigned, int);
12	#endif

Added Link Here

(-)b/audio/sndio/files/patch-libsndio_mio__umidi.c (+222 lines)
1	--- libsndio/mio_umidi.c.orig 2016-11-04 12:06:45 UTC
2	+++ libsndio/mio_umidi.c
3	@@ -0,0 +1,219 @@
4	+/* $OpenBSD$ */
5	+/*
6	+ * Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>
7	+ * Copyright (c) 2016 Tobias Kortkamp <t@tobik.me>
8	+ *
9	+ * Permission to use, copy, modify, and distribute this software for any
10	+ * purpose with or without fee is hereby granted, provided that the above
11	+ * copyright notice and this permission notice appear in all copies.
12	+ *
13	+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14	+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15	+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16	+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17	+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18	+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19	+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20	+ */
21	+
22	+#ifdef USE_UMIDI
23	+#include <sys/types.h>
24	+#include <sys/stat.h>
25	+
26	+#include <errno.h>
27	+#include <fcntl.h>
28	+#include <limits.h>
29	+#include <poll.h>
30	+#include <stdio.h>
31	+#include <stdlib.h>
32	+#include <string.h>
33	+#include <unistd.h>
34	+
35	+#include "debug.h"
36	+#include "mio_priv.h"
37	+
38	+#define DEVPATH_PREFIX "/dev/umidi"
39	+#define DEVPATH_MAX (1 + \
40	+ sizeof(DEVPATH_PREFIX) - 1 + \
41	+ sizeof(int) * 3)
42	+
43	+struct mio_umidi_hdl {
44	+ struct mio_hdl mio;
45	+ int fd;
46	+};
47	+
48	+static void mio_umidi_close(struct mio_hdl *);
49	+static size_t mio_umidi_read(struct mio_hdl , void , size_t);
50	+static size_t mio_umidi_write(struct mio_hdl , const void , size_t);
51	+static int mio_umidi_nfds(struct mio_hdl *);
52	+static int mio_umidi_pollfd(struct mio_hdl , struct pollfd , int);
53	+static int mio_umidi_revents(struct mio_hdl , struct pollfd );
54	+
55	+static struct mio_ops mio_umidi_ops = {
56	+ mio_umidi_close,
57	+ mio_umidi_write,
58	+ mio_umidi_read,
59	+ mio_umidi_nfds,
60	+ mio_umidi_pollfd,
61	+ mio_umidi_revents
62	+};
63	+
64	+static int
65	+mio_umidi_getfd(const char *str, unsigned int mode, int nbio)
66	+{
67	+ const char *p;
68	+ char path[DEVPATH_MAX];
69	+ unsigned int devnum;
70	+ unsigned int subdevnum;
71	+ int fd, flags;
72	+
73	+ p = _sndio_parsetype(str, "rmidi");
74	+ if (p == NULL) {
75	+ DPRINTF("mio_umidi_getfd: %s: \"rsnd\" expected\n", str);
76	+ return -1;
77	+ }
78	+ switch (*p) {
79	+ case '/':
80	+ p++;
81	+ break;
82	+ default:
83	+ DPRINTF("mio_umidi_getfd: %s: '/' expected\n", str);
84	+ return -1;
85	+ }
86	+ p = _sndio_parsenum(p, &devnum, 255);
87	+ if (p == NULL) {
88	+ DPRINTF("mio_umidi_getfd: %s: number expected after '/'\n", str);
89	+ return -1;
90	+ }
91	+ switch (*p) {
92	+ case '.':
93	+ p++;
94	+ p = _sndio_parsenum(p, &subdevnum, 255);
95	+ if (p == NULL \|\| *p != '\0') {
96	+ DPRINTF("mio_umidi_getfd: %s: number expected after '.'\n",
97	+ str);
98	+ return -1;
99	+ }
100	+ break;
101	+ default:
102	+ subdevnum = 0;
103	+ }
104	+ snprintf(path, sizeof(path), DEVPATH_PREFIX "%u.%u", devnum, subdevnum);
105	+ if (mode == (MIO_IN \| MIO_OUT))
106	+ flags = O_RDWR;
107	+ else
108	+ flags = (mode & MIO_OUT) ? O_WRONLY : O_RDONLY;
109	+ while ((fd = open(path, flags \| O_NONBLOCK \| O_CLOEXEC)) < 0) {
110	+ if (errno == EINTR)
111	+ continue;
112	+ DPERROR(path);
113	+ return -1;
114	+ }
115	+ return fd;
116	+}
117	+
118	+static struct mio_hdl *
119	+mio_umidi_fdopen(int fd, unsigned int mode, int nbio)
120	+{
121	+ struct mio_umidi_hdl *hdl;
122	+
123	+ hdl = malloc(sizeof(struct mio_umidi_hdl));
124	+ if (hdl == NULL)
125	+ return NULL;
126	+ _mio_create(&hdl->mio, &mio_umidi_ops, mode, nbio);
127	+ hdl->fd = fd;
128	+ return (struct mio_hdl *)hdl;
129	+}
130	+
131	+struct mio_hdl *
132	+_mio_umidi_open(const char *str, unsigned int mode, int nbio)
133	+{
134	+ struct mio_hdl *hdl;
135	+ int fd;
136	+
137	+ fd = mio_umidi_getfd(str, mode, nbio);
138	+ if (fd < 0)
139	+ return NULL;
140	+ hdl = mio_umidi_fdopen(fd, mode, nbio);
141	+ if (hdl != NULL)
142	+ return hdl;
143	+ while (close(fd) < 0 && errno == EINTR)
144	+ ; /* retry */
145	+ return NULL;
146	+}
147	+
148	+static void
149	+mio_umidi_close(struct mio_hdl *sh)
150	+{
151	+ struct mio_umidi_hdl hdl = (struct mio_umidi_hdl )sh;
152	+ int rc;
153	+
154	+ do {
155	+ rc = close(hdl->fd);
156	+ } while (rc < 0 && errno == EINTR);
157	+ free(hdl);
158	+}
159	+
160	+static size_t
161	+mio_umidi_read(struct mio_hdl sh, void buf, size_t len)
162	+{
163	+ struct mio_umidi_hdl hdl = (struct mio_umidi_hdl )sh;
164	+ ssize_t n;
165	+
166	+ while ((n = read(hdl->fd, buf, len)) < 0) {
167	+ if (errno == EINTR)
168	+ continue;
169	+ if (errno != EAGAIN) {
170	+ DPERROR("mio_umidi_read: read");
171	+ hdl->mio.eof = 1;
172	+ }
173	+ return 0;
174	+ }
175	+ if (n == 0) {
176	+ DPRINTF("mio_umidi_read: eof\n");
177	+ hdl->mio.eof = 1;
178	+ return 0;
179	+ }
180	+ return n;
181	+}
182	+
183	+static size_t
184	+mio_umidi_write(struct mio_hdl sh, const void buf, size_t len)
185	+{
186	+ struct mio_umidi_hdl hdl = (struct mio_umidi_hdl )sh;
187	+ ssize_t n;
188	+
189	+ while ((n = write(hdl->fd, buf, len)) < 0) {
190	+ if (errno == EINTR)
191	+ continue;
192	+ if (errno != EAGAIN) {
193	+ DPERROR("mio_umidi_write: write");
194	+ hdl->mio.eof = 1;
195	+ }
196	+ return 0;
197	+ }
198	+ return n;
199	+}
200	+
201	+static int
202	+mio_umidi_nfds(struct mio_hdl *sh)
203	+{
204	+ return 1;
205	+}
206	+
207	+static int
208	+mio_umidi_pollfd(struct mio_hdl sh, struct pollfd pfd, int events)
209	+{
210	+ struct mio_umidi_hdl hdl = (struct mio_umidi_hdl )sh;
211	+
212	+ pfd->fd = hdl->fd;
213	+ pfd->events = events;
214	+ return 1;
215	+}
216	+
217	+static int
218	+mio_umidi_revents(struct mio_hdl sh, struct pollfd pfd)
219	+{
220	+ return pfd->revents;
221	+}
222	+#endif /* defined USE_UMIDI */

Lines 1-23 Link Here

(-)b/audio/sndio/files/patch-libsndio_sio.c (-11 / +3 lines)
1	--- libsndio/sio.c.orig 2016-01-08 20:51:12 UTC	1	--- libsndio/sio.c.orig 2016-01-08 20:51:12 UTC
2	+++ libsndio/sio.c	2	+++ libsndio/sio.c
3	@@ -64,17 +64,25 @@ sio_open(const char *str, unsigned int m	3	@@ -64,6 +64,8 @@ sio_open(const char *str, unsigned int m
4	return hdl;	4	return hdl;
5	#if defined(USE_SUN)	5	#if defined(USE_SUN)
6	return _sio_sun_open("rsnd/0", mode, nbio);	6	return _sio_sun_open("rsnd/0", mode, nbio);
7	+#elif defined(USE_OSS)	7	+#elif defined(USE_OSS)
8	+ return _sio_oss_open("fallback", mode, nbio);	8	+ return _sio_oss_open("rsnd/0", mode, nbio);
9	#elif defined(USE_ALSA)	9	#elif defined(USE_ALSA)
10	return _sio_alsa_open("rsnd/0", mode, nbio);	10	return _sio_alsa_open("rsnd/0", mode, nbio);
11	#else	11	#else
12	return NULL;	12	@@ -75,6 +77,8 @@ sio_open(const char *str, unsigned int m
13	#endif
14	}
15	+#if defined(USE_OSS)
16	+ if (strcmp(str, "fallback") == 0)
17	+ return _sio_oss_open(str, mode, nbio);
18	+#endif
19	if (_sndio_parsetype(str, "snd"))
20	return _sio_aucat_open(str, mode, nbio);
21	if (_sndio_parsetype(str, "rsnd"))	13	if (_sndio_parsetype(str, "rsnd"))
22	#if defined(USE_SUN)	14	#if defined(USE_SUN)
23	return _sio_sun_open(str, mode, nbio);	15	return _sio_sun_open(str, mode, nbio);

Lines 3-21 Link Here

(-)b/audio/sndio/files/sndiod.in (-11 / +3 lines)
3	# $FreeBSD$	3	# $FreeBSD$
4	#	4	#
5	# PROVIDE: sndiod	5	# PROVIDE: sndiod
6	# REQUIRE: NETWORKING	6	# REQUIRE: NETWORKING sysctl
7	# BEFORE: DAEMON	7	# BEFORE: DAEMON
8	# KEYWORD: shutdown	8	# KEYWORD: shutdown
9		9
10	# By default sndiod will use the audio device from
11	# hw.snd.default_unit. You can override this by setting sndiod_flags.
12	#
13	# To connect to a remote sndiod use e.g.
14	# sndiod_flags="-f snd@remotehost/0"
15	#
16	# To use /dev/dsp5
17	# sndiod_flags="-f rsnd/5"
18
19	. /etc/rc.subr	10	. /etc/rc.subr
20		11
21	name=sndiod	12	name=sndiod
Lines 23-30 rcvar=sndiod_enable Link Here
23		14
24	load_rc_config $name	15	load_rc_config $name
25		16
		17	: ${sndiod_dev="rsnd/$($SYSCTL -n hw.snd.default_unit)"}
26	: ${sndiod_enable="NO"}	18	: ${sndiod_enable="NO"}
27	: ${sndiod_flags="-s default -m mon -s monitor"}	19	: ${sndiod_flags="-f ${sndiod_dev} -c 0:7 -j off -s default -m mon -s monitor"}
28		20
29	command="%%PREFIX%%/bin/sndiod"	21	command="%%PREFIX%%/bin/sndiod"
30		22

Lines 1-7 Link Here

(-)b/audio/sndio/pkg-message (-16 / +5 lines)
1	Sndio's OSS support (i.e. local playback/recording support) is highly
2	experimental. If you run into problems please file a bug at
3	https://github.com/t6/sndio or send an email to t+sndio@tobik.me.
4
5	Enable the sndiod server with:	1	Enable the sndiod server with:
6		2
7	sysrc sndiod_enable=YES	3	sysrc sndiod_enable=YES
Lines 13-31 plays through sndiod: Link Here
13		9
14	aucat -f snd/0.monitor -o recording.wav	10	aucat -f snd/0.monitor -o recording.wav
15		11
16	Make sure you override sndiod_flags if this is not wanted:	12	Make sure you override sndiod_flags if this is not wanted.
17
18	sysrc sndiod_flags=""
19
20	If you want clients to auto-play to your remote sndio server set
21	sndiod_flags accordingly:
22
23	sysrc sndiod_flags="-f snd@remotehost/0"
24
25	Alternatively you can always set the AUDIODEVICE environment variable
26	so clients know where to stream to:
27		13
28	export AUDIODEVICE=snd@remotehost/0	14	By default the rc.d script passes '-c 0:7 -j off' to sndiod, so that
		15	it uses all 8 virtual channels provided by OSS. If you override
		16	sndiod_flags consider keeping these options, so that multi-channel
		17	audio works as you'd expect.
29		18
30	There is little sndio support in the FreeBSD ports tree right now. If	19	There is little sndio support in the FreeBSD ports tree right now. If
31	your favourite port is missing support please take a look at the fork	20	your favourite port is missing support please take a look at the fork